SimiLie
Loading...
Searching...
No Matches
extrapolation_rules.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 <cstddef>
8#include <type_traits>
9#include <utility>
10
11#include <ddc/ddc.hpp>
12
13#include <similie/misc/domain_contains.hpp>
14#include <similie/misc/specialization.hpp>
15#include <similie/misc/type_seq_conversion.hpp>
16
17#include "extrapolation_basis.hpp"
18#include "scalar_extrapolation_rules.hpp"
19
20namespace sil::tensor {
21
22namespace detail {
23
24template <class Result, class Contribution>
25KOKKOS_FUNCTION void accumulate_extrapolation(
26 Result& result,
27 Contribution const& contribution,
28 double weight,
29 std::size_t source)
30{
31 if constexpr (ddc::type_seq_contains_v<
32 ddc::TypeSeq<ExtrapolationSource>,
33 ddc::to_type_seq_t<typename Result::discrete_domain_type>>) {
34 using Spatial = misc::convert_type_seq_to_t<
35 ddc::DiscreteDomain,
36 ddc::type_seq_remove_t<
37 ddc::to_type_seq_t<typename Result::discrete_domain_type>,
38 ddc::TypeSeq<ExtrapolationSource>>>;
39 ddc::device_for_each(contribution.domain(), [&](auto entry) {
40 result
41 .mem(typename Spatial::discrete_element_type(entry),
42 ddc::DiscreteElement<ExtrapolationSource>(
43 entry.template uid<ExtrapolationSource>() == 0 ? 0 : source))
44 += weight * contribution.mem(entry);
45 });
46 } else
47 ddc::device_for_each(result.domain(), [&](auto component) {
48 result.mem(component) += weight * contribution.mem(component);
49 });
50}
51
52template <std::size_t Dimension, class... RulePairs>
53class ExtrapolationRulesStorage;
54
55template <std::size_t Dimension>
56class ExtrapolationRulesStorage<Dimension>
57{
58public:
59 KOKKOS_DEFAULTED_FUNCTION ExtrapolationRulesStorage() = default;
60
61 template <class Domain, class Element, class Result, class Evaluate>
62 KOKKOS_FUNCTION void accumulate(Domain, Element, Result&, double&, Evaluate) const
63 {
64 }
65};
66
67template <std::size_t Dimension, class RulePair, class... OtherRulePairs>
68class ExtrapolationRulesStorage<Dimension, RulePair, OtherRulePairs...>
69{
70 RulePair m_rules;
71 ExtrapolationRulesStorage<Dimension + 1, OtherRulePairs...> m_other_rules;
72
73public:
74 KOKKOS_DEFAULTED_FUNCTION ExtrapolationRulesStorage() = default;
75
76 KOKKOS_FUNCTION explicit ExtrapolationRulesStorage(
77 RulePair rules,
78 OtherRulePairs... other_rules)
79 : m_rules(rules)
80 , m_other_rules(other_rules...)
81 {
82 }
83
84 template <std::size_t Axis, bool Upper>
85 KOKKOS_FUNCTION auto const& boundary_rule() const
86 {
87 if constexpr (Axis == Dimension) {
88 if constexpr (Upper)
89 return m_rules.second;
90 else
91 return m_rules.first;
92 } else {
93 return m_other_rules.template boundary_rule<Axis, Upper>();
94 }
95 }
96
97 template <class Domain, class Element, class Result, class Evaluate>
98 KOKKOS_FUNCTION void accumulate(
99 Domain const& domain,
100 Element element,
101 Result& result,
102 double& total,
103 Evaluate const& evaluate) const
104 {
105 using DDim = ddc::type_seq_element_t<Dimension, ddc::to_type_seq_t<Domain>>;
106 std::ptrdiff_t const sampled = static_cast<std::ptrdiff_t>(element.template uid<DDim>());
107 std::ptrdiff_t const front
108 = static_cast<std::ptrdiff_t>(domain.front().template uid<DDim>());
109 std::ptrdiff_t const back = static_cast<std::ptrdiff_t>(domain.back().template uid<DDim>());
110 double const distance = sampled < front ? double(front - sampled)
111 : sampled > back ? double(sampled - back)
112 : 0.0;
113 if (distance != 0.0) {
114 if (sampled < front)
115 accumulate_extrapolation(
116 result,
117 evaluate(m_rules.first, element),
118 distance,
119 1 + 2 * Dimension);
120 else
121 accumulate_extrapolation(
122 result,
123 evaluate(m_rules.second, element),
124 distance,
125 2 + 2 * Dimension);
126 total += distance;
127 }
128 m_other_rules.accumulate(domain, element, result, total, evaluate);
129 }
130};
131
132} // namespace detail
133
162template <misc::Specialization<std::pair>... RulePairs>
164{
165 detail::ExtrapolationRulesStorage<0, RulePairs...> m_rules;
166
167public:
168 KOKKOS_DEFAULTED_FUNCTION ExtrapolationRules() = default;
169
170 KOKKOS_FUNCTION explicit ExtrapolationRules(RulePairs... rules)
171 requires(sizeof...(RulePairs) > 0)
172 : m_rules(rules...)
173 {
174 }
175
176 template <class ExtrapolationRule>
177 requires(
178 sizeof...(RulePairs) > 0
179 && ((std::is_same_v<ExtrapolationRule, typename RulePairs::first_type>
180 && std::is_same_v<ExtrapolationRule, typename RulePairs::second_type>)
181 && ...))
182 KOKKOS_FUNCTION ExtrapolationRules(ExtrapolationRule rule) : m_rules(RulePairs {rule, rule}...)
183 {
184 }
185
187 template <std::size_t Axis, bool Upper>
188 KOKKOS_FUNCTION auto const& boundary_rule() const
189 {
190 static_assert(Axis < sizeof...(RulePairs));
191 return m_rules.template boundary_rule<Axis, Upper>();
192 }
193
194 template <class Domain, class Element>
195 KOKKOS_FUNCTION auto value(Domain const& domain, Element sampled_element) const
196 {
197 static_assert(sizeof...(RulePairs) == ddc::type_seq_size_v<ddc::to_type_seq_t<Domain>>);
199 element(sampled_element);
200 auto result
201 = detail::make_extrapolation_basis<1 + 2 * sizeof...(RulePairs)>(domain, element);
202 if (misc::domain_contains(domain, element)) {
203 result
204 .mem(element.storage_element(),
205 ddc::DiscreteElement<detail::ExtrapolationSource>(0))
206 = 1.0;
207 return result;
208 }
209 double total = 0.0;
210 m_rules.accumulate(domain, element, result, total, [&](auto const& rule, auto sample) {
211 return rule.value(domain, sample);
212 });
213 result *= 1.0 / total;
214 return result;
215 }
216
217 template <class Field, class Element>
218 KOKKOS_FUNCTION auto operator()(Field const& field, Element sampled_element) const
219 {
220 return evaluate(
221 field,
222 sampled_element,
223 [&](auto const& rule, auto element) { return rule(field, element); },
224 [&](auto element) {
225 return detail::pointwise_tensor<Field>([&](auto component) {
226 return field.mem(element.storage_element(), component);
227 });
228 });
229 }
230
231private:
232 template <class Field, class Element, class Evaluate, class Interior>
233 KOKKOS_FUNCTION auto evaluate(
234 Field const& field,
235 Element sample,
236 Evaluate const& evaluate,
237 Interior const& interior) const
238 {
239 static_assert(
240 sizeof...(RulePairs)
241 == ddc::type_seq_size_v<ddc::to_type_seq_t<typename Field::non_indices_domain_t>>);
244 ddc::to_type_seq_t<typename Field::non_indices_domain_t>> const element(sample);
245 if (misc::domain_contains(field.non_indices_domain(), element))
246 return interior(element);
247 auto result = detail::pointwise_tensor<Field>([](auto) { return 0.0; });
248 double total = 0.0;
249 m_rules.accumulate(field.non_indices_domain(), element, result, total, evaluate);
250 result *= 1.0 / total;
251 return result;
252 }
253};
254
255static_assert(ExtrapolationRulesConcept<
257 detail::FieldConcept<ScalarIndex>,
258 ddc::DiscreteElement<detail::GridConcept>>);
259
260template <class LeftRule, class RightRule, misc::Specialization<std::pair>... OtherRulePairs>
261ExtrapolationRules(std::pair<LeftRule, RightRule>, OtherRulePairs...)
263
264namespace detail {
265
266template <class ExtrapolationRule, std::size_t... Dimension>
267KOKKOS_FUNCTION auto repeat_extrapolation_rule(
268 ExtrapolationRule rule,
269 std::index_sequence<Dimension...>)
270{
271 if constexpr (sizeof...(Dimension) == 0)
272 return ExtrapolationRules<> {};
273 else
274 return ExtrapolationRules((static_cast<void>(Dimension), std::pair {rule, rule})...);
275}
276
277} // namespace detail
278
291template <std::size_t N, misc::NotSpecialization<ExtrapolationRules> ExtrapolationRule>
292KOKKOS_FUNCTION auto make_extrapolation_rules(ExtrapolationRule rule)
293{
294 return detail::repeat_extrapolation_rule(rule, std::make_index_sequence<N>());
295}
296
297template <class TensorType, misc::NotSpecialization<ExtrapolationRules> ExtrapolationRule>
298KOKKOS_FUNCTION auto make_extrapolation_rules(TensorType const&, ExtrapolationRule rule)
299{
301 ddc::type_seq_size_v<ddc::to_type_seq_t<typename TensorType::non_indices_domain_t>>>(
302 rule);
303}
304
305} // namespace sil::tensor
Absolute logical coordinates with signed storage, including exterior nodes.
Select an extrapolation rule independently on each side of each dimension.
KOKKOS_FUNCTION ExtrapolationRules(RulePairs... rules)
KOKKOS_FUNCTION auto const & boundary_rule() const
Access one face policy for boundary integrals and nodal constraints.
KOKKOS_DEFAULTED_FUNCTION ExtrapolationRules()=default
KOKKOS_FUNCTION auto value(Domain const &domain, Element sampled_element) const
KOKKOS_FUNCTION auto operator()(Field const &field, Element sampled_element) const
KOKKOS_FUNCTION ExtrapolationRules(ExtrapolationRule rule)
KOKKOS_FUNCTION bool domain_contains(ddc::DiscreteDomain< DDim... > const &dom, ddc::DiscreteElement< ODDim... > elem)
typename detail::ConvertTypeSeqTo< T, Seq >::type convert_type_seq_to_t
KOKKOS_FUNCTION auto make_extrapolation_rules(ExtrapolationRule rule)
Broadcast a rule to both sides of all N non-index dimensions.
ExtrapolationRules(std::pair< LeftRule, RightRule >, OtherRulePairs...) -> ExtrapolationRules< std::pair< LeftRule, RightRule >, OtherRulePairs... >