Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
ROOT::VecOps::RVec< T > Class Template Reference

template<typename T>
class ROOT::VecOps::RVec< T >

A "std::vector"-like collection of values implementing handy operation to analyse them.

Template Parameters
TThe type of the contained objects

A RVec is a container designed to make analysis of values' collections fast and easy. Its storage is contiguous in memory and its interface is designed such to resemble to the one of the stl vector. In addition the interface features methods and external functions to ease the manipulation and analysis of the data in the RVec.

DOI

Table of Contents

Also see the reference for RVec helper functions.

Example

Suppose to have an event featuring a collection of muons with a certain pseudorapidity, momentum and charge, e.g.:

std::vector<short> mu_charge {1, 1, -1, -1, -1, 1, 1, -1};
std::vector<float> mu_pt {56, 45, 32, 24, 12, 8, 7, 6.2};
std::vector<float> mu_eta {3.1, -.2, -1.1, 1, 4.1, 1.6, 2.4, -.5};

Suppose you want to extract the transverse momenta of the muons satisfying certain criteria, for example consider only negatively charged muons with a pseudorapidity smaller or equal to 2 and with a transverse momentum greater than 10 GeV. Such a selection would require, among the other things, the management of an explicit loop, for example:

std::vector<float> goodMuons_pt;
const auto size = mu_charge.size();
for (size_t i=0; i < size; ++i) {
if (mu_pt[i] > 10 && abs(mu_eta[i]) <= 2. && mu_charge[i] == -1) {
goodMuons_pt.emplace_back(mu_pt[i]);
}
}
size_type size() const noexcept
Definition RVec.hxx:433

These operations become straightforward with RVec - we just need to write what we mean:

auto goodMuons_pt = mu_pt[ (mu_pt > 10.f && abs(mu_eta) <= 2.f && mu_charge == -1) ]

Now the clean collection of transverse momenta can be used within the rest of the data analysis, for example to fill a histogram.

Owning and adopting memory

RVec has contiguous memory associated to it. It can own it or simply adopt it. In the latter case, it can be constructed with the address of the memory associated to it and its length. For example:

std::vector<int> myStlVec {1,2,3};
RVec<int> myRVec(myStlVec.data(), myStlVec.size());
A "std::vector"-like collection of values implementing handy operation to analyse them.
Definition RVec.hxx:296

In this case, the memory associated to myStlVec and myRVec is the same, myRVec simply "adopted it". If any method which implies a re-allocation is called, e.g. emplace_back or resize, the adopted memory is released and new one is allocated. The previous content is copied in the new memory and preserved.

Sorting and manipulation of indices

Sorting

RVec complies to the STL interfaces when it comes to iterations. As a result, standard algorithms can be used, for example sorting:

RVec<double> v{6., 4., 5.};
std::sort(v.begin(), v.end());

For convinience, helpers are provided too:

auto sorted_v = Sort(v);
auto reversed_v = Reverse(v);
RVec< T > Reverse(const RVec< T > &v)
Return copy of reversed vector.
Definition RVec.hxx:1116
RVec< T > Sort(const RVec< T > &v)
Return copy of RVec with elements sorted in ascending order.
Definition RVec.hxx:1137

Manipulation of indices

It is also possible to manipulated the RVecs acting on their indices. For example, the following syntax

RVec<double> v0 {9., 7., 8.};
auto v1 = Take(v0, {1, 2, 0});
RVec< T > Take(const RVec< T > &v, const RVec< typename RVec< T >::size_type > &i)
Return elements of a vector at given indices.
Definition RVec.hxx:1058

will yield a new RVec<double> the content of which is the first, second and zeroth element of v0, i.e. {7., 8., 9.}.

The Argsort helper extracts the indices which order the content of a RVec. For example, this snippet accomplish in a more expressive way what we just achieved:

auto v1_indices = Argsort(v0); // The content of v1_indices is {1, 2, 0}.
v1 = Take(v0, v1_indices);
RVec< typename RVec< T >::size_type > Argsort(const RVec< T > &v)
Return an RVec of indices that sort the input RVec.
Definition RVec.hxx:1038

The Take utility allows to extract portions of the RVec. The content to be taken can be specified with an RVec of indices or an integer. If the integer is negative, elements will be picked starting from the end of the container:

RVec<float> vf {1.f, 2.f, 3.f, 4.f};
auto vf_1 = Take(vf, {1, 3}); // The content is {2.f, 4.f}
auto vf_2 = Take(vf, 2); // The content is {1.f, 2.f}
auto vf_3 = Take(vf, -3); // The content is {2.f, 3.f, 4.f}

Usage in combination with RDataFrame

RDataFrame leverages internally RVecs. Suppose to have a dataset stored in a TTree which holds these columns (here we choose C arrays to represent the collections, they could be as well std::vector instances):

nPart "nPart/I" An integer representing the number of particles
px "px[nPart]/D" The C array of the particles' x component of the momentum
py "py[nPart]/D" The C array of the particles' y component of the momentum
E "E[nPart]/D" The C array of the particles' Energy

Suppose you'd like to plot in a histogram the transverse momenta of all particles for which the energy is greater than 200 MeV. The code required would just be:

RDataFrame d("mytree", "myfile.root");
using doubles = RVec<double>;
auto cutPt = [](doubles &pxs, doubles &pys, doubles &Es) {
auto all_pts = sqrt(pxs * pxs + pys * pys);
auto good_pts = all_pts[Es > 200.];
return good_pts;
};
auto hpt = d.Define("pt", cutPt, {"px", "py", "E"})
.Histo1D("pt");
hpt->Draw();
#define d(i)
Definition RSha256.hxx:102
double sqrt(double)
ROOT's RDataFrame offers a high level interface for analyses of data stored in TTrees,...

And if you'd like to express your selection as a string:

RDataFrame d("mytree", "myfile.root");
auto hpt = d.Define("pt", "sqrt(pxs * pxs + pys * pys)[E>200]")
.Histo1D("pt");
hpt->Draw();

PyROOT

The ROOT::RVec class has additional features in Python, which allow to adopt memory from Numpy arrays and vice versa. The purpose of these features is the copyless interfacing of Python and C++ using their most common data containers, Numpy arrays and RVec with a std::vector interface.

Conversion of RVecs to Numpy arrays

RVecs of fundamental types (int, float, ...) have in Python the __array_interface__ attribute attached. This information allows Numpy to adopt the memory of RVecs without copying the content. You can find further documentation regarding the Numpy array interface here. The following code example demonstrates the memory adoption mechanism using numpy.asarray.

rvec = ROOT.RVec('double')((1, 2, 3))
print(rvec) # { 1.0000000, 2.0000000, 3.0000000 }
npy = numpy.asarray(rvec)
print(npy) # [1. 2. 3.]
rvec[0] = 42
print(npy) # [42. 2. 3.]

Conversion of Numpy arrays to RVecs

Data owned by Numpy arrays with fundamental types (int, float, ...) can be adopted by RVecs. To create an RVec from a Numpy array, ROOT offers the facility ROOT.VecOps.AsRVec, which performs a similar operation to numpy.asarray, but vice versa. A code example demonstrating the feature and the adoption of the data owned by the Numpy array is shown below.

npy = numpy.array([1.0, 2.0, 3.0])
print(npy) # [1. 2. 3.]
rvec = ROOT.VecOps.AsRVec(npy)
print(rvec) # { 1.0000000, 2.0000000, 3.0000000 }
npy[0] = 42
print(rvec) # { 42.000000, 2.0000000, 3.0000000 }

Definition at line 296 of file RVec.hxx.

Public Types

using const_data_t = typename std::conditional< IsVecBool, void, typename Impl_t::const_pointer >::type
 
using const_iterator = typename Impl_t::const_iterator
 
using const_pointer = typename Impl_t::const_pointer
 
using const_reference = typename Impl_t::const_reference
 
using const_reverse_iterator = typename Impl_t::const_reverse_iterator
 
using data_t = typename std::conditional< IsVecBool, void, typename Impl_t::pointer >::type
 
using difference_type = typename Impl_t::difference_type
 
using Impl_t = typename std::conditional< IsVecBool, std::vector< bool >, std::vector< T, ::ROOT::Detail::VecOps::RAdoptAllocator< T > > >::type
 
using iterator = typename Impl_t::iterator
 
using pointer = typename Impl_t::pointer
 
using reference = typename Impl_t::reference
 
using reverse_iterator = typename Impl_t::reverse_iterator
 
using size_type = typename Impl_t::size_type
 
using value_type = typename Impl_t::value_type
 

Public Member Functions

 RVec ()
 
 RVec (const RVec< T > &v)
 
 RVec (const std::vector< T > &v)
 
template<class InputIt >
 RVec (InputIt first, InputIt last)
 
 RVec (pointer p, size_type n)
 
 RVec (RVec< T > &&v)
 
 RVec (size_type count)
 
 RVec (size_type count, const T &value)
 
 RVec (std::initializer_list< T > init)
 
reference at (size_type pos)
 
const_reference at (size_type pos) const
 
value_type at (size_type pos, value_type fallback)
 No exception thrown. The user specifies the desired value in case the RVec is shorter than pos.
 
value_type at (size_type pos, value_type fallback) const
 No exception thrown. The user specifies the desired value in case the RVec is shorter than pos.
 
reference back ()
 
const_reference back () const
 
const_iterator begin () const noexcept
 
iterator begin () noexcept
 
size_type capacity () const noexcept
 
const_iterator cbegin () const noexcept
 
const_iterator cend () const noexcept
 
void clear () noexcept
 
const_reverse_iterator crbegin () const noexcept
 
const_reverse_iterator crend () const noexcept
 
const_data_t data () const noexcept
 
data_t data () noexcept
 
template<typename U = T, typename std::enable_if< std::is_arithmetic< U >::value, int > * = nullptr>
iterator emplace (const_iterator pos, U value)
 This method is intended only for arithmetic types unlike the std::vector corresponding one which is generic.
 
template<class... Args>
reference emplace_back (Args &&... args)
 
bool empty () const noexcept
 
const_iterator end () const noexcept
 
iterator end () noexcept
 
iterator erase (iterator first, iterator last)
 
iterator erase (iterator pos)
 
reference front ()
 
const_reference front () const
 
size_type max_size () const noexcept
 
template<typename U , typename = std::enable_if<std::is_convertible<T, U>::value>>
 operator RVec () const
 
RVec< T > & operator= (const RVec< T > &v)
 
RVec< T > & operator= (RVec< T > &&v)
 
RVec< T > & operator= (std::initializer_list< T > ilist)
 
template<typename V , typename = std::enable_if<std::is_convertible<V, bool>::value>>
RVec operator[] (const RVec< V > &conds) const
 
reference operator[] (size_type pos)
 
const_reference operator[] (size_type pos) const
 
void pop_back ()
 
void push_back (const value_type &value)
 
void push_back (T &&value)
 
 R__DEPRECATED (6, 26, "Please use `std::vector<T>(rvec.begin(), rvec.end())` instead.") const Impl_t &AsVector() const
 
 R__DEPRECATED (6, 26, "Please use `std::vector<T>(rvec.begin(), rvec.end())` instead.") Impl_t &AsVector()
 
const_reverse_iterator rbegin () const noexcept
 
reverse_iterator rbegin () noexcept
 
const_reverse_iterator rend () const noexcept
 
reverse_iterator rend () noexcept
 
void reserve (size_type new_cap)
 
void resize (size_type count)
 
void resize (size_type count, const value_type &value)
 
void shrink_to_fit ()
 
size_type size () const noexcept
 
void swap (RVec< T > &other)
 

Private Member Functions

friend void ::ROOT::Internal::RDF::SetBranchesHelper (ROOT::Internal::RDF::BoolArrayMap &boolArrays, TTree *inputTree, TTree &outputTree, const std::string &inName, const std::string &outName, TBranch *&branch, void *&branchAddress, RVec< T > *ab, ROOT::Internal::RDF::RBranchSet &outputBranches)
 

Private Attributes

Impl_t fData
 

Static Private Attributes

static constexpr const auto IsVecBool = std::is_same<bool, T>::value
 

#include <ROOT/RVec.hxx>

Member Typedef Documentation

◆ const_data_t

template<typename T >
using ROOT::VecOps::RVec< T >::const_data_t = typename std::conditional<IsVecBool, void, typename Impl_t::const_pointer>::type

Definition at line 321 of file RVec.hxx.

◆ const_iterator

template<typename T >
using ROOT::VecOps::RVec< T >::const_iterator = typename Impl_t::const_iterator

Definition at line 323 of file RVec.hxx.

◆ const_pointer

template<typename T >
using ROOT::VecOps::RVec< T >::const_pointer = typename Impl_t::const_pointer

Definition at line 317 of file RVec.hxx.

◆ const_reference

template<typename T >
using ROOT::VecOps::RVec< T >::const_reference = typename Impl_t::const_reference

Definition at line 315 of file RVec.hxx.

◆ const_reverse_iterator

template<typename T >
using ROOT::VecOps::RVec< T >::const_reverse_iterator = typename Impl_t::const_reverse_iterator

Definition at line 325 of file RVec.hxx.

◆ data_t

template<typename T >
using ROOT::VecOps::RVec< T >::data_t = typename std::conditional<IsVecBool, void, typename Impl_t::pointer>::type

Definition at line 320 of file RVec.hxx.

◆ difference_type

template<typename T >
using ROOT::VecOps::RVec< T >::difference_type = typename Impl_t::difference_type

Definition at line 313 of file RVec.hxx.

◆ Impl_t

template<typename T >
using ROOT::VecOps::RVec< T >::Impl_t = typename std::conditional<IsVecBool, std::vector<bool>, std::vector<T, ::ROOT::Detail::VecOps::RAdoptAllocator<T> >>::type

Definition at line 310 of file RVec.hxx.

◆ iterator

template<typename T >
using ROOT::VecOps::RVec< T >::iterator = typename Impl_t::iterator

Definition at line 322 of file RVec.hxx.

◆ pointer

template<typename T >
using ROOT::VecOps::RVec< T >::pointer = typename Impl_t::pointer

Definition at line 316 of file RVec.hxx.

◆ reference

template<typename T >
using ROOT::VecOps::RVec< T >::reference = typename Impl_t::reference

Definition at line 314 of file RVec.hxx.

◆ reverse_iterator

template<typename T >
using ROOT::VecOps::RVec< T >::reverse_iterator = typename Impl_t::reverse_iterator

Definition at line 324 of file RVec.hxx.

◆ size_type

template<typename T >
using ROOT::VecOps::RVec< T >::size_type = typename Impl_t::size_type

Definition at line 312 of file RVec.hxx.

◆ value_type

template<typename T >
using ROOT::VecOps::RVec< T >::value_type = typename Impl_t::value_type

Definition at line 311 of file RVec.hxx.

Constructor & Destructor Documentation

◆ RVec() [1/9]

template<typename T >
ROOT::VecOps::RVec< T >::RVec ( )
inline

Definition at line 332 of file RVec.hxx.

◆ RVec() [2/9]

template<typename T >
ROOT::VecOps::RVec< T >::RVec ( size_type  count)
inlineexplicit

Definition at line 334 of file RVec.hxx.

◆ RVec() [3/9]

template<typename T >
ROOT::VecOps::RVec< T >::RVec ( size_type  count,
const T &  value 
)
inline

Definition at line 336 of file RVec.hxx.

◆ RVec() [4/9]

template<typename T >
ROOT::VecOps::RVec< T >::RVec ( const RVec< T > &  v)
inline

Definition at line 338 of file RVec.hxx.

◆ RVec() [5/9]

template<typename T >
ROOT::VecOps::RVec< T >::RVec ( RVec< T > &&  v)
inline

Definition at line 340 of file RVec.hxx.

◆ RVec() [6/9]

template<typename T >
ROOT::VecOps::RVec< T >::RVec ( const std::vector< T > &  v)
inline

Definition at line 342 of file RVec.hxx.

◆ RVec() [7/9]

template<typename T >
ROOT::VecOps::RVec< T >::RVec ( pointer  p,
size_type  n 
)
inline

Definition at line 344 of file RVec.hxx.

◆ RVec() [8/9]

template<typename T >
template<class InputIt >
ROOT::VecOps::RVec< T >::RVec ( InputIt  first,
InputIt  last 
)
inline

Definition at line 347 of file RVec.hxx.

◆ RVec() [9/9]

template<typename T >
ROOT::VecOps::RVec< T >::RVec ( std::initializer_list< T >  init)
inline

Definition at line 349 of file RVec.hxx.

Member Function Documentation

◆ at() [1/4]

template<typename T >
reference ROOT::VecOps::RVec< T >::at ( size_type  pos)
inline

Definition at line 387 of file RVec.hxx.

◆ at() [2/4]

template<typename T >
const_reference ROOT::VecOps::RVec< T >::at ( size_type  pos) const
inline

Definition at line 388 of file RVec.hxx.

◆ at() [3/4]

template<typename T >
value_type ROOT::VecOps::RVec< T >::at ( size_type  pos,
value_type  fallback 
)
inline

No exception thrown. The user specifies the desired value in case the RVec is shorter than pos.

Definition at line 390 of file RVec.hxx.

◆ at() [4/4]

template<typename T >
value_type ROOT::VecOps::RVec< T >::at ( size_type  pos,
value_type  fallback 
) const
inline

No exception thrown. The user specifies the desired value in case the RVec is shorter than pos.

Definition at line 392 of file RVec.hxx.

◆ back() [1/2]

template<typename T >
reference ROOT::VecOps::RVec< T >::back ( )
inline

Definition at line 414 of file RVec.hxx.

◆ back() [2/2]

template<typename T >
const_reference ROOT::VecOps::RVec< T >::back ( ) const
inline

Definition at line 415 of file RVec.hxx.

◆ begin() [1/2]

template<typename T >
const_iterator ROOT::VecOps::RVec< T >::begin ( ) const
inlinenoexcept

Definition at line 420 of file RVec.hxx.

◆ begin() [2/2]

template<typename T >
iterator ROOT::VecOps::RVec< T >::begin ( )
inlinenoexcept

Definition at line 419 of file RVec.hxx.

◆ capacity()

template<typename T >
size_type ROOT::VecOps::RVec< T >::capacity ( ) const
inlinenoexcept

Definition at line 436 of file RVec.hxx.

◆ cbegin()

template<typename T >
const_iterator ROOT::VecOps::RVec< T >::cbegin ( ) const
inlinenoexcept

Definition at line 421 of file RVec.hxx.

◆ cend()

template<typename T >
const_iterator ROOT::VecOps::RVec< T >::cend ( ) const
inlinenoexcept

Definition at line 424 of file RVec.hxx.

◆ clear()

template<typename T >
void ROOT::VecOps::RVec< T >::clear ( )
inlinenoexcept

Definition at line 439 of file RVec.hxx.

◆ crbegin()

template<typename T >
const_reverse_iterator ROOT::VecOps::RVec< T >::crbegin ( ) const
inlinenoexcept

Definition at line 427 of file RVec.hxx.

◆ crend()

template<typename T >
const_reverse_iterator ROOT::VecOps::RVec< T >::crend ( ) const
inlinenoexcept

Definition at line 430 of file RVec.hxx.

◆ data() [1/2]

template<typename T >
const_data_t ROOT::VecOps::RVec< T >::data ( ) const
inlinenoexcept

Definition at line 417 of file RVec.hxx.

◆ data() [2/2]

template<typename T >
data_t ROOT::VecOps::RVec< T >::data ( )
inlinenoexcept

Definition at line 416 of file RVec.hxx.

◆ emplace()

template<typename T >
template<typename U = T, typename std::enable_if< std::is_arithmetic< U >::value, int > * = nullptr>
iterator ROOT::VecOps::RVec< T >::emplace ( const_iterator  pos,
value 
)
inline

This method is intended only for arithmetic types unlike the std::vector corresponding one which is generic.

Definition at line 453 of file RVec.hxx.

◆ emplace_back()

template<typename T >
template<class... Args>
reference ROOT::VecOps::RVec< T >::emplace_back ( Args &&...  args)
inline

Definition at line 445 of file RVec.hxx.

◆ empty()

template<typename T >
bool ROOT::VecOps::RVec< T >::empty ( ) const
inlinenoexcept

Definition at line 432 of file RVec.hxx.

◆ end() [1/2]

template<typename T >
const_iterator ROOT::VecOps::RVec< T >::end ( ) const
inlinenoexcept

Definition at line 423 of file RVec.hxx.

◆ end() [2/2]

template<typename T >
iterator ROOT::VecOps::RVec< T >::end ( )
inlinenoexcept

Definition at line 422 of file RVec.hxx.

◆ erase() [1/2]

template<typename T >
iterator ROOT::VecOps::RVec< T >::erase ( iterator  first,
iterator  last 
)
inline

Definition at line 441 of file RVec.hxx.

◆ erase() [2/2]

template<typename T >
iterator ROOT::VecOps::RVec< T >::erase ( iterator  pos)
inline

Definition at line 440 of file RVec.hxx.

◆ front() [1/2]

template<typename T >
reference ROOT::VecOps::RVec< T >::front ( )
inline

Definition at line 412 of file RVec.hxx.

◆ front() [2/2]

template<typename T >
const_reference ROOT::VecOps::RVec< T >::front ( ) const
inline

Definition at line 413 of file RVec.hxx.

◆ max_size()

template<typename T >
size_type ROOT::VecOps::RVec< T >::max_size ( ) const
inlinenoexcept

Definition at line 434 of file RVec.hxx.

◆ operator RVec()

template<typename T >
template<typename U , typename = std::enable_if<std::is_convertible<T, U>::value>>
ROOT::VecOps::RVec< T >::operator RVec ( ) const
inline

Definition at line 372 of file RVec.hxx.

◆ operator=() [1/3]

template<typename T >
RVec< T > & ROOT::VecOps::RVec< T >::operator= ( const RVec< T > &  v)
inline

Definition at line 352 of file RVec.hxx.

◆ operator=() [2/3]

template<typename T >
RVec< T > & ROOT::VecOps::RVec< T >::operator= ( RVec< T > &&  v)
inline

Definition at line 358 of file RVec.hxx.

◆ operator=() [3/3]

template<typename T >
RVec< T > & ROOT::VecOps::RVec< T >::operator= ( std::initializer_list< T >  ilist)
inline

Definition at line 364 of file RVec.hxx.

◆ operator[]() [1/3]

template<typename T >
template<typename V , typename = std::enable_if<std::is_convertible<V, bool>::value>>
RVec ROOT::VecOps::RVec< T >::operator[] ( const RVec< V > &  conds) const
inline

Definition at line 397 of file RVec.hxx.

◆ operator[]() [2/3]

template<typename T >
reference ROOT::VecOps::RVec< T >::operator[] ( size_type  pos)
inline

Definition at line 393 of file RVec.hxx.

◆ operator[]() [3/3]

template<typename T >
const_reference ROOT::VecOps::RVec< T >::operator[] ( size_type  pos) const
inline

Definition at line 394 of file RVec.hxx.

◆ pop_back()

template<typename T >
void ROOT::VecOps::RVec< T >::pop_back ( )
inline

Definition at line 457 of file RVec.hxx.

◆ push_back() [1/2]

template<typename T >
void ROOT::VecOps::RVec< T >::push_back ( const value_type value)
inline

Definition at line 443 of file RVec.hxx.

◆ push_back() [2/2]

template<typename T >
void ROOT::VecOps::RVec< T >::push_back ( T &&  value)
inline

Definition at line 442 of file RVec.hxx.

◆ R__DEPRECATED() [1/2]

template<typename T >
ROOT::VecOps::RVec< T >::R__DEPRECATED ( ,
26  ,
"Please use `std::vector<T>(rvec.begin(), rvec.end())` instead."   
) const &
inline

Definition at line 379 of file RVec.hxx.

◆ R__DEPRECATED() [2/2]

template<typename T >
ROOT::VecOps::RVec< T >::R__DEPRECATED ( ,
26  ,
"Please use `std::vector<T>(rvec.begin(), rvec.end())` instead."   
) &
inline

Definition at line 381 of file RVec.hxx.

◆ rbegin() [1/2]

template<typename T >
const_reverse_iterator ROOT::VecOps::RVec< T >::rbegin ( ) const
inlinenoexcept

Definition at line 426 of file RVec.hxx.

◆ rbegin() [2/2]

template<typename T >
reverse_iterator ROOT::VecOps::RVec< T >::rbegin ( )
inlinenoexcept

Definition at line 425 of file RVec.hxx.

◆ rend() [1/2]

template<typename T >
const_reverse_iterator ROOT::VecOps::RVec< T >::rend ( ) const
inlinenoexcept

Definition at line 429 of file RVec.hxx.

◆ rend() [2/2]

template<typename T >
reverse_iterator ROOT::VecOps::RVec< T >::rend ( )
inlinenoexcept

Definition at line 428 of file RVec.hxx.

◆ reserve()

template<typename T >
void ROOT::VecOps::RVec< T >::reserve ( size_type  new_cap)
inline

Definition at line 435 of file RVec.hxx.

◆ resize() [1/2]

template<typename T >
void ROOT::VecOps::RVec< T >::resize ( size_type  count)
inline

Definition at line 458 of file RVec.hxx.

◆ resize() [2/2]

template<typename T >
void ROOT::VecOps::RVec< T >::resize ( size_type  count,
const value_type value 
)
inline

Definition at line 459 of file RVec.hxx.

◆ shrink_to_fit()

template<typename T >
void ROOT::VecOps::RVec< T >::shrink_to_fit ( )
inline

Definition at line 437 of file RVec.hxx.

◆ size()

template<typename T >
size_type ROOT::VecOps::RVec< T >::size ( ) const
inlinenoexcept

Definition at line 433 of file RVec.hxx.

◆ swap()

template<typename T >
void ROOT::VecOps::RVec< T >::swap ( RVec< T > &  other)
inline

Definition at line 460 of file RVec.hxx.

◆ void ::ROOT::Internal::RDF::SetBranchesHelper()

template<typename T >
ROOT::VecOps::RVec< T >::void ::ROOT::Internal::RDF::SetBranchesHelper ( ROOT::Internal::RDF::BoolArrayMap boolArrays,
TTree inputTree,
TTree outputTree,
const std::string &  inName,
const std::string &  outName,
TBranch *&  branch,
void *&  branchAddress,
RVec< T > *  ab,
ROOT::Internal::RDF::RBranchSet &  outputBranches 
)
private

Member Data Documentation

◆ fData

template<typename T >
Impl_t ROOT::VecOps::RVec< T >::fData
private

Definition at line 328 of file RVec.hxx.

◆ IsVecBool

template<typename T >
constexpr const auto ROOT::VecOps::RVec< T >::IsVecBool = std::is_same<bool, T>::value
staticconstexprprivate

Definition at line 308 of file RVec.hxx.

  • math/vecops/inc/ROOT/RVec.hxx