Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <array>
       7              : #include <cmath>
       8              : #include <cstddef>
       9              : #include <limits>
      10              : #include <memory>
      11              : #include <ostream>
      12              : #include <pup.h>
      13              : 
      14              : #include "DataStructures/DataVector.hpp"
      15              : #include "Domain/FunctionsOfTime/FunctionOfTime.hpp"
      16              : #include "Utilities/Serialization/CharmPupable.hpp"
      17              : 
      18              : namespace domain {
      19            1 : namespace FunctionsOfTime {
      20              : /*!
      21              :  * \ingroup ControlSystemGroup
      22              :  * \brief Sets \f$f(t)\f$ and derivatives using cubic rational functions,
      23              :  * such that the first derivative approaches a constant and the second
      24              :  * derivative approaches zero.
      25              :  *
      26              :  * The resultant function of time is
      27              :  *
      28              :  * \f{align*}{
      29              :  *   f(t) &= f_0 + \frac{v(t-t_0)^3}{\tau^2+(t-t_0)^2},
      30              :  * \f}
      31              :  *
      32              :  * where \f$f_0\f$ is the value of the function \f$f\f$ at the initial time
      33              :  * \f$t_0\f$, and \f$v\f$ is the velocity that \f$f^\prime(t)\f$ approaches on a
      34              :  * timescale of \f$\tau\f$.
      35              :  */
      36            1 : class FixedSpeedCubic : public FunctionOfTime {
      37              :  public:
      38            0 :   FixedSpeedCubic() = default;
      39            0 :   FixedSpeedCubic(double initial_function_value, double initial_time,
      40              :                   double velocity, double decay_timescale);
      41              : 
      42            0 :   ~FixedSpeedCubic() override = default;
      43            0 :   FixedSpeedCubic(FixedSpeedCubic&&) = default;
      44            0 :   FixedSpeedCubic& operator=(FixedSpeedCubic&&) = default;
      45            0 :   FixedSpeedCubic(const FixedSpeedCubic&) = default;
      46            0 :   FixedSpeedCubic& operator=(const FixedSpeedCubic&) = default;
      47              : 
      48              :   // NOLINTNEXTLINE(google-runtime-references)
      49            0 :   WRAPPED_PUPable_decl_template(FixedSpeedCubic);
      50              : 
      51            0 :   explicit FixedSpeedCubic(CkMigrateMessage* /*unused*/) {}
      52              : 
      53            0 :   auto get_clone() const -> std::unique_ptr<FunctionOfTime> override;
      54              : 
      55              :   /// Returns the function at an arbitrary time `t`.
      56            1 :   std::array<DataVector, 1> func(double t) const override;
      57              :   /// Returns the function and its first derivative at an arbitrary time `t`.
      58            1 :   std::array<DataVector, 2> func_and_deriv(double t) const override;
      59              :   /// Returns the function and the first two derivatives at an arbitrary time
      60              :   /// `t`.
      61            1 :   std::array<DataVector, 3> func_and_2_derivs(double t) const override;
      62              : 
      63              :   /// Returns the domain of validity of the function.
      64            1 :   std::array<double, 2> time_bounds() const override;
      65              : 
      66            1 :   double expiration_after(double time) const override;
      67              : 
      68            1 :   void truncate_at_time(double time) override;
      69              : 
      70              :   /// Returns the velocity that the function approaches
      71            1 :   double velocity() const;
      72              : 
      73              :   /// Returns the timescale at which the function approaches a constant
      74              :   /// velocity.
      75            1 :   double decay_timescale() const;
      76              : 
      77              :   // NOLINTNEXTLINE(google-runtime-references)
      78            0 :   void pup(PUP::er& p) override;
      79              : 
      80              :  private:
      81            0 :   friend bool operator==(const FixedSpeedCubic& lhs,
      82              :                          const FixedSpeedCubic& rhs);
      83              : 
      84            0 :   friend std::ostream& operator<<(  // NOLINT(readability-redundant-declaration
      85              :       std::ostream& os, const FixedSpeedCubic& fixed_speed_cubic);
      86              : 
      87              :   template <size_t MaxDerivReturned = 2>
      88            0 :   std::array<DataVector, MaxDerivReturned + 1> func_and_derivs(double t) const;
      89              : 
      90            0 :   double initial_function_value_{std::numeric_limits<double>::signaling_NaN()};
      91            0 :   double initial_time_{std::numeric_limits<double>::signaling_NaN()};
      92            0 :   double velocity_{std::numeric_limits<double>::signaling_NaN()};
      93            0 :   double squared_decay_timescale_{std::numeric_limits<double>::signaling_NaN()};
      94              : };
      95              : 
      96            0 : bool operator!=(const FixedSpeedCubic& lhs, const FixedSpeedCubic& rhs);
      97              : }  // namespace FunctionsOfTime
      98              : }  // namespace domain