explicit_runge_kutta_chebyshev_integrator.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <deal.II/lac/la_parallel_vector.h>
 
#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 <vector>
 
namespace MeltPoolDG::TimeIntegration
{
  inline static constexpr std::array<TimeIntegratorSchemes, 1> explicit_rkc_supported_schemes{{
    TimeIntegratorSchemes::RKC_n_stages,
  }};
 
  template <typename number>
  class ExplicitRungeKuttaChebyshevIntegrator final : public TimeIntegratorBase<number>
  {
  public:
    using VectorType = dealii::LinearAlgebra::distributed::Vector<number>;
 
    using RhsFunctionType = std::function<void(number,
                                               number,
                                               VectorType &,
                                               const VectorType &,
                                               std::function<void(unsigned, unsigned)>)>;
 
    explicit ExplicitRungeKuttaChebyshevIntegrator(
      const TimeIntegratorData<number> &time_integrator_data,
      const RhsFunctionType            &compute_rhs);
 
    unsigned int
    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:
    unsigned int n_stages;
 
    struct RecurrenceWeights
    {
      std::vector<number> mu_j;
 
      std::vector<number> nu_j;
 
      std::vector<number> mu_j_tilde;
 
      std::vector<number> gamma_j_tilde;
 
      std::vector<number> cj;
    };
 
    struct Registers
    {
      VectorType F0;
 
      VectorType Fj1;
 
      VectorType Yj1;
 
      VectorType Yj2;
    };
 
    RecurrenceWeights weights;
    Registers         registers;
 
    RhsFunctionType compute_rhs;
  };
} // namespace MeltPoolDG::TimeIntegration