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 that is topologically a line. The 2nd and 3rd
40 : /// dimensions use Cartoon bases with Killing vectors along the \f$\theta\f$ and
41 : /// \f$\phi\f$ directions.
42 1 : class CartoonSphere1D : 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::Identity<1>,
48 : CoordinateMaps::Identity<1>>>>;
49 :
50 0 : static std::string name() { return "CartoonSphere1D"; }
51 :
52 0 : struct InnerRadius {
53 0 : using type = double;
54 0 : static constexpr Options::String help = {
55 : "Inner radius of domain, greater than or equal to 0. If the origin is "
56 : "included, the innermost element will use a 1D Zernike basis, "
57 : "otherwise the domain will be a spherical shell."};
58 : };
59 :
60 0 : struct OuterRadius {
61 0 : using type = double;
62 0 : static constexpr Options::String help = {"Outer radius of domain."};
63 : };
64 :
65 0 : struct InitialRadialRefinement {
66 0 : using type = std::variant<size_t, std::vector<size_t>>;
67 0 : static constexpr Options::String help = {
68 : "Initial refinement level for the radial direction. If one value is "
69 : "given, it will be applied to all blocks, or every block can be "
70 : "specified individually."};
71 : };
72 :
73 0 : struct InitialNumberOfRadialGridPoints {
74 0 : using type = std::variant<size_t, std::vector<size_t>>;
75 0 : static constexpr Options::String help = {
76 : "Initial number of radial grid points. If one input is given, it "
77 : "will be applied to all blocks, or every block can be specified "
78 : "individually."};
79 : };
80 :
81 0 : struct RadialPartitioning {
82 0 : using type = std::vector<double>;
83 0 : static constexpr Options::String help = {
84 : "Radial coordinates of the boundaries splitting the radial blocks, "
85 : "strictly between InnerRadius and OuterRadius. They must be given in "
86 : "ascending order."};
87 : };
88 :
89 0 : struct RadialDistributions {
90 0 : using type = std::variant<CoordinateMaps::Distribution,
91 : std::vector<CoordinateMaps::Distribution>>;
92 0 : static constexpr Options::String help = {
93 : "Distribution of grid points along the radial blocks. A single input "
94 : "will be applied to all blocks, or every block can be specified "
95 : "individually, in which case for N partitions, there must be N+1 "
96 : "distributions."};
97 : };
98 :
99 : template <typename BoundaryConditionsBase>
100 0 : struct InnerBoundaryCondition {
101 0 : static constexpr Options::String help =
102 : "Options for the boundary conditions at the inner boundary.";
103 0 : using type = std::unique_ptr<BoundaryConditionsBase>;
104 : };
105 :
106 : template <typename BoundaryConditionsBase>
107 0 : struct OuterBoundaryCondition {
108 0 : static constexpr Options::String help =
109 : "Options for the boundary conditions at the outer boundary.";
110 0 : using type = std::unique_ptr<BoundaryConditionsBase>;
111 : };
112 :
113 : template <typename BoundaryConditionsBase>
114 0 : struct CartoonBoundaryCondition {
115 0 : static constexpr Options::String help =
116 : "Cartoon boundary condition will be automatically applied to "
117 : "internal cartoon boundaries. No user options needed.";
118 0 : using type = std::nullptr_t;
119 0 : static std::string name() { return "CartoonBC"; }
120 : };
121 :
122 0 : struct TimeDependence {
123 0 : using type =
124 : std::unique_ptr<domain::creators::time_dependence::TimeDependence<3>>;
125 0 : static constexpr Options::String help = {
126 : "The time dependence of the moving mesh domain. Specify `None` for no "
127 : "time dependant maps."};
128 : };
129 :
130 0 : using basic_options =
131 : tmpl::list<InnerRadius, OuterRadius, InitialRadialRefinement,
132 : InitialNumberOfRadialGridPoints, RadialPartitioning,
133 : RadialDistributions, TimeDependence>;
134 :
135 : template <typename Metavariables>
136 0 : using options = tmpl::conditional_t<
137 : domain::BoundaryConditions::has_boundary_conditions_base_v<
138 : typename Metavariables::system>,
139 : tmpl::push_back<
140 : basic_options,
141 : InnerBoundaryCondition<
142 : domain::BoundaryConditions::get_boundary_conditions_base<
143 : typename Metavariables::system>>,
144 : OuterBoundaryCondition<
145 : domain::BoundaryConditions::get_boundary_conditions_base<
146 : typename Metavariables::system>>>,
147 : basic_options>;
148 :
149 0 : static constexpr Options::String help{
150 : "A sphere domain that requires/enforces spherical symmetry, resulting in "
151 : "a 1D computational domain (the radial axis). It uses Cartoon partial "
152 : "derivatives for the angular directions not in the computational "
153 : "domain. If an element touches the x=0 axis, it uses ZernikeB1 bases and "
154 : "automatically applies a system's Cartoon-type boundary condition."};
155 :
156 0 : CartoonSphere1D(
157 : double inner_bound, double outer_bound,
158 : typename InitialRadialRefinement::type&& initial_refinement_levels,
159 : typename InitialNumberOfRadialGridPoints::type&& initial_num_points,
160 : std::vector<double> radial_partitioning = {},
161 : const typename RadialDistributions::type& radial_distributions =
162 : domain::CoordinateMaps::Distribution::Linear,
163 : std::unique_ptr<domain::creators::time_dependence::TimeDependence<3>>
164 : time_dependence = nullptr,
165 : std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>
166 : inner_boundary_condition = nullptr,
167 : std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>
168 : outer_boundary_condition = nullptr,
169 : std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>
170 : cartoon_boundary_condition = nullptr,
171 : const Options::Context& context = {});
172 :
173 0 : CartoonSphere1D() = default;
174 0 : CartoonSphere1D(const CartoonSphere1D&) = delete;
175 0 : CartoonSphere1D(CartoonSphere1D&&) = default;
176 0 : CartoonSphere1D& operator=(const CartoonSphere1D&) = delete;
177 0 : CartoonSphere1D& operator=(CartoonSphere1D&&) = default;
178 0 : ~CartoonSphere1D() override = default;
179 :
180 0 : Domain<3> create_domain() const override;
181 :
182 : std::vector<DirectionMap<
183 : 3, std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>>>
184 1 : external_boundary_conditions() const override;
185 :
186 1 : std::vector<std::array<size_t, 3>> initial_extents() const override;
187 :
188 1 : std::vector<std::array<size_t, 3>> initial_refinement_levels() const override;
189 :
190 : // The block names are Block0, Block1, ..., starting with the innermost
191 : // Block.
192 1 : std::vector<std::string> block_names() const override;
193 :
194 : // The only block group is PositiveBlocks
195 : std::unordered_map<std::string, std::unordered_set<std::string>>
196 1 : block_groups() const override;
197 :
198 1 : auto functions_of_time(const std::unordered_map<std::string, double>&
199 : initial_expiration_times = {}) const
200 : -> std::unordered_map<
201 : std::string,
202 : std::unique_ptr<domain::FunctionsOfTime::FunctionOfTime>> override;
203 :
204 : private:
205 0 : double inner_bound_{};
206 0 : double outer_bound_{};
207 0 : std::vector<size_t> initial_refinement_levels_{};
208 0 : std::vector<size_t> initial_num_points_{};
209 0 : std::vector<double> radial_partitioning_{};
210 0 : std::vector<CoordinateMaps::Distribution> radial_distributions_{};
211 0 : bool use_zernike_{};
212 : std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>
213 0 : inner_boundary_condition_{};
214 : std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>
215 0 : outer_boundary_condition_{};
216 : std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>
217 0 : cartoon_boundary_condition_{};
218 : std::unique_ptr<domain::creators::time_dependence::TimeDependence<3>>
219 0 : time_dependence_;
220 0 : size_t num_blocks_{};
221 0 : std::vector<std::string> block_names_{};
222 : std::unordered_map<std::string, std::unordered_set<std::string>>
223 0 : block_groups_{};
224 : };
225 :
226 : } // namespace domain::creators
227 :
228 : namespace domain::creators::detail {
229 : /// \brief Helper struct for CartoonSphere1D options parsing so the internal
230 : /// cartoon boundary condition at $x = 0$ is not a required argument.
231 : ///
232 : /// \details To get the cartoon-type boundary condition from a system we need
233 : /// access to the system's metavariables, which is only present when parsing
234 : /// options. The point of this design is so that the input file does not require
235 : /// a dummy value for an InnerBoundaryCondition that is always the same for a
236 : /// given system.
237 : ///
238 : /// This helper's constructor does not take an InnerBoundaryCondition, which
239 : /// means if we parse a CartoonSphere1D as a CartonSphere1DOptionsHelper
240 : /// by having an options parsing specialization (so the input file values are
241 : /// the helper's construtor, not CartoonSphere1D's), we can detect the
242 : /// cartoon-type boundary condition for the given system and only then call the
243 : /// CartoonSphere1D constructor with the extra information.
244 : struct CartoonSphere1DOptionsHelper {
245 : // Inherit the options template from CartoonSphere1D
246 : template <typename Metavariables>
247 : using options = typename domain::creators::CartoonSphere1D::template options<
248 : Metavariables>;
249 :
250 : using InitialRadialRefinement =
251 : domain::creators::CartoonSphere1D::InitialRadialRefinement;
252 : using InitialNumberOfRadialGridPoints =
253 : domain::creators::CartoonSphere1D::InitialNumberOfRadialGridPoints;
254 : using RadialDistributions =
255 : domain::creators::CartoonSphere1D::RadialDistributions;
256 :
257 : static constexpr Options::String help = {"CartoonSphere1DOptionsHelper"};
258 :
259 : // Default constructor required by Options system
260 : CartoonSphere1DOptionsHelper() = default;
261 :
262 : // Does not take cartoon BC
263 : CartoonSphere1DOptionsHelper(
264 : double inner_bound, double outer_bound,
265 : typename InitialRadialRefinement::type&& initial_refinement_levels,
266 : typename InitialNumberOfRadialGridPoints::type&& initial_num_points,
267 : std::vector<double> radial_partitioning = {},
268 : typename RadialDistributions::type&& radial_distributions =
269 : domain::CoordinateMaps::Distribution::Linear,
270 : std::unique_ptr<domain::creators::time_dependence::TimeDependence<3>>
271 : time_dependence = nullptr,
272 : std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>
273 : inner_boundary_condition = nullptr,
274 : std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>
275 : outer_boundary_condition = nullptr,
276 : Options::Context&& context = {});
277 :
278 : // Same members as in CartoonSphere1D; public, to be extracted
279 : double inner_bound_{std::numeric_limits<double>::signaling_NaN()};
280 : double outer_bound_{std::numeric_limits<double>::signaling_NaN()};
281 : typename domain::creators::CartoonSphere1D::InitialRadialRefinement::type
282 : initial_refinement_levels_{};
283 : typename domain::creators::CartoonSphere1D::InitialNumberOfRadialGridPoints::
284 : type initial_num_points_{};
285 : std::vector<double> radial_partitioning_{};
286 : domain::creators::CartoonSphere1D::RadialDistributions::type
287 : radial_distributions_{domain::CoordinateMaps::Distribution::Linear};
288 : std::unique_ptr<domain::creators::time_dependence::TimeDependence<3>>
289 : time_dependence_{nullptr};
290 : std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>
291 : inner_boundary_condition_{nullptr};
292 : std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>
293 : outer_boundary_condition_{nullptr};
294 : std::nullptr_t cartoon_boundary_condition_{
295 : nullptr}; // For CartoonBoundaryCondition option
296 : Options::Context context_{};
297 : };
298 : } // namespace domain::creators::detail
299 :
300 : // Options parsing specialization to automate CartoonSphere1D's cartoon
301 : // boundary condition
302 : template <>
303 0 : struct Options::create_from_yaml<domain::creators::CartoonSphere1D> {
304 : template <typename Metavariables>
305 0 : static domain::creators::CartoonSphere1D create(
306 : const Options::Option& options) {
307 : auto helper =
308 : options.parse_as<domain::creators::detail::CartoonSphere1DOptionsHelper,
309 : Metavariables>();
310 :
311 : // Create cartoon BC if system supports it, if not will throw parse error in
312 : // real constructor
313 : std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>
314 : cartoon_boundary_condition = nullptr;
315 : if constexpr (domain::BoundaryConditions::has_boundary_conditions_base_v<
316 : typename Metavariables::system>) {
317 : if constexpr (domain::BoundaryConditions::system_has_cartoon_bc_v<
318 : Metavariables>) {
319 : cartoon_boundary_condition =
320 : domain::BoundaryConditions::make_cartoon_boundary_condition<
321 : Metavariables>();
322 : }
323 : }
324 :
325 : // Construct CartoonSphere1D using the helper's parsed data + cartoon BC
326 : return domain::creators::CartoonSphere1D(
327 : helper.inner_bound_, helper.outer_bound_,
328 : std::move(helper.initial_refinement_levels_),
329 : std::move(helper.initial_num_points_),
330 : std::move(helper.radial_partitioning_), helper.radial_distributions_,
331 : std::move(helper.time_dependence_),
332 : std::move(helper.inner_boundary_condition_),
333 : std::move(helper.outer_boundary_condition_),
334 : std::move(cartoon_boundary_condition), helper.context_);
335 : }
336 : };
|
