SimiLie
Loading...
Searching...
No Matches
differential_operator.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 <stdexcept>
8#include <tuple>
9
10#include <similie/solvers/stencil_assembly.hpp>
11
12#include "multidomain_operator.hpp"
13#include "stencil_composition.hpp"
14
21
22namespace detail {
23using similie::solvers::detail::RowAssembly;
31template <
32 bool Matrix,
34 std::size_t Capacity,
35 class Output,
36 class Input,
37 class Operator,
38 class Rules,
39 class StencilFactory>
40void assemble_differential_rows(
41 Kokkos::DefaultExecutionSpace const& stream,
42 RowAssembly<Capacity> system,
43 Output const& output,
44 Input const& input,
45 Operator op,
46 Rules const& rules,
47 StencilFactory stencil_factory)
48{
49 std::tuple<Operator, Input, Rules, StencilFactory> const
50 bound(op, input, rules, stencil_factory);
51 ddc::parallel_for_each(
52 "assemble_multidomain_differential_rows",
53 stream,
54 output.non_indices_domain(),
55 KOKKOS_LAMBDA(typename Output::non_indices_domain_t::discrete_element_type elem) {
56 auto const& local_op = std::get<0>(bound);
57 auto const& local_input = std::get<1>(bound);
58 auto const& local_rules = std::get<2>(bound);
59 auto const& value = std::get<3>(bound);
60 ddc::device_for_each(output.indices_domain(), [&](auto component) {
61 std::size_t const row = output.global_index(elem, component);
62 if (row >= system.constants.extent(0)) {
63 system.fail(4);
64 return;
65 }
66 auto const coefficients
67 = value(local_op, local_input, local_rules, elem, component);
68 ddc::device_for_each(coefficients.domain(), [&](auto entry) {
69 double const weight = coefficients.mem(entry);
70 if (weight != 0.0)
71 visit_rule_basis(
72 local_rules,
73 local_input,
74 [&] {
75 if constexpr (Coordinates == StencilCoordinates::Relative)
76 return sil::tensor::detail::stencil_sample(elem, entry);
77 else
78 return typename Input::non_indices_domain_t::
79 discrete_element_type(entry);
80 }(),
81 typename Input::indices_domain_t::discrete_element_type(entry),
82 weight,
83 [&](auto const& donor,
84 auto sample,
85 auto source_component,
86 double coefficient) {
87 if constexpr (Matrix)
88 system.add(
89 row,
90 donor.global_index(sample, source_component),
91 coefficient);
92 },
93 [&](double constant) { system.constants(row) += constant; });
94 });
95 });
96 });
97}
98} // namespace detail
99
115template <
116 std::size_t ColumnCapacity,
117 StencilCoordinates Coordinates = StencilCoordinates::Absolute,
118 FieldRole InputRole = FieldRole::Primal,
119 class OutputDomains,
120 class InputDomains,
121 class Operator,
122 class StencilFactory>
124 Kokkos::DefaultExecutionSpace const& exec,
125 OutputDomains const& output_domains,
126 InputDomains const& input_domains,
127 MultidomainOperator<Operator> const& operators,
128 StencilFactory stencil_factory,
129 std::size_t rows,
130 std::size_t columns,
131 bool normalize = true)
132{
133 if (output_domains.domain_count() != input_domains.domain_count()
134 || operators.domain_count() != output_domains.domain_count())
135 throw std::invalid_argument("differential operator domain counts differ");
136 if (columns == 0)
137 throw std::invalid_argument("differential operator requires input columns");
138 detail::RowAssembly<ColumnCapacity> const system(rows, true, columns);
139 operators.for_each(
140 exec,
141 [&](std::size_t id, Kokkos::DefaultExecutionSpace const& stream, Operator const& op) {
142 detail::assemble_differential_rows<true, Coordinates>(
143 stream,
144 system,
145 output_domains.field(id),
146 input_domains.template field<InputRole>(id),
147 op,
148 input_domains.template extrapolation_rules<InputRole>(id),
149 stencil_factory);
150 });
151 return system.finalize(exec, normalize, true);
152}
153} // namespace sil::multidomains
Dispatch any homogeneous collection of domain operators.
void for_each(ExecSpace const &exec, Function function) const
similie::solvers::AssembledLinearSystem assemble_multidomain_differential_operator(Kokkos::DefaultExecutionSpace const &exec, OutputDomains const &output_domains, InputDomains const &input_domains, MultidomainOperator< Operator > const &operators, StencilFactory stencil_factory, std::size_t rows, std::size_t columns, bool normalize=true)
Assemble any local differential operator with a stencil-producing value().
StencilCoordinates
Spatial coordinates carried by differential stencil entries.