mesh.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_MESH_H
#define __H2D_MESH_H

#include "element.h"
#include "mesh_util.h"
#include "hash.h"
#include "../mixins2d.h"

namespace Hermes
{
  namespace Hermes2D
  {
    class Element;
    class HashTable;

    template<typename Scalar> class Space;
    template<typename Scalar> class KellyTypeAdapt;
    struct MItem;
    struct Rect;
    extern HERMES_API unsigned g_mesh_seq;

    namespace RefinementSelectors
    {
      template<typename Scalar> class Selector;
      template<typename Scalar> class POnlySelector;
      template<typename Scalar> class HOnlySelector;
      template<typename Scalar> class OptimumSelector;
      template<typename Scalar> class ProjBasedSelector;
      template<typename Scalar> class H1ProjBasedSelector;
      template<typename Scalar> class L2ProjBasedSelector;
      template<typename Scalar> class HcurlProjBasedSelector;
    }
    class HERMES_API Mesh : public HashTable,
      public Hermes::Mixins::StateQueryable
    {
    public:
      Mesh();
      virtual ~Mesh();

      void init(int size = H2D_DEFAULT_HASH_SIZE);

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

      bool rescale(double x_ref, double y_ref);

      void copy(MeshSharedPtr mesh);

      void copy_base(MeshSharedPtr mesh);

      void copy_converted(MeshSharedPtr mesh);

      void create(int nv, double2* verts, int nt, int3* tris, std::string* tri_markers,
        int nq, int4* quads, std::string* quad_markers, int nm, int2* mark, std::string* boundary_markers);

#pragma region MeshHashGrid
      Element* element_on_physical_coordinates(double x, double y);

      MeshHashGrid* meshHashGrid;
#pragma endregion

#pragma region MarkerArea
      double get_marker_area(int marker);

      std::map<int, MarkerArea*> marker_areas;
#pragma endregion

#pragma region getters
      Element* get_element(int id) const;

      int get_num_elements() const;

      int get_num_base_elements() const;

      int get_num_used_base_elements() const;

      int get_num_active_elements() const;

      int get_max_element_id() const;

      int get_num_vertex_nodes() const;

      int get_num_edge_nodes() const;

      void get_bounding_box(double& bottom_left_x, double& bottom_left_y, double& top_right_x, double& top_right_y);

      Element* get_element_fast(int id) const;

      unsigned get_seq() const;
#pragma endregion

#pragma region refinements
      void refine_element_id(int id, int refinement = 0);

      void refine_all_elements(int refinement = 0, bool mark_as_initial = false);

      void refine_by_criterion(int(*criterion)(Element* e), int depth = 1, bool mark_as_initial = false);

      void refine_towards_vertex(int vertex_id, int depth = 1, bool mark_as_initial = false);

      void refine_towards_boundary(std::vector<std::string> markers, int depth = 1, bool aniso = true, bool mark_as_initial = false);
      void refine_towards_boundary(std::string marker, int depth = 1, bool aniso = true, bool mark_as_initial = false);

      void refine_in_area(std::string marker, int depth = 1, int refinement = 0, bool mark_as_initial = false);
      void refine_in_areas(std::vector<std::string> markers, int depth = 1, int refinement = 0, bool mark_as_initial = false);

      int* regularize(int n);

      void unrefine_element_id(int id);

      void unrefine_all_elements(bool keep_initial_refinements = true);
#pragma endregion

      class HERMES_API ReferenceMeshCreator
      {
      public:
        ReferenceMeshCreator(MeshSharedPtr coarse_mesh, int refinement = 0);

        virtual MeshSharedPtr create_ref_mesh();

      private:
        MeshSharedPtr coarse_mesh;
        int refinement;
      };

      class HERMES_API MarkersConversion
      {
      public:
        MarkersConversion();

        int insert_marker(std::string user_marker);

        struct StringValid
        {
          StringValid();
          StringValid(std::string marker, bool valid);
          std::string marker;
          bool valid;
        };

        struct IntValid
        {
          IntValid();
          IntValid(int marker, bool valid);
          int marker;
          bool valid;
        };

        StringValid get_user_marker(int internal_marker) const;

        IntValid get_internal_marker(std::string user_marker) const;

        enum MarkersConversionType {
          HERMES_ELEMENT_MARKERS_CONVERSION = 0,
          HERMES_BOUNDARY_MARKERS_CONVERSION = 1
        };

        virtual MarkersConversionType get_type() const = 0;

        int size() const;

      protected:
        int min_marker_unused;

        std::map<int, std::string> conversion_table;

        std::map<std::string, int> conversion_table_inverse;

        friend class Space < double > ;
        friend class Space < std::complex<double> > ;
        friend class Mesh;
      };

      void free();

      void set_seq(unsigned seq);

      int nbase, ntopvert, ninitial, nactive;

      class ElementMarkersConversion : public MarkersConversion
      {
      public:
        ElementMarkersConversion();
        virtual MarkersConversionType get_type() const;
      };

      class BoundaryMarkersConversion : public MarkersConversion
      {
      public:
        BoundaryMarkersConversion();
        virtual MarkersConversionType get_type() const;
      };

      ElementMarkersConversion element_markers_conversion;
      BoundaryMarkersConversion boundary_markers_conversion;
      Array<Element> elements;

      unsigned seq;

      void initial_single_check();

    private:
      void convert_quads_to_triangles();

      void convert_to_base();

      void refine_element_to_quads_id(int id);

      void refine_triangle_to_quads(Element* e, Element** elems_out = nullptr);

      void refine_element_to_triangles_id(int id);

      void refine_quad_to_triangles(Element* e);

      void refine_quad_to_quads(Element* e, int refinement = 0);

      void convert_element_to_base_id(int id);
      void convert_triangles_to_base(Element* e);
      void convert_quads_to_base(Element* e);

      double bottom_left_x, bottom_left_y, top_right_x, top_right_y;
      bool bounding_box_calculated;
      void calc_bounding_box();

      void unrefine_element_internal(Element* e);

      int* parents;
      int parents_size;

      int  get_edge_degree(Node* v1, Node* v2);
      void assign_parent(Element* e, int i);
      void regularize_triangle(Element* e);
      void regularize_quad(Element* e);
      void flatten();

      class HERMES_API CurvedException : public Hermes::Exceptions::Exception
      {
      public:
        CurvedException(int elementId);
        CurvedException(const CurvedException & e);

        int getElementId() const;
      private:
        int elementId;
      };

      friend class MeshHashGrid;
      friend class MeshReaderH2D;
      friend class MeshReaderH2DBSON;
      friend class MeshReaderH2DXML;
      friend class MeshReaderH1DXML;
      friend class MeshReaderExodusII;
      friend class DiscreteProblem < double > ;
      friend class DiscreteProblem < std::complex<double> > ;
      template<typename Scalar> friend class DiscreteProblemDGAssembler;
      friend class WeakForm < double > ;
      friend class WeakForm < std::complex<double> > ;
      template<typename Scalar> friend class Adapt;
      friend class KellyTypeAdapt < double > ;
      friend class KellyTypeAdapt < std::complex<double> > ;
      template<typename Scalar> friend class Solution;
      template<typename Scalar> friend class Filter;
      template<typename Scalar> friend class MeshFunction;
      friend class RefMap;
      friend class Traverse;
      friend class Transformable;
      friend class Curved;
      friend class Views::MeshView;
      template<typename Scalar> friend class RefinementSelectors::Selector;
      template<typename Scalar> friend class RefinementSelectors::POnlySelector;
      template<typename Scalar> friend class RefinementSelectors::HOnlySelector;
      template<typename Scalar> friend class RefinementSelectors::OptimumSelector;
      template<typename Scalar> friend class RefinementSelectors::ProjBasedSelector;
      template<typename Scalar> friend class RefinementSelectors::H1ProjBasedSelector;
      template<typename Scalar> friend class RefinementSelectors::L2ProjBasedSelector;
      template<typename Scalar> friend class RefinementSelectors::HcurlProjBasedSelector;
      friend class PrecalcShapeset;
      template<typename Scalar> friend class Space;
      template<typename Scalar> friend class H1Space;
      template<typename Scalar> friend class HcurlSpace;
      template<typename Scalar> friend class HdivSpace;
      template<typename Scalar> friend class L2Space;
      friend class Views::ScalarView;
      friend class Views::Orderizer;
    public:
      const ElementMarkersConversion &get_element_markers_conversion() const;
      const BoundaryMarkersConversion &get_boundary_markers_conversion() const;
      ElementMarkersConversion &get_element_markers_conversion();
      BoundaryMarkersConversion &get_boundary_markers_conversion();

      Element* create_quad(int marker, Node* v0, Node* v1, Node* v2, Node* v3, CurvMap* cm, int id = -1);
      Element* create_triangle(int marker, Node* v0, Node* v1, Node* v2, CurvMap* cm, int id = -1);
      void refine_element(Element* e, int refinement);

      std::vector<std::pair<unsigned int, int> > refinements;

      void refine_quad(Element* e, int refinement, Element** sons_out = nullptr);
      void refine_triangle_to_triangles(Element* e, Element** sons = nullptr);

      static double vector_length(double a_1, double a_2);

      static bool same_line(double p_1, double p_2, double q_1, double q_2, double r_1, double r_2);

      static bool is_convex(double a_1, double a_2, double b_1, double b_2);
      static void check_triangle(int i, Node *&v0, Node *&v1, Node *&v2);
      static void check_quad(int i, Node *&v0, Node *&v1, Node *&v2, Node *&v3);

      friend class EggShell;
    };

    class HERMES_API EggShell
    {
    public:
      static MeshSharedPtr get_egg_shell(MeshSharedPtr mesh, std::string marker, unsigned int levels);

      static MeshSharedPtr get_egg_shell(MeshSharedPtr mesh, std::vector<std::string> markers, unsigned int levels);

      static const std::string eggShell1Marker;
      static const std::string eggShell0Marker;

      static const std::string eggShellMarker;

      static bool egg_shell_verbose;

    private:
      static void get_egg_shell_structures(MeshSharedPtr target_mesh, std::vector<std::string> markers, unsigned int levels);

      static void handle_vertex_on_target_mesh(Element* e, int vertex, MeshSharedPtr target_mesh, std::vector<int> markers, int* neighbor_targets_local);

      static void fix_hanging_nodes(MeshSharedPtr target_mesh);

      static void mark_elements_down_used(int eggShell_marker_volume, Element* element);

      static const std::string eggShellInnerMarker;

      static void fix_markers(MeshSharedPtr target_mesh, MeshSharedPtr original_mesh);
    };
  }
}
#endif