Tensor fields as new kind of sampling

[blegouix]

This is clearly unrelated to current developments but I had the following idea to describe tensor fields:

I think we could have a new kind of discrete_space aiming to enumerate the elements of a tensor, in the spirit of:

template <class... TensorTags>
class Tensor
{
public:
    template <class DDim, class MemorySpace>
    class Impl { ... }
    
    template <class DDim>
    init(DiscreteVector<TensorTags...> tensor_sizes) {
        // Instantiate an Impl 
        ...
        DiscreteDomain<DDim> domain(0, tensor_sizes.size());
        return std::make_tuple(std::move(disc), std::move(domain));
    }
    
    DiscreteElement<DDim> get_element(DiscreteElement<TensorTags...> e)
    {
       const int uid = ... // Gives a way to produce a unique uid associated to the combination of uids in e
       return DiscreteElement<DDim>(uid);
    }
 }

Then the idea would be to use TensorTags to describe the dimensions of the tensor (like, for a 2D tensor T_{\mu\nu} we would have TensorTags... = Mu, Nu. We could then write the associated DiscreteDomain:

struct DDim{};
DiscreteDomain tensor_dom = Tensor<Mu,Nu>::init<DDim>(DiscreteVector<Mu,Nu>(4,4)); // Build a DiscreteDomain allowing to describe 4x4 tensors.

It would then allow to build supports for tensor_fields:

DiscreteDomain tensor_field_support(mesh, tensor_dom);

The advantages I see are:

• In the spirit of the core concepts of DDC
• Allow to describe any kind of tensor (vector, ND tensor etc...)
• User has control on memory layout (tensor_field_support(mesh, tensor_dom) vs tensor_field_support(tensor_dom, mesh))

(I hope there are not too much mistakes in the code I have written here and the intention is understandable)

[tpadioleau]

ChunkSpan should already represent a tensor field ? Let us say you want to store $T_{1 \leq \mu \leq m, 1 \leq \nu \leq n}(x, y, z)$, then a

ChunkSpan<double, DiscreteDomain<Mu, Nu, DDimX, DDimY, DDimZ>>

should be a representation of it, isn't it ?

I did not get any notification of the creation of this discussion. I only see it now.

[blegouix]

Yes that's right. I overthinked another problem while not solving it, which was allowing to have a discrete dimension Mu which contains the link:

Mu<T>() -> Mu(0)
Mu<X>() -> Mu(1)
Mu<Y>() -> Mu(2)
Mu<Z>() -> Mu(3)

And afterward we can proceed as you said to build domains with conveniant access to its element. But the way to build the class Mu is a whole different topic.