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 : #include <memory>
9 : #include <string>
10 : #include <unordered_map>
11 : #include <vector>
12 :
13 : #include "Domain/BoundaryConditions/BoundaryCondition.hpp"
14 : #include "Domain/BoundaryConditions/Cartoon.hpp"
15 : #include "Domain/BoundaryConditions/GetBoundaryConditionsBase.hpp"
16 : #include "Domain/CoordinateMaps/Distribution.hpp"
17 : #include "Domain/Creators/DomainCreator.hpp"
18 : #include "Domain/Creators/TimeDependence/TimeDependence.hpp"
19 : #include "Domain/Domain.hpp"
20 : #include "Domain/Structure/DirectionMap.hpp"
21 : #include "Options/Context.hpp"
22 : #include "Options/String.hpp"
23 : #include "Utilities/TMPL.hpp"
24 :
25 : /// \cond
26 : namespace domain {
27 : namespace CoordinateMaps {
28 : class Interval;
29 : template <typename Map1, typename Map2, typename Map3>
30 : class ProductOf3Maps;
31 : } // namespace CoordinateMaps
32 :
33 : template <typename SourceFrame, typename TargetFrame, typename... Maps>
34 : class CoordinateMap;
35 : } // namespace domain
36 : /// \endcond
37 :
38 : namespace domain::creators {
39 : /// Create a 3D Domain with its computational domain being the\f$x-y\f$
40 : /// plane. The third dimension uses a Cartoon basis with Killing vector along
41 : /// the \f$\phi\f$ direction.
42 1 : class CartoonCylinder : public DomainCreator<3> {
43 : public:
44 0 : using maps_list = tmpl::list<domain::CoordinateMap<
45 : Frame::BlockLogical, Frame::Inertial,
46 : CoordinateMaps::ProductOf3Maps<CoordinateMaps::Interval,
47 : CoordinateMaps::Interval,
48 : CoordinateMaps::Identity<1>>>>;
49 :
50 0 : static std::string name() { return "CartoonCylinder"; }
51 :
52 0 : struct LowerBounds {
53 0 : using type = std::array<double, 2>;
54 0 : static constexpr Options::String help = {
55 : "Lower bound in the [x,y] dimensions. The lower x must be greater than "
56 : "or equal to 0. If x=0 is included, the innermost elements use a 1D "
57 : "Zernike basis, otherwise the domain will be a cylindrical shell."};
58 : };
59 :
60 0 : struct UpperBounds {
61 0 : using type = std::array<double, 2>;
62 0 : static constexpr Options::String help = {
63 : "Upper bound in the [x,y] dimensions."};
64 : };
65 :
66 0 : struct InitialRefinement {
67 0 : using type = std::array<size_t, 2>;
68 0 : static constexpr Options::String help = {
69 : "Initial refinement level for the [x,y] dimensions."};
70 : };
71 :
72 0 : struct InitialGridPoints {
73 0 : using type = std::array<size_t, 2>;
74 0 : static constexpr Options::String help = {
75 : "Initial number of grid points in the [x,y] dimensions."};
76 : };
77 :
78 0 : struct Distributions {
79 0 : using type = std::array<CoordinateMaps::Distribution, 2>;
80 0 : static constexpr Options::String help = {
81 : "Distribution of grid points in the [x,y] dimensions."};
82 : };
83 :
84 : template <typename BoundaryConditionsBase>
85 0 : struct LowerUpperBoundaryCondition {
86 0 : static constexpr Options::String help =
87 : "Lower and upper Boundary Conditions";
88 0 : struct LowerBC {
89 0 : using type = std::unique_ptr<BoundaryConditionsBase>;
90 0 : static constexpr Options::String help = "Lower Boundary Condition";
91 0 : static std::string name() { return "Lower"; };
92 : };
93 0 : struct UpperBC {
94 0 : using type = std::unique_ptr<BoundaryConditionsBase>;
95 0 : static constexpr Options::String help = "Upper Boundary Condition";
96 0 : static std::string name() { return "Upper"; };
97 : };
98 0 : LowerUpperBoundaryCondition(typename LowerBC::type lower_bc,
99 : typename UpperBC::type upper_bc)
100 : : lower(std::move(lower_bc)), upper(std::move(upper_bc)){};
101 0 : LowerUpperBoundaryCondition() = default;
102 0 : std::unique_ptr<BoundaryConditionsBase> lower;
103 0 : std::unique_ptr<BoundaryConditionsBase> upper;
104 0 : using options = tmpl::list<LowerBC, UpperBC>;
105 : };
106 :
107 : template <typename BoundaryConditionsBase>
108 0 : struct BoundaryConditions {
109 0 : static constexpr Options::String help = {
110 : "The boundary conditions to be imposed in the x & y dimensions. "
111 : "Either specify one B.C. to be imposed for both "
112 : "lower and upper boundary or a pair 'Lower:' and 'Upper:'."};
113 0 : using type = std::array<
114 : std::variant<std::unique_ptr<BoundaryConditionsBase>,
115 : LowerUpperBoundaryCondition<BoundaryConditionsBase>>,
116 : 2>;
117 : };
118 :
119 0 : struct TimeDependence {
120 0 : using type =
121 : std::unique_ptr<domain::creators::time_dependence::TimeDependence<3>>;
122 0 : static constexpr Options::String help = {
123 : "The time dependence of the moving mesh domain. Specify `None` for no "
124 : "time dependant maps."};
125 : };
126 :
127 0 : using basic_options =
128 : tmpl::list<LowerBounds, UpperBounds, InitialRefinement, InitialGridPoints,
129 : Distributions, TimeDependence>;
130 :
131 : template <typename Metavariables>
132 0 : using options = tmpl::conditional_t<
133 : domain::BoundaryConditions::has_boundary_conditions_base_v<
134 : typename Metavariables::system>,
135 : tmpl::push_back<
136 : basic_options,
137 : BoundaryConditions<
138 : domain::BoundaryConditions::get_boundary_conditions_base<
139 : typename Metavariables::system>>>,
140 : basic_options>;
141 :
142 0 : static constexpr Options::String help{
143 : "A cylinder domain that requires/enforces axial symmetry. The "
144 : "computational domain is the x-y plane, with Cartoon partial derivatives "
145 : "being used for the z direction. Elements touching the x=0 axis use "
146 : "ZernikeB1 bases in the x direction and automatically apply a system's "
147 : "Cartoon-type boundary condition."};
148 :
149 0 : CartoonCylinder(
150 : std::array<double, 2> lower_bounds, std::array<double, 2> upper_bounds,
151 : std::array<size_t, 2> initial_refinement_levels,
152 : std::array<size_t, 2> initial_num_points,
153 : std::array<CoordinateMaps::Distribution, 2> distributions = {},
154 : std::unique_ptr<domain::creators::time_dependence::TimeDependence<3>>
155 : time_dependence = nullptr,
156 : std::array<std::array<std::unique_ptr<
157 : domain::BoundaryConditions::BoundaryCondition>,
158 : 2>,
159 : 2>
160 : boundary_conditions = {},
161 : std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>
162 : cartoon_boundary_condition = nullptr,
163 : const Options::Context& context = {});
164 :
165 0 : CartoonCylinder() = default;
166 0 : CartoonCylinder(const CartoonCylinder&) = delete;
167 0 : CartoonCylinder(CartoonCylinder&&) = default;
168 0 : CartoonCylinder& operator=(const CartoonCylinder&) = delete;
169 0 : CartoonCylinder& operator=(CartoonCylinder&&) = default;
170 0 : ~CartoonCylinder() override = default;
171 :
172 0 : Domain<3> create_domain() const override;
173 :
174 : std::vector<DirectionMap<
175 : 3, std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>>>
176 1 : external_boundary_conditions() const override;
177 :
178 1 : std::vector<std::array<size_t, 3>> initial_extents() const override;
179 :
180 1 : std::vector<std::array<size_t, 3>> initial_refinement_levels() const override;
181 :
182 : /// The only block is Block0
183 1 : std::vector<std::string> block_names() const override;
184 :
185 : /// The only group is CartoonCylinder
186 : std::unordered_map<std::string, std::unordered_set<std::string>>
187 1 : block_groups() const override;
188 :
189 1 : auto functions_of_time(const std::unordered_map<std::string, double>&
190 : initial_expiration_times = {}) const
191 : -> std::unordered_map<
192 : std::string,
193 : std::unique_ptr<domain::FunctionsOfTime::FunctionOfTime>> override;
194 :
195 : // Transforms from option-created boundary conditions to the type used in the
196 : // constructor
197 : template <typename BoundaryConditionsBase>
198 0 : static auto transform_boundary_conditions(
199 : std::array<
200 : std::variant<std::unique_ptr<BoundaryConditionsBase>,
201 : LowerUpperBoundaryCondition<BoundaryConditionsBase>>,
202 : 2>
203 : boundary_conditions)
204 : -> std::array<
205 : std::array<
206 : std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>,
207 : 2>,
208 : 2>;
209 :
210 : private:
211 0 : std::array<double, 2> lower_bounds_{};
212 0 : std::array<double, 2> upper_bounds_{};
213 0 : std::array<size_t, 2> initial_refinement_levels_{};
214 0 : std::array<size_t, 2> initial_num_points_{};
215 0 : bool is_periodic_in_y_{};
216 0 : std::array<CoordinateMaps::Distribution, 2> distributions_{};
217 0 : bool using_zernike_{};
218 : std::array<
219 : std::array<std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>,
220 : 2>,
221 : 2>
222 0 : boundary_conditions_{};
223 : std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>
224 0 : cartoon_boundary_condition_{};
225 : std::unique_ptr<domain::creators::time_dependence::TimeDependence<3>>
226 0 : time_dependence_;
227 0 : size_t num_blocks_{};
228 0 : std::vector<std::string> block_names_{};
229 : std::unordered_map<std::string, std::unordered_set<std::string>>
230 0 : block_groups_{};
231 : };
232 :
233 : template <typename BoundaryConditionsBase>
234 : auto CartoonCylinder::transform_boundary_conditions(
235 : std::array<
236 : std::variant<std::unique_ptr<BoundaryConditionsBase>,
237 : LowerUpperBoundaryCondition<BoundaryConditionsBase>>,
238 : 2>
239 : boundary_conditions)
240 : -> std::array<
241 : std::array<
242 : std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>, 2>,
243 : 2> {
244 : std::array<
245 : std::array<std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>,
246 : 2>,
247 : 2>
248 : result{};
249 : for (size_t d = 0; d < 2; ++d) {
250 : if (std::holds_alternative<std::unique_ptr<BoundaryConditionsBase>>(
251 : boundary_conditions[d])) {
252 : auto bc = std::move(std::get<std::unique_ptr<BoundaryConditionsBase>>(
253 : boundary_conditions[d]));
254 : gsl::at(gsl::at(result, d), 0) = bc->get_clone();
255 : gsl::at(gsl::at(result, d), 1) = std::move(bc);
256 : } else {
257 : auto& bc = std::get<LowerUpperBoundaryCondition<BoundaryConditionsBase>>(
258 : boundary_conditions[d]);
259 : gsl::at(gsl::at(result, d), 0) = std::move(bc.lower);
260 : gsl::at(gsl::at(result, d), 1) = std::move(bc.upper);
261 : }
262 : }
263 : return result;
264 : }
265 :
266 : } // namespace domain::creators
267 :
268 : namespace domain::creators::detail {
269 : /// \brief Helper struct for CartoonCylinder options parsing so the internal
270 : /// cartoon boundary condition at $x = 0$ is not a required argument.
271 : ///
272 : /// \details To get the cartoon-type boundary condition from a system we need
273 : /// access to the system's metavariables, which is only present when parsing
274 : /// options. The point of this design is so that the input file does not
275 : /// require a dummy value for an InnerBoundaryCondition that is always the
276 : /// same for a given system.
277 : ///
278 : /// This helper's constructor does not take an InnerBoundaryCondition, which
279 : /// means if we parse a CartoonCylinder as a CartonSphere2DOptionsHelper
280 : /// by having an options parsing specialization (so the input file values are
281 : /// the helper's construtor, not CartoonCylinder's), we can detect the
282 : /// cartoon-type boundary condition for the given system and only then call
283 : /// the CartoonCylinder constructor with the extra information.
284 : struct CartoonCylinderOptionsHelper {
285 : template <typename Metavariables>
286 : using options = typename domain::creators::CartoonCylinder::template options<
287 : Metavariables>;
288 :
289 : template <typename BoundaryConditionsBase>
290 : using LowerUpperBoundaryCondition =
291 : domain::creators::CartoonCylinder::LowerUpperBoundaryCondition<
292 : BoundaryConditionsBase>;
293 :
294 : static constexpr Options::String help = {"CartoonCylinderOptionsHelper"};
295 :
296 : // Default constructor required by Options system
297 : CartoonCylinderOptionsHelper() = default;
298 :
299 : // Does not take cartoon BC
300 : CartoonCylinderOptionsHelper(
301 : std::array<double, 2> lower_bounds, std::array<double, 2> upper_bounds,
302 : std::array<size_t, 2> initial_refinement_levels,
303 : std::array<size_t, 2> initial_num_points,
304 : std::array<CoordinateMaps::Distribution, 2> distributions,
305 : std::unique_ptr<domain::creators::time_dependence::TimeDependence<3>>
306 : time_dependence = nullptr,
307 : std::array<std::array<std::unique_ptr<
308 : domain::BoundaryConditions::BoundaryCondition>,
309 : 2>,
310 : 2>
311 : boundary_conditions = {},
312 : Options::Context context = {});
313 :
314 : template <typename BoundaryConditionsBase>
315 : CartoonCylinderOptionsHelper(
316 : std::array<double, 2> lower_bounds, std::array<double, 2> upper_bounds,
317 : std::array<size_t, 2> initial_refinement_levels,
318 : std::array<size_t, 2> initial_num_points,
319 : std::array<CoordinateMaps::Distribution, 2> distributions,
320 : std::unique_ptr<domain::creators::time_dependence::TimeDependence<3>>
321 : time_dependence = nullptr,
322 : std::array<
323 : std::variant<std::unique_ptr<BoundaryConditionsBase>,
324 : LowerUpperBoundaryCondition<BoundaryConditionsBase>>,
325 : 2>
326 : boundary_conditions = {},
327 : Options::Context context = {})
328 : : CartoonCylinderOptionsHelper(
329 : std::move(lower_bounds), std::move(upper_bounds),
330 : std::move(initial_refinement_levels), std::move(initial_num_points),
331 : std::move(distributions), std::move(time_dependence),
332 : domain::creators::CartoonCylinder::transform_boundary_conditions(
333 : std::move(boundary_conditions)),
334 : std::move(context)) {}
335 : // Same members as in CartoonCylinder; public, to be extracted
336 : std::array<double, 2> lower_bounds_{};
337 : std::array<double, 2> upper_bounds_{};
338 : std::array<size_t, 2> initial_refinement_levels_{};
339 : std::array<size_t, 2> initial_num_points_{};
340 : std::array<CoordinateMaps::Distribution, 2> distributions_{};
341 : std::unique_ptr<domain::creators::time_dependence::TimeDependence<3>>
342 : time_dependence_{nullptr};
343 : std::array<
344 : std::array<std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>,
345 : 2>,
346 : 2>
347 : boundary_conditions_{};
348 : Options::Context context_{};
349 : };
350 : } // namespace domain::creators::detail
351 :
352 : // Options parsing specialization to automate CartoonCylinder's cartoon
353 : // boundary condition
354 : template <>
355 0 : struct Options::create_from_yaml<domain::creators::CartoonCylinder> {
356 : template <typename Metavariables>
357 0 : static domain::creators::CartoonCylinder create(
358 : const Options::Option& options) {
359 : auto helper =
360 : options.parse_as<domain::creators::detail::CartoonCylinderOptionsHelper,
361 : Metavariables>();
362 :
363 : // Create cartoon BC if system supports it, if not will throw parse error in
364 : // real constructor
365 : std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>
366 : cartoon_boundary_condition = nullptr;
367 : if constexpr (domain::BoundaryConditions::has_boundary_conditions_base_v<
368 : typename Metavariables::system>) {
369 : if constexpr (domain::BoundaryConditions::system_has_cartoon_bc_v<
370 : Metavariables>) {
371 : cartoon_boundary_condition =
372 : domain::BoundaryConditions::make_cartoon_boundary_condition<
373 : Metavariables>();
374 : }
375 : }
376 :
377 : // Construct CartoonCylinder using the helper's parsed data + cartoon BC
378 : return domain::creators::CartoonCylinder(
379 : helper.lower_bounds_, helper.upper_bounds_,
380 : helper.initial_refinement_levels_, helper.initial_num_points_,
381 : helper.distributions_, std::move(helper.time_dependence_),
382 : std::move(helper.boundary_conditions_),
383 : std::move(cartoon_boundary_condition), helper.context_);
384 : }
385 : };
|
