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 <optional>
       9             : #include <string>
      10             : #include <utility>
      11             : #include <variant>
      12             : #include <vector>
      13             : 
      14             : #include "DataStructures/DataVector.hpp"
      15             : #include "Domain/Creators/TimeDependentOptions/FromVolumeFile.hpp"
      16             : #include "Options/Auto.hpp"
      17             : #include "Options/Context.hpp"
      18             : #include "Options/Options.hpp"
      19             : #include "Options/String.hpp"
      20             : #include "Utilities/TMPL.hpp"
      21             : 
      22             : namespace domain::creators::time_dependent_options {
      23             : /*!
      24             :  * \brief Class that holds hard coded rotation map options from the input file.
      25             :  *
      26             :  * \details This class can also be used as an option tag with the \p type type
      27             :  * alias, `name()` function, and \p help string.
      28             :  */
      29             : template <bool AllowSettleFoTs>
      30           1 : struct RotationMapOptions {
      31           0 :   using type = Options::Auto<
      32             :       std::variant<RotationMapOptions<AllowSettleFoTs>, FromVolumeFile>,
      33             :       Options::AutoLabel::None>;
      34           0 :   static std::string name() { return "RotationMap"; }
      35           0 :   static constexpr Options::String help = {
      36             :       "Options for a time-dependent rotation of the coordinates. Specify "
      37             :       "'None' to not use this map."};
      38             : 
      39           0 :   struct InitialQuaternions {
      40           0 :     using type = std::vector<std::array<double, 4>>;
      41           0 :     static constexpr Options::String help = {
      42             :         "Initial values for the quaternion of the rotation map. You can "
      43             :         "optionally specify its first two time derivatives. If time "
      44             :         "derivatives aren't specified, zero will be used."};
      45             :   };
      46             : 
      47           0 :   struct InitialAngularVelocity {
      48           0 :     using type = std::array<double, 3>;
      49           0 :     static constexpr Options::String help = {"The initial angular velocity."};
      50             :   };
      51             : 
      52           0 :   struct DecayTimescale {
      53           0 :     using type = double;
      54           0 :     static constexpr Options::String help = {
      55             :         "The timescale for how fast the rotation approaches its asymptotic "
      56             :         "value with a SettleToConstant function of time."};
      57             :   };
      58             : 
      59           0 :   using non_settle_options = tmpl::list<InitialAngularVelocity>;
      60           0 :   using settle_options = tmpl::list<InitialQuaternions, DecayTimescale>;
      61             : 
      62           0 :   using options = tmpl::conditional_t<
      63             :       AllowSettleFoTs,
      64             :       tmpl::list<Options::Alternatives<non_settle_options, settle_options>>,
      65             :       non_settle_options>;
      66             : 
      67           0 :   RotationMapOptions() = default;
      68             :   // Constructor for non SettleToConstant functions of time
      69             :   // NOLINTNEXTLINE(google-explicit-constructor)
      70           0 :   RotationMapOptions(const std::array<double, 3>& initial_angular_velocity,
      71             :                      const Options::Context& context = {});
      72             :   // Constructor for SettleToConst functions of time
      73           0 :   RotationMapOptions(
      74             :       const std::vector<std::array<double, 4>>& initial_quaternions,
      75             :       double decay_timescale_in, const Options::Context& context = {});
      76             : 
      77           0 :   std::array<DataVector, 3> quaternions{};
      78           0 :   std::array<DataVector, 4> angles{};
      79           0 :   std::optional<double> decay_timescale;
      80             : 
      81             :  private:
      82           0 :   void initialize_angles_and_quats();
      83             : };
      84             : 
      85             : /*!
      86             :  * \brief Helper function that takes the variant of the rotation map options,
      87             :  * and returns the fully constructed rotation function of time.
      88             :  *
      89             :  * \details The function of time will have a new \p initial_time and \p
      90             :  * expiration_time, unless it is read from a file and is replaying.
      91             :  */
      92             : template <bool AllowSettleFoTs>
      93           1 : std::unique_ptr<domain::FunctionsOfTime::FunctionOfTime> get_rotation(
      94             :     const std::variant<RotationMapOptions<AllowSettleFoTs>, FromVolumeFile>&
      95             :         rotation_map_options,
      96             :     double initial_time, double expiration_time);
      97             : }  // namespace domain::creators::time_dependent_options