transformable.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_TRANSFORM_H
#define __H2D_TRANSFORM_H

#include "../global.h"
#include "exceptions.h"
namespace Hermes
{
  namespace Hermes2D
  {
    class Element;
    template<typename Scalar> class Func;

    struct Trf
    {
      double2 m; 
      double2 t; 
    };

    extern HERMES_API Trf tri_trf[H2D_TRF_NUM];
    extern HERMES_API Trf quad_trf[H2D_TRF_NUM];

    class HERMES_API Transformable : public Hermes::Mixins::Loggable
    {
    public:
      inline Element* get_active_element() const { return this->element; }

      virtual void set_transform(uint64_t idx);

      uint64_t get_transform() const;

      virtual ~Transformable();

      virtual void push_transform(int son);

      virtual void pop_transform();

      static const unsigned int H2D_MAX_TRN_LEVEL = 15;

    protected:

      Transformable();

      virtual void set_active_element(Element* e);

      virtual void reset_transform();

      inline double get_transform_jacobian() const { return ctm->m[0] * ctm->m[1]; }

      inline Trf* get_ctm() const { return ctm; }

      virtual void force_transform(uint64_t sub_idx, Trf* ctm);

      inline unsigned int get_depth() const { return top; }

      static void push_transforms(std::set<Transformable *>& transformables, int son);
      static void pop_transforms(std::set<Transformable *>& transformables);

      Element* element;

      Trf* ctm;
      uint64_t sub_idx;

      static const uint64_t H2D_MAX_IDX = (1ULL << 3 * H2D_MAX_TRN_LEVEL) - 1;

      Trf stack[21];
      unsigned int top;

      template<typename T> friend class KellyTypeAdapt;
      template<typename T> friend class Adapt;
      template<typename T> friend class Func;
      template<typename T> friend class Function;
      template<typename T> friend class DiscontinuousFunc;
      template<typename T> friend class DiscreteProblem;
      template<typename T> friend class DiscreteProblemDGAssembler;
      template<typename T> friend class DiscreteProblemThreadAssembler;
      template<typename T> friend class NeighborSearch;
      friend class CurvMap;
      friend class Traverse;
    };
  }
}
#endif