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 <cstddef>
       8             : #include <limits>
       9             : #include <memory>
      10             : #include <pup.h>
      11             : 
      12             : #include "DataStructures/DataVector.hpp"
      13             : #include "Domain/FunctionsOfTime/FunctionOfTime.hpp"
      14             : #include "Domain/FunctionsOfTime/SettleToConstant.hpp"
      15             : #include "Utilities/Serialization/CharmPupable.hpp"
      16             : 
      17             : namespace domain::FunctionsOfTime {
      18             : /// \ingroup ControlSystemGroup
      19             : /// \brief Given an initial function of time that is a unit quaternion,
      20             : /// transitions to a constant-in-time unit quaternion.
      21             : ///
      22             : /// Given an initial unit quaternion \f$\mathbf{f}(t)\f$ and its first two
      23             : /// derivatives at the matching time \f$t_0\f$, return a function of time
      24             : /// \f$\mathbf{g}(t)\f$ satisfies \f$\mathbf{g}(t=t_0)=\mathbf{f}f(t=t_0)\f$ and
      25             : /// approaches a constant value for \f$t > t_0\f$ on a timescale of \f$\tau\f$.
      26             : /// This is done by internally holding a `SettleToConstant` function of time
      27             : /// initialized from \f$\mathbf{f}(t)\f$ and its first two derivatives at the
      28             : /// matching time, but then ensuring that \f$\mathbf{g}(t)\f$ remains
      29             : /// a unit quaternion.
      30           1 : class SettleToConstantQuaternion : public FunctionOfTime {
      31             :  public:
      32           0 :   SettleToConstantQuaternion() = default;
      33           0 :   SettleToConstantQuaternion(
      34             :       const std::array<DataVector, 3>& initial_func_and_derivs,
      35             :       double match_time, double decay_time);
      36             : 
      37           0 :   ~SettleToConstantQuaternion() override = default;
      38           0 :   SettleToConstantQuaternion(SettleToConstantQuaternion&&) = default;
      39           0 :   SettleToConstantQuaternion& operator=(SettleToConstantQuaternion&&) = default;
      40           0 :   SettleToConstantQuaternion(const SettleToConstantQuaternion&) = default;
      41           0 :   SettleToConstantQuaternion& operator=(const SettleToConstantQuaternion&) =
      42             :       default;
      43             : 
      44             :   // NOLINTNEXTLINE(google-runtime-references)
      45           0 :   WRAPPED_PUPable_decl_template(SettleToConstantQuaternion);
      46             : 
      47           0 :   explicit SettleToConstantQuaternion(CkMigrateMessage* /*unused*/) {}
      48             : 
      49           0 :   auto get_clone() const -> std::unique_ptr<FunctionOfTime> override;
      50             : 
      51             :   /// Returns the function at an arbitrary time `t`.
      52           1 :   std::array<DataVector, 1> func(const double t) const override {
      53             :     return func_and_derivs<0>(t);
      54             :   }
      55             :   /// Returns the function and its first derivative at an arbitrary time `t`.
      56           1 :   std::array<DataVector, 2> func_and_deriv(const double t) const override {
      57             :     return func_and_derivs<1>(t);
      58             :   }
      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(const double t) const override {
      62             :     return func_and_derivs<2>(t);
      63             :   }
      64             : 
      65             :   /// Returns the domain of validity of the function.
      66           1 :   std::array<double, 2> time_bounds() const override {
      67             :     return {{match_time_, std::numeric_limits<double>::infinity()}};
      68             :   }
      69             : 
      70           1 :   double expiration_after(const double /*time*/) const override {
      71             :     return std::numeric_limits<double>::infinity();
      72             :   }
      73             : 
      74             :   // NOLINTNEXTLINE(google-runtime-references)
      75           0 :   void pup(PUP::er& p) override;
      76             : 
      77             :  private:
      78           0 :   friend bool operator==(const SettleToConstantQuaternion& lhs,
      79             :                          const SettleToConstantQuaternion& rhs);
      80             : 
      81             :   template <size_t MaxDerivReturned = 2>
      82           0 :   std::array<DataVector, MaxDerivReturned + 1> func_and_derivs(double t) const;
      83             : 
      84           0 :   SettleToConstant unnormalized_function_of_time_;
      85           0 :   double match_time_{std::numeric_limits<double>::signaling_NaN()};
      86           0 :   double decay_time_{std::numeric_limits<double>::signaling_NaN()};
      87             : };
      88             : 
      89           0 : bool operator!=(const SettleToConstantQuaternion& lhs,
      90             :                 const SettleToConstantQuaternion& rhs);
      91             : }  // namespace domain::FunctionsOfTime