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 :
9 : #include "DataStructures/DataBox/Tag.hpp"
10 : #include "DataStructures/DataVector.hpp"
11 : #include "DataStructures/Tensor/Tensor.hpp"
12 : #include "Domain/FaceNormal.hpp"
13 : #include "Evolution/Systems/ScalarWave/Tags.hpp"
14 : #include "Utilities/Gsl.hpp"
15 : #include "Utilities/MakeWithValue.hpp"
16 : #include "Utilities/TMPL.hpp"
17 :
18 : /// \cond
19 : template <typename>
20 : class Variables;
21 :
22 : namespace Tags {
23 : template <typename Tag>
24 : struct Normalized;
25 : } // namespace Tags
26 : /// \endcond
27 :
28 : namespace ScalarWave {
29 : /// @{
30 : /*!
31 : * \brief Compute the characteristic speeds for the scalar wave system.
32 : *
33 : * Computes the speeds as described in "Optimal constraint projection for
34 : * hyperbolic evolution systems" by Holst et al. \cite Holst2004wt
35 : * [see text following Eq.(32)]. The characteristic fields' names used here
36 : * differ from this paper:
37 : *
38 : * \f{align*}
39 : * \mathrm{SpECTRE} && \mathrm{Holst} \\
40 : * v^{\hat \psi} && Z^1 \\
41 : * v^{\hat 0}_{i} && Z^{2}_{i} \\
42 : * v^{\hat \pm} && u^{1\pm}
43 : * \f}
44 : *
45 : * The corresponding characteristic speeds \f$\lambda_{\hat \alpha}\f$ are given
46 : * in the text following Eq.(38) of \cite Holst2004wt :
47 : *
48 : * \f{align*}
49 : * \lambda_{\hat \psi} =& 0 \\
50 : * \lambda_{\hat 0} =& 0 \\
51 : * \lambda_{\hat \pm} =& \pm 1.
52 : * \f}
53 : */
54 : template <size_t Dim>
55 1 : std::array<DataVector, 4> characteristic_speeds(
56 : const tnsr::i<DataVector, Dim, Frame::Inertial>& unit_normal_one_form);
57 :
58 : template <size_t Dim>
59 1 : void characteristic_speeds(
60 : gsl::not_null<std::array<DataVector, 4>*> char_speeds,
61 : const tnsr::i<DataVector, Dim, Frame::Inertial>& unit_normal_one_form);
62 :
63 1 : namespace Tags {
64 : template <size_t Dim>
65 0 : struct CharacteristicSpeedsCompute : Tags::CharacteristicSpeeds<Dim>,
66 : db::ComputeTag {
67 0 : using base = Tags::CharacteristicSpeeds<Dim>;
68 0 : using return_type = typename base::type;
69 0 : using argument_tags =
70 : tmpl::list<::Tags::Normalized<domain::Tags::UnnormalizedFaceNormal<Dim>>>;
71 :
72 0 : static void function(
73 : gsl::not_null<return_type*> char_speeds,
74 : const tnsr::i<DataVector, Dim, Frame::Inertial>& unit_normal_one_form) {
75 : characteristic_speeds(char_speeds, unit_normal_one_form);
76 : }
77 : };
78 : } // namespace Tags
79 : /// @}
80 :
81 : /// @{
82 : /*!
83 : * \brief Computes characteristic fields from evolved fields
84 : *
85 : * \ref Tags::CharacteristicFieldsCompute and
86 : * \ref Tags::EvolvedFieldsFromCharacteristicFieldsCompute convert between
87 : * characteristic and evolved fields for the scalar-wave system.
88 : *
89 : * \ref Tags::CharacteristicFieldsCompute computes
90 : * characteristic fields as described in "Optimal constraint projection for
91 : * hyperbolic evolution systems" by Holst et al. \cite Holst2004wt .
92 : * Their names used here differ from this paper:
93 : *
94 : * \f{align*}
95 : * \mathrm{SpECTRE} && \mathrm{Holst} \\
96 : * v^{\hat \psi} && Z^1 \\
97 : * v^{\hat 0}_{i} && Z^{2}_{i} \\
98 : * v^{\hat \pm} && u^{1\pm}
99 : * \f}
100 : *
101 : * The characteristic fields \f${v}^{\hat \alpha}\f$ are given in terms of
102 : * the evolved fields by Eq.(33) - (35) of \cite Holst2004wt, respectively:
103 : *
104 : * \f{align*}
105 : * v^{\hat \psi} =& \psi \\
106 : * v^{\hat 0}_{i} =& (\delta^k_i - n_i n^k) \Phi_{k} := P^k_i \Phi_{k} \\
107 : * v^{\hat \pm} =& \Pi \pm n^i \Phi_{i} - \gamma_2\psi
108 : * \f}
109 : *
110 : * where \f$\psi\f$ is the scalar field, \f$\Phi_{i}=\partial_i \psi\f$ is an
111 : * auxiliary variable, \f$\Pi\f$ is a conjugate momentum, \f$\gamma_2\f$
112 : * is a constraint damping parameter, and \f$n_k\f$ is the unit normal to the
113 : * surface along which the characteristic fields are defined.
114 : *
115 : * \ref Tags::EvolvedFieldsFromCharacteristicFieldsCompute computes evolved
116 : * fields \f$u_\alpha\f$ in terms of the characteristic fields. This uses the
117 : * inverse of above relations:
118 : *
119 : * \f{align*}
120 : * \psi =& v^{\hat \psi}, \\
121 : * \Pi =& \frac{1}{2}(v^{\hat +} + v^{\hat -}) + \gamma_2 v^{\hat \psi}, \\
122 : * \Phi_{i} =& \frac{1}{2}(v^{\hat +} - v^{\hat -}) n_i + v^{\hat 0}_{i}.
123 : * \f}
124 : *
125 : * The corresponding characteristic speeds \f$\lambda_{\hat \alpha}\f$
126 : * are computed by \ref Tags::CharacteristicSpeedsCompute .
127 : */
128 : template <size_t Dim>
129 : Variables<tmpl::list<Tags::VPsi, Tags::VZero<Dim>, Tags::VPlus, Tags::VMinus>>
130 1 : characteristic_fields(
131 : const Scalar<DataVector>& gamma_2, const Scalar<DataVector>& psi,
132 : const Scalar<DataVector>& pi,
133 : const tnsr::i<DataVector, Dim, Frame::Inertial>& phi,
134 : const tnsr::i<DataVector, Dim, Frame::Inertial>& unit_normal_one_form);
135 :
136 : template <size_t Dim>
137 1 : void characteristic_fields(
138 : gsl::not_null<Variables<
139 : tmpl::list<Tags::VPsi, Tags::VZero<Dim>, Tags::VPlus, Tags::VMinus>>*>
140 : char_fields,
141 : const Scalar<DataVector>& gamma_2, const Scalar<DataVector>& psi,
142 : const Scalar<DataVector>& pi,
143 : const tnsr::i<DataVector, Dim, Frame::Inertial>& phi,
144 : const tnsr::i<DataVector, Dim, Frame::Inertial>& unit_normal_one_form);
145 :
146 : namespace Tags {
147 : template <size_t Dim>
148 0 : struct CharacteristicFieldsCompute : Tags::CharacteristicFields<Dim>,
149 : db::ComputeTag {
150 0 : using base = Tags::CharacteristicFields<Dim>;
151 0 : using return_type = typename base::type;
152 0 : using argument_tags =
153 : tmpl::list<Tags::ConstraintGamma2, Psi, Pi, Phi<Dim>,
154 : ::Tags::Normalized<domain::Tags::UnnormalizedFaceNormal<Dim>>>;
155 :
156 0 : static void function(
157 : const gsl::not_null<return_type*> char_fields,
158 : const Scalar<DataVector>& gamma_2, const Scalar<DataVector>& psi,
159 : const Scalar<DataVector>& pi,
160 : const tnsr::i<DataVector, Dim, Frame::Inertial>& phi,
161 : const tnsr::i<DataVector, Dim, Frame::Inertial>& unit_normal_one_form) {
162 : characteristic_fields(char_fields, gamma_2, psi, pi, phi,
163 : unit_normal_one_form);
164 : };
165 : };
166 : } // namespace Tags
167 : /// @}
168 :
169 : /// @{
170 : /*!
171 : * \brief Compute evolved fields from characteristic fields.
172 : *
173 : * For expressions used here to compute evolved fields from characteristic ones,
174 : * see \ref Tags::CharacteristicFieldsCompute.
175 : */
176 : template <size_t Dim>
177 : Variables<tmpl::list<Tags::Psi, Tags::Pi, Tags::Phi<Dim>>>
178 1 : evolved_fields_from_characteristic_fields(
179 : const Scalar<DataVector>& gamma_2, const Scalar<DataVector>& v_psi,
180 : const tnsr::i<DataVector, Dim, Frame::Inertial>& v_zero,
181 : const Scalar<DataVector>& v_plus, const Scalar<DataVector>& v_minus,
182 : const tnsr::i<DataVector, Dim, Frame::Inertial>& unit_normal_one_form);
183 :
184 : template <size_t Dim>
185 1 : void evolved_fields_from_characteristic_fields(
186 : gsl::not_null<Variables<tmpl::list<Tags::Psi, Tags::Pi, Tags::Phi<Dim>>>*>
187 : evolved_fields,
188 : const Scalar<DataVector>& gamma_2, const Scalar<DataVector>& v_psi,
189 : const tnsr::i<DataVector, Dim, Frame::Inertial>& v_zero,
190 : const Scalar<DataVector>& v_plus, const Scalar<DataVector>& v_minus,
191 : const tnsr::i<DataVector, Dim, Frame::Inertial>& unit_normal_one_form);
192 :
193 : namespace Tags {
194 : template <size_t Dim>
195 0 : struct EvolvedFieldsFromCharacteristicFieldsCompute
196 : : Tags::EvolvedFieldsFromCharacteristicFields<Dim>,
197 : db::ComputeTag {
198 0 : using base = Tags::EvolvedFieldsFromCharacteristicFields<Dim>;
199 0 : using return_type = typename base::type;
200 0 : using argument_tags =
201 : tmpl::list<Tags::ConstraintGamma2, Tags::VPsi, Tags::VZero<Dim>,
202 : Tags::VPlus, Tags::VMinus,
203 : ::Tags::Normalized<domain::Tags::UnnormalizedFaceNormal<Dim>>>;
204 :
205 0 : static void function(
206 : const gsl::not_null<return_type*> evolved_fields,
207 : const Scalar<DataVector>& gamma_2, const Scalar<DataVector>& v_psi,
208 : const tnsr::i<DataVector, Dim, Frame::Inertial>& v_zero,
209 : const Scalar<DataVector>& v_plus, const Scalar<DataVector>& v_minus,
210 : const tnsr::i<DataVector, Dim, Frame::Inertial>& unit_normal_one_form) {
211 : evolved_fields_from_characteristic_fields(evolved_fields, gamma_2, v_psi,
212 : v_zero, v_plus, v_minus,
213 : unit_normal_one_form);
214 : };
215 : };
216 :
217 0 : struct LargestCharacteristicSpeed : db::SimpleTag {
218 0 : using type = double;
219 : };
220 :
221 : /// Compute the maximum magnitude of the characteristic speeds.
222 1 : struct ComputeLargestCharacteristicSpeed : LargestCharacteristicSpeed,
223 : db::ComputeTag {
224 0 : using argument_tags = tmpl::list<>;
225 0 : using return_type = double;
226 0 : using base = LargestCharacteristicSpeed;
227 0 : SPECTRE_ALWAYS_INLINE static constexpr void function(
228 : const gsl::not_null<double*> speed) {
229 : *speed = 1.0;
230 : }
231 : };
232 : } // namespace Tags
233 : /// @}
234 : } // namespace ScalarWave
|
