discrete_problem_integration_order_calculator.h

#ifndef __H2D_DISCRETE_PROBLEM_INTEGRATION_ORDER_CALCULATOR_H
#define __H2D_DISCRETE_PROBLEM_INTEGRATION_ORDER_CALCULATOR_H

#include "hermes_common.h"
#include "adapt/adapt.h"
#include "graph.h"
#include "forms.h"
#include "weakform/weakform.h"
#include "function/function.h"
#include "neighbor_search.h"
#include "refinement_selectors/selector.h"
#include "exceptions.h"
#include "mixins2d.h"
#include "discrete_problem_helpers.h"

namespace Hermes
{
  namespace Hermes2D
  {
    class PrecalcShapeset;
    template<typename Scalar>
    class HERMES_API DiscreteProblemIntegrationOrderCalculator :
      public Hermes::Hermes2D::Mixins::DiscreteProblemRungeKutta < Scalar >
    {
    private:
      DiscreteProblemIntegrationOrderCalculator(DiscreteProblemSelectiveAssembler<Scalar>* selectiveAssembler);

      void adjust_order_to_refmaps(Form<Scalar> *form, int& order, Hermes::Ord* o, RefMap** current_refmaps);

      template<typename MatrixFormType>
      int calc_order_matrix_form(const std::vector<SpaceSharedPtr<Scalar> >& spaces, MatrixFormType* mf, RefMap** current_refmaps, Func<Hermes::Ord>** ext, Func<Hermes::Ord>** u_ext);

      template<typename VectorFormType>
      int calc_order_vector_form(const std::vector<SpaceSharedPtr<Scalar> >& spaces, VectorFormType* vf, RefMap** current_refmaps, Func<Hermes::Ord>** ext, Func<Hermes::Ord>** u_ext);

      int calculate_order(const std::vector<SpaceSharedPtr<Scalar> >& spaces, RefMap** current_refmaps, WeakFormSharedPtr<Scalar> current_wf);

      Func<Hermes::Ord>** init_u_ext_orders();
      void deinit_u_ext_orders(Func<Hermes::Ord>** u_ext_func);

      Func<Hermes::Ord>** init_ext_orders(std::vector<MeshFunctionSharedPtr<Scalar> >& ext, std::vector<UExtFunctionSharedPtr<Scalar> >& u_ext_fns, Func<Hermes::Ord>** u_ext_func);
      void deinit_ext_orders(Func<Hermes::Ord>** ext_func);

      int calc_order_dg_matrix_form(const std::vector<SpaceSharedPtr<Scalar> > spaces, Traverse::State* state, MatrixFormDG<Scalar>* mfDG, RefMap** current_refmaps, Solution<Scalar>** current_u_ext, bool neighbor_supp_u, bool neighbor_supp_v, NeighborSearch<Scalar>** neighbor_searches);

      int calc_order_dg_vector_form(const std::vector<SpaceSharedPtr<Scalar> > spaces, Traverse::State* state, VectorFormDG<Scalar>* vfDG, RefMap** current_refmaps, Solution<Scalar>** current_u_ext, bool neighbor_supp_v, NeighborSearch<Scalar>** neighbor_searches);

      DiscontinuousFunc<Hermes::Ord>* init_ext_fn_ord(NeighborSearch<Scalar>* ns, MeshFunctionSharedPtr<Scalar> fu);

      DiscontinuousFunc<Hermes::Ord>** init_ext_fns_ord(std::vector<MeshFunctionSharedPtr<Scalar> > &ext,
        NeighborSearch<Scalar>** neighbor_searches);

      template<typename FormType>
      void deinit_ext_fns_ord(Form<Scalar> *form, FormType** oi, FormType** oext);

      DiscreteProblemSelectiveAssembler<Scalar>* selectiveAssembler;

      Solution<Scalar>** u_ext;
      Func<Hermes::Ord>** ext_orders;
      Func<Hermes::Ord>** u_ext_orders;
      Traverse::State* current_state;

      template<typename T> friend class DiscreteProblem;
      template<typename T> friend class DiscreteProblemThreadAssembler;
    };
  }
}
#endif