59 Geometry
const& geometry,
62 typename Domain::discrete_element_type element,
63 Arguments
const& arguments,
64 std::index_sequence<I...>)
66 return Operator::value(geometry, first, second, element, std::get<I>(arguments)...);
77 FirstField
const& first,
78 SecondField
const& second,
79 Geometry
const& geometry,
80 Arguments
const&... arguments)
83 result.m_domain = first.non_indices_domain();
84 result.m_first_domain = first.non_indices_domain();
85 result.m_second_domain = second.non_indices_domain();
87 if (result.m_first_domain != result.m_second_domain)
88 throw std::invalid_argument(
"Bilinear staging requires equal input spatial domains");
89 result.m_weights =
decltype(m_weights)(
90 Kokkos::view_alloc(Kokkos::WithoutInitializing,
"staged_bilinear_stencils"),
91 result.m_domain.size());
92 auto const weights = result.m_weights;
93 Domain
const domain = result.m_domain;
94 std::tuple<Arguments...>
const cached_arguments(arguments...);
95 Kokkos::View<int, Memory> incomplete(
"staged_bilinear_incomplete");
97 "similie_cache_bilinear_operator_stencils",
98 Kokkos::RangePolicy<Exec>(exec, 0, domain.size()),
99 KOKKOS_LAMBDA(std::size_t node) {
104 detail::stencil_element(domain, node),
106 std::index_sequence_for<Arguments...>());
108 Kokkos::atomic_max(&incomplete(), 1);
109 for (std::size_t entry = 0; entry < stencil.
weights.size(); ++entry)
110 weights(node, entry) = stencil.
weights[entry];
113 Kokkos::deep_copy(exec, failed, incomplete);
116 throw std::invalid_argument(
"Bilinear boundary closure exceeds cached stencil support");
139 Output
const& output,
140 FirstTensor
const& first,
141 SecondTensor
const& second,
142 typename Domain::discrete_element_type element)
const
144 std::size_t
const node = detail::stencil_node(m_domain, element);
145 for (std::size_t target = 0; target < Target::mem_size(); ++target) {
147 for (std::size_t a = 0; a < First::mem_size(); ++a)
148 for (std::size_t b = 0; b < Second::mem_size(); ++b)
151 (target * First::mem_size() + a) * Second::mem_size() + b)
152 * first.mem(ddc::DiscreteElement<First>(a))
153 * second.mem(ddc::DiscreteElement<Second>(b));
154 output.mem(ddc::DiscreteElement<Target>(target)) = sum;
165 Output
const& output,
166 FirstField
const& first,
167 SecondField
const& second)
const
169 if (first.non_indices_domain() != m_first_domain
170 || second.non_indices_domain() != m_second_domain)
171 throw std::invalid_argument(
"Staged bilinear operator input domain changed");
172 Domain
const out_domain = output.non_indices_domain();
173 if (!out_domain.empty()
176 throw std::invalid_argument(
"Staged bilinear operator output exceeds cached domain");
177 auto const weights = m_weights;
178 Domain
const domain = m_domain;
179 Kokkos::parallel_for(
180 "similie_apply_staged_bilinear_stencil",
181 Kokkos::RangePolicy<Exec>(exec, 0, out_domain.size() * Target::mem_size()),
182 KOKKOS_LAMBDA(std::size_t row) {
184 = detail::stencil_element(out_domain, row / Target::mem_size());
185 std::size_t
const node = detail::stencil_node(domain, element),
186 target = row % Target::mem_size();
190 double const coefficient = weights(
195 if (coefficient != 0.0)
198 .mem(detail::stencil_source<Index, FirstRadius>(
201 a / First::mem_size()),
202 ddc::DiscreteElement<First>(
203 a % First::mem_size()))
205 .mem(detail::stencil_source<Index, SecondRadius>(
208 b / Second::mem_size()),
209 ddc::DiscreteElement<Second>(
210 b % Second::mem_size()));
212 output.mem(element, ddc::DiscreteElement<Target>(target)) = sum;