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/SphericalCompression.hpp" 17 : #include "Domain/Creators/TimeDependence/GenerateCoordinateMap.hpp" 18 : #include "Domain/Creators/TimeDependence/TimeDependence.hpp" 19 : #include "Options/Auto.hpp" 20 : #include "Options/Context.hpp" 21 : #include "Options/String.hpp" 22 : #include "Utilities/ErrorHandling/Assert.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 <bool InertiorMap> 31 : class SphericalCompression; 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 spherical compression about some center, as given by 48 : * domain::CoordinateMaps::TimeDependent::SphericalCompression<false>. 49 : * 50 : * \details This TimeDependence is suitable for use on a spherical shell, 51 : * where MinRadius and MaxRadius are the inner and outer radii of the shell, 52 : * respectively. 53 : * 54 : * \note The quantity stored in the FunctionOfTime is really 55 : * the spherical-harmonic coefficient \f$\lambda_{00}(t)\f$. This is 56 : * different from the Shape map, which stores ylm::Spherepack coefficients 57 : * \f$a_{lm}(t)\f$ and \f$b_{lm}(t)\f$ instead of \f$\lambda_{lm}(t)\f$. 58 : * See domain::CoordinateMaps::TimeDependent::Shape for more details. 59 : */ 60 1 : class SphericalCompression final : public TimeDependence<3> { 61 : private: 62 0 : using SphericalCompressionMap = 63 : domain::CoordinateMaps::TimeDependent::SphericalCompression<false>; 64 : 65 : public: 66 0 : using maps_list = 67 : tmpl::list<domain::CoordinateMap<Frame::Grid, Frame::Inertial, 68 : SphericalCompressionMap>>; 69 : 70 0 : static constexpr size_t mesh_dim = 3; 71 : 72 : /// \brief The initial time of the function of time. 73 1 : struct InitialTime { 74 0 : using type = double; 75 0 : static constexpr Options::String help = { 76 : "The initial time of the function of time"}; 77 : }; 78 : /// \brief Minimum radius for the SphericalCompression map 79 1 : struct MinRadius { 80 0 : using type = double; 81 0 : static constexpr Options::String help = { 82 : "Min radius for SphericalCompression map."}; 83 : }; 84 : /// \brief Maximum radius for the SphericalCompression map 85 1 : struct MaxRadius { 86 0 : using type = double; 87 0 : static constexpr Options::String help = { 88 : "Max radius for SphericalCompression map."}; 89 : }; 90 : /// \brief Center for the SphericalCompression map 91 1 : struct Center { 92 0 : using type = std::array<double, 3>; 93 0 : static constexpr Options::String help = { 94 : "Center for the SphericalCompression map."}; 95 : }; 96 : /// \brief Initial value for function of time for the spherical compression 97 1 : struct InitialValue { 98 0 : using type = double; 99 0 : static constexpr Options::String help = { 100 : "Spherical compression value at initial time."}; 101 : }; 102 : /// \brief Initial radial velocity for the function of time for the spherical 103 : /// compression 104 1 : struct InitialVelocity { 105 0 : using type = double; 106 0 : static constexpr Options::String help = { 107 : "Spherical compression initial radial velocity."}; 108 : }; 109 : /// \brief Initial radial acceleration for the function of time for the 110 : /// spherical compression 111 1 : struct InitialAcceleration { 112 0 : using type = double; 113 0 : static constexpr Options::String help = { 114 : "Spherical compression initial radial acceleration."}; 115 : }; 116 : 117 0 : using GridToInertialMap = 118 : detail::generate_coordinate_map_t<Frame::Grid, Frame::Inertial, 119 : tmpl::list<SphericalCompressionMap>>; 120 : 121 0 : using options = 122 : tmpl::list<InitialTime, MinRadius, MaxRadius, Center, InitialValue, 123 : InitialVelocity, InitialAcceleration>; 124 : 125 0 : static constexpr Options::String help = {"A spherical compression."}; 126 : 127 0 : SphericalCompression() = default; 128 0 : ~SphericalCompression() override = default; 129 0 : SphericalCompression(const SphericalCompression&) = delete; 130 0 : SphericalCompression(SphericalCompression&&) = default; 131 0 : SphericalCompression& operator=(const SphericalCompression&) = delete; 132 0 : SphericalCompression& operator=(SphericalCompression&&) = default; 133 : 134 0 : SphericalCompression(double initial_time, double min_radius, 135 : double max_radius, std::array<double, 3> center, 136 : double initial_value, double initial_velocity, 137 : double initial_acceleration, 138 : const Options::Context& context = {}); 139 : 140 1 : auto get_clone() const -> std::unique_ptr<TimeDependence<mesh_dim>> override; 141 : 142 1 : auto block_maps_grid_to_inertial(size_t number_of_blocks) const 143 : -> std::vector<std::unique_ptr<domain::CoordinateMapBase< 144 : Frame::Grid, Frame::Inertial, mesh_dim>>> override; 145 : 146 1 : auto block_maps_grid_to_distorted(size_t number_of_blocks) const 147 : -> std::vector<std::unique_ptr<domain::CoordinateMapBase< 148 : Frame::Grid, Frame::Distorted, mesh_dim>>> override { 149 : using ptr_type = 150 : domain::CoordinateMapBase<Frame::Grid, Frame::Distorted, mesh_dim>; 151 : return std::vector<std::unique_ptr<ptr_type>>(number_of_blocks); 152 : } 153 : 154 1 : auto block_maps_distorted_to_inertial(size_t number_of_blocks) const 155 : -> std::vector<std::unique_ptr<domain::CoordinateMapBase< 156 : Frame::Distorted, Frame::Inertial, mesh_dim>>> override { 157 : using ptr_type = 158 : domain::CoordinateMapBase<Frame::Distorted, Frame::Inertial, mesh_dim>; 159 : return std::vector<std::unique_ptr<ptr_type>>(number_of_blocks); 160 : } 161 : 162 1 : auto functions_of_time(const std::unordered_map<std::string, double>& 163 : initial_expiration_times = {}) const 164 : -> std::unordered_map< 165 : std::string, 166 : std::unique_ptr<domain::FunctionsOfTime::FunctionOfTime>> override; 167 : 168 : private: 169 : // NOLINTNEXTLINE(readability-redundant-declaration) 170 0 : friend bool operator==(const SphericalCompression& lhs, 171 : const SphericalCompression& rhs); 172 : 173 0 : GridToInertialMap grid_to_inertial_map() const; 174 : 175 0 : double initial_time_{std::numeric_limits<double>::signaling_NaN()}; 176 0 : double min_radius_{std::numeric_limits<double>::signaling_NaN()}; 177 0 : double max_radius_{std::numeric_limits<double>::signaling_NaN()}; 178 0 : std::array<double, 3> center_{}; 179 0 : double initial_value_{std::numeric_limits<double>::signaling_NaN()}; 180 0 : double initial_velocity_{std::numeric_limits<double>::signaling_NaN()}; 181 0 : double initial_acceleration_{std::numeric_limits<double>::signaling_NaN()}; 182 0 : inline static const std::string function_of_time_name_{"Size"}; 183 : }; 184 : 185 0 : bool operator!=(const SphericalCompression& lhs, 186 : const SphericalCompression& rhs); 187 : } // namespace domain::creators::time_dependence