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 <iosfwd>
9 : #include <limits>
10 : #include <memory>
11 : #include <vector>
12 :
13 : #include "DataStructures/Index.hpp"
14 : #include "Domain/BoundaryConditions/BoundaryCondition.hpp"
15 : #include "Domain/BoundaryConditions/GetBoundaryConditionsBase.hpp"
16 : #include "Domain/Creators/DomainCreator.hpp"
17 : #include "Domain/Creators/Rectilinear.hpp"
18 : #include "Domain/Domain.hpp"
19 : #include "Domain/Structure/DirectionMap.hpp"
20 : #include "Options/Context.hpp"
21 : #include "Options/String.hpp"
22 : #include "Utilities/MakeArray.hpp"
23 : #include "Utilities/TMPL.hpp"
24 :
25 : /// \cond
26 : namespace domain {
27 : namespace CoordinateMaps {
28 : class Interval;
29 : template <typename Map1, typename Map2>
30 : class ProductOf2Maps;
31 : template <typename Map1, typename Map2, typename Map3>
32 : class ProductOf3Maps;
33 : } // namespace CoordinateMaps
34 :
35 : template <typename SourceFrame, typename TargetFrame, typename... Maps>
36 : class CoordinateMap;
37 : } // namespace domain
38 : /// \endcond
39 :
40 : namespace domain {
41 1 : namespace creators {
42 :
43 : template <size_t Dim>
44 0 : struct RefinementRegion {
45 0 : std::array<size_t, Dim> lower_corner_index;
46 0 : std::array<size_t, Dim> upper_corner_index;
47 0 : std::array<size_t, Dim> refinement;
48 :
49 0 : struct LowerCornerIndex {
50 0 : using type = std::array<size_t, Dim>;
51 0 : static constexpr Options::String help = {"Lower bound of refined region."};
52 : };
53 :
54 0 : struct UpperCornerIndex {
55 0 : using type = std::array<size_t, Dim>;
56 0 : static constexpr Options::String help = {"Upper bound of refined region."};
57 : };
58 :
59 0 : struct Refinement {
60 0 : using type = std::array<size_t, Dim>;
61 0 : static constexpr Options::String help = {"Refinement inside region."};
62 : };
63 :
64 0 : static constexpr Options::String help = {
65 : "A region to be refined differently from the default for the lattice.\n"
66 : "The region is a box between the block boundaries indexed by the\n"
67 : "Lower- and UpperCornerIndex options."};
68 0 : using options = tmpl::list<LowerCornerIndex, UpperCornerIndex, Refinement>;
69 0 : RefinementRegion(const std::array<size_t, Dim>& lower_corner_index_in,
70 : const std::array<size_t, Dim>& upper_corner_index_in,
71 : const std::array<size_t, Dim>& refinement_in)
72 : : lower_corner_index(lower_corner_index_in),
73 : upper_corner_index(upper_corner_index_in),
74 : refinement(refinement_in) {}
75 0 : RefinementRegion() = default;
76 : };
77 :
78 : /// \cond
79 : // This is needed to print the default value for the RefinedGridPoints
80 : // option. Since the default value is an empty vector, this function
81 : // is never actually called.
82 : template <size_t Dim>
83 : [[noreturn]] std::ostream& operator<<(std::ostream& /*s*/,
84 : const RefinementRegion<Dim>& /*unused*/);
85 : /// \endcond
86 :
87 : /// \brief Create a Domain consisting of multiple aligned Blocks arrayed in a
88 : /// lattice.
89 : ///
90 : /// This is useful for setting up problems with piecewise smooth initial data,
91 : /// problems that specify different boundary conditions on distinct parts of
92 : /// the boundary, or problems that need different length scales initially.
93 : ///
94 : /// \note Adaptive mesh refinement can never join Block%s, so use the fewest
95 : /// number of Block%s that your problem needs. More initial Element%s can be
96 : /// created by specifying a larger `InitialRefinement`.
97 : template <size_t Dim>
98 1 : class AlignedLattice : public DomainCreator<Dim> {
99 : public:
100 0 : using maps_list =
101 : tmpl::list<domain::CoordinateMap<Frame::BlockLogical, Frame::Inertial,
102 : CoordinateMaps::Interval>,
103 : domain::CoordinateMap<
104 : Frame::BlockLogical, Frame::Inertial,
105 : CoordinateMaps::ProductOf2Maps<CoordinateMaps::Interval,
106 : CoordinateMaps::Interval>>,
107 : domain::CoordinateMap<
108 : Frame::BlockLogical, Frame::Inertial,
109 : CoordinateMaps::ProductOf3Maps<CoordinateMaps::Interval,
110 : CoordinateMaps::Interval,
111 : CoordinateMaps::Interval>>>;
112 :
113 0 : struct BlockBounds {
114 0 : using type = std::array<std::vector<double>, Dim>;
115 0 : static constexpr Options::String help = {
116 : "Coordinates of block boundaries in each dimension."};
117 : };
118 :
119 0 : struct Distributions {
120 0 : using type =
121 : std::array<std::vector<domain::CoordinateMaps::Distribution>, Dim>;
122 0 : static constexpr Options::String help = {
123 : "Grid point distribution in each dimension."};
124 : };
125 :
126 0 : struct SingularityPositions {
127 0 : using type = std::array<std::vector<double>, Dim>;
128 0 : static constexpr Options::String help = {
129 : "Singularity positions in each dimension."};
130 : };
131 :
132 0 : struct IsPeriodicIn {
133 0 : using type = std::array<bool, Dim>;
134 0 : static constexpr Options::String help = {
135 : "Whether the domain is periodic in each dimension."};
136 : };
137 :
138 0 : struct InitialLevels {
139 0 : using type = std::array<size_t, Dim>;
140 0 : static constexpr Options::String help = {
141 : "Initial refinement level in each dimension."};
142 : };
143 :
144 0 : struct InitialGridPoints {
145 0 : using type = std::array<size_t, Dim>;
146 0 : static constexpr Options::String help = {
147 : "Initial number of grid points in each dimension."};
148 : };
149 :
150 0 : struct RefinedLevels {
151 0 : using type = std::vector<RefinementRegion<Dim>>;
152 0 : static constexpr Options::String help = {
153 : "h-refined regions. Later entries take priority."};
154 : };
155 :
156 0 : struct RefinedGridPoints {
157 0 : using type = std::vector<RefinementRegion<Dim>>;
158 0 : static constexpr Options::String help = {
159 : "p-refined regions. Later entries take priority."};
160 : };
161 :
162 0 : struct BlocksToExclude {
163 0 : using type = std::vector<std::array<size_t, Dim>>;
164 0 : static constexpr Options::String help = {
165 : "List of Block indices to exclude, if any."};
166 : };
167 :
168 : template <typename Metavariables>
169 0 : using options = tmpl::list<
170 : BlockBounds, Distributions, SingularityPositions, InitialLevels,
171 : InitialGridPoints, RefinedLevels, RefinedGridPoints, BlocksToExclude,
172 : tmpl::conditional_t<
173 : domain::BoundaryConditions::has_boundary_conditions_base_v<
174 : typename Metavariables::system>,
175 : typename Rectilinear<Dim>::template BoundaryConditions<
176 : domain::BoundaryConditions::get_boundary_conditions_base<
177 : typename Metavariables::system>>,
178 : IsPeriodicIn>>;
179 :
180 0 : static constexpr Options::String help = {
181 : "AlignedLattice creates a regular lattice of blocks whose corners are\n"
182 : "given by tensor products of the specified BlockBounds. Each Block in\n"
183 : "the lattice is identified by a Dim-tuple of zero-based indices\n"
184 : "Supplying a list of these tuples to BlocksToExclude will result in\n"
185 : "the domain having the corresponding Blocks excluded. See the Domain\n"
186 : "Creation tutorial in the documentation for more information on Block\n"
187 : "numberings in rectilinear domains. Note that if any Blocks are\n"
188 : "excluded, setting the option IsPeriodicIn to `true` in any dimension\n"
189 : "will trigger an error, as periodic boundary\n"
190 : "conditions for this domain with holes is not supported."};
191 :
192 0 : AlignedLattice(
193 : std::array<std::vector<double>, Dim> block_bounds,
194 : std::array<std::vector<domain::CoordinateMaps::Distribution>, Dim>
195 : distributions,
196 : std::array<std::vector<double>, Dim> singularity_positions,
197 : std::array<size_t, Dim> initial_refinement_levels,
198 : std::array<size_t, Dim> initial_number_of_grid_points,
199 : std::vector<RefinementRegion<Dim>> refined_refinement,
200 : std::vector<RefinementRegion<Dim>> refined_grid_points,
201 : std::vector<std::array<size_t, Dim>> blocks_to_exclude,
202 : std::array<bool, Dim> is_periodic_in = make_array<Dim>(false),
203 : const Options::Context& context = {});
204 :
205 0 : AlignedLattice(
206 : std::array<std::vector<double>, Dim> block_bounds,
207 : std::array<std::vector<domain::CoordinateMaps::Distribution>, Dim>
208 : distributions,
209 : std::array<std::vector<double>, Dim> singularity_positions,
210 : std::array<size_t, Dim> initial_refinement_levels,
211 : std::array<size_t, Dim> initial_number_of_grid_points,
212 : std::vector<RefinementRegion<Dim>> refined_refinement,
213 : std::vector<RefinementRegion<Dim>> refined_grid_points,
214 : std::vector<std::array<size_t, Dim>> blocks_to_exclude,
215 : std::array<std::array<std::unique_ptr<
216 : domain::BoundaryConditions::BoundaryCondition>,
217 : 2>,
218 : Dim>
219 : boundary_conditions,
220 : const Options::Context& context = {});
221 :
222 : template <typename BoundaryConditionsBase>
223 0 : AlignedLattice(
224 : std::array<std::vector<double>, Dim> block_bounds,
225 : std::array<std::vector<domain::CoordinateMaps::Distribution>, Dim>
226 : distributions,
227 : std::array<std::vector<double>, Dim> singularity_positions,
228 : std::array<size_t, Dim> initial_refinement_levels,
229 : std::array<size_t, Dim> initial_number_of_grid_points,
230 : std::vector<RefinementRegion<Dim>> refined_refinement,
231 : std::vector<RefinementRegion<Dim>> refined_grid_points,
232 : std::vector<std::array<size_t, Dim>> blocks_to_exclude,
233 : std::array<std::variant<std::unique_ptr<BoundaryConditionsBase>,
234 : typename Rectilinear<Dim>::
235 : template LowerUpperBoundaryCondition<
236 : BoundaryConditionsBase>>,
237 : Dim>
238 : boundary_conditions,
239 : const Options::Context& context = {})
240 : : AlignedLattice(std::move(block_bounds), std::move(distributions),
241 : std::move(singularity_positions),
242 : initial_refinement_levels, initial_number_of_grid_points,
243 : refined_refinement, refined_grid_points,
244 : blocks_to_exclude,
245 : Rectilinear<Dim>::transform_boundary_conditions(
246 : std::move(boundary_conditions)),
247 : context) {}
248 :
249 0 : AlignedLattice() = default;
250 0 : AlignedLattice(const AlignedLattice&) = delete;
251 0 : AlignedLattice(AlignedLattice&&) = default;
252 0 : AlignedLattice& operator=(const AlignedLattice&) = delete;
253 0 : AlignedLattice& operator=(AlignedLattice&&) = default;
254 0 : ~AlignedLattice() override = default;
255 :
256 0 : Domain<Dim> create_domain() const override;
257 :
258 : std::vector<DirectionMap<
259 : Dim, std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>>>
260 1 : external_boundary_conditions() const override;
261 :
262 1 : std::vector<std::string> block_names() const override;
263 :
264 1 : std::vector<std::array<size_t, Dim>> initial_extents() const override;
265 :
266 1 : std::vector<std::array<size_t, Dim>> initial_refinement_levels()
267 : const override;
268 :
269 : private:
270 0 : std::array<std::vector<double>, Dim> block_bounds_{
271 : make_array<Dim, std::vector<double>>({})};
272 : std::array<std::vector<domain::CoordinateMaps::Distribution>, Dim>
273 0 : distributions_{};
274 0 : std::array<std::vector<std::optional<double>>, Dim> singularity_positions_{};
275 0 : std::array<bool, Dim> is_periodic_in_{make_array<Dim>(false)};
276 0 : std::array<size_t, Dim> initial_refinement_levels_{
277 : make_array<Dim>(std::numeric_limits<size_t>::max())};
278 0 : std::array<size_t, Dim> initial_number_of_grid_points_{
279 : make_array<Dim>(std::numeric_limits<size_t>::max())};
280 0 : std::vector<RefinementRegion<Dim>> refined_refinement_{};
281 0 : std::vector<RefinementRegion<Dim>> refined_grid_points_{};
282 0 : std::vector<std::array<size_t, Dim>> blocks_to_exclude_{};
283 0 : Index<Dim> number_of_blocks_by_dim_{};
284 : std::array<
285 : std::array<std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>,
286 : 2>,
287 : Dim>
288 0 : boundary_conditions_{};
289 : };
290 : } // namespace creators
291 : } // namespace domain
|
