neighbor_search.h

#ifndef __H2D_NEIGHBOR_H
#define __H2D_NEIGHBOR_H

#include "mesh/mesh.h"
#include "quadrature/quad.h"
#include "function/solution.h"
#include "forms.h"
#include "mesh/refmap.h"
#include "asmlist.h"
#include "space/space.h"
#include "adapt/error_thread_calculator.h"

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

    /*** Class NeighborSearch. ***/

    template<typename Scalar>
    class HERMES_API NeighborSearch
    {
    public:

      NeighborSearch(Element* el, MeshSharedPtr mesh);
      NeighborSearch(const NeighborSearch& ns);

      ~NeighborSearch();

      void free();

      /*** Methods for changing active state for further calculations. ***/

      void set_active_edge(int edge);

      bool set_active_edge_multimesh(const int& edge);

      std::vector<unsigned int> get_transforms(uint64_t sub_idx) const;

      bool is_inter_edge(const int& edge, const std::vector<unsigned int>& transformations) const;

      void update_according_to_sub_idx(const std::vector<unsigned int>& transformations);

      void handle_sub_idx_way_down(const std::vector<unsigned int>& transformations);

      bool compatible_transformations(unsigned int a, unsigned int b, int edge) const;

      void clear_initial_sub_idx();

      void delete_neighbor(unsigned int position);

      DiscontinuousFunc<Scalar>* init_ext_fn(MeshFunction<Scalar>* fu);

      class ExtendedShapeset;
      ExtendedShapeset *supported_shapes;

      ExtendedShapeset* create_extended_asmlist(SpaceSharedPtr<Scalar> space, AsmList<Scalar>* al);
      ExtendedShapeset* create_extended_asmlist_multicomponent(SpaceSharedPtr<Scalar> space, AsmList<Scalar>* al);

      /*** Methods for working with quadrature on the active edge. ***/

      void set_quad_order(int order);

      int get_quad_eo(bool on_neighbor = false) const;

      /*** Methods for retrieving additional information about the neighborhood. ***/

      int get_num_neighbors() const;

      const std::vector<Element*>* get_neighbors() const;

      void clear_supported_shapes();

      void set_ignore_errors(bool value);

      class ExtendedShapeset
      {
      public:
        ExtendedShapeset(NeighborSearch<Scalar>* neighborhood, AsmList<Scalar>* central_al, SpaceSharedPtr<Scalar>space);

        ExtendedShapeset(const ExtendedShapeset & other);

        ~ExtendedShapeset();

        void free_central_al();

        void combine_assembly_lists();

        void update(NeighborSearch* neighborhood, SpaceSharedPtr<Scalar> space);

      public:
        int cnt;
        int *dof;

        bool has_support_on_neighbor(unsigned int index) const;

        AsmList<Scalar>* central_al;
        AsmList<Scalar>* neighbor_al;

        // Only a NeighborSearch is allowed to create an ExtendedShapeset.
        friend class NeighborSearch;
      };

      /*** Neighborhood information. ***/
      class NeighborEdgeInfo
      {
      public:
        NeighborEdgeInfo() : local_num_of_edge(-1), orientation(false) {};

        int local_num_of_edge;
        bool orientation;
      };

      bool ignore_errors;

      int get_active_segment() const;

      void set_active_segment(unsigned int index);

      Element* get_neighb_el() const;

      NeighborEdgeInfo get_neighbor_edge() const;

      unsigned int get_central_n_trans(unsigned int index) const;

      unsigned int get_central_transformations(unsigned int index_1, unsigned int index_2) const;

      unsigned int get_neighbor_n_trans(unsigned int index) const;

      unsigned int get_neighbor_transformations(unsigned int index_1, unsigned int index_2) const;

      class HERMES_API Transformations
      {
      public:
        static const int max_level = Transformable::H2D_MAX_TRN_LEVEL;

        unsigned int transf[max_level];
        unsigned int num_levels;

        Transformations();
        Transformations(const Transformations* t);
        void operator=(const Transformations* t);
        Transformations(const std::vector<unsigned int>& t);

        void copy_from(const std::vector<unsigned int>& t);

        void copy_from(const Transformations* t);

        void copy_to(std::vector<unsigned int>* t);

        void reset();

        void strip_initial_transformations(unsigned int number_of_stripped);

        void apply_on(Transformable* tr) const;

        void apply_on(const std::vector<Transformable*>& tr) const;

        template<typename T> friend class NeighborSearch;
        template<typename T> friend class KellyTypeAdapt;
        template<typename T> friend class Adapt;
        template<typename T> friend class Func;
        template<typename T> friend class DiscontinuousFunc;
        template<typename T> friend class MultimeshDGNeighborTree;
      };

      MeshSharedPtr mesh;

      /*** Transformations. ***/
      static const unsigned int H2D_INITIAL_NEIGHBOR_NUMBER_GUESS = 32;

      Transformations** central_transformations;

      void add_central_transformations(Transformations* to_add, int position, bool replace = false);
      unsigned int central_transformations_size;
      unsigned int central_transformations_alloc_size;
      Transformations** neighbor_transformations;

      void add_neighbor_transformations(Transformations* to_add, int position, bool replace = false);
      unsigned int neighbor_transformations_size;
      unsigned int neighbor_transformations_alloc_size;
      uint64_t original_central_el_transform;

      /*** Significant objects of the neighborhood. ***/
      Element* central_el;
      Element* neighb_el;

    private:
      int active_edge;
      NeighborEdgeInfo neighbor_edge;
      int active_segment;

      std::vector<NeighborEdgeInfo> neighbor_edges;
      std::vector<Element*> neighbors;
      unsigned int n_neighbors;

      enum NeighborhoodType
      {
        H2D_DG_NOT_INITIALIZED = -1,
        H2D_DG_NO_TRANSF = 0, 
        H2D_DG_GO_DOWN = 1,   
        H2D_DG_GO_UP = 2      
      };
      NeighborhoodType neighborhood_type;

      void find_act_elem_up(Element* elem, int* orig_vertex_id, Node** par_mid_vertices, int n_parents);

      void find_act_elem_down(Node* vertex, int* bounding_verts_id, int* sons, unsigned int n_sons);

      bool neighbor_edge_orientation(int bounding_vert1, int bounding_vert2, int segment) const;

      void reset_neighb_info();

      /*** Quadrature on the active edge. ***/
      Quad2D* quad;

      int central_quad_order;
      int neighb_quad_order;

      template<typename T> friend class KellyTypeAdapt;
      template<typename T> friend class Adapt;
      template<typename T> friend class Func;
      template<typename T> friend class DiscontinuousFunc;
      template<typename T> friend class MultimeshDGNeighborTree;
      template<typename T> friend class DiscreteProblemDGAssembler;
      template<typename T> friend class DiscreteProblemIntegrationOrderCalculator;
      template<typename T> friend class ErrorThreadCalculator<T>::DGErrorCalculator;
    };
  }
}
#endif