traverse.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_TRAVERSE_H
#define __H2D_TRAVERSE_H

#include "hermes_common.h"
#include "mesh.h"

namespace Hermes
{
  namespace Hermes2D
  {
    struct SurfPos
    {
      int marker;
      int surf_num;

      Element *base;

      int v1, v2;
      double t;
      double lo, hi;
    };

    class Mesh;
    class Transformable;
    struct Rect;

    struct UniData
    {
      Element* e;
      uint64_t idx;
    };

    static const uint64_t ONE = (uint64_t)1 << 63;

    struct Rect
    {
      uint64_t l, b, r, t;
    };

    class HERMES_API Traverse : public Hermes::Mixins::Loggable
    {
    public:
      Traverse(int spaces_size);
      class State
      {
      public:
        Element** e;
        uint64_t* sub_idx;
        bool bnd[H2D_MAX_NUMBER_EDGES];
        bool isBnd;
        unsigned char isurf;
        Element* rep;
        unsigned short rep_i;
        ~State();
        unsigned short num;
        static State* clone(const State * other);
      private:
        State();
        //void operator=(const State * other);
        void push_transform(unsigned char son, unsigned char i, bool is_triangle = false);
        bool is_triangle();
        uint64_t get_transform(unsigned char i);
        bool visited;
        Rect  cr;
        Rect* er;
        friend class Traverse;
        template<typename Scalar> friend class DiscreteProblem;
        template<typename T> friend class DiscreteProblemDGAssembler;
        template<typename T> friend class DiscreteProblemThreadAssembler;
      };

      State** get_states(std::vector<MeshSharedPtr> meshes, unsigned int& states_count);
      State** get_states(MeshSharedPtr* meshes, unsigned short meshes_count, unsigned int& states_count);

      template<typename Scalar>
      State** get_states(std::vector<MeshFunctionSharedPtr<Scalar> > mesh_functions, unsigned int& states_count);

    private:
      void begin(int n);
      void finish();
      void init_transforms(State* s, unsigned char i);

#pragma region union-mesh
      static UniData** construct_union_mesh(unsigned char n, MeshSharedPtr* meshes, MeshSharedPtr unimesh);
      void union_recurrent(Rect* cr, Element** e, Rect* er, uint64_t* idx, Element* uni);
      uint64_t init_idx(Rect* cr, Rect* er);

      UniData** unidata;
      int udsize;
#pragma endregion

      unsigned short num;
      State* stack;
      int top, size;

      State* push_state(int* top_by_ref = nullptr);
      void set_boundary_info(State* s);
      void free_state(State* state);
      unsigned char spaces_size;

      MeshSharedPtr unimesh;
      template<typename T> friend class Adapt;
      template<typename T> friend class KellyTypeAdapt;
      template<typename T> friend class DiscreteProblem;
      template<typename T> friend class DiscreteProblemDGAssembler;
      template<typename T> friend class DiscreteProblemIntegrationOrderCalculator;
      template<typename T> friend class Filter;
      template<typename T> friend class SimpleFilter;
      friend class Views::Orderizer;
    };
  }
}
#endif