SimiLie
Loading...
Searching...
No Matches
vertex_form_transfer.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 <array>
8#include <cassert>
9#include <cstddef>
10#include <string>
11
12#include <similie/exterior/quadrature/quadrature.hpp>
13#include <similie/exterior/reduction_and_reconstruction/reduction_and_reconstruction.hpp>
14#include <similie/tensor/scalar_extrapolation_rules.hpp>
15
16namespace sil::exterior {
17namespace detail {
18
20template <class Position, class Element>
21struct FormTransferCell;
22
23template <class Position, class... Grid>
24struct FormTransferCell<Position, ddc::DiscreteElement<Grid...>>
25{
26 using Element = ddc::DiscreteElement<Grid...>;
27 using Domain = ddc::DiscreteDomain<Grid...>;
28 using PositionIndex
29 = ddc::type_seq_element_t<0, ddc::to_type_seq_t<typename Position::indices_domain_t>>;
30 static constexpr std::size_t dimension = Domain::rank();
31 static constexpr std::size_t vertices = std::size_t(1) << dimension;
32 using GeometryDomain = ddc::DiscreteDomain<Grid..., PositionIndex>;
33 using Geometry = tensor::
34 Tensor<double, GeometryDomain, Kokkos::layout_right, typename Position::memory_space>;
35
36 std::array<double, vertices * PositionIndex::size()> storage {};
37 Geometry geometry;
38
39 KOKKOS_FUNCTION static Element corner(std::size_t vertex)
40 {
41 Element result;
42 for (std::size_t axis = 0; axis < dimension; ++axis)
43 ddc::detail::array(result)[axis] = (vertex >> axis) & 1;
44 return result;
45 }
46
47 KOKKOS_FUNCTION FormTransferCell(Position const& position, Element const& base)
48 : geometry(
49 ddc::ChunkSpan<
50 double,
51 GeometryDomain,
52 Kokkos::layout_right,
53 typename Position::memory_space>(
54 storage.data(),
55 GeometryDomain(
56 Domain(Element(),
57 ddc::DiscreteVector<Grid...>(
58 (static_cast<void>(sizeof(Grid)), 2)...)),
59 tensor::TensorAccessor<PositionIndex>::domain())))
60 {
61 static_assert(PositionIndex::size() == dimension);
62 for (std::size_t vertex = 0; vertex < vertices; ++vertex) {
63 Element node = base;
64 for (std::size_t axis = 0; axis < dimension; ++axis)
65 ddc::detail::array(node)[axis] += (vertex >> axis) & 1;
66 assert(misc::domain_contains(position.non_indices_domain(), node));
67 for (std::size_t component = 0; component < dimension; ++component)
68 geometry.mem(corner(vertex), ddc::DiscreteElement<PositionIndex>(component))
69 = position.get(position.access_element(
70 node,
71 ddc::DiscreteElement<PositionIndex>(component)));
72 }
73 }
74};
75
76} // namespace detail
77
90template <misc::Specialization<ddc::TypeSeq> Indices>
92{
93 template <
94 CochainType Output,
95 FormType Input,
96 class Position,
97 class Element,
98 class Extrapolation = tensor::ClampExtrapolationRule>
99 KOKKOS_FUNCTION static void operator()(
100 Output const& output,
101 Input const& input,
102 Position const& position,
103 Element const& element,
104 Extrapolation const& extrapolation = {})
105 {
106 using Index = reduction_index_t<Indices>;
107 if constexpr (Index::rank() == 0) {
108 auto const sample = extrapolation(input, element);
109 output.mem(output.domain().front()) = sample.get(sample.domain().front());
110 } else {
111 using Cell = detail::FormTransferCell<Position, Element>;
112 using LocalTensor = tensor::Tensor<
113 double,
114 ddc::DiscreteDomain<Index>,
115 Kokkos::layout_right,
116 typename Position::memory_space>;
117 Cell cell(position, element);
118 std::array<double, Index::mem_size()> storage {};
119 LocalTensor const reduced(
120 ddc::ChunkSpan<
121 double,
122 ddc::DiscreteDomain<Index>,
123 Kokkos::layout_right,
124 typename Position::memory_space>(
125 storage.data(),
127 ddc::device_for_each(output.domain(), [&](auto component) {
128 auto const natural = output.accessor().canonical_natural_element(component);
129 std::array const axes = detail::flat_natural_elem_ids(natural);
130 double value = 0;
131 VertexQuadrature<Index::rank()> const rule;
132 for (std::size_t sample = 0; sample < rule.size; ++sample) {
133 std::size_t vertex = 0;
134 Element node = element;
135 for (std::size_t axis = 0; axis < axes.size(); ++axis) {
136 std::size_t const offset = (sample >> axis) & 1;
137 vertex |= offset << axes[axis];
138 ddc::detail::array(node)[axes[axis]] += offset;
139 }
140 // Keep the sampled storage alive while Reduction uses its view.
141 auto const sampled = extrapolation(input, node);
142 tensor::Tensor<
143 double,
144 typename Input::indices_domain_t,
145 Kokkos::layout_right,
146 typename Input::memory_space> const& coefficients
147 = sampled;
148 Reduction<Indices, typename Cell::Geometry, Element>::operator()(
149 Cochain(reduced),
150 Form(coefficients),
151 cell.geometry,
152 Cell::corner(vertex));
153 value += rule.weight(sample) * reduced.get(reduced.access_element(natural));
154 }
155 output.mem(component) = value;
156 });
157 }
158 }
159};
160
172template <misc::Specialization<ddc::TypeSeq> Indices>
174{
175 template <
176 FormType Output,
177 CochainType Input,
178 class Position,
179 class Element,
180 class Extrapolation = tensor::ClampExtrapolationRule>
181 KOKKOS_FUNCTION static void operator()(
182 Output const& output,
183 Input const& input,
184 Position const& position,
185 Element const& element,
186 Extrapolation const& extrapolation = {})
187 {
188 using Index = reduction_index_t<Indices>;
189 if constexpr (Index::rank() == 0) {
190 auto const sample = extrapolation(input, element);
191 output.mem(output.domain().front()) = sample.get(sample.domain().front());
192 } else {
193 using Cell = detail::FormTransferCell<Position, Element>;
194 using LocalTensor = tensor::Tensor<
195 double,
196 ddc::DiscreteDomain<Index>,
197 Kokkos::layout_right,
198 typename Position::memory_space>;
199 std::array<double, Index::mem_size()> cochain_storage {}, coefficient_storage {};
200 LocalTensor const cochain(
201 ddc::ChunkSpan<
202 double,
203 ddc::DiscreteDomain<Index>,
204 Kokkos::layout_right,
205 typename Position::memory_space>(
206 cochain_storage.data(),
207 tensor::TensorAccessor<Index>::domain()));
208 LocalTensor const coefficients(
209 ddc::ChunkSpan<
210 double,
211 ddc::DiscreteDomain<Index>,
212 Kokkos::layout_right,
213 typename Position::memory_space>(
214 coefficient_storage.data(),
215 tensor::TensorAccessor<Index>::domain()));
216 ddc::device_for_each(output.domain(), [&](auto component) {
217 output.mem(component) = 0;
218 });
219 for (std::size_t vertex = 0; vertex < Cell::vertices; ++vertex) {
220 Element base = element;
221 for (std::size_t axis = 0; axis < Cell::dimension; ++axis)
222 ddc::detail::array(base)[axis] -= (vertex >> axis) & 1;
223 Cell cell(position, base);
224 ddc::device_for_each(cochain.domain(), [&](auto component) {
225 auto const natural = cochain.accessor().canonical_natural_element(component);
226 std::array const axes = detail::flat_natural_elem_ids(natural);
227 Element node = element;
228 for (std::size_t axis : axes)
229 ddc::detail::array(node)[axis] -= (vertex >> axis) & 1;
230 auto const sample = extrapolation(input, node);
231 cochain.mem(component) = sample.get(sample.access_element(natural));
232 });
233 Reconstruction<Indices, typename Cell::Geometry, Element>::operator()(
234 Form(coefficients),
235 Cochain(cochain),
236 cell.geometry,
237 Cell::corner(vertex));
238 ddc::device_for_each(output.domain(), [&](auto component) {
239 auto const natural = output.accessor().canonical_natural_element(component);
240 output.mem(component) += coefficients.get(coefficients.access_element(natural))
241 / Cell::vertices;
242 });
243 }
244 }
245 }
246};
247
248// Apply the geometric vertex transfer to a complete field. The same policy
249// can reconstruct/project several form degrees in a representation adapter.
250template <class Position, class Extrapolation = tensor::ClampExtrapolationRule>
252{
253 Position m_position;
254 Extrapolation m_extrapolation;
255 std::string m_label;
256
257public:
259 Position const& position,
260 Extrapolation const& extrapolation = {},
261 std::string const& label = "similie_vertex_form_transfer")
262 : m_position(position)
263 , m_extrapolation(extrapolation)
264 , m_label(label)
265 {
266 }
267
268 template <class Exec, FormType Output, CochainType Input>
269 void operator()(Exec const& exec, Output const& output, Input const& input) const
270 {
271 using Index
272 = ddc::type_seq_element_t<0, ddc::to_type_seq_t<typename Input::indices_domain_t>>;
273 using Indices = std::conditional_t<
274 Index::rank() == 0,
275 ddc::TypeSeq<>,
276 ddc::to_type_seq_t<tensor::natural_domain_t<Index>>>;
277 Position const position = m_position;
278 Extrapolation const extrapolation = m_extrapolation;
279 ddc::parallel_for_each(
280 m_label,
281 exec,
282 output.non_indices_domain(),
283 KOKKOS_LAMBDA(
284 typename Output::non_indices_domain_t::discrete_element_type element) {
286 operator()(output[element], input, position, element, extrapolation);
287 });
288 }
289};
290
291// Apply the geometric vertex transfer to a complete field. The same policy
292// can reconstruct/project several form degrees in a representation adapter.
293template <class Position, class Extrapolation = tensor::ClampExtrapolationRule>
295{
296 Position m_position;
297 Extrapolation m_extrapolation;
298 std::string m_label;
299
300public:
302 Position const& position,
303 Extrapolation const& extrapolation = {},
304 std::string const& label = "similie_vertex_form_transfer")
305 : m_position(position)
306 , m_extrapolation(extrapolation)
307 , m_label(label)
308 {
309 }
310
311 template <class Exec, CochainType Output, FormType Input>
312 void operator()(Exec const& exec, Output const& output, Input const& input) const
313 {
314 using Index
315 = ddc::type_seq_element_t<0, ddc::to_type_seq_t<typename Output::indices_domain_t>>;
316 using Indices = std::conditional_t<
317 Index::rank() == 0,
318 ddc::TypeSeq<>,
319 ddc::to_type_seq_t<tensor::natural_domain_t<Index>>>;
320 Position const position = m_position;
321 Extrapolation const extrapolation = m_extrapolation;
322 ddc::parallel_for_each(
323 m_label,
324 exec,
325 output.non_indices_domain(),
326 KOKKOS_LAMBDA(
327 typename Output::non_indices_domain_t::discrete_element_type element) {
329 operator()(output[element], input, position, element, extrapolation);
330 });
331 }
332};
333
334} // namespace sil::exterior
void operator()(Exec const &exec, Output const &output, Input const &input) const
VertexFormProjectionField(Position const &position, Extrapolation const &extrapolation={}, std::string const &label="similie_vertex_form_transfer")
void operator()(Exec const &exec, Output const &output, Input const &input) const
VertexFormReconstructionField(Position const &position, Extrapolation const &extrapolation={}, std::string const &label="similie_vertex_form_transfer")
static KOKKOS_FUNCTION constexpr discrete_domain_type domain()
Cochain(Tensor const &) -> Cochain< Tensor >
typename detail::ReductionTargetIndex< Indices >::type reduction_index_t
Form(Coefficients const &) -> Form< Coefficients >
KOKKOS_FUNCTION bool domain_contains(ddc::DiscreteDomain< DDim... > const &dom, ddc::DiscreteElement< ODDim... > elem)
Project a nodally sampled differential form onto primal cochains.
static KOKKOS_FUNCTION void operator()(Output const &output, Input const &input, Position const &position, Element const &element, Extrapolation const &extrapolation={})
Reconstruct a primal cochain as a differential form at a mesh vertex.
static KOKKOS_FUNCTION void operator()(Output const &output, Input const &input, Position const &position, Element const &element, Extrapolation const &extrapolation={})
Spatial closure evaluated independently of the stored field values.