Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <cmath>
       7              : #include <cstddef>
       8              : #include <limits>
       9              : #include <pup.h>
      10              : 
      11              : #include "DataStructures/DataBox/DataBox.hpp"
      12              : #include "Domain/MinimumGridSpacing.hpp"
      13              : #include "Options/String.hpp"
      14              : #include "Time/StepChoosers/StepChooser.hpp"
      15              : #include "Time/TimeStepRequest.hpp"
      16              : #include "Time/TimeSteppers/TimeStepper.hpp"
      17              : #include "Utilities/Serialization/CharmPupable.hpp"
      18              : #include "Utilities/TMPL.hpp"
      19              : 
      20              : /// \cond
      21              : namespace Tags {
      22              : template <typename StepperInterface>
      23              : struct TimeStepper;
      24              : }  // namespace Tags
      25              : namespace domain {
      26              : namespace Tags {
      27              : template <size_t Dim, typename Frame>
      28              : struct MinimumGridSpacing;
      29              : }  // namespace Tags
      30              : }  // namespace domain
      31              : 
      32              : /// \endcond
      33              : 
      34              : namespace StepChoosers {
      35              : /// Sets a goal based on the CFL stability criterion.
      36              : template <typename Frame, typename System>
      37            1 : class Cfl : public StepChooser<StepChooserUse::Slab>,
      38              :             public StepChooser<StepChooserUse::LtsStep> {
      39              :  public:
      40              :   /// \cond
      41              :   Cfl() = default;
      42              :   explicit Cfl(CkMigrateMessage* /*unused*/) {}
      43              :   using PUP::able::register_constructor;
      44              :   WRAPPED_PUPable_decl_template(Cfl);  // NOLINT
      45              :   /// \endcond
      46              : 
      47            0 :   struct SafetyFactor {
      48            0 :     using type = double;
      49            0 :     static constexpr Options::String help{"Multiplier for computed step"};
      50            0 :     static type lower_bound() { return 0.0; }
      51              :   };
      52              : 
      53            0 :   static constexpr Options::String help{
      54              :       "Sets a goal based on the CFL stability criterion."};
      55            0 :   using options = tmpl::list<SafetyFactor>;
      56              : 
      57            0 :   explicit Cfl(const double safety_factor) : safety_factor_(safety_factor) {}
      58              : 
      59            0 :   using argument_tags =
      60              :       tmpl::list<domain::Tags::MinimumGridSpacing<System::volume_dim, Frame>,
      61              :                  ::Tags::TimeStepper<TimeStepper>,
      62              :                  typename System::compute_largest_characteristic_speed::base>;
      63              : 
      64            0 :   using compute_tags = tmpl::list<
      65              :       domain::Tags::MinimumGridSpacingCompute<System::volume_dim, Frame>,
      66              :       typename System::compute_largest_characteristic_speed>;
      67              : 
      68            0 :   TimeStepRequest operator()(const double minimum_grid_spacing,
      69              :                              const TimeStepper& time_stepper,
      70              :                              const double speed, const double last_step) const {
      71              :     const double time_stepper_stability_factor = time_stepper.stable_step();
      72              :     const double step_size = safety_factor_ * time_stepper_stability_factor *
      73              :                              minimum_grid_spacing /
      74              :                              (speed * System::volume_dim);
      75              :     return {.size_goal = std::copysign(step_size, last_step)};
      76              :   }
      77              : 
      78            1 :   bool uses_local_data() const override { return true; }
      79            1 :   bool can_be_delayed() const override { return true; }
      80            1 :   bool must_set_step_size() const override { return false; }
      81              : 
      82              :   // NOLINTNEXTLINE(google-runtime-references)
      83            0 :   void pup(PUP::er& p) override {
      84              :     StepChooser<StepChooserUse::Slab>::pup(p);
      85              :     StepChooser<StepChooserUse::LtsStep>::pup(p);
      86              :     p | safety_factor_;
      87              :   }
      88              : 
      89              :  private:
      90            0 :   double safety_factor_ = std::numeric_limits<double>::signaling_NaN();
      91              : };
      92              : 
      93              : /// \cond
      94              : template <typename Frame, typename System>
      95              : PUP::able::PUP_ID Cfl<Frame, System>::my_PUP_ID = 0;  // NOLINT
      96              : /// \endcond
      97              : }  // namespace StepChoosers