SimiLie
Loading...
Searching...
No Matches
exterior/concepts.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 <concepts>
8
9#include <similie/tensor/metric.hpp>
10#include <similie/tensor/tensor_indices/character.hpp>
11
12#include "cochain.hpp"
13#include "form.hpp"
14#include "local_chain.hpp"
15
16namespace sil::exterior::detail {
17
18using GridConcept = tensor::detail::GridConcept;
19using DirectionConcept
20 = tensor::Covariant<tensor::TensorNaturalIndex<tensor::detail::DimensionConcept>>;
21using ScalarConcept = tensor::Covariant<tensor::ScalarIndex>;
22using MetricIndexConcept = tensor::TensorIdentityIndex<
23 tensor::Covariant<tensor::MetricIndex1<tensor::detail::DimensionConcept>>,
24 tensor::Covariant<tensor::MetricIndex2<tensor::detail::DimensionConcept>>>;
25using PositionIndexConcept
26 = tensor::Contravariant<tensor::TensorNaturalIndex<tensor::detail::DimensionConcept>>;
27
28template <class Index>
29using FieldConcept = tensor::Tensor<
30 double,
31 ddc::DiscreteDomain<GridConcept, Index>,
32 Kokkos::layout_right,
33 Kokkos::HostSpace>;
34
35template <class Index>
36using CochainFieldConcept = Cochain<FieldConcept<Index>>;
37
38template <class Index>
39using FormFieldConcept = Form<FieldConcept<Index>>;
40
41struct EvaluatorConcept
42{
43 template <class Element, class Component>
44 KOKKOS_FUNCTION double operator()(Element element, Component component) const;
45};
46
47} // namespace sil::exterior::detail
48
49
50namespace sil::exterior {
51
52template <
53 class Operator,
54 class Output,
55 class Evaluator,
56 class Chain,
57 class LowerChain,
58 class Element,
59 class NaturalElement>
62 && requires(
63 Output const& output,
64 Evaluator const& evaluator,
65 Chain const& chain,
66 LowerChain const& lower_chain,
67 Element element,
68 NaturalElement natural_element) {
69 Operator::value(chain, lower_chain, element, natural_element);
70 {
71 Operator::operator()(output, evaluator, chain, lower_chain, element)
72 } -> std::same_as<void>;
73 };
74
75template <
76 class Operator,
77 class Output,
78 class Input,
79 class Metric,
80 class Position,
81 class Element,
82 class NaturalElement>
85 && requires(
86 Operator operation,
87 Output const& output,
88 Input const& input,
89 Metric const& metric,
90 Position const& position,
91 Element element,
92 NaturalElement natural_element) {
93 operation.value(metric, position, element);
94 {
95 operation.value(metric, position, element, natural_element)
96 } -> std::same_as<double>;
97 { operation(output, input, metric, position, element) } -> std::same_as<void>;
98 };
99
100template <
101 class Operator,
102 class Output,
103 class Input,
104 class Metric,
105 class Element,
106 class NaturalElement>
108 && requires(
109 Operator operation,
110 Output const& output,
111 Input const& input,
112 Metric const& metric,
113 Element element,
114 NaturalElement natural_element) {
115 requires Operator::input_is_form;
116 requires Operator::output_is_form;
117 operation.value(metric, element);
118 {
119 operation.value(metric, element, natural_element)
120 } -> std::same_as<double>;
121 {
122 operation(output, input, metric, element)
123 } -> std::same_as<void>;
124 };
125
126template <class T>
128
129namespace detail {
130template <class Operator>
131constexpr bool input_is_form = [] {
132 if constexpr (requires { Operator::input_is_form; })
133 return Operator::input_is_form;
134 else
135 return false;
136}();
137template <class Operator>
138constexpr bool output_is_form = [] {
139 if constexpr (requires { Operator::output_is_form; })
140 return Operator::output_is_form;
141 else
142 return false;
143}();
144} // namespace detail
145
146template <class Operator, class Input>
147concept OperatorInputType = (detail::input_is_form<Operator> && FormType<Input>)
148 || (!detail::input_is_form<Operator> && CochainType<Input>);
149template <class Operator, class Output>
150concept OperatorOutputType = (detail::output_is_form<Operator> && FormType<Output>)
151 || (!detail::output_is_form<Operator> && CochainType<Output>);
152
153template <class Operator, class Output, class Input, class... Arguments>
154concept LocalOperatorConcept = requires(
155 Operator const& operation,
156 Output const& output,
157 Input const& input,
158 Arguments... arguments) {
159 { operation(output, input, arguments...) } -> std::same_as<void>;
160};
161
162template <class Operator, class Output, class Input = Output>
164 = requires(Operator const& operation, Output const& output, Input const& input) {
165 { operation(output, input) } -> std::same_as<Output>;
166 };
167
168template <class Storage, class Output, class Input = Output>
169concept StagingStorageConcept = requires(
170 Storage const& storage,
171 typename Storage::execution_space const& exec,
172 Output const& output,
173 Input const& input) {
174 { storage.apply(exec, output, input) } -> std::same_as<Output>;
175};
176
177// Explicit arity contracts. The historical concepts above describe linear maps.
178template <class Operator, class Output, class Input = Output>
180
181template <class Storage, class Output, class Input = Output>
183
184template <class Storage, class Output, class First, class Second>
186 Storage const& storage,
187 typename Storage::execution_space const& exec,
188 Output const& output,
189 First const& first,
190 Second const& second) {
191 { storage.apply(exec, output, first, second) } -> std::same_as<Output>;
192};
193
194template <class Operator, class Output, class First, class Second>
196 Operator const& operation,
197 Output const& output,
198 First const& first,
199 Second const& second) {
200 { operation(output, first, second) } -> std::same_as<Output>;
201};
202
203template <class Operator, class Output, class Input = Output>
209
210template <class Operator, class Output, class Input = Output>
212
213template <class Operator, class Output, class First, class Second>
217 typename Operator::staged_storage_type;
219 typename Operator::staged_storage_type,
220 Output,
221 First,
222 Second>;
223 };
224
225} // namespace sil::exterior
Chain(Head, Tail...) -> Chain< typename Head::value_type, typename Head::array_layout, typename Head::memory_space >
Cochain(Tensor const &) -> Cochain< Tensor >
Form(Coefficients const &) -> Form< Coefficients >
Tensor(ddc::Chunk< ElementType, SupportType, Allocator >) -> Tensor< ElementType, SupportType, Kokkos::layout_right, typename Allocator::memory_space >