discrete_problem_dg_assembler.h

#ifndef __H2D_DISCRETE_PROBLEM_DG_ASSEMBLER_H
#define __H2D_DISCRETE_PROBLEM_DG_ASSEMBLER_H

#include "hermes_common.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 "multimesh_dg_neighbor_tree.h"
#include "discrete_problem/discrete_problem_selective_assembler.h"

namespace Hermes
{
  namespace Hermes2D
  {
    template<typename Scalar>
    class HERMES_API DiscreteProblemDGAssembler
    {
    public:
      DiscreteProblemDGAssembler(DiscreteProblemThreadAssembler<Scalar>* threadAssembler, const std::vector<SpaceSharedPtr<Scalar> > spaces, std::vector<MeshSharedPtr>& meshes);

      ~DiscreteProblemDGAssembler();

      void init_assembling_one_state(Traverse::State* current_state_);
      void assemble_one_state();
      void deinit_assembling_one_state();

      static unsigned int dg_order;
    private:
      bool DG_matrix_forms_present;

      bool DG_vector_forms_present;

      void init_assembling_one_neighbor();
      void assemble_one_neighbor(bool edge_processed, unsigned int neighbor_i, NeighborSearch<Scalar>** neighbor_searches);
      void deinit_assembling_one_neighbor();

      DiscontinuousFunc<Scalar>** init_ext_fns(std::vector<MeshFunctionSharedPtr<Scalar> > ext,
        NeighborSearch<Scalar>** neighbor_searches, int order);

      bool init_neighbors(NeighborSearch<Scalar>** neighbor_searches, Traverse::State* current_state);
      void deinit_neighbors(NeighborSearch<Scalar>** neighbor_searches, Traverse::State* current_state);

      NeighborSearch<Scalar>*** neighbor_searches;
      unsigned int* num_neighbors;
      bool** processed;

      // Neighbor psss, refmaps.
      PrecalcShapesetAssembling ** npss;
      RefMap ** nrefmaps;

      PrecalcShapesetAssembling** pss;
      RefMap** refmaps;
      Solution<Scalar>** u_ext;
      AsmList<Scalar>* als;
      std::vector<Transformable *> fns;
      WeakFormSharedPtr<Scalar> wf;
      int spaces_size;
      bool nonlinear;
      DiscreteProblemSelectiveAssembler<Scalar>* selectiveAssembler;

      SparseMatrix<Scalar>* current_mat;
      Vector<Scalar>* current_rhs;

      Traverse::State* current_state;
      Scalar local_stiffness_matrix[H2D_MAX_LOCAL_BASIS_SIZE * H2D_MAX_LOCAL_BASIS_SIZE * 4];

      const std::vector<SpaceSharedPtr<Scalar> > spaces;
      const std::vector<MeshSharedPtr>& meshes;

      template<typename T> friend class DiscreteProblem;
      template<typename T> friend class DiscreteProblemIntegrationOrderCalculator;

      static NeighborSearch<Scalar>* get_neighbor_search_ext(WeakFormSharedPtr<Scalar> wf, NeighborSearch<Scalar>** neighbor_searches, int index);

#ifdef DEBUG_DG_ASSEMBLING
      void debug();
#endif
    };
  }
}
#endif