filter.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_FILTER_H
#define __H2D_FILTER_H

#include "solution.h"
#include <complex>

namespace Hermes
{
  namespace Hermes2D
  {
    struct UniData;

    template<typename Scalar>
    class HERMES_API Filter : public MeshFunction<Scalar>
    {
    public:
      Filter();
      Filter(const Hermes::vector<MeshFunction<Scalar>*>& solutions);
      Filter(MeshFunction<Scalar>** solutions, int num);
      Filter(const Hermes::vector<Solution<Scalar>*>& solutions);

      virtual ~Filter();

      virtual void reinit();

      inline std::string getClassName() const { return "Filter"; }

    protected:
      void init(const Hermes::vector<MeshFunction<Scalar>*>& solutions);

      virtual void set_quad_2d(Quad2D* quad_2d);

      virtual void set_active_element(Element* e);

      virtual void free();

      virtual void push_transform(int son);

      virtual void pop_transform();

      virtual void init();

      int num;

      MeshFunction<Scalar>* sln[H2D_MAX_COMPONENTS];

      uint64_t sln_sub[H2D_MAX_COMPONENTS];

#ifdef _MSC_VER // For Visual Studio compiler the latter does not compile.
      std::map<uint64_t, LightArray<Node*>*> tables[H2D_MAX_QUADRATURES];
#else
      std::map<uint64_t, LightArray<struct Filter<Scalar>::Node*>*> tables[H2D_MAX_QUADRATURES];
#endif

      bool unimesh;

      UniData** unidata;

      void copy_base(Filter* flt);
      
      virtual void setDeleteSolutions();
      bool deleteSolutions;
    };

    template<typename Scalar>
    class HERMES_API SimpleFilter : public Filter<Scalar>
    {
    public:
      SimpleFilter();
      virtual ~SimpleFilter();

      SimpleFilter(const Hermes::vector<MeshFunction<Scalar>*>& solutions, const Hermes::vector<int>& items = Hermes::vector<int>());

      SimpleFilter(const Hermes::vector<Solution<Scalar>*>& solutions, const Hermes::vector<int>& items = Hermes::vector<int>());

      virtual Func<Scalar>* get_pt_value(double x, double y);

    protected:
      int item[H2D_MAX_COMPONENTS];

      virtual void filter_fn(int n, Hermes::vector<Scalar*> values, Scalar* result) = 0;

      void init_components();
      virtual void precalculate(int order, int mask);

    };

    class HERMES_API ComplexFilter : public Filter<double>
    {
    public:
      ComplexFilter(MeshFunction<std::complex<double> >* solution, int item = H2D_FN_VAL_0);

      virtual ~ComplexFilter();
    protected:
      virtual Func<double>* get_pt_value(double x, double y);

      virtual void set_quad_2d(Quad2D* quad_2d);

      virtual void set_active_element(Element* e);

      virtual void push_transform(int son);

      virtual void pop_transform();

      virtual void free();
      MeshFunction<std::complex<double> >* sln_complex;

      int item;

      virtual void filter_fn(int n, std::complex<double>* values, double* result) = 0;

      virtual void precalculate(int order, int mask);
    };

    template<typename Scalar>
    class HERMES_API DXDYFilter : public Filter<Scalar>
    {
    public:
      // one result (rslt), all inputs and result including derivatives
      DXDYFilter();

      DXDYFilter(const Hermes::vector<MeshFunction<Scalar>*>& solutions);

      DXDYFilter(const Hermes::vector<Solution<Scalar>*>& solutions);

      virtual ~DXDYFilter();
    protected:
      void init(const Hermes::vector<MeshFunction<Scalar>*>& solutions);

      virtual Func<Scalar>* get_pt_value(double x, double y);

      virtual void filter_fn (int n, Hermes::vector<Scalar *> values, Hermes::vector<Scalar *> dx, Hermes::vector<Scalar *> dy, Scalar* rslt, Scalar* rslt_dx, Scalar* rslt_dy) = 0;

      void init_components();

      virtual void precalculate(int order, int mask);
    };

    template<typename Scalar>
    class HERMES_API DXFilter : public DXDYFilter<Scalar>
    {
    public:
      DXFilter(const Hermes::vector<MeshFunction<Scalar>*>& solutions);
      
      virtual MeshFunction<Scalar>* clone() const;

      virtual ~DXFilter();
    protected:
      virtual void filter_fn(int n, Hermes::vector<Scalar *> values, Hermes::vector<Scalar *> dx, Hermes::vector<Scalar *> dy, Scalar* rslt, Scalar* rslt_dx, Scalar* rslt_dy);
    };

    template<typename Scalar>
    class HERMES_API MagFilter : public SimpleFilter<Scalar>
    {
    public:
      MagFilter(Hermes::vector<MeshFunction<Scalar>*> solutions, Hermes::vector<int> items = *(new Hermes::vector<int>));

      MagFilter(MeshFunction<Scalar>* sln1, int item1 = H2D_FN_VAL); 
      virtual MeshFunction<Scalar>* clone() const;

      virtual ~MagFilter();
    protected:
      virtual void filter_fn(int n, Hermes::vector<Scalar*> values, Scalar* result);
    };

    class HERMES_API TopValFilter : public SimpleFilter<double>
    {
    public:
      TopValFilter(Hermes::vector<MeshFunction<double>*> solutions, Hermes::vector<double> limits, Hermes::vector<int> items = *(new Hermes::vector<int>));

      TopValFilter(MeshFunction<double>* sln, double limit, int item = H2D_FN_VAL_0); 
      virtual MeshFunction<double>* clone() const;

      virtual ~TopValFilter();
    protected:
      virtual void filter_fn(int n, Hermes::vector<double*> values, double* result);
      Hermes::vector<double> limits;
    };

    class HERMES_API BottomValFilter : public SimpleFilter<double>
    {
    public:
      BottomValFilter(Hermes::vector<MeshFunction<double>*> solutions, Hermes::vector<double> limits, Hermes::vector<int> items = *(new Hermes::vector<int>));

      BottomValFilter(MeshFunction<double>* sln, double limit, int item = H2D_FN_VAL_0); 
      virtual MeshFunction<double>* clone() const;

      virtual ~BottomValFilter();
    protected:
      virtual void filter_fn(int n, Hermes::vector<double*> values, double* result);
      Hermes::vector<double> limits;
    };

    class HERMES_API ValFilter : public SimpleFilter<double>
    {
    public:
      ValFilter(Hermes::vector<MeshFunction<double>*> solutions, Hermes::vector<double> low_limits, Hermes::vector<double> high_limits, Hermes::vector<int> items = *(new Hermes::vector<int>));

      ValFilter(MeshFunction<double>* sln, double low_limit, double high_limit, int item = H2D_FN_VAL_0); 
      virtual MeshFunction<double>* clone() const;

      virtual ~ValFilter();
    protected:
      virtual void filter_fn(int n, Hermes::vector<double*> values, double* result);
      Hermes::vector<double> low_limits;
      Hermes::vector<double> high_limits;
    };

    template<typename Scalar>
    class HERMES_API DiffFilter : public SimpleFilter<Scalar>
    {
    public:
      DiffFilter(Hermes::vector<MeshFunction<Scalar>*> solutions, Hermes::vector<int> items = *(new Hermes::vector<int>));
      virtual MeshFunction<Scalar>* clone() const;
      virtual ~DiffFilter();

    protected:
      virtual void filter_fn(int n, Hermes::vector<Scalar*> values, Scalar* result);
    };

    template<typename Scalar>
    class HERMES_API SumFilter : public SimpleFilter<Scalar>
    {
    public:
      SumFilter(Hermes::vector<MeshFunction<Scalar>*> solutions, Hermes::vector<int> items = *(new Hermes::vector<int>));
      virtual MeshFunction<Scalar>* clone() const;
      virtual ~SumFilter();

    protected:
      virtual void filter_fn(int n, Hermes::vector<Scalar*> values, Scalar* result);
    };

    template<typename Scalar>
    class HERMES_API SquareFilter : public SimpleFilter<Scalar>
    {
    public:
      SquareFilter(Hermes::vector<MeshFunction<Scalar>*> solutions, Hermes::vector<int> items = *(new Hermes::vector<int>));
      virtual MeshFunction<Scalar>* clone() const;
      virtual ~SquareFilter();

    protected:
      virtual void filter_fn(int n, Hermes::vector<Scalar*> values, Scalar* result);
    };

    class HERMES_API AbsFilter : public SimpleFilter<double>
    {
    public:
      AbsFilter(Hermes::vector<MeshFunction<double>*> solutions, Hermes::vector<int> items = *(new Hermes::vector<int>));
      AbsFilter(MeshFunction<double>* solution);
      virtual MeshFunction<double>* clone() const;
      virtual ~AbsFilter();

    protected:
      virtual void filter_fn(int n, Hermes::vector<double*> values, double* result);
    };

    class HERMES_API RealFilter : public ComplexFilter
    {
    public:
      RealFilter(MeshFunction<std::complex<double> >* solution, int item = H2D_FN_VAL_0);
      virtual ~RealFilter();

      virtual MeshFunction<double>* clone() const;

    protected:
      virtual void filter_fn(int n, std::complex<double>* values, double* result);
    };

    class HERMES_API ImagFilter : public ComplexFilter
    {
    public:
      ImagFilter(MeshFunction<std::complex<double> >* solution, int item = H2D_FN_VAL_0);
      virtual ~ImagFilter();

      virtual MeshFunction<double>* clone() const;
    protected:
      virtual void filter_fn(int n, std::complex<double>* values, double* result);
    };

    class HERMES_API ComplexAbsFilter : public ComplexFilter
    {
    public:
      ComplexAbsFilter(MeshFunction<std::complex<double> >* solution, int item = H2D_FN_VAL_0);
      virtual ~ComplexAbsFilter();

      virtual MeshFunction<double>* clone() const;

    protected:
      virtual void filter_fn(int n, std::complex<double>* values, double* result);
    };

    class HERMES_API AngleFilter : public SimpleFilter<std::complex<double> >
    {
    public:
      AngleFilter(Hermes::vector<MeshFunction<std::complex<double> >*> solutions, Hermes::vector<int> items = *(new Hermes::vector<int>));
      virtual ~AngleFilter();

    protected:
      virtual void filter_fn(int n, Hermes::vector<std::complex<double>*> values, double* result);
    };

    class HERMES_API VonMisesFilter : public Filter<double>
    {
    public: 

      VonMisesFilter(Hermes::vector<MeshFunction<double>*> solutions, double lambda, double mu,
        int cyl = 0, int item1 = H2D_FN_VAL, int item2 = H2D_FN_VAL);
      VonMisesFilter(MeshFunction<double>** solutions, int num, double lambda, double mu,
        int cyl = 0, int item1 = H2D_FN_VAL, int item2 = H2D_FN_VAL);

      virtual Func<double>* get_pt_value(double x, double y);

      virtual MeshFunction<double>* clone() const;
      virtual ~VonMisesFilter();

    protected:
      double lambda, mu;

      int cyl, item1, item2;

      virtual void precalculate(int order, int mask);
    };

    template<typename Scalar>
    class HERMES_API LinearFilter : public Filter<Scalar>
    {
    public:
      LinearFilter(MeshFunction<Scalar>* old);

      LinearFilter(MeshFunction<Scalar>* older, MeshFunction<Scalar>* old, double tau_frac = 1);

      virtual Func<Scalar>* get_pt_value(double x, double y);
      virtual MeshFunction<Scalar>* clone() const;
      virtual ~LinearFilter();

    protected:
      double tau_frac;

      virtual void precalculate(int order, int mask);

      void init_components();

      virtual void set_active_element(Element* e);
    };
  }
}
#endif