SimiLie
Loading...
Searching...
No Matches
extrapolation_basis.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
9#include <similie/misc/clamp_to_domain.hpp>
10#include <similie/misc/type_seq_conversion.hpp>
11
12#include "owning_tensor.hpp"
13
14namespace sil::tensor {
15namespace detail {
16template <class Domain, class Memory, class Evaluate>
17KOKKOS_FUNCTION auto pointwise_tensor(Evaluate const& evaluate)
18{
20 std::array<double, Accessor::domain().size()> storage {};
22 ddc::ChunkSpan<
23 double,
24 Domain,
25 Kokkos::layout_right,
26 Memory>(storage.data(), Accessor::domain()));
27 ddc::device_for_each(tensor.domain(), [&](auto component) {
28 tensor.mem(component) = evaluate(component);
29 });
30 return OwningTensor(tensor, std::move(storage));
31}
32
33template <class Field, class Evaluate>
34KOKKOS_FUNCTION auto pointwise_tensor(Evaluate const& evaluate)
35{
36 return pointwise_tensor<typename Field::indices_domain_t, typename Field::memory_space>(
37 evaluate);
38}
39
40// Source zero denotes stored samples. For a single rule, source one denotes
41// its evaluation at the requested exterior point. For per-face rules, sources
42// 1 + 2*axis and 2 + 2*axis denote the lower and upper face evaluations.
43// The spatial domain contains the nearest node and its inward neighbours;
44// rule values occupy the nearest node in their source plane.
45struct ExtrapolationSource
46{
47};
48
49template <class Domain, class Element>
50KOKKOS_FUNCTION auto extrapolation_sample(Domain const& domain, Element element)
51{
53 sample(element);
54 return misc::clamp_to_domain(domain, sample).storage_element();
55}
56
57template <std::size_t Sources = 2, class... Grid>
58KOKKOS_FUNCTION auto make_extrapolation_basis(
59 ddc::DiscreteDomain<Grid...> const& domain,
60 auto element)
61{
62 typename ddc::DiscreteDomain<Grid...>::discrete_element_type front
63 = extrapolation_sample(domain, element);
64 typename ddc::DiscreteDomain<Grid...>::discrete_vector_type extent = domain.extents();
65 for (std::size_t dim = 0; dim < sizeof...(Grid); ++dim) {
66 if (ddc::detail::array(extent)[dim] > 1) {
67 ddc::detail::array(extent)[dim] = 2;
68 if (ddc::detail::array(front)[dim] == ddc::detail::array(domain.back())[dim])
69 --ddc::detail::array(front)[dim];
70 }
71 }
72 ddc::DiscreteDomain<Grid..., ExtrapolationSource> const
73 patch(ddc::DiscreteDomain<Grid...>(front, extent),
74 ddc::DiscreteDomain<ExtrapolationSource>(
75 ddc::DiscreteElement<ExtrapolationSource>(0),
76 ddc::DiscreteVector<ExtrapolationSource>(Sources)));
77 std::array<double, (1UL << sizeof...(Grid)) * Sources> storage {};
78 Tensor<double,
79 ddc::DiscreteDomain<Grid..., ExtrapolationSource>,
80 Kokkos::layout_right,
81 Kokkos::HostSpace>
82 tensor(ddc::ChunkSpan<
83 double,
84 ddc::DiscreteDomain<Grid..., ExtrapolationSource>,
85 Kokkos::layout_right,
86 Kokkos::HostSpace>(storage.data(), patch));
87 return OwningTensor(tensor, std::move(storage));
88}
89
90template <class Basis, class Stored, class Evaluated>
91KOKKOS_FUNCTION double contract_extrapolation_basis(
92 Basis const& basis,
93 Stored stored,
94 Evaluated evaluated)
95{
96 using Spatial = misc::convert_type_seq_to_t<
97 ddc::DiscreteDomain,
98 ddc::type_seq_remove_t<
99 ddc::to_type_seq_t<typename Basis::discrete_domain_type>,
100 ddc::TypeSeq<ExtrapolationSource>>>;
101 double result = 0.0;
102 ddc::device_for_each(basis.domain(), [&](auto entry) {
103 double const weight = basis.mem(entry);
104 if (weight != 0.0) {
105 std::size_t const source = entry.template uid<ExtrapolationSource>();
106 result += weight
107 * (source == 0 ? stored(typename Spatial::discrete_element_type(entry))
108 : evaluated(source));
109 }
110 });
111 return result;
112}
113template <class Element>
114KOKKOS_FUNCTION auto storage_element(Element element)
115{
116 if constexpr (misc::Specialization<Element, misc::SignedDiscreteElement>)
117 return element.storage_element();
118 else
119 return element;
120}
121
122template <class Rule>
123KOKKOS_FUNCTION bool is_interface(Rule const& rule)
124{
125 if constexpr (requires { rule.is_interface(); })
126 return rule.is_interface();
127 else if constexpr (requires { Rule::IS_INTERFACE; })
128 return Rule::IS_INTERFACE;
129 else
130 return false;
131}
132template <class Rule>
133KOKKOS_FUNCTION bool is_dirichlet(Rule const& rule)
134{
135 if constexpr (requires { rule.is_dirichlet(); })
136 return rule.is_dirichlet();
137 else if constexpr (requires { Rule::IS_DIRICHLET; })
138 return Rule::IS_DIRICHLET;
139 else
140 return false;
141}
142template <class Rule>
143KOKKOS_FUNCTION bool shared_boundary(Rule const& rule)
144{
145 if constexpr (requires { rule.shared_boundary(); })
146 return rule.shared_boundary();
147 else if constexpr (requires { rule.boundary_map.shared_boundary; })
148 return rule.boundary_map.shared_boundary;
149 else
150 return true;
151}
152template <class... Grid, class Entry>
153KOKKOS_FUNCTION ddc::DiscreteElement<Grid...> stencil_sample(
154 ddc::DiscreteElement<Grid...> center,
155 Entry entry)
156{
157 ((center.template uid<Grid>() += entry.template uid<Grid>() - 1), ...);
158 return center;
159}
160
161template <class Rule, class Field, class Element, class Component>
162KOKKOS_FUNCTION double extrapolation_source_value(
163 Rule const& rule,
164 Field const& field,
165 Element element,
166 Component component)
167{
168 if constexpr (requires { rule.source_value(); })
169 return rule.source_value();
170 else if constexpr (requires { rule.prescribed_value; })
171 return rule.prescribed_value;
172 else if constexpr (requires { rule.exterior_value; })
173 return rule.exterior_value;
174 else if constexpr (requires { Rule::STORED_SAMPLES_ONLY; })
175 return 0.0;
176 else
177 return rule(field, element).mem(component);
178}
179} // namespace detail
180} // namespace sil::tensor
KOKKOS_FUNCTION Elem clamp_to_domain(BatchDomain const &batch_domain, Elem const &elem)
typename detail::ConvertTypeSeqTo< T, Seq >::type convert_type_seq_to_t
Tensor(ddc::Chunk< ElementType, SupportType, Allocator >) -> Tensor< ElementType, SupportType, Kokkos::layout_right, typename Allocator::memory_space >
OwningTensor(TensorType, Storage &&) -> OwningTensor< TensorType, Storage >
detail::TensorAccessorForDomain< Dom >::type tensor_accessor_for_domain_t