superLattice.h

Go to the documentation of this file.

/*  This file is part of the OpenLB library
 *
 *  Copyright (C) 2007 Mathias J. Krause
 *                2021 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 SUPER_LATTICE_H
#define SUPER_LATTICE_H
 
#include "utilities/aliases.h"
 
#include "unitConverter.h"
#include "stages.h"
#include "cellD.h"
#include "blockLattice.hh"
#include "communication/superCommunicator.h"
#include "postProcessing.hh"
#include "serializer.h"
#include "communication/superStructure.hh"
#include "utilities/functorPtr.h"
#include "geometry/superGeometry.h"
 
namespace olb {
 
 
template <typename T, typename DESCRIPTOR>
class SuperLattice final : public SuperStructure<T,DESCRIPTOR::d>
                         , public BufferSerializable {
private:
  std::optional<const UnitConverter<T,DESCRIPTOR>*> _converter;
  std::vector<std::unique_ptr<BlockLattice<T,DESCRIPTOR>>> _block;
  std::map<std::type_index,std::unique_ptr<SuperCommunicator<T,SuperLattice>>> _communicator;
  bool _communicationNeeded;
  std::map<std::type_index,std::vector<std::function<void()>>> _customTasks;
  std::map<std::type_index,std::vector<std::future<void>>> _backgroundTasks;
 
  LatticeStatistics<T> _statistics;
 
  bool _statisticsEnabled;
  void collectStatistics();
  bool _initialized = false;
 
public:
  constexpr static unsigned d = DESCRIPTOR::d;
 
  using value_t = T;
  using descriptor_t = DESCRIPTOR;
 
  using block_t = ConcretizableBlockLattice<T,DESCRIPTOR>;
 
  SuperLattice(CuboidDecomposition<T,DESCRIPTOR::d>& cuboidDecomposition,
               LoadBalancer<T>& loadBalancer,
               unsigned overlap = 3);
 
  SuperLattice(CuboidDecomposition<T,DESCRIPTOR::d>& cuboidDecomposition,
               LoadBalancer<T>& loadBalancer,
               unsigned overlap,
               const UnitConverter<T,DESCRIPTOR>& converter)
    : SuperLattice(cuboidDecomposition, loadBalancer, overlap)
  {
    _converter = &converter;
  }
 
  SuperLattice(SuperGeometry<T,DESCRIPTOR::d>& sGeometry)
    : SuperLattice(sGeometry.getCuboidDecomposition(),
                   sGeometry.getLoadBalancer(),
                   sGeometry.getOverlap())
  { }
 
  SuperLattice(const SuperLattice&) = delete;
  ~SuperLattice() = default;
 
  const UnitConverter<T,DESCRIPTOR>& getConverter() const {
    if (_converter) {
      return **_converter;
    } else {
      throw std::runtime_error("Unit converter not provided");
    }
  }
 
  BlockLattice<T,DESCRIPTOR>& getBlock(int locC)
  {
    return *_block[locC];
  };
 
  template <typename BLOCK>
  BLOCK& getBlock(int locC)
  {
    return *dynamic_cast<BLOCK*>(_block[locC].get());
  };
  const BlockLattice<T,DESCRIPTOR>& getBlock(int locC) const
  {
    return *_block[locC];
  };
  template <typename BLOCK>
  const BLOCK& getBlock(int locIC) const
  {
    return *dynamic_cast<const BLOCK*>(_block[locIC].get());
  };
 
  template <Platform PLATFORM, typename F>
  void forBlocksOnPlatform(F f) {
    for (int iC = 0; iC < this->_loadBalancer.size(); ++iC) {
      if (_block[iC]->getPlatform() == PLATFORM) {
        f(static_cast<ConcreteBlockLattice<T,DESCRIPTOR,PLATFORM>&>(*_block[iC]));
      }
    }
  };
 
 
  void setProcessingContext(ProcessingContext context)
  {
    // Communicate overlap prior to evaluation
    if (context == ProcessingContext::Evaluation) {
      communicate();
      waitForBackgroundTasks<stage::PreContextSwitchTo<ProcessingContext::Evaluation>>();
    }
    for (int iC = 0; iC < this->_loadBalancer.size(); ++iC) {
      _block[iC]->setProcessingContext(context);
    }
  };
 
 
  template <typename FIELD_TYPE>
  void setProcessingContext(ProcessingContext context)
  {
    for (int iC = 0; iC < this->_loadBalancer.size(); ++iC) {
      if (_block[iC]->template hasData<FIELD_TYPE>()) {
        _block[iC]->template getData<FIELD_TYPE>().setProcessingContext(context);
      }
    }
  };
 
  template <typename STAGE>
  SuperCommunicator<T,SuperLattice>& getCommunicator(STAGE stage=STAGE());
  void communicate() override;
 
  LatticeStatistics<T>& getStatistics();
  LatticeStatistics<T> const& getStatistics() const;
 
  Cell<T,DESCRIPTOR> get(LatticeR<DESCRIPTOR::d+1> latticeR);
  template <typename... R>
  std::enable_if_t<sizeof...(R) == DESCRIPTOR::d+1, Cell<T,DESCRIPTOR>>
  get(R... latticeR);
 
 
  void initialize();
 
 
  void printSummary() const;
  void writeSummary(std::string fileName = "lattice") const;
 
  template <typename DYNAMICS>
  void defineDynamics();
  template <template<typename...> typename DYNAMICS>
  void defineDynamics();
  template <typename DYNAMICS>
  void defineDynamics(FunctorPtr<SuperIndicatorF<T,DESCRIPTOR::d>>&& indicator);
  template <typename DYNAMICS>
  void defineDynamics(SuperGeometry<T,DESCRIPTOR::d>& sGeometry, int material);
 
  template <template<typename...> typename DYNAMICS>
  void defineDynamics(FunctorPtr<SuperIndicatorF<T,DESCRIPTOR::d>>&& indicator);
  template <template<typename...> typename DYNAMICS>
  void defineDynamics(SuperGeometry<T,DESCRIPTOR::d>& sGeometry, int material);
 
  //Define the dynamics on a domain with indicator and promise
  void defineDynamics(FunctorPtr<SuperIndicatorF<T,DESCRIPTOR::d>>&& indicator,DynamicsPromise<T,DESCRIPTOR>&& promise);
 
 
  void defineRho(FunctorPtr<SuperIndicatorF<T,DESCRIPTOR::d>>&&, AnalyticalF<DESCRIPTOR::d,T,T>& rho);
  void defineRho(SuperGeometry<T,DESCRIPTOR::d>& sGeometry, int material, AnalyticalF<DESCRIPTOR::d,T,T>& rho);
 
 
  void defineU(FunctorPtr<SuperIndicatorF<T,DESCRIPTOR::d>>&& indicator, AnalyticalF<DESCRIPTOR::d,T,T>& u);
  void defineU(SuperGeometry<T,DESCRIPTOR::d>& sGeometry, int material, AnalyticalF<DESCRIPTOR::d,T,T>& u);
 
 
  void defineRhoU(FunctorPtr<SuperIndicatorF<T,DESCRIPTOR::d>>&& indicator,
                  AnalyticalF<DESCRIPTOR::d,T,T>& rho, AnalyticalF<DESCRIPTOR::d,T,T>& u);
  void defineRhoU(SuperGeometry<T,DESCRIPTOR::d>& sGeometry, int material,
                  AnalyticalF<DESCRIPTOR::d,T,T>& rho, AnalyticalF<DESCRIPTOR::d,T,T>& u);
 
 
  void definePopulations(FunctorPtr<SuperIndicatorF<T,DESCRIPTOR::d>>&& indicator,
                         AnalyticalF<DESCRIPTOR::d,T,T>& Pop);
  void definePopulations(SuperGeometry<T,DESCRIPTOR::d>& sGeometry, int material,
                         AnalyticalF<DESCRIPTOR::d,T,T>& Pop);
  void definePopulations(FunctorPtr<SuperIndicatorF<T,DESCRIPTOR::d>>&& indicator,
                         SuperF<DESCRIPTOR::d,T,T>& Pop);
  void definePopulations(SuperGeometry<T,DESCRIPTOR::d>& sGeometry, int material,
                         SuperF<DESCRIPTOR::d,T,T>& Pop);
 
  template <typename FIELD>
  void defineField(FunctorPtr<SuperIndicatorF<T,DESCRIPTOR::d>>&& indicator,
                   FunctorPtr<SuperF<DESCRIPTOR::d,T,T>>&& field);
  template <typename FIELD>
  void defineField(FunctorPtr<SuperIndicatorF<T,DESCRIPTOR::d>>&& indicator,
                   AnalyticalF<DESCRIPTOR::d,T,T>& field);
  template <typename FIELD>
  void defineField(SuperGeometry<T,DESCRIPTOR::d>& sGeometry, int material,
                   FunctorPtr<SuperF<DESCRIPTOR::d,T,T>>&& field);
  template <typename FIELD>
  void defineField(SuperGeometry<T,DESCRIPTOR::d>& sGeometry, int material,
                   AnalyticalF<DESCRIPTOR::d,T,T>& field);
  template <typename FIELD>
  void defineField(SuperGeometry<T,DESCRIPTOR::d>& sGeometry,
                   IndicatorF<T,DESCRIPTOR::d>& indicator,
                   AnalyticalF<DESCRIPTOR::d,T,T>& field);
  template <typename FIELD>
  void defineField(SuperGeometry<T,DESCRIPTOR::d>& sGeometry,
                   IndicatorF<T,DESCRIPTOR::d>& indicator,
                   FunctorPtr<SuperF<DESCRIPTOR::d,T,T>>&& field);
 
 
  template <typename PARAMETER>
  void setParameter(FieldD<T,DESCRIPTOR,PARAMETER> field);
 
  template <typename PARAMETER, typename DYNAMICS>
  void setParameterOfDynamics(FieldD<T,DESCRIPTOR,PARAMETER>&& field);
  template <typename PARAMETER, template<typename...> typename DYNAMICS>
  void setParameterOfDynamics(FieldD<T,DESCRIPTOR,PARAMETER>&& field);
 
 
  template <typename PARAMETER, typename _DESCRIPTOR, typename FIELD>
  void setParameter(AbstractFieldArrayD<T,_DESCRIPTOR,FIELD>& abstractFieldArray);
 
 
  void iniEquilibrium(FunctorPtr<SuperIndicatorF<T,DESCRIPTOR::d>>&& indicator,
                      AnalyticalF<DESCRIPTOR::d,T,T>& rho, AnalyticalF<DESCRIPTOR::d,T,T>& u);
  void iniEquilibrium(SuperGeometry<T,DESCRIPTOR::d>& sGeometry, int material,
                      AnalyticalF<DESCRIPTOR::d,T,T>& rho, AnalyticalF<DESCRIPTOR::d,T,T>& u);
  void iniEquilibrium(FunctorPtr<SuperIndicatorF<T,DESCRIPTOR::d>>&& indicator,
                      AnalyticalF<DESCRIPTOR::d,T,T>& rho, SuperF<DESCRIPTOR::d,T,T>& u);
  void iniEquilibrium(SuperGeometry<T,DESCRIPTOR::d>& sGeometry, int material,
                      AnalyticalF<DESCRIPTOR::d,T,T>& rho, SuperF<DESCRIPTOR::d,T,T>& u);
 
  void iniRegularized(FunctorPtr<SuperIndicatorF<T,DESCRIPTOR::d>>&& indicator,
                      AnalyticalF<DESCRIPTOR::d,T,T>& rho, AnalyticalF<DESCRIPTOR::d,T,T>& u,
                      AnalyticalF<DESCRIPTOR::d,T,T>& pi);
  void iniRegularized(SuperGeometry<T,DESCRIPTOR::d>& sGeometry, int material,
                      AnalyticalF<DESCRIPTOR::d,T,T>& rho, AnalyticalF<DESCRIPTOR::d,T,T>& u,
                      AnalyticalF<DESCRIPTOR::d,T,T>& pi);
 
 
  void collideAndStream();
 
  void stripeOffDensityOffset(T offset);
 
  void statisticsOn()
  {
    _statisticsEnabled = true;
    for (int iC = 0; iC < this->_loadBalancer.size(); ++iC) {
      _block[iC]->setStatisticsEnabled(true);
    }
  };
 
  void statisticsOff()
  {
    _statisticsEnabled = false;
    for (int iC = 0; iC < this->_loadBalancer.size(); ++iC) {
      _block[iC]->setStatisticsEnabled(false);
    }
  };
 
  template <typename STAGE=stage::PostStream>
  void addPostProcessor(FunctorPtr<SuperIndicatorF<T,DESCRIPTOR::d>>&& indicator,
                        PostProcessorPromise<T,DESCRIPTOR>&& promise);
  template <typename STAGE=stage::PostStream>
  void addPostProcessor(PostProcessorPromise<T,DESCRIPTOR>&& promise);
 
 
  template <typename STAGE=stage::PostStream>
  void executePostProcessors(STAGE stage=STAGE());
 
  template <typename STAGE>
  void addCustomTask(std::function<void()> f) {
    _customTasks[typeid(STAGE)].emplace_back(f);
  }
  template <typename STAGE>
  void executeCustomTasks(STAGE stage=STAGE());
 
  template <typename STAGE, typename F>
  void scheduleBackgroundTask(F&& f);
  template <typename F>
  void scheduleBackgroundOutput(F&& f);
 
  template <typename CONTEXT>
  void scheduleBackgroundOutputVTK(CONTEXT&& vtkContext);
  template <typename STAGE>
  void waitForBackgroundTasks(STAGE stage=STAGE{});
 
  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 postLoad() override;
 
};
 
 
}
 
#endif