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_LINEARIZER_H
#define __H2D_LINEARIZER_H

#include "thread_linearizer.h"
#include "linearizer_utils.h"
#ifndef NOGLUT
#include <pthread.h>
#endif
#include "../function/solution.h"

namespace Hermes
{
  namespace Hermes2D
  {
    namespace Views
    {
      template<typename LinearizerDataDimensions>
      class HERMES_API LinearizerMultidimensional :
        public Hermes::Mixins::TimeMeasurable,
        public Hermes::Mixins::Loggable,
        public Hermes::Hermes2D::Mixins::Parallel
      {
      public:
        LinearizerMultidimensional(LinearizerOutputType linearizerOutputType);
        ~LinearizerMultidimensional();

        void process_solution(MeshFunctionSharedPtr<double> sln, int item = H2D_FN_VAL_0);
        void process_solution(MeshFunctionSharedPtr<double>* sln, int* items);

        void save_solution_vtk(MeshFunctionSharedPtr<double> sln, const char* filename, const char* quantity_name, bool mode_3D = true, int item = H2D_FN_VAL_0);
        void save_solution_vtk(std::vector<MeshFunctionSharedPtr<double> > slns, std::vector<int> items, const char* filename, const char* quantity_name, bool mode_3D = true);
        void save_solution_tecplot(MeshFunctionSharedPtr<double> sln, const char* filename, const char* quantity_name, int item = H2D_FN_VAL_0);
        void save_solution_tecplot(std::vector<MeshFunctionSharedPtr<double> > slns, std::vector<int> items, const char* filename, std::vector<std::string> quantity_names);

        void set_criterion(LinearizerCriterion criterion);

        void set_displacement(MeshFunctionSharedPtr<double> xdisp, MeshFunctionSharedPtr<double> ydisp, double dmult = 1.0);

        template<typename T>
        class HERMES_API Iterator
        {
        public:
          Iterator(const LinearizerMultidimensional<LinearizerDataDimensions>* linearizer);
          void operator++();
          T& get() const;
          int& get_marker() const;
          bool end;
        private:
          int current_thread_index;
          int current_thread;
          int current_thread_size;
          std::vector<int> thread_sizes;
          const LinearizerMultidimensional<LinearizerDataDimensions>* linearizer;
          void check_zero_lengths();
          friend class LinearizerMultidimensional;
        };

        Iterator<typename LinearizerDataDimensions::vertex_t> vertices_begin() const;
        Iterator<typename LinearizerDataDimensions::triangle_t> triangles_begin() const;
        Iterator<typename LinearizerDataDimensions::edge_t> edges_begin() const;
        Iterator<triangle_indices_t> triangle_indices_begin() const;

        int get_vertex_count() const;
        int get_triangle_count() const;
        int get_edge_count() const;
        int get_triangle_index_count() const;

        void set_max_absolute_value(double max_abs);

        double get_min_value() const;
        double get_max_value() const;

        void set_curvature_epsilon(double curvature_epsilon);

        double get_curvature_epsilon() const;

        void free();

        LinearizerCriterion criterion;

        void lock_data() const;
        void unlock_data() const;

        void calc_vertices_aabb(double* min_x, double* max_x, double* min_y, double* max_y) const;

      protected:
        Quad2D *old_quad[LinearizerDataDimensions::dimension], *old_quad_x, *old_quad_y;

        LinearizerOutputType linearizerOutputType;

        void check_data(MeshFunctionSharedPtr<double>* sln);

        ThreadLinearizerMultidimensional<LinearizerDataDimensions>** threadLinearizerMultidimensional;

        void init(MeshFunctionSharedPtr<double>* sln, int* item);

        std::vector<MeshSharedPtr> meshes;

        double curvature_epsilon;

        bool user_xdisp, user_ydisp;

#ifndef NOGLUT
        mutable pthread_mutex_t data_mutex;
#endif

        MeshFunctionSharedPtr<double> xdisp, ydisp;

        double dmult;

        int item[LinearizerDataDimensions::dimension], component[LinearizerDataDimensions::dimension], value_type[LinearizerDataDimensions::dimension];

        // Finish - contour triangles calculation etc.
        void finish(MeshFunctionSharedPtr<double>* sln);

        Traverse::State** states;
        unsigned int num_states;

        double min_val, max_val;

        void find_min_max();

        friend class ThreadLinearizerMultidimensional < LinearizerDataDimensions > ;
      };

      typedef LinearizerMultidimensional<ScalarLinearizerDataDimensions<LINEARIZER_DATA_TYPE> > Linearizer;
      typedef LinearizerMultidimensional<VectorLinearizerDataDimensions<LINEARIZER_DATA_TYPE> > Vectorizer;
    }
  }
}
#endif