mesh_function.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_MESH_FUNCTION_H
#define __H2D_MESH_FUNCTION_H

#include "function.h"
#include "../mesh/refmap.h"
#include "../space/space.h"
#include "exceptions.h"

namespace Hermes
{
  namespace Hermes2D
  {
    template<typename Scalar>
    class HERMES_API MeshFunctionSharedPtr : public std::tr1::shared_ptr < Hermes::Hermes2D::MeshFunction<Scalar> >
    {
    public:
      MeshFunctionSharedPtr(Hermes::Hermes2D::MeshFunction<Scalar>* ptr = nullptr);

      MeshFunctionSharedPtr(const MeshFunctionSharedPtr<Scalar>& other);

      void operator=(const MeshFunctionSharedPtr<Scalar>& other);

      Hermes::Hermes2D::Solution<Scalar>* get_solution();
    };

    template<typename Scalar>
    class HERMES_API MeshFunction : public Function<Scalar>, public Hermes::Mixins::StateQueryable
    {
    public:
      MeshFunction();

      MeshFunction(MeshSharedPtr mesh);

      virtual ~MeshFunction();

      MeshSharedPtr get_mesh() const;

      virtual void copy(const MeshFunction<Scalar>* sln);
      virtual void copy(MeshFunctionSharedPtr<Scalar> sln);

      RefMap* get_refmap(bool update = true);

      virtual Func<Scalar>* get_pt_value(double x, double y, bool use_MeshHashGrid = false, Element* e = nullptr) = 0;

      virtual MeshFunction<Scalar>* clone() const = 0;

      virtual void multiply(Scalar coef);

      virtual void add(MeshFunctionSharedPtr<Scalar>& other_mesh_function, SpaceSharedPtr<Scalar> target_space);

      virtual Scalar get_approx_max_value(int item = H2D_FN_VAL_0);

      virtual Scalar get_approx_min_value(int item = H2D_FN_VAL_0);

      virtual bool isOkay() const;

      std::string getClassName() const;

      virtual void init();

      virtual void free();

      virtual void reinit();

      virtual void set_quad_2d(Quad2D* quad_2d);

      virtual void set_active_element(Element* e);

      virtual int get_edge_fn_order(int edge);
    protected:
      ElementMode2D mode;
      MeshSharedPtr mesh;
      RefMap refmap;

      void update_refmap();

      friend class RefMap;
      template<typename T> friend class KellyTypeAdapt;
      template<typename T> friend class Adapt;

      template<typename T> friend class Func;

      template<typename T> friend HERMES_API Func<T>* init_fn(MeshFunction<T>*fu, const int order);

      template<typename T> friend class DiscontinuousFunc;
      template<typename T> friend class DiscreteProblem;
      template<typename T> friend class NeighborSearch;
    };
  }
}

#endif