152 template <
class Field>
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)
163 for (std::size_t
id = 0;
id < constructed; ++id)
164 std::destroy_at(values.data() +
id);
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;
173 template <
class Field,
class Select>
174 auto make_views(std::string
const& label, Select
const& select)
const
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;
184 template <FieldRole Role>
185 auto reference(std::size_t
id)
const
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};
192 return DomainReference<
decltype(Data::geometry)> {m_geometry->values.data() +
id};
195 template <FieldRole Role,
class Dimension, std::
size_t Axis,
bool Upper>
196 auto face_rule(std::size_t
id,
double jump_scale)
const
199 = Upper ? tensor::BoundarySide::Upper : tensor::BoundarySide::Lower;
201 bool const interface = edge.domain < m_data.size();
202 auto const donor = reference<Role>(interface ? edge.
domain :
id);
206 if constexpr (Role == FieldRole::Primal)
208 else if constexpr (Role == FieldRole::Flux)
209 boundary = node.
flux;
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)
217 && ddc::detail::array(source.extents())[tangent]
218 != ddc::detail::array(target.extents())[tangent])
219 throw std::invalid_argument(
"interface tangential extents must match");
221 return FaceRule<Dimension, std::remove_cvref_t<
decltype(donor)>> {
224 Role == FieldRole::Primal ? jump_scale * edge.
jump : 0.0,
225 Role == FieldRole::Geometry ? 1.0 : edge.
orientation},
229 template <
FieldRole Role, std::size_t... Axis>
230 auto rules(std::size_t
id,
double scale, std::index_sequence<Axis...>)
const
233 = ddc::to_type_seq_t<typename decltype(field<Role>(
id))::non_indices_domain_t>;
238 ddc::type_seq_element_t<Axis, Dimensions>,
243 ddc::type_seq_element_t<Axis, Dimensions>,
245 true>(
id, scale)}...);
248 template <
FieldRole Role, std::size_t... Axis>
249 auto physical_rules(std::size_t
id, std::index_sequence<Axis...>)
const
252 = ddc::to_type_seq_t<typename decltype(field<Role>(
id))::non_indices_domain_t>;
257 ddc::type_seq_element_t<Axis, Dimensions>,
263 ddc::type_seq_element_t<Axis, Dimensions>,
272 : m_topology(std::move(topology))
273 , m_data(std::move(data))
277 throw std::invalid_argument(
"one state is required per physical domain");
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) {
285 m_geometry = make_views<
286 decltype(Data::geometry)>(
"multidomain_geometry", [](Data
const& state) {
287 return state.geometry;
289 m_flux = make_views<
decltype(Data::flux)>(
"multidomain_flux", [](Data
const& state) {
299 return m_data.size();
301 Data
const&
data(std::size_t
id)
const
303 return m_data.at(
id);
305 template <FieldRole Role = FieldRole::Primal>
308 if constexpr (Role == FieldRole::Primal)
309 return data(
id).field;
310 else if constexpr (Role == FieldRole::Flux)
311 return data(
id).flux;
313 return data(
id).geometry;
315 template <
class Function>
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]));
324 template <FieldRole Role = FieldRole::Primal>
327 return rules<Role>(
id, jump_scale, std::make_index_sequence<N> {});
333 template <FieldRole Role>
336 return physical_rules<Role>(
id, std::make_index_sequence<N> {});
338 template <
class ExecSpace,
class Function>
A device-copyable choice of the scalar boundary policies.
KOKKOS_FUNCTION bool is_dirichlet() const
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.
std::size_t domain_count() const
Connection const & connection(Face face) const
BoundaryDomain const & boundary(std::size_t id) const
auto domain_data(Field const &field, Geometry const &geometry, Physics physics)
Multidomain(Topology< N >, std::vector< Data >) -> Multidomain< N, Data >
tensor::BoundarySide side
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.