7#include <similie/exterior/laplacian/laplacian.hpp>
8#include <similie/solvers/stencil_assembly.hpp>
10#include "differential_operator.hpp"
11#include "indexed_scalar_field.hpp"
12#include "multidomains.hpp"
21template <
class Direction,
class Domains,
class Diffusivity>
23 Domains
const& domains,
24 Diffusivity diffusivity,
25 double jump_scale = 1.0)
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);
35 domains.extrapolation_rules(
id, jump_scale)),
37 domains.template extrapolation_rules<sil::multidomains::FieldRole::Geometry>(
id),
38 domains.template boundary_rules<sil::multidomains::FieldRole::Flux>(
id),
45template <std::
size_t Axis,
bool Upper, std::
size_t Capacity,
class Field,
class Primal>
47 Kokkos::DefaultExecutionSpace
const& exec,
48 RowAssembly<Capacity> system,
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;
60 [&]<std::size_t... Tangent>(std::index_sequence<Tangent...>) {
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];
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(
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(
87 ddc::DiscreteElement<typename Field::component_type>(0),
89 [&](
auto const& donor,
auto sample,
auto component,
double weight) {
90 if (!similie::solvers::detail::add_stencil_coefficient(
94 donor.global_index(sample, component),
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)
103 ddc::DiscreteElement<similie::solvers::detail::StencilColumn>(
109 auto exterior = elem;
111 ++ddc::detail::array(exterior)[Axis];
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;
121 double const value = sil::tensor::detail::extrapolation_source_value(
125 ddc::DiscreteElement<typename Field::component_type>(0));
133 ddc::DiscreteElement<
134 similie::solvers::detail::StencilColumn>(
140template <std::size_t Capacity,
class Field,
class Primal, std::size_t... Axis>
142 Kokkos::DefaultExecutionSpace
const& exec,
143 RowAssembly<Capacity> system,
146 std::index_sequence<Axis...>)
148 (prescribe_face<Axis, false, Capacity>(exec, system, field, primal), ...);
149 (prescribe_face<Axis, true, Capacity>(exec, system, field, primal), ...);
152template <
class Direction, std::
size_t Requested>
153constexpr std::size_t column_capacity()
155 if constexpr (Requested != 0)
157 std::size_t samples = 1;
158 for (std::size_t axis = 0; axis < Direction::size(); ++axis)
163struct CodifferentialStencil
165 template <
class Operator,
class Flux,
class Rules,
class Element,
class Component>
166 KOKKOS_FUNCTION
auto operator()(
167 Operator
const& operation,
173 return operation.value(flux, flux, elem);
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,
185 auto const flux_domains
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>(
205 CodifferentialStencil {});
206 prescribe_faces<Capacity>(
210 domains.extrapolation_rules(
id, jump_scale),
211 std::make_index_sequence<Direction::size()> {});
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)
230 detail::RowAssembly<detail::column_capacity<Direction, ColumnCapacity>()>
const system(
232 detail::assemble_laplacian_rows<
234 true>(exec, system, domains, diffusivity, jump_scale);
235 return system.finalize(exec, normalize);
243template <
class Direction, std::
size_t ColumnCapacity = 0,
class Domains,
class Diffusivity>
245 Kokkos::DefaultExecutionSpace
const& exec,
246 Domains
const& domains,
248 Diffusivity diffusivity,
249 double jump_scale = 1.0)
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<
257 false>(exec, system, domains, diffusivity, jump_scale);
258 return system.finalize_rhs(exec, matrix_system.
row_scales);
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)
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)
Kokkos::View< double * > row_scales
Kokkos::View< double ** > rhs