superGeometry.h

Go to the documentation of this file.

/*  This file is part of the OpenLB library
 *
 *  Copyright (C) 2013, 2014 Mathias J. Krause, Peter Weisbrod
 *  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 SUPER_GEOMETRY_H
#define SUPER_GEOMETRY_H
 
#include <vector>
#include <iostream>
#include <string>
 
#include "geometry/cuboidGeometry2D.h"
#include "geometry/cuboidGeometry3D.h"
#include "geometry/superGeometryStatistics2D.h"
#include "geometry/superGeometryStatistics3D.h"
#include "geometry/blockGeometry.h"
#include "communication/superStructure.h"
#include "communication/loadBalancer.h"
#include "communication/superCommunicator.h"
#include "functors/analytical/indicator/indicatorF2D.h"
#include "functors/analytical/indicator/indicatorF3D.h"
#include "io/ostreamManager.h"
#include "utilities/functorPtr.h"
#include "dynamics/latticeDescriptors.h"
 
 
// All OpenLB code is contained in this namespace.
namespace olb {
 
template<typename T, unsigned D>
class SuperGeometry : public SuperStructure<T,D>
                    , public BufferSerializable {
private:
  std::vector<std::unique_ptr<BlockGeometry<T,D>>> _block{};
  std::unique_ptr<SuperCommunicator<T,SuperGeometry<T,D>>> _communicator{};
  bool _communicationNeeded{};
  SuperGeometryStatistics<T,D> _statistics{};
  mutable OstreamManager clout;
 
public:
  constexpr static unsigned d = D;
 
  using block_t = ConcretizableBlockGeometry<T,D>;
 
  SuperGeometry(CuboidGeometry<T,D>& cuboidGeometry,
                LoadBalancer<T>& loadBalancer,
                int overlap = 3);
 
  int get(int iCglob, LatticeR<D> latticeR) const;
  int get(const int latticeR[D+1]) const;
  int get(LatticeR<D+1> latticeR) const;
 
  template <typename... L>
  std::enable_if_t<sizeof...(L) == (D+1), int>
  get(L... latticeR) const {
    return get(LatticeR<D+1>{latticeR...});
  }
 
  int getAndCommunicate(int iCglob, LatticeR<D> latticeR) const;
  int getAndCommunicate(LatticeR<D+1> latticeR) const;
 
  std::vector<T> getPhysR(int iCglob, LatticeR<D> latticeR) const;
  std::vector<T> getPhysR(LatticeR<D+1> latticeR) const;
  void getPhysR(T output[D], const int latticeR[D+1]) const;
  void getPhysR(T output[D], const int iCglob, LatticeR<D> latticeR) const;
 
  BlockGeometry<T,D>& getBlockGeometry(int locIC);
  BlockGeometry<T,D> const& getBlockGeometry(int locIC) const;
 
  template <typename BLOCK = BlockGeometry<T,D>>
  BLOCK& getBlock(int locIC);
  template <typename BLOCK = BlockGeometry<T,D>>
  const BLOCK& getBlock(int locIC) const;
 
  SuperGeometryStatistics<T,D>& getStatistics();
  const SuperGeometryStatistics<T,D>& getStatistics() const;
  bool& getStatisticsStatus();
  bool const& getStatisticsStatus() const;
  void updateStatistics(bool verbose=true);
 
  template <typename DESCRIPTOR=std::conditional_t<D==2,descriptors::D2Q9<>,descriptors::D3Q27<>>>
  int clean(bool verbose=true, std::vector<int> bulkMaterials={1});
  int outerClean(bool verbose=true, std::vector<int> bulkMaterials={1});
  int innerClean(bool verbose=true);
  int innerClean(int material, bool verbose=true);
  bool checkForErrors(bool verbose=true);
 
  void reset(IndicatorF<T,D>& domain);
 
  void rename(int fromM, int toM);
  void rename(int fromM, int toM, FunctorPtr<IndicatorF<T,D>>&& condition);
  void rename(int fromM, int toM, LatticeR<D> offset);
  void rename(int fromM, int toM, int testM, std::vector<int> testDirection);
  void rename(int fromBcMat, int toBcMat, int fluidMat, IndicatorF<T,D>& condition);
  void rename(int fromBcMat, int toBcMat, int fluidMat, FunctorPtr<IndicatorF<T,D>>&& condition);
 
 
  void print();
 
  std::unique_ptr<SuperIndicatorF<T,D>> getMaterialIndicator(std::vector<int>&& materials);
  std::unique_ptr<SuperIndicatorF<T,D>> getMaterialIndicator(int material);
 
  void communicate() override
  {
    if (_communicationNeeded) {
      _communicator->communicate();
      _communicationNeeded = false;
    }
  }
 
  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;
 
};
 
} // namespace olb
 
#endif