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 <limits>
8 : #include <string>
9 :
10 : #include "DataStructures/TaggedTuple.hpp"
11 : #include "DataStructures/Tensor/TypeAliases.hpp"
12 : #include "Evolution/Systems/CurvedScalarWave/Tags.hpp"
13 : #include "Options/String.hpp"
14 : #include "PointwiseFunctions/AnalyticData/AnalyticData.hpp"
15 : #include "PointwiseFunctions/AnalyticData/ScalarTensor/AnalyticData.hpp"
16 : #include "PointwiseFunctions/AnalyticSolutions/GeneralRelativity/KerrSchild.hpp"
17 : #include "PointwiseFunctions/InitialDataUtilities/InitialData.hpp"
18 : #include "Utilities/Serialization/CharmPupable.hpp"
19 : #include "Utilities/TMPL.hpp"
20 :
21 : /// \cond
22 : namespace PUP {
23 : class er;
24 : } // namespace PUP
25 : /// \endcond
26 :
27 : namespace ScalarTensor::AnalyticData {
28 : /*!
29 : * \brief Analytic initial data for a pure spherical harmonic in three
30 : * dimensions in a KerrSchild background.
31 : *
32 : * \details The initial data is taken from \cite Scheel2003vs , Eqs. 4.1--4.3,
33 : * and sets the evolved variables of the scalar wave as follows:
34 : *
35 : * \f{align}
36 : * \Psi &= 0 \\
37 : * \Phi_i &= 0 \\
38 : * \Pi &= \Pi_0(r, \theta, \phi) = A e^{- (r - r_0)^2 / w^2} Y_{lm}(\theta,
39 : * \phi), \f}
40 : *
41 : * where \f$A\f$ is the amplitude of the profile, \f$r_0\f$ is its radius and
42 : * \f$w\f$ is its width. This describes a pure spherical harmonic mode
43 : * \f$Y_{lm}(\theta, \phi)\f$ truncated by a circular Gaussian window function.
44 : *
45 : * When evolved, the scalar field \f$\Phi\f$ will briefly build up around the
46 : * radius \f$r_0\f$ and then disperse. This can be used to study the ringdown
47 : * behavior and late-time tails in the Kerr spacetime.
48 : * \see CurvedScalarWave::AnalyticData::PureSphericalHarmonic and
49 : * gr::Solutions::KerrSchild.
50 : */
51 1 : class KerrSphericalHarmonic
52 : : public virtual evolution::initial_data::InitialData,
53 : public MarkAsAnalyticData,
54 : public AnalyticDataBase {
55 : public:
56 : /// The mass of the black hole.
57 1 : struct Mass {
58 0 : using type = double;
59 0 : static constexpr Options::String help = {"Mass of the black hole."};
60 0 : static type lower_bound() { return 0.0; }
61 : };
62 : /// The spin of the black hole
63 1 : struct Spin {
64 0 : using type = std::array<double, volume_dim>;
65 0 : static constexpr Options::String help = {
66 : "The [x,y,z] dimensionless spin of the black hole"};
67 : };
68 : /// The amplitude of the scalar field
69 1 : struct Amplitude {
70 0 : using type = double;
71 0 : static constexpr Options::String help = {
72 : "Amplitude of the constant scalar field"};
73 : };
74 : /// The location of the scalar field
75 1 : struct Radius {
76 0 : using type = double;
77 0 : static constexpr Options::String help = {
78 : "The radius of the spherical harmonic profile"};
79 0 : static type lower_bound() { return 0.0; }
80 : };
81 : /// The width of the scalar field
82 1 : struct Width {
83 0 : using type = double;
84 0 : static constexpr Options::String help = {
85 : "The width of the spherical harmonic profile. The width must be "
86 : "greater than 0."};
87 0 : static type lower_bound() { return 0.0; }
88 : };
89 : /// The spherical harmonic mode of the scalar field
90 1 : struct Mode {
91 0 : using type = std::pair<size_t, int>;
92 0 : static constexpr Options::String help = {
93 : "The l-mode and m-mode of the spherical harmonic Ylm. The absolute "
94 : "value of the m_mode must be less than or equal to the "
95 : "l-mode."};
96 : };
97 :
98 0 : using options = tmpl::list<Mass, Spin, Amplitude, Radius, Width, Mode>;
99 0 : static constexpr Options::String help = {
100 : "Initial data for a pure spherical harmonic mode truncated by a circular "
101 : "Gaussian window funtion. The expression is taken from Scheel(2003), "
102 : "equations 4.1-4.3."};
103 :
104 0 : KerrSphericalHarmonic() = default;
105 0 : KerrSphericalHarmonic(const KerrSphericalHarmonic& /*rhs*/) = default;
106 0 : KerrSphericalHarmonic& operator=(const KerrSphericalHarmonic& /*rhs*/) =
107 : default;
108 0 : KerrSphericalHarmonic(KerrSphericalHarmonic&& /*rhs*/) = default;
109 0 : KerrSphericalHarmonic& operator=(KerrSphericalHarmonic&& /*rhs*/) = default;
110 0 : ~KerrSphericalHarmonic() override = default;
111 :
112 0 : KerrSphericalHarmonic(double mass,
113 : const std::array<double, 3>& dimensionless_spin,
114 : double amplitude, double radius, double width,
115 : std::pair<size_t, int> mode);
116 :
117 0 : auto get_clone() const
118 : -> std::unique_ptr<evolution::initial_data::InitialData> override;
119 :
120 : /// \cond
121 : explicit KerrSphericalHarmonic(CkMigrateMessage* msg);
122 : using PUP::able::register_constructor;
123 : WRAPPED_PUPable_decl_template(KerrSphericalHarmonic);
124 : /// \endcond
125 :
126 : // The extra tags below can also be added as common to all scalar tensor
127 : // solutions
128 : template <typename DataType, typename Frame = Frame::Inertial>
129 0 : using tags = tmpl::flatten<tmpl::list<
130 : typename AnalyticDataBase::template tags<DataType>,
131 : gr::Tags::DerivDetSpatialMetric<DataType, 3, Frame>,
132 : gr::Tags::TraceExtrinsicCurvature<DataType>,
133 : gr::Tags::SpatialChristoffelFirstKind<DataType, 3, Frame>,
134 : gr::Tags::SpatialChristoffelSecondKind<DataType, 3, Frame>,
135 : gr::Tags::TraceSpatialChristoffelSecondKind<DataType, 3, Frame>>>;
136 :
137 : /// @{
138 : /// Retrieve scalar variable at `x`
139 : template <typename DataType>
140 1 : auto variables(const tnsr::I<DataType, 3>& x,
141 : tmpl::list<CurvedScalarWave::Tags::Psi> /*meta*/) const
142 : -> tuples::TaggedTuple<CurvedScalarWave::Tags::Psi>;
143 :
144 : template <typename DataType>
145 1 : auto variables(const tnsr::I<DataType, 3>& x,
146 : tmpl::list<CurvedScalarWave::Tags::Phi<3_st>> /*meta*/) const
147 : -> tuples::TaggedTuple<CurvedScalarWave::Tags::Phi<3_st>>;
148 :
149 : template <typename DataType>
150 1 : auto variables(const tnsr::I<DataType, 3>& x,
151 : tmpl::list<CurvedScalarWave::Tags::Pi> /*meta*/) const
152 : -> tuples::TaggedTuple<CurvedScalarWave::Tags::Pi>;
153 : /// @}
154 :
155 : /// Retrieve a collection of scalar variables at `x`
156 : template <typename DataType, typename... Tags>
157 1 : tuples::TaggedTuple<Tags...> variables(const tnsr::I<DataType, 3>& x,
158 : tmpl::list<Tags...> /*meta*/) const {
159 : static_assert(sizeof...(Tags) > 1,
160 : "The generic template will recurse infinitely if only one "
161 : "tag is being retrieved.");
162 : return {get<Tags>(variables(x, tmpl::list<Tags>{}))...};
163 : }
164 :
165 : /// Retrieve the metric variables
166 : template <typename DataType, typename Tag>
167 1 : tuples::TaggedTuple<Tag> variables(
168 : const tnsr::I<DataType, 3>& x,
169 : tmpl::list<Tag> /*meta*/) const {
170 : // We need to provide a time argument for the background solution
171 : return background_spacetime_.variables(x, 0.0, tmpl::list<Tag>{});
172 : }
173 :
174 : // NOLINTNEXTLINE(google-runtime-references)
175 0 : void pup(PUP::er& /*p*/) override;
176 :
177 : protected:
178 0 : friend bool operator==(const KerrSphericalHarmonic& lhs,
179 : const KerrSphericalHarmonic& rhs);
180 :
181 0 : double mass_ = std::numeric_limits<double>::signaling_NaN();
182 0 : std::array<double, volume_dim> dimensionless_spin_ =
183 : make_array<volume_dim>(std::numeric_limits<double>::signaling_NaN());
184 0 : double amplitude_ = std::numeric_limits<double>::signaling_NaN();
185 0 : double radius_{std::numeric_limits<double>::signaling_NaN()};
186 0 : double width_sq_{std::numeric_limits<double>::signaling_NaN()};
187 0 : std::pair<size_t, int> mode_{std::numeric_limits<size_t>::signaling_NaN(),
188 : std::numeric_limits<int>::signaling_NaN()};
189 :
190 0 : gr::Solutions::KerrSchild background_spacetime_{};
191 : };
192 :
193 0 : bool operator!=(const KerrSphericalHarmonic& lhs,
194 : const KerrSphericalHarmonic& rhs);
195 :
196 : } // namespace ScalarTensor::AnalyticData
|
