SimiLie
Loading...
Searching...
No Matches
stencil_assembly.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 <limits>
8
9#include <similie/tensor/owning_tensor.hpp>
10
11#include "minimize_strong_formulation_residual.hpp"
12
13namespace similie::solvers {
15{
16 std::shared_ptr<gko::matrix::Csr<double, gko::int32>> matrix;
17 Kokkos::View<double**> rhs;
18 Kokkos::View<double*> row_scales;
19};
20} // namespace similie::solvers
21
22namespace similie::solvers::detail {
23struct StencilColumn
24{
25};
26
27template <std::size_t Capacity>
28KOKKOS_FUNCTION auto make_row_stencil()
29{
30 std::array<double, Capacity> storage {};
31 ddc::DiscreteDomain<StencilColumn> const
32 domain(ddc::DiscreteElement<StencilColumn>(0),
33 ddc::DiscreteVector<StencilColumn>(Capacity));
35 double,
36 ddc::DiscreteDomain<StencilColumn>,
37 Kokkos::layout_right,
38 Kokkos::DefaultExecutionSpace::memory_space>
39 tensor(ddc::ChunkSpan<
40 double,
41 ddc::DiscreteDomain<StencilColumn>,
42 Kokkos::layout_right,
43 Kokkos::DefaultExecutionSpace::memory_space>(storage.data(), domain));
44 return sil::tensor::OwningTensor(tensor, std::move(storage));
45}
46
47template <class Weights, class Indices>
48KOKKOS_FUNCTION bool add_stencil_coefficient(
49 Weights const& weights,
50 Indices indices,
51 std::size_t& count,
52 std::size_t column,
53 double weight)
54{
55 if (weight == 0.0)
56 return true;
57 std::size_t i = 0;
58 for (; i < count; ++i)
59 if (indices[i] == column)
60 break;
61 if (i == count) {
62 if (count == weights.domain().size())
63 return false;
64 indices[count++] = column;
65 }
66 weights.mem(ddc::DiscreteElement<StencilColumn>(i)) += weight;
67 return true;
68}
69
70// Native tensor coefficients and their global column mapping are kept apart.
71// RHS-only assembly allocates neither coefficient rows nor sparse matrix arrays.
72template <std::size_t Capacity>
73struct RowAssembly
74{
75 static_assert(Capacity > 0);
76 std::size_t column_count;
77 Kokkos::View<std::size_t**, Kokkos::LayoutRight> columns;
78 Kokkos::View<double**, Kokkos::LayoutRight> weights;
79 Kokkos::View<std::size_t*> counts;
80 Kokkos::View<double*> constants, lower, upper;
81 Kokkos::View<int> errors;
82
83 explicit RowAssembly(std::size_t size, bool matrix = true, std::size_t input_size = 0)
84 : column_count(input_size == 0 ? size : input_size)
85 , columns("dec_columns", matrix ? size : 0, Capacity)
86 , weights("dec_weights", matrix ? size : 0, Capacity)
87 , counts("dec_counts", matrix ? size : 0)
88 , constants("dec_constants", size)
89 , lower("dirichlet_lower", size)
90 , upper("dirichlet_upper", size)
91 , errors("dec_errors")
92 {
93 if (size == 0 || size > std::size_t(std::numeric_limits<int>::max()) / Capacity
94 || column_count > std::size_t(std::numeric_limits<int>::max()))
95 throw std::invalid_argument("differential matrix exceeds 32-bit CSR capacity");
96 Kokkos::deep_copy(lower, std::numeric_limits<double>::infinity());
97 Kokkos::deep_copy(upper, -std::numeric_limits<double>::infinity());
98 }
99
100 KOKKOS_FUNCTION void fail(int code) const
101 {
102 Kokkos::atomic_fetch_or(&errors(), code);
103 }
104
105 KOKKOS_FUNCTION auto coefficients(std::size_t row) const
106 {
107 ddc::DiscreteDomain<StencilColumn> const
108 domain(ddc::DiscreteElement<StencilColumn>(0),
109 ddc::DiscreteVector<StencilColumn>(Capacity));
110 return sil::tensor::Tensor<
111 double,
112 ddc::DiscreteDomain<StencilColumn>,
113 Kokkos::layout_right,
114 Kokkos::DefaultExecutionSpace::memory_space>(
115 ddc::ChunkSpan<
116 double,
117 ddc::DiscreteDomain<StencilColumn>,
118 Kokkos::layout_right,
119 Kokkos::DefaultExecutionSpace::memory_space>(&weights(row, 0), domain));
120 }
121
122 KOKKOS_FUNCTION void add(std::size_t row, std::size_t column, double weight) const
123 {
124 if (column >= column_count) {
125 fail(4);
126 return;
127 }
128 if (!add_stencil_coefficient(
129 coefficients(row),
130 &columns(row, 0),
131 counts(row),
132 column,
133 weight))
134 fail(2);
135 }
136
137 KOKKOS_FUNCTION void prescribe(std::size_t index, double value) const
138 {
139 if (index >= constants.extent(0) || index >= column_count || !Kokkos::isfinite(value)) {
140 fail(8);
141 return;
142 }
143 Kokkos::atomic_min(&lower(index), value);
144 Kokkos::atomic_max(&upper(index), value);
145 }
146
147 void check() const
148 {
149 int error = 0;
150 Kokkos::deep_copy(error, errors);
151 if (error & 2)
152 throw std::runtime_error("differential stencil exceeds its column capacity");
153 if (error & 8)
154 throw std::runtime_error("incompatible or invalid Dirichlet constraints");
155 if (error)
156 throw std::runtime_error("invalid or empty differential row");
157 }
158
159 Kokkos::View<double**> finalize_rhs(
160 Kokkos::DefaultExecutionSpace const& exec,
161 Kokkos::View<double*> const& scales) const
162 {
163 check();
164 RowAssembly const data = *this;
165 Kokkos::View<double**> rhs("dec_rhs", constants.extent(0), 1);
166 Kokkos::parallel_for(
167 "finish_dec_rhs",
168 Kokkos::RangePolicy(exec, 0, constants.extent(0)),
169 KOKKOS_LAMBDA(std::size_t row) {
170 if (Kokkos::isfinite(data.lower(row))) {
171 if (Kokkos::abs(data.upper(row) - data.lower(row))
172 > 1.e-12 * (1.0 + Kokkos::abs(data.lower(row))))
173 data.fail(8);
174 data.constants(row) = -data.lower(row);
175 }
176 if (!Kokkos::isfinite(data.constants(row)))
177 data.fail(4);
178 rhs(row, 0) = -data.constants(row) / scales(row);
179 });
180 exec.fence("scalar DEC rhs ready");
181 check();
182 return rhs;
183 }
184
185 AssembledLinearSystem finalize(
186 Kokkos::DefaultExecutionSpace const& exec,
187 bool normalize,
188 bool allow_empty_rows = false) const
189 {
190 check();
191 RowAssembly const data = *this;
192 Kokkos::View<int*> offsets("dec_offsets", constants.extent(0) + 1);
193 Kokkos::View<double*> scales("dec_row_scales", constants.extent(0));
194 Kokkos::parallel_for(
195 "finish_dec_rows",
196 Kokkos::RangePolicy(exec, 0, constants.extent(0)),
197 KOKKOS_LAMBDA(std::size_t row) {
198 if (Kokkos::isfinite(data.lower(row))) {
199 data.counts(row) = 1;
200 data.columns(row, 0) = row;
201 data.weights(row, 0) = 1.0;
202 }
203 double scale = 0.0;
204 std::size_t count = 0;
205 for (std::size_t i = 0; i < data.counts(row); ++i) {
206 double const weight = data.weights(row, i);
207 if (!Kokkos::isfinite(weight))
208 data.fail(4);
209 if (weight != 0.0) {
210 data.columns(row, count) = data.columns(row, i);
211 data.weights(row, count++) = weight;
212 scale = Kokkos::max(scale, Kokkos::abs(weight));
213 }
214 }
215 data.counts(row) = count;
216 if (!(scale > 0.0)) {
217 if (allow_empty_rows)
218 scale = 1.0;
219 else
220 data.fail(4);
221 }
222 scales(row) = normalize ? scale : 1.0;
223 for (std::size_t i = 0; i < count; ++i)
224 data.weights(row, i) /= scales(row);
225 });
226 int total = 0;
227 Kokkos::parallel_scan(
228 "scan_dec_rows",
229 Kokkos::RangePolicy(exec, 0, constants.extent(0) + 1),
230 KOKKOS_LAMBDA(std::size_t row, int& sum, bool final) {
231 if (final)
232 offsets(row) = sum;
233 if (row < data.constants.extent(0))
234 sum += static_cast<int>(data.counts(row));
235 },
236 total);
237 check();
238 Kokkos::View<int*> csr_columns("dec_csr_columns", total);
239 Kokkos::View<double*> values("dec_values", total);
240 Kokkos::parallel_for(
241 "pack_dec_rows",
242 Kokkos::RangePolicy(exec, 0, constants.extent(0)),
243 KOKKOS_LAMBDA(std::size_t row) {
244 for (std::size_t i = 0; i < data.counts(row); ++i) {
245 csr_columns(offsets(row) + i) = static_cast<int>(data.columns(row, i));
246 values(offsets(row) + i) = data.weights(row, i);
247 }
248 });
249 Kokkos::View<double**> const rhs = finalize_rhs(exec, scales);
250 auto const executor = gko::ext::kokkos::create_executor(exec);
251 gko::array<double> matrix_values(executor, values.extent(0));
252 gko::array<gko::int32> matrix_columns(executor, csr_columns.extent(0)),
253 matrix_offsets(executor, offsets.extent(0));
254 executor->copy_from(
255 executor.get(),
256 values.extent(0),
257 values.data(),
258 matrix_values.get_data());
259 executor->copy_from(
260 executor.get(),
261 csr_columns.extent(0),
262 csr_columns.data(),
263 matrix_columns.get_data());
264 executor->copy_from(
265 executor.get(),
266 offsets.extent(0),
267 offsets.data(),
268 matrix_offsets.get_data());
269 std::shared_ptr<gko::matrix::Csr<double, gko::int32>> matrix
270 = gko::matrix::Csr<double, gko::int32>::
271 create(executor,
272 gko::dim<2>(constants.extent(0), column_count),
273 std::move(matrix_values),
274 std::move(matrix_columns),
275 std::move(matrix_offsets));
276 matrix->sort_by_column_index();
277 return {matrix, rhs, scales};
278 }
279};
280} // namespace similie::solvers::detail
OwningTensor(TensorType, Storage &&) -> OwningTensor< TensorType, Storage >
std::shared_ptr< gko::matrix::Csr< double, gko::int32 > > matrix