adapt.h

// This file is part of Hermes2D.
//
// Hermes2D 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.
//
// Hermes2D 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 Hermes2D.  If not, see <http://www.gnu.org/licenses/>.

#ifndef __H2D_ADAPT_H
#define __H2D_ADAPT_H

#include "../space/space.h"
#include "error_calculator.h"
#include "../refinement_selectors/selector.h"
#include "exceptions.h"

namespace Hermes
{
  namespace Hermes2D
  {
    template<typename Scalar> class ErrorCalculator;

    template<typename Scalar>
    class AdaptivityStoppingCriterion
    {
    public:
      virtual bool add_refinement(ErrorCalculator<Scalar>* error_calculator, double processed_error_squared, double max_error_squared, int element_inspected_i) = 0;
    };

    template<typename Scalar>
    class HERMES_API AdaptStoppingCriterionCumulative : public AdaptivityStoppingCriterion < Scalar >
    {
    public:
      AdaptStoppingCriterionCumulative(double threshold);

      bool add_refinement(ErrorCalculator<Scalar>* error_calculator, double processed_error_squared, double max_error_squared, int element_inspected_i);
    private:
      double threshold;
    };

    template<typename Scalar>
    class HERMES_API AdaptStoppingCriterionSingleElement : public AdaptivityStoppingCriterion < Scalar >
    {
    public:
      AdaptStoppingCriterionSingleElement(double threshold);

      bool add_refinement(ErrorCalculator<Scalar>* error_calculator, double processed_error_squared, double max_error_squared, int element_inspected_i);
    private:
      double threshold;
    };

    template<typename Scalar>
    class HERMES_API AdaptStoppingCriterionLevels : public AdaptivityStoppingCriterion < Scalar >
    {
    public:
      AdaptStoppingCriterionLevels(double threshold);

      bool add_refinement(ErrorCalculator<Scalar>* error_calculator, double processed_error_squared, double max_error_squared, int element_inspected_i);
    private:
      double threshold;
    };


    template<typename Scalar>
    class HERMES_API Adapt :
      public Hermes::Mixins::TimeMeasurable,
      public Hermes::Mixins::Loggable,
      public Hermes::Mixins::StateQueryable,
      public Hermes::Hermes2D::Mixins::Parallel
    {
    public:
      Adapt(std::vector<SpaceSharedPtr<Scalar> > spaces, ErrorCalculator<Scalar>* error_calculator, AdaptivityStoppingCriterion<Scalar>* strategy = nullptr);
      Adapt(SpaceSharedPtr<Scalar> space, ErrorCalculator<Scalar>* error_calculator, AdaptivityStoppingCriterion<Scalar>* strategy = nullptr);
      Adapt(ErrorCalculator<Scalar>* error_calculator, AdaptivityStoppingCriterion<Scalar>* strategy = nullptr);
      virtual ~Adapt();
      void free();


      bool adapt(std::vector<RefinementSelectors::Selector<Scalar>*> refinement_selectors);


      bool adapt(RefinementSelectors::Selector<Scalar>* refinement_selector);

      void set_strategy(AdaptivityStoppingCriterion<Scalar>* strategy);

      void set_regularization_level(int regularization);

      virtual bool isOkay() const;
      inline std::string getClassName() const { return "Adapt"; }

      void set_spaces(std::vector<SpaceSharedPtr<Scalar> > spaces);
      void set_space(SpaceSharedPtr<Scalar> space);

      MeshFunctionSharedPtr<double> get_refinementInfoMeshFunction(int component = -1);
    protected:
      void set_defaults();

      void init_adapt(std::vector<RefinementSelectors::Selector<Scalar>*>& refinement_selectors, ElementToRefine*** element_refinement_location, MeshSharedPtr* meshes);
      int calculate_attempted_element_refinements_count();
      void adapt_postprocess(MeshSharedPtr* meshes, int element_refinements_count);
      void deinit_adapt(ElementToRefine*** element_refinement_location);

      void init();

      AdaptivityStoppingCriterion<Scalar>* strategy;


      void apply_refinement(const ElementToRefine& elem_ref);


      virtual void apply_refinements(ElementToRefine* elems_to_refine, int num_elem_to_process);


      void fix_shared_mesh_refinements(MeshSharedPtr * meshes, ElementToRefine*& elems_to_refine, int& num_elem_to_process, ElementToRefine*** refinement_location, RefinementSelectors::Selector<Scalar>** refinement_selectors);


      void homogenize_shared_mesh_orders(MeshSharedPtr * meshes);

      int num;

      int regularization;

      std::vector<MeshSharedPtr> meshes;
      std::vector<SpaceSharedPtr<Scalar> > spaces;

      ErrorCalculator<Scalar>* errorCalculator;

      ElementToRefine* elements_to_refine;
      int elements_to_refine_count;

      MeshFunctionSharedPtr<double> refinementInfoMeshFunction[H2D_MAX_COMPONENTS];
      MeshFunctionSharedPtr<double> refinementInfoMeshFunctionGlobal;
      template<typename T, typename S> friend class AdaptSolver;
    };
  }
}
#endif