cuboid3D.h

Go to the documentation of this file.

/*  This file is part of the OpenLB library
 *
 *  Copyright (C) 2007, 2014 Mathias J. Krause
 *  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 CUBOID_3D_H
#define CUBOID_3D_H
 
#include <vector>
#include <math.h>
 
#include "core/serializer.h"
#include "core/blockStructure.h"
#include "io/ostreamManager.h"
#include "functors/analytical/indicator/indicatorF3D.h"
 
 
// All OpenLB code is contained in this namespace.
namespace olb {
 
 
template<typename T> class IndicatorF3D;
 
 
 
template<typename T>
class Cuboid3D final : public Serializable {
private:
  T   _globPosX, _globPosY, _globPosZ;
  T   _delta;
  int _nX, _nY, _nZ;
  size_t _weight;
 
  mutable OstreamManager clout;
 
public:
  static Cuboid3D<T> motherOf(Cuboid3D<T> a, Cuboid3D<T> b);
 
  Cuboid3D();
  Cuboid3D(T globPosX, T globPosY, T globPosZ, T delta, int nX, int nY, int nZ);
  Cuboid3D(std::vector<T> origin, T delta, std::vector<int> extend);
  Cuboid3D(Vector<T,3> origin, T delta, Vector<int,3> extend);
  Cuboid3D(IndicatorF3D<T>& indicatorF, T voxelSize);
  Cuboid3D(Cuboid3D<T> const& rhs, int overlap=0);
  Cuboid3D& operator=(Cuboid3D const& rhs);
  void init(T globPosX, T globPosY, T globPosZ, T delta, int nX, int nY, int nZ);
 
  Vector<T,3> getOrigin() const;
  T getDeltaR() const;
  int getNx() const;
  int getNy() const;
  int getNz() const;
  Vector<int,3> const getExtent() const;
  T getPhysVolume() const;
  int getWeightValue() const;
  std::size_t getWeight() const;
  std::size_t getWeightIn(IndicatorF3D<T>& indicator) const;
  void setWeight(size_t fullCells);
  T getFraction() const {
    return T(getWeight()) / getLatticeVolume();
  }
  size_t getLatticeVolume() const;
  T getPhysPerimeter() const;
  int getLatticePerimeter() const;
 
  void refine(int factor);
 
  bool getLatticeR(Vector<T,3> physR, Vector<int,3>& latticeR, T eps=1e-5) {
    auto globR = Vector<T,3>{_globPosX, _globPosY, _globPosZ};
    auto physLatticeR = (physR - globR) / _delta;
    if (   std::fabs(std::roundf(physLatticeR[0]) - physLatticeR[0]) <= eps
        && std::fabs(std::roundf(physLatticeR[1]) - physLatticeR[1]) <= eps
        && std::fabs(std::roundf(physLatticeR[2]) - physLatticeR[2]) <= eps) {
      latticeR[0] = std::roundf(physLatticeR[0]);
      latticeR[1] = std::roundf(physLatticeR[1]);
      latticeR[2] = std::roundf(physLatticeR[2]);
      return true;
    } else {
      return false;
    }
  }
 
  bool operator==(const Cuboid3D<T>& rhs) const;
 
  std::size_t getNblock() const override;
  std::size_t getSerializableSize() const override;
  bool* getBlock(std::size_t iBlock, std::size_t& sizeBlock, bool loadingMode) override;
 
  void print() const;
 
  void getPhysR(T physR[3], const int latticeR[3]) const;
  void getPhysR(T physR[3], const int& iX, const int& iY, const int& iZ) const;
  void getPhysR(T physR[3], LatticeR<3> latticeR) const;
 
  void getLatticeR(int latticeR[3], const T physR[3]) const;
  void getLatticeR(int latticeR[3], const Vector<T,3>& physR) const;
 
  void getFloorLatticeR(const std::vector<T>& physR, std::vector<int>& latticeR) const;
  void getFloorLatticeR(int latticeR[3], const T physR[3]) const;
 
  bool checkPoint(T globX, T globY, T globZ, int overlap = 0) const; //TODO globX-> x + additional interface: with (std::vector<T> physR, int overlap=0)
  bool checkPoint(Vector<T,3>& globXYZ, int overlap = 0) const;
  bool physCheckPoint(T globX, T globY, T globZ, double overlap = 0) const;
  // TODO: adapt to use only sum operation (cf. #204)
  [[deprecated]] bool checkPoint(T globX, T globY, T globZ, int &locX, int &locY, int &locZ, int overlap = 0) const; //TODO globX-> x + additional interface: with (std::vector<T> physR, std::vector<int>& latticeR, int overlap=0)
  bool checkInters(T globX0, T globX1, T globY0, T globY1, T globZ0, T globZ1, int overlap = 0) const;
  bool checkInters(T globX, T globY, T globZ, int overlap = 0) const;
  bool checkInters(T globX0, T globX1, T globY0, T globY1, T globZ0, T globZ1,
                   int &locX0, int &locX1, int &locY0, int &locY1, int &locZ0, int &locZ1,
                   int overlap = 0) const;
  bool checkInters(Cuboid3D<T>& child) const;
  void divide(int p, int q, int r, std::vector<Cuboid3D<T> > &childrenC) const;
  void divide(int p, std::vector<Cuboid3D<T> > &childrenC) const;
 
  void divideFractional(int iD, std::vector<T> fractions, std::vector<Cuboid3D<T>>& childrenC) const;
 
  void resize(int X, int Y, int Z, int nX, int nY, int nZ);
 
};
 
}  // namespace olb
 
#endif