7#include <similie/exterior/discrete_hodge_star/discrete_hodge_star.hpp>
8#include <similie/tensor/tensor_indices/weighted_levi_civita_tensor.hpp>
13template <
class SourceIndices,
class TargetIndices>
14using WeightedHodgeIndex = tensor::TensorWeightedLeviCivitaIndex<
18template <
class SourceIndices,
class TargetIndices>
19KOKKOS_FUNCTION std::array<std::size_t, 2> weighted_hodge_components(std::size_t entry)
21 using Index = WeightedHodgeIndex<SourceIndices, TargetIndices>;
23 std::array<std::size_t, Target::rank()> target {};
24 std::array
const ids = Index::mem_id_to_canonical_natural_ids(entry);
25 for (std::size_t i = 0; i < target.size(); ++i)
26 target[i] = ids[ddc::type_seq_size_v<SourceIndices> + i];
27 return {entry, Target::mem_id(target)};
30template <
class SourceIndices,
class TargetIndices,
class Output,
class Input>
31KOKKOS_FUNCTION
void apply_weighted_hodge(
37 using Index = WeightedHodgeIndex<SourceIndices, TargetIndices>;
41 ddc::DiscreteDomain<Index>,
45 if constexpr (ddc::type_seq_size_v<SourceIndices> == 0) {
48 typename Input::element_type,
49 ddc::DiscreteDomain<>,
52 memory_space>(input.data_handle(), ddc::DiscreteDomain<>()));
57 ddc::device_for_each(output.domain(), [&](
auto component) {
58 output.mem(component) /= misc::factorial(ddc::type_seq_size_v<SourceIndices>);
62template <
class Operator,
class SourceIndices,
class TargetIndices,
class Metric>
63class WeightedHodgeStorage
65 using Index = WeightedHodgeIndex<SourceIndices, TargetIndices>;
68 using Domain =
typename Metric::non_indices_domain_t;
69 using Element =
typename Domain::discrete_element_type;
71 Kokkos::View<double**, Kokkos::LayoutLeft, typename Metric::memory_space> m_weights;
73 KOKKOS_FUNCTION std::array<double,
Index::mem_size()> weights(Element element)
const
76 std::size_t
const node = stencil_node(m_domain, element);
77 for (std::size_t entry = 0; entry < result.size(); ++entry)
78 result[entry] = m_weights(node, entry);
83 using execution_space =
typename Metric::memory_space::execution_space;
85 template <
class Position>
86 static WeightedHodgeStorage build(
87 execution_space
const& exec,
89 Position
const& position)
91 WeightedHodgeStorage result;
92 result.m_domain = metric.non_indices_domain();
94 = Kokkos::View<double**, Kokkos::LayoutLeft, typename Metric::memory_space>(
95 "weighted_levi_civita_hodge_coefficients",
96 result.m_domain.size(),
98 WeightedHodgeStorage
const storage = result;
99 ddc::parallel_for_each(
100 "cache_weighted_levi_civita_hodge",
103 KOKKOS_LAMBDA(Element element) {
104 auto const stencil = Operator::value(metric, position, element);
105 std::size_t
const node = stencil_node(storage.m_domain, element);
107 std::array
const components
108 = weighted_hodge_components<SourceIndices, TargetIndices>(entry);
109 storage.m_weights(node, entry)
111 [components[1] * Source::mem_size() + components[0]];
117 template <
class Output,
class Input,
class Position>
118 KOKKOS_FUNCTION
void apply_pointwise(
119 Output
const& output,
123 Element element)
const
125 apply_weighted_hodge<SourceIndices, TargetIndices>(output, input, weights(element));
127 template <
class Output,
class Input>
128 Output apply(execution_space
const& exec, Output
const& output, Input
const& input)
const
130 WeightedHodgeStorage
const storage = *
this;
131 ddc::parallel_for_each(
132 "apply_weighted_levi_civita_hodge",
134 output.non_indices_domain(),
135 KOKKOS_LAMBDA(Element element) {
136 apply_weighted_hodge<SourceIndices, TargetIndices>(
139 storage.weights(element));
143 template <
class Position>
144 KOKKOS_FUNCTION LocalOperatorStencil<Source, Target> value(
147 Element element)
const
149 LocalOperatorStencil<Source, Target> result;
150 std::array
const coefficients = weights(element);
151 for (std::size_t entry = 0; entry < coefficients.size(); ++entry) {
152 std::array
const components
153 = weighted_hodge_components<SourceIndices, TargetIndices>(entry);
154 result.weights[components[1] * Source::mem_size() + components[0]]
155 = coefficients[entry];
159 template <
class Position,
class Natural>
160 KOKKOS_FUNCTION
double value(
161 Metric
const& metric,
162 Position
const& position,
164 Natural natural)
const
168 return local_stencil_coefficient<Source, Target>(
169 value(metric, position, element),
170 ddc::detail::array(SourceElement(natural)),
171 ddc::detail::array(TargetElement(natural)));
194 = ddc::type_seq_element_t<0, ddc::to_type_seq_t<typename MetricType::indices_domain_t>>;
199 MetricType
const& metric,
200 PositionType
const& position,
216 for (std::size_t entry = 0; entry < result.size(); ++entry) {
217 std::array
const components
218 = detail::weighted_hodge_components<Indices1, Indices2>(entry);
220 = reconstruction.weights[components[0] * Source::mem_size() + components[0]]
221 * reduction.weights[components[1] * Target::mem_size() + components[1]]
234 template <CochainType Output, CochainType Input>
236 Output
const& output,
238 MetricType
const& metric,
239 PositionType
const& position,
242 detail::apply_weighted_hodge<
244 Indices2>(output, input, weights(metric, position, element));
246 KOKKOS_FUNCTION
static detail::LocalOperatorStencil<Source, Target>
value(
247 MetricType
const& metric,
248 PositionType
const& position,
251 detail::LocalOperatorStencil<Source, Target> result;
252 std::array
const coefficients = weights(metric, position, element);
253 for (std::size_t entry = 0; entry < coefficients.size(); ++entry) {
254 std::array
const components
255 = detail::weighted_hodge_components<Indices1, Indices2>(entry);
256 result.weights[components[1] * Source::mem_size() + components[0]]
257 = coefficients[entry];
261 template <
class Natural>
262 KOKKOS_FUNCTION
static double value(
263 MetricType
const& metric,
264 PositionType
const& position,
270 return detail::local_stencil_coefficient<Source, Target>(
271 value(metric, position, element),
272 ddc::detail::array(SourceElement(natural)),
273 ddc::detail::array(TargetElement(natural)));
Discrete Hodge star for an identity metric and coordinate-aligned orthogonal cells.
detail::WeightedHodgeStorage< WeightedLeviCivitaDiscreteHodgeStar, Indices1, Indices2, MetricType > staged_storage_type
static KOKKOS_FUNCTION void operator()(Output const &output, Input const &input, MetricType const &metric, PositionType const &position, BatchElem element)
static KOKKOS_FUNCTION detail::LocalOperatorStencil< Source, Target > value(MetricType const &metric, PositionType const &position, BatchElem element)
static KOKKOS_FUNCTION constexpr discrete_domain_type domain()
typename detail::ReductionTargetIndex< Indices >::type reduction_index_t
KOKKOS_FUNCTION constexpr int permutation_parity(std::array< std::size_t, N > const &lst)
typename detail::ConvertTypeSeqTo< T, Seq >::type convert_type_seq_to_t
Tensor(ddc::Chunk< ElementType, SupportType, Allocator >) -> Tensor< ElementType, SupportType, Kokkos::layout_right, typename Allocator::memory_space >
ddc::type_seq_element_t< 0, ddc::to_type_seq_t< typename MetricIndex::subindices_domain_t > > metric_index_1
Tensor< ElementType, ddc::DiscreteDomain< ProdDDim... >, LayoutStridedPolicy, MemorySpace > tensor_prod(Tensor< ElementType, ddc::DiscreteDomain< ProdDDim... >, LayoutStridedPolicy, MemorySpace > const &prod_tensor, Tensor< ElementType, ddc::DiscreteDomain< DDim1... >, LayoutStridedPolicy, MemorySpace > const &tensor1, Tensor< ElementType, ddc::DiscreteDomain< DDim2... >, LayoutStridedPolicy, MemorySpace > const &tensor2)
detail::Lower< T >::type lower_t
static constexpr std::size_t rank()
static constexpr std::size_t mem_size()
static KOKKOS_FUNCTION constexpr std::array< std::size_t, rank()> mem_id_to_canonical_natural_ids(std::size_t id)