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 <optional>
      11             : #include <string>
      12             : #include <unordered_map>
      13             : #include <vector>
      14             : 
      15             : #include "Domain/CoordinateMaps/CoordinateMap.hpp"
      16             : #include "Domain/CoordinateMaps/Identity.hpp"
      17             : #include "Domain/CoordinateMaps/TimeDependent/Rotation.hpp"
      18             : #include "Domain/Creators/TimeDependence/GenerateCoordinateMap.hpp"
      19             : #include "Domain/Creators/TimeDependence/TimeDependence.hpp"
      20             : #include "Options/String.hpp"
      21             : #include "Utilities/ErrorHandling/Assert.hpp"
      22             : #include "Utilities/PrettyType.hpp"
      23             : #include "Utilities/TMPL.hpp"
      24             : 
      25             : /// \cond
      26             : namespace domain::FunctionsOfTime {
      27             : class FunctionOfTime;
      28             : }  // namespace domain::FunctionsOfTime
      29             : namespace domain::CoordinateMaps::TimeDependent {
      30             : template <typename Map1, typename Map2>
      31             : class ProductOf2Maps;
      32             : }  // namespace domain::CoordinateMaps::TimeDependent
      33             : namespace domain {
      34             : template <typename SourceFrame, typename TargetFrame, typename... Maps>
      35             : class CoordinateMap;
      36             : }  // namespace domain
      37             : 
      38             : namespace Frame {
      39             : struct Distorted;
      40             : struct Grid;
      41             : struct Inertial;
      42             : }  // namespace Frame
      43             : /// \endcond
      44             : 
      45             : namespace domain::creators::time_dependence {
      46             : /*!
      47             :  * \brief A spatially uniform rotation about the \f$z\f$ axis:
      48             :  * \f{eqnarray*}
      49             :  * x &\to& x \cos \alpha(t) - y \sin \alpha(t)\text{,} \\
      50             :  * y &\to& x \sin \alpha(t) + y \cos \alpha(t)\text{,}
      51             :  * \f}
      52             :  * where \f$\alpha(t)\f$ is a `domain::FunctionsOfTime::FunctionOfTime`. For 3
      53             :  * spatial dimensions, \f$z \to z\f$, and the rotation is implemented as a
      54             :  * product of the 2D rotation and an identity map. The rotation is undefined
      55             :  * (and therefore unimplemented here) for 1 spatial dimension.
      56             :  */
      57             : template <size_t MeshDim>
      58           1 : class RotationAboutZAxis final : public TimeDependence<MeshDim> {
      59             :   static_assert(MeshDim > 1,
      60             :                 "RotationAboutZAxis<MeshDim> undefined for MeshDim == 1");
      61             : 
      62             :  private:
      63           0 :   using Identity = domain::CoordinateMaps::Identity<1>;
      64           0 :   using Rotation = domain::CoordinateMaps::TimeDependent::Rotation<2>;
      65             : 
      66             :  public:
      67           0 :   using maps_list = tmpl::list<
      68             :       domain::CoordinateMap<Frame::Grid, Frame::Inertial, Rotation>,
      69             :       domain::CoordinateMap<
      70             :           Frame::Grid, Frame::Inertial,
      71             :           CoordinateMaps::TimeDependent::ProductOf2Maps<Rotation, Identity>>>;
      72             : 
      73           0 :   static constexpr size_t mesh_dim = MeshDim;
      74             : 
      75             :   /// \brief The initial time of the function of time.
      76           1 :   struct InitialTime {
      77           0 :     using type = double;
      78           0 :     static constexpr Options::String help = {
      79             :         "The initial time of the function of time"};
      80             :   };
      81           0 :   struct InitialAngle {
      82           0 :     using type = double;
      83           0 :     static constexpr Options::String help = {"The initial angle."};
      84             :   };
      85             :   /// \brief The \f$x\f$-, \f$y\f$-, and \f$z\f$-velocity.
      86           1 :   struct InitialAngularVelocity {
      87           0 :     using type = double;
      88           0 :     static constexpr Options::String help = {
      89             :         "The initial angular velocity of the map."};
      90             :   };
      91           0 :   struct InitialAngularAcceleration {
      92           0 :     using type = double;
      93           0 :     static constexpr Options::String help = {
      94             :         "The initial angular acceleration of the map."};
      95             :   };
      96             : 
      97           0 :   using GridToInertialMap = detail::generate_coordinate_map_t<
      98             :       Frame::Grid, Frame::Inertial,
      99             :       tmpl::list<tmpl::conditional_t<MeshDim == 2, Rotation,
     100             :                                      domain::CoordinateMaps::TimeDependent::
     101             :                                          ProductOf2Maps<Rotation, Identity>>>>;
     102             : 
     103           0 :   using options = tmpl::list<InitialTime, InitialAngle, InitialAngularVelocity,
     104             :                              InitialAngularAcceleration>;
     105             : 
     106           0 :   static constexpr Options::String help = {
     107             :       "A spatially uniform rotation about the z axis initialized with a "
     108             :       "constant angular velocity."};
     109             : 
     110           0 :   RotationAboutZAxis() = default;
     111           0 :   ~RotationAboutZAxis() override = default;
     112           0 :   RotationAboutZAxis(const RotationAboutZAxis&) = delete;
     113           0 :   RotationAboutZAxis(RotationAboutZAxis&&) = default;
     114           0 :   RotationAboutZAxis& operator=(const RotationAboutZAxis&) = delete;
     115           0 :   RotationAboutZAxis& operator=(RotationAboutZAxis&&) = default;
     116             : 
     117           0 :   RotationAboutZAxis(double initial_time, double initial_angle,
     118             :                      double initial_angular_velocity,
     119             :                      double initial_angular_acceleration);
     120             : 
     121           1 :   auto get_clone() const -> std::unique_ptr<TimeDependence<MeshDim>> override;
     122             : 
     123           1 :   auto block_maps_grid_to_inertial(size_t number_of_blocks) const
     124             :       -> std::vector<std::unique_ptr<domain::CoordinateMapBase<
     125             :           Frame::Grid, Frame::Inertial, MeshDim>>> override;
     126             : 
     127           1 :   auto block_maps_grid_to_distorted(size_t number_of_blocks) const
     128             :       -> std::vector<std::unique_ptr<domain::CoordinateMapBase<
     129             :           Frame::Grid, Frame::Distorted, MeshDim>>> override {
     130             :     using ptr_type =
     131             :         domain::CoordinateMapBase<Frame::Grid, Frame::Distorted, MeshDim>;
     132             :     return std::vector<std::unique_ptr<ptr_type>>(number_of_blocks);
     133             :   }
     134             : 
     135           1 :   auto block_maps_distorted_to_inertial(size_t number_of_blocks) const
     136             :       -> std::vector<std::unique_ptr<domain::CoordinateMapBase<
     137             :           Frame::Distorted, Frame::Inertial, MeshDim>>> override {
     138             :     using ptr_type =
     139             :         domain::CoordinateMapBase<Frame::Distorted, Frame::Inertial, MeshDim>;
     140             :     return std::vector<std::unique_ptr<ptr_type>>(number_of_blocks);
     141             :   }
     142             : 
     143           1 :   auto functions_of_time(const std::unordered_map<std::string, double>&
     144             :                              initial_expiration_times = {}) const
     145             :       -> std::unordered_map<
     146             :           std::string,
     147             :           std::unique_ptr<domain::FunctionsOfTime::FunctionOfTime>> override;
     148             : 
     149             :  private:
     150             :   template <size_t LocalDim>
     151             :   // NOLINTNEXTLINE(readability-redundant-declaration)
     152           0 :   friend bool operator==(const RotationAboutZAxis<LocalDim>& lhs,
     153             :                          const RotationAboutZAxis<LocalDim>& rhs);
     154             : 
     155           0 :   GridToInertialMap grid_to_inertial_map() const;
     156             : 
     157           0 :   double initial_time_{std::numeric_limits<double>::signaling_NaN()};
     158           0 :   double initial_angle_{std::numeric_limits<double>::signaling_NaN()};
     159           0 :   double initial_angular_velocity_{
     160             :       std::numeric_limits<double>::signaling_NaN()};
     161           0 :   double initial_angular_acceleration_{
     162             :       std::numeric_limits<double>::signaling_NaN()};
     163           0 :   inline static const std::string function_of_time_name_{"Rotation"};
     164             : };
     165             : 
     166             : template <size_t Dim>
     167           0 : bool operator==(const RotationAboutZAxis<Dim>& lhs,
     168             :                 const RotationAboutZAxis<Dim>& rhs);
     169             : 
     170             : template <size_t Dim>
     171           0 : bool operator!=(const RotationAboutZAxis<Dim>& lhs,
     172             :                 const RotationAboutZAxis<Dim>& rhs);
     173             : }  // namespace domain::creators::time_dependence