SimiLie
Loading...
Searching...
No Matches
operator_representation.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 <tuple>
8#include <utility>
9
10#include <similie/exterior/cochain.hpp>
11#include <similie/exterior/form.hpp>
12
13namespace sil::exterior {
14namespace detail {
15template <
16 class Operator,
17 class Output,
18 class Forms,
19 class Element,
20 std::size_t... I,
21 class Arguments>
22KOKKOS_FUNCTION void apply_form_tuple(
23 Operator const& operation,
24 Output const& output,
25 Forms const& forms,
26 Element element,
27 std::index_sequence<I...>,
28 Arguments const& arguments)
29{
30 [&]<std::size_t... A>(std::index_sequence<A...>) {
31 if constexpr (requires {
32 operation(
33 output[element],
34 std::get<I>(forms)[element]...,
35 std::get<A>(arguments)...,
36 element);
37 })
38 operation(
39 output[element],
40 std::get<I>(forms)[element]...,
41 std::get<A>(arguments)...,
42 element);
43 else
44 operation(output[element], std::get<I>(forms)[element]..., std::get<A>(arguments)...);
45 }(std::make_index_sequence<std::tuple_size_v<Arguments>>());
46}
47template <class Operator, class Output, class Buffers, class Arguments>
48struct ApplyRepresentation
49{
50 Operator operation;
51 Output output;
52 Buffers buffers;
53 Arguments arguments;
54
55 KOKKOS_FUNCTION void operator()(
56 typename Output::non_indices_domain_t::discrete_element_type element) const
57 {
58 apply_form_tuple(
59 operation,
60 output,
61 buffers,
62 element,
63 std::make_index_sequence<std::tuple_size_v<Buffers>>(),
64 arguments);
65 }
66};
67} // namespace detail
68
69
70// Transfer callables carry the geometry, complex and sampling rule. The adapter
71// owns no hidden discretization and uses the caller's explicitly typed buffers.
72template <class Operator>
74{
75 Operator m_operator;
76
77public:
78 KOKKOS_DEFAULTED_FUNCTION OperatorActingOnCochainInPlaceOfForm() = default;
79 KOKKOS_FUNCTION explicit OperatorActingOnCochainInPlaceOfForm(Operator const& operation)
80 : m_operator(operation)
81 {
82 }
83
84 template <
85 CochainType Output,
86 CochainType Input,
87 FormType Reconstructed,
88 FormType Transformed,
89 class Reconstruction,
90 class Reduction,
91 class... Arguments>
92 KOKKOS_FUNCTION void operator()(
93 Output const& output,
94 Input const& input,
95 Reconstructed const& reconstructed,
96 Transformed const& transformed,
97 Reconstruction const& reconstruct,
98 Reduction const& reduce,
99 Arguments const&... arguments) const
100 {
101 reconstruct(reconstructed, input);
102 m_operator(transformed, reconstructed, arguments...);
103 reduce(output, transformed);
104 }
105 // Value operators can return an owned result (including scalar forms).
106 // Transfers return values, so no mutable-view convention is imposed here.
107 template <class TransferIn, class TransferOut, class... Inputs>
108 requires(sizeof...(Inputs) > 0
110 && requires(Operator const& operation, TransferIn const& transfer_in,
111 TransferOut const& transfer_out, Inputs const&... inputs) {
112 requires (FormType<decltype(transfer_in(inputs))> && ...);
113 requires FormType<decltype(operation(transfer_in(inputs)...))>;
114 requires (CochainType<decltype(transfer_out(operation(transfer_in(inputs)...)))>
115 || misc::Specialization<decltype(transfer_out(operation(transfer_in(inputs)...))), Cosimplex>);
116 })
117 KOKKOS_FUNCTION auto operator()(
118 TransferIn const& transfer_in, TransferOut const& transfer_out, Inputs const&... inputs) const
119 {
120 return transfer_out(m_operator(transfer_in(inputs)...));
121 }
122
123 // Multiple operands share one geometric transfer policy. Its overloads
124 // select the appropriate form degree and placement for each operand.
125 template <
126 class Exec,
127 CochainType Output,
128 class... Inputs,
129 class... Buffers,
130 FormType Transformed,
131 class TransferIn,
132 class TransferOut,
133 class... Arguments>
135 Exec const& exec,
136 Output const& output,
137 std::tuple<Inputs...> const& inputs,
138 std::tuple<Buffers...> const& buffers,
139 Transformed const& transformed,
140 TransferIn const& transfer_in,
141 TransferOut const& transfer_out,
142 Arguments const&... arguments) const
143 {
144 static_assert(sizeof...(Inputs) == sizeof...(Buffers));
145 static_assert((CochainType<Inputs> && ...));
146 static_assert((FormType<Buffers> && ...));
147 [&]<std::size_t... I>(std::index_sequence<I...>) {
148 (transfer_in(exec, std::get<I>(buffers), std::get<I>(inputs)), ...);
149 }(std::index_sequence_for<Inputs...>());
150 std::tuple<Arguments...> const argument_tuple(arguments...);
151 ddc::parallel_for_each(
152 "similie_apply_representation_adapter",
153 exec,
154 transformed.non_indices_domain(),
155 detail::ApplyRepresentation<
156 Operator,
157 Transformed,
158 std::tuple<Buffers...>,
159 std::tuple<
160 Arguments...>> {m_operator, transformed, buffers, argument_tuple});
161 transfer_out(exec, output, transformed);
162 return output;
163 }
164};
165
166template <class Operator>
168{
169 Operator m_operator;
170
171public:
172 static constexpr bool input_is_form = true;
173 static constexpr bool output_is_form = true;
174 KOKKOS_DEFAULTED_FUNCTION OperatorActingOnFormInPlaceOfCochain() = default;
175 KOKKOS_FUNCTION explicit OperatorActingOnFormInPlaceOfCochain(Operator const& operation)
176 : m_operator(operation)
177 {
178 }
179
180 template <
181 FormType Output,
182 FormType Input,
183 CochainType Reduced,
184 CochainType Transformed,
185 class Reduction,
186 class Reconstruction,
187 class... Arguments>
188 KOKKOS_FUNCTION void operator()(
189 Output const& output,
190 Input const& input,
191 Reduced const& reduced,
192 Transformed const& transformed,
193 Reduction const& reduce,
194 Reconstruction const& reconstruct,
195 Arguments const&... arguments) const
196 {
197 reduce(reduced, input);
198 m_operator(transformed, reduced, arguments...);
199 reconstruct(output, transformed);
200 }
201 // Value operators can return an owned result (including scalar forms).
202 // Transfers return values, so no mutable-view convention is imposed here.
203 template <class TransferIn, class TransferOut, class... Inputs>
204 requires(sizeof...(Inputs) > 0
205 && (FormType<Inputs> && ...)
206 && requires(Operator const& operation, TransferIn const& transfer_in,
207 TransferOut const& transfer_out, Inputs const&... inputs) {
208 requires ((CochainType<decltype(transfer_in(inputs))>
209 || misc::Specialization<decltype(transfer_in(inputs)), Cosimplex>) && ...);
210 requires FormType<decltype(transfer_out(operation(transfer_in(inputs)...)))>;
211 })
212 KOKKOS_FUNCTION auto operator()(
213 TransferIn const& transfer_in, TransferOut const& transfer_out, Inputs const&... inputs) const
214 {
215 return transfer_out(m_operator(transfer_in(inputs)...));
216 }
217
218 // Multiple operands share one geometric transfer policy. Its overloads
219 // select the appropriate form degree and placement for each operand.
220 template <
221 class Exec,
222 FormType Output,
223 class... Inputs,
224 class... Buffers,
225 CochainType Transformed,
226 class TransferIn,
227 class TransferOut,
228 class... Arguments>
230 Exec const& exec,
231 Output const& output,
232 std::tuple<Inputs...> const& inputs,
233 std::tuple<Buffers...> const& buffers,
234 Transformed const& transformed,
235 TransferIn const& transfer_in,
236 TransferOut const& transfer_out,
237 Arguments const&... arguments) const
238 {
239 static_assert(sizeof...(Inputs) == sizeof...(Buffers));
240 static_assert((FormType<Inputs> && ...));
241 static_assert((CochainType<Buffers> && ...));
242 [&]<std::size_t... I>(std::index_sequence<I...>) {
243 (transfer_in(exec, std::get<I>(buffers), std::get<I>(inputs)), ...);
244 }(std::index_sequence_for<Inputs...>());
245 std::tuple<Arguments...> const argument_tuple(arguments...);
246 ddc::parallel_for_each(
247 "similie_apply_representation_adapter",
248 exec,
249 transformed.non_indices_domain(),
250 detail::ApplyRepresentation<
251 Operator,
252 Transformed,
253 std::tuple<Buffers...>,
254 std::tuple<
255 Arguments...>> {m_operator, transformed, buffers, argument_tuple});
256 transfer_out(exec, output, transformed);
257 return output;
258 }
259};
260
261} // namespace sil::exterior
Cosimplex class.
Definition cosimplex.hpp:20
Output operator()(Exec const &exec, Output const &output, std::tuple< Inputs... > const &inputs, std::tuple< Buffers... > const &buffers, Transformed const &transformed, TransferIn const &transfer_in, TransferOut const &transfer_out, Arguments const &... arguments) const
KOKKOS_FUNCTION void operator()(Output const &output, Input const &input, Reconstructed const &reconstructed, Transformed const &transformed, Reconstruction const &reconstruct, Reduction const &reduce, Arguments const &... arguments) const
KOKKOS_FUNCTION OperatorActingOnCochainInPlaceOfForm(Operator const &operation)
KOKKOS_DEFAULTED_FUNCTION OperatorActingOnCochainInPlaceOfForm()=default
Output operator()(Exec const &exec, Output const &output, std::tuple< Inputs... > const &inputs, std::tuple< Buffers... > const &buffers, Transformed const &transformed, TransferIn const &transfer_in, TransferOut const &transfer_out, Arguments const &... arguments) const
KOKKOS_FUNCTION void operator()(Output const &output, Input const &input, Reduced const &reduced, Transformed const &transformed, Reduction const &reduce, Reconstruction const &reconstruct, Arguments const &... arguments) const
KOKKOS_DEFAULTED_FUNCTION OperatorActingOnFormInPlaceOfCochain()=default
KOKKOS_FUNCTION OperatorActingOnFormInPlaceOfCochain(Operator const &operation)