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>
20template <
class Position,
class Element>
21struct FormTransferCell;
23template <
class Position,
class... Grid>
24struct FormTransferCell<Position,
ddc::DiscreteElement<Grid...>>
26 using Element = ddc::DiscreteElement<Grid...>;
27 using Domain = ddc::DiscreteDomain<Grid...>;
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>;
34 Tensor<double, GeometryDomain, Kokkos::layout_right, typename Position::memory_space>;
36 std::array<double, vertices * PositionIndex::size()> storage {};
39 KOKKOS_FUNCTION
static Element corner(std::size_t vertex)
42 for (std::size_t axis = 0; axis < dimension; ++axis)
43 ddc::detail::array(result)[axis] = (vertex >> axis) & 1;
47 KOKKOS_FUNCTION FormTransferCell(Position
const& position, Element
const& base)
53 typename Position::memory_space>(
57 ddc::DiscreteVector<Grid...>(
58 (static_cast<void>(sizeof(Grid)), 2)...)),
59 tensor::TensorAccessor<PositionIndex>::domain())))
61 static_assert(PositionIndex::size() == dimension);
62 for (std::size_t vertex = 0; vertex < vertices; ++vertex) {
64 for (std::size_t axis = 0; axis < dimension; ++axis)
65 ddc::detail::array(node)[axis] += (vertex >> axis) & 1;
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(
71 ddc::DiscreteElement<PositionIndex>(component)));
90template <misc::Specialization<ddc::TypeSeq> Indices>
100 Output
const& output,
102 Position
const& position,
103 Element
const& element,
104 Extrapolation
const& extrapolation = {})
107 if constexpr (Index::rank() == 0) {
108 auto const sample = extrapolation(input, element);
109 output.mem(output.domain().front()) = sample.get(sample.domain().front());
111 using Cell = detail::FormTransferCell<Position, Element>;
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(
122 ddc::DiscreteDomain<Index>,
123 Kokkos::layout_right,
124 typename Position::memory_space>(
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);
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;
141 auto const sampled = extrapolation(input, node);
144 typename Input::indices_domain_t,
145 Kokkos::layout_right,
146 typename Input::memory_space> const& coefficients
148 Reduction<Indices, typename Cell::Geometry, Element>::operator()(
152 Cell::corner(vertex));
153 value += rule.weight(sample) * reduced.get(reduced.access_element(natural));
155 output.mem(component) = value;
172template <misc::Specialization<ddc::TypeSeq> Indices>
182 Output
const& output,
184 Position
const& position,
185 Element
const& element,
186 Extrapolation
const& extrapolation = {})
189 if constexpr (Index::rank() == 0) {
190 auto const sample = extrapolation(input, element);
191 output.mem(output.domain().front()) = sample.get(sample.domain().front());
193 using Cell = detail::FormTransferCell<Position, Element>;
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(
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(
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;
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));
233 Reconstruction<Indices, typename Cell::Geometry, Element>::operator()(
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))
250template <
class Position,
class Extrapolation = tensor::ClampExtrapolationRule>
254 Extrapolation m_extrapolation;
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)
268 template <
class Exec, FormType Output, CochainType Input>
269 void operator()(Exec
const& exec, Output
const& output, Input
const& input)
const
272 = ddc::type_seq_element_t<0, ddc::to_type_seq_t<typename Input::indices_domain_t>>;
273 using Indices = std::conditional_t<
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(
282 output.non_indices_domain(),
284 typename Output::non_indices_domain_t::discrete_element_type element) {
286 operator()(output[element], input, position, element, extrapolation);
293template <
class Position,
class Extrapolation = tensor::ClampExtrapolationRule>
297 Extrapolation m_extrapolation;
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)
311 template <
class Exec, CochainType Output, FormType Input>
312 void operator()(Exec
const& exec, Output
const& output, Input
const& input)
const
315 = ddc::type_seq_element_t<0, ddc::to_type_seq_t<typename Output::indices_domain_t>>;
316 using Indices = std::conditional_t<
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(
325 output.non_indices_domain(),
327 typename Output::non_indices_domain_t::discrete_element_type element) {
329 operator()(output[element], input, position, element, extrapolation);
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)