Marker.hpp

#pragma once
 
#include <limits>
#include <optional>
#include <string>
#include <utility>
 
#include <dune/grid/common/grid.hh>
 
#include <amdis/common/ConceptsBase.hpp>
#include <amdis/common/TypeTraits.hpp>
 
#include <amdis/gridfunctions/GridFunction.hpp>
 
#include <amdis/AdaptInfo.hpp>
#include <amdis/Flag.hpp>
#include <amdis/Initfile.hpp>
 
namespace AMDiS
{
  template <class Grid>
  class Marker
  {
  protected:
    using GridView = typename Grid::LeafGridView;
    using Element  = typename GridView::template Codim<0>::Entity;
 
  public:
    Marker() = default;
 
    Marker(std::string const& name, std::shared_ptr<Grid> const& grid)
      : name_(name)
      , grid_(grid)
    {
      Parameters::get(name + "->info", info_);
      Parameters::get(name + "->max refinement level", maxRefineLevel_);
      Parameters::get(name + "->min refinement level", minRefineLevel_);
    }
 
    virtual ~Marker() = default;
 
    void mark(Element const& elem, int newMark);
 
    virtual void initMarking(AdaptInfo& adaptInfo);
 
    virtual void finishMarking(AdaptInfo& adaptInfo);
 
    virtual void markElement(AdaptInfo& adaptInfo, Element const& elem) = 0;
 
    virtual Flag markGrid(AdaptInfo& adaptInfo);
 
    int elMarkRefine() const
    {
      return elMarkRefine_;
    }
 
    int elMarkCoarsen() const
    {
      return elMarkCoarsen_;
    }
 
    std::string const& name() const
    {
      return name_;
    }
 
    void setMaximumMarking(bool maxMark)
    {
      maximumMarking_ = maxMark;
    }
 
    void allowRefinement(bool allow)
    {
      refineAllowed_ = allow;
    }
 
    void allowCoarsening(bool allow)
    {
      coarsenAllowed_ = allow;
    }
 
  protected:
    std::string name_;
 
    std::shared_ptr<Grid> grid_;
 
    bool maximumMarking_ = false;
 
    int info_ = 0;
 
    int elMarkRefine_ = 0;
 
    int elMarkCoarsen_ = 0;
 
    int maxRefineLevel_ = std::numeric_limits<int>::max();
 
    int minRefineLevel_ = 0;
 
    bool refineAllowed_ = true;
 
    bool coarsenAllowed_ = true;
  };
 
 
  template <class Grid>
  class EstimatorMarker
      : public Marker<Grid>
  {
  protected:
    using Super = Marker<Grid>;
    using Element   = typename Super::Element;
    using Estimates = std::vector<double>;
 
  public:
    EstimatorMarker() = default;
 
    EstimatorMarker(std::string name, std::string component, Estimates const& est,
                    std::shared_ptr<Grid> const& grid)
      : Super{std::move(name), grid}
      , component_(std::move(component))
      , est_(est)
    {
      Parameters::get(this->name_ + "->p", p_);
    }
 
    void initMarking(AdaptInfo& adaptInfo) override;
 
    void markElement(AdaptInfo& adaptInfo, Element const& elem) override;
 
    static std::unique_ptr<EstimatorMarker<Grid> > createMarker(std::string const& name,
      std::string const& component, Estimates const& est, std::shared_ptr<Grid> const& grid);
 
  protected:
    std::string component_;
 
    Estimates est_;
 
    double estSum_ = 0.0;
 
    double estMax_ = 0.0;
 
    double markRLimit_;
 
    double markCLimit_;
 
    double p_ = 2.0;
  };
 
 
  template <class Grid>
  class GRMarker
      : public EstimatorMarker<Grid>
  {
    using Super = EstimatorMarker<Grid>;
    using Element   = typename Super::Element;
    using Estimates = typename Super::Estimates;
 
  public:
    GRMarker(std::string const& name, std::string const& component, Estimates const& est,
             std::shared_ptr<Grid> const& grid)
      : Super{name, component, est, grid}
    {}
 
    void markElement(AdaptInfo& /*adaptInfo*/, Element const& elem) override
    {
      if (this->refineAllowed_)
        this->mark(elem, 1);
    }
  };
 
 
  template <class Grid>
  class MSMarker
      : public EstimatorMarker<Grid>
  {
    using Super = EstimatorMarker<Grid>;
    using Estimates = typename Super::Estimates;
 
  public:
    MSMarker(std::string const& name, std::string component, Estimates const& est,
             std::shared_ptr<Grid> const& grid)
      : Super{name, std::move(component), est, grid}
    {
      Parameters::get(name + "->MSGamma", msGamma_);
      Parameters::get(name + "->MSGammaC", msGammaC_);
    }
 
    void initMarking(AdaptInfo& adaptInfo) override;
 
  protected:
    double msGamma_ = 0.5;
 
    double msGammaC_ = 0.1;
  };
 
 
  template <class Grid>
  class ESMarker
      : public EstimatorMarker<Grid>
  {
    using Super = EstimatorMarker<Grid>;
    using Estimates = typename Super::Estimates;
 
  public:
    ESMarker(std::string const& name, std::string component, Estimates const& est,
             std::shared_ptr<Grid> const& grid)
      : Super{name, std::move(component), est, grid}
    {
      Parameters::get(name + "->ESTheta", esTheta_);
      Parameters::get(name + "->ESThetaC", esThetaC_);
    }
 
    void initMarking(AdaptInfo& adaptInfo) override;
 
  protected:
    double esTheta_ = 0.9;
 
    double esThetaC_ = 0.2;
  };
 
 
  template <class Grid>
  class GERSMarker
      : public EstimatorMarker<Grid>
  {
    using Super = EstimatorMarker<Grid>;
    using Element   = typename Super::Element;
    using Estimates = typename Super::Estimates;
 
  public:
    GERSMarker(std::string const& name, std::string component, Estimates const& est,
               std::shared_ptr<Grid> const& grid)
      : Super{name, std::move(component), est, grid}
    {
      Parameters::get(name + "->GERSThetaStar", gersThetaStar_);
      Parameters::get(name + "->GERSNu", gersNu_);
      Parameters::get(name + "->GERSThetaC", gersThetaC_);
    }
 
    Flag markGrid(AdaptInfo& adaptInfo) override;
 
  protected:
    void markElementForRefinement(AdaptInfo& adaptInfo, Element const& elem);
 
    void markElementForCoarsening(AdaptInfo& adaptInfo, Element const& elem);
 
  protected:
    double gersSum_ = 0.0;
 
    double oldErrSum_ = 0.0;
 
    double gersThetaStar_ = 0.6;
 
    double gersNu_ = 0.1;
 
    double gersThetaC_ = 0.1;
  };
 
 
  template <class Grid, class GridFct>
  class GridFunctionMarker
      : public Marker<Grid>
  {
    using Super = Marker<Grid>;
    using Element = typename Super::Element;
 
    template <class GF>
    using IsGridFunction = decltype(localFunction(std::declval<GF>()));
 
    static_assert(Dune::Std::is_detected<IsGridFunction,GridFct>::value, "");
 
  public:
    template <class GF>
    GridFunctionMarker(std::string const& name, std::shared_ptr<Grid> const& grid, GF&& gf)
      : Super{name, grid}
      , gridFct_{makeGridFunction(FWD(gf), grid->leafGridView())}
    {}
 
    void markElement(AdaptInfo& /*adaptInfo*/, Element const& /*elem*/) final { /* do nothing */}
 
    Flag markGrid(AdaptInfo& adaptInfo) override;
 
  private:
    GridFct gridFct_;
  };
 
 
  // Deduction guide for GridFunctionMarker class
  template <class Grid, class GF>
  GridFunctionMarker(std::string const& name, std::shared_ptr<Grid> const& grid, GF&& gf)
    -> GridFunctionMarker<Grid,
          TYPEOF( makeGridFunction(FWD(gf), grid->leafGridView()) )>;
 
} // end namespace AMDiS
 
#include "Marker.inc.hpp"