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/TimeDependent/CubicScale.hpp"
      17             : #include "Domain/Creators/TimeDependence/TimeDependence.hpp"
      18             : #include "Options/Auto.hpp"
      19             : #include "Options/String.hpp"
      20             : #include "Utilities/PrettyType.hpp"
      21             : #include "Utilities/TMPL.hpp"
      22             : 
      23             : /// \cond
      24             : namespace domain::FunctionsOfTime {
      25             : class FunctionOfTime;
      26             : }  // namespace domain::FunctionsOfTime
      27             : 
      28             : namespace domain {
      29             : template <typename SourceFrame, typename TargetFrame, typename... Maps>
      30             : class CoordinateMap;
      31             : }  // namespace domain
      32             : 
      33             : namespace Frame {
      34             : struct Distorted;
      35             : struct Grid;
      36             : struct Inertial;
      37             : }  // namespace Frame
      38             : /// \endcond
      39             : 
      40           1 : namespace domain::creators::time_dependence {
      41             : /// \brief A linear or cubic radial scaling time dependence.
      42             : ///
      43             : /// Adds the `domain::CoordinateMaps::TimeDependent::CubicScale` map. A linear
      44             : /// radial scaling can be used by specifying the `UseLinearScaling` bool.
      45             : template <size_t MeshDim>
      46           1 : class CubicScale final : public TimeDependence<MeshDim> {
      47             :  private:
      48           0 :   using CubicScaleMap =
      49             :       domain::CoordinateMaps::TimeDependent::CubicScale<MeshDim>;
      50             : 
      51             :  public:
      52           0 :   using maps_list =
      53             :       tmpl::list<CoordinateMap<Frame::Grid, Frame::Inertial, CubicScaleMap>>;
      54             : 
      55           0 :   static constexpr size_t mesh_dim = MeshDim;
      56             : 
      57             :   /// \brief The initial time of the functions of time.
      58           1 :   struct InitialTime {
      59           0 :     using type = double;
      60           0 :     static constexpr Options::String help = {
      61             :         "The initial time of the functions of time"};
      62             :   };
      63             :   /// \brief The outer boundary or pivot point of the
      64             :   /// `domain::CoordinateMaps::TimeDependent::CubicScale` map
      65           1 :   struct OuterBoundary {
      66           0 :     using type = double;
      67           0 :     static constexpr Options::String help = {
      68             :         "Outer boundary or pivot point of the map"};
      69             :   };
      70             :   /// \brief The initial values of the expansion factors.
      71           1 :   struct InitialExpansion {
      72           0 :     using type = std::array<double, 2>;
      73           0 :     static constexpr Options::String help = {
      74             :         "Expansion values at initial time."};
      75             :   };
      76             :   /// \brief The velocity of the expansion factors.
      77           1 :   struct Velocity {
      78           0 :     using type = std::array<double, 2>;
      79           0 :     static constexpr Options::String help = {"The rate of expansion."};
      80             :   };
      81             :   /// \brief The acceleration of the expansion factors.
      82           1 :   struct Acceleration {
      83           0 :     using type = std::array<double, 2>;
      84           0 :     static constexpr Options::String help = {"The acceleration of expansion."};
      85             :   };
      86             :   /// \brief Whether to use linear scaling or cubic scaling.
      87           1 :   struct UseLinearScaling {
      88           0 :     using type = bool;
      89           0 :     static constexpr Options::String help = {
      90             :         "Whether or not to turn on cubic scaling."};
      91             :   };
      92             : 
      93           0 :   using options = tmpl::list<InitialTime, OuterBoundary, UseLinearScaling,
      94             :                              InitialExpansion, Velocity, Acceleration>;
      95             : 
      96           0 :   static constexpr Options::String help = {
      97             :       "A spatial radial scaling either based on a cubic scaling or a simple\n"
      98             :       "linear scaling.\n"
      99             :       "\n"
     100             :       "If the two functions of time have the same name then the scaling is a\n"
     101             :       "linear radial scaling."};
     102             : 
     103           0 :   using GridToInertialMap =
     104             :       domain::CoordinateMap<Frame::Grid, Frame::Inertial, CubicScaleMap>;
     105             : 
     106           0 :   CubicScale() = default;
     107           0 :   ~CubicScale() override = default;
     108           0 :   CubicScale(const CubicScale&) = delete;
     109           0 :   CubicScale(CubicScale&&) = default;
     110           0 :   CubicScale& operator=(const CubicScale&) = delete;
     111           0 :   CubicScale& operator=(CubicScale&&) = default;
     112             : 
     113           0 :   CubicScale(double initial_time, double outer_boundary,
     114             :              bool use_linear_scaling,
     115             :              const std::array<double, 2>& initial_expansion,
     116             :              const std::array<double, 2>& velocity,
     117             :              const std::array<double, 2>& acceleration);
     118             : 
     119           1 :   auto get_clone() const -> std::unique_ptr<TimeDependence<MeshDim>> override;
     120             : 
     121           1 :   auto block_maps_grid_to_inertial(size_t number_of_blocks) const
     122             :       -> std::vector<std::unique_ptr<domain::CoordinateMapBase<
     123             :           Frame::Grid, Frame::Inertial, MeshDim>>> override;
     124             : 
     125           1 :   auto block_maps_grid_to_distorted(size_t number_of_blocks) const
     126             :       -> std::vector<std::unique_ptr<domain::CoordinateMapBase<
     127             :           Frame::Grid, Frame::Distorted, MeshDim>>> override {
     128             :     using ptr_type =
     129             :         domain::CoordinateMapBase<Frame::Grid, Frame::Distorted, MeshDim>;
     130             :     return std::vector<std::unique_ptr<ptr_type>>(number_of_blocks);
     131             :   }
     132             : 
     133           1 :   auto block_maps_distorted_to_inertial(size_t number_of_blocks) const
     134             :       -> std::vector<std::unique_ptr<domain::CoordinateMapBase<
     135             :           Frame::Distorted, Frame::Inertial, MeshDim>>> override {
     136             :     using ptr_type =
     137             :         domain::CoordinateMapBase<Frame::Distorted, Frame::Inertial, MeshDim>;
     138             :     return std::vector<std::unique_ptr<ptr_type>>(number_of_blocks);
     139             :   }
     140             : 
     141           1 :   auto functions_of_time(const std::unordered_map<std::string, double>&
     142             :                              initial_expiration_times = {}) const
     143             :       -> std::unordered_map<
     144             :           std::string,
     145             :           std::unique_ptr<domain::FunctionsOfTime::FunctionOfTime>> override;
     146             : 
     147             :  private:
     148             :   template <size_t LocalDim>
     149             :   // NOLINTNEXTLINE(readability-redundant-declaration)
     150           0 :   friend bool operator==(const CubicScale<LocalDim>& lhs,
     151             :                          const CubicScale<LocalDim>& rhs);
     152             : 
     153           0 :   GridToInertialMap grid_to_inertial_map() const;
     154             : 
     155           0 :   double initial_time_{std::numeric_limits<double>::signaling_NaN()};
     156           0 :   double outer_boundary_{std::numeric_limits<double>::signaling_NaN()};
     157           0 :   bool use_linear_scaling_{false};
     158             :   // Unlike other TimeDependences, these names aren't inline static const
     159             :   // because they can potentially be changed by the run-time option
     160             :   // use_linear_scaling in the constructor
     161           0 :   std::array<std::string, 2> functions_of_time_names_{
     162             :       {"CubicScaleA", "CubicScaleB"}};
     163           0 :   std::array<double, 2> initial_expansion_{};
     164           0 :   std::array<double, 2> velocity_{};
     165           0 :   std::array<double, 2> acceleration_{};
     166             : };
     167             : 
     168             : template <size_t Dim>
     169           0 : bool operator==(const CubicScale<Dim>& lhs, const CubicScale<Dim>& rhs);
     170             : 
     171             : template <size_t Dim>
     172           0 : bool operator!=(const CubicScale<Dim>& lhs, const CubicScale<Dim>& rhs);
     173             : }  // namespace domain::creators::time_dependence