13#include <similie/misc/domain_contains.hpp>
14#include <similie/misc/specialization.hpp>
15#include <similie/misc/type_seq_conversion.hpp>
17#include "extrapolation_basis.hpp"
18#include "scalar_extrapolation_rules.hpp"
24template <
class Result,
class Contribution>
25KOKKOS_FUNCTION
void accumulate_extrapolation(
27 Contribution
const& contribution,
31 if constexpr (ddc::type_seq_contains_v<
32 ddc::TypeSeq<ExtrapolationSource>,
33 ddc::to_type_seq_t<typename Result::discrete_domain_type>>) {
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) {
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);
47 ddc::device_for_each(result.domain(), [&](
auto component) {
48 result.mem(component) += weight * contribution.mem(component);
52template <std::size_t Dimension,
class... RulePairs>
53class ExtrapolationRulesStorage;
55template <std::
size_t Dimension>
56class ExtrapolationRulesStorage<Dimension>
59 KOKKOS_DEFAULTED_FUNCTION ExtrapolationRulesStorage() =
default;
61 template <
class Domain,
class Element,
class Result,
class Evaluate>
62 KOKKOS_FUNCTION
void accumulate(Domain, Element, Result&,
double&, Evaluate)
const
67template <std::size_t Dimension,
class RulePair,
class... OtherRulePairs>
68class ExtrapolationRulesStorage<Dimension, RulePair, OtherRulePairs...>
71 ExtrapolationRulesStorage<Dimension + 1, OtherRulePairs...> m_other_rules;
74 KOKKOS_DEFAULTED_FUNCTION ExtrapolationRulesStorage() =
default;
76 KOKKOS_FUNCTION
explicit ExtrapolationRulesStorage(
78 OtherRulePairs... other_rules)
80 , m_other_rules(other_rules...)
84 template <std::
size_t Axis,
bool Upper>
85 KOKKOS_FUNCTION
auto const& boundary_rule()
const
87 if constexpr (Axis == Dimension) {
89 return m_rules.second;
93 return m_other_rules.template boundary_rule<Axis, Upper>();
97 template <
class Domain,
class Element,
class Result,
class Evaluate>
98 KOKKOS_FUNCTION
void accumulate(
103 Evaluate
const& evaluate)
const
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)
113 if (distance != 0.0) {
115 accumulate_extrapolation(
117 evaluate(m_rules.first, element),
121 accumulate_extrapolation(
123 evaluate(m_rules.second, element),
128 m_other_rules.accumulate(domain, element, result, total, evaluate);
162template <misc::Specialization<std::pair>... RulePairs>
165 detail::ExtrapolationRulesStorage<0, RulePairs...> m_rules;
171 requires(
sizeof...(RulePairs) > 0)
176 template <
class ExtrapolationRule>
178 sizeof...(RulePairs) > 0
179 && ((std::is_same_v<ExtrapolationRule, typename RulePairs::first_type>
180 && std::is_same_v<ExtrapolationRule, typename RulePairs::second_type>)
187 template <std::
size_t Axis,
bool Upper>
190 static_assert(Axis <
sizeof...(RulePairs));
194 template <
class Domain,
class Element>
195 KOKKOS_FUNCTION
auto value(Domain
const& domain, Element sampled_element)
const
197 static_assert(
sizeof...(RulePairs) == ddc::type_seq_size_v<ddc::to_type_seq_t<Domain>>);
199 element(sampled_element);
201 = detail::make_extrapolation_basis<1 + 2 *
sizeof...(RulePairs)>(domain, element);
204 .mem(element.storage_element(),
205 ddc::DiscreteElement<detail::ExtrapolationSource>(0))
210 m_rules.accumulate(domain, element, result, total, [&](
auto const& rule,
auto sample) {
211 return rule.value(domain, sample);
213 result *= 1.0 / total;
217 template <
class Field,
class Element>
218 KOKKOS_FUNCTION
auto operator()(Field
const& field, Element sampled_element)
const
223 [&](
auto const& rule,
auto element) {
return rule(field, element); },
225 return detail::pointwise_tensor<Field>([&](
auto component) {
226 return field.mem(element.storage_element(), component);
232 template <
class Field,
class Element,
class Evaluate,
class Interior>
233 KOKKOS_FUNCTION
auto evaluate(
236 Evaluate
const& evaluate,
237 Interior
const& interior)
const
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);
246 return interior(element);
247 auto result = detail::pointwise_tensor<Field>([](
auto) {
return 0.0; });
249 m_rules.accumulate(field.non_indices_domain(), element, result, total, evaluate);
250 result *= 1.0 / total;
255static_assert(ExtrapolationRulesConcept<
257 detail::FieldConcept<ScalarIndex>,
258 ddc::DiscreteElement<detail::GridConcept>>);
260template <
class LeftRule,
class RightRule, misc::Specialization<std::pair>... OtherRulePairs>
266template <
class ExtrapolationRule, std::size_t... Dimension>
267KOKKOS_FUNCTION
auto repeat_extrapolation_rule(
268 ExtrapolationRule rule,
269 std::index_sequence<Dimension...>)
271 if constexpr (
sizeof...(Dimension) == 0)
291template <std::
size_t N, misc::NotSpecialization<ExtrapolationRules> ExtrapolationRule>
294 return detail::repeat_extrapolation_rule(rule, std::make_index_sequence<N>());
297template <
class TensorType, misc::NotSpecialization<ExtrapolationRules> ExtrapolationRule>
301 ddc::type_seq_size_v<ddc::to_type_seq_t<typename TensorType::non_indices_domain_t>>>(
Absolute logical coordinates with signed storage, including exterior nodes.
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... >