9#include <similie/tensor/metric.hpp>
10#include <similie/tensor/tensor_indices/character.hpp>
14#include "local_chain.hpp"
16namespace sil::exterior::detail {
18using GridConcept = tensor::detail::GridConcept;
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>>;
31 ddc::DiscreteDomain<GridConcept, Index>,
41struct EvaluatorConcept
43 template <
class Element,
class Component>
44 KOKKOS_FUNCTION
double operator()(Element element, Component component)
const;
64 Evaluator
const& evaluator,
66 LowerChain
const& lower_chain,
68 NaturalElement natural_element) {
69 Operator::value(chain, lower_chain, element, natural_element);
71 Operator::operator()(output, evaluator, chain, lower_chain, element)
72 } -> std::same_as<void>;
90 Position
const& position,
92 NaturalElement natural_element) {
93 operation.value(metric, position, element);
95 operation.value(metric, position, element, natural_element)
96 } -> std::same_as<double>;
97 { operation(output, input, metric, position, element) } -> std::same_as<void>;
106 class NaturalElement>
110 Output
const& output,
112 Metric
const& metric,
114 NaturalElement natural_element) {
115 requires Operator::input_is_form;
116 requires Operator::output_is_form;
117 operation.value(metric, element);
119 operation.value(metric, element, natural_element)
120 } -> std::same_as<double>;
122 operation(output, input, metric, element)
123 } -> std::same_as<void>;
130template <
class Operator>
131constexpr bool input_is_form = [] {
132 if constexpr (
requires { Operator::input_is_form; })
133 return Operator::input_is_form;
137template <
class Operator>
138constexpr bool output_is_form = [] {
139 if constexpr (
requires { Operator::output_is_form; })
140 return Operator::output_is_form;
146template <
class Operator,
class Input>
149template <
class Operator,
class Output>
153template <
class Operator,
class Output,
class Input,
class... Arguments>
155 Operator
const& operation,
156 Output
const& output,
158 Arguments... arguments) {
159 { operation(output, input, arguments...) } -> std::same_as<void>;
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>;
168template <
class Storage,
class Output,
class Input = Output>
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>;
178template <
class Operator,
class Output,
class Input = Output>
181template <
class Storage,
class Output,
class Input = Output>
184template <
class Storage,
class Output,
class First,
class Second>
186 Storage
const& storage,
187 typename Storage::execution_space
const& exec,
188 Output
const& output,
190 Second
const& second) {
191 { storage.apply(exec, output, first, second) } -> std::same_as<Output>;
194template <
class Operator,
class Output,
class First,
class Second>
196 Operator
const& operation,
197 Output
const& output,
199 Second
const& second) {
200 { operation(output, first, second) } -> std::same_as<Output>;
203template <
class Operator,
class Output,
class Input = Output>
206 typename Operator::staged_storage_type;
210template <
class Operator,
class Output,
class Input = Output>
213template <
class Operator,
class Output,
class First,
class Second>
217 typename Operator::staged_storage_type;
219 typename Operator::staged_storage_type,
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 >