Line data Source code
1 0 : // Distributed under the MIT License.
2 : // See LICENSE.txt for details.
3 :
4 : #pragma once
5 :
6 : #include <cstddef>
7 : #include <memory>
8 : #include <string>
9 :
10 : #include "DataStructures/DataBox/Prefixes.hpp"
11 : #include "DataStructures/DataVector.hpp"
12 : #include "DataStructures/TaggedTuple.hpp"
13 : #include "DataStructures/Tensor/Tensor.hpp"
14 : #include "Evolution/Systems/Ccz4/Tags.hpp"
15 : #include "Options/String.hpp"
16 : #include "PointwiseFunctions/GeneralRelativity/Tags.hpp"
17 : #include "PointwiseFunctions/InitialDataUtilities/InitialData.hpp"
18 : #include "Utilities/GenerateInstantiations.hpp"
19 : #include "Utilities/Serialization/CharmPupable.hpp"
20 : #include "Utilities/TMPL.hpp"
21 :
22 : /// \cond
23 : namespace PUP {
24 : class er;
25 : } // namespace PUP
26 : /// \endcond
27 :
28 0 : namespace Ccz4::Solutions {
29 : /*!
30 : * \brief A wrapper for general-relativity analytic solutions that loads
31 : * the analytic solution and then adds a function that returns
32 : * any combination of the Ccz4 evolution variables.
33 : * Specifically, see `Ccz4::fd::System`.
34 : *
35 : * The wrapper returns the everywhere-nonnegative lapse
36 : * \f$|\alpha|\f$ in place of the wrapped solution's lapse \f$\alpha\f$, with
37 : * the lapse derivative and time derivative scaled by
38 : * \f$\mathrm{sgn}(\alpha)\f$ (where \f$\mathrm{sgn}(0) := 0\f$). For
39 : * solutions with positive lapse this is an exact no-op. For solutions whose
40 : * lapse is negative somewhere (e.g. the lapse of
41 : * `gr::Solutions::HighSpinKerrPuncture` inside its throat) the sign flip is
42 : * pure gauge: the spatial metric and extrinsic curvature are unchanged.
43 : */
44 : template <typename SolutionType>
45 1 : class Ccz4WrappedGr : public virtual evolution::initial_data::InitialData,
46 : public SolutionType {
47 : public:
48 : using SolutionType::SolutionType;
49 :
50 0 : Ccz4WrappedGr() = default;
51 0 : Ccz4WrappedGr(const Ccz4WrappedGr& /*rhs*/) = default;
52 0 : Ccz4WrappedGr& operator=(const Ccz4WrappedGr& /*rhs*/) = default;
53 0 : Ccz4WrappedGr(Ccz4WrappedGr&& /*rhs*/) = default;
54 0 : Ccz4WrappedGr& operator=(Ccz4WrappedGr&& /*rhs*/) = default;
55 0 : ~Ccz4WrappedGr() override = default;
56 :
57 0 : explicit Ccz4WrappedGr(const SolutionType& wrapped_solution);
58 :
59 0 : auto get_clone() const
60 : -> std::unique_ptr<evolution::initial_data::InitialData> override;
61 :
62 : /// \cond
63 : explicit Ccz4WrappedGr(CkMigrateMessage* msg);
64 : using PUP::able::register_constructor;
65 : WRAPPED_PUPable_decl_template(Ccz4WrappedGr);
66 : /// \endcond
67 :
68 0 : static constexpr size_t volume_dim = SolutionType::volume_dim;
69 : static_assert(volume_dim == 3,
70 : "Ccz4 evolution system has only been implemented in 3D!");
71 0 : using options = typename SolutionType::options;
72 0 : static constexpr Options::String help = SolutionType::help;
73 0 : static std::string name() {
74 : return "Ccz4(" + pretty_type::name<SolutionType>() + ")";
75 : }
76 :
77 0 : using DerivLapse = ::Tags::deriv<gr::Tags::Lapse<DataVector>,
78 : tmpl::size_t<volume_dim>, Frame::Inertial>;
79 0 : using DerivShift = ::Tags::deriv<gr::Tags::Shift<DataVector, volume_dim>,
80 : tmpl::size_t<volume_dim>, Frame::Inertial>;
81 0 : using DerivSpatialMetric =
82 : ::Tags::deriv<gr::Tags::SpatialMetric<DataVector, volume_dim>,
83 : tmpl::size_t<volume_dim>, Frame::Inertial>;
84 0 : using TimeDerivLapse = ::Tags::dt<gr::Tags::Lapse<DataVector>>;
85 0 : using TimeDerivShift = ::Tags::dt<gr::Tags::Shift<DataVector, volume_dim>>;
86 0 : using TimeDerivSpatialMetric =
87 : ::Tags::dt<gr::Tags::SpatialMetric<DataVector, volume_dim>>;
88 :
89 0 : using IntermediateVars = tuples::tagged_tuple_from_typelist<
90 : typename SolutionType::template tags<DataVector>>;
91 :
92 : template <typename DataType>
93 0 : using tags =
94 : tmpl::push_back<typename SolutionType::template tags<DataType>,
95 : Ccz4::Tags::ConformalMetric<DataType, volume_dim>,
96 : Ccz4::Tags::ConformalFactor<DataType>,
97 : Ccz4::Tags::ATilde<DataType, volume_dim>,
98 : gr::Tags::TraceExtrinsicCurvature<DataType>,
99 : Ccz4::Tags::Theta<DataType>,
100 : Ccz4::Tags::GammaHat<DataType, volume_dim>,
101 : Ccz4::Tags::AuxiliaryShiftB<DataType, volume_dim>>;
102 :
103 : template <typename... Tags>
104 0 : tuples::TaggedTuple<Tags...> variables(
105 : const tnsr::I<DataVector, volume_dim>& x, const double t,
106 : tmpl::list<Tags...> /*meta*/) const {
107 : const IntermediateVars intermediate_vars = make_intermediate_vars(x, t);
108 :
109 : return {
110 : get<Tags>(variables(x, t, tmpl::list<Tags>{}, intermediate_vars))...};
111 : }
112 :
113 : template <typename Tag>
114 0 : tuples::TaggedTuple<Tag> variables(const tnsr::I<DataVector, volume_dim>& x,
115 : const double t,
116 : tmpl::list<Tag> /*meta*/) const {
117 : const IntermediateVars intermediate_vars = make_intermediate_vars(x, t);
118 : return {get<Tag>(variables(x, t, tmpl::list<Tag>{}, intermediate_vars))};
119 : }
120 :
121 : // overloads for wrapping analytic data
122 :
123 : template <typename... Tags>
124 0 : tuples::TaggedTuple<Tags...> variables(
125 : const tnsr::I<DataVector, volume_dim>& x,
126 : tmpl::list<Tags...> /*meta*/) const {
127 : const IntermediateVars intermediate_vars = make_intermediate_vars(x);
128 :
129 : return {get<Tags>(variables(x, tmpl::list<Tags>{}, intermediate_vars))...};
130 : }
131 :
132 : template <typename Tag>
133 0 : tuples::TaggedTuple<Tag> variables(const tnsr::I<DataVector, volume_dim>& x,
134 : tmpl::list<Tag> /*meta*/) const {
135 : const IntermediateVars intermediate_vars = make_intermediate_vars(x);
136 : return {get<Tag>(variables(x, tmpl::list<Tag>{}, intermediate_vars))};
137 : }
138 :
139 : // NOLINTNEXTLINE(google-runtime-references)
140 0 : void pup(PUP::er& p) override;
141 :
142 : private:
143 : // Computes the wrapped solution's variables and applies the nonnegative
144 : // lapse: the lapse is replaced by its absolute
145 : // value, and the lapse derivative and time derivative are scaled by
146 : // sign(lapse), with sign(0) := 0. Every tag the wrapper returns,
147 : // passed through or derived, must be computed from the IntermediateVars
148 : // returned here, never by calling the solution directly, so that any
149 : // lapse-dependent quantity added in the future automatically sees the
150 : // corrected gauge.
151 : template <typename... OptionalTime>
152 0 : IntermediateVars make_intermediate_vars(
153 : const tnsr::I<DataVector, volume_dim>& x, OptionalTime... time) const {
154 : IntermediateVars vars = SolutionType::variables(
155 : x, time..., typename SolutionType::template tags<DataVector>{});
156 : // The sign must be taken before the lapse is replaced
157 : const DataVector sgn_of_lapse =
158 : sign(get(get<gr::Tags::Lapse<DataVector>>(vars)));
159 : for (size_t i = 0; i < volume_dim; ++i) {
160 : get<DerivLapse>(vars).get(i) *= sgn_of_lapse;
161 : }
162 : get(get<TimeDerivLapse>(vars)) *= sgn_of_lapse;
163 : get(get<gr::Tags::Lapse<DataVector>>(vars)) =
164 : abs(get(get<gr::Tags::Lapse<DataVector>>(vars)));
165 : return vars;
166 : }
167 :
168 : // The generic overloads below pass the wrapped solution's tags through
169 : // from the IntermediateVars; the explicit overloads compute the seven
170 : // tags the wrapper adds (Ccz4::Tags::ConformalMetric,
171 : // Ccz4::Tags::ConformalFactor, Ccz4::Tags::ATilde,
172 : // gr::Tags::TraceExtrinsicCurvature, Ccz4::Tags::Theta,
173 : // Ccz4::Tags::GammaHat, Ccz4::Tags::AuxiliaryShiftB)
174 0 : using TagShift = gr::Tags::Shift<DataVector, volume_dim>;
175 0 : using TagSpatialMetric = gr::Tags::SpatialMetric<DataVector, volume_dim>;
176 0 : using TagInverseSpatialMetric =
177 : gr::Tags::InverseSpatialMetric<DataVector, volume_dim>;
178 0 : using TagExCurvature = gr::Tags::ExtrinsicCurvature<DataVector, volume_dim>;
179 :
180 : template <typename Tag>
181 0 : tuples::TaggedTuple<Tag> variables(
182 : const tnsr::I<DataVector, volume_dim>& /*x*/, double /*t*/,
183 : tmpl::list<Tag> /*meta*/,
184 : const IntermediateVars& intermediate_vars) const {
185 : static_assert(
186 : tmpl::list_contains_v<typename SolutionType::template tags<DataVector>,
187 : Tag>);
188 : return {get<Tag>(intermediate_vars)};
189 : }
190 :
191 : template <typename Tag>
192 0 : tuples::TaggedTuple<Tag> variables(
193 : const tnsr::I<DataVector, volume_dim>& /*x*/, tmpl::list<Tag> /*meta*/,
194 : const IntermediateVars& intermediate_vars) const {
195 : static_assert(
196 : tmpl::list_contains_v<typename SolutionType::template tags<DataVector>,
197 : Tag>);
198 : return {get<Tag>(intermediate_vars)};
199 : }
200 :
201 : tuples::TaggedTuple<Ccz4::Tags::ConformalMetric<DataVector, volume_dim>>
202 0 : variables(
203 : const tnsr::I<DataVector, volume_dim>& /*x*/,
204 : tmpl::list<Ccz4::Tags::ConformalMetric<DataVector, volume_dim>> /*meta*/,
205 : const IntermediateVars& intermediate_vars) const;
206 0 : tuples::TaggedTuple<Ccz4::Tags::ConformalFactor<DataVector>> variables(
207 : const tnsr::I<DataVector, volume_dim>& /*x*/,
208 : tmpl::list<Ccz4::Tags::ConformalFactor<DataVector>> /*meta*/,
209 : const IntermediateVars& intermediate_vars) const;
210 0 : tuples::TaggedTuple<Ccz4::Tags::ATilde<DataVector, volume_dim>> variables(
211 : const tnsr::I<DataVector, volume_dim>& /*x*/,
212 : tmpl::list<Ccz4::Tags::ATilde<DataVector, volume_dim>> /*meta*/,
213 : const IntermediateVars& intermediate_vars) const;
214 0 : tuples::TaggedTuple<gr::Tags::TraceExtrinsicCurvature<DataVector>> variables(
215 : const tnsr::I<DataVector, volume_dim>& /*x*/,
216 : tmpl::list<gr::Tags::TraceExtrinsicCurvature<DataVector>> /*meta*/,
217 : const IntermediateVars& intermediate_vars) const;
218 0 : tuples::TaggedTuple<Ccz4::Tags::Theta<DataVector>> variables(
219 : const tnsr::I<DataVector, volume_dim>& /*x*/,
220 : tmpl::list<Ccz4::Tags::Theta<DataVector>> /*meta*/,
221 : const IntermediateVars& intermediate_vars) const;
222 0 : tuples::TaggedTuple<Ccz4::Tags::GammaHat<DataVector, volume_dim>> variables(
223 : const tnsr::I<DataVector, volume_dim>& /*x*/,
224 : tmpl::list<Ccz4::Tags::GammaHat<DataVector, volume_dim>> /*meta*/,
225 : const IntermediateVars& intermediate_vars) const;
226 : tuples::TaggedTuple<Ccz4::Tags::AuxiliaryShiftB<DataVector, volume_dim>>
227 0 : variables(
228 : const tnsr::I<DataVector, volume_dim>& /*x*/,
229 : tmpl::list<Ccz4::Tags::AuxiliaryShiftB<DataVector, volume_dim>> /*meta*/,
230 : const IntermediateVars& intermediate_vars) const;
231 :
232 : tuples::TaggedTuple<Ccz4::Tags::ConformalMetric<DataVector, volume_dim>>
233 0 : variables(
234 : const tnsr::I<DataVector, volume_dim>& x, const double /*t*/,
235 : tmpl::list<Ccz4::Tags::ConformalMetric<DataVector, volume_dim>> meta,
236 : const IntermediateVars& intermediate_vars) const {
237 : return variables(x, meta, intermediate_vars);
238 : }
239 0 : tuples::TaggedTuple<Ccz4::Tags::ConformalFactor<DataVector>> variables(
240 : const tnsr::I<DataVector, volume_dim>& x, double /*t*/,
241 : tmpl::list<Ccz4::Tags::ConformalFactor<DataVector>> meta,
242 : const IntermediateVars& intermediate_vars) const {
243 : return variables(x, meta, intermediate_vars);
244 : }
245 0 : tuples::TaggedTuple<Ccz4::Tags::ATilde<DataVector, volume_dim>> variables(
246 : const tnsr::I<DataVector, volume_dim>& x, double /*t*/,
247 : tmpl::list<Ccz4::Tags::ATilde<DataVector, volume_dim>> meta,
248 : const IntermediateVars& intermediate_vars) const {
249 : return variables(x, meta, intermediate_vars);
250 : }
251 0 : tuples::TaggedTuple<gr::Tags::TraceExtrinsicCurvature<DataVector>> variables(
252 : const tnsr::I<DataVector, volume_dim>& x, const double /*t*/,
253 : tmpl::list<gr::Tags::TraceExtrinsicCurvature<DataVector>> meta,
254 : const IntermediateVars& intermediate_vars) const {
255 : return variables(x, meta, intermediate_vars);
256 : }
257 0 : tuples::TaggedTuple<Ccz4::Tags::Theta<DataVector>> variables(
258 : const tnsr::I<DataVector, volume_dim>& x, double /*t*/,
259 : tmpl::list<Ccz4::Tags::Theta<DataVector>> meta,
260 : const IntermediateVars& intermediate_vars) const {
261 : return variables(x, meta, intermediate_vars);
262 : }
263 0 : tuples::TaggedTuple<Ccz4::Tags::GammaHat<DataVector, volume_dim>> variables(
264 : const tnsr::I<DataVector, volume_dim>& x, double /*t*/,
265 : tmpl::list<Ccz4::Tags::GammaHat<DataVector, volume_dim>> meta,
266 : const IntermediateVars& intermediate_vars) const {
267 : return variables(x, meta, intermediate_vars);
268 : }
269 : tuples::TaggedTuple<Ccz4::Tags::AuxiliaryShiftB<DataVector, volume_dim>>
270 0 : variables(
271 : const tnsr::I<DataVector, volume_dim>& x, double /*t*/,
272 : tmpl::list<Ccz4::Tags::AuxiliaryShiftB<DataVector, volume_dim>> meta,
273 : const IntermediateVars& intermediate_vars) const {
274 : return variables(x, meta, intermediate_vars);
275 : }
276 : };
277 :
278 : template <typename SolutionType>
279 0 : bool operator==(const Ccz4WrappedGr<SolutionType>& lhs,
280 : const Ccz4WrappedGr<SolutionType>& rhs);
281 :
282 : template <typename SolutionType>
283 0 : bool operator!=(const Ccz4WrappedGr<SolutionType>& lhs,
284 : const Ccz4WrappedGr<SolutionType>& rhs);
285 :
286 : template <typename SolutionType>
287 0 : Ccz4WrappedGr(SolutionType solution) -> Ccz4WrappedGr<SolutionType>;
288 : } // namespace Ccz4::Solutions
|
