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 <pup.h>
8 : #include <utility>
9 :
10 : #include "DataStructures/Variables.hpp"
11 : #include "Domain/Structure/DirectionMap.hpp"
12 : #include "Utilities/ErrorHandling/Assert.hpp"
13 : #include "Utilities/Gsl.hpp"
14 : #include "Utilities/MakeWithValue.hpp"
15 :
16 : /*!
17 : * \ingroup DataStructuresGroup
18 : * \brief A data structure holding Variables associated with directions.
19 : *
20 : * This class holds Variables of sizes `points_per_direction`, all
21 : * referencing a single memory allocation. The individual Variables
22 : * can be accessed through the `variables()` member. Access to the
23 : * underlying buffer is provided so that the class can, for example,
24 : * be used as the evolved variables for an evolution system.
25 : */
26 : template <size_t Dim, typename Tags>
27 1 : class BoundaryVariables {
28 : static_assert(
29 : DirectionMap<Dim, size_t>::hash_is_perfect,
30 : "Map must use a perfect hash to ensure consistent data ordering.");
31 :
32 : public:
33 0 : using tags_list = Tags;
34 0 : using VariablesType = Variables<tags_list>;
35 0 : using Vector = typename VariablesType::vector_type;
36 :
37 0 : BoundaryVariables() = default;
38 0 : BoundaryVariables(BoundaryVariables&& other)
39 : : points_per_direction_(std::move(other.points_per_direction_)),
40 : buffer_(std::move(other.buffer_)) {
41 : other.clear();
42 : setup_variables();
43 : }
44 0 : BoundaryVariables(const BoundaryVariables& other)
45 : : points_per_direction_(other.points_per_direction_),
46 : buffer_(other.buffer_) {
47 : setup_variables();
48 : }
49 :
50 0 : BoundaryVariables& operator=(BoundaryVariables&& other) {
51 : if (this == &other) {
52 : return *this;
53 : }
54 : points_per_direction_ = std::move(other.points_per_direction_);
55 : buffer_ = std::move(other.buffer_);
56 : other.clear();
57 : setup_variables();
58 : return *this;
59 : }
60 0 : BoundaryVariables& operator=(const BoundaryVariables& other) {
61 : points_per_direction_ = other.points_per_direction_;
62 : buffer_ = other.buffer_;
63 : setup_variables();
64 : return *this;
65 : }
66 :
67 0 : ~BoundaryVariables() = default;
68 :
69 0 : explicit BoundaryVariables(DirectionMap<Dim, size_t> points_per_direction) {
70 : initialize(std::move(points_per_direction));
71 : }
72 :
73 0 : BoundaryVariables(DirectionMap<Dim, size_t> points_per_direction,
74 : const typename Vector::value_type& initial_value) {
75 : initialize(std::move(points_per_direction), initial_value);
76 : }
77 :
78 0 : void initialize(DirectionMap<Dim, size_t> points_per_direction) {
79 : points_per_direction_ = std::move(points_per_direction);
80 : buffer_ = Vector(buffer_size());
81 : setup_variables();
82 : }
83 :
84 0 : void initialize(DirectionMap<Dim, size_t> points_per_direction,
85 : const typename Vector::value_type& initial_value) {
86 : points_per_direction_ = std::move(points_per_direction);
87 : buffer_ = Vector(buffer_size(), initial_value);
88 : setup_variables();
89 : }
90 :
91 0 : size_t size() const { return buffer_.size(); }
92 0 : bool empty() const { return buffer_.size() == 0; }
93 :
94 0 : void clear() {
95 : points_per_direction_.clear();
96 : buffer_.clear();
97 : variables_.clear();
98 : }
99 :
100 0 : const DirectionMap<Dim, size_t>& points_per_direction() const {
101 : return points_per_direction_;
102 : }
103 :
104 0 : const Vector& buffer() const {
105 : check_pointers();
106 : return buffer_;
107 : }
108 0 : Vector& buffer() {
109 : check_pointers();
110 : return buffer_;
111 : }
112 :
113 0 : DirectionMap<Dim, VariablesType>& variables() {
114 : check_pointers();
115 : return variables_;
116 : }
117 0 : const DirectionMap<Dim, VariablesType>& variables() const {
118 : check_pointers();
119 : return variables_;
120 : }
121 :
122 0 : void pup(PUP::er& p) {
123 : p | points_per_direction_;
124 : p | buffer_;
125 : if (p.isUnpacking()) {
126 : setup_variables();
127 : }
128 : }
129 :
130 : private:
131 0 : size_t buffer_size() const {
132 : size_t num_points = 0;
133 : for (const auto& [direction, points] : points_per_direction_) {
134 : num_points += points;
135 : }
136 : return num_points * VariablesType::number_of_independent_components;
137 : }
138 :
139 0 : void setup_variables() {
140 : variables_.clear();
141 : size_t offset = 0;
142 : for (const auto& [direction, points] : points_per_direction_) {
143 : const size_t vars_size =
144 : points * VariablesType::number_of_independent_components;
145 : variables_.emplace(direction,
146 : VariablesType(buffer_.data() + offset, vars_size));
147 : offset += vars_size;
148 : }
149 : }
150 :
151 0 : void check_pointers() const {
152 : #ifdef SPECTRE_DEBUG
153 : if (points_per_direction_.empty()) {
154 : return;
155 : }
156 : ASSERT(buffer_.size() == buffer_size(),
157 : "Buffer has been manually resized. Have "
158 : << buffer_.size() << " entries but should be " << buffer_size());
159 : const auto first_direction = points_per_direction_.begin()->first;
160 : ASSERT(variables_.at(first_direction).data() == buffer_.data(),
161 : "Pointer mismatch. Data buffers have been replaced.");
162 : #endif
163 : }
164 :
165 0 : DirectionMap<Dim, size_t> points_per_direction_{};
166 0 : Vector buffer_{};
167 0 : DirectionMap<Dim, VariablesType> variables_{};
168 : };
169 :
170 : template <size_t Dim, typename Tags>
171 0 : bool operator==(const BoundaryVariables<Dim, Tags>& a,
172 : const BoundaryVariables<Dim, Tags>& b) {
173 : return a.points_per_direction() == b.points_per_direction() and
174 : a.buffer() == b.buffer();
175 : }
176 :
177 : template <size_t Dim, typename Tags>
178 0 : bool operator!=(const BoundaryVariables<Dim, Tags>& a,
179 : const BoundaryVariables<Dim, Tags>& b) {
180 : return not(a == b);
181 : }
182 :
183 : template <size_t Dim, typename Tags>
184 0 : auto make_math_wrapper(
185 : const gsl::not_null<BoundaryVariables<Dim, Tags>*> data) {
186 : return make_math_wrapper(&data->buffer());
187 : }
188 :
189 : template <size_t Dim, typename Tags>
190 0 : auto make_math_wrapper(const BoundaryVariables<Dim, Tags>& data) {
191 : return make_math_wrapper(data.buffer());
192 : }
193 :
194 : template <size_t Dim, typename Tags>
195 0 : auto into_math_wrapper_type(BoundaryVariables<Dim, Tags>&& data) {
196 : auto result = into_math_wrapper_type(std::move(data.buffer()));
197 : data.clear();
198 : return result;
199 : }
200 :
201 : // We can't set the size from an arbitrary object, but we can copy
202 : // sizes from one BoundaryVariables to another.
203 : template <size_t Dim, typename Tags1, typename Tags2>
204 0 : struct MakeWithValueImpls::MakeWithValueImpl<BoundaryVariables<Dim, Tags1>,
205 : BoundaryVariables<Dim, Tags2>> {
206 : template <typename ValueType>
207 0 : static BoundaryVariables<Dim, Tags1> apply(
208 : const BoundaryVariables<Dim, Tags2>& input, const ValueType value) {
209 : return {input.points_per_direction(), value};
210 : }
211 : };
212 :
213 : template <size_t Dim, typename Tags1, typename Tags2>
214 0 : void set_number_of_grid_points(
215 : const gsl::not_null<BoundaryVariables<Dim, Tags1>*> result,
216 : const BoundaryVariables<Dim, Tags2>& pattern) {
217 : if (UNLIKELY(result->points_per_direction() !=
218 : pattern.points_per_direction())) {
219 : *result = BoundaryVariables<Dim, Tags1>(pattern.points_per_direction());
220 : }
221 : }
222 :
223 : template <size_t Dim, typename Tags>
224 0 : bool contains_allocations(const BoundaryVariables<Dim, Tags>& value) {
225 : return contains_allocations(value.buffer());
226 : }
|
