Representation of a block geometry. More...

#include <blockGeometry.h>

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

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

Public Member Functions
	BlockGeometry (Cuboid< T, D > &cuboid, int padding, int iCglob=-1)

Platform	getPlatform () const

const BlockGeometryStatistics< T, D > &	getStatistics () const
	Read only access to the associated block statistic.

BlockGeometryStatistics< T, D > &	getStatistics ()
	Write access to the associated block statistic.

bool	hasCommunicatable (std::type_index field) const

auto &	getCommunicatable (std::type_index field)

int	getIcGlob () const
	Read only access to the global iC number which is given !=-1 if the block geometries are part of a super geometry.

Vector< int, D >	getExtent () const
	Returns the extend of the block in lattice units.

Vector< T, D >	getOrigin () const
	Read only access to the origin position given in SI units (meter)

T	getDeltaR () const
	Read only access to the voxel size given in SI units (meter)

template<typename... L>
std::enable_if_t< sizeof...(L)==D, int >	get (L... latticeR) const
	Read-only access to a material number.

int	get (LatticeR< D > latticeR) const

int	get (const int latticeR[D]) const

int	get (std::size_t iCell) const

int	getMaterial (LatticeR< D > latticeR) const
	returns the (iX,iY) entry in the 2D scalar field

int	getMaterial (const int latticeR[D]) const

template<typename... L>
std::enable_if_t< sizeof...(L)==D, int >	getMaterial (L... latticeR) const

void	set (LatticeR< D > latticeR, int material)
	Write access to a material number.

void	set (const int latticeR[D], int material)

void	set (std::size_t iCell, int material)

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

void	getPhysR (Vector< T, D > &physR, LatticeR< D > latticeR) const
	Transforms lattice to physical coordinates (wrapped from cuboid geometry)

Cuboid< T, D > &	getCuboid ()

const Cuboid< T, D > &	getCuboid () const

template<typename... L>
std::enable_if_t< sizeof...(L)==D, void >	get (T physR[D], L... latticeR) const

template<typename DESCRIPTOR = std::conditional_t<D==2,descriptors::D2Q9<>,descriptors::D3Q27<>>>
int	clean (bool verbose=true, std::vector< int > bulkMaterials={1})
	Changes all cell materials which are not in bulkMaterials to 0 if there is no neighbour from bulkMaterials.

int	outerClean (bool verbose=true, std::vector< int > bulkMaterials={1})
	Changes all cell materials from bulkMaterials to 0 if there is a neighbour with material 0.

int	innerClean (bool verbose=true)
	Changes all cell materials which are not 0 or 1 to 1 if there is a non robust constiallation.

int	innerClean (int fromM, bool verbose=true)
	Changes all cells with material fromM to 1 if there is a non robust constiallation.

void	reset (IndicatorF< T, D > &domain)
	Resets all cell materials inside of a domain to 0.

bool	find (int material, std::vector< unsigned > offset, std::vector< int > var)
	Returns the coordinates (iX,iY) of a voxel with a given material number (material) if there exists an neighbourhood of size (offsetX,offsetY) only with voxels of the given material number.

bool	check (int material, std::vector< int > var, std::vector< unsigned > offset)
	Returns true if at position (iX,iY) and in a neighbourhood of size (offsetX,offsetY) only voxels with a given material number (material) are there.

bool	checkForErrors (bool verbose=true) const
	Checks for errors (searches for all outer voxels (=0) with an inner voxel (=1) as a direct neighbour)

void	rename (int fromM, int toM)
	Replaces all material numbers (fromM) to another (toM)

void	rename (int fromM, int toM, IndicatorF< T, D > &condition)
	Replaces all material numbers (fromM) to another (toM) if an indicator functor condition is fulfilled.

void	rename (int fromM, int toM, LatticeR< D > offset)
	Replaces all material numbers (fromM) to another (toM) if all materials in the neighbourhood (iX-offsetX,..,iX,..,ix+offsetX), .. are of the original material number (fromM)

void	rename (int fromM, int toM, int testM, std::vector< int > testDirection)
	Replaces all material numbers (fromM) to another (toM) if all materials in the neighbourhood (iX+1,iX+2,..,ix+testDirection[0]), .. are of another material number (testM)

void	rename (int fromM, int toM, int fluidM, IndicatorF< T, D > &condition, Vector< int, D > discreteNormal)
	Replaces all material numbers (fromM) to another (toM) if all materials in the neighbourhood (iX+discreteNormal[0],iX+2*discreteNormal[0]), .. are of another material number (testM) and if an indicator functor condition is fulfilled.

void	rename (int fromM, int toM, int fluidM, IndicatorF< T, D > &condition)
	Replaces all material numbers (fromM) to another (toM) if all materials in the neighbourhood (iX+discreteNormal[0],iX+2*discreteNormal[0]), .. are of another material number (fluidM) and if an indicator functor condition is fulfilled, the discreteNormal is computed from all fromM which fulfill the indicator functor condition.

void	copyMaterialLayer (IndicatorF3D< T > &condition, int discreteNormal[D], int numberOfLayers)
	Copy a layer of material numbers inside an indicator in a discrete normal direction.

void	regionGrowing (int fromM, int toM, LatticeR< D > seed, std::vector< int > offset, std::map< std::vector< int >, int > *tmp=nullptr)
	Replaces all material numbers (fromM) to another (toM) using a seed point and max. directions indicated by offsetX,Y != 0.

void	printLayer (std::vector< int > min, std::vector< int > max, bool linenumber=false)
	Prints a chosen part of the block geometry.

void	printLayer (int direction, int layer, bool linenumber=false)
	Prints a chosen part of the block geometry.

void	printNode (std::vector< int > loc, int offset=1)
	Prints a chosen node and its neighbourhood.

std::size_t	getNblock () const override
	Number of data blocks for the serializable interface.

std::size_t	getSerializableSize () const override
	Binary size for the serializer.

bool *	getBlock (std::size_t iBlock, std::size_t &sizeBlock, bool loadingMode) override
	Return a pointer to the memory of the current block and its size for the serializable interface.

Public Member Functions inherited from olb::BlockStructureD< D >
	BlockStructureD (Vector< int, D > size, int padding=0)

	BlockStructureD ()

void	resize (Vector< int, D > size)

auto	getCore () const

int	getNx () const
	Read only access to block width.

int	getNy () const
	Read only access to block height.

int	getNz () const
	Read only access to block height.

LatticeR< D >	getExtent () const

int	getPadding () const
	Read only access to padding.

std::size_t	getNcells () const
	Get number of cells.

CellID	getCellId (LatticeR< D > latticeR) const
	Get 1D cell ID.

template<typename... L>
std::enable_if_t< sizeof...(L)==D, CellID >	getCellId (L... latticeR) const

LatticeR< D >	getLatticeR (CellID iCell) const

CellDistance	getNeighborDistance (LatticeR< D > dir) const
	Get 1D neighbor distance.

bool	isInside (LatticeR< D > latticeR) const
	Return whether location is valid.

bool	isInsideCore (LatticeR< D > latticeR) const
	Return whether location is inside core.

bool	isPadding (LatticeR< D > latticeR) const
	Return whether location is valid.

bool	isPadding (LatticeR< D > latticeR, int overlap) const

bool	isPadding (CellID iCell) const

template<typename... L>
std::enable_if_t< sizeof...(L)==D, bool >	isInside (L... latticeR) const

CellDistance	getNeighborhoodRadius (LatticeR< D > latticeR) const
	Return maximum valid neighborhood sphere radius w.r.t. latticeR.

template<typename F >
void	forSpatialLocations (F f) const

template<typename F >
void	forSpatialLocationsParallel (F f) const

template<typename F >
void	forSpatialLocations (LatticeR< D > min, LatticeR< D > max, F f) const

template<typename F >
void	forCoreSpatialLocations (F f) const

template<typename F >
void	forCellIndices (F f) const

Public Member Functions inherited from olb::Serializable
virtual	~Serializable ()=default

template<bool includeLogOutputDir = true>
bool	save (std::string fileName="", const bool enforceUint=false)
	Save `Serializable` into file `fileName`

template<bool includeLogOutputDir = true>
bool	load (std::string fileName="", const bool enforceUint=false)
	Load `Serializable` from file `fileName`

bool	save (std::uint8_t *buffer)
	Save `Serializable` into buffer of length `getSerializableSize`

bool	load (const std::uint8_t *buffer)
	Load `Serializable` from buffer of length `getSerializableSize`

virtual void	postLoad ()

Static Public Attributes
static constexpr Platform	platform = Platform::CPU_SISD

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

template<typename DataType >
void	registerSerializableOfConstSize (const std::size_t iBlock, std::size_t &sizeBlock, std::size_t &currentBlock, bool *&dataPtr, DataType &data, const bool loadingMode=false)
	Register `Serializable` object of constant size.

template<typename DataType >
void	registerSerializablesOfConstSize (const std::size_t iBlock, std::size_t &sizeBlock, std::size_t &currentBlock, bool &dataPtr, DataType data, const size_t arrayLength, const bool loadingMode=false)
	Register an array of `Serializable` objects of constant size.

Protected Attributes inherited from olb::BlockStructureD< D >
LatticeR< D >	_core

LatticeR< D >	_size

LatticeR< D >	_projection

int	_padding

Detailed Description

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

Representation of a block geometry.

Representation of a statistic for a 3D geometry.

Representation of a statistic for a 2D geometry.

This class is derived from block geometry structure. It holds the actual data with the materials. It stores pointers to all dependent block geometry views. It presents a volume of voxels where different types are given my material numbers which is important e.g. to work with different boundaries (like for inflow/output regions).

A block geomety statistic computes different integral values, like total number of different materials, materials of any kind, min./max. physical position, of an underlying block geoemtry structure.

This class is not intended to be derived from.

Definition at line 50 of file blockGeometryStatistics3D.h.

Constructor & Destructor Documentation

◆ BlockGeometry()

template<typename T , unsigned D>

olb::BlockGeometry< T, D >::BlockGeometry	(	Cuboid< T, D > &	cuboid,
		int	padding,
		int	iCglob = -1 )

Definition at line 44 of file blockGeometry.hh.

  : BlockStructureD<D>(cuboid.getExtent(), padding),
    _data(this->getNcells()),
    _communicatable(_data),
    _cuboid(cuboid),
    _iCglob(iCglob),
    _statistics(this),
    clout(std::cout, ("BlockGeometry" + std::to_string(D) + "D"))
{
  _statistics.update(false);
}

Member Function Documentation

◆ check()

template<typename T , unsigned D>

bool olb::BlockGeometry< T, D >::check	(	int	material,
		std::vector< int >	var,
		std::vector< unsigned >	offset )

Returns true if at position (iX,iY) and in a neighbourhood of size (offsetX,offsetY) only voxels with a given material number (material) are there.

Definition at line 346 of file blockGeometry.hh.

{
  bool found = true;
  for (int iOffsetX = -offset[0]; iOffsetX <= (int) offset[0]; ++iOffsetX) {
    for (int iOffsetY = -offset[1]; iOffsetY <= (int) offset[1]; ++iOffsetY) {
      if constexpr (D==3){
        for (int iOffsetZ = -offset[2]; iOffsetZ <= (int) offset[2]; ++iOffsetZ) {
          if (getMaterial({var[0] + iOffsetX, var[1] + iOffsetY, var[2] + iOffsetZ}) != material) {
            found = false;
          }
        }
      } else {
        if (getMaterial({var[0] + iOffsetX, var[1] + iOffsetY}) != material) {
          found = false;
        }
      }
    }
  }
  return found;
}

◆ checkForErrors()

template<typename T , unsigned D>

bool olb::BlockGeometry< T, D >::checkForErrors ( bool verbose = true ) const

Checks for errors (searches for all outer voxels (=0) with an inner voxel (=1) as a direct neighbour)

Definition at line 369 of file blockGeometry.hh.

{
  bool error = false;
  using DESCRIPTOR = std::conditional_t<D==2,descriptors::D2Q9<>,descriptors::D3Q27<>>;
  bool errorFound = false;
  this->forSpatialLocations([&](LatticeR<D> latticeR)
  {
    if (get(latticeR) == 0) {
          errorFound = false;
          for(int iPop = 1; iPop < DESCRIPTOR::q; iPop++){
            if(getMaterial(latticeR + (descriptors::c<DESCRIPTOR>(iPop))) == 1){
              errorFound = true;
            }
          }
      if(errorFound){
        error = true;
      }
    }
  });
 
  if (verbose) {
    if (error) {
      clout << "error!" << std::endl;
    }
    else {
      clout << "the model is correct!" << std::endl;
    }
  }
  return error;
}

References olb::descriptors::c().

Here is the call graph for this function:

◆ clean()

template<typename T , unsigned D>

template<typename DESCRIPTOR >

int olb::BlockGeometry< T, D >::clean	(	bool	verbose = true,
		std::vector< int >	bulkMaterials = {1} )

Changes all cell materials which are not in bulkMaterials to 0 if there is no neighbour from bulkMaterials.

Definition at line 166 of file blockGeometry.hh.

{
  //using DESCRIPTOR = std::conditional_t<D==2,descriptors::D2Q5<>,descriptors::D3Q27<>>;
int counter=0;
  bool toClean = true;
  this->forCoreSpatialLocations([&](LatticeR<D> latticeR) {
    // material not 0 and not in bulkMaterials
    if (get(latticeR) != 0 && (! util::isContained(bulkMaterials, get(latticeR))) ) {
      toClean = true;
      for (int iPop = 1; iPop < DESCRIPTOR::q; iPop++){
        if ( util::isContained(bulkMaterials, get(latticeR + (descriptors::c<DESCRIPTOR>(iPop)))) ){
          toClean = false;
        }
      }
      if (toClean){
        set(latticeR, 0);
        counter++;
      }
    }
  });
  if (verbose) {
    clout << "cleaned "<< counter << " outer boundary voxel(s)" << std::endl;
  }
  return counter;
}

◆ copyMaterialLayer()

template<typename T , unsigned D>

void olb::BlockGeometry< T, D >::copyMaterialLayer	(	IndicatorF3D< T > &	condition,
		int	discreteNormal[D],
		int	numberOfLayers )

Copy a layer of material numbers inside an indicator in a discrete normal direction.

Definition at line 569 of file blockGeometry.hh.

{
  T physR[D];
  this->forCoreSpatialLocations([&](LatticeR<D> latticeR) {
    getPhysR(physR, latticeR);
    bool inside[1];
    condition(inside, physR);
    if (inside[0]) {
      for (int i = 0; i < numberOfLayers; i++) {
        if (0 <= latticeR[0] + i * discreteNormal[0] && latticeR[0] + i * discreteNormal[0] < this->getNx() &&
            0 <= latticeR[1] + i * discreteNormal[1] && latticeR[1] + i * discreteNormal[1] < this->getNy()){
          if constexpr(D==3){
            if(0 <= latticeR[2] + i * discreteNormal[2] && latticeR[2] + i * discreteNormal[2] < this->getNz()){
              set({latticeR[0] + i * discreteNormal[0], latticeR[1] + i * discreteNormal[1], latticeR[2] + i * discreteNormal[2]}, get(latticeR));
            }
          } else {
            set({latticeR[0] + i * discreteNormal[0], latticeR[1] + i * discreteNormal[1]}, get(latticeR));
          }
        }
      }
    }
  });
}

◆ find()

template<typename T , unsigned D>

bool olb::BlockGeometry< T, D >::find	(	int	material,
		std::vector< unsigned >	offset,
		std::vector< int >	var )

Returns the coordinates (iX,iY) of a voxel with a given material number (material) if there exists an neighbourhood of size (offsetX,offsetY) only with voxels of the given material number.

Definition at line 324 of file blockGeometry.hh.

{
  bool found = false;
  for (var[0] = 0; var[0] < this->getNx(); var[0]++) {
    for (var[1] = 0; var[1] < this->getNy(); var[1]++) {
      if constexpr(D==3){
        for (var[2] = 0; var[2] < this->getNz(); var[2]++) {
          found = check(material, var, offset);
        }
      } else {
        found = check(material, var, offset);
      }
      if (found) {
        return found;
      }
    }
  }
  return found;
}

◆ get() [1/5]

template<typename T , unsigned D>

int olb::BlockGeometry< T, D >::get ( const int latticeR[D] ) const

Definition at line 87 of file blockGeometry.hh.

{
  return _data[0][this->getCellId(latticeR)];
}

◆ get() [2/5]

template<typename T , unsigned D>

template<typename... L>

std::enable_if_t< sizeof...(L)==D, int > olb::BlockGeometry< T, D >::get ( L... latticeR ) const

inline

Read-only access to a material number.

Definition at line 107 of file blockGeometry.h.

                           {
    return _data[0][this->getCellId(latticeR...)];
  }

References olb::BlockStructureD< D >::getCellId().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get() [3/5]

template<typename T , unsigned D>

int olb::BlockGeometry< T, D >::get ( LatticeR< D > latticeR ) const

Definition at line 81 of file blockGeometry.hh.

{
  return _data[0][this->getCellId(latticeR)];
}

◆ get() [4/5]

template<typename T , unsigned D>

int olb::BlockGeometry< T, D >::get ( std::size_t iCell ) const

Definition at line 93 of file blockGeometry.hh.

{
  return _data[0][iCell];
}

◆ get() [5/5]

template<typename T , unsigned D>

template<typename... L>

std::enable_if_t< sizeof...(L)==D, void > olb::BlockGeometry< T, D >::get	(	T	physR[D],
		L...	latticeR ) const

inline

Definition at line 146 of file blockGeometry.h.

                                      {
    return this->getPhysR(physR[D],LatticeR<D>{latticeR...});
  }

References olb::BlockGeometry< T, D >::getPhysR().

Here is the call graph for this function:

◆ getBlock()

template<typename T , unsigned D>

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

overridevirtual

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

Implements olb::Serializable.

Definition at line 748 of file blockGeometry.hh.

{
  std::size_t currentBlock = 0;
  bool* dataPtr = nullptr;
 
  this->registerSerializableOfConstSize(iBlock, sizeBlock, currentBlock, dataPtr, _data, loadingMode);
 
  return dataPtr;
}

◆ getCommunicatable()

template<typename T , unsigned D>

auto & olb::BlockGeometry< T, D >::getCommunicatable ( std::type_index field )

inline

Definition at line 88 of file blockGeometry.h.

                                               {
    OLB_ASSERT(field == typeid(descriptors::MATERIAL),
               "BlockGeometry only offers MATERIAL for communication");
    return _communicatable;
  }

References OLB_ASSERT.

◆ getCuboid() [1/2]

template<typename T , unsigned D>

Cuboid< T, D > & olb::BlockGeometry< T, D >::getCuboid ( )

inline

Definition at line 137 of file blockGeometry.h.

                          {
    return _cuboid;
  }

◆ getCuboid() [2/2]

template<typename T , unsigned D>

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

inline

Definition at line 140 of file blockGeometry.h.

                                       {
    return _cuboid;
  }

◆ getDeltaR()

template<typename T , unsigned D>

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

Read only access to the voxel size given in SI units (meter)

Definition at line 75 of file blockGeometry.hh.

{
  return _cuboid.getDeltaR();
}

Here is the caller graph for this function:

◆ getExtent()

template<typename T , unsigned D>

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

Returns the extend of the block in lattice units.

Definition at line 154 of file blockGeometry.hh.

{
  if constexpr (D == 3) {
    return Vector<int,3>(this->getNx(), this->getNy(), this->getNz());
  } else {
    return Vector<int,2>(this->getNx(), this->getNy());
  }
  __builtin_unreachable();
}

Here is the caller graph for this function:

◆ getIcGlob()

template<typename T , unsigned D>

int olb::BlockGeometry< T, D >::getIcGlob ( ) const

Read only access to the global iC number which is given !=-1 if the block geometries are part of a super geometry.

Definition at line 148 of file blockGeometry.hh.

{
  return _iCglob;
}

Here is the caller graph for this function:

◆ getMaterial() [1/3]

template<typename T , unsigned D>

int olb::BlockGeometry< T, D >::getMaterial ( const int latticeR[D] ) const

Definition at line 110 of file blockGeometry.hh.

{
  LatticeR<D> loc{latticeR};
  if (this->isInside(loc)) {
    return _data[0][this->getCellId(loc)];
  }
  else {
    return 0;
  }
}

◆ getMaterial() [2/3]

template<typename T , unsigned D>

template<typename... L>

std::enable_if_t< sizeof...(L)==D, int > olb::BlockGeometry< T, D >::getMaterial ( L... latticeR ) const

inline

Definition at line 120 of file blockGeometry.h.

                                   {
    return this->getMaterial(LatticeR<D>{latticeR...});
  }

References olb::BlockGeometry< T, D >::getMaterial().

Here is the call graph for this function:

◆ getMaterial() [3/3]

template<typename T , unsigned D>

int olb::BlockGeometry< T, D >::getMaterial ( LatticeR< D > latticeR ) const

returns the (iX,iY) entry in the 2D scalar field

Definition at line 99 of file blockGeometry.hh.

{
  if (this->isInside(latticeR)) {
    return _data[0][this->getCellId(latticeR)];
  }
  else {
    return 0;
  }
}

Here is the caller graph for this function:

◆ getNblock()

template<typename T , unsigned D>

std::size_t olb::BlockGeometry< T, D >::getNblock ( ) const

overridevirtual

Number of data blocks for the serializable interface.

Implements olb::Serializable.

Definition at line 736 of file blockGeometry.hh.

{
  return _data.getNblock();
}

References olb::BlockGeometry< T, D >::getNblock().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getOrigin()

template<typename T , unsigned D>

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

Read only access to the origin position given in SI units (meter)

Definition at line 69 of file blockGeometry.hh.

{
  return _cuboid.getOrigin();
}

Here is the caller graph for this function:

◆ getPhysR() [1/2]

template<typename T , unsigned D>

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

inline

Definition at line 129 of file blockGeometry.h.

                                                   {
    Vector<T,D> physR;
    getPhysR(physR, latticeR);
    return physR;
  }

References olb::BlockGeometry< T, D >::getPhysR().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getPhysR() [2/2]

template<typename T , unsigned D>

void olb::BlockGeometry< T, D >::getPhysR	(	Vector< T, D > &	physR,
		LatticeR< D >	latticeR ) const

Transforms lattice to physical coordinates (wrapped from cuboid geometry)

Definition at line 141 of file blockGeometry.hh.

{
  physR = _cuboid.getPhysR(latticeR);
  return;
}

◆ getPlatform()

template<typename T , unsigned D>

Platform olb::BlockGeometry< T, D >::getPlatform ( ) const

inline

Definition at line 76 of file blockGeometry.h.

                               {
    return platform;
  }

References olb::BlockGeometry< T, D >::platform.

◆ getSerializableSize()

template<typename T , unsigned D>

std::size_t olb::BlockGeometry< T, D >::getSerializableSize ( ) const

overridevirtual

Binary size for the serializer.

Implements olb::Serializable.

Definition at line 742 of file blockGeometry.hh.

{
  return _data.getSerializableSize();
}

◆ getStatistics() [1/2]

template<typename T , unsigned D>

BlockGeometryStatistics< T, D > & olb::BlockGeometry< T, D >::getStatistics ( )

Write access to the associated block statistic.

Definition at line 63 of file blockGeometry.hh.

{
  return _statistics;
}

◆ getStatistics() [2/2]

template<typename T , unsigned D>

const BlockGeometryStatistics< T, D > & olb::BlockGeometry< T, D >::getStatistics ( ) const

Read only access to the associated block statistic.

Definition at line 57 of file blockGeometry.hh.

{
  return _statistics;
}

Here is the caller graph for this function:

◆ hasCommunicatable()

template<typename T , unsigned D>

bool olb::BlockGeometry< T, D >::hasCommunicatable ( std::type_index field ) const

inline

Definition at line 85 of file blockGeometry.h.

                                                    {
    return field == typeid(descriptors::MATERIAL);
  }

◆ innerClean() [1/2]

template<typename T , unsigned D>

int olb::BlockGeometry< T, D >::innerClean ( bool verbose = true )

Changes all cell materials which are not 0 or 1 to 1 if there is a non robust constiallation.

Definition at line 219 of file blockGeometry.hh.

{
  int count2 = 0;
  using DESCRIPTOR = std::conditional_t<D==2,descriptors::D2Q5<>,descriptors::D3Q7<>>;
 
  this->forCoreSpatialLocations([&](LatticeR<D> latticeR) {
    if (get(latticeR) != 1 && get(latticeR) != 0) {
      if constexpr (D==3){
        bool var[7] = {false};
        for(int iPop = 1; iPop < DESCRIPTOR::q; iPop++){
          if(getMaterial(latticeR + (descriptors::c<DESCRIPTOR>(iPop)))==1){
            var[iPop] = true;
          }
        }
        int comb[12][3]={{1,4,2},{1,4,3},{1,4,5},{1,4,6},{2,5,1},{2,5,3},{2,5,4},{2,5,6},{3,6,1},{3,6,2},{3,6,4},{3,6,5}};
        for(int i = 0; i < 12; i++){
          if (var[(comb[i][0])] == true
              && var[(comb[i][1])] == true
              && var[(comb[i][2])] == true){
            set(latticeR, 1);
            count2++;//count2 is the same value as before, count2 gets increased even if this cell has already been cleaned
          }
        }
     } else {
        int var = 0;
        for(int iPop = 1; iPop < DESCRIPTOR::q; iPop++){
          if(getMaterial(latticeR + (descriptors::c<DESCRIPTOR>(iPop)))==1){
            var = var+1;
          }
        }
        if(var >= 3){
          set(latticeR, 1);
          count2++;//count2 differs from original count2
        }
      }
    }
  });
 
  if (verbose) {
    clout << "cleaned "<< count2 << " inner boundary voxel(s)" << std::endl;
  }
  return count2;
}

References olb::descriptors::c().

Here is the call graph for this function:

◆ innerClean() [2/2]

template<typename T , unsigned D>

int olb::BlockGeometry< T, D >::innerClean	(	int	fromM,
		bool	verbose = true )

Changes all cells with material fromM to 1 if there is a non robust constiallation.

Definition at line 264 of file blockGeometry.hh.

{
  int count2 = 0;
  using DESCRIPTOR = std::conditional_t<D==2,descriptors::D2Q5<>,descriptors::D3Q7<>>;
 
  this->forCoreSpatialLocations([&](LatticeR<D> latticeR) {
    if (get(latticeR) != 1 && get(latticeR) != 0 && get(latticeR) == fromM) {
      if constexpr (D==3){
        bool var[7] = {false};
        for(int iPop = 1; iPop < DESCRIPTOR::q; iPop++){
          if(getMaterial(latticeR + (descriptors::c<DESCRIPTOR>(iPop)))==1){
            var[iPop] = true;
          }
        }
        int comb[12][3]={{1,4,2},{1,4,3},{1,4,5},{1,4,6},{2,5,1},{2,5,3},{2,5,4},{2,5,6},{3,6,1},{3,6,2},{3,6,4},{3,6,5}};
        for(int i = 0; i < 12; i++){
          if (var[(comb[i][0])] == true
              && var[(comb[i][1])] == true
              && var[(comb[i][2])] == true){
            set(latticeR, 1);
            count2++;//count2 is the same value as before, count2 gets increased even if this cell has already been cleaned
          }
        }
     } else {
        int var = 0;
        for(int iPop = 1; iPop < DESCRIPTOR::q; iPop++){
          if(getMaterial(latticeR + (descriptors::c<DESCRIPTOR>(iPop)))==1){
            var = var+1;
          }
        }
        if(var >= 3){
          set(latticeR, 1);
          count2++;//count2 differs from original count2
        }
      }
    }
  });
 
  if (verbose){
    clout << "cleaned "<< count2
    << " inner boundary voxel(s) of Type " << fromM << std::endl;
  }
  return count2;
}

References olb::descriptors::c().

Here is the call graph for this function:

◆ outerClean()

template<typename T , unsigned D>

int olb::BlockGeometry< T, D >::outerClean	(	bool	verbose = true,
		std::vector< int >	bulkMaterials = {1} )

Changes all cell materials from bulkMaterials to 0 if there is a neighbour with material 0.

Definition at line 193 of file blockGeometry.hh.

{
  int counter=0;
  using DESCRIPTOR = std::conditional_t<D==2,descriptors::D2Q9<>,descriptors::D3Q27<>>;
  bool toClean = false;
  this->forCoreSpatialLocations([&](LatticeR<D> latticeR) {
    if (util::isContained(bulkMaterials, get(latticeR))) {
      toClean = false;
      for(int iPop = 1; iPop < DESCRIPTOR::q; iPop++){
        if(getMaterial(latticeR + (descriptors::c<DESCRIPTOR>(iPop))) == 0){
          toClean = true;
        }
      }
      if(toClean){
        set(latticeR, 0);
        counter++;
      }
    }
  });
  if (verbose) {
    clout << "cleaned "<< counter << " outer fluid voxel(s)" << std::endl;
  }
  return counter;
}

◆ printLayer() [1/2]

template<typename T , unsigned D>

void olb::BlockGeometry< T, D >::printLayer	(	int	direction,
		int	layer,
		bool	linenumber = false )

Prints a chosen part of the block geometry.

Definition at line 679 of file blockGeometry.hh.

{
  assert(direction >= 0 && direction <= 2);
  if constexpr(D==3){
    switch (direction) {
    case 0:
      printLayer({layer, 0, 0},{layer, this->getNy() - 1, this->getNz() - 1}, linenumber);
      break;
    case 1:
      printLayer({0, layer, 0}, {this->getNx() - 1, layer, this->getNz() - 1}, linenumber);
      break;
    case 2:
      printLayer({0, 0, layer}, {this->getNx() - 1, this->getNy() - 1, layer}, linenumber);
      break;
    }
  } else {
    switch (direction) {
    case 0:
      printLayer({layer, 0}, {layer, this->getNy() - 1}, linenumber);
      break;
    case 1:
      printLayer({0, layer}, {this->getNx() - 1, layer}, linenumber);
      break;
    }
  }
}

◆ printLayer() [2/2]

template<typename T , unsigned D>

void olb::BlockGeometry< T, D >::printLayer	(	std::vector< int >	min,
		std::vector< int >	max,
		bool	linenumber = false )

Prints a chosen part of the block geometry.

Definition at line 653 of file blockGeometry.hh.

{
  for (int x = min[0]; x <= max[0]; x++) {
    if (linenumber) {
      clout << x << ": ";
    }
    for (int y = min[1]; y <= max[1]; y++) {
      if constexpr (D==3){
        for (int z = min[2]; z <= max[2]; z++) {
          clout << getMaterial({x, y, z}) << " ";
        }
        if (max[1] - min[1] != 0 && max[2] - min[2] != 0) {
          clout << std::endl;
        }
      } else {
        clout << getMaterial({x, y}) << " ";
      }
    }
    if (max[0] - min[0] != 0) {
      clout << std::endl;
    }
  }
  clout << std::endl;
}

◆ printNode()

template<typename T , unsigned D>

void olb::BlockGeometry< T, D >::printNode	(	std::vector< int >	loc,
		int	offset = 1 )

Prints a chosen node and its neighbourhood.

Definition at line 707 of file blockGeometry.hh.

{
  for (int x = loc[0] - offset; x <= loc[0] + offset; x++) {
    if constexpr (D==3) {
      clout << "yz-plane_x=" << x - loc[0] << std::endl;
    }
    for (int y = loc[1] - offset; y <= loc[1] + offset; y++) {
      if constexpr (D==3){
        for (int z = loc[2] - offset; z <= loc[2] + offset; z++) {
          clout << getMaterial({x, y, z}) << " ";
        }
        clout << std::endl;
      } else {
        clout << getMaterial({x, y}) << " ";
      }
    }
    if constexpr (D==2){
      clout << std::endl;
    }
  }
}

◆ regionGrowing()

template<typename T , unsigned D>

void olb::BlockGeometry< T, D >::regionGrowing	(	int	fromM,
		int	toM,
		LatticeR< D >	seed,
		std::vector< int >	offset,
		std::map< std::vector< int >, int > *	tmp = nullptr )

Replaces all material numbers (fromM) to another (toM) using a seed point and max. directions indicated by offsetX,Y != 0.

Definition at line 594 of file blockGeometry.hh.

{
  std::map<std::vector<int>, int> tmp2;
  bool firstCall = false;
  if (tmp == nullptr) {
    tmp = &tmp2;
    firstCall = true;
  }
 
  if (getMaterial(seed) == fromM) {
    std::vector<int> found;
    found.push_back(seed[0]);
    found.push_back(seed[1]);
    if constexpr(D==3){
      found.push_back(seed[2]);
      if (tmp->count(found) == 0) {
        (*tmp)[found] = 2;
        if (offset[0] != 0) {
          regionGrowing(fromM, toM, {seed[0] + 1, seed[1], seed[2]}, offset, tmp);
          regionGrowing(fromM, toM, {seed[0] - 1, seed[1], seed[2]}, offset, tmp);
        }
        if (offset[1] != 0) {
          regionGrowing(fromM, toM, {seed[0], seed[1] + 1, seed[2]}, offset, tmp);
          regionGrowing(fromM, toM, {seed[0], seed[1] - 1, seed[2]}, offset, tmp);
        }
        if (offset[2] != 0) {
          regionGrowing(fromM, toM, {seed[0], seed[1], seed[2] + 1}, offset, tmp);
          regionGrowing(fromM, toM, {seed[0], seed[1], seed[2] - 1}, offset, tmp);
        }
      }
    } else {
      if (tmp->count(found) == 0) {
        (*tmp)[found] = 2;
        if (offset[0] != 0) {
          regionGrowing(fromM, toM, {seed[0] + 1, seed[1]}, offset, tmp);
          regionGrowing(fromM, toM, {seed[0] - 1, seed[1]}, offset, tmp);
        }
        if (offset[1] != 0) {
          regionGrowing(fromM, toM, {seed[0], seed[1] + 1}, offset, tmp);
          regionGrowing(fromM, toM, {seed[0], seed[1] - 1}, offset, tmp);
        }
      }
    }
  }
  if (firstCall) {
    std::map<std::vector<int>, int>::iterator iter;
    for (iter = tmp->begin(); iter != tmp->end(); iter++) {
      if constexpr(D==3){
        set((iter->first)[0],(iter->first)[1],(iter->first)[2], toM);
      } else {
        set((iter->first)[0],(iter->first)[1], toM);
      }
    }
  }
  return;
}

◆ rename() [1/6]

template<typename T , unsigned D>

void olb::BlockGeometry< T, D >::rename	(	int	fromM,
		int	toM )

Replaces all material numbers (fromM) to another (toM)

Definition at line 401 of file blockGeometry.hh.

{
  this->forCoreSpatialLocations([&](LatticeR<D> latticeR) {
    if (get(latticeR) == fromM) {
      set(latticeR, toM);
    }
  });
}

◆ rename() [2/6]

template<typename T , unsigned D>

void olb::BlockGeometry< T, D >::rename	(	int	fromM,
		int	toM,
		IndicatorF< T, D > &	condition )

Replaces all material numbers (fromM) to another (toM) if an indicator functor condition is fulfilled.

Definition at line 411 of file blockGeometry.hh.

{
  OstreamManager clout("rename");
 
  Vector<T, D> physR;
 
  Vector<T, D> min = condition.getMin();
  Vector<T, D> max = condition.getMax();
  LatticeR<D> latticeRmin= _cuboid.getLatticeR(min);
  LatticeR<D> latticeRmax=_cuboid.getLatticeR(max);
 
  this->forSpatialLocations(latticeRmin, latticeRmax, [&](LatticeR<D> latticeR) {
    if (get(latticeR) == fromM) {
      getPhysR(physR, latticeR);
 
      bool inside[1];
      condition(inside, physR.data());
 
      if (inside[0]) {
        set(latticeR, toM);
      }
    }
  });
}

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

Here is the call graph for this function:

◆ rename() [3/6]

template<typename T , unsigned D>

void olb::BlockGeometry< T, D >::rename	(	int	fromM,
		int	toM,
		int	fluidM,
		IndicatorF< T, D > &	condition )

Replaces all material numbers (fromM) to another (toM) if all materials in the neighbourhood (iX+discreteNormal[0],iX+2*discreteNormal[0]), .. are of another material number (fluidM) and if an indicator functor condition is fulfilled, the discreteNormal is computed from all fromM which fulfill the indicator functor condition.

Definition at line 537 of file blockGeometry.hh.

{
  rename(fromM, toM, condition);
  std::vector<int> testDirection = getStatistics().computeDiscreteNormal(toM);
  T physR[D];
  // values that have been incorrectly changed from "fromM to "toM" get assigned back to "fromM"
  this->forCoreSpatialLocations([&](LatticeR<D> latticeR) {
    if (get(latticeR) == toM) {
      getPhysR(physR, latticeR);
      bool inside[1];
      condition(inside, physR);
      if (inside[0]) {
        if constexpr(D==3){
          if (getMaterial({latticeR[0]+testDirection[0],latticeR[1]+testDirection[1],latticeR[2]+testDirection[2]})!=fluidM ||
              getMaterial({latticeR[0]+2*testDirection[0],latticeR[1]+2*testDirection[1],latticeR[2]+2*testDirection[2]})!=fluidM ||
              getMaterial({latticeR[0]-testDirection[0],latticeR[1]-testDirection[1],latticeR[2]-testDirection[2]})!=0 ) {
            set(latticeR, fromM);
          }
        } else {
          if (getMaterial({latticeR[0]+testDirection[0],latticeR[1]+testDirection[1]})!=fluidM ||
              getMaterial({latticeR[0]+2*testDirection[0],latticeR[1]+2*testDirection[1]})!=fluidM ||
              getMaterial({latticeR[0]-testDirection[0],latticeR[1]-testDirection[1]})!=0 ) {
            set(latticeR, fromM);
          }
        }
      }
    }
  });
}

◆ rename() [4/6]

template<typename T , unsigned D>

void olb::BlockGeometry< T, D >::rename	(	int	fromM,
		int	toM,
		int	fluidM,
		IndicatorF< T, D > &	condition,
		Vector< int, D >	discreteNormal )

Replaces all material numbers (fromM) to another (toM) if all materials in the neighbourhood (iX+discreteNormal[0],iX+2*discreteNormal[0]), .. are of another material number (testM) and if an indicator functor condition is fulfilled.

Definition at line 504 of file blockGeometry.hh.

{
  rename(fromM, toM, condition);
  Vector<int,D> testDirection(discreteNormal);
  Vector<T,D> physR;
 
  this->forCoreSpatialLocations([&](LatticeR<D> latticeR) {
    if (get(latticeR) == toM) {
      getPhysR(physR, latticeR);
      bool inside[1];
 
      condition(inside, physR.data());
      if (inside[0]) {
        if constexpr (D==3){
          if (getMaterial({latticeR[0]+testDirection[0],latticeR[1]+testDirection[1],latticeR[2]+testDirection[2]})!=fluidM ||
              getMaterial({latticeR[0]+2*testDirection[0],latticeR[1]+2*testDirection[1],latticeR[2]+2*testDirection[2]})!=fluidM ||
              getMaterial({latticeR[0]-testDirection[0],latticeR[1]-testDirection[1],latticeR[2]-testDirection[2]})!=0 ) {
            set(latticeR, fromM);
          }
        } else {
          if (getMaterial({latticeR[0]+testDirection[0],latticeR[1]+testDirection[1]}) != fluidM ||
              getMaterial({latticeR[0]+2*testDirection[0],latticeR[1]+2*testDirection[1]}) != fluidM ||
              getMaterial({latticeR[0]-testDirection[0],latticeR[1]-testDirection[1]}) != 0) {
            set(latticeR, fromM);
          }
        }
      }
    }
  });
}

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

Here is the call graph for this function:

◆ rename() [5/6]

template<typename T , unsigned D>

void olb::BlockGeometry< T, D >::rename	(	int	fromM,
		int	toM,
		int	testM,
		std::vector< int >	testDirection )

Replaces all material numbers (fromM) to another (toM) if all materials in the neighbourhood (iX+1,iX+2,..,ix+testDirection[0]), .. are of another material number (testM)

Definition at line 469 of file blockGeometry.hh.

{
  this->forCoreSpatialLocations([&](LatticeR<D> latticeR) {
    if (get(latticeR) == fromM) {
      // flag that indicates the renaming of the current voxel, valid voxels are not renamed
      bool isValid = true;
      for (int iOffsetX = util::min(testDirection[0],0); iOffsetX <= util::max(testDirection[0],0); ++iOffsetX) {
        for (int iOffsetY = util::min(testDirection[1],0); iOffsetY <= util::max(testDirection[1],0); ++iOffsetY) {
          if constexpr (D == 3){
            for (int iOffsetZ = util::min(testDirection[2],0); iOffsetZ <= util::max(testDirection[2],0); ++iOffsetZ) {
              if (iOffsetX!=0 || iOffsetY!=0 || iOffsetZ!=0) {
                if (getMaterial({latticeR[0] + iOffsetX, latticeR[1] + iOffsetY, latticeR[2] + iOffsetZ}) != testM) {
                  isValid = false;
                }
              }
            }
          } else {
            if (iOffsetX!=0 || iOffsetY!=0) {
              if (getMaterial({latticeR[0] + iOffsetX, latticeR[1] + iOffsetY}) != testM) {
                isValid = false;
              }
            }
          }
        }
      }
      if (!isValid) {
        set(latticeR, toM);
      }
    }
  });
}

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

Here is the call graph for this function:

◆ rename() [6/6]

template<typename T , unsigned D>

void olb::BlockGeometry< T, D >::rename	(	int	fromM,
		int	toM,
		LatticeR< D >	offset )

Replaces all material numbers (fromM) to another (toM) if all materials in the neighbourhood (iX-offsetX,..,iX,..,ix+offsetX), .. are of the original material number (fromM)

Definition at line 436 of file blockGeometry.hh.

{
  this->forCoreSpatialLocations([&](LatticeR<D> latticeR) {
    if (get(latticeR) == fromM) {
      bool found = true;
      for (int iOffsetX = -offset[0]; iOffsetX <= (int) offset[0]; ++iOffsetX) {
        for (int iOffsetY = -offset[1]; iOffsetY <= (int) offset[1]; ++iOffsetY) {
          if constexpr (D == 3) {
            for (int iOffsetZ = -offset[2]; iOffsetZ <= (int) offset[2]; ++iOffsetZ) {
              if (getMaterial({latticeR[0] + iOffsetX, latticeR[1] + iOffsetY, latticeR[2] + iOffsetZ}) != fromM) {
                if (getMaterial({latticeR[0] + iOffsetX, latticeR[1] + iOffsetY, latticeR[2] + iOffsetZ}) != 1245) {
                  found = false;
                }
              }
            }
          } else {
            if (getMaterial({latticeR[0] + iOffsetX, latticeR[1] + iOffsetY}) != fromM) {
              if (getMaterial({latticeR[0] + iOffsetX, latticeR[1] + iOffsetY}) != 1245) {
                found = false;
              }
            }
          }
        }
      }
      if (found) {
        set(latticeR, 1245); // TODO Replace this embarassing approach
      }
    }
  });
  rename(1245,toM);
}

◆ reset()

template<typename T , unsigned D>

void olb::BlockGeometry< T, D >::reset ( IndicatorF< T, D > & domain )

Resets all cell materials inside of a domain to 0.

Definition at line 310 of file blockGeometry.hh.

{
  this->forCoreSpatialLocations([&](LatticeR<D> latticeR) {
    T physR[D] { };
    bool output{};
    getPhysR(physR, latticeR);
    domain(&output, physR);
    if (output) {
      set(latticeR, 0);
    }
  });
}

◆ set() [1/3]

template<typename T , unsigned D>

void olb::BlockGeometry< T, D >::set	(	const int	latticeR[D],
		int	material )

Definition at line 128 of file blockGeometry.hh.

{
  set(this->getCellId(latticeR), material);
}

◆ set() [2/3]

template<typename T , unsigned D>

void olb::BlockGeometry< T, D >::set	(	LatticeR< D >	latticeR,
		int	material )

Write access to a material number.

Definition at line 122 of file blockGeometry.hh.

{
  set(this->getCellId(latticeR), material);
}

◆ set() [3/3]

template<typename T , unsigned D>

void olb::BlockGeometry< T, D >::set	(	std::size_t	iCell,
		int	material )

Definition at line 134 of file blockGeometry.hh.

{
  resetStatistics();
  _data[0][iCell] = material;
}

Member Data Documentation

◆ platform

template<typename T , unsigned D>

Platform olb::BlockGeometry< T, D >::platform = Platform::CPU_SISD

staticconstexpr

Definition at line 72 of file blockGeometry.h.

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

src/geometry/blockGeometry.h
src/geometry/blockGeometryStatistics2D.h
src/geometry/blockGeometryStatistics3D.h
src/geometry/blockGeometry.hh

Public Member Functions

Static Public Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ BlockGeometry()

Member Function Documentation

◆ check()

◆ checkForErrors()

◆ clean()

◆ copyMaterialLayer()

◆ find()

◆ get() [1/5]

◆ get() [2/5]

◆ get() [3/5]

◆ get() [4/5]

◆ get() [5/5]

◆ getBlock()

◆ getCommunicatable()

◆ getCuboid() [1/2]

◆ getCuboid() [2/2]

◆ getDeltaR()

◆ getExtent()

◆ getIcGlob()

◆ getMaterial() [1/3]

◆ getMaterial() [2/3]

◆ getMaterial() [3/3]

◆ getNblock()

◆ getOrigin()

◆ getPhysR() [1/2]

◆ getPhysR() [2/2]

◆ getPlatform()

◆ getSerializableSize()

◆ getStatistics() [1/2]

◆ getStatistics() [2/2]

◆ hasCommunicatable()

◆ innerClean() [1/2]

◆ innerClean() [2/2]

◆ outerClean()

◆ printLayer() [1/2]

◆ printLayer() [2/2]

◆ printNode()

◆ regionGrowing()

◆ rename() [1/6]

◆ rename() [2/6]

◆ rename() [3/6]

◆ rename() [4/6]

◆ rename() [5/6]

◆ rename() [6/6]

◆ reset()

◆ set() [1/3]

◆ set() [2/3]

◆ set() [3/3]

Member Data Documentation

◆ platform