I am using RDataFrame in Python and when using indices to access vector entries I notice some weird behavior when the index is out of scope of the variable.
In the case where the accessed index is greater than the size of the vector for this event, it defaults to the last found value at this index from a previous event.
I have a minimal working example here: testDF.py (751 Bytes)
Is this behavior known or intended?
Are there any workarounds except for checking the vector size before trying to access an element through the index?
Would it be better to have the script crash in case of accessing such an index?
Thanks for the post and welcome to the ROOT Community!
I had a look to your example (thanks for sharing). What you are experiencing can be easily explained.
Accessing elements of the vector with the operator[]is undefined behaviour in C++. Therefore anything can happen (see below for my explanation about why you see previous values). If you want to cause a crash, you can use the operator at() (see here). This behaviour makes sense: it’s like that for performance reasons.
Let me now come to your example.
During the read process, the number of allocations performed by ROOT for the destination vector is minimised: this is done for performance reasons - in your case it would not make any difference, it clearly does at scale (hundreds of vector columns read over millions of entries). In case the vector is filled with less values than for a previous entry, the runtime does not assign a smaller chunk of memory to the vector storage, but simply changes the value of its size, leaving the previous memory in place, and without zeroing the rest of the memory (again for performance reasons). It then so happens that accessing the vector beyond its current size, you access memory previously allocated and correctly filled (with previous values in your TTree!).
I hope this helps clarifying the situation… It seems a bit surprising, but everything makes perfect sense and it’s not really a bug of ROOT or the STL, it’s just an undefined behaviour that, by chance, does not cause a crash or reading allocated but uninitialised memory
