10#include <similie/misc/portable_stl.hpp>
11#include <similie/misc/specialization.hpp>
12#include <similie/misc/type_seq_ext.hpp>
14#include "concepts.hpp"
21template <
class... CDim>
34 return ddc::DiscreteDomain<>();
37 static constexpr std::size_t
rank()
39 return sizeof...(CDim) != 0;
42 static constexpr std::size_t
size()
44 if constexpr (
rank() == 0) {
47 return sizeof...(CDim);
62 KOKKOS_FUNCTION
static constexpr std::size_t
mem_id()
64 if constexpr (
rank() == 0) {
67 return ddc::type_seq_rank_v<ODim, type_seq_dimensions>;
71 KOKKOS_FUNCTION
static constexpr std::size_t
mem_id(std::size_t
const natural_id)
76 KOKKOS_FUNCTION
static constexpr std::size_t
access_id(std::size_t
const natural_id)
86 template <
class Tensor,
class Elem,
class Id,
class FunctorType>
88 const FunctorType& access,
92 return access(tensor, elem);
95 KOKKOS_FUNCTION
static constexpr std::array<std::size_t,
rank()>
99 if constexpr (
rank() == 0) {
100 return std::array<std::size_t,
rank()> {};
102 return std::array<std::size_t,
rank()> {
mem_id};
107static_assert(NaturalTensorIndexConcept<
108 TensorNaturalIndex<detail::DimensionConcept>,
109 detail::DimensionConcept>);
113 { DDim::is_tensor_index } -> std::convertible_to<bool>;
114} && DDim::is_tensor_index;
118 { DDim::is_tensor_natural_index } -> std::convertible_to<bool>;
119} && DDim::is_tensor_natural_index;
131template <
class Index>
132struct NaturalDomainType;
134template <
class Index>
136struct NaturalDomainType<Index>
138 using type =
typename Index::subindices_domain_t;
141template <TensorNatIndex Index>
142struct NaturalDomainType<Index>
144 using type = ddc::DiscreteDomain<Index>;
149template <TensorIndex Index>
155template <
class Index,
class...>
156struct NbDimsBeforeIndex;
158template <
class Index,
class IndexHead,
class... IndexTail>
159struct NbDimsBeforeIndex<Index,
ddc::TypeSeq<IndexHead, IndexTail...>>
161 static constexpr std::size_t operator()(std::size_t nb_dims_before_index)
163 if constexpr (std::is_same_v<IndexHead, Index>) {
164 return nb_dims_before_index;
166 return NbDimsBeforeIndex<Index, ddc::TypeSeq<IndexTail...>>::operator()(
167 nb_dims_before_index + IndexHead::rank());
173template <std::
size_t Offset,
class IndexSeq>
174struct OffsetIndexSeq;
176template <std::size_t Offset, std::size_t... Is>
177struct OffsetIndexSeq<Offset, std::integer_sequence<std::size_t, Is...>>
179 using type = std::integer_sequence<std::size_t, Offset + Is...>;
182template <std::
size_t Offset,
class IndexSeq>
183using offset_index_seq_t = OffsetIndexSeq<Offset, IndexSeq>::type;
186template <
class CDimTypeSeq,
class IndexSeq>
187struct TypeSeqDimsAtInts;
189template <
class CDimTypeSeq, std::size_t... Is>
190struct TypeSeqDimsAtInts<CDimTypeSeq, std::integer_sequence<std::size_t, Is...>>
192 using type = ddc::TypeSeq<ddc::type_seq_element_t<Is, CDimTypeSeq>...>;
195template <
class CDimTypeSeq,
class IndexSeq>
196using type_seq_dims_at_ints_t = TypeSeqDimsAtInts<CDimTypeSeq, IndexSeq>::type;
199template <
class Index,
class SubindicesDomain,
class TypeSeqDims>
200struct IdFromTypeSeqDims;
202template <
class Index,
class... Subindex,
class... CDim>
203struct IdFromTypeSeqDims<Index,
ddc::DiscreteDomain<Subindex...>, ddc::TypeSeq<CDim...>>
205 KOKKOS_FUNCTION
static constexpr std::size_t operator()()
207 static_assert(
sizeof...(Subindex) ==
sizeof...(CDim));
209 return Index::access_id(
210 ddc::type_seq_rank_v<CDim, typename Index::type_seq_dimensions>...);
212 return Index::access_id(
213 std::array<std::size_t,
sizeof...(Subindex)> {ddc::type_seq_rank_v<
214 typename ddc::type_seq_element_t<
215 ddc::type_seq_rank_v<Subindex, ddc::TypeSeq<Subindex...>>,
216 ddc::TypeSeq<CDim...>>,
217 typename Subindex::type_seq_dimensions>...});
223template <
class Index,
class IndicesTypeSeq,
class... CDim>
224KOKKOS_FUNCTION
static constexpr std::size_t access_id()
227 return IdFromTypeSeqDims<
229 ddc::DiscreteDomain<Index>,
230 type_seq_dims_at_ints_t<
231 ddc::TypeSeq<CDim...>,
233 NbDimsBeforeIndex<Index, IndicesTypeSeq>::operator()(0),
234 std::make_integer_sequence<std::size_t, Index::rank()>>>>::
237 return IdFromTypeSeqDims<
239 typename Index::subindices_domain_t,
240 type_seq_dims_at_ints_t<
241 ddc::TypeSeq<CDim...>,
243 NbDimsBeforeIndex<Index, IndicesTypeSeq>::operator()(0),
244 std::make_integer_sequence<std::size_t, Index::rank()>>>>::
249template <
class Index,
class SubindicesDomain>
252template <
class Index,
class... Subindex>
253struct IdFromElem<Index,
ddc::DiscreteDomain<Subindex...>>
255 template <
class Elem>
256 KOKKOS_FUNCTION
static constexpr std::size_t operator()(Elem natural_elem)
259 return Index::access_id(natural_elem.template uid<Index>());
261 return Index::access_id(
262 std::array<std::size_t,
sizeof...(Subindex)> {
263 natural_elem.template uid<Subindex>()...});
268template <
class Index,
class IndicesTypeSeq,
class... NaturalIndex>
269KOKKOS_FUNCTION
static constexpr std::size_t access_id(
270 ddc::DiscreteElement<NaturalIndex...> natural_elem)
273 return IdFromElem<Index, ddc::DiscreteDomain<Index>>::operator()(natural_elem);
275 return IdFromElem<Index, typename Index::subindices_domain_t>::operator()(natural_elem);
282template <TensorIndex... Index>
294 ddc::DiscreteDomain<Index>,
295 typename Index::subindices_domain_t>...>;
303 template <
class... CDim>
306 template <
class... NaturalIndex>
308 ddc::DiscreteElement<NaturalIndex...> natural_elem);
310 template <
class... MemIndex>
311 KOKKOS_FUNCTION
static constexpr natural_domain_t::discrete_element_type
318struct TensorAccessorForTypeSeq;
321struct TensorAccessorForTypeSeq<
ddc::TypeSeq<Index...>>
327struct TensorAccessorForDomain;
329template <
class... DDim>
330struct TensorAccessorForDomain<
ddc::DiscreteDomain<DDim...>>
332 using type =
typename TensorAccessorForTypeSeq<
335 ddc::DiscreteDomain<DDim>,
336 ddc::DiscreteDomain<>>...>>>::type;
341template <misc::Specialization<ddc::DiscreteDomain> Dom>
350template <
class Index>
351KOKKOS_FUNCTION
constexpr auto natural_domain()
354 return typename ddc::DiscreteDomain<
355 Index>(ddc::DiscreteElement<Index>(0), ddc::DiscreteVector<Index>(Index::size()));
357 return Index::subindices_domain();
362template <TensorIndex... Index>
364 Index...>::natural_domain()
373 return ddc::DiscreteDomain<Index...>(
374 ddc::DiscreteElement<Index...>(ddc::DiscreteElement<Index>(0)...),
375 ddc::DiscreteVector<Index...>(ddc::DiscreteVector<Index>(Index::mem_size())...));
380 Index...>::access_domain()
382 return ddc::DiscreteDomain<Index...>(
383 ddc::DiscreteElement<Index...>(ddc::DiscreteElement<Index>(0)...),
384 ddc::DiscreteVector<Index...>(ddc::DiscreteVector<Index>(Index::access_size())...));
388template <
class... CDim>
390 Index...>::access_element()
392 return ddc::DiscreteElement<Index...>(ddc::DiscreteElement<Index>(
393 detail::access_id<Index, ddc::TypeSeq<Index...>, CDim...>())...);
397template <
class... NaturalIndex>
399 access_element([[maybe_unused]] ddc::DiscreteElement<NaturalIndex...> natural_elem)
401 return ddc::DiscreteElement<Index...>(
402 ddc::DiscreteElement<Index>(detail::access_id<Index, ddc::TypeSeq<Index...>>(
403 typename natural_domain_t::discrete_element_type(natural_elem)))...);
407template <
class... MemIndex>
408KOKKOS_FUNCTION
constexpr TensorAccessor<Index...>::natural_domain_t::discrete_element_type
411 std::array<std::size_t, natural_domain_t::rank()> ids {};
412 auto it = ids.begin();
415 auto const i = MemIndex::mem_id_to_canonical_natural_ids(
416 mem_elem.template uid<MemIndex>());
417 misc::detail::copy(i.begin(), i.end(), it);
421 typename natural_domain_t::discrete_element_type natural_elem;
422 ddc::detail::array(natural_elem) = std::array<std::size_t, natural_domain_t::rank()>(ids);
432 class IndexHeadsTypeSeq,
443struct Access<TensorField, Element,
ddc::TypeSeq<IndexHead...>, IndexInterest, IndexTail...>
445 template <
class Elem>
446 KOKKOS_FUNCTION
static TensorField::element_type operator()(
447 TensorField
const& tensor_field,
456 if constexpr (
sizeof...(IndexTail) > 0) {
458 return IndexInterest::template process_access<TensorField, Elem, IndexInterest>(
459 KOKKOS_LAMBDA(TensorField
const& tensor_field_, Elem
const& elem_)
460 ->TensorField::element_type {
464 ddc::TypeSeq<IndexHead..., IndexInterest>,
465 IndexTail...>::operator()(tensor_field_, elem_);
473 ddc::TypeSeq<IndexHead..., IndexInterest>,
474 IndexTail...>::operator()(tensor_field, elem);
477 if constexpr (TensorIndex<IndexInterest>) {
478 return IndexInterest::template process_access<TensorField, Elem, IndexInterest>(
479 KOKKOS_LAMBDA(TensorField
const& tensor_field_, Elem
const& elem_)
480 ->TensorField::element_type {
481 double tensor_field_value = 0;
482 if constexpr (IndexInterest::is_explicitely_stored_tensor) {
483 std::size_t
const mem_id
484 = IndexInterest::access_id_to_mem_id(
485 elem_.template uid<IndexInterest>());
486 if (mem_id != std::numeric_limits<std::size_t>::max()) {
489 .mem(ddc::DiscreteElement<
490 IndexHead...>(elem_),
491 ddc::DiscreteElement<
492 IndexInterest>(mem_id));
494 tensor_field_value = 1.;
499 std::vector<std::size_t>>
const mem_lin_comb
500 = IndexInterest::access_id_to_mem_lin_comb(
501 elem_.template uid<IndexInterest>());
503 if (std::get<0>(mem_lin_comb).size() > 0) {
504 for (std::size_t i = 0;
505 i < std::get<0>(mem_lin_comb).size();
508 += std::get<0>(mem_lin_comb)[i]
510 ddc::DiscreteElement<
511 IndexHead...>(elem_),
512 ddc::DiscreteElement<
513 IndexInterest>(std::get<
518 tensor_field_value = 1.;
522 return tensor_field_value;
527 return tensor_field(elem);
534template <
class InterestDim>
537 template <
class Elem>
538 KOKKOS_FUNCTION
static ddc::DiscreteElement<InterestDim> operator()(Elem elem)
540 return ddc::DiscreteElement<InterestDim>(elem);
544template <TensorIndex InterestDim>
545struct LambdaMemElem<InterestDim>
547 template <
class Elem>
548 KOKKOS_FUNCTION
static ddc::DiscreteElement<InterestDim> operator()(Elem elem)
550 if constexpr (InterestDim::is_explicitely_stored_tensor) {
551 std::size_t
const mem_id
552 = InterestDim::access_id_to_mem_id(elem.template uid<InterestDim>());
553 assert(mem_id != std::numeric_limits<std::size_t>::max()
554 &&
"mem_elem is not defined because mem_id() returned a max integer. Maybe you "
555 "used Tensor::operator() in place of Tensor::get ?");
556 return ddc::DiscreteElement<InterestDim>(mem_id);
558 std::pair<std::vector<double>, std::vector<std::size_t>>
const mem_lin_comb
559 = InterestDim::access_id_to_mem_lin_comb(elem.template uid<InterestDim>());
560 assert(std::get<0>(mem_lin_comb).size() > 0
561 &&
"mem_elem is not defined because mem_lin_comb contains no id. Maybe you used "
562 "Tensor::operator() in place of Tensor::get ?");
563 assert(std::get<0>(mem_lin_comb).size() == 1
564 &&
"mem_elem is not defined because mem_lin_comb contains several ids. Maybe "
565 "you used Tensor::operator() in place of Tensor::get ?");
566 return ddc::DiscreteElement<InterestDim>(std::get<1>(mem_lin_comb)[0]);
575template <
class ElementType,
class SupportType,
class LayoutStr
idedPolicy,
class MemorySpace>
584template <
class ElementType,
class SupportType,
class LayoutStr
idedPolicy,
class MemorySpace>
585inline constexpr bool enable_chunk<
589template <
class ElementType,
class SupportType,
class LayoutStr
idedPolicy,
class MemorySpace>
590inline constexpr bool enable_borrowed_chunk<
603template <
class ElementType,
class... DDim,
class LayoutStridedPolicy,
class MemorySpace>
604class Tensor<ElementType,
ddc::DiscreteDomain<DDim...>, LayoutStridedPolicy, MemorySpace>
606 ChunkSpan<ElementType, ddc::DiscreteDomain<DDim...>, LayoutStridedPolicy, MemorySpace>
610 ChunkSpan<ElementType, ddc::DiscreteDomain<DDim...>, LayoutStridedPolicy, MemorySpace>;
613 using base_type::base_type;
618 using base_type::domain;
620 KOKKOS_FUNCTION
constexpr explicit Tensor(
623 ddc::DiscreteDomain<DDim...>,
625 MemorySpace> other) noexcept
632 ddc::DiscreteDomain<DDim>,
633 ddc::DiscreteDomain<>>...>>;
643 = ddc::detail::convert_type_seq_to_discrete_domain_t<ddc::type_seq_remove_t<
644 ddc::to_type_seq_t<discrete_domain_type>,
645 ddc::to_type_seq_t<indices_domain_t>>>;
658 cartesian_prod_t<non_indices_domain_t, typename accessor_t::natural_domain_t>;
662 return natural_domain_t(non_indices_domain(), accessor_t::natural_domain());
670 template <
class... CDim>
677 template <
class... Elem>
681 accessor_t::access_element(
682 typename accessor_t::natural_domain_t::discrete_element_type(elem...)),
683 typename non_indices_domain_t::discrete_element_type(elem...));
686 template <
class... Elem>
687 KOKKOS_FUNCTION
constexpr natural_domain_t::discrete_element_type canonical_natural_element(
688 Elem... mem_elem)
const noexcept
690 return typename natural_domain_t::discrete_element_type(
691 accessor_t::canonical_natural_element(
692 typename accessor_t::discrete_element_type(mem_elem...)),
693 typename non_indices_domain_t::discrete_element_type(mem_elem...));
696 template <
class... DElems>
697 KOKKOS_FUNCTION
constexpr reference mem(DElems
const&... delems)
const noexcept
699 return ddc::ChunkSpan<
701 ddc::DiscreteDomain<DDim...>,
703 MemorySpace>::operator()(delems...);
706 template <
class... DElems>
707 KOKKOS_FUNCTION
constexpr reference operator()(DElems
const&... delems)
const noexcept
709 return ddc::ChunkSpan<
711 ddc::DiscreteDomain<DDim...>,
714 operator()(ddc::DiscreteElement<DDim...>(
715 detail::LambdaMemElem<DDim>::operator()(ddc::DiscreteElement<DDim>(delems...))...));
718 template <
class... ODDim>
719 KOKKOS_FUNCTION
constexpr auto operator[](
720 ddc::DiscreteElement<ODDim...>
const& slice_spec)
const noexcept
722 ddc::ChunkSpan chunkspan = ddc::ChunkSpan<
724 ddc::DiscreteDomain<DDim...>,
727 operator[](ddc::DiscreteElement<ODDim...>(
728 detail::LambdaMemElem<ODDim>::operator()(slice_spec)...));
731 ddc::detail::convert_type_seq_to_discrete_domain_t<
732 ddc::type_seq_remove_t<ddc::TypeSeq<DDim...>, ddc::TypeSeq<ODDim...>>>,
733 typename decltype(chunkspan)::layout_type,
734 MemorySpace>(chunkspan);
737 template <
class... DElems>
738 KOKKOS_FUNCTION ElementType get(DElems
const&... delems)
const noexcept
740 if constexpr (
sizeof...(DDim) == 0) {
741 return operator()(delems...);
743 return detail::Access<
745 ddc::DiscreteDomain<DDim...>,
748 ddc::DiscreteElement<DDim...>,
750 DDim...>::operator()(*
this, ddc::DiscreteElement<DDim...>(delems...));
756 ddc::DiscreteDomain<DDim...>,
761 ddc::DiscreteDomain<DDim...>,
763 MemorySpace>& tensor)
765 ddc::device_for_each(this->domain(), [&](ddc::DiscreteElement<DDim...> elem) {
766 this->mem(elem) += tensor.mem(elem);
773 ddc::DiscreteDomain<DDim...>,
776 operator*=(
const ElementType scalar)
778 ddc::device_for_each(this->domain(), [&](ddc::DiscreteElement<DDim...> elem) {
779 this->mem(elem) *= scalar;
785template <
class ElementType,
class SupportType,
class Allocator>
786Tensor(ddc::Chunk<ElementType, SupportType, Allocator>)
789template <
class ElementType,
class SupportType,
class LayoutStr
idedPolicy,
class MemorySpace>
790Tensor(ddc::ChunkSpan<ElementType, SupportType, LayoutStridedPolicy, MemorySpace>)
793template <
class ElementType,
class SupportType>
797 Kokkos::layout_right,
798 Kokkos::DefaultHostExecutionSpace::memory_space>;
803template <
class Dom1,
class Dom2>
804struct NaturalTensorProdDomain;
806template <
class... DDim1,
class... DDim2>
807struct NaturalTensorProdDomain<
ddc::DiscreteDomain<DDim1...>, ddc::DiscreteDomain<DDim2...>>
809 using type = ddc::detail::convert_type_seq_to_discrete_domain_t<ddc::type_seq_merge_t<
810 ddc::type_seq_remove_t<ddc::TypeSeq<DDim1...>, ddc::TypeSeq<DDim2...>>,
811 ddc::type_seq_remove_t<ddc::TypeSeq<DDim2...>, ddc::TypeSeq<DDim1...>>>>;
832template <
class HeadDDim1TypeSeq,
class ContractDDimTypeSeq,
class TailDDim2TypeSeq>
833struct NaturalTensorProd;
835template <
class... HeadDDim1,
class... ContractDDim,
class... TailDDim2>
836struct NaturalTensorProd<
837 ddc::TypeSeq<HeadDDim1...>,
838 ddc::TypeSeq<ContractDDim...>,
839 ddc::TypeSeq<TailDDim2...>>
841 template <
class ElementType,
class LayoutStr
idedPolicy,
class MemorySpace>
842 KOKKOS_FUNCTION
static Tensor<
844 ddc::DiscreteDomain<HeadDDim1..., TailDDim2...>,
849 ddc::DiscreteDomain<HeadDDim1..., TailDDim2...>,
851 MemorySpace>
const& prod_tensor,
853 ddc::DiscreteDomain<HeadDDim1..., ContractDDim...>,
855 MemorySpace>
const& tensor1,
857 ddc::DiscreteDomain<ContractDDim..., TailDDim2...>,
859 MemorySpace>
const& tensor2)
861 ddc::device_for_each(
862 prod_tensor.domain(),
863 [&](ddc::DiscreteElement<HeadDDim1..., TailDDim2...> elem) {
864 prod_tensor(elem) = ddc::device_transform_reduce(
865 tensor1.template domain<ContractDDim...>(),
867 ddc::reducer::sum<ElementType>(),
868 [&](ddc::DiscreteElement<ContractDDim...> contract_elem) {
869 return tensor1(ddc::select<HeadDDim1...>(elem), contract_elem)
870 * tensor2(ddc::select<TailDDim2...>(elem), contract_elem);
880 TensorNatIndex... ProdDDim,
881 TensorNatIndex... DDim1,
882 TensorNatIndex... DDim2,
884 class LayoutStridedPolicy,
886Tensor<ElementType, ddc::DiscreteDomain<ProdDDim...>, LayoutStridedPolicy, MemorySpace> tensor_prod(
888 ddc::DiscreteDomain<ProdDDim...>,
890 MemorySpace>
const& prod_tensor,
891 Tensor<ElementType, ddc::DiscreteDomain<DDim1...>, LayoutStridedPolicy, MemorySpace>
const&
893 Tensor<ElementType, ddc::DiscreteDomain<DDim2...>, LayoutStridedPolicy, MemorySpace>
const&
896 static_assert(std::is_same_v<
897 ddc::type_seq_remove_t<ddc::TypeSeq<DDim1...>, ddc::TypeSeq<ProdDDim...>>,
898 ddc::type_seq_remove_t<ddc::TypeSeq<DDim2...>, ddc::TypeSeq<ProdDDim...>>>);
899 return detail::NaturalTensorProd<
900 ddc::type_seq_remove_t<ddc::TypeSeq<ProdDDim...>, ddc::TypeSeq<DDim2...>>,
901 ddc::type_seq_remove_t<ddc::TypeSeq<DDim1...>, ddc::TypeSeq<ProdDDim...>>,
902 ddc::type_seq_remove_t<ddc::TypeSeq<ProdDDim...>, ddc::TypeSeq<DDim1...>>>::
903 operator()(prod_tensor, tensor1, tensor2);
908template <
class HeadDom,
class InterestDom,
class TailDom>
911template <
class... HeadDDim,
class InterestDDim>
913 ddc::DiscreteDomain<HeadDDim...>,
914 ddc::DiscreteDomain<InterestDDim>,
915 ddc::DiscreteDomain<>>
917 template <
class TensorType>
918 static std::string operator()(
920 TensorType
const& tensor,
921 ddc::DiscreteElement<HeadDDim...> i)
923 for (ddc::DiscreteElement<InterestDDim> elem :
924 ddc::DiscreteDomain<InterestDDim>(tensor.natural_domain())) {
926 + std::to_string(tensor.get(tensor.access_element(
927 ddc::DiscreteElement<HeadDDim..., InterestDDim>(i, elem))));
934template <
class... HeadDDim,
class InterestDDim,
class HeadOfTailDDim,
class... TailOfTailDDim>
936 ddc::DiscreteDomain<HeadDDim...>,
937 ddc::DiscreteDomain<InterestDDim>,
938 ddc::DiscreteDomain<HeadOfTailDDim, TailOfTailDDim...>>
940 template <
class TensorType>
941 static std::string operator()(
943 TensorType
const& tensor,
944 ddc::DiscreteElement<HeadDDim...> i)
947 for (ddc::DiscreteElement<InterestDDim> elem :
948 ddc::DiscreteDomain<InterestDDim>(tensor.natural_domain())) {
950 ddc::DiscreteDomain<HeadDDim..., InterestDDim>,
951 ddc::DiscreteDomain<HeadOfTailDDim>,
952 ddc::DiscreteDomain<TailOfTailDDim...>>::
953 operator()(str, tensor, ddc::DiscreteElement<HeadDDim..., InterestDDim>(i, elem));
962template <misc::Specialization<Tensor> TensorType>
963std::ostream& operator<<(std::ostream& os, TensorType
const& tensor)
965 std::string str =
"";
966 os << detail::PrintTensor<
967 ddc::DiscreteDomain<>,
968 ddc::DiscreteDomain<ddc::type_seq_element_t<
970 ddc::to_type_seq_t<typename TensorType::natural_domain_t>>>,
971 ddc::detail::convert_type_seq_to_discrete_domain_t<ddc::type_seq_remove_t<
972 ddc::to_type_seq_t<typename TensorType::natural_domain_t>,
973 ddc::TypeSeq<ddc::type_seq_element_t<
975 ddc::to_type_seq_t<typename TensorType::natural_domain_t>>>>>>::
976 operator()(str, tensor, ddc::DiscreteElement<>());
KOKKOS_FUNCTION constexpr TensorAccessor()
static KOKKOS_FUNCTION constexpr discrete_element_type access_element()
static KOKKOS_FUNCTION constexpr natural_domain_t natural_domain()
static KOKKOS_FUNCTION constexpr discrete_domain_type access_domain()
sil::misc::cartesian_prod_t< std::conditional_t< TensorNatIndex< Index >, ddc::DiscreteDomain< Index >, typename Index::subindices_domain_t >... > natural_domain_t
ddc::DiscreteDomain< Index... > discrete_domain_type
ddc::DiscreteElement< Index... > discrete_element_type
static KOKKOS_FUNCTION constexpr natural_domain_t::discrete_element_type canonical_natural_element(ddc::DiscreteElement< MemIndex... > mem_elem)
static KOKKOS_FUNCTION constexpr discrete_domain_type domain()
ddc:: ChunkSpan< ElementType, ddc::DiscreteDomain< DDim... >, LayoutStridedPolicy, MemorySpace > base_type
static KOKKOS_FUNCTION constexpr accessor_t accessor()
base_type::discrete_domain_type discrete_domain_type
base_type::discrete_element_type discrete_element_type
sil::misc:: cartesian_prod_t< non_indices_domain_t, typename accessor_t::natural_domain_t > natural_domain_t
tensor_accessor_for_domain_t< sil::misc::cartesian_prod_t< std::conditional_t< TensorIndex< DDim >, ddc::DiscreteDomain< DDim >, ddc::DiscreteDomain<> >... > > accessor_t
ddc::detail::convert_type_seq_to_discrete_domain_t< ddc::type_seq_remove_t< ddc::to_type_seq_t< discrete_domain_type >, ddc::to_type_seq_t< indices_domain_t > > > non_indices_domain_t
KOKKOS_FUNCTION constexpr Tensor(ddc::ChunkSpan< ElementType, ddc::DiscreteDomain< DDim... >, LayoutStridedPolicy, MemorySpace > other) noexcept
accessor_t::discrete_domain_type indices_domain_t
base_type::reference reference
convert_type_seq_to_t< ddc::DiscreteDomain, typename detail::CartesianProd< Domains... >::type > cartesian_prod_t
Tensor(ddc::Chunk< ElementType, SupportType, Allocator >) -> Tensor< ElementType, SupportType, Kokkos::layout_right, typename Allocator::memory_space >
detail::NaturalTensorProdDomain< Dom1, Dom2 >::type natural_tensor_prod_domain_t
natural_tensor_prod_domain_t< Dom1, Dom2 > natural_tensor_prod_domain(Dom1 dom1, Dom2 dom2)
typename detail::NaturalDomainType< Index >::type natural_domain_t
detail::TensorAccessorForDomain< Dom >::type tensor_accessor_for_domain_t
The top-level namespace of SimiLie.
static KOKKOS_FUNCTION constexpr std::size_t mem_id(std::size_t const natural_id)
static KOKKOS_FUNCTION constexpr std::size_t mem_id()
ddc::DiscreteDomain<> subindices_domain_t
static KOKKOS_FUNCTION constexpr subindices_domain_t subindices_domain()
static KOKKOS_FUNCTION constexpr std::size_t access_id_to_mem_id(std::size_t access_id)
static constexpr std::size_t mem_size()
static constexpr bool is_explicitely_stored_tensor
ddc::TypeSeq< CDim... > type_seq_dimensions
static KOKKOS_FUNCTION constexpr std::size_t access_id(std::size_t const natural_id)
static constexpr std::size_t rank()
static constexpr std::size_t size()
static KOKKOS_FUNCTION constexpr Tensor::element_type process_access(const FunctorType &access, Tensor const &tensor, Elem const &elem)
static KOKKOS_FUNCTION constexpr std::array< std::size_t, rank()> mem_id_to_canonical_natural_ids(std::size_t mem_id)
static constexpr bool is_tensor_natural_index
static constexpr std::size_t access_size()
static constexpr bool is_tensor_index