neighbor.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"
namespace Hermes
{
  namespace Hermes2D
  {
    /*** Class NeighborSearch. ***/

    template<typename Scalar>
    class HERMES_API NeighborSearch
    {
    public:

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

      ~NeighborSearch();

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

      void set_active_edge(int edge);

      bool set_active_edge_multimesh(const int& edge);

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

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

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

      void handle_sub_idx_way_down(const Hermes::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(const Space<Scalar>* space, AsmList<Scalar>* al);
      ExtendedShapeset* create_extended_asmlist_multicomponent(const Space<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 Hermes::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, const Space<Scalar>*space);

        ExtendedShapeset(const ExtendedShapeset & other);

        ~ExtendedShapeset();

        void free_central_al();

        void combine_assembly_lists();

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

      public:
        int cnt;  
        int *dof; 

        bool has_support_on_neighbor(unsigned int index) const;

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

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

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

        int local_num_of_edge;  
        int 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;

      struct 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);
        Transformations(const Hermes::vector<unsigned int>& t);

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

        void copy_from(const Transformations* t);

        void copy_to(Hermes::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 Hermes::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 DiscreteProblem;
        template<typename T> friend class DiscreteProblemLinear;
      };

    private:

      const Mesh* mesh;

      /*** Transformations. ***/

      LightArray< Transformations* > central_transformations;     


      LightArray< Transformations* > neighbor_transformations;    

      uint64_t original_central_el_transform;                  


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

      int active_edge;               
      NeighborEdgeInfo neighbor_edge;
      int active_segment;            

      Hermes::vector<NeighborEdgeInfo> neighbor_edges;   
      Hermes::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);

      int 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 DiscreteProblem;
      template<typename T> friend class DiscreteProblemLinear;
    };
  }
}
#endif