Marker.hpp

#pragma once

#include <string>

#include <dune/grid/common/grid.hh>

#include <amdis/AdaptInfo.hpp>
#include <amdis/Flag.hpp>
#include <amdis/Initfile.hpp>

namespace AMDiS {


  /**
   * \ingroup Adaption
   *
   * \brief
   * Base class for all scalar markers.
   */
  template <class Traits>
  class Marker
  {
  protected:
    using GlobalBasis = typename Traits::GlobalBasis;
    using GridView = typename GlobalBasis::GridView;
    using Grid     = typename GridView::Grid;
    using IndexSet = typename GridView::IndexSet;
    using Element  = typename GridView::template Codim<0>::Entity;
    using Estimates = std::vector<double>;

  public:
    /// Constructor.
    Marker() {}

    /// Constructor.
    Marker(std::string const& name, std::string const& component, Estimates const& est,
           std::shared_ptr<Grid> const& grid)
      : name_(name)
      , component_(component)
      , grid_(grid)
      , est_(est)
      , maximumMarking_(false)
    {
      Parameters::get(name + "->p", p_);
      Parameters::get(name + "->info", info_);
      Parameters::get(name + "->max refinement level", maxRefineLevel_);
      Parameters::get(name + "->min refinement level", minRefineLevel_);
    }

    /// destructor
    virtual ~Marker() {}

    /// Marks element with newMark. If \ref maximumMarking_ is set, the element
    /// is marked only if the new mark is bigger than the old one. The return
    /// value specifies whether the element has been marked, or not.
    void mark(Element const& elem, int newMark)
    {
      int oldMark = grid_->getMark(elem);

      if (!maximumMarking_ || (newMark > oldMark)) {
        bool marked = grid_->mark(newMark, elem);
        if (marked) {
          if (oldMark > 0) {
            elMarkRefine_--;
          } else if (oldMark < 0) {
            elMarkCoarsen_--;
          }

          if (newMark > 0) {
            elMarkRefine_++;
          } else if (newMark < 0) {
              elMarkCoarsen_++;
          }
        } else {
          msg("Marking failed");
        }
      }
    }

    /// Can be used by sub classes. Called before traversal.
    virtual void initMarking(AdaptInfo& adaptInfo);

    /// Can be used by sub classes. Called after traversal.
    virtual void finishMarking(AdaptInfo& adaptInfo);

    /// Marks one element.
    virtual void markElement(AdaptInfo& adaptInfo, Element const& elem);

    /// Marking of the mesh.
    virtual Flag markGrid(AdaptInfo& adaptInfo);

    /// Sets \ref maximumMarking.
    void setMaximumMarking(bool maxMark)
    {
      maximumMarking_ = maxMark;
    }

    int getElMarkRefine()
    {
      return elMarkRefine_;
    }

    int getElMarkCoarsen()
    {
      return elMarkCoarsen_;
    }

    /// Returns \ref name of the Marker
    std::string const& getName() const
    {
      return name_;
    }

    /// Creates a scalar marker depending on the strategy set in parameters.
    static std::unique_ptr<Marker<Traits> > createMarker(std::string const& name, std::string const& component, Estimates const& est, std::shared_ptr<Grid> const& grid);

  protected:
    /// Name of the scalar marker.
    std::string name_;

    /// Problem component to work on
    std::string component_;

    /// Pointer to the grid
    std::shared_ptr<Grid> grid_;

    /// Pointer to the local error estimates
    Estimates est_;

    /// estimation sum
    double estSum_ = 0.0;

    /// estmation maximum
    double estMax_ = 0.0;

    /// If true, elements are marked only if the new value is bigger than
    /// the current marking.
    bool maximumMarking_;

    /// Lower limit for error estimation, from which an element is marked for
    /// refinement
    double markRLimit_;

    /// Upper limit for error estimation, from which an element is marked for
    /// coarsening
    double markCLimit_;

    /// power in estimator norm TODO: is this info necessary in marker?
    double p_ = 2.0;

    /// Info level.
    int info_ = 10;

    /// Counter for elements marked for refinement
    int elMarkRefine_ = 0;

    /// Counter for elements marked for coarsening
    int elMarkCoarsen_ = 0;

    /// Maximal level of all elements.
    int maxRefineLevel_ = -1;

    /// Minimal level of all elements.
    int minRefineLevel_ = -1;

    bool refineAllowed_ = true;

    bool coarsenAllowed_ = false;
  };


  /**
   * \ingroup Adaption
   *
   * \brief
   * Global refinement.
   */
  template <class Traits>
  class GRMarker
      : public Marker<Traits>
  {
    using Super = Marker<Traits>;
    using Grid      = typename Super::Grid;
    using Element   = typename Super::Element;
    using Estimates = typename Super::Estimates;

  public:
    /// Constructor.
    GRMarker(std::string const& name, std::string component, Estimates const& est,
             std::shared_ptr<Grid> const& grid)
      : Marker<Traits>(name, std::move(component), est, grid)
    {}

    /// Implementation of Marker::markElement().
    virtual void markElement(AdaptInfo& adaptInfo, Element const& elem)
    {
      if (this->refineAllowed_)
        this->mark(elem, 1);
    }
  };


  /**
   * \ingroup Adaption
   *
   * \brief
   * Maximum strategy.
   */

  template <class Traits>
  class MSMarker
      : public Marker<Traits>
  {
    using Super = Marker<Traits>;
    using Grid      = typename Super::Grid;
    using Estimates = typename Super::Estimates;

  public:
    /// Constructor.
    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_);
    }

    /// Implementation of Marker::initMarking().
    void initMarking(AdaptInfo& adaptInfo);

  protected:
    /// Marking parameter.
    double msGamma_ = 0.5;

    /// Marking parameter.
    double msGammaC_ = 0.1;
  };


  /**
   * \ingroup Adaption
   *
   * \brief
   * Equidistribution strategy
   */

  template <class Traits>
  class ESMarker
      : public Marker<Traits>
  {
    using Super = Marker<Traits>;
    using Grid      = typename Super::Grid;
    using Estimates = typename Super::Estimates;

  public:
    /// Constructor.
    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_);
    }

    /// Implementation of Marker::initMarking().
    virtual void initMarking(AdaptInfo& adaptInfo);

  protected:
    /// Marking parameter.
    double esTheta_ = 0.9;

    /// Marking parameter.
    double esThetaC_ = 0.2;
  };


  /**
   * \ingroup Adaption
   *
   * \brief
   * Guaranteed error reduction strategy
   */

  template <class Traits>
  class GERSMarker
      : public Marker<Traits>
  {
    using Super = Marker<Traits>;
    using Grid      = typename Super::Grid;
    using Element   = typename Super::Element;
    using Estimates = typename Super::Estimates;

  public:
    /// Constructor.
    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_);
    }

    /// Implementation of Marker::markGrid().
    virtual Flag markGrid(AdaptInfo& adaptInfo);

  protected:
    /// Refinement marking function.
    void markElementForRefinement(AdaptInfo& adaptInfo, Element const& elem);

    /// Coarsening marking function.
    void markElementForCoarsening(AdaptInfo& adaptInfo, Element const& elem);

  protected:
    /// Marking parameter.
    double gersSum_ = 0.0;

    /// Marking parameter.
    double oldErrSum_ = 0.0;

    /// Marking parameter.
    double gersThetaStar_ = 0.6;

    /// Marking parameter.
    double gersNu_ = 0.1;

    /// Marking parameter.
    double gersThetaC_ = 0.1;
  };

}

#include "Marker.inc.hpp"