element.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_ELEMENT_H
#define __H2D_ELEMENT_H

#include "../global.h"
#include "curved.h"
#include "hash.h"

namespace Hermes
{
  namespace Hermes2D
  {
    class HashTable;

    enum 
    {
      HERMES_TYPE_VERTEX = 0,
      HERMES_TYPE_EDGE = 1
    };

    class Element;

    struct HERMES_API Node
    {
      int id;
      unsigned ref : 29;
      unsigned type : 1;
      unsigned bnd : 1;
      unsigned used : 1;

      union
      {
        struct
        {
          double x, y;
        };
        struct
        {
          int marker;
          Element* elem[2];
        };
      };

      int p1, p2;
      Node* next_hash;

      bool is_constrained_vertex() const;

      void ref_element(Element* e = nullptr);
      void unref_element(HashTable* ht, Element* e = nullptr);
    };

    class HERMES_API Element
    {
    public:
      Element();
      int id;
      bool active;
      bool used;
      Element* parent;
      bool visited;

      void calc_area(bool precise_for_curvature = false);

      void calc_diameter();

      void get_center(double& x, double& y);

      Node* vn[H2D_MAX_NUMBER_VERTICES];
      union
      {
        Node* en[H2D_MAX_NUMBER_EDGES];
        Element* sons[H2D_MAX_ELEMENT_SONS];
      };

      int marker;

      // returns the edge orientation. This works for the unconstrained edges.
      bool get_edge_orientation(int ie) const;

      ElementMode2D  get_mode() const {
        return (nvert == 3) ? HERMES_MODE_TRIANGLE : HERMES_MODE_QUAD;
      }

      inline bool is_triangle() const {
        return nvert == 3;
      }
      inline bool is_quad() const {
        return nvert == 4;
      }
      inline bool is_curved() const {
        return cm != nullptr;
      }
      inline unsigned char get_nvert() const {
        return this->nvert;
      }

      inline bool is_parallelogram() const
      {
        if (this->nvert == 3)
          return false;
        else if (this->id == -1)
          return true;

        const double eps = 1e-14;
        return fabs(this->vn[2]->x - (this->vn[1]->x + this->vn[3]->x - this->vn[0]->x)) < eps &&
          fabs(this->vn[2]->y - (this->vn[1]->y + this->vn[3]->y - this->vn[0]->y)) < eps;
      }

      inline bool has_const_ref_map() const
      {
        return (this->nvert == 3 || is_parallelogram()) && (!this->cm);
      }

      bool hsplit() const;
      bool vsplit() const;
      bool bsplit() const;

      CurvMap* cm;
      double area;

      bool center_set;
      double x_center, y_center;

      double diameter;

      unsigned short iro_cache;

      inline unsigned char next_vert(unsigned char i) const
      {
        return ((i + 1) % nvert);
      }

      inline unsigned char prev_vert(unsigned char i) const
      {
        return ((i + nvert - 1) % nvert);
      }

      Element* get_neighbor(int ie) const;

      void ref_all_nodes();
      void unref_all_nodes(HashTable* ht);

      unsigned char nvert;
    };

    static Node* get_edge_node();
    static Node* get_vertex_node(Node* v1, Node* v2);

    const int TOP_LEVEL_REF = 123456;
  }
}
#endif