blockGeometryStatistics3D.h

Go to the documentation of this file.

/*  This file is part of the OpenLB library
 *
 *  Copyright (C) 2011, 2014 Mathias J. Krause, Simon Zimny
 *  E-mail contact: info@openlb.net
 *  The most recent release of OpenLB can be downloaded at
 *  <http://www.openlb.net/>
 *
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License
 *  as published by the Free Software Foundation; either version 2
 *  of the License, or (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public
 *  License along with this program; if not, write to the Free
 *  Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 *  Boston, MA  02110-1301, USA.
 */
 
#ifndef BLOCK_GEOMETRY_STATISTICS_3D_H
#define BLOCK_GEOMETRY_STATISTICS_3D_H
 
#include <vector>
#include <map>
#include <string>
 
#include "io/ostreamManager.h"
 
// All OpenLB code is contained in this namespace.
namespace olb {
 
 
template<typename T, unsigned D>
class BlockGeometry;
 
template<typename T>
class BlockGeometryStatistics3D {
private:
  BlockGeometry<T,3>* _blockGeometry{};
  bool _statisticsUpdateNeeded{};
  int _nX{}, _nY{}, _nZ{};
  T _h{};
 
  int _nMaterials{};
  std::map<int, std::size_t> _material2n{};
  std::map<int, std::vector<int> > _material2min{};
  std::map<int, std::vector<int> > _material2max{};
 
  mutable OstreamManager clout;
 
  const BlockGeometryStatistics3D<T>* const_this{};
 
public:
  BlockGeometryStatistics3D(BlockGeometry<T,3>* blockGeometry);
 
  bool& getStatisticsStatus();
  bool const & getStatisticsStatus() const;
  std::map<int, std::size_t> getMaterial2n();
  std::map<int, std::size_t> getMaterial2n() const;
 
  void update(bool verbose=false);
 
  int getNmaterials();
  int getNmaterials() const;
  std::size_t getNvoxel(int material);
  std::size_t getNvoxel(int material) const;
  std::size_t getNvoxel();
  std::size_t getNvoxel() const;
  std::vector<int> getMinLatticeR(int material);
  std::vector<int> getMinLatticeR(int material) const;
  std::vector<int> getMaxLatticeR(int material);
  std::vector<int> getMaxLatticeR(int material) const;
  std::vector<T> getMinPhysR(int material) const;
  std::vector<T> getMaxPhysR(int material) const;
  std::vector<T> getLatticeExtend(int material);
  std::vector<T> getLatticeExtend(int material) const;
  std::vector<T> getPhysExtend(int material);
  std::vector<T> getPhysExtend(int material) const;
  std::vector<T> getPhysRadius(int material);
  std::vector<T> getPhysRadius(int material) const;
  std::vector<T> getCenterPhysR(int material);
  std::vector<T> getCenterPhysR(int material) const;
  /* Returns the boundary type which is characterized by a discrete normal (c.f. Zimny)
   * 0 element:   flat, corner or edge
   * 1 element:   orientation -1, 0 or 1
   * 2 element:   orientation -1, 0 or 1
   * 3 element:   orientation -1, 0 or 1
   */
  std::vector<int> getType(int iX, int iY, int iZ, bool anyNormal = false);
  std::vector<int> getType(const int* input, bool anyNormal = false) const;
  std::vector<int> getType(int iX, int iY, int iZ, bool anyNormal = false) const;
 
  std::vector<int> computeNormal(int iX, int iY, int iZ);
  std::vector<int> computeNormal(int iX, int iY, int iZ) const;
  std::vector<T> computeNormal (int material);
  std::vector<T> computeNormal (int material) const;
  std::vector<int> computeDiscreteNormal (int material, T maxNorm = 1.1);
  std::vector<int> computeDiscreteNormal (int material, T maxNorm = 1.1) const;
 
  // Returns true if at position (iX,iY,iZ) and in a neighbourhood of size (offsetX,offsetY,offsetZ) only voxels of the given material are found
  bool check(int material, int iX, int iY, int iZ, unsigned offsetX, unsigned offsetY, unsigned offsetZ);
  bool check(int material, int iX, int iY, int iZ, unsigned offsetX, unsigned offsetY, unsigned offsetZ) const;
  // Returns true and a position (iX,iY,iZ) if there is a neighbourhood of size (offsetX,offsetY,offsetZ) around (iX,iY,iZ) with only voxels of the given material
  bool find(int material, unsigned offsetX, unsigned offsetY, unsigned offsetZ, int& iX, int& iY, int& iZ);
  bool find(int material, unsigned offsetX, unsigned offsetY, unsigned offsetZ, int& iX, int& iY, int& iZ) const;
 
  void print();
  void print() const;
 
private:
 
  void takeStatistics(int iX, int iY, int iZ);
  std::vector<int> checkExtraBoundary(std::vector<int> discreteNormal,
                                      std::vector<int> discreteNormal2);
  std::vector<int> checkExtraBoundary(std::vector<int> discreteNormal,
                                      std::vector<int> discreteNormal2) const;
};
 
} // namespace olb
 
#endif