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_FUNCTION_H
#define __H2D_FUNCTION_H

#include "transformable.h"
#include "../quadrature/quad.h"
#include "exceptions.h"
namespace Hermes
{
  namespace Hermes2D
  {
    struct SurfPos;
    class PrecalcShapeset;
    namespace RefinementSelectors{
      template<typename Scalar> class Selector;
      template<typename Scalar> class HOnlySelector;
      template<typename Scalar> class POnlySelector;
      template<typename Scalar> class OptimumSelector;
      template<typename Scalar> class ProjBasedSelector;
      template<typename Scalar> class L2ProjBasedSelector;
      template<typename Scalar> class H1ProjBasedSelector;
      template<typename Scalar> class HcurlProjBasedSelector;
    };

    enum
    {
      H2D_FN_VAL_0 = 0x0001, H2D_FN_VAL_1 = 0x0040, // Function values
      H2D_FN_DX_0 = 0x0002, H2D_FN_DX_1 = 0x0080, // First derivative
      H2D_FN_DY_0 = 0x0004, H2D_FN_DY_1 = 0x0100, // First derivative
#ifdef H2D_USE_SECOND_DERIVATIVES
      H2D_FN_DXX_0 = 0x0008, H2D_FN_DXX_1 = 0x0200, // Second derivative
      H2D_FN_DYY_0 = 0x0010, H2D_FN_DYY_1 = 0x0400, // Second derivative
      H2D_FN_DXY_0 = 0x0020, H2D_FN_DXY_1 = 0x0800  // Second mixed derivative
#endif
    };

    const int H2D_FN_VAL = H2D_FN_VAL_0 | H2D_FN_VAL_1;
    const int H2D_FN_DX = H2D_FN_DX_0 | H2D_FN_DX_1;
    const int H2D_FN_DY = H2D_FN_DY_0 | H2D_FN_DY_1;
    const int H2D_FN_DEFAULT = H2D_FN_VAL | H2D_FN_DX | H2D_FN_DY;

#ifdef H2D_USE_SECOND_DERIVATIVES
    const int H2D_FN_COMPONENT_0 = H2D_FN_VAL_0 | H2D_FN_DX_0 | H2D_FN_DY_0 | H2D_FN_DXX_0 | H2D_FN_DYY_0 | H2D_FN_DXY_0;
    const int H2D_FN_COMPONENT_1 = H2D_FN_VAL_1 | H2D_FN_DX_1 | H2D_FN_DY_1 | H2D_FN_DXX_1 | H2D_FN_DYY_1 | H2D_FN_DXY_1;
#else
    const int H2D_FN_COMPONENT_0 = H2D_FN_VAL_0 | H2D_FN_DX_0 | H2D_FN_DY_0;
    const int H2D_FN_COMPONENT_1 = H2D_FN_VAL_1 | H2D_FN_DX_1 | H2D_FN_DY_1;
#endif

    const int H2D_GRAD = H2D_FN_DX_0 | H2D_FN_DY_0;
    const int H2D_CURL = H2D_FN_DX | H2D_FN_DY;

#ifdef H2D_USE_SECOND_DERIVATIVES
    const int H2D_FN_DXX = H2D_FN_DXX_0 | H2D_FN_DXX_1;
    const int H2D_FN_DYY = H2D_FN_DYY_0 | H2D_FN_DYY_1;
    const int H2D_FN_DXY = H2D_FN_DXY_0 | H2D_FN_DXY_1;

    const int H2D_SECOND = H2D_FN_DXX_0 | H2D_FN_DXY_0 | H2D_FN_DYY_0;

    const int H2D_FN_ALL = H2D_FN_DEFAULT | H2D_FN_DXX | H2D_FN_DYY | H2D_FN_DXY;
#endif

    template<typename Scalar>
    class HERMES_API Function : public Transformable
    {
    public:

      Function();

      virtual ~Function();

      unsigned char get_num_components() const;

      virtual const Scalar* get_fn_values(int component = 0) const;

      virtual const Scalar* get_dx_values(int component = 0) const;

      virtual const Scalar* get_dy_values(int component = 0) const;

#ifdef H2D_USE_SECOND_DERIVATIVES
      virtual const Scalar* get_dxx_values(int component = 0) const;

      virtual const Scalar* get_dyy_values(int component = 0) const;

      virtual const Scalar* get_dxy_values(int component = 0) const;
#endif

      Scalar* deep_copy_array(int component = 0, int item = 0) const;

      Quad2D* get_quad_2d() const;

      void set_quad_order(unsigned short order, unsigned short mask = H2D_FN_DEFAULT);

      virtual const Scalar* get_values(int component, int item) const;

      virtual int get_fn_order() const;

      virtual void push_transform(int son);

      virtual void pop_transform();

      virtual void set_active_element(Element* e);

      virtual void set_transform(uint64_t idx);

    protected:
      virtual void set_quad_2d(Quad2D* quad_2d);

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

      virtual void free() = 0;

      Scalar values[H2D_MAX_SOLUTION_COMPONENTS][H2D_NUM_FUNCTION_VALUES][H2D_MAX_INTEGRATION_POINTS_COUNT];
      bool values_valid;

      virtual int get_edge_fn_order(unsigned char edge) const;

      virtual void precalculate(unsigned short order, unsigned short mask);

      int order;

      unsigned char num_components;

      void invalidate_values();

      Quad2D* quads[H2D_MAX_QUADRATURES];
      int cur_quad;

      static int idx2mask[H2D_NUM_FUNCTION_VALUES][2];

      template<typename T> friend class KellyTypeAdapt;
      template<typename T> friend class RefinementSelectors::H1ProjBasedSelector;
      template<typename T> friend class RefinementSelectors::L2ProjBasedSelector;
      template<typename T> friend class RefinementSelectors::HcurlProjBasedSelector;
      template<typename T> friend class Adapt;

      template<typename T> friend class DiscontinuousFunc;
      template<typename T> friend class DiscreteProblem;
      friend class CurvMap;

      template<typename T> friend class Func;
      template<typename T> friend class Filter;
      template<typename T> friend class SimpleFilter;
      template<typename T> friend class DXDYFilter;
      friend class ComplexFilter;
      friend class VonMisesFilter;
      friend HERMES_API Func<double>* init_fn(PrecalcShapeset *fu, RefMap *rm, const int order);
      template<typename T> friend HERMES_API Func<T>* init_fn(MeshFunction<T>*fu, const int order);
    };
  }
}
#endif