implicit_explicit_integrator.hpp

Go to the documentation of this file.

#pragma once
 
#include <deal.II/lac/la_parallel_vector.h>
 
#include <meltpooldg/linear_algebra/newton_raphson_solver.hpp>
#include <meltpooldg/linear_algebra/preconditioner.hpp>
#include <meltpooldg/time_integration/solution_history.hpp>
#include <meltpooldg/time_integration/time_integrator_base.hpp>
#include <meltpooldg/time_integration/time_integrator_data.hpp>
 
#include <functional>
#include <optional>
 
namespace MeltPoolDG::TimeIntegration
{
  inline static constexpr std::array<TimeIntegratorSchemes, 1> imex_supported_schemes{
    {TimeIntegratorSchemes::imex}};
 
 
  template <unsigned int dim, typename number>
  class ImplicitExplicitIntegrator final : public TimeIntegratorBase<number>
  {
    using VectorType = dealii::LinearAlgebra::distributed::Vector<number>;
 
    using ExplicitRhsFunctionType =
      std::function<void(number,
                         number,
                         VectorType &,
                         const VectorType &,
                         const bool,
                         const std::function<void(unsigned, unsigned)> &)>;
 
    using JacobianType =
      std::function<void(number time, number time_step, VectorType &dst, const VectorType &src)>;
 
    using ResidualType = std::function<void(number            time,
                                            number            time_step,
                                            const VectorType &src,
                                            VectorType       &dst,
                                            const VectorType &explicit_solution)>;
 
    using DistributeConstraintsType = std::function<void(VectorType &dst)>;
 
    using CustomSolverType = std::function<void(number            time,
                                                number            time_step,
                                                const VectorType &explicit_step_solution,
                                                const VectorType &solution)>;
 
  public:
    explicit ImplicitExplicitIntegrator(const TimeIntegratorData<number> &time_integrator_data);
 
    unsigned
    required_solution_history_size() const override;
 
    void
    reinit(const VectorType &vector_template) override;
 
    void
    reinit(const SolutionHistory<VectorType> &solution_history) override;
 
    void
    configure_explicit_step(ExplicitRhsFunctionType explicit_rhs);
 
    void
    configure_implicit_step_wo_internal_nonlinear_solver(CustomSolverType custom_solver_in);
 
    void
    configure_implicit_step(
      JacobianType              jacobian,
      ResidualType              residual,
      DistributeConstraintsType constraints = [](VectorType &) {});
 
    void
    set_preconditioner(Preconditioner<dim, VectorType, number> &&preconditioner_in);
 
    void
    perform_time_step(const number                 current_time,
                      const number                 time_step,
                      SolutionHistory<VectorType> &solution_history,
                      const std::function<void(number, number, VectorType &, const VectorType &)>
                        &stage_pre_processing,
                      const std::function<void(number, number, VectorType &, const VectorType &)>
                        &stage_post_processing) override;
 
  private:
    ResidualType compute_residual;
 
    JacobianType compute_jacobian;
 
    DistributeConstraintsType distribute_constraints;
 
    CustomSolverType custom_solver;
 
    ExplicitRhsFunctionType explicit_compute_rhs;
 
    VectorType intermediate_explicit_solution;
 
    std::optional<NewtonRaphsonSolver<number, VectorType>> solver;
 
    Preconditioner<dim, VectorType, number> preconditioner;
 
    bool preconditioner_update_flag = false;
 
    unsigned n_steps_performed = 0;
 
    void
    apply_explicit_step(number            time,
                        number            time_step,
                        const VectorType &src,
                        VectorType       &dst) const;
 
    void
    apply_implicit_step(number      time,
                        number      time_step,
                        VectorType &explicit_solution,
                        VectorType &solution);
  };
} // namespace MeltPoolDG::TimeIntegration