discrete_problem.h

#ifndef __H2D_DISCRETE_PROBLEM_H
#define __H2D_DISCRETE_PROBLEM_H

#include "hermes_common.h"
#include "weakform/weakform.h"
#include "function/function.h"
#include "exceptions.h"
#include "mixins2d.h"
#include "discrete_problem_helpers.h"
#include "discrete_problem_thread_assembler.h"

namespace Hermes
{
  namespace Hermes2D
  {
    class PrecalcShapeset;
    template<typename Scalar>
    class HERMES_API DiscreteProblem :
      public Hermes::Mixins::Loggable,
      public Hermes::Mixins::TimeMeasurable,
      public Hermes::Hermes2D::Mixins::SettableSpaces<Scalar>,
      public Hermes::Mixins::StateQueryable,
      public Hermes::Hermes2D::Mixins::DiscreteProblemRungeKutta<Scalar>,
      public Hermes::Hermes2D::Mixins::DiscreteProblemWeakForm<Scalar>,
      public Hermes::Mixins::IntegrableWithGlobalOrder,
      public Hermes::Hermes2D::Mixins::DiscreteProblemMatrixVector<Scalar>,
      public Hermes::Hermes2D::Mixins::Parallel
    {
    public:
      DiscreteProblem(WeakFormSharedPtr<Scalar> wf, std::vector<SpaceSharedPtr<Scalar> > spaces, bool linear = false, bool dirichlet_lift_accordingly = true);
      DiscreteProblem(WeakFormSharedPtr<Scalar> wf, SpaceSharedPtr<Scalar> space, bool linear = false, bool dirichlet_lift_accordingly = true);
      DiscreteProblem(bool linear = false, bool dirichlet_lift_accordingly = true);
      virtual ~DiscreteProblem();

      bool assemble(Scalar*& coeff_vec, SparseMatrix<Scalar>* mat, Vector<Scalar>* rhs = nullptr);
      bool assemble(Scalar*& coeff_vec, Vector<Scalar>* rhs = nullptr);
      bool assemble(SparseMatrix<Scalar>* mat, Vector<Scalar>* rhs = nullptr);
      bool assemble(Vector<Scalar>* rhs);

      void set_time(double time);
      void set_time_step(double time_step);

      void set_spaces(std::vector<SpaceSharedPtr<Scalar> > spaces);
      void set_space(SpaceSharedPtr<Scalar> space);

      void set_weak_formulation(WeakFormSharedPtr<Scalar> wf);

      std::vector<SpaceSharedPtr<Scalar> > get_spaces();

      typedef void(*reassembled_states_reuse_linear_system_fn)(Traverse::State**& states, unsigned int& num_states, SparseMatrix<Scalar>* mat, Vector<Scalar>* rhs, Vector<Scalar>* dirichlet_lift_rhs, Scalar*& coeff_vec);
      void set_reassembled_states_reuse_linear_system_fn(reassembled_states_reuse_linear_system_fn fn) {
        this->reassembled_states_reuse_linear_system = fn;
      }
      reassembled_states_reuse_linear_system_fn reassembled_states_reuse_linear_system;
      void set_reusable_DOFs(bool **reusable_DOFs, bool **reusable_Dirichlet)
      {
        for (int i = 0; i < this->num_threads_used; i++)
        {
          this->threadAssembler[i]->reusable_DOFs = reusable_DOFs;
          this->threadAssembler[i]->reusable_Dirichlet = reusable_Dirichlet;
        }
      }

      virtual void set_verbose_output(bool to_set);

    protected:
      void init_assembling(Traverse::State**& states, unsigned int& num_states, std::vector<MeshSharedPtr>& meshes);
      void deinit_assembling(Traverse::State** states, unsigned  int num_states);

      void set_RK(int original_spaces_count, bool force_diagonal_blocks = nullptr, Table* block_weights = nullptr);

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

      void init(bool linear, bool dirichlet_lift_accordingly);

      std::vector<SpaceSharedPtr<Scalar> > spaces;
      int spaces_size;

      Vector<Scalar>* dirichlet_lift_rhs;

      bool nonlinear, add_dirichlet_lift;

      bool set_matrix(SparseMatrix<Scalar>* mat);
      bool set_rhs(Vector<Scalar>* rhs);
      void invalidate_matrix();

      DiscreteProblemThreadAssembler<Scalar>** threadAssembler;

      DiscreteProblemSelectiveAssembler<Scalar> selectiveAssembler;

      template<typename T> friend class Solver;
      template<typename T> friend class LinearSolver;
      template<typename T, typename S> friend class AdaptSolver;
      template<typename T> friend class NonlinearSolver;
      template<typename T> friend class NewtonSolver;
      template<typename T> friend class PicardSolver;
      template<typename T> friend class RungeKutta;
      template<typename T> friend class KellyTypeAdapt;
    };
  }
}
#endif