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/linear_algebra/preconditioner_trilinos_wrapper.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>
 
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>
  {
  public:
    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)>;
 
    struct SolverFunctions
    {
      JacobianType compute_jacobian;
 
      ResidualType compute_residual;
 
      DistributeConstraintsType distribute_constraints;
 
      ExplicitRhsFunctionType compute_explicit_rhs;
    };
 
    explicit ImplicitExplicitIntegrator(
      const TimeIntegratorData<number>         &time_integrator_data,
      const SolverFunctions                     solver_functions,
      Preconditioner<dim, VectorType, number> &&preconditioner_in =
        Preconditioner<dim, VectorType, number>(IdentityPreconditioner<dim, VectorType, number>()));
 
    unsigned
    required_solution_history_size() const override;
 
    void
    reinit(const VectorType &vector_template) override;
 
    void
    reinit(const SolutionHistory<VectorType> &solution_history) override;
 
    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;
 
    ExplicitRhsFunctionType explicit_compute_rhs;
 
    VectorType intermediate_explicit_solution;
 
    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