Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <cstddef>
       7              : 
       8              : #include "DataStructures/TaggedVariant.hpp"
       9              : #include "Options/String.hpp"
      10              : #include "Time/TimeSteppers/RungeKutta.hpp"
      11              : #include "Utilities/Serialization/CharmPupable.hpp"
      12              : #include "Utilities/TMPL.hpp"
      13              : 
      14              : /// \cond
      15              : namespace TimeSteppers {
      16              : template <typename T>
      17              : class UntypedHistory;
      18              : }  // namespace TimeSteppers
      19              : /// \endcond
      20              : 
      21              : namespace TimeSteppers {
      22              : 
      23              : /*!
      24              :  * \ingroup TimeSteppersGroup
      25              :  *
      26              :  * The standard 4th-order Runge-Kutta method, given e.g. in
      27              :  * https://en.wikipedia.org/wiki/Runge-Kutta_methods
      28              :  * that solves equations of the form
      29              :  *
      30              :  * \f{eqnarray}{
      31              :  * \frac{du}{dt} & = & \mathcal{L}(t,u).
      32              :  * \f}
      33              :  * Given a solution \f$u(t^n)=u^n\f$, this stepper computes
      34              :  * \f$u(t^{n+1})=u^{n+1}\f$ using the following equations:
      35              :  *
      36              :  * \f{eqnarray}{
      37              :  * v^{(1)} & = & u^n + dt\cdot \mathcal{L}(t^n, u^n)/2,\\
      38              :  * v^{(2)} & = & u^n + dt\cdot \mathcal{L}(t^n + dt/2, v^{(1)})/2,\\
      39              :  * v^{(3)} & = & u^n + dt\cdot \mathcal{L}(t^n + dt/2, v^{(2)}),\\
      40              :  * v^{(4)} & = & u^n + dt\cdot \mathcal{L}(t^n + dt, v^{(3)}),\\
      41              :  * u^{n+1} & = & (2v^{(1)} + 4v^{(2)} + 2v^{(3)} + v^{(4)} - 3 u^n)/6.
      42              :  * \f}
      43              :  *
      44              :  * Note that in the implementation, the expression for \f$u^{n+1}\f$ is
      45              :  * computed simultaneously with \f$v^{(4)}\f$, so that there are
      46              :  * actually only four substeps per step.
      47              :  *
      48              :  * The CFL factor/stable step size is 1.3926467817026411.
      49              :  */
      50            1 : class ClassicalRungeKutta4 : public RungeKutta {
      51              :  public:
      52            0 :   using options = tmpl::list<>;
      53            0 :   static constexpr Options::String help = {
      54              :       "The standard fourth-order Runge-Kutta time-stepper."};
      55              : 
      56            0 :   ClassicalRungeKutta4() = default;
      57            0 :   ClassicalRungeKutta4(const ClassicalRungeKutta4&) = default;
      58            0 :   ClassicalRungeKutta4& operator=(const ClassicalRungeKutta4&) = default;
      59            0 :   ClassicalRungeKutta4(ClassicalRungeKutta4&&) = default;
      60            0 :   ClassicalRungeKutta4& operator=(ClassicalRungeKutta4&&) = default;
      61            0 :   ~ClassicalRungeKutta4() override = default;
      62              : 
      63            1 :   variants::TaggedVariant<Tags::FixedOrder, Tags::VariableOrder> order()
      64              :       const override;
      65              : 
      66            1 :   double stable_step() const override;
      67              : 
      68            0 :   WRAPPED_PUPable_decl_template(ClassicalRungeKutta4);  // NOLINT
      69              : 
      70            0 :   explicit ClassicalRungeKutta4(CkMigrateMessage* /*unused*/) {}
      71              : 
      72            0 :   const ButcherTableau& butcher_tableau() const override;
      73              : };
      74              : 
      75            0 : inline bool constexpr operator==(const ClassicalRungeKutta4& /*lhs*/,
      76              :                                  const ClassicalRungeKutta4& /*rhs*/) {
      77              :   return true;
      78              : }
      79              : 
      80            0 : inline bool constexpr operator!=(const ClassicalRungeKutta4& /*lhs*/,
      81              :                                  const ClassicalRungeKutta4& /*rhs*/) {
      82              :   return false;
      83              : }
      84              : }  // namespace TimeSteppers