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(double t) const override;
      53              :   /// Returns the function and its first derivative at an arbitrary time `t`.
      54            1 :   std::array<DataVector, 2> func_and_deriv(double t) const override;
      55              :   /// Returns the function and the first two derivatives at an arbitrary time
      56              :   /// `t`.
      57            1 :   std::array<DataVector, 3> func_and_2_derivs(double t) const override;
      58              : 
      59              :   /// Returns the domain of validity of the function.
      60            1 :   std::array<double, 2> time_bounds() const override;
      61              : 
      62            1 :   double expiration_after(double time) const override;
      63              : 
      64            1 :   void truncate_at_time(double time) override;
      65              : 
      66              :   // NOLINTNEXTLINE(google-runtime-references)
      67            0 :   void pup(PUP::er& p) override;
      68              : 
      69              :  private:
      70            0 :   friend bool operator==(const SettleToConstantQuaternion& lhs,
      71              :                          const SettleToConstantQuaternion& rhs);
      72              : 
      73              :   template <size_t MaxDerivReturned = 2>
      74            0 :   std::array<DataVector, MaxDerivReturned + 1> func_and_derivs(double t) const;
      75              : 
      76            0 :   SettleToConstant unnormalized_function_of_time_;
      77            0 :   double match_time_{std::numeric_limits<double>::signaling_NaN()};
      78            0 :   double decay_time_{std::numeric_limits<double>::signaling_NaN()};
      79              : };
      80              : 
      81            0 : bool operator!=(const SettleToConstantQuaternion& lhs,
      82              :                 const SettleToConstantQuaternion& rhs);
      83              : }  // namespace domain::FunctionsOfTime