thread_linearizer.h

Go to the documentation of this file.

// 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_THREAD_LINEARIZER_H
#define __H2D_THREAD_LINEARIZER_H

#include "linearizer.h"
#include "linearizer_utils.h"
#include <pthread.h>
#include "../function/mesh_function.h"

namespace Hermes
{
  namespace Hermes2D
  {
    namespace Views
    {
      template<typename LinearizerDataDimensions>
      class HERMES_API LinearizerMultidimensional;

      template<typename LinearizerDataDimensions>
      class HERMES_API ThreadLinearizerMultidimensional
      {
      public:
        void free();

      private:
        ThreadLinearizerMultidimensional(LinearizerMultidimensional<LinearizerDataDimensions>* linearizer);
        ~ThreadLinearizerMultidimensional();

        void init_linearizer_data(LinearizerMultidimensional<LinearizerDataDimensions>* linearizer);

        void init_processing(MeshFunctionSharedPtr<double>* sln, LinearizerMultidimensional<LinearizerDataDimensions>* linearizer);
        void deinit_processing();

        void process_state(Traverse::State* current_state);

        int hash(int p1, int p2);
        int peek_vertex(int p1, int p2);

        void process_edge(int iv1, int iv2, int marker);
        void add_edge(int iv1, int iv2, int marker);
        void add_triangle(int iv0, int iv1, int iv2, int marker);

        int add_vertex();
        int get_vertex(int p1, int p2, double x, double y, double* value);

        void process_triangle(int iv0, int iv1, int iv2, int level);
        void process_quad(int iv0, int iv1, int iv2, int iv3, int level);

        void split_decision(int& split, int iv0, int iv1, int iv2, int iv3, ElementMode2D mode, const double** val, double* phx, double* phy, unsigned short* indices) const;

        bool quad_flip(int iv0, int iv1, int iv2, int iv3) const;

        double get_max_value(Traverse::State* current_state);
        double max_value_approx;

        void push_transforms(int transform);

        void pop_transforms();

        void reallocate(MeshSharedPtr mesh);

        MeshFunction<double>* fns[LinearizerDataDimensions::dimension + 2];

        LinearizerCriterion criterion;

        typename LinearizerDataDimensions::triangle_t* triangles;
        typename LinearizerDataDimensions::edge_t* edges;
        int* edge_markers;

        triangle_indices_t* triangle_indices;

        typename LinearizerDataDimensions::vertex_t* vertices;
        int* triangle_markers;
        int* hash_table;
        internal_vertex_info_t* info;

        int vertex_count, triangle_count, edges_count;
        int vertex_size, triangle_size, edges_size;

        double midval[LinearizerDataDimensions::dimension + 2][5];
        const double* val[LinearizerDataDimensions::dimension];
        Element* rep_element;
        bool curved;

        LinearizerOutputType linearizerOutputType;

        int item[LinearizerDataDimensions::dimension], component[LinearizerDataDimensions::dimension], value_type[LinearizerDataDimensions::dimension];
        bool user_xdisp, user_ydisp;
        double dmult;
        double curvature_epsilon;

        friend class LinearizerMultidimensional < LinearizerDataDimensions > ;
      };
    }
  }
}
#endif