SimiLie
Loading...
Searching...
No Matches
tensor/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 <array>
8#include <concepts>
9#include <cstddef>
10#include <type_traits>
11#include <utility>
12#include <vector>
13
14#include <ddc/ddc.hpp>
15
16namespace sil::tensor {
17
18template <class ElementType, class SupportType, class LayoutStridedPolicy, class MemorySpace>
19class Tensor;
20
21namespace detail {
22struct DimensionConcept
23{
24};
25
26struct GridConcept : ddc::UniformPointSampling<DimensionConcept>
27{
28};
29
30template <class Index>
31using FieldConcept = Tensor<
32 double,
33 ddc::DiscreteDomain<GridConcept, Index>,
34 Kokkos::layout_right,
35 Kokkos::HostSpace>;
36
37struct IndexTensorConcept
38{
39 using element_type = double;
40};
41
42struct IndexAccessConcept
43{
44 template <class Tensor, class Element>
45 double operator()(Tensor const& tensor, Element element) const;
46};
47} // namespace detail
48
49// All indices expose the same metadata and access operation. Explicit storage
50// additionally provides a direct map between access IDs and memory IDs.
51template <class Index>
52concept TensorIndexConcept = requires(
53 detail::IndexTensorConcept tensor,
54 ddc::DiscreteElement<Index> element,
55 detail::IndexAccessConcept access) {
56 requires Index::is_tensor_index;
57 typename std::bool_constant<Index::is_explicitely_stored_tensor>;
58 typename Index::subindices_domain_t;
59 { Index::subindices_domain() } -> std::same_as<typename Index::subindices_domain_t>;
60 { Index::rank() } -> std::same_as<std::size_t>;
61 { Index::size() } -> std::same_as<std::size_t>;
62 { Index::mem_size() } -> std::same_as<std::size_t>;
63 { Index::access_size() } -> std::same_as<std::size_t>;
64 typename std::integral_constant<std::size_t, Index::rank()>;
65 typename std::integral_constant<std::size_t, Index::size()>;
66 typename std::integral_constant<std::size_t, Index::mem_size()>;
67 typename std::integral_constant<std::size_t, Index::access_size()>;
68 {
69 Index::template process_access<
70 detail::IndexTensorConcept,
71 ddc::DiscreteElement<Index>,
72 Index>(access, tensor, element)
73 } -> std::same_as<double>;
74 requires(!Index::is_explicitely_stored_tensor || requires(std::size_t id) {
75 { Index::access_id_to_mem_id(id) } -> std::same_as<std::size_t>;
76 {
77 Index::mem_id_to_canonical_natural_ids(id)
78 } -> std::same_as<std::array<std::size_t, Index::rank()>>;
79 // Natural indices take one ID; composite indices take subindex IDs.
80 requires (requires(std::array<std::size_t, Index::subindices_domain_t::rank()> const& ids) {
81 { Index::mem_id(ids) } -> std::same_as<std::size_t>;
82 { Index::access_id(ids) } -> std::same_as<std::size_t>;
83 } || requires {
84 requires Index::is_tensor_natural_index;
85 { Index::mem_id(id) } -> std::same_as<std::size_t>;
86 { Index::access_id(id) } -> std::same_as<std::size_t>;
87 });
88 });
89};
90
91template <class Index, class Dimension>
92concept NaturalTensorIndexConcept = TensorIndexConcept<Index> && requires(std::size_t id) {
93 requires Index::is_explicitely_stored_tensor;
94 requires Index::is_tensor_natural_index;
95 typename Index::type_seq_dimensions;
96 { Index::template mem_id<Dimension>() } -> std::same_as<std::size_t>;
97 { Index::mem_id(id) } -> std::same_as<std::size_t>;
98 { Index::access_id(id) } -> std::same_as<std::size_t>;
99};
100
101template <class Index>
104 && requires(std::array<std::size_t, Index::subindices_domain_t::rank()> const& ids) {
105 requires(!Index::is_explicitely_stored_tensor);
106 { Index::access_id(ids) } -> std::same_as<std::size_t>;
107 {
108 Index::mem_lin_comb(ids)
109 } -> std::same_as<std::pair<std::vector<double>, std::vector<std::size_t>>>;
110 };
111
112template <class Rule, class Field, class Element>
113concept ExtrapolationRuleConcept = requires(
114 Rule const& rule,
115 Field const& field,
116 typename Field::non_indices_domain_t domain,
117 Element element) {
118 rule.value(domain, element).domain();
119 { rule(field, element).domain() } -> std::same_as<typename Field::indices_domain_t>;
120};
121
122template <class Rules, class Field, class Element>
124 = ExtrapolationRuleConcept<Rules, Field, Element> && requires(Rules const& rules) {
125 requires std::is_lvalue_reference_v<
126 decltype(rules.template boundary_rule<0, false>())>;
127 requires std::is_const_v<
128 std::remove_reference_t<decltype(rules.template boundary_rule<0, false>())>>;
129 requires std::is_lvalue_reference_v<
130 decltype(rules.template boundary_rule<0, true>())>;
131 requires std::is_const_v<
132 std::remove_reference_t<decltype(rules.template boundary_rule<0, true>())>>;
133 };
134
135} // namespace sil::tensor
Tensor(ddc::Chunk< ElementType, SupportType, Allocator >) -> Tensor< ElementType, SupportType, Kokkos::layout_right, typename Allocator::memory_space >