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 <vector>
8 :
9 : #include "Utilities/ErrorHandling/Assert.hpp"
10 : #include "Utilities/Gsl.hpp"
11 : #include "Utilities/TMPL.hpp"
12 :
13 : /// \cond
14 : template <size_t VolumeDim>
15 : class Mesh;
16 : template <size_t VolumeDim>
17 : class OrientationMap;
18 : template <size_t>
19 : class Index;
20 : template <typename TagsList>
21 : class Variables;
22 : /// \endcond
23 :
24 : /// \ingroup ComputationalDomainGroup
25 : /// \brief Orient a sliced Mesh to the logical frame of a neighbor element with
26 : /// the given orientation.
27 : template <size_t VolumeDim>
28 1 : Mesh<VolumeDim - 1> orient_mesh_on_slice(
29 : const Mesh<VolumeDim - 1>& mesh_on_slice, size_t sliced_dim,
30 : const OrientationMap<VolumeDim>& orientation_of_neighbor);
31 :
32 : /// @{
33 : /// \ingroup ComputationalDomainGroup
34 : /// \brief Orient a `DataVector`, `ComplexDataVector`, `std::vector<double>`, or
35 : /// `std::vector<std::complex<double>>` to the data-storage order of a neighbor
36 : /// element with the given orientation.
37 : ///
38 : /// The vector may represent more than one tensor component over the grid
39 : /// represented by `extents`.
40 : ///
41 : /// \warning The result is *not* resized and assumes to be of the correct size
42 : /// (`variables.size()`).
43 : ///
44 : /// In most cases the `Variables` version of `orient_variables` should be
45 : /// called. However, in some cases the tags and thus the type of the data being
46 : /// sent is determined at runtime. In these cases the `std::vector` version of
47 : /// `orient_variables` is useful. A concrete example of this is when hybridizing
48 : /// DG with finite difference methods, where sometimes the data sent is both the
49 : /// variables for reconstruction and the fluxes for either the DG or finite
50 : /// difference scheme, while at other points only one of these three is sent.
51 : template <typename VectorType, size_t VolumeDim>
52 1 : void orient_variables(gsl::not_null<VectorType*> result,
53 : const VectorType& variables,
54 : const Index<VolumeDim>& extents,
55 : const OrientationMap<VolumeDim>& orientation_of_neighbor);
56 :
57 : template <typename VectorType, size_t VolumeDim>
58 1 : VectorType orient_variables(
59 : const VectorType& variables, const Index<VolumeDim>& extents,
60 : const OrientationMap<VolumeDim>& orientation_of_neighbor);
61 :
62 : template <typename VectorType, size_t VolumeDim>
63 1 : void orient_variables_on_slice(
64 : gsl::not_null<VectorType*> result, const VectorType& variables_on_slice,
65 : const Index<VolumeDim - 1>& slice_extents, size_t sliced_dim,
66 : const OrientationMap<VolumeDim>& orientation_of_neighbor);
67 :
68 : template <typename VectorType, size_t VolumeDim>
69 1 : VectorType orient_variables_on_slice(
70 : const VectorType& variables_on_slice,
71 : const Index<VolumeDim - 1>& slice_extents, size_t sliced_dim,
72 : const OrientationMap<VolumeDim>& orientation_of_neighbor);
73 : /// @}
74 :
75 : /// @{
76 : /// \ingroup ComputationalDomainGroup
77 : /// Orient variables to the data-storage order of a neighbor element with
78 : /// the given orientation.
79 : template <size_t VolumeDim, typename TagsList>
80 1 : Variables<TagsList> orient_variables(
81 : const Variables<TagsList>& variables, const Index<VolumeDim>& extents,
82 : const OrientationMap<VolumeDim>& orientation_of_neighbor) {
83 : // Skip work (aside from a copy) if neighbor is aligned
84 : if (orientation_of_neighbor.is_aligned()) {
85 : return variables;
86 : }
87 :
88 : const size_t number_of_grid_points = extents.product();
89 : ASSERT(variables.number_of_grid_points() == number_of_grid_points,
90 : "Inconsistent `variables` and `extents`:\n"
91 : " variables.number_of_grid_points() = "
92 : << variables.number_of_grid_points()
93 : << "\n"
94 : " extents.product() = "
95 : << extents.product());
96 : Variables<TagsList> oriented_variables(number_of_grid_points);
97 : using VectorType = typename Variables<TagsList>::vector_type;
98 : using ValueType = typename Variables<TagsList>::value_type;
99 : VectorType result(oriented_variables.data(), oriented_variables.size());
100 : orient_variables(
101 : make_not_null(&result),
102 : // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
103 : VectorType(const_cast<ValueType*>(variables.data()), variables.size()),
104 : extents, orientation_of_neighbor);
105 : return oriented_variables;
106 : }
107 :
108 : template <size_t VolumeDim, typename TagsList>
109 1 : Variables<TagsList> orient_variables_on_slice(
110 : const Variables<TagsList>& variables_on_slice,
111 : const Index<VolumeDim - 1>& slice_extents, const size_t sliced_dim,
112 : const OrientationMap<VolumeDim>& orientation_of_neighbor) {
113 : // Skip work (aside from a copy) if neighbor slice is aligned
114 : if (orientation_of_neighbor.is_aligned()) {
115 : return variables_on_slice;
116 : }
117 :
118 : const size_t number_of_grid_points = slice_extents.product();
119 : ASSERT(variables_on_slice.number_of_grid_points() == number_of_grid_points,
120 : "Inconsistent `variables_on_slice` and `slice_extents`:\n"
121 : " variables_on_slice.number_of_grid_points() = "
122 : << variables_on_slice.number_of_grid_points()
123 : << "\n"
124 : " slice_extents.product() = "
125 : << slice_extents.product());
126 :
127 : Variables<TagsList> oriented_variables(number_of_grid_points);
128 : using VectorType = typename Variables<TagsList>::vector_type;
129 : using ValueType = typename Variables<TagsList>::value_type;
130 : VectorType result(oriented_variables.data(), oriented_variables.size());
131 : orient_variables_on_slice(
132 : make_not_null(&result),
133 : // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
134 : VectorType(const_cast<ValueType*>(variables_on_slice.data()),
135 : variables_on_slice.size()),
136 : slice_extents, sliced_dim, orientation_of_neighbor);
137 : return oriented_variables;
138 : }
139 : /// @}
|
