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

Representation of a statistic for a parallel 2D geometry. More...

#include <superGeometry.h>

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

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

Public Types
using	block_t = ConcretizableBlockGeometry<T,D>
Public Types inherited from olb::SuperStructure< T, D >
using	value_t = T

Public Member Functions
	SuperGeometry (CuboidDecomposition< T, D > &cuboidDecomposition, LoadBalancer< T > &loadBalancer, int overlap=3)
int	get (LatticeR< D+1 > latticeR) const
	Read only access to the material numbers, error handling: returns 0 if data is not available.
template<typename... L>
std::enable_if_t< sizeof...(L)==(D+1), int >	get (L... latticeR) const
int	getAndCommunicate (LatticeR< D+1 > latticeR) const
	Read only access to the material numbers with global communication to all ranks.
Vector< T, D >	getPhysR (LatticeR< D+1 > latticeR) const
	Transforms a lattice to physical position (SI units)
void	getPhysR (T output[D], const int latticeR[D+1]) const
	Transforms a lattice to physical position (SI units)
BlockGeometry< T, D > &	getBlockGeometry (int locIC)
	Read and write access to a single block geometry.
BlockGeometry< T, D > const &	getBlockGeometry (int locIC) const
	Read only access to a single block geometry.
template<typename BLOCK = BlockGeometry<T,D>>
BLOCK &	getBlock (int locIC)
	Read and write access to a single extended block geometry.
template<typename BLOCK = BlockGeometry<T,D>>
const BLOCK &	getBlock (int locIC) const
	Read only access to a single extended block geometry.
SuperGeometryStatistics< T, D > &	getStatistics ()
	Returns the statistics object.
const SuperGeometryStatistics< T, D > &	getStatistics () const
	Returns the statistics object (readonly)
bool &	getStatisticsStatus ()
	Read and write access to the statistic status flag, update needed = true.
bool const &	getStatisticsStatus () const
	Read only access to the statistic status flag, update needed = true.
void	updateStatistics (bool verbose=true)
	Updates the super geometry at the boundaries if needed and afterwards the statisics if needed.
template<typename DESCRIPTOR = std::conditional_t<D==2,descriptors::D2Q9<>,descriptors::D3Q27<>>>
int	clean (bool verbose=true, std::vector< int > bulkMaterials={1})
	Executes an outer cleaning: Sets all material numbers which are not bulk-materials to 0 if there is no neighbour from bulkMaterials.
int	outerClean (bool verbose=true, std::vector< int > bulkMaterials={1})
	Removes not needed fluid cells from the outer domain.
int	innerClean (bool verbose=true)
	inner cleaning for all boundary types
int	innerClean (int material, bool verbose=true)
	inner cleaning for specific boundary types
bool	checkForErrors (bool verbose=true)
	check for errors (searches for all outer voxels (=0) with an inner voxel (=1) as a direct neighbour)
void	reset (IndicatorF< T, D > &domain)
	reset all cell materials inside of a domain to 0
void	rename (int fromM, int toM)
	replace one material with another
void	rename (int fromM, int toM, FunctorPtr< IndicatorF< T, D > > &&condition)
	replace one material that fulfills an indicator functor condition with another
void	rename (int fromM, int toM, LatticeR< D > offset)
	replace one material with another respecting an offset (overlap)
void	rename (int fromM, int toM, int testM, Vector< int, D > testDirection)
	renames all voxels of material fromM to toM if the number of voxels given by testDirection is of material testM
void	rename (int fromBcMat, int toBcMat, int fluidMat, IndicatorF< T, D > &condition)
	renames all boundary voxels of material fromBcMat to toBcMat if two neighbour voxel in the direction of the discrete normal are fluid voxel with material fluidM in the region where the indicator function is fulfilled
void	rename (int fromBcMat, int toBcMat, int fluidMat, FunctorPtr< IndicatorF< T, D > > &&condition)
	renames all boundary voxels of material fromBcMat to toBcMat if two neighbour voxel in the direction of the discrete normal are fluid voxel with material fluidM in the region where the indicator function is fulfilled
void	print ()
	Prints some information about the super geometry.
void	setWriteIncrementalVTK (bool state)
	Toggles whether geometry should be written out as VTK after every modification.
bool	getWriteIncrementalVTKState ()
void	print (const T physR[D], int offset)
std::unique_ptr< SuperIndicatorF< T, D > >	getMaterialIndicator (std::vector< int > &&materials)
	Returns a material indicator using the given vector of materials.
std::unique_ptr< SuperIndicatorF< T, D > >	getMaterialIndicator (int material)
	Returns a material indicator using a single material number.
void	communicate () override
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::SuperStructure< T, D >
virtual	~SuperStructure ()
	Virtual Destructor for inheritance.
	SuperStructure (CuboidDecomposition< T, D > &cuboidDecomposition, LoadBalancer< T > &loadBalancer, int overlap=2)
	Construction of a super structure.
CuboidDecomposition< T, D > &	getCuboidDecomposition ()
	Read and write access to cuboid geometry.
const CuboidDecomposition< T, D > &	getCuboidDecomposition () const
	Read only access to cuboid geometry.
int	getOverlap ()
	Read and write access to the overlap.
int	getOverlap () const
	Read only access to the overlap.
LoadBalancer< T > &	getLoadBalancer ()
	Read and write access to the load balancer.
LoadBalancer< T > const &	getLoadBalancer () const
	Read only access to the load balancer.
template<typename F >
void	forCorePhysLocations (F f) const
	Iterate over discrete physical locations.
template<typename F >
void	forCorePhysLocations (PhysR< T, D > min, PhysR< T, D > max, F f) const
	Iterate over discrete physical locations between min and max.
template<typename F >
void	forCoreSpatialLocations (F f) const
	Iterate over spatial locations NOTE: Based on physical locations (as opposed to its blockStructure version)
template<typename F >
void	forCoreSpatialLocations (PhysR< T, D > min, PhysR< T, D > max, F f) const
	Iterate over spatial locations between min and max NOTE: Based on physical locations (as opposed to its blockStructure version)
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 unsigned	d = D

Additional Inherited Members
Protected Member Functions inherited from olb::BufferSerializable
template<typename DataType >
void	registerSerializable (const std::size_t iBlock, std::size_t &sizeBlock, std::size_t &currentBlock, size_t &sizeBufferIndex, bool *&dataPtr, DataType &data, const bool loadingMode=false)
	Register Serializable object of dynamic size.
template<typename DataType >
void	registerStdVectorOfVars (const std::size_t iBlock, std::size_t &sizeBlock, std::size_t &currentBlock, size_t &sizeBufferIndex, bool *&dataPtr, std::vector< DataType > &data, const bool loadingMode=false)
	Method for registering a std::vector<DataType> of primitive DataType (int, double, ...)
template<typename DataType >
void	registerStdVectorOfSerializablesOfConstSize (const std::size_t iBlock, std::size_t &sizeBlock, std::size_t &currentBlock, size_t &sizeBufferIndex, bool *&dataPtr, std::vector< DataType > &data, const bool loadingMode=false)
	Method for registering a std::vector<DataType> of constant-sized Serializable
template<typename DataType >
void	registerStdVectorOfSerializables (const std::size_t iBlock, std::size_t &sizeBlock, std::size_t &currentBlock, size_t &sizeBufferIndex, bool *&dataPtr, std::vector< DataType > &data, const bool loadingMode=false)
	Method for registering a std::vector<DataType> of dynamic-sized DataType
template<typename DataTypeKey , typename DataTypeValue >
void	registerMap (const std::size_t iBlock, std::size_t &sizeBlock, std::size_t &currentBlock, size_t &sizeBufferIndex, bool *&dataPtr, std::map< DataTypeKey, DataTypeValue > &data, const bool loadingMode=false)
	Method for registering a std::map<DataTypeKey, DataTypeValue> of fixed-sized types (i.e. int, double)
size_t	addSizeToBuffer (const std::size_t iBlock, std::size_t &sizeBlock, std::size_t &currentBlock, size_t &sizeBufferIndex, bool *&dataPtr, const size_t data) const
	Add a size_t to the sizeBuffer in the n-th util::round and return that size_t in all successive rounds.
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::SuperStructure< T, D >
CuboidDecomposition< T, D > &	_cuboidDecomposition
	The grid structure is referenced here.
LoadBalancer< T > &	_loadBalancer
	Distribution of the cuboids of the cuboid structure.
int	_overlap
	Size of ghost cell layer (must be greater than 1 and greater_overlapBC, default =1)
OstreamManager	clout
	class specific output stream
Protected Attributes inherited from olb::BufferSerializable
std::vector< bool * >	_dataBuffer
	Data buffer for data that has to be buffered between two getBlock() iterations.
std::vector< size_t >	_sizeBuffer
	std::vector of integer buffers (e.g. for std::vector size) to be buffered for the whole iteration process

Detailed Description

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

Representation of a statistic for a parallel 2D geometry.

Representation of a statistic for a parallel 3D geometry.

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

This class is not intended to be derived from.

A super geometry statistic computes different integral values, like total number of different materials, materials of any kind, min./max. physical position, of an underlying super geometry.

This class is not intended to be derived from.

Definition at line 54 of file superGeometryStatistics3D.h.

Member Typedef Documentation

block_t

template<typename T , unsigned D>

using olb::SuperGeometry< T, D >::block_t = ConcretizableBlockGeometry<T,D>

Definition at line 92 of file superGeometry.h.

Constructor & Destructor Documentation

SuperGeometry()

template<typename T , unsigned D>

olb::SuperGeometry< T, D >::SuperGeometry	(	CuboidDecomposition< T, D > &	cuboidDecomposition,
		LoadBalancer< T > &	loadBalancer,
		int	overlap = 3 )

Definition at line 57 of file superGeometry.hh.

                                              :
  SuperStructure<T,D>(cuboidDecomposition, loadBalancer, overlap),
  _communicator(new SuperCommunicator<T,SuperGeometry<T,D>>(*this)),
  _communicationNeeded(false),
  _statistics(this),
  _clout(std::cout, ("SuperGeometry" + std::to_string(D) + "D")),
  _iConstructionT{0},
  _writeIncrementalVtkEnabled{true}
{
  for (int iCloc=0; iCloc < this->getLoadBalancer().size(); iCloc++) {
    int iCglob = this->getLoadBalancer().glob(iCloc);
    _block.emplace_back(
      new BlockGeometry<T,D>(cuboidDecomposition.get(iCglob), overlap, iCglob));
  }
 
  _communicator->template requestField<descriptors::MATERIAL>();
  _communicator->requestOverlap(this->_overlap);
  _communicator->exchangeRequests();
 
  _statistics.getStatisticsStatus() = true;
  _communicationNeeded = true;
  updateStatistics(false);
 
  //writeIncrementalVTK();
}

References olb::SuperStructure< T, D >::_overlap, olb::CuboidDecomposition< T, D >::get(), olb::SuperStructure< T, D >::getLoadBalancer(), and olb::SuperGeometry< T, D >::updateStatistics().

Here is the call graph for this function:

Member Function Documentation

checkForErrors()

template<typename T , unsigned D>

bool olb::SuperGeometry< T, D >::checkForErrors

(

bool

verbose = true

)

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

Definition at line 291 of file superGeometry.hh.

{
  updateStatistics(verbose);
  bool error = false;
  for (unsigned iC=0; iC<_block.size(); iC++) {
    if (_block[iC]->checkForErrors(false)) {
      error = true;
    }
  }
  if (verbose) {
    if (error) {
      this->_clout << "error!" << std::endl;
    }
    else {
      this->_clout << "the model is correct!" << std::endl;
    }
  }
  return error;
}

clean()

template<typename T , unsigned D>

template<typename DESCRIPTOR >

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

Executes an outer cleaning: Sets all material numbers which are not bulk-materials to 0 if there is no neighbour from bulkMaterials.

Definition at line 206 of file superGeometry.hh.

{
  this->communicate();
  int counter=0;
  for (unsigned iC=0; iC<_block.size(); iC++) {
    counter+=_block[iC]->template clean <DESCRIPTOR>(false, bulkMaterials);
  }
#ifdef PARALLEL_MODE_MPI
  singleton::mpi().reduceAndBcast(counter, MPI_SUM);
#endif
 
  if (verbose) {
    _clout << "cleaned "<< counter << " outer boundary voxel(s)" << std::endl;
  }
  _statistics.getStatisticsStatus() = true;
  this->_communicationNeeded = true;
  writeIncrementalVTK();
  return counter;
}

communicate()

template<typename T , unsigned D>

void olb::SuperGeometry< T, D >::communicate ( )

inlineoverridevirtual

Reimplemented from olb::SuperStructure< T, D >.

Definition at line 199 of file superGeometry.h.

  {
    if (_communicationNeeded) {
      _communicator->communicate();
      _communicationNeeded = false;
    }
  }

get() [1/2]

template<typename T , unsigned D>

template<typename... L>

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

inline

Definition at line 103 of file superGeometry.h.

                           {
    return get(LatticeR<D+1>{latticeR...});
  }

References olb::SuperGeometry< T, D >::get().

Here is the call graph for this function:

get() [2/2]

template<typename T , unsigned D>

int olb::SuperGeometry< T, D >::get

(

LatticeR< D+1 >

latticeR

)

const

Read only access to the material numbers, error handling: returns 0 if data is not available.

Definition at line 100 of file superGeometry.hh.

{
  if ( this->getLoadBalancer().rank(latticeR[0]) == singleton::mpi().getRank() ) {
    return _block[this->getLoadBalancer().loc(latticeR[0])]->get(latticeR.data()+1);
  } else {
    throw std::domain_error("read only access to data which is not available locally");
  }
}

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

Here is the call graph for this function:

Here is the caller graph for this function:

getAndCommunicate()

template<typename T , unsigned D>

int olb::SuperGeometry< T, D >::getAndCommunicate

(

LatticeR< D+1 >

latticeR

)

const

Read only access to the material numbers with global communication to all ranks.

Definition at line 110 of file superGeometry.hh.

{
  int material = 0;
  if ( this->getLoadBalancer().rank(latticeR[0]) == singleton::mpi().getRank() ) {
    material = _block[this->getLoadBalancer().loc(latticeR[0])]->get(latticeR.data()+1);
  }
#ifdef PARALLEL_MODE_MPI
  singleton::mpi().bCast(&material, 1, this->_loadBalancer.rank(latticeR[0]));
#endif
  return material;
}

getBlock() [1/3]

template<typename T , unsigned D>

template<typename BLOCK >

BLOCK & olb::SuperGeometry< T, D >::getBlock

(

int

locIC

)

Read and write access to a single extended block geometry.

Definition at line 150 of file superGeometry.hh.

{
  _statistics.getStatisticsStatus() = true;
  return *_block[locIC];
}

Here is the caller graph for this function:

getBlock() [2/3]

template<typename T , unsigned D>

template<typename BLOCK >

const BLOCK & olb::SuperGeometry< T, D >::getBlock

(

int

locIC

)

const

Read only access to a single extended block geometry.

Definition at line 158 of file superGeometry.hh.

{
  return *_block[locIC];
}

getBlock() [3/3]

template<typename T , unsigned D>

bool * olb::SuperGeometry< 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 511 of file superGeometry.hh.

{
  std::size_t currentBlock = 0;
  bool* dataPtr = nullptr;
 
  for (std::size_t iC=0; iC < _block.size(); ++iC) {
    registerSerializableOfConstSize(iBlock, sizeBlock, currentBlock, dataPtr, getBlock(iC), loadingMode);
  }
 
  return dataPtr;
}

getBlockGeometry() [1/2]

template<typename T , unsigned D>

BlockGeometry< T, D > & olb::SuperGeometry< T, D >::getBlockGeometry

(

int

locIC

)

Read and write access to a single block geometry.

Definition at line 136 of file superGeometry.hh.

{
  _statistics.getStatisticsStatus() = true;
  return *_block[locIC];
}

Here is the caller graph for this function:

getBlockGeometry() [2/2]

template<typename T , unsigned D>

BlockGeometry< T, D > const & olb::SuperGeometry< T, D >::getBlockGeometry

(

int

locIC

)

const

Read only access to a single block geometry.

Definition at line 143 of file superGeometry.hh.

{
  return *_block[locIC];
}

getMaterialIndicator() [1/2]

template<typename T , unsigned D>

std::unique_ptr< SuperIndicatorF< T, D > > olb::SuperGeometry< T, D >::getMaterialIndicator

(

int

material

)

Returns a material indicator using a single material number.

Parameters

material

Material to be indicated

Returns

Unique ownership of the constructed indicator. May be stored or passed directly to e.g. defineDynamics

Definition at line 488 of file superGeometry.hh.

{
  return this->getMaterialIndicator(std::vector<int> { material });
}

getMaterialIndicator() [2/2]

template<typename T , unsigned D>

std::unique_ptr< SuperIndicatorF< T, D > > olb::SuperGeometry< T, D >::getMaterialIndicator

(

std::vector< int > &&

materials

)

Returns a material indicator using the given vector of materials.

Parameters

materials

Materials to be indicated

Returns

Unique ownership of the constructed indicator. May be stored or passed directly to e.g. defineDynamics

Definition at line 476 of file superGeometry.hh.

{
  static_assert(std::is_base_of<SuperIndicatorF<T,D>, SuperIndicatorMaterial<T,D>>::value,
                "Indicator to be constructed is SuperIndicatorF implementation");
 
  return std::unique_ptr<SuperIndicatorF<T,D>>(
           new SuperIndicatorMaterial<T,D>(*this, std::forward<std::vector<int>>(materials))
         );
}

Here is the caller graph for this function:

getNblock()

template<typename T , unsigned D>

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

overridevirtual

Number of data blocks for the serializable interface.

Implements olb::Serializable.

Definition at line 494 of file superGeometry.hh.

{
  return std::accumulate(_block.begin(), _block.end(), size_t(0), [](std::size_t sum, auto& b) -> std::size_t {
    return sum + b->getNblock();
  });
}

getPhysR() [1/2]

template<typename T , unsigned D>

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

(

LatticeR< D+1 >

latticeR

)

const

Transforms a lattice to physical position (SI units)

Definition at line 123 of file superGeometry.hh.

{
  return this->_cuboidDecomposition.getPhysR(latticeR);
}

getPhysR() [2/2]

template<typename T , unsigned D>

void olb::SuperGeometry< T, D >::getPhysR	(	T	output[D],
		const int	latticeR[D+1] ) const

Transforms a lattice to physical position (SI units)

Definition at line 129 of file superGeometry.hh.

{
  auto physR = this->_cuboidDecomposition.getPhysR(latticeR);
  std::copy(physR.data(), physR.data() + D, output);
}

getSerializableSize()

template<typename T , unsigned D>

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

overridevirtual

Binary size for the serializer.

Implements olb::Serializable.

Definition at line 503 of file superGeometry.hh.

{
  return std::accumulate(_block.begin(), _block.end(), size_t(0), [](std::size_t sum, auto& b) -> std::size_t {
    return sum + b->getSerializableSize();
  });
}

getStatistics() [1/2]

template<typename T , unsigned D>

SuperGeometryStatistics< T, D > & olb::SuperGeometry< T, D >::getStatistics

(

)

Returns the statistics object.

Definition at line 164 of file superGeometry.hh.

{
  if (this->_communicationNeeded) {
    this->communicate();
    getStatisticsStatus()=true;
  }
  return _statistics;
}

Here is the caller graph for this function:

getStatistics() [2/2]

template<typename T , unsigned D>

const SuperGeometryStatistics< T, D > & olb::SuperGeometry< T, D >::getStatistics

(

)

const

Returns the statistics object (readonly)

Definition at line 174 of file superGeometry.hh.

{
  return _statistics;
}

getStatisticsStatus() [1/2]

template<typename T , unsigned D>

bool & olb::SuperGeometry< T, D >::getStatisticsStatus

(

)

Read and write access to the statistic status flag, update needed = true.

Definition at line 180 of file superGeometry.hh.

{
  return _statistics.getStatisticsStatus();
}

getStatisticsStatus() [2/2]

template<typename T , unsigned D>

bool const & olb::SuperGeometry< T, D >::getStatisticsStatus

(

)

const

Read only access to the statistic status flag, update needed = true.

Definition at line 186 of file superGeometry.hh.

{
  return _statistics.getStatisticsStatus();
}

getWriteIncrementalVTKState()

template<typename T , unsigned D>

bool olb::SuperGeometry< T, D >::getWriteIncrementalVTKState ( )

inline

Definition at line 174 of file superGeometry.h.

  {
    return _writeIncrementalVtkEnabled;
  }

Here is the caller graph for this function:

innerClean() [1/2]

template<typename T , unsigned D>

int olb::SuperGeometry< T, D >::innerClean

(

bool

verbose = true

)

inner cleaning for all boundary types

Definition at line 248 of file superGeometry.hh.

{
  this->communicate();
  int counter=0;
  for (unsigned iC=0; iC<_block.size(); iC++) {
    counter+=_block[iC]->innerClean(false);
  }
#ifdef PARALLEL_MODE_MPI
  singleton::mpi().barrier();
  singleton::mpi().reduceAndBcast(counter, MPI_SUM);
#endif
 
  if (verbose) {
    _clout << "cleaned "<< counter << " inner boundary voxel(s)" << std::endl;
  }
  _statistics.getStatisticsStatus() = true;
  this->_communicationNeeded = true;
  writeIncrementalVTK();
  return counter;
}

References olb::singleton::MpiManager::barrier(), olb::singleton::mpi(), and olb::singleton::MpiManager::reduceAndBcast().

Here is the call graph for this function:

innerClean() [2/2]

template<typename T , unsigned D>

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

inner cleaning for specific boundary types

Definition at line 270 of file superGeometry.hh.

{
  this->communicate();
  int counter=0;
  for (unsigned iC=0; iC<_block.size(); iC++) {
    counter+=_block[iC]->innerClean(bcType,false);
  }
#ifdef PARALLEL_MODE_MPI
  singleton::mpi().reduceAndBcast(counter, MPI_SUM);
#endif
 
  if (verbose) {
    _clout << "cleaned "<< counter << " inner boundary voxel(s) of Type " << bcType << std::endl;
  }
  _statistics.getStatisticsStatus() = true;
  this->_communicationNeeded = true;
  writeIncrementalVTK();
  return counter;
}

References olb::singleton::mpi(), and olb::singleton::MpiManager::reduceAndBcast().

Here is the call graph for this function:

outerClean()

template<typename T , unsigned D>

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

Removes not needed fluid cells from the outer domain.

Definition at line 227 of file superGeometry.hh.

{
  this->communicate();
  int counter=0;
  for (unsigned iC=0; iC<_block.size(); iC++) {
    counter+=_block[iC]->outerClean(false, bulkMaterials);
  }
#ifdef PARALLEL_MODE_MPI
  singleton::mpi().reduceAndBcast(counter, MPI_SUM);
#endif
 
  if (verbose) {
    _clout << "cleaned "<< counter << " outer fluid voxel(s)" << std::endl;
  }
  _statistics.getStatisticsStatus() = true;
  this->_communicationNeeded = true;
  writeIncrementalVTK();
  return counter;
}

References olb::singleton::mpi(), and olb::singleton::MpiManager::reduceAndBcast().

Here is the call graph for this function:

print() [1/2]

template<typename T , unsigned D>

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

(

)

Prints some information about the super geometry.

Definition at line 435 of file superGeometry.hh.

{
  this->_cuboidDecomposition.print();
  getStatistics().print();
}

print() [2/2]

template<typename T , unsigned D>

void olb::SuperGeometry< T, D >::print	(	const T	physR[D],
		int	offset )

Definition at line 443 of file superGeometry.hh.

{
    if (offset >= this->_overlap) {
      _clout << "Warning! the offset is larger than overlap, set offset to _overlap = " << this->_overlap << std::endl;
      offset=this->_overlap;
    }
    int latticeR[D+1];
 
    if ( this->_cuboidDecomposition.getLatticeR(latticeR, physR) ) {
      int iCglob = latticeR[0];
 
      std::vector<int> loc(D, 0);
      if constexpr (D==3) {
        loc[0] = latticeR[1];
        loc[1] = latticeR[2];
        loc[2] = latticeR[3];
        _clout << "physR(center)" << "=" << "{" << latticeR[1] << "," << latticeR[2] << "," << latticeR[3] << "}" << std::endl;
      }
      else {
        loc[0] = latticeR[1];
        loc[1] = latticeR[2];
        _clout << "physR(center)" << "=" << "{" << latticeR[1] << "," << latticeR[2] << "}" << std::endl;
      }
 
      _block[this->getLoadBalancer().loc(iCglob)]->printNode(loc,offset);
 
    }
    else {
      _clout << "this point isn't inside the geometry" << std::endl;
    }
}

rename() [1/6]

template<typename T , unsigned D>

void olb::SuperGeometry< T, D >::rename	(	int	fromBcMat,
		int	toBcMat,
		int	fluidMat,
		FunctorPtr< IndicatorF< T, D > > &&	condition )

renames all boundary voxels of material fromBcMat to toBcMat if two neighbour voxel in the direction of the discrete normal are fluid voxel with material fluidM in the region where the indicator function is fulfilled

Definition at line 413 of file superGeometry.hh.

{
  if (this->_overlap>1) {
    _communicator->communicate();
    rename(fromBcMat, toBcMat, *condition);
    Vector<int,D> testDirection = this->getStatistics().computeDiscreteNormal(toBcMat);
    _communicator->communicate();
    for (unsigned iC=0; iC<_block.size(); iC++) {
      _block[iC]->rename(fromBcMat,toBcMat,fluidMat,*condition,testDirection);
    }
    _statistics.getStatisticsStatus() = true;
    this->_communicationNeeded = true;
    writeIncrementalVTK();
  }
  else {
    _clout << "error rename only implemented for overlap>=2" << std::endl;
  }
}

rename() [2/6]

template<typename T , unsigned D>

void olb::SuperGeometry< T, D >::rename	(	int	fromBcMat,
		int	toBcMat,
		int	fluidMat,
		IndicatorF< T, D > &	condition )

renames all boundary voxels of material fromBcMat to toBcMat if two neighbour voxel in the direction of the discrete normal are fluid voxel with material fluidM in the region where the indicator function is fulfilled

Definition at line 392 of file superGeometry.hh.

{
  if (this->_overlap>1) {
    this->communicate();
    rename(fromBcMat, toBcMat, condition);
    Vector<int,D> testDirection = this->getStatistics().computeDiscreteNormal(toBcMat);
    this->communicate();
    for (unsigned iC=0; iC < _block.size(); iC++) {
      _block[iC]->rename(fromBcMat,toBcMat,fluidMat,condition,testDirection);
    }
    _statistics.getStatisticsStatus() = true;
    this->_communicationNeeded = true;
    writeIncrementalVTK();
  }
  else {
    _clout << "error rename only implemented for overlap>=2" << std::endl;
  }
}

rename() [3/6]

template<typename T , unsigned D>

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

replace one material with another

Definition at line 324 of file superGeometry.hh.

{
  this->communicate();
  for (unsigned iC=0; iC<_block.size(); iC++) {
    _block[iC]->rename(fromM,toM);
  }
  _statistics.getStatisticsStatus() = true;
  this->_communicationNeeded = true;
  writeIncrementalVTK();
}

Here is the caller graph for this function:

rename() [4/6]

template<typename T , unsigned D>

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

replace one material that fulfills an indicator functor condition with another

Definition at line 336 of file superGeometry.hh.

{
  this->communicate();
  for (unsigned iC=0; iC<_block.size(); iC++) {
    _block[iC]->rename(fromM,toM,*condition);
  }
  _statistics.getStatisticsStatus() = true;
  writeIncrementalVTK();
}

rename() [5/6]

template<typename T , unsigned D>

void olb::SuperGeometry< T, D >::rename	(	int	fromM,
		int	toM,
		int	testM,
		Vector< int, D >	testDirection )

renames all voxels of material fromM to toM if the number of voxels given by testDirection is of material testM

Definition at line 364 of file superGeometry.hh.

{
  if ( testDirection[0]*testDirection[0]<=(this->_overlap)*(this->_overlap)
        && testDirection[1]*testDirection[1]<=(this->_overlap)*(this->_overlap)  ){
    if constexpr (D==3){
      if(testDirection[2]*testDirection[2]<=(this->_overlap)*(this->_overlap)){
        _communicator->communicate();
        for (unsigned iC=0; iC<_block.size(); iC++) {
          _block[iC]->rename(fromM,toM,testM,testDirection);
        }
        _statistics.getStatisticsStatus() = true;
        this->_communicationNeeded = true;
      }
    }else{
      _communicator->communicate();
      for (unsigned iC=0; iC<_block.size(); iC++) {
        _block[iC]->rename(fromM,toM,testM,testDirection);
      }
      _statistics.getStatisticsStatus() = true;
      this->_communicationNeeded = true;
    }
    writeIncrementalVTK();
  } else {
    _clout << "error rename only implemented for |testDirection[i]|<=overlap" << std::endl;
  }
}

rename() [6/6]

template<typename T , unsigned D>

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

replace one material with another respecting an offset (overlap)

Definition at line 347 of file superGeometry.hh.

{
  LatticeR<D> overlap (this->_overlap);
  if ( offset <= overlap ){
    _communicator->communicate();
    for (unsigned iC=0; iC<_block.size(); iC++) {
      _block[iC]->rename(fromM,toM,offset);
    }
    _statistics.getStatisticsStatus() = true;
    this->_communicationNeeded = true;
    writeIncrementalVTK();
  }else{
    _clout << "error rename only implemented for offset<=overlap" << std::endl;
  }
}

reset()

template<typename T , unsigned D>

void olb::SuperGeometry< T, D >::reset

(

IndicatorF< T, D > &

domain

)

reset all cell materials inside of a domain to 0

Definition at line 312 of file superGeometry.hh.

{
  this->communicate();
  for (unsigned iC = 0; iC < _block.size(); ++iC) {
    _block[iC]->reset(domain);
  }
  _statistics.getStatisticsStatus() = true;
  this->_communicationNeeded = true;
  writeIncrementalVTK();
}

setWriteIncrementalVTK()

template<typename T , unsigned D>

void olb::SuperGeometry< T, D >::setWriteIncrementalVTK ( bool state )

inline

Toggles whether geometry should be written out as VTK after every modification.

Definition at line 171 of file superGeometry.h.

                                          {
    _writeIncrementalVtkEnabled = state;
  }

Here is the caller graph for this function:

updateStatistics()

template<typename T , unsigned D>

void olb::SuperGeometry< T, D >::updateStatistics

(

bool

verbose = true

)

Updates the super geometry at the boundaries if needed and afterwards the statisics if needed.

Definition at line 192 of file superGeometry.hh.

{
  if (this->_communicationNeeded) {
    this->communicate();
    getStatisticsStatus()=true;
  }
  _statistics.update(verbose);
  for (unsigned iC=0; iC<_block.size(); iC++) {
    _block[iC]->getStatistics().update(verbose);
  }
}

Here is the caller graph for this function:

Member Data Documentation

d

template<typename T , unsigned D>

unsigned olb::SuperGeometry< T, D >::d = D

staticconstexpr

Definition at line 90 of file superGeometry.h.

---

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

• src/core/superLattice2D.h
• src/functors/analytical/frameChangeF3D.h
• src/functors/lattice/indicator/superIndicatorBaseF2D.h
• src/functors/lattice/indicator/superIndicatorBaseF3D.h
• src/functors/lattice/integral/superLpNorm2D.h
• src/functors/lattice/integral/superLpNorm3D.h
• src/functors/lattice/latticeDiscreteNormal2D.h
• src/functors/lattice/latticeGeometry2D.h
• src/geometry/superGeometry.h
• src/geometry/superGeometryStatistics2D.h
• src/geometry/superGeometryStatistics3D.h
• src/geometry/superGeometry.hh