SimiLie
Loading...
Searching...
No Matches
spatial_operator_storage.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 <similie/exterior/stencil.hpp>
8
9namespace sil::exterior::detail {
10
11template <
12 class Operator,
13 class Index,
14 class Source,
15 class Target,
16 std::size_t Radius,
17 class Tensor,
18 class Exec = typename Tensor::memory_space::execution_space,
19 bool EqualDomains = false>
20class LinearSpatialOperatorStorage
21{
22 using Domain = typename Tensor::non_indices_domain_t;
23 StencilStorage<Index, Source, Target, Radius, Domain, typename Tensor::memory_space> m_stencils;
24
25public:
26 using execution_space = Exec;
27 template <class OtherExec>
28 using rebind = LinearSpatialOperatorStorage<
29 Operator,
30 Index,
31 Source,
32 Target,
33 Radius,
34 Tensor,
35 OtherExec,
36 EqualDomains>;
37
38 template <class Metric, class Position, class Rules = tensor::ZeroExtrapolationRule>
39 requires requires(
40 Exec const& exec,
41 Tensor const& input,
42 Metric const& metric,
43 Position const& position,
44 typename Domain::discrete_element_type element,
45 Rules const& rules) {
46 Operator::value(Operator::geometry(exec, metric, position), input, element, rules);
47 }
48 static LinearSpatialOperatorStorage build(
49 Exec const& exec,
50 Tensor const& input,
51 Metric const& metric,
52 Position const& position,
53 Rules const& rules = {})
54 {
55 LinearSpatialOperatorStorage result;
56 result.m_stencils = cache_stencils<
57 Operator,
58 Index,
59 Source,
60 Target,
61 Radius>(exec, input, Operator::geometry(exec, metric, position), rules);
62 return result;
63 }
64
65 template <
66 class Output,
67 class Metric,
68 class Position,
69 class Primal = tensor::ClampExtrapolationRule,
70 class Dual = tensor::ZeroExtrapolationRule>
71 requires requires(
72 Exec const& exec,
73 Tensor const& input,
74 Metric const& metric,
75 Position const& position,
76 typename Domain::discrete_element_type element,
77 Primal const& primal,
78 Dual const& dual) {
79 Operator::
80 value(Operator::geometry(exec, metric, position), input, element, primal, dual);
81 }
82 static LinearSpatialOperatorStorage build(
83 Exec const& exec,
84 Output const& output,
85 Tensor const& input,
86 Metric const& metric,
87 Position const& position,
88 Primal const& primal = {},
89 Dual const& dual = {})
90 {
91 if constexpr (EqualDomains) {
92 if (input.non_indices_domain() != output.non_indices_domain())
93 throw std::invalid_argument(
94 "Staged operator requires equal input/output spatial domains");
95 }
96 LinearSpatialOperatorStorage result;
97 result.m_stencils = cache_stencils<
98 Operator,
99 Index,
100 Source,
101 Target,
102 Radius>(exec, input, Operator::geometry(exec, metric, position), primal, dual);
103 return result;
104 }
105
106 template <ExteriorFieldType Output>
107 Output apply(Exec const& exec, Output const& output, Tensor const& input) const
108 {
109 if constexpr (EqualDomains) {
110 if (output.non_indices_domain() != m_stencils.domain)
111 throw std::invalid_argument("Staged operator output domain changed");
112 }
113 return apply_stencils<Index, Source, Target, Radius>(exec, output, input, m_stencils);
114 }
115};
116
117template <
118 class Operator,
119 class Index,
120 class Source,
121 class Target,
122 std::size_t Radius,
123 class Tensor,
124 class Exec = typename Tensor::memory_space::execution_space,
125 bool EqualDomains = false>
126using SpatialOperatorStorage = LinearSpatialOperatorStorage<
127 Operator,
128 Index,
129 Source,
130 Target,
131 Radius,
132 Tensor,
133 Exec,
134 EqualDomains>;
135
136} // namespace sil::exterior::detail
Tensor(ddc::Chunk< ElementType, SupportType, Allocator >) -> Tensor< ElementType, SupportType, Kokkos::layout_right, typename Allocator::memory_space >