# Interpolation forvector-valued element (e.g. Raviart-Thomas) inconsistent

The interpolation of the vector-valued Raviart-Thomas functions is somehow inconsistent.

For H(div) functions, it is only meaningful to assign values in the normal direction of a vector valued function. Therefore dune-localfunctions projects the original function in normal direction. There is two possibilities to define such an *original function*: scalar-valued or vector-valued. Let's distinguish:

- In the interpolation process of dune-functions, scalar-valued functions will be automatically transformed to vectors. I think this trick is rather dirty as in the end, if thinking of BCs, it would be natural that the
*original function*is projected in outer normal direction first and then interpolated. However, this is not the case, as e.g. orientation of normal vectors is not taken into account - Assuming, a vector-valued function is used, the produced result is actually wrong. And I believe it is due to an implementation of interpolate.hh in dune-functions. In particular, if I understand correctly, in the LocalInterpolateVisitor, a local view of a grid function is addressed component-wise (here component j):

`auto localFj = [&](const LocalDomain& x){ `

` const auto& y = localF_(x); // still correct`

` return FiniteElementRange(flatVectorView(nodeToRangeEntry_(node, treePath, y))[j]);`

`};`

The problem for the vector-valued Raviart-Thomas elements is that the subsequent code does not lead to increasing `j`

such that always only the first component of the _original function _ is utilized for interpolation. This leads to errors. So far I used very simple output messages to analyze this.

After all, maybe vector-valued local finite elements have not been considered when implementing interpolate?