cuboid.h

Go to the documentation of this file.

/*  This file is part of the OpenLB library
 *
 *  Copyright (C) 2007, 2014 Mathias J. Krause
 *                2025 Adrian Kummerlaender
 *  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_H
#define CUBOID_H
 
#include "core/vector.h"
#include "core/serializer.h"
 
#include "utilities/vectorHelpers.h"
 
#include <optional>
 
namespace olb {
 
template <typename T, unsigned D>
class Cuboid final {
private:
  Vector<T,D> _origin;
  Vector<int,D> _extent;
  T _delta;
  std::size_t _weight;
 
  // Don't want to use concept here as it would have to be repeated for all method implementations
  static_assert(D == 2 || D == 3, "Only 2D/3D supported");
 
public:
  Cuboid() = default;
  Cuboid(Vector<T,D> origin, T delta, Vector<int,D> extent):
    _origin(origin),
    _extent(extent),
    _delta(delta),
    _weight(getLatticeVolume()) { }
  Cuboid(const Cuboid& rhs):
    _origin(rhs._origin),
    _extent(rhs._extent),
    _delta(rhs._delta),
    _weight(rhs._weight) { }
  Cuboid(IndicatorF<T,D>& indicatorF, T delta):
    _origin(indicatorF.getMin()),
    _extent((indicatorF.getMax() - indicatorF.getMin()) / delta + 1.5),
    _delta(delta),
    _weight(getLatticeVolume()) { }
 
  Cuboid& operator=(const Cuboid& rhs);
  bool operator==(const Cuboid& rhs) const;
 
  Vector<T,D> getOrigin() const { return _origin; }
  T getDeltaR() const { return _delta; }
  Vector<int,D> getExtent() const { return _extent; }
 
  int getNx() const { return _extent[0]; }
  int getNy() const { return _extent[1]; }
  int getNz() const { return _extent[2]; }
 
  T getPhysVolume() const;
 
  std::size_t getWeight() const { return _weight; }
  void setWeight(std::size_t weight) { _weight = weight; }
 
  Vector<T,D> getPhysR(LatticeR<D> latticeR) const {
    return _origin + latticeR*_delta;
  }
 
  LatticeR<D> getLatticeR(Vector<T,D> physR) const {
    return util::floor((physR - _origin) / _delta + 0.5);
  }
 
  LatticeR<D> getFloorLatticeR(Vector<T,D> physR) const {
    return util::floor((physR - _origin) / _delta);
  }
 
  std::optional<LatticeR<D>> getCloseLatticeR(Vector<T,D> physR, T eps=1e-5) const;
 
  std::size_t getLatticeVolume() const;
  T getPhysPerimeter() const requires (D == 2);
  T getPhysPerimeter() const requires (D == 3);
  std::size_t getLatticePerimeter() const requires (D == 2);
  std::size_t getLatticePerimeter() const requires (D == 3);
 
  bool isInside(Vector<T,D> pos, int overlap = 0) const;
 
  bool intersects(Vector<T,D> globMin, Vector<T,D> globMax, int overlap = 0) const;
  bool intersects(const Cuboid<T,D>& cuboid) const;
 
  void divide(Vector<int,D> division, std::vector<Cuboid<T,D>>& childrenC) const requires (D == 3);
  void divide(Vector<int,D> division, std::vector<Cuboid<T,D>>& childrenC) const requires (D == 2);
 
  void divideP(int p, std::vector<Cuboid<T,D>>& childrenC) const requires (D == 2);
  void divideP(int p, std::vector<Cuboid<T,D>>& childrenC) const requires (D == 3);
 
  void divideFractional(int iD, std::vector<T> fractions, std::vector<Cuboid<T,D>>& childrenC) const;
 
  void resize(Vector<int,D> offset, Vector<int,D> extent);
 
  void refine(int factor);
 
  void write(std::ostream& cout) const;
  void print() const;
 
  void writeAsXML(std::ostream&) const;
 
};
 
template <typename T>
using Cuboid2D = Cuboid<T,2>;
template <typename T>
using Cuboid3D = Cuboid<T,3>;
 
}
 
#endif