11#include <similie/exterior/boundary/boundary.hpp>
12#include <similie/exterior/cochain.hpp>
13#include <similie/exterior/concepts.hpp>
14#include <similie/exterior/cosimplex.hpp>
15#include <similie/misc/are_all_same.hpp>
16#include <similie/misc/filled_struct.hpp>
17#include <similie/misc/macros.hpp>
18#include <similie/misc/portable_stl.hpp>
19#include <similie/misc/select_from_type_seq.hpp>
20#include <similie/misc/specialization.hpp>
21#include <similie/misc/type_seq_conversion.hpp>
22#include <similie/misc/type_seq_ext.hpp>
23#include <similie/tensor/extrapolation_rules.hpp>
24#include <similie/tensor/owning_tensor.hpp>
25#include <similie/tensor/scalar_extrapolation_rules.hpp>
26#include <similie/tensor/tensor_impl.hpp>
27#include <similie/tensor/tensor_indices/antisymmetric_tensor.hpp>
28#include <similie/tensor/tensor_indices/dummy_index.hpp>
30#include <Kokkos_StdAlgorithms.hpp>
46 class LayoutStridedPolicy1,
47 class LayoutStridedPolicy2,
52 LayoutStridedPolicy2>>
54 using type = Cosimplex<
Simplex<K + 1, Tag...>, ElementType>;
59template <misc::Specialization<Cochain> CochainType>
60using coboundary_t =
typename detail::CoboundaryType<CochainType>::type;
64template <
class TagToAddToCochain,
class CochainTag>
65struct CoboundaryIndex;
67template <tensor::TensorNatIndex TagToAddToCochain, tensor::TensorNatIndex CochainTag>
68 requires(CochainTag::rank() == 0)
69struct CoboundaryIndex<TagToAddToCochain, CochainTag>
71 using type = TagToAddToCochain;
74template <tensor::TensorNatIndex TagToAddToCochain, tensor::TensorNatIndex CochainTag>
75 requires(CochainTag::rank() == 1)
76struct CoboundaryIndex<TagToAddToCochain, CochainTag>
82struct CoboundaryIndex<TagToAddToCochain, tensor::TensorAntisymmetricIndex<Tag...>>
89template <
class TagToAddToCochain,
class CochainTag>
98struct CoboundaryTensorType
101 typename TensorType::element_type,
102 ddc::replace_dim_of_t<
103 typename TensorType::discrete_domain_type,
106 typename TensorType::layout_type,
107 typename TensorType::memory_space>>;
115 CochainType TensorType>
121template <misc::Specialization<Chain> ChainType>
122struct ComputeSimplex;
124template <std::size_t K,
class... Tag,
class LayoutStridedPolicy,
class ExecSpace>
125struct ComputeSimplex<
Chain<
Simplex<K, Tag...>, LayoutStridedPolicy, ExecSpace>>
127 KOKKOS_FUNCTION
static Simplex<K + 1, Tag...> operator()(
130 ddc::DiscreteVector<Tag...> vect {0 * ddc::type_seq_rank_v<Tag, ddc::TypeSeq<Tag...>>...};
131 for (
auto i = chain.begin(); i < chain.end(); ++i) {
132 vect = ddc::DiscreteVector<Tag...> {
133 (
static_cast<bool>(vect.template get<Tag>())
134 ||
static_cast<bool>((*i).discrete_vector().
template get<Tag>()))...};
138 std::integral_constant<std::size_t, K + 1> {},
147template <
class... Args>
150template <
class... Args>
153template <misc::Specialization<Cochain> CochainType>
160 assert(cochain.size() == 2 * (cochain.dimension() + 1)
161 &&
"only cochain over the boundary of a single simplex is supported");
169 detail::ComputeSimplex<typename CochainType::chain_type>::operator()(
171 cochain.integrate());
177template <tensor::TensorNatIndex Index,
class Dom>
178struct NonSpectatorDimension;
181struct NonSpectatorDimension<Index,
ddc::DiscreteDomain<DDim...>>
184 ddc::type_seq_contains_v<
185 ddc::TypeSeq<typename DDim::continuous_dimension_type>,
186 typename Index::type_seq_dimensions>,
187 ddc::DiscreteDomain<DDim>,
188 ddc::DiscreteDomain<>>...>;
191struct CoboundaryDummyIndex
196 class MemorySpace = Kokkos::HostSpace,
198 std::size_t Width = 2,
200KOKKOS_FUNCTION
auto make_stencil(ddc::DiscreteElement<DDims...> front)
202 constexpr std::size_t size = [] {
203 std::size_t nodes = 1;
204 for (std::size_t axis = 0; axis <
sizeof...(DDims); ++axis)
206 return nodes * TensorIndex::mem_size();
208 std::array<double, size> storage {};
209 ddc::DiscreteDomain<DDims..., TensorIndex>
const
210 domain(ddc::DiscreteDomain<DDims...>(
212 typename ddc::DiscreteDomain<DDims...>::discrete_vector_type(
213 ddc::DiscreteVector<DDims>(Width)...)),
214 ddc::DiscreteDomain<TensorIndex>(
215 ddc::DiscreteElement<TensorIndex>(0),
216 ddc::DiscreteVector<TensorIndex>(TensorIndex::mem_size())));
219 ddc::DiscreteDomain<DDims..., TensorIndex>,
220 Kokkos::layout_right,
222 result(ddc::ChunkSpan<
224 ddc::DiscreteDomain<DDims..., TensorIndex>,
225 Kokkos::layout_right,
226 MemorySpace>(storage.data(), domain));
230template <
class Elem,
class Domain>
231KOKKOS_FUNCTION Elem forward_stencil_front(Elem elem, Domain
const& domain)
236 Elem
const domain_front(domain.front());
237 Elem
const domain_back(domain.back());
238 for (std::size_t dim_id = 0; dim_id < ddc::type_seq_size_v<ddc::to_type_seq_t<Elem>>;
240 if (ddc::detail::array(front)[dim_id] == ddc::detail::array(domain_back)[dim_id]
241 && ddc::detail::array(front)[dim_id] > ddc::detail::array(domain_front)[dim_id]) {
242 --ddc::detail::array(front)[dim_id];
248template <
class Elem,
class Domain>
249KOKKOS_FUNCTION Elem backward_stencil_front(Elem elem, Domain
const& domain)
251 Elem
const domain_front(domain.front());
252 for (std::size_t dim_id = 0; dim_id < ddc::type_seq_size_v<ddc::to_type_seq_t<Elem>>;
254 if (ddc::detail::array(elem)[dim_id] > ddc::detail::array(domain_front)[dim_id]) {
255 --ddc::detail::array(elem)[dim_id];
261template <
class LowerChainType,
class VectorType>
262KOKKOS_FUNCTION
auto find_discrete_vector(
263 LowerChainType
const& lower_chain,
264 VectorType
const& vector)
266 for (
auto i = lower_chain.begin(); i < lower_chain.end(); ++i) {
267 if (i->discrete_vector() == vector) {
271 return lower_chain.end();
283KOKKOS_FUNCTION
void apply_incidence(
284 Output
const& output,
285 Evaluator
const& evaluator,
287 LowerChain
const& lower_chain,
291 ddc::to_type_seq_t<typename Chain::simplex_type::discrete_element_type>>(element);
292 for (std::size_t component = 0; component < chain.size(); ++component) {
296 for (std::size_t half = 0; half < 2; ++half) {
297 std::size_t face = 0;
298 for (std::size_t axis = 0;
299 axis < ddc::type_seq_size_v<
300 ddc::to_type_seq_t<typename Chain::simplex_type::discrete_element_type>>;
302 if (ddc::detail::array(chain[component].discrete_vector())[axis] == 0)
304 typename Chain::simplex_type::discrete_vector_type vector
305 = chain[component].discrete_vector();
306 ddc::detail::array(vector)[axis] = 0;
307 typename Chain::simplex_type::discrete_element_type sample = origin;
309 if constexpr (Transposed)
310 --ddc::detail::array(sample)[axis];
312 ++ddc::detail::array(sample)[axis];
314 ddc::DiscreteElement<CochainTag>
const source(
315 Kokkos::Experimental::distance(
317 find_discrete_vector(lower_chain, vector)));
318 double const value = [&] {
320 ddc::type_seq_size_v<ddc::type_seq_remove_t<
321 ddc::to_type_seq_t<Element>,
322 ddc::to_type_seq_t<
typename LowerChain::simplex_type::
323 discrete_element_type>>>
325 return evaluator(Element(sample), source);
330 ddc::to_type_seq_t<Element>,
332 typename LowerChain::simplex_type::
333 discrete_element_type>>>(element)),
336 sum += ((face + half) % 2 == 0 ? -1.0 : 1.0) * value;
341 = Transposed ? -sum : sum;
353KOKKOS_FUNCTION
auto incidence_stencil(
360 std::size_t
const access = component.template uid<OutputIndex>();
361 std::size_t
const index
362 = OutputIndex::rank() > 1 && access == 0 ? 0 : OutputIndex::access_id_to_mem_id(access);
363 double const orientation = [&] {
364 if constexpr (OutputIndex::rank() > 1)
365 return access == 0 ? 0.0 : access <= OutputIndex::mem_size() ? 1.0 : -1.0;
370 simplex(std::integral_constant<std::size_t, CochainTag::rank() + 1> {},
371 typename Chain::simplex_type::discrete_element_type(element),
372 chain[index].discrete_vector());
374 std::array<
typename Lower::simplex_type::discrete_element_type, 2 * (CochainTag::rank() + 1)>
376 for (std::size_t i = 0; i < faces.size(); ++i)
377 samples[i] = faces[i].discrete_element();
378 if constexpr (Transposed) {
379 for (std::size_t i = CochainTag::rank() + 1; i < faces.size(); ++i)
380 for (std::size_t axis = 0;
381 axis < ddc::type_seq_size_v<
382 ddc::to_type_seq_t<typename Lower::simplex_type::discrete_element_type>>;
384 if (ddc::detail::array(simplex.discrete_vector())[axis] != 0
385 && ddc::detail::array(faces[i].discrete_vector())[axis] == 0) {
386 ddc::detail::array(samples[i])[axis] -= 2;
390 typename Lower::simplex_type::discrete_element_type front(samples[0]);
391 for (
auto const& face : samples)
392 for (std::size_t axis = 0; axis < ddc::type_seq_size_v<ddc::to_type_seq_t<
decltype(front)>>;
394 ddc::detail::array(front)[axis]
395 = std::min(ddc::detail::array(front)[axis], ddc::detail::array(face)[axis]);
396 auto stencil = make_stencil<typename Chain::memory_space, CochainTag>(front);
397 for (std::size_t i = 0; i < faces.size(); ++i) {
398 std::size_t
const source = Kokkos::Experimental::
399 distance(lower.begin(), find_discrete_vector(lower, faces[i].discrete_vector()));
400 stencil.mem(samples[i], ddc::DiscreteElement<CochainTag>(source))
401 += (Transposed ? -orientation : orientation) * (faces[i].negative() ? -1.0 : 1.0);
408template <tensor::TensorNatIndex TagToAddToCochain, tensor::TensorIndex CochainTag>
412 template <
class ChainType,
class LowerChainType,
class Elem,
class NaturalElem>
414 ChainType
const& chain,
415 LowerChainType
const& lower_chain,
417 NaturalElem natural_elem)
419 return detail::incidence_stencil<
422 CochainTag>(chain, lower_chain, elem, natural_elem);
429 class LowerChainType,
432 CoboundaryTensorType
const& coboundary_tensor,
433 Evaluator
const& evaluator,
434 ChainType
const& chain,
435 LowerChainType
const& lower_chain,
438 detail::apply_incidence<
441 CochainTag>(coboundary_tensor, evaluator, chain, lower_chain, elem);
445static_assert(CoboundaryConcept<
446 Coboundary<detail::DirectionConcept, detail::ScalarConcept>,
449 ddc::DiscreteDomain<detail::DirectionConcept>,
450 Kokkos::layout_right,
452 detail::EvaluatorConcept,
455 ddc::DiscreteElement<detail::GridConcept>,
456 ddc::DiscreteElement<detail::DirectionConcept>>);
458template <tensor::TensorNatIndex TagToAddToCochain, tensor::TensorIndex CochainTag>
461 template <
class ChainType,
class LowerChainType,
class Elem,
class NaturalElem>
463 ChainType
const& chain,
464 LowerChainType
const& lower_chain,
466 NaturalElem natural_elem)
468 return detail::incidence_stencil<
471 CochainTag>(chain, lower_chain, elem, natural_elem);
478 class LowerChainType,
481 CoboundaryTensorType
const& coboundary_tensor,
482 Evaluator
const& evaluator,
483 ChainType
const& chain,
484 LowerChainType
const& lower_chain,
487 detail::apply_incidence<
490 CochainTag>(coboundary_tensor, evaluator, chain, lower_chain, elem);
494static_assert(CoboundaryConcept<
495 TransposedCoboundary<detail::DirectionConcept, detail::ScalarConcept>,
498 ddc::DiscreteDomain<detail::DirectionConcept>,
499 Kokkos::layout_right,
501 detail::EvaluatorConcept,
504 ddc::DiscreteElement<detail::GridConcept>,
505 ddc::DiscreteElement<detail::DirectionConcept>>);
507template <misc::Specialization<Cochain> CochainType>
529 CochainType TensorType,
533 ExecSpace
const& exec_space,
535 TensorType
const& tensor,
536 ExtrapolationRules
const& extrapolation = {})
538 auto const extrapolation_rules = [&]() {
540 return extrapolation;
544 ddc::DiscreteDomain batch_dom
545 = ddc::remove_dims_of<coboundary_index_t<TagToAddToCochain, CochainTag>>(
546 coboundary_tensor.domain());
549 CochainTag::rank() + 1,
550 typename detail::NonSpectatorDimension<
552 typename TensorType::non_indices_domain_t>::type>(exec_space);
555 typename detail::NonSpectatorDimension<
557 typename TensorType::non_indices_domain_t>::type>(exec_space);
559 SIMILIE_DEBUG_LOG(
"similie_compute_coboundary");
560 ddc::parallel_for_each(
561 "similie_compute_coboundary",
564 KOKKOS_LAMBDA(
typename decltype(batch_dom)::discrete_element_type elem) {
566 coboundary_tensor[elem],
567 [&](
auto sampled_elem,
auto component) {
568 return extrapolation_rules(tensor, sampled_elem)
569 .mem(
typename TensorType::indices_domain_t::
570 discrete_element_type(sampled_elem, component));
577 return coboundary_tensor;
581 tensor::TensorNatIndex TagToAddToCochain,
582 tensor::TensorIndex CochainTag,
583 CochainType TensorType,
587 ExecSpace
const& exec_space,
589 TensorType
const& tensor,
590 ExtrapolationRules
const& extrapolation = {})
592 auto const extrapolation_rules = [&]() {
594 return extrapolation;
598 ddc::DiscreteDomain batch_dom
599 = ddc::remove_dims_of<coboundary_index_t<TagToAddToCochain, CochainTag>>(
600 coboundary_tensor.domain());
603 CochainTag::rank() + 1,
604 typename detail::NonSpectatorDimension<
606 typename TensorType::non_indices_domain_t>::type>(exec_space);
609 typename detail::NonSpectatorDimension<
611 typename TensorType::non_indices_domain_t>::type>(exec_space);
613 SIMILIE_DEBUG_LOG(
"similie_compute_transposed_coboundary");
614 ddc::parallel_for_each(
615 "similie_compute_transposed_coboundary",
618 KOKKOS_LAMBDA(
typename decltype(batch_dom)::discrete_element_type elem) {
620 coboundary_tensor[elem],
621 [&](
auto sampled_elem,
auto component) {
622 return extrapolation_rules(tensor, sampled_elem)
623 .mem(
typename TensorType::indices_domain_t::
624 discrete_element_type(sampled_elem, component));
631 return coboundary_tensor;
635 tensor::TensorNatIndex TagToAddToCochain,
636 tensor::TensorIndex CochainTag,
637 CochainType TensorType,
641 ExecSpace
const& exec_space,
643 TensorType
const& tensor,
644 ExtrapolationRules
const& extrapolation = {})
648 CochainTag>(exec_space, coboundary_tensor, tensor, extrapolation);
Simplex(ddc::DiscreteElement< Tag... >, ddc::DiscreteVector< T... >) -> Simplex< sizeof...(T), Tag... >
Chain(Head, Tail...) -> Chain< typename Head::value_type, typename Head::array_layout, typename Head::memory_space >
typename detail::CoboundaryTensorType< TagToAddToCochain, CochainTag, TensorType >::type coboundary_tensor_t
Cochain(Tensor const &) -> Cochain< Tensor >
KOKKOS_FUNCTION Chain< boundary_t< SimplexType >, typename AllocationType::array_layout, typename AllocationType::memory_space > boundary(AllocationType allocation, SimplexType const &simplex)
coboundary_tensor_t< TagToAddToCochain, CochainTag, TensorType > transposed_coboundary(ExecSpace const &exec_space, coboundary_tensor_t< TagToAddToCochain, CochainTag, TensorType > const &coboundary_tensor, TensorType const &tensor, ExtrapolationRules const &extrapolation={})
coboundary_tensor_t< TagToAddToCochain, CochainTag, TensorType > deriv(ExecSpace const &exec_space, coboundary_tensor_t< TagToAddToCochain, CochainTag, TensorType > const &coboundary_tensor, TensorType const &tensor, ExtrapolationRules const &extrapolation={})
KOKKOS_FUNCTION constexpr auto tangent_basis(Elem elem)
LocalChain(AllocationType, SimplexType, T...) -> LocalChain< std::remove_cvref_t< SimplexType >, typename AllocationType::array_layout, typename AllocationType::memory_space >
typename detail::CoboundaryIndex< TagToAddToCochain, CochainTag >::type coboundary_index_t
KOKKOS_FUNCTION coboundary_t< CochainType > coboundary(CochainType const &cochain)
typename detail::CoboundaryType< CochainType >::type coboundary_t
convert_type_seq_to_t< ddc::DiscreteDomain, typename detail::CartesianProd< Domains... >::type > cartesian_prod_t
KOKKOS_FUNCTION auto select_from_type_seq(T t)
Tensor(ddc::Chunk< ElementType, SupportType, Allocator >) -> Tensor< ElementType, SupportType, Kokkos::layout_right, typename Allocator::memory_space >
OwningTensor(TensorType, Storage &&) -> OwningTensor< TensorType, Storage >
KOKKOS_FUNCTION auto make_extrapolation_rules(ExtrapolationRule rule)
Broadcast a rule to both sides of all N non-index dimensions.
ExtrapolationRules(std::pair< LeftRule, RightRule >, OtherRulePairs...) -> ExtrapolationRules< std::pair< LeftRule, RightRule >, OtherRulePairs... >
The top-level namespace of SimiLie.
static KOKKOS_FUNCTION coboundary_t< CochainType > operator()(CochainType const &cochain)
static KOKKOS_FUNCTION void operator()(CoboundaryTensorType const &coboundary_tensor, Evaluator const &evaluator, ChainType const &chain, LowerChainType const &lower_chain, Elem elem)
static KOKKOS_FUNCTION auto value(ChainType const &chain, LowerChainType const &lower_chain, Elem elem, NaturalElem natural_elem)
static KOKKOS_FUNCTION void operator()(CoboundaryTensorType const &coboundary_tensor, Evaluator const &evaluator, ChainType const &chain, LowerChainType const &lower_chain, Elem elem)
static KOKKOS_FUNCTION auto value(ChainType const &chain, LowerChainType const &lower_chain, Elem elem, NaturalElem natural_elem)