Line data Source code
1 0 : // Distributed under the MIT License.
2 : // See LICENSE.txt for details
3 :
4 : #pragma once
5 :
6 : #include "DataStructures/ComplexDataVector.hpp"
7 : #include "DataStructures/VectorImpl.hpp"
8 : #include "Utilities/ForceInline.hpp"
9 : #include "Utilities/Requires.hpp"
10 : #include "Utilities/SetNumberOfGridPoints.hpp"
11 : #include "Utilities/TypeTraits.hpp"
12 :
13 : /// @{
14 : /*!
15 : * \ingroup DataStructuresGroup
16 : * \brief Make a spin-weighted type `T` with spin-weight `Spin`. Mathematical
17 : * operators are restricted to addition, subtraction, multiplication and
18 : * division, with spin-weights checked for validity.
19 : *
20 : * \details For a spin-weighted object, we limit operations to those valid for a
21 : * pair of spin-weighted quantities - i.e. addition only makes sense when the
22 : * two summands possess the same spin weight, and multiplication (or division)
23 : * result in a summed (or subtracted) spin weight.
24 : */
25 : template <typename T, int Spin, bool is_vector = is_derived_of_vector_impl_v<T>>
26 1 : struct SpinWeighted;
27 :
28 : template <typename T, int Spin>
29 0 : struct SpinWeighted<T, Spin, false> {
30 0 : using value_type = T;
31 0 : constexpr static int spin = Spin;
32 :
33 0 : SpinWeighted() = default;
34 0 : SpinWeighted(const SpinWeighted&) = default;
35 0 : SpinWeighted(SpinWeighted&&) = default;
36 0 : SpinWeighted& operator=(const SpinWeighted&) = default;
37 0 : SpinWeighted& operator=(SpinWeighted&&) = default;
38 0 : ~SpinWeighted() = default;
39 :
40 : // clang-tidy asks that these be marked explicit, but we actually do not want
41 : // them explicit for use in the math operations below.
42 : template <typename Rhs>
43 0 : SpinWeighted(const SpinWeighted<Rhs, Spin>& rhs) // NOLINT
44 : : data_{rhs.data()} {}
45 :
46 : template <typename Rhs>
47 0 : SpinWeighted(SpinWeighted<Rhs, Spin>&& rhs) // NOLINT
48 : : data_{std::move(rhs.data())} {}
49 :
50 0 : SpinWeighted(const T& rhs) : data_{rhs} {} // NOLINT
51 0 : SpinWeighted(T&& rhs) : data_{std::move(rhs)} {} // NOLINT
52 0 : explicit SpinWeighted(const size_t size) : data_{size} {}
53 : template <typename U>
54 0 : SpinWeighted(const size_t size, const U& val) : data_{size, val} {}
55 :
56 : template <typename Rhs>
57 0 : SpinWeighted& operator=(const SpinWeighted<Rhs, Spin>& rhs) {
58 : data_ = rhs.data();
59 : return *this;
60 : }
61 :
62 : template <typename Rhs>
63 0 : SpinWeighted& operator=(SpinWeighted<Rhs, Spin>&& rhs) {
64 : data_ = std::move(rhs.data());
65 : return *this;
66 : }
67 :
68 0 : SpinWeighted& operator=(const T& rhs) {
69 : data_ = rhs;
70 : return *this;
71 : }
72 0 : SpinWeighted& operator=(T&& rhs) {
73 : data_ = std::move(rhs);
74 : return *this;
75 : }
76 :
77 : template <typename Rhs>
78 0 : auto& operator+=(const SpinWeighted<Rhs, Spin>& rhs) {
79 : data_ += rhs.data();
80 : return *this;
81 : }
82 :
83 0 : auto& operator+=(const T& rhs) {
84 : data_ += rhs;
85 : return *this;
86 : }
87 :
88 : template <typename Rhs>
89 0 : auto& operator-=(const SpinWeighted<Rhs, Spin>& rhs) {
90 : data_ -= rhs.data();
91 : return *this;
92 : }
93 :
94 0 : auto& operator-=(const T& rhs) {
95 : data_ -= rhs;
96 : return *this;
97 : }
98 :
99 0 : T& data() { return data_; }
100 0 : const T& data() const { return data_; }
101 :
102 0 : size_t size() const { return data_.size(); }
103 :
104 : /// Serialization for Charm++
105 : // NOLINTNEXTLINE(google-runtime-references)
106 1 : void pup(PUP::er& p);
107 :
108 : private:
109 0 : T data_;
110 : };
111 :
112 : template <typename T, int Spin>
113 0 : struct SpinWeighted<T, Spin, true> {
114 0 : using value_type = T;
115 0 : constexpr static int spin = Spin;
116 :
117 0 : void set_data_ref(const gsl::not_null<T*> rhs) { data_.set_data_ref(rhs); }
118 :
119 : // needed for invoking the check in `Variables.hpp` that ensures that
120 : // default-constructed `Variables` are never used.
121 0 : void set_data_ref(const std::nullptr_t null, const size_t size) {
122 : data_.set_data_ref(null, size);
123 : }
124 :
125 0 : void set_data_ref(const gsl::not_null<SpinWeighted<T, spin>*> rhs) {
126 : data_.set_data_ref(make_not_null(&(rhs->data_)));
127 : }
128 :
129 : template <typename ValueType>
130 0 : void set_data_ref(ValueType* const start, const size_t set_size) {
131 : data_.set_data_ref(start, set_size);
132 : }
133 :
134 0 : void destructive_resize(const size_t new_size) {
135 : data_.destructive_resize(new_size);
136 : }
137 :
138 0 : SpinWeighted() = default;
139 0 : SpinWeighted(const SpinWeighted&) = default;
140 0 : SpinWeighted(SpinWeighted&&) = default;
141 0 : SpinWeighted& operator=(const SpinWeighted&) = default;
142 0 : SpinWeighted& operator=(SpinWeighted&&) = default;
143 0 : ~SpinWeighted() = default;
144 :
145 : // clang-tidy asks that these be marked explicit, but we actually do not want
146 : // them explicit for use in the math operations below.
147 : template <typename Rhs>
148 0 : SpinWeighted(const SpinWeighted<Rhs, Spin>& rhs) // NOLINT
149 : : data_{rhs.data()} {}
150 :
151 : template <typename Rhs>
152 0 : SpinWeighted(SpinWeighted<Rhs, Spin>&& rhs) // NOLINT
153 : : data_{std::move(rhs.data())} {}
154 :
155 0 : SpinWeighted(const T& rhs) : data_{rhs} {} // NOLINT
156 0 : SpinWeighted(T&& rhs) : data_{std::move(rhs)} {} // NOLINT
157 0 : explicit SpinWeighted(const size_t size) : data_{size} {}
158 : template <typename U>
159 0 : SpinWeighted(const size_t size, const U& val) : data_{size, val} {}
160 :
161 : template <typename Rhs>
162 0 : SpinWeighted& operator=(const SpinWeighted<Rhs, Spin>& rhs) {
163 : data_ = rhs.data();
164 : return *this;
165 : }
166 :
167 : template <typename Rhs>
168 0 : SpinWeighted& operator=(SpinWeighted<Rhs, Spin>&& rhs) {
169 : data_ = std::move(rhs.data());
170 : return *this;
171 : }
172 :
173 0 : SpinWeighted& operator=(const T& rhs) {
174 : data_ = rhs;
175 : return *this;
176 : }
177 0 : SpinWeighted& operator=(T&& rhs) {
178 : data_ = std::move(rhs);
179 : return *this;
180 : }
181 :
182 : template <typename Rhs>
183 0 : auto& operator+=(const SpinWeighted<Rhs, Spin>& rhs) {
184 : data_ += rhs.data();
185 : return *this;
186 : }
187 :
188 0 : auto& operator+=(const T& rhs) {
189 : data_ += rhs;
190 : return *this;
191 : }
192 :
193 : template <typename Rhs>
194 0 : auto& operator-=(const SpinWeighted<Rhs, Spin>& rhs) {
195 : data_ -= rhs.data();
196 : return *this;
197 : }
198 :
199 0 : auto& operator-=(const T& rhs) {
200 : data_ -= rhs;
201 : return *this;
202 : }
203 :
204 0 : T& data() { return data_; }
205 0 : const T& data() const { return data_; }
206 :
207 0 : size_t size() const { return data_.size(); }
208 :
209 : /// Serialization for Charm++
210 : // NOLINTNEXTLINE(google-runtime-references)
211 1 : void pup(PUP::er& p);
212 :
213 : private:
214 0 : T data_;
215 : };
216 : /// @}
217 :
218 : template <typename T, int Spin>
219 : void SpinWeighted<T, Spin, true>::pup(PUP::er& p) {
220 : p | data_;
221 : }
222 :
223 : template <typename T, int Spin>
224 : void SpinWeighted<T, Spin, false>::pup(PUP::er& p) {
225 : p | data_;
226 : }
227 :
228 : /// @{
229 : /// \ingroup TypeTraitsGroup
230 : /// \ingroup DataStructuresGroup
231 : /// This is a `std::true_type` if the provided type is a `SpinWeighted` of any
232 : /// type and spin, otherwise is a `std::false_type`.
233 : template <typename T>
234 1 : struct is_any_spin_weighted : std::false_type {};
235 :
236 : template <typename T, int S>
237 0 : struct is_any_spin_weighted<SpinWeighted<T, S>> : std::true_type {};
238 : /// @}
239 :
240 : template <typename T>
241 0 : constexpr bool is_any_spin_weighted_v = is_any_spin_weighted<T>::value;
242 :
243 : /// @{
244 : /// \ingroup TypeTraitsGroup
245 : /// \ingroup DataStructuresGroup
246 : /// This is a `std::true_type` if the provided type `T` is a `SpinWeighted` of
247 : /// `InternalType` and any spin, otherwise is a `std::false_type`.
248 : template <typename InternalType, typename T>
249 1 : struct is_spin_weighted_of : std::false_type {};
250 :
251 : template <typename InternalType, int S>
252 0 : struct is_spin_weighted_of<InternalType, SpinWeighted<InternalType, S>>
253 : : std::true_type {};
254 : /// @}
255 :
256 : template <typename InternalType, typename T>
257 0 : constexpr bool is_spin_weighted_of_v =
258 : is_spin_weighted_of<InternalType, T>::value;
259 :
260 : /// @{
261 : /// \ingroup TypeTraitsGroup
262 : /// \ingroup DataStructuresGroup
263 : /// This is a `std::true_type` if the provided type `T1` is a `SpinWeighted` and
264 : /// `T2` is a `SpinWeighted`, and both have the same internal type, but any
265 : /// combination of spin weights.
266 : template <typename T1, typename T2>
267 1 : struct is_spin_weighted_of_same_type : std::false_type {};
268 :
269 : template <typename T, int Spin1, int Spin2>
270 0 : struct is_spin_weighted_of_same_type<SpinWeighted<T, Spin1>,
271 : SpinWeighted<T, Spin2>> : std::true_type {
272 : };
273 : /// @}
274 :
275 : template <typename T1, typename T2>
276 0 : constexpr bool is_spin_weighted_of_same_type_v =
277 : is_spin_weighted_of_same_type<T1, T2>::value;
278 :
279 : /// @{
280 : /// \brief Add two spin-weighted quantities if the types are compatible and
281 : /// spins are the same. Un-weighted quantities are assumed to be spin 0.
282 : // These overloads are designed to allow SpinWeighted to wrap Blaze expression
283 : // templates to ensure efficient math operations, necessitating the
284 : // `decltype(declval<T>() ...` syntax
285 : template <typename T1, typename T2, int Spin>
286 : SPECTRE_ALWAYS_INLINE
287 : SpinWeighted<decltype(std::declval<T1>() + std::declval<T2>()), Spin>
288 1 : operator+(const SpinWeighted<T1, Spin>& lhs,
289 : const SpinWeighted<T2, Spin>& rhs) {
290 : return {lhs.data() + rhs.data()};
291 : }
292 : template <typename T>
293 : SPECTRE_ALWAYS_INLINE
294 : SpinWeighted<decltype(std::declval<T>() + std::declval<T>()), 0>
295 1 : operator+(const SpinWeighted<T, 0>& lhs, const T& rhs) {
296 : return {lhs.data() + rhs};
297 : }
298 : template <typename T>
299 : SPECTRE_ALWAYS_INLINE SpinWeighted<
300 : decltype(std::declval<T>() + std::declval<get_vector_element_type_t<T>>()),
301 : 0>
302 1 : operator+(const SpinWeighted<T, 0>& lhs,
303 : const get_vector_element_type_t<T>& rhs) {
304 : return {lhs.data() + rhs};
305 : }
306 : template <typename T>
307 : SPECTRE_ALWAYS_INLINE
308 : SpinWeighted<decltype(std::declval<T>() + std::declval<T>()), 0>
309 1 : operator+(const T& lhs, const SpinWeighted<T, 0>& rhs) {
310 : return {lhs + rhs.data()};
311 : }
312 : template <typename T>
313 : SPECTRE_ALWAYS_INLINE SpinWeighted<
314 : decltype(std::declval<get_vector_element_type_t<T>>() + std::declval<T>()),
315 : 0>
316 1 : operator+(const get_vector_element_type_t<T>& lhs,
317 : const SpinWeighted<T, 0>& rhs) {
318 : return {lhs + rhs.data()};
319 : }
320 : /// @}
321 :
322 : /// @{
323 : /// \brief Subtract two spin-weighted quantities if the types are compatible and
324 : /// spins are the same. Un-weighted quantities are assumed to be spin 0.
325 : // These overloads are designed to allow SpinWeighted to wrap Blaze expression
326 : // templates to ensure efficient math operations, necessitating the
327 : // `decltype(declval<T>() ...` syntax
328 : template <typename T1, typename T2, int Spin>
329 : SPECTRE_ALWAYS_INLINE
330 : SpinWeighted<decltype(std::declval<T1>() - std::declval<T2>()), Spin>
331 1 : operator-(const SpinWeighted<T1, Spin>& lhs,
332 : const SpinWeighted<T2, Spin>& rhs) {
333 : return {lhs.data() - rhs.data()};
334 : }
335 : template <typename T>
336 : SPECTRE_ALWAYS_INLINE
337 : SpinWeighted<decltype(std::declval<T>() - std::declval<T>()), 0>
338 1 : operator-(const SpinWeighted<T, 0>& lhs, const T& rhs) {
339 : return {lhs.data() - rhs};
340 : }
341 : template <typename T>
342 : SPECTRE_ALWAYS_INLINE SpinWeighted<
343 : decltype(std::declval<T>() - std::declval<get_vector_element_type_t<T>>()),
344 : 0>
345 1 : operator-(const SpinWeighted<T, 0>& lhs,
346 : const get_vector_element_type_t<T>& rhs) {
347 : return {lhs.data() - rhs};
348 : }
349 : template <typename T>
350 : SPECTRE_ALWAYS_INLINE
351 : SpinWeighted<decltype(std::declval<T>() - std::declval<T>()), 0>
352 1 : operator-(const T& lhs, const SpinWeighted<T, 0>& rhs) {
353 : return {lhs - rhs.data()};
354 : }
355 : template <typename T>
356 : SPECTRE_ALWAYS_INLINE SpinWeighted<
357 : decltype(std::declval<get_vector_element_type_t<T>>() - std::declval<T>()),
358 : 0>
359 1 : operator-(const get_vector_element_type_t<T>& lhs,
360 : const SpinWeighted<T, 0>& rhs) {
361 : return {lhs - rhs.data()};
362 : }
363 : /// @}
364 :
365 : /// Negation operator preserves spin
366 : template <typename T, int Spin>
367 : SPECTRE_ALWAYS_INLINE SpinWeighted<decltype(-std::declval<T>()), Spin>
368 1 : operator-(const SpinWeighted<T, Spin>& operand) {
369 : return {-operand.data()};
370 : }
371 :
372 : /// Unary `+` operator preserves spin
373 : template <typename T, int Spin>
374 : SPECTRE_ALWAYS_INLINE SpinWeighted<decltype(+std::declval<T>()), Spin>
375 1 : operator+(const SpinWeighted<T, Spin>& operand) {
376 : return {+operand.data()};
377 : }
378 :
379 : /// @{
380 : /// \brief Multiply two spin-weighted quantities if the types are compatible and
381 : /// add the spins. Un-weighted quantities are assumed to be spin 0.
382 : // These overloads are designed to allow SpinWeighted to wrap Blaze expression
383 : // templates to ensure efficient math operations, necessitating the
384 : // `decltype(declval<T>() ...` syntax
385 : template <typename T1, typename T2, int Spin1, int Spin2>
386 : SPECTRE_ALWAYS_INLINE SpinWeighted<
387 : decltype(std::declval<T1>() * std::declval<T2>()), Spin1 + Spin2>
388 1 : operator*(const SpinWeighted<T1, Spin1>& lhs,
389 : const SpinWeighted<T2, Spin2>& rhs) {
390 : return {lhs.data() * rhs.data()};
391 : }
392 : template <typename T, int Spin>
393 : SPECTRE_ALWAYS_INLINE
394 : SpinWeighted<decltype(std::declval<T>() * std::declval<T>()), Spin>
395 1 : operator*(const SpinWeighted<T, Spin>& lhs, const T& rhs) {
396 : return {lhs.data() * rhs};
397 : }
398 : template <typename T, int Spin>
399 : SPECTRE_ALWAYS_INLINE SpinWeighted<
400 : decltype(std::declval<T>() * std::declval<get_vector_element_type_t<T>>()),
401 : Spin>
402 1 : operator*(const SpinWeighted<T, Spin>& lhs,
403 : const get_vector_element_type_t<T>& rhs) {
404 : return {lhs.data() * rhs};
405 : }
406 : template <typename T, int Spin>
407 : SPECTRE_ALWAYS_INLINE
408 : SpinWeighted<decltype(std::declval<T>() * std::declval<T>()), Spin>
409 1 : operator*(const T& lhs, const SpinWeighted<T, Spin>& rhs) {
410 : return {lhs * rhs.data()};
411 : }
412 : template <typename T, int Spin>
413 : SPECTRE_ALWAYS_INLINE SpinWeighted<
414 : decltype(std::declval<get_vector_element_type_t<T>>() * std::declval<T>()),
415 : Spin>
416 1 : operator*(const get_vector_element_type_t<T>& lhs,
417 : const SpinWeighted<T, Spin>& rhs) {
418 : return {lhs * rhs.data()};
419 : }
420 : /// @}
421 :
422 : /// @{
423 : /// \brief Divide two spin-weighted quantities if the types are compatible and
424 : /// subtract the spins. Un-weighted quantities are assumed to be spin 0.
425 : // These overloads are designed to allow SpinWeighted to wrap Blaze expression
426 : // templates to ensure efficient math operations, necessitating the
427 : // `decltype(declval<T>() ...` syntax
428 : template <typename T1, typename T2, int Spin1, int Spin2>
429 : SPECTRE_ALWAYS_INLINE SpinWeighted<
430 : decltype(std::declval<T1>() / std::declval<T2>()), Spin1 - Spin2>
431 1 : operator/(const SpinWeighted<T1, Spin1>& lhs,
432 : const SpinWeighted<T2, Spin2>& rhs) {
433 : return {lhs.data() / rhs.data()};
434 : }
435 : template <typename T, int Spin>
436 : SPECTRE_ALWAYS_INLINE
437 : SpinWeighted<decltype(std::declval<T>() / std::declval<T>()), Spin>
438 1 : operator/(const SpinWeighted<T, Spin>& lhs, const T& rhs) {
439 : return {lhs.data() / rhs};
440 : }
441 : template <typename T, int Spin>
442 : SPECTRE_ALWAYS_INLINE SpinWeighted<
443 : decltype(std::declval<T>() / std::declval<get_vector_element_type_t<T>>()),
444 : Spin>
445 1 : operator/(const SpinWeighted<T, Spin>& lhs,
446 : const get_vector_element_type_t<T>& rhs) {
447 : return {lhs.data() / rhs};
448 : }
449 : template <typename T, int Spin>
450 : SPECTRE_ALWAYS_INLINE
451 : SpinWeighted<decltype(std::declval<T>() / std::declval<T>()), -Spin>
452 1 : operator/(const T& lhs, const SpinWeighted<T, Spin>& rhs) {
453 : return {lhs / rhs.data()};
454 : }
455 : template <
456 : typename T, int Spin,
457 : Requires<not std::is_same_v<T, get_vector_element_type_t<T>>> = nullptr>
458 : SPECTRE_ALWAYS_INLINE SpinWeighted<
459 : decltype(std::declval<get_vector_element_type_t<T>>() / std::declval<T>()),
460 : -Spin>
461 1 : operator/(const get_vector_element_type_t<T>& lhs,
462 : const SpinWeighted<T, Spin>& rhs) {
463 : return {lhs / rhs.data()};
464 : }
465 : /// @}
466 :
467 : /// conjugate the spin-weighted quantity, inverting the spin
468 : template <typename T, int Spin>
469 : SPECTRE_ALWAYS_INLINE SpinWeighted<decltype(conj(std::declval<T>())), -Spin>
470 1 : conj(const SpinWeighted<T, Spin>& value) {
471 : return {conj(value.data())};
472 : }
473 :
474 : /// Take the exponential of the spin-weighted quantity; only valid for
475 : /// spin-weight = 0
476 : template <typename T>
477 1 : SPECTRE_ALWAYS_INLINE SpinWeighted<decltype(exp(std::declval<T>())), 0> exp(
478 : const SpinWeighted<T, 0>& value) {
479 : return {exp(value.data())};
480 : }
481 :
482 : /// Take the square-root of the spin-weighted quantity; only valid for
483 : /// spin-weight = 0
484 : template <typename T, int Spin>
485 1 : SPECTRE_ALWAYS_INLINE SpinWeighted<decltype(sqrt(std::declval<T>())), 0> sqrt(
486 : const SpinWeighted<T, Spin>& value) {
487 : return {sqrt(value.data())};
488 : }
489 :
490 : /// @{
491 : /// \brief Test equivalence of spin-weighted quantities if the types are
492 : /// compatible and spins are the same. Un-weighted quantities are assumed to
493 : /// be spin 0.
494 : template <typename T1, typename T2, int Spin>
495 1 : SPECTRE_ALWAYS_INLINE bool operator==(const SpinWeighted<T1, Spin>& lhs,
496 : const SpinWeighted<T2, Spin>& rhs) {
497 : return lhs.data() == rhs.data();
498 : }
499 : template <typename T>
500 1 : SPECTRE_ALWAYS_INLINE bool operator==(const SpinWeighted<T, 0>& lhs,
501 : const T& rhs) {
502 : return lhs.data() == rhs;
503 : }
504 : template <typename T>
505 1 : SPECTRE_ALWAYS_INLINE bool operator==(const T& lhs,
506 : const SpinWeighted<T, 0>& rhs) {
507 : return lhs == rhs.data();
508 : }
509 : /// @}
510 :
511 : /// @{
512 : /// \brief Test inequivalence of spin-weighted quantities if the types are
513 : /// compatible and spins are the same. Un-weighted quantities are assumed to be
514 : /// spin 0.
515 : template <typename T1, typename T2, int Spin>
516 1 : SPECTRE_ALWAYS_INLINE bool operator!=(const SpinWeighted<T1, Spin>& lhs,
517 : const SpinWeighted<T2, Spin>& rhs) {
518 : return not(lhs == rhs);
519 : }
520 : template <typename T>
521 1 : SPECTRE_ALWAYS_INLINE bool operator!=(const SpinWeighted<T, 0>& lhs,
522 : const T& rhs) {
523 : return not(lhs == rhs);
524 : }
525 : template <typename T>
526 1 : SPECTRE_ALWAYS_INLINE bool operator!=(const T& lhs,
527 : const SpinWeighted<T, 0>& rhs) {
528 : return not(lhs == rhs);
529 : }
530 : /// @}
531 :
532 : /// \ingroup DataStructuresGroup
533 : /// Make the input `view` a `const` view of the const data `spin_weighted`, at
534 : /// offset `offset` and length `extent`.
535 : ///
536 : /// \warning This DOES modify the (const) input `view`. The reason `view` is
537 : /// taken by const pointer is to try to insist that the object to be a `const`
538 : /// view is actually const. Of course, there are ways of subverting this
539 : /// intended functionality and editing the data pointed into by `view` after
540 : /// this function is called; doing so is highly discouraged and results in
541 : /// undefined behavior.
542 : template <typename SpinWeightedType,
543 : Requires<is_any_spin_weighted_v<SpinWeightedType> and
544 : is_derived_of_vector_impl_v<
545 : typename SpinWeightedType::value_type>> = nullptr>
546 1 : void make_const_view(const gsl::not_null<const SpinWeightedType*> view,
547 : const SpinWeightedType& spin_weighted, const size_t offset,
548 : const size_t extent) {
549 : const_cast<SpinWeightedType*>(view.get()) // NOLINT
550 : ->set_data_ref(const_cast< // NOLINT
551 : typename SpinWeightedType::value_type::value_type*>(
552 : spin_weighted.data().data()) + // NOLINT
553 : offset,
554 : extent);
555 : }
556 :
557 : /// Stream operator simply forwards
558 : template <typename T, int Spin>
559 1 : std::ostream& operator<<(std::ostream& os, const SpinWeighted<T, Spin>& d) {
560 : return os << d.data();
561 : }
562 :
563 : namespace MakeWithValueImpls {
564 : template <int Spin, typename SpinWeightedType>
565 0 : struct NumberOfPoints<SpinWeighted<SpinWeightedType, Spin>> {
566 : static SPECTRE_ALWAYS_INLINE size_t
567 0 : apply(const SpinWeighted<SpinWeightedType, Spin>& input) {
568 : return number_of_points(input.data());
569 : }
570 : };
571 :
572 : template <int Spin, typename SpinWeightedType>
573 0 : struct MakeWithSize<SpinWeighted<SpinWeightedType, Spin>> {
574 : template <typename ValueType>
575 0 : static SPECTRE_ALWAYS_INLINE SpinWeighted<SpinWeightedType, Spin> apply(
576 : const size_t size, const ValueType value) {
577 : return SpinWeighted<SpinWeightedType, Spin>{
578 : make_with_value<SpinWeightedType>(size, value)};
579 : }
580 : };
581 : } // namespace MakeWithValueImpls
582 :
583 : template <int Spin, typename SpinWeightedType>
584 0 : struct SetNumberOfGridPointsImpls::SetNumberOfGridPointsImpl<
585 : SpinWeighted<SpinWeightedType, Spin>> {
586 0 : static constexpr bool is_trivial =
587 : SetNumberOfGridPointsImpl<SpinWeightedType>::is_trivial;
588 0 : static SPECTRE_ALWAYS_INLINE void apply(
589 : const gsl::not_null<SpinWeighted<SpinWeightedType, Spin>*> result,
590 : const size_t size) {
591 : set_number_of_grid_points(make_not_null(&result->data()), size);
592 : }
593 : };
|
