solution.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_SOLUTION_H
#define __H2D_SOLUTION_H

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

namespace Hermes
{
  namespace Hermes2D
  {
    class Quad2DCheb;

    enum SolutionType {
      HERMES_UNDEF = -1,
      HERMES_SLN = 0,
      HERMES_EXACT = 1
    };

    template<typename Scalar>
    class HERMES_API Solution :
      public MeshFunction<Scalar>,
      public Hermes2D::Mixins::XMLParsing
    {
    public:
      Solution();
      Solution(MeshSharedPtr mesh);
      Solution(SpaceSharedPtr<Scalar> s, Vector<Scalar>* coeff_vec);
      Solution(SpaceSharedPtr<Scalar> s, Scalar* coeff_vec);
      virtual ~Solution();

      virtual bool isOkay() const;
      virtual inline std::string getClassName() const { return "Solution"; }

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

      void set_dirichlet_lift(SpaceSharedPtr<Scalar> space);

      virtual void save(const char* filename) const;
#ifdef WITH_BSON
      virtual void save_bson(const char* filename) const;
#endif

      void load(const char* filename, SpaceSharedPtr<Scalar> space);
#ifdef WITH_BSON
      void load_bson(const char* filename, SpaceSharedPtr<Scalar> space);
#endif

      Scalar get_ref_value(Element* e, double xi1, double xi2, int component = 0, int item = 0);

      Scalar get_ref_value_transformed(Element* e, double xi1, double xi2, int a, int b);

      Scalar** get_ref_values_transformed(Element* e, double x, double y);

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

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

      virtual void multiply(Scalar coef);

      inline SolutionType get_type() const { return sln_type; };

      inline SpaceType get_space_type() const { return space_type; };

      virtual void set_active_element(Element* e);

      virtual MeshFunction<Scalar>* clone() const;

      void set_type(SolutionType type) { sln_type = type; };

      virtual void free();

      Scalar* mono_coeffs;

      int* elem_orders;
    protected:

      void enable_transform(bool enable = true);

      virtual void init();

      virtual void set_coeff_vector(SpaceSharedPtr<Scalar> space, const Vector<Scalar>* vec, bool add_dir_lift, int start_index);

      virtual void set_coeff_vector(SpaceSharedPtr<Scalar> space, const Scalar* coeffs, bool add_dir_lift, int start_index);

      SolutionType sln_type;
      SpaceType space_type;

      bool transform;

      int* elem_coeffs[H2D_MAX_SOLUTION_COMPONENTS];
      int num_coeffs, num_elems;
      int num_dofs;

      void transform_values(int order, int mask, int np);

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

      Scalar* dxdy_coeffs[H2D_MAX_SOLUTION_COMPONENTS][H2D_NUM_FUNCTION_VALUES];

      Scalar* dxdy_buffer;

      double** calc_mono_matrix(int mode, unsigned char o);

      void init_dxdy_buffer();

      void check_space_type_compliance(const char* space_type_to_check) const;

      void load_exact_solution(int number_of_components, SpaceSharedPtr<Scalar> space, bool complexness,
        double x_real, double y_real, double x_complex, double y_complex);

      Scalar x[H2D_MAX_INTEGRATION_POINTS_COUNT], y[H2D_MAX_INTEGRATION_POINTS_COUNT], tx[H2D_MAX_INTEGRATION_POINTS_COUNT];

#pragma region friends
      friend class RefMap;
      template<typename T> friend class KellyTypeAdapt;
      template<typename T> friend class Views::BaseView;
      template<typename T> friend class Views::VectorBaseView;
      template<typename T> friend class OGProjectionNOX;
      template<typename T> friend class Adapt;
      template<typename T> friend class Func;
      template<typename T> friend class DiscontinuousFunc;
      template<typename T> friend class DiscreteProblem;
      template<typename T> friend class DiscreteProblemIntegrationOrderCalculator;
      template<typename T> friend class NeighborSearch;
      template<typename T> friend class RefinementSelectors::ProjBasedSelector;
      template<typename T> friend class RefinementSelectors::H1ProjBasedSelector;
      template<typename T> friend class RefinementSelectors::L2ProjBasedSelector;
      template<typename T> friend class RefinementSelectors::HcurlProjBasedSelector;
#pragma endregion

#pragma region static
    public:
      static bool static_verbose_output;

      // Calculate derivative wrt. x of mono into result.
      static void make_dx_coeffs(int mode, int o, Scalar* mono, Scalar* result);
      // Calculate derivative wrt. y of mono into result.
      static void make_dy_coeffs(int mode, int o, Scalar* mono, Scalar* result);

      static void set_static_verbose_output(bool verbose);

      static void vector_to_solutions(const Scalar* solution_vector, std::vector<SpaceSharedPtr<Scalar> > spaces,
        std::vector<MeshFunctionSharedPtr<Scalar> > solutions,
        std::vector<bool> add_dir_lift = std::vector<bool>(),
        std::vector<int> start_indices = std::vector<int>());

      static void vector_to_solution(const Scalar* solution_vector, SpaceSharedPtr<Scalar> space, MeshFunctionSharedPtr<Scalar> solution,
        bool add_dir_lift = true, int start_index = 0);

      static void vector_to_solution(const Scalar* solution_vector, SpaceSharedPtr<Scalar> space, Solution<Scalar>* solution,
        bool add_dir_lift = true, int start_index = 0);

      static void vector_to_solutions(const Vector<Scalar>* vec, std::vector<SpaceSharedPtr<Scalar> > spaces,
        std::vector<MeshFunctionSharedPtr<Scalar> > solutions,
        std::vector<bool> add_dir_lift = std::vector<bool>(),
        std::vector<int> start_indices = std::vector<int>());

      static void vector_to_solutions_common_dir_lift(const Vector<Scalar>* vec, std::vector<SpaceSharedPtr<Scalar> > spaces,
        std::vector<MeshFunctionSharedPtr<Scalar> > solutions,
        bool add_dir_lift = false);

      static void vector_to_solutions_common_dir_lift(const Scalar* solution_vector, std::vector<SpaceSharedPtr<Scalar> > spaces,
        std::vector<MeshFunctionSharedPtr<Scalar> > solutions,
        bool add_dir_lift = false);

      static void vector_to_solution(const Vector<Scalar>* vec, SpaceSharedPtr<Scalar> space, MeshFunctionSharedPtr<Scalar> solution,
        bool add_dir_lift = true, int start_index = 0);

#pragma endregion
    };
  }
}

#endif