SimiLie
Loading...
Searching...
No Matches
multidomains/laplacian.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/laplacian/laplacian.hpp>
8#include <similie/solvers/stencil_assembly.hpp>
9
10#include "differential_operator.hpp"
11#include "indexed_scalar_field.hpp"
12#include "multidomains.hpp"
13
14namespace sil::multidomains {
21template <class Direction, class Domains, class Diffusivity>
23 Domains const& domains,
24 Diffusivity diffusivity,
25 double jump_scale = 1.0)
26{
27 return domains.transform_data([&](std::size_t id, auto const& data) {
28 double const coefficient = diffusivity(data.physics);
29 if (!(coefficient > 0.0) || !std::isfinite(coefficient))
30 throw std::invalid_argument("scalar diffusivity must be finite and positive");
31 auto const field = domains.field(id);
34 field,
35 domains.extrapolation_rules(id, jump_scale)),
36 data.geometry,
37 domains.template extrapolation_rules<sil::multidomains::FieldRole::Geometry>(id),
38 domains.template boundary_rules<sil::multidomains::FieldRole::Flux>(id),
39 coefficient);
40 return sil::multidomains::domain_data(data.field, data.geometry, data.physics, flux);
41 });
42}
43
44namespace detail {
45template <std::size_t Axis, bool Upper, std::size_t Capacity, class Field, class Primal>
46void prescribe_face(
47 Kokkos::DefaultExecutionSpace const& exec,
48 RowAssembly<Capacity> system,
49 Field const& field,
50 Primal const& primal)
51{
52 if (sil::tensor::detail::is_dirichlet(primal.template boundary_rule<Axis, Upper>())) {
53 auto nodes = field.non_indices_domain();
54 auto front = nodes.front();
55 auto extent = nodes.extents();
56 ddc::detail::array(front)[Axis]
57 = ddc::detail::array(Upper ? nodes.back() : nodes.front())[Axis];
58 ddc::detail::array(extent)[Axis] = 1;
59 // The final endpoint of a physical face can belong to a donor domain.
60 [&]<std::size_t... Tangent>(std::index_sequence<Tangent...>) {
61 (
62 [&] {
63 if constexpr (Tangent != Axis)
64 if (sil::tensor::detail::is_interface(
65 primal.template boundary_rule<Tangent, true>())
66 && !sil::tensor::detail::shared_boundary(
67 primal.template boundary_rule<Tangent, true>()))
68 ++ddc::detail::array(extent)[Tangent];
69 }(),
70 ...);
71 }(std::make_index_sequence<
72 ddc::type_seq_size_v<ddc::to_type_seq_t<typename Field::non_indices_domain_t>>> {});
73 nodes = typename Field::non_indices_domain_t(front, extent);
74 ddc::parallel_for_each(
75 "prescribe_dec_face",
76 exec,
77 nodes,
78 KOKKOS_LAMBDA(typename Field::non_indices_domain_t::discrete_element_type elem) {
79 std::array<std::size_t, Capacity> indices {};
80 auto weights = similie::solvers::detail::make_row_stencil<Capacity>();
81 std::size_t count = 0;
82 double constant = 0.0;
83 detail::visit_rule_basis(
84 primal,
85 field,
86 elem,
87 ddc::DiscreteElement<typename Field::component_type>(0),
88 1.0,
89 [&](auto const& donor, auto sample, auto component, double weight) {
90 if (!similie::solvers::detail::add_stencil_coefficient(
91 weights,
92 indices.data(),
93 count,
94 donor.global_index(sample, component),
95 weight))
96 system.fail(2);
97 },
98 [&](double value) { constant += value; });
99 std::size_t nonzero = 0;
100 std::size_t selected = 0;
101 for (std::size_t i = 0; i < count; ++i)
102 if (weights.mem(
103 ddc::DiscreteElement<similie::solvers::detail::StencilColumn>(
104 i))
105 != 0.0) {
106 ++nonzero;
107 selected = i;
108 }
109 auto exterior = elem;
110 if constexpr (Upper)
111 ++ddc::detail::array(exterior)[Axis];
112 else
113 --ddc::detail::array(exterior)[Axis];
114 auto const& face = primal.template boundary_rule<Axis, Upper>();
115 auto const& boundary = [&]() -> auto const& {
116 if constexpr (requires { face.boundary; })
117 return face.boundary;
118 else
119 return face;
120 }();
121 double const value = sil::tensor::detail::extrapolation_source_value(
122 boundary,
123 field,
124 exterior,
125 ddc::DiscreteElement<typename Field::component_type>(0));
126 if (nonzero != 1)
127 system.fail(8);
128 else
129 system.prescribe(
130 indices[selected],
131 (value - constant)
132 / weights.mem(
133 ddc::DiscreteElement<
134 similie::solvers::detail::StencilColumn>(
135 selected)));
136 });
137 }
138}
139
140template <std::size_t Capacity, class Field, class Primal, std::size_t... Axis>
141void prescribe_faces(
142 Kokkos::DefaultExecutionSpace const& exec,
143 RowAssembly<Capacity> system,
144 Field const& field,
145 Primal const& primal,
146 std::index_sequence<Axis...>)
147{
148 (prescribe_face<Axis, false, Capacity>(exec, system, field, primal), ...);
149 (prescribe_face<Axis, true, Capacity>(exec, system, field, primal), ...);
150}
151
152template <class Direction, std::size_t Requested>
153constexpr std::size_t column_capacity()
154{
155 if constexpr (Requested != 0)
156 return Requested;
157 std::size_t samples = 1;
158 for (std::size_t axis = 0; axis < Direction::size(); ++axis)
159 samples *= 5;
160 return samples;
161}
162
163struct CodifferentialStencil
164{
165 template <class Operator, class Flux, class Rules, class Element, class Component>
166 KOKKOS_FUNCTION auto operator()(
167 Operator const& operation,
168 Flux const& flux,
169 Rules const&,
170 Element elem,
171 Component) const
172 {
173 return operation.value(flux, flux, elem);
174 }
175};
176
177template <class Direction, bool Matrix, std::size_t Capacity, class Domains, class Diffusivity>
178void assemble_laplacian_rows(
179 Kokkos::DefaultExecutionSpace const& exec,
180 RowAssembly<Capacity> system,
181 Domains const& domains,
182 Diffusivity diffusivity,
183 double jump_scale)
184{
185 auto const flux_domains
186 = make_laplacian_flux_domains<Direction>(domains, diffusivity, jump_scale);
187 auto const operation = make_multidomain_operator(
188 domains,
190 operation.for_each(
191 exec,
192 [&](std::size_t id,
193 Kokkos::DefaultExecutionSpace const& stream,
195 auto const field = domains.field(id);
196 auto const flux = flux_domains.template field<FieldRole::Flux>(id);
197 auto const rules = flux_domains.template extrapolation_rules<FieldRole::Flux>(id);
198 assemble_differential_rows<Matrix, StencilCoordinates::Relative>(
199 stream,
200 system,
201 field,
202 flux,
203 op,
204 rules,
205 CodifferentialStencil {});
206 prescribe_faces<Capacity>(
207 stream,
208 system,
209 field,
210 domains.extrapolation_rules(id, jump_scale),
211 std::make_index_sequence<Direction::size()> {});
212 });
213}
214} // namespace detail
215
221template <class Direction, std::size_t ColumnCapacity = 0, class Domains, class Diffusivity>
223 Kokkos::DefaultExecutionSpace const& exec,
224 Domains const& domains,
225 std::size_t unknowns,
226 Diffusivity diffusivity,
227 double jump_scale = 1.0,
228 bool normalize = true)
229{
230 detail::RowAssembly<detail::column_capacity<Direction, ColumnCapacity>()> const system(
231 unknowns);
232 detail::assemble_laplacian_rows<
233 Direction,
234 true>(exec, system, domains, diffusivity, jump_scale);
235 return system.finalize(exec, normalize);
236}
237
243template <class Direction, std::size_t ColumnCapacity = 0, class Domains, class Diffusivity>
245 Kokkos::DefaultExecutionSpace const& exec,
246 Domains const& domains,
247 similie::solvers::AssembledLinearSystem const& matrix_system,
248 Diffusivity diffusivity,
249 double jump_scale = 1.0)
250{
251 if (matrix_system.row_scales.extent(0) != matrix_system.rhs.extent(0))
252 throw std::invalid_argument("RHS assembly requires the original DEC row scaling");
253 detail::RowAssembly<detail::column_capacity<Direction, ColumnCapacity>()> const
254 system(matrix_system.rhs.extent(0), false);
255 detail::assemble_laplacian_rows<
256 Direction,
257 false>(exec, system, domains, diffusivity, jump_scale);
258 return system.finalize_rhs(exec, matrix_system.row_scales);
259}
260} // namespace sil::multidomains
auto make_dual_hodge_cochain(Cochain cochain, Position const &position, Geometry const &geometry_rule, Flux const &flux_rule, double diffusivity=1.0)
Normalize single policies locally, as for the staged differential operators.
KOKKOS_FUNCTION Chain< boundary_t< SimplexType >, typename AllocationType::array_layout, typename AllocationType::memory_space > boundary(AllocationType allocation, SimplexType const &simplex)
Definition boundary.hpp:170
MultidomainOperator< Operator > make_multidomain_operator(Domains const &domains, Operator operation)
Replicate a local differential operator for each physical domain.
auto domain_data(Field const &field, Geometry const &geometry, Physics physics)
similie::solvers::AssembledLinearSystem assemble_multidomain_laplacian(Kokkos::DefaultExecutionSpace const &exec, Domains const &domains, std::size_t unknowns, Diffusivity diffusivity, double jump_scale=1.0, bool normalize=true)
Assemble scalar DEC tensor stencils through topology-generated rules.
auto make_laplacian_flux_domains(Domains const &domains, Diffusivity diffusivity, double jump_scale=1.0)
Bind lazy *d(phi) cochains, so dual topology rules enter the donor's DEC flux.
Kokkos::View< double ** > assemble_multidomain_laplacian_rhs(Kokkos::DefaultExecutionSpace const &exec, Domains const &domains, similie::solvers::AssembledLinearSystem const &matrix_system, Diffusivity diffusivity, double jump_scale=1.0)
Evaluate a new boundary/interface load for an already assembled operator.
KOKKOS_FUNCTION auto make_tensor_with_extrapolation_rules(Field const &field, Rule rule)