Marker.hpp

#pragma once
// TODO: Cleanup of copied comments
#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
  {
    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 EstType = std::vector<double>;

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

    /// Constructor.
    Marker(std::string name_, std::string component_, const EstType& est_, std::shared_ptr<Grid> grid_)
      : name(name_),
        component(component_),
        grid(grid_),
        est(est_),
        maximumMarking(false),
        p(2),
        info(10),
        maxRefineLevel(-1),
        minRefineLevel(-1),
        refineAllowed(true),
        coarsenAllowed(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.
    inline void mark(const Element& 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, const Element& elem);

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

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

    inline int getElMarkRefine()
    {
      return elMarkRefine;
    }

    inline int getElMarkCoarsen()
    {
      return elMarkCoarsen;
    }

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

    /// Creates a scalar marker depending on the strategy set in parameters.
    static std::shared_ptr<Marker<Traits> > createMarker(std::string name, std::string component_, const EstType& est_, std::shared_ptr<Grid> 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
    EstType est;

    /// estimation sum
    double estSum;

    /// estmation maximum
    double estMax;

    /// 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
    double p;

    /// Info level.
    int info;

    /// Counter for elements marked for refinement
    int elMarkRefine;

    /// Counter for elements marked for coarsening
    int elMarkCoarsen;

    /// Maximal level of all elements.
    int maxRefineLevel;

    /// Minimal level of all elements.
    int minRefineLevel;

    bool refineAllowed;

    bool coarsenAllowed;
  };


  /**
   * \ingroup Adaption
   *
   * \brief
   * Global refinement.
   */
  template <class Traits>
  class GRMarker : public Marker<Traits>
  {
    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 EstType = std::vector<double>;

  public:
    /// Constructor.
    GRMarker(std::string name_, std::string component_, const EstType& est_, std::shared_ptr<Grid> grid_)
      : Marker<Traits>(name_, component_, est_, grid_)
    {}

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


  /**
   * \ingroup Adaption
   *
   * \brief
   * Maximum strategy.
   */
  
  template <class Traits>
  class MSMarker : public Marker<Traits>
  {
    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 EstType = std::vector<double>;

  public:
    /// Constructor.
    MSMarker(std::string name_, std::string component_, const EstType& est_, std::shared_ptr<Grid> grid_)
      : Marker<Traits>(name_, component_, est_, grid_),
        MSGamma(0.5),
        MSGammaC(0.1)
    {
      Parameters::get(this->name + "->MSGamma", MSGamma);
      Parameters::get(this->name + "->MSGammaC", MSGammaC);
    }

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

  protected:
    /// Marking parameter.
    double MSGamma;

    /// Marking parameter.
    double MSGammaC;
  };


  /**
   * \ingroup Adaption
   *
   * \brief
   * Equidistribution strategy
   */
  
  template <class Traits>
  class ESMarker : public Marker<Traits>
  {
    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 EstType = std::vector<double>;

  public:
    /// Constructor.
    ESMarker(std::string name_, std::string component_, const EstType& est_, std::shared_ptr<Grid> grid_)
      : Marker<Traits>(name_, component_, est_, grid_),
        ESTheta(0.9),
        ESThetaC(0.2)
    {
      Parameters::get(this->name + "->ESTheta", ESTheta);
      Parameters::get(this->name + "->ESThetaC", ESThetaC);
    }

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

  protected:
    /// Marking parameter.
    double ESTheta;

    /// Marking parameter.
    double ESThetaC;
  };


  /**
   * \ingroup Adaption
   *
   * \brief
   * Guaranteed error reduction strategy
   */
  
  template <class Traits>
  class GERSMarker : public Marker<Traits>
  {
    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 EstType = std::vector<double>;

  public:
    /// Constructor.
    GERSMarker(std::string name_, std::string component_, const EstType& est_, std::shared_ptr<Grid> grid_)
      : Marker<Traits>(name_, component_, est_, grid_),
        oldErrSum(0.0),
        GERSThetaStar(0.6),
        GERSNu(0.1),
        GERSThetaC(0.1)
    {
      Parameters::get(this->name + "->GERSThetaStar", GERSThetaStar);
      Parameters::get(this->name + "->GERSNu", GERSNu);
      Parameters::get(this->name + "->GERSThetaC", GERSThetaC);
    }

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

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

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

  protected:
    /// Marking parameter.
    double GERSSum;

    /// Marking parameter.
    double oldErrSum;

    /// Marking parameter.
    double GERSThetaStar;

    /// Marking parameter.
    double GERSNu;

    /// Marking parameter.
    double GERSThetaC;
  };

}