olb::SuperGeometryStatistics2D< T > Class Template Reference

#include <superGeometryStatistics2D.h>

Collaboration diagram for olb::SuperGeometryStatistics2D< T >:

Public Member Functions
	SuperGeometryStatistics2D (SuperGeometry< T, 2 > *superGeometry)
	Constructor.
	SuperGeometryStatistics2D (SuperGeometryStatistics2D const &rhs)
	Copy constructor.
SuperGeometryStatistics2D< T > &	operator= (SuperGeometryStatistics2D const &rhs)
	Copy assignment.
bool &	getStatisticsStatus ()
	Read and write access to a flag, which indicates if an uptate is needed (=true)
bool const &	getStatisticsStatus () const
	Read only access to a flag, which indicates if an uptate is needed (=true)
void	update (bool verbose=false)
	Updates the statistics if it is really needed.
int	getNmaterials ()
	Returns the number of different materials.
int	getNmaterials () const
int	getNvoxel (int material)
	Returns the number of voxels for a given material number.
int	getNvoxel (int material) const
int	getNvoxel ()
	Returns the number of voxels with material!=0.
int	getNvoxel () const
std::vector< T >	getMinPhysR (int material)
	Returns the min. phys position in each direction.
std::vector< T >	getMinPhysR (int material) const
std::vector< T >	getMaxPhysR (int material)
	Returns the max. phys position in each direction.
std::vector< T >	getMaxPhysR (int material) const
std::vector< T >	getPhysExtend (int material)
	Returns the phys extend as length in each direction.
std::vector< T >	getPhysExtend (int material) const
std::vector< T >	getPhysRadius (int material)
	Returns the phys radius as length in each direction.
std::vector< T >	getPhysRadius (int material) const
std::vector< T >	getCenterPhysR (int material)
	Returns the center position.
std::vector< T >	getCenterPhysR (int material) const
std::vector< int >	getType (int iC, int iX, int iY)
	Returns the boundary type which is characterized by a discrte normal (c.f. Zimny)
std::vector< int >	getType (int iC, int iX, int iY) const
std::vector< T >	computeNormal (int material)
	Returns normal that points into the fluid for paraxial surfaces.
std::vector< T >	computeNormal (int material) const
std::vector< int >	computeDiscreteNormal (int material, T maxNorm=1.1)
	Returns discrete normal with norm maxNorm that points into the fluid for paraxial surfaces maxNorm=1.1 implies only normals parallel to the axises.
std::vector< int >	computeDiscreteNormal (int material, T maxNorm=1.1) const
void	print ()
	Prints some statistic information, i.e. the number of voxels and min. max. physical position for each different material.
void	print () const

Detailed Description

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

Definition at line 56 of file superGeometryStatistics2D.h.

Constructor & Destructor Documentation

SuperGeometryStatistics2D() [1/2]

template<typename T >

olb::SuperGeometryStatistics2D< T >::SuperGeometryStatistics2D

(

SuperGeometry< T, 2 > *

superGeometry

)

Constructor.

Definition at line 40 of file superGeometryStatistics2D.hh.

  : _superGeometry(superGeometry), _statisticsUpdateNeeded(true), clout(std::cout,"SuperGeometryStatistics2D")
{
}

SuperGeometryStatistics2D() [2/2]

template<typename T >

olb::SuperGeometryStatistics2D< T >::SuperGeometryStatistics2D

(

SuperGeometryStatistics2D< T > const &

rhs

)

Copy constructor.

Definition at line 46 of file superGeometryStatistics2D.hh.

  : _superGeometry(rhs._superGeometry), _statisticsUpdateNeeded(true),
    clout(std::cout,"SuperGeometryStatistics2D")
{
}

Member Function Documentation

computeDiscreteNormal() [1/2]

template<typename T >

std::vector< int > olb::SuperGeometryStatistics2D< T >::computeDiscreteNormal	(	int	material,
		T	maxNorm = 1.1 )

Returns discrete normal with norm maxNorm that points into the fluid for paraxial surfaces maxNorm=1.1 implies only normals parallel to the axises.

Definition at line 439 of file superGeometryStatistics2D.hh.

{
  update();
  return const_this->computeDiscreteNormal(material, maxNorm);
}

computeDiscreteNormal() [2/2]

template<typename T >

std::vector< int > olb::SuperGeometryStatistics2D< T >::computeDiscreteNormal	(	int	material,
		T	maxNorm = 1.1 ) const

Definition at line 446 of file superGeometryStatistics2D.hh.

{
  std::vector<T> normal = computeNormal(material);
  std::vector<int> discreteNormal(2,int(0));
 
  T smallestAngle = T(0);
  for (int iX = -1; iX<=1; iX++) {
    for (int iY = -1; iY<=1; iY++) {
      T norm = util::sqrt(iX*iX+iY*iY);
      if (norm>0.&& norm<maxNorm) {
        T angle = (iX*normal[0] + iY*normal[1])/norm;
        if (angle>=smallestAngle) {
          smallestAngle=angle;
          discreteNormal[0] = iX;
          discreteNormal[1] = iY;
        }
      }
    }
  }
  return discreteNormal;
}

References olb::norm(), and olb::util::sqrt().

Here is the call graph for this function:

computeNormal() [1/2]

template<typename T >

std::vector< T > olb::SuperGeometryStatistics2D< T >::computeNormal

(

int

material

)

Returns normal that points into the fluid for paraxial surfaces.

Definition at line 398 of file superGeometryStatistics2D.hh.

{
  update();
  return const_this->computeNormal(material);
}

computeNormal() [2/2]

template<typename T >

std::vector< T > olb::SuperGeometryStatistics2D< T >::computeNormal

(

int

material

)

const

Definition at line 405 of file superGeometryStatistics2D.hh.

{
  std::vector<T> normal (2,int());
  for (int iCloc=0; iCloc<_superGeometry->getLoadBalancer().size(); iCloc++) {
    for (int iDim=0; iDim<2; iDim++) {
      if (_superGeometry->getBlockGeometry(iCloc).getStatistics().getNvoxel(material)!=0) {
        normal[iDim] += _superGeometry->getBlockGeometry(iCloc).getStatistics().computeNormal(material)[iDim]*_superGeometry->getBlockGeometry(iCloc).getStatistics().getNvoxel(material);
      }
    }
  }
 
#ifdef PARALLEL_MODE_MPI
  for (int iDim=0; iDim<2; iDim++) {
    singleton::mpi().reduceAndBcast((normal[iDim]), MPI_SUM);
  }
#endif
 
  int nVoxel = getNvoxel(material);
  if (nVoxel != 0) {
    for (int iDim=0; iDim<2; iDim++) {
      normal[iDim] /= nVoxel;
    }
  }
  OLB_ASSERT(nVoxel || (normal[0] == 0 && normal[1] == 0), "if no voxels found we expect the normal to be zero");
 
  T norm = util::sqrt(normal[0]*normal[0]+normal[1]*normal[1]);
  if (norm>0.) {
    normal[0]/=norm;
    normal[1]/=norm;
  }
  return normal;
}

References olb::singleton::mpi(), olb::norm(), OLB_ASSERT, olb::singleton::MpiManager::reduceAndBcast(), and olb::util::sqrt().

Here is the call graph for this function:

getCenterPhysR() [1/2]

template<typename T >

std::vector< T > olb::SuperGeometryStatistics2D< T >::getCenterPhysR

(

int

material

)

Returns the center position.

Definition at line 367 of file superGeometryStatistics2D.hh.

{
  update();
  return const_this->getCenterPhysR(material);
}

getCenterPhysR() [2/2]

template<typename T >

std::vector< T > olb::SuperGeometryStatistics2D< T >::getCenterPhysR

(

int

material

)

const

Definition at line 374 of file superGeometryStatistics2D.hh.

{
  std::vector<T> center;
  for (int iDim=0; iDim<2; iDim++) {
    center.push_back(getMinPhysR(material)[iDim] + getPhysRadius(material)[iDim]);
  }
  return center;
}

getMaxPhysR() [1/2]

template<typename T >

std::vector< T > olb::SuperGeometryStatistics2D< T >::getMaxPhysR

(

int

material

)

Returns the max. phys position in each direction.

Definition at line 310 of file superGeometryStatistics2D.hh.

{
  update();
  return const_this->getMaxPhysR(material);
}

getMaxPhysR() [2/2]

template<typename T >

std::vector< T > olb::SuperGeometryStatistics2D< T >::getMaxPhysR

(

int

material

)

const

Definition at line 317 of file superGeometryStatistics2D.hh.

{
  try {
    return _material2max.at(material);
  }
  catch (std::out_of_range& ex) {
    return {0, 0};
  }
}

getMinPhysR() [1/2]

template<typename T >

std::vector< T > olb::SuperGeometryStatistics2D< T >::getMinPhysR

(

int

material

)

Returns the min. phys position in each direction.

Definition at line 292 of file superGeometryStatistics2D.hh.

{
  update();
  return const_this->getMinPhysR(material);
}

getMinPhysR() [2/2]

template<typename T >

std::vector< T > olb::SuperGeometryStatistics2D< T >::getMinPhysR

(

int

material

)

const

Definition at line 299 of file superGeometryStatistics2D.hh.

{
  try {
    return _material2min.at(material);
  }
  catch (std::out_of_range& ex) {
    return {0, 0};
  }
}

getNmaterials() [1/2]

template<typename T >

int olb::SuperGeometryStatistics2D< T >::getNmaterials

(

)

Returns the number of different materials.

Definition at line 242 of file superGeometryStatistics2D.hh.

{
  update();
  return const_this->getNmaterials();
}

getNmaterials() [2/2]

template<typename T >

int olb::SuperGeometryStatistics2D< T >::getNmaterials

(

)

const

Definition at line 249 of file superGeometryStatistics2D.hh.

{
  return _nMaterials;
}

getNvoxel() [1/4]

template<typename T >

int olb::SuperGeometryStatistics2D< T >::getNvoxel

(

)

Returns the number of voxels with material!=0.

Definition at line 273 of file superGeometryStatistics2D.hh.

{
  update();
  return const_this->getNvoxel();
}

getNvoxel() [2/4]

template<typename T >

int olb::SuperGeometryStatistics2D< T >::getNvoxel

(

)

const

Definition at line 280 of file superGeometryStatistics2D.hh.

{
  int total = 0;
  for (const auto& material : _material2n) {
    if (material.first!=0) {
      total+=material.second;
    }
  }
  return total;
}

getNvoxel() [3/4]

template<typename T >

int olb::SuperGeometryStatistics2D< T >::getNvoxel

(

int

material

)

Returns the number of voxels for a given material number.

Definition at line 255 of file superGeometryStatistics2D.hh.

{
  update(true);
  return const_this->getNvoxel(material);
}

getNvoxel() [4/4]

template<typename T >

int olb::SuperGeometryStatistics2D< T >::getNvoxel

(

int

material

)

const

Definition at line 262 of file superGeometryStatistics2D.hh.

{
  try {
    return _material2n.at(material);
  }
  catch (std::out_of_range& ex) {
    return 0;
  }
}

getPhysExtend() [1/2]

template<typename T >

std::vector< T > olb::SuperGeometryStatistics2D< T >::getPhysExtend

(

int

material

)

Returns the phys extend as length in each direction.

Definition at line 328 of file superGeometryStatistics2D.hh.

{
  update();
  return const_this->getPhysExtend(material);
}

getPhysExtend() [2/2]

template<typename T >

std::vector< T > olb::SuperGeometryStatistics2D< T >::getPhysExtend

(

int

material

)

const

Definition at line 335 of file superGeometryStatistics2D.hh.

{
  try {
    std::vector<T> extend;
    for (int iDim = 0; iDim < 2; iDim++) {
      extend.push_back(_material2max.at(material)[iDim] - _material2min.at(material)[iDim]);
    }
    return extend;
  }
  catch (std::out_of_range& ex) {
    return std::vector<T> {};
  }
}

getPhysRadius() [1/2]

template<typename T >

std::vector< T > olb::SuperGeometryStatistics2D< T >::getPhysRadius

(

int

material

)

Returns the phys radius as length in each direction.

Definition at line 350 of file superGeometryStatistics2D.hh.

{
  update();
  return const_this->getPhysRadius(material);
}

getPhysRadius() [2/2]

template<typename T >

std::vector< T > olb::SuperGeometryStatistics2D< T >::getPhysRadius

(

int

material

)

const

Definition at line 357 of file superGeometryStatistics2D.hh.

{
  std::vector<T> radius;
  for (int iDim=0; iDim<2; iDim++) {
    radius.push_back((getMaxPhysR(material)[iDim] - getMinPhysR(material)[iDim])/2.);
  }
  return radius;
}

getStatisticsStatus() [1/2]

template<typename T >

bool & olb::SuperGeometryStatistics2D< T >::getStatisticsStatus

(

)

Read and write access to a flag, which indicates if an uptate is needed (=true)

Definition at line 62 of file superGeometryStatistics2D.hh.

{
  return _statisticsUpdateNeeded;
}

getStatisticsStatus() [2/2]

template<typename T >

bool const & olb::SuperGeometryStatistics2D< T >::getStatisticsStatus

(

)

const

Read only access to a flag, which indicates if an uptate is needed (=true)

Definition at line 68 of file superGeometryStatistics2D.hh.

{
  return _statisticsUpdateNeeded;
}

getType() [1/2]

template<typename T >

std::vector< int > olb::SuperGeometryStatistics2D< T >::getType	(	int	iC,
		int	iX,
		int	iY )

Returns the boundary type which is characterized by a discrte normal (c.f. Zimny)

Definition at line 384 of file superGeometryStatistics2D.hh.

{
  return const_this->getType(iC, iX, iY);
}

getType() [2/2]

template<typename T >

std::vector< int > olb::SuperGeometryStatistics2D< T >::getType	(	int	iC,
		int	iX,
		int	iY ) const

Definition at line 390 of file superGeometryStatistics2D.hh.

{
  int iCloc=_superGeometry->getLoadBalancer().loc(iC);
  std::vector<int> discreteNormal = _superGeometry->getBlockGeometry(iCloc).getStatistics().getType(iX, iY);
  return discreteNormal;
}

operator=()

template<typename T >

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

(

SuperGeometryStatistics2D< T > const &

rhs

)

Copy assignment.

Definition at line 53 of file superGeometryStatistics2D.hh.

{
  _superGeometry = rhs._superGeometry;
  _statisticsUpdateNeeded = true;
  return *this;
}

print() [1/2]

template<typename T >

void olb::SuperGeometryStatistics2D< T >::print

(

)

Prints some statistic information, i.e. the number of voxels and min. max. physical position for each different material.

Definition at line 469 of file superGeometryStatistics2D.hh.

{
  update();
  return const_this->print();
}

print() [2/2]

template<typename T >

void olb::SuperGeometryStatistics2D< T >::print

(

)

const

Definition at line 476 of file superGeometryStatistics2D.hh.

{
  for (const auto& material : _material2n) {
    clout << "materialNumber=" << material.first
          << "; count=" << material.second
          << "; minPhysR=(" << _material2min.at(material.first)[0] <<","<< _material2min.at(material.first)[1] <<")"
          << "; maxPhysR=(" << _material2max.at(material.first)[0] <<","<< _material2max.at(material.first)[1] <<")"
          << std::endl;
  }
}

update()

template<typename T >

void olb::SuperGeometryStatistics2D< T >::update

(

bool

verbose = false

)

Updates the statistics if it is really needed.

Definition at line 75 of file superGeometryStatistics2D.hh.

{
  const_this = const_cast<const SuperGeometryStatistics2D<T>*>(this);
 
#ifdef PARALLEL_MODE_MPI
  int updateReallyNeededGlobal = 0;
  if (_statisticsUpdateNeeded ) {
    updateReallyNeededGlobal = 1;
  }
  singleton::mpi().reduceAndBcast(updateReallyNeededGlobal, MPI_SUM);
  if (updateReallyNeededGlobal>0) {
    _statisticsUpdateNeeded = true;
  }
  //singleton::mpi().reduceAndBcast(_statisticsUpdateNeeded, MPI_LOR);
#endif
 
  // check if update is really needed
  if (_statisticsUpdateNeeded ) {
    int updateReallyNeeded = 0;
    for (int iCloc=0; iCloc<_superGeometry->getLoadBalancer().size(); iCloc++) {
      if (_superGeometry->getBlockGeometry(iCloc).getStatistics().getStatisticsStatus() ) {
        auto& blockGeometry = const_cast<BlockGeometry<T,2>&>(_superGeometry->getBlockGeometry(iCloc));
        blockGeometry.getStatistics().update(false);
        updateReallyNeeded++;
      }
    }
 
 
#ifdef PARALLEL_MODE_MPI
    singleton::mpi().reduceAndBcast(updateReallyNeeded, MPI_SUM);
#endif
 
    if (updateReallyNeeded==0) {
      _statisticsUpdateNeeded = false;
      //      clout << "almost updated" << std::endl;
      return;
    }
 
 
    // get total number of different materials right
    _nMaterials = int();
    {
      std::set<int> tmpMaterials{};
      for (int iCloc=0; iCloc<_superGeometry->getLoadBalancer().size(); iCloc++) {
        const auto& blockMaterial2n = _superGeometry->getBlockGeometry(iCloc).getStatistics().getMaterial2n();
        for (auto [material, _] : blockMaterial2n) {
          tmpMaterials.insert(material);
        }
      }
      _nMaterials = tmpMaterials.size();
    }
 
    _material2n = std::map<int, int>();
 
#ifdef PARALLEL_MODE_MPI
    singleton::mpi().reduceAndBcast(_nMaterials, MPI_SUM);
#endif
 
    // store the number and min., max. possition for each rank
    for (int iCloc=0; iCloc<_superGeometry->getLoadBalancer().size(); iCloc++) {
      std::map<int, int> material2n = _superGeometry->getBlockGeometry(iCloc).getStatistics().getMaterial2n();
      std::map<int, int>::iterator iter;
 
      for (iter = material2n.begin(); iter != material2n.end(); iter++) {
        if (iter->second!=0) {
          std::vector<T> minPhysR = _superGeometry->getBlockGeometry(iCloc).getStatistics().getMinPhysR(iter->first);
          std::vector<T> maxPhysR = _superGeometry->getBlockGeometry(iCloc).getStatistics().getMaxPhysR(iter->first);
          if (_material2n.count(iter->first) == 0) {
            _material2n[iter->first] = iter->second;
            _material2min[iter->first] = minPhysR;
            _material2max[iter->first] = maxPhysR;
            //std::cout << iter->first<<":"<<_material2n[iter->first]<<std::endl;
          }
          else {
            _material2n[iter->first] += iter->second;
            for (int iDim=0; iDim<2; iDim++) {
              if (_material2min[iter->first][iDim] > minPhysR[iDim]) {
                _material2min[iter->first][iDim] = minPhysR[iDim];
              }
              if (_material2max[iter->first][iDim] < maxPhysR[iDim]) {
                _material2max[iter->first][iDim] = maxPhysR[iDim];
              }
            }
            //std::cout << iter->first<<":"<<_material2n[iter->first]<<std::endl;
          }
        }
      }
    }
 
    // store the number and min., max. possition for all ranks
#ifdef PARALLEL_MODE_MPI
    int materials[_nMaterials];
    int materialsInBuf[_nMaterials];
    int materialCount[_nMaterials];
    int materialCountInBuf[_nMaterials];
    T materialMinR[2*_nMaterials];
    T materialMaxR[2*_nMaterials];
    T materialMinRinBuf[2*_nMaterials];
    T materialMaxRinBuf[2*_nMaterials];
 
    for (int iM=0; iM<_nMaterials; iM++) {
      materials[iM]=-1;
      materialCount[iM]=0;
      for (int iDim=0; iDim<2; iDim++) {
        materialMinRinBuf[2*iM + iDim] = T();
        materialMaxRinBuf[2*iM + iDim] = T();
      }
    }
    int counter = 0;
    std::map<int, int>::iterator iMaterial;
    for (iMaterial = _material2n.begin(); iMaterial != _material2n.end(); iMaterial++) {
      materials[counter] = iMaterial->first;
      materialCount[counter] = iMaterial->second;
      for (int iDim=0; iDim<2; iDim++) {
        materialMinR[2*counter + iDim] = _material2min[iMaterial->first][iDim];
        materialMaxR[2*counter + iDim] = _material2max[iMaterial->first][iDim];
      }
      counter++;
    }
 
    for (int iRank=1; iRank<singleton::mpi().getSize(); iRank++) {
      int myRank = singleton::mpi().getRank();
      singleton::mpi().sendRecv(materials, materialsInBuf, _nMaterials, (myRank+iRank)%singleton::mpi().getSize(), (myRank-iRank+singleton::mpi().getSize())%singleton::mpi().getSize(), 0);
      singleton::mpi().sendRecv(materialCount, materialCountInBuf, _nMaterials, (myRank+iRank)%singleton::mpi().getSize(), (myRank-iRank+singleton::mpi().getSize())%singleton::mpi().getSize(), 1);
      singleton::mpi().sendRecv(materialMinR, materialMinRinBuf, 2*_nMaterials, (myRank+iRank)%singleton::mpi().getSize(), (myRank-iRank+singleton::mpi().getSize())%singleton::mpi().getSize(), 2);
      singleton::mpi().sendRecv(materialMaxR, materialMaxRinBuf, 2*_nMaterials, (myRank+iRank)%singleton::mpi().getSize(), (myRank-iRank+singleton::mpi().getSize())%singleton::mpi().getSize(), 2);
      for (int iM=0; iM<_nMaterials; iM++) {
        if (materialsInBuf[iM]!=-1) {
          std::vector<T> minPhysR(2,T());
          std::vector<T> maxPhysR(2,T());
          for (int iDim=0; iDim<2; iDim++) {
            minPhysR[iDim] = materialMinRinBuf[2*iM + iDim];
            maxPhysR[iDim] = materialMaxRinBuf[2*iM + iDim];
          }
          if (_material2n.count(materialsInBuf[iM]) == 0) {
            _material2n[materialsInBuf[iM]] = materialCountInBuf[iM];
            _material2min[materialsInBuf[iM]] = minPhysR;
            _material2max[materialsInBuf[iM]] = maxPhysR;
          }
          else {
            _material2n[materialsInBuf[iM]] += materialCountInBuf[iM];
            for (int iDim=0; iDim<2; iDim++) {
              if (_material2min[materialsInBuf[iM]][iDim] > minPhysR[iDim]) {
                _material2min[materialsInBuf[iM]][iDim] = minPhysR[iDim];
              }
              if (_material2max[materialsInBuf[iM]][iDim] < maxPhysR[iDim]) {
                _material2max[materialsInBuf[iM]][iDim] = maxPhysR[iDim];
              }
            }
          }
        }
      }
    }
#endif
 
    //clout.setMultiOutput(true);
    //print();
    //clout.setMultiOutput(false);
 
    if (verbose) {
      clout << "updated" << std::endl;
    }
    _statisticsUpdateNeeded = false;
  }
}

References olb::singleton::MpiManager::getRank(), olb::singleton::MpiManager::getSize(), olb::BlockGeometry< T, D >::getStatistics(), olb::singleton::mpi(), olb::singleton::MpiManager::reduceAndBcast(), and olb::singleton::MpiManager::sendRecv().

Here is the call graph for this function:

---

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

• src/geometry/superGeometryStatistics2D.h
• src/geometry/superGeometryStatistics2D.hh