time_integrator.h

Go to the documentation of this file.

//
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// Copyright (C) 2022 - 2024 by the ryujin authors
//
 
#pragma once
 
#include <compile_time_options.h>
 
#include "convenience_macros.h"
#include "hyperbolic_module.h"
#include "offline_data.h"
#include "parabolic_module.h"
#include "patterns_conversion.h"
 
namespace ryujin
{
  enum class CFLRecoveryStrategy {
    none,
 
    bang_bang_control,
  };
 
 
  enum class TimeSteppingScheme {
    ssprk_22,
    ssprk_33,
 
    erk_11,
 
    erk_22,
 
    erk_33,
 
    erk_43,
 
    erk_54,
 
    strang_ssprk_33_cn,
 
    strang_erk_33_cn,
 
    strang_erk_43_cn,
  };
} // namespace ryujin
 
#ifndef DOXYGEN
DECLARE_ENUM(ryujin::CFLRecoveryStrategy,
             LIST({ryujin::CFLRecoveryStrategy::none, "none"},
                  {ryujin::CFLRecoveryStrategy::bang_bang_control,
                   "bang bang control"}));
 
DECLARE_ENUM(
    ryujin::TimeSteppingScheme,
    LIST({ryujin::TimeSteppingScheme::ssprk_22, "ssprk 22"},
         {ryujin::TimeSteppingScheme::ssprk_33, "ssprk 33"},
         {ryujin::TimeSteppingScheme::erk_11, "erk 11"},
         {ryujin::TimeSteppingScheme::erk_22, "erk 22"},
         {ryujin::TimeSteppingScheme::erk_33, "erk 33"},
         {ryujin::TimeSteppingScheme::erk_43, "erk 43"},
         {ryujin::TimeSteppingScheme::erk_54, "erk 54"},
         {ryujin::TimeSteppingScheme::strang_ssprk_33_cn, "strang ssprk 33 cn"},
         {ryujin::TimeSteppingScheme::strang_erk_33_cn, "strang erk 33 cn"},
         {ryujin::TimeSteppingScheme::strang_erk_43_cn, "strang erk 43 cn"}, ));
#endif
 
namespace ryujin
{
  template <typename Description, int dim, typename Number = double>
  class TimeIntegrator final : public dealii::ParameterAcceptor
  {
  public:
    using HyperbolicSystem = typename Description::HyperbolicSystem;
 
    using ParabolicSystem = typename Description::ParabolicSystem;
 
    using View =
        typename Description::template HyperbolicSystemView<dim, Number>;
 
    static constexpr unsigned int problem_dimension = View::problem_dimension;
 
    static constexpr unsigned int n_precomputed_values =
        View::n_precomputed_values;
 
    using vector_type = MultiComponentVector<Number, problem_dimension>;
 
    using precomputed_type = MultiComponentVector<Number, n_precomputed_values>;
 
    TimeIntegrator(
        const MPI_Comm &mpi_communicator,
        std::map<std::string, dealii::Timer> &computing_timer,
        const OfflineData<dim, Number> &offline_data,
        const HyperbolicModule<Description, dim, Number> &hyperbolic_module,
        const ParabolicModule<Description, dim, Number> &parabolic_module,
        const std::string &subsection = "/TimeIntegrator");
 
    void prepare();
 
 
    Number step(vector_type &U, Number t);
 
    ACCESSOR_READ_ONLY(time_stepping_scheme);
 
    ACCESSOR_READ_ONLY(efficiency);
 
  protected:
    Number step_ssprk_22(vector_type &U, Number t);
 
    Number step_ssprk_33(vector_type &U, Number t);
 
    Number step_erk_11(vector_type &U, Number t);
 
    Number step_erk_22(vector_type &U, Number t);
 
    Number step_erk_33(vector_type &U, Number t);
 
    Number step_erk_43(vector_type &U, Number t);
 
    Number step_erk_54(vector_type &U, Number t);
 
    Number step_strang_ssprk_33_cn(vector_type &U, Number t);
 
    Number step_strang_erk_33_cn(vector_type &U, Number t);
 
    Number step_strang_erk_43_cn(vector_type &U, Number t);
 
  private:
 
 
    Number cfl_min_;
    Number cfl_max_;
 
    CFLRecoveryStrategy cfl_recovery_strategy_;
 
    TimeSteppingScheme time_stepping_scheme_;
    double efficiency_;
 
 
 
 
    const MPI_Comm &mpi_communicator_;
    std::map<std::string, dealii::Timer> &computing_timer_;
 
    dealii::SmartPointer<const OfflineData<dim, Number>> offline_data_;
    dealii::SmartPointer<const HyperbolicModule<Description, dim, Number>>
        hyperbolic_module_;
    dealii::SmartPointer<const ParabolicModule<Description, dim, Number>>
        parabolic_module_;
 
    std::vector<vector_type> U_;
    std::vector<precomputed_type> precomputed_;
 
  };
 
} /* namespace ryujin */