SimiLie
Loading...
Searching...
No Matches
multidomain.hpp
1// SPDX-FileCopyrightText: 2026 Baptiste Legouix
2// SPDX-License-Identifier: AGPL-3.0-or-later
3// AI-GENERATED
4
5#pragma once
6
7#include <memory>
8#include <stdexcept>
9#include <string>
10#include <type_traits>
11#include <utility>
12#include <vector>
13
14#include <similie/tensor/extrapolation_rules.hpp>
15
16#include "topology.hpp"
17
18namespace sil::multidomains {
19
23template <class ExecSpace>
25{
26 std::vector<ExecSpace> m_spaces;
27
28public:
29 DomainExecution(ExecSpace const& parent, std::size_t count)
30 {
31 if (count == 0)
32 throw std::invalid_argument("no physical execution domains");
33 parent.fence("multidomain input readiness");
34 m_spaces = Kokkos::Experimental::partition_space(parent, std::vector<int>(count, 1));
35 }
36 template <class Function>
37 void for_each(Function function) const
38 {
39 for (std::size_t id = 0; id < m_spaces.size(); ++id)
40 function(id, m_spaces[id]);
41 }
42 ExecSpace const& space(std::size_t id) const
43 {
44 return m_spaces.at(id);
45 }
46 void fence() const
47 {
48 for (ExecSpace const& space : m_spaces)
49 space.fence("multidomain phase complete");
50 }
51};
52
53enum class FieldRole { Primal, Flux, Geometry };
54
58template <class Field>
60{
61 using non_indices_domain_t = typename Field::non_indices_domain_t;
62 using discrete_domain_type = typename Field::discrete_domain_type;
63 using indices_domain_t = typename Field::indices_domain_t;
64 using memory_space = typename Field::memory_space;
65 Field const* field;
67 {
68 return field->non_indices_domain();
69 }
70 template <class Element, class Component>
71 KOKKOS_FUNCTION double mem(Element elem, Component component) const
72 {
73 return field->mem(elem, component);
74 }
75 template <class Element, class Component>
76 KOKKOS_FUNCTION std::size_t global_index(Element elem, Component component) const
77 {
78 return field->global_index(elem, component);
79 }
80};
81
82template <class Field, class Geometry, class Physics, class Flux = Field>
84{
85 using physics_type = Physics;
86 Field field;
88 Physics physics;
90};
91
92template <class Field, class Geometry, class Physics>
93auto domain_data(Field const& field, Geometry const& geometry, Physics physics)
94{
95 return DomainData<Field, Geometry, Physics> {field, geometry, physics, field};
96}
97template <class Field, class Geometry, class Physics, class Flux>
98auto domain_data(Field const& field, Geometry const& geometry, Physics physics, Flux const& flux)
99{
100 return DomainData<Field, Geometry, Physics, Flux> {field, geometry, physics, flux};
101}
102
109template <class Dimension, class Field>
111{
115 KOKKOS_FUNCTION bool is_interface() const
116 {
117 return interface;
118 }
119 KOKKOS_FUNCTION bool is_dirichlet() const
120 {
121 return !interface && boundary.is_dirichlet();
122 }
123 template <class Source, class Element>
124 KOKKOS_FUNCTION auto operator()(Source const& field, Element elem) const
125 {
126 return interface ? external(field, elem) : boundary(field, elem);
127 }
128 template <class Domain, class Element>
129 KOKKOS_FUNCTION auto value(Domain const& domain, Element elem) const
130 {
131 return interface ? external.value(domain, elem) : boundary.value(domain, elem);
132 }
133 KOKKOS_FUNCTION bool shared_boundary() const
134 {
135 return external.boundary_map.shared_boundary;
136 }
137};
138
149template <std::size_t N, class Data>
151{
152 template <class Field>
153 struct DomainViews
154 {
155 Kokkos::View<Field*, Kokkos::SharedSpace> values;
156 std::size_t constructed = 0;
157 DomainViews(std::string const& label, std::size_t count)
158 : values(Kokkos::view_alloc(Kokkos::WithoutInitializing, label), count)
159 {
160 }
161 ~DomainViews()
162 {
163 for (std::size_t id = 0; id < constructed; ++id)
164 std::destroy_at(values.data() + id);
165 }
166 };
167 Topology<N> m_topology;
168 std::vector<Data> m_data;
169 std::shared_ptr<DomainViews<decltype(Data::field)>> m_fields;
170 std::shared_ptr<DomainViews<decltype(Data::geometry)>> m_geometry;
171 std::shared_ptr<DomainViews<decltype(Data::flux)>> m_flux;
172
173 template <class Field, class Select>
174 auto make_views(std::string const& label, Select const& select) const
175 {
176 std::shared_ptr<DomainViews<Field>> views
177 = std::make_shared<DomainViews<Field>>(label, domain_count());
178 for (std::size_t id = 0; id < domain_count(); ++id) {
179 std::construct_at(views->values.data() + id, select(m_data[id]));
180 ++views->constructed;
181 }
182 return views;
183 }
184 template <FieldRole Role>
185 auto reference(std::size_t id) const
186 {
187 if constexpr (Role == FieldRole::Primal)
188 return DomainReference<decltype(Data::field)> {m_fields->values.data() + id};
189 else if constexpr (Role == FieldRole::Flux)
190 return DomainReference<decltype(Data::flux)> {m_flux->values.data() + id};
191 else
192 return DomainReference<decltype(Data::geometry)> {m_geometry->values.data() + id};
193 }
194
195 template <FieldRole Role, class Dimension, std::size_t Axis, bool Upper>
196 auto face_rule(std::size_t id, double jump_scale) const
197 {
198 constexpr tensor::BoundarySide side
199 = Upper ? tensor::BoundarySide::Upper : tensor::BoundarySide::Lower;
200 Connection const& edge = m_topology.connection({id, Axis, side});
201 bool const interface = edge.domain < m_data.size();
202 auto const donor = reference<Role>(interface ? edge.domain : id);
203 BoundaryRule boundary;
204 if (!interface) {
205 BoundaryDomain const& node = m_topology.boundary(edge.domain);
206 if constexpr (Role == FieldRole::Primal)
207 boundary = node.primal;
208 else if constexpr (Role == FieldRole::Flux)
209 boundary = node.flux;
210 else
211 boundary = node.geometry;
212 } else {
213 auto const source = field<Role>(id).non_indices_domain();
214 auto const target = field<Role>(edge.domain).non_indices_domain();
215 for (std::size_t tangent = 0; tangent < N; ++tangent)
216 if (tangent != Axis
217 && ddc::detail::array(source.extents())[tangent]
218 != ddc::detail::array(target.extents())[tangent])
219 throw std::invalid_argument("interface tangential extents must match");
220 }
221 return FaceRule<Dimension, std::remove_cvref_t<decltype(donor)>> {
222 {donor,
223 {side, edge.side, edge.shared_boundary},
224 Role == FieldRole::Primal ? jump_scale * edge.jump : 0.0,
225 Role == FieldRole::Geometry ? 1.0 : edge.orientation},
226 boundary,
227 interface};
228 }
229 template <FieldRole Role, std::size_t... Axis>
230 auto rules(std::size_t id, double scale, std::index_sequence<Axis...>) const
231 {
232 using Dimensions
233 = ddc::to_type_seq_t<typename decltype(field<Role>(id))::non_indices_domain_t>;
235 std::
236 pair {face_rule<
237 Role,
238 ddc::type_seq_element_t<Axis, Dimensions>,
239 Axis,
240 false>(id, scale),
241 face_rule<
242 Role,
243 ddc::type_seq_element_t<Axis, Dimensions>,
244 Axis,
245 true>(id, scale)}...);
246 }
247
248 template <FieldRole Role, std::size_t... Axis>
249 auto physical_rules(std::size_t id, std::index_sequence<Axis...>) const
250 {
251 using Dimensions
252 = ddc::to_type_seq_t<typename decltype(field<Role>(id))::non_indices_domain_t>;
254 std::
255 pair {face_rule<
256 Role,
257 ddc::type_seq_element_t<Axis, Dimensions>,
258 Axis,
259 false>(id, 1.0)
260 .boundary,
261 face_rule<
262 Role,
263 ddc::type_seq_element_t<Axis, Dimensions>,
264 Axis,
265 true>(id, 1.0)
266 .boundary}...);
267 }
268
269public:
271 Multidomain(Topology<N> topology, std::vector<Data> data)
272 : m_topology(std::move(topology))
273 , m_data(std::move(data))
274 {
275 m_topology.validate();
276 if (m_data.size() != m_topology.domain_count())
277 throw std::invalid_argument("one state is required per physical domain");
278 static_assert(
279 N
280 == ddc::type_seq_size_v<
281 ddc::to_type_seq_t<typename decltype(Data::field)::non_indices_domain_t>>);
282 m_fields = make_views<decltype(Data::field)>("multidomain_fields", [](Data const& state) {
283 return state.field;
284 });
285 m_geometry = make_views<
286 decltype(Data::geometry)>("multidomain_geometry", [](Data const& state) {
287 return state.geometry;
288 });
289 m_flux = make_views<decltype(Data::flux)>("multidomain_flux", [](Data const& state) {
290 return state.flux;
291 });
292 }
293 Topology<N> const& topology() const
294 {
295 return m_topology;
296 }
297 std::size_t domain_count() const
298 {
299 return m_data.size();
300 }
301 Data const& data(std::size_t id) const
302 {
303 return m_data.at(id);
304 }
305 template <FieldRole Role = FieldRole::Primal>
306 auto field(std::size_t id) const
307 {
308 if constexpr (Role == FieldRole::Primal)
309 return data(id).field;
310 else if constexpr (Role == FieldRole::Flux)
311 return data(id).flux;
312 else
313 return data(id).geometry;
314 }
315 template <class Function>
316 auto transform_data(Function function) const
317 {
318 std::vector<std::remove_cvref_t<decltype(function(std::size_t(0), m_data.front()))>> data;
319 data.reserve(domain_count());
320 for (std::size_t id = 0; id < domain_count(); ++id)
321 data.push_back(function(id, m_data[id]));
322 return Multidomain<N, typename decltype(data)::value_type>(m_topology, std::move(data));
323 }
324 template <FieldRole Role = FieldRole::Primal>
325 auto extrapolation_rules(std::size_t id, double jump_scale = 1.0) const
326 {
327 return rules<Role>(id, jump_scale, std::make_index_sequence<N> {});
328 }
333 template <FieldRole Role>
334 auto boundary_rules(std::size_t id) const
335 {
336 return physical_rules<Role>(id, std::make_index_sequence<N> {});
337 }
338 template <class ExecSpace, class Function>
339 void for_each_domain(ExecSpace const& exec, Function function) const
340 {
341 DomainExecution<ExecSpace> partitions(exec, domain_count());
342 partitions.for_each(function);
343 partitions.fence();
344 }
345};
346template <std::size_t N, class Data>
348} // namespace sil::multidomains
A device-copyable choice of the scalar boundary policies.
Definition topology.hpp:24
KOKKOS_FUNCTION bool is_dirichlet() const
Definition topology.hpp:45
One stream per physical domain, retained until all submitted work completes.
DomainExecution(ExecSpace const &parent, std::size_t count)
void for_each(Function function) const
ExecSpace const & space(std::size_t id) const
Bind homogeneous field/geometry/physics views to a runtime topology.
auto boundary_rules(std::size_t id) const
Physical face laws for constitutive flux evaluation.
auto extrapolation_rules(std::size_t id, double jump_scale=1.0) const
auto transform_data(Function function) const
std::size_t domain_count() const
Topology< N > const & topology() const
void for_each_domain(ExecSpace const &exec, Function function) const
Data const & data(std::size_t id) const
auto field(std::size_t id) const
Multidomain(Topology< N > topology, std::vector< Data > data)
Runtime adjacency of aligned tensor domains of dimension N.
Definition topology.hpp:120
std::size_t domain_count() const
Definition topology.hpp:138
Connection const & connection(Face face) const
Definition topology.hpp:176
BoundaryDomain const & boundary(std::size_t id) const
Definition topology.hpp:147
Select an extrapolation rule independently on each side of each dimension.
auto domain_data(Field const &field, Geometry const &geometry, Physics physics)
Multidomain(Topology< N >, std::vector< Data >) -> Multidomain< N, Data >
tensor::BoundarySide side
Definition topology.hpp:102
A thin borrowed donor view, so face policies never duplicate lazy operators.
typename Field::memory_space memory_space
typename Field::non_indices_domain_t non_indices_domain_t
typename Field::indices_domain_t indices_domain_t
KOKKOS_FUNCTION non_indices_domain_t non_indices_domain() const
typename Field::discrete_domain_type discrete_domain_type
KOKKOS_FUNCTION std::size_t global_index(Element elem, Component component) const
KOKKOS_FUNCTION double mem(Element elem, Component component) const
A runtime face policy with the same sampling API as an individual rule.
KOKKOS_FUNCTION bool is_dirichlet() const
KOKKOS_FUNCTION bool is_interface() const
tensor::ExternalDomainExtrapolationRule< Dimension, Field > external
KOKKOS_FUNCTION auto operator()(Source const &field, Element elem) const
KOKKOS_FUNCTION bool shared_boundary() const
KOKKOS_FUNCTION auto value(Domain const &domain, Element elem) const
Continue tensor values into a specified boundary of another tensor domain.