Logo ROOT  
Reference Guide
ROOT::RDF Namespace Reference

Namespaces

 Internal
 

Classes

class  RArrowDS
 RDataFrame data source class to interface with Apache Arrow. More...
 
class  RCsvDS
 RDataFrame data source class for reading CSV files. More...
 
class  RCutFlowReport
 
class  RDataSource
 RDataSource defines an API that RDataFrame can use to read arbitrary data formats. More...
 
class  RDisplay
 This class is the textual representation of the content of a columnar dataset. More...
 
class  RInterface
 The public interface to the RDataFrame federation of classes. More...
 
class  RLazyDS
 A RDataSource implementation which is built on top of result proxies. More...
 
class  RResultHandle
 
class  RResultPtr
 Smart pointer for the return type of actions. More...
 
struct  RSnapshotOptions
 A collection of options to steer the creation of the dataset on file. More...
 
class  RSqliteDS
 RSqliteDS is an RDF data source implementation for SQL result sets from sqlite3 files. More...
 
class  RTrivialDS
 
class  TCutInfo
 
class  TH1DModel
 A struct which stores the parameters of a TH1D. More...
 
class  TH2DModel
 A struct which stores the parameters of a TH2D. More...
 
class  TH3DModel
 A struct which stores the parameters of a TH3D. More...
 
class  TProfile1DModel
 A struct which stores the parameters of a TProfile. More...
 
class  TProfile2DModel
 A struct which stores the parameters of a TProfile2D. More...
 

Typedefs

using RNode = RInterface<::ROOT::Detail::RDF::RNodeBase, void >
 
template<typename T >
using TResultProxy = RResultPtr< T >
 

Functions

template<typename NodeType >
RNode AsRNode (NodeType node)
 Cast a RDataFrame node to the common type ROOT::RDF::RNode. More...
 
template<typename T >
std::shared_ptr< arrow::ChunkedArray > getData (T p)
 
int getNRecords (std::shared_ptr< arrow::Table > &table, std::vector< std::string > &columnNames)
 
RDataFrame MakeArrowDataFrame (std::shared_ptr< arrow::Table > table, std::vector< std::string > const &columns)
 Factory method to create a Apache Arrow RDataFrame. More...
 
RDataFrame MakeCsvDataFrame (std::string_view fileName, bool readHeaders=true, char delimiter=',', Long64_t linesChunkSize=-1LL)
 Factory method to create a CSV RDataFrame. More...
 
template<typename... ColumnTypes>
RDataFrame MakeLazyDataFrame (std::pair< std::string, RResultPtr< std::vector< ColumnTypes >>> &&... colNameProxyPairs)
 Factory method to create a Lazy RDataFrame. More...
 
RDataFrame MakeSqliteDataFrame (std::string_view fileName, std::string_view query)
 Factory method to create a SQlite RDataFrame. More...
 
RInterface< RDFDetail::RLoopManager, RTrivialDSMakeTrivialDataFrame ()
 
RInterface< RDFDetail::RLoopManager, RTrivialDSMakeTrivialDataFrame (ULong64_t size, bool skipEvenEntries=false)
 
template<typename F , typename Args = typename ROOT::TypeTraits::CallableTraits<typename std::decay<F>::type>::arg_types_nodecay, typename Ret = typename ROOT::TypeTraits::CallableTraits<typename std::decay<F>::type>::ret_type>
auto Not (F &&f) -> decltype(RDFInternal::NotHelper(Args(), std::forward< F >(f)))
 Given a callable with signature bool(T1, T2, ...) return a callable with same signature that returns the negated result. More...
 
template<class T1 , class T2 >
bool operator!= (const RResultPtr< T1 > &lhs, const RResultPtr< T2 > &rhs)
 
template<class T1 >
bool operator!= (const RResultPtr< T1 > &lhs, std::nullptr_t rhs)
 
template<class T1 >
bool operator!= (std::nullptr_t lhs, const RResultPtr< T1 > &rhs)
 
template<class T1 , class T2 >
bool operator== (const RResultPtr< T1 > &lhs, const RResultPtr< T2 > &rhs)
 
template<class T1 >
bool operator== (const RResultPtr< T1 > &lhs, std::nullptr_t rhs)
 
template<class T1 >
bool operator== (std::nullptr_t lhs, const RResultPtr< T1 > &rhs)
 
template<std::size_t N, typename T , typename F >
auto PassAsVec (F &&f) -> RDFInternal::PassAsVecHelper< std::make_index_sequence< N >, T, F >
 PassAsVec is a callable generator that allows passing N variables of type T to a function as a single collection. More...
 
void RunGraphs (std::vector< RResultHandle > handles)
 Trigger the event loop of multiple RDataFrames concurrently. More...
 
template<typename NodeType >
std::string SaveGraph (NodeType node)
 Create a graphviz representation of the dataframe computation graph, return it as a string. More...
 
template<typename NodeType >
void SaveGraph (NodeType node, const std::string &outputFile)
 Create a graphviz representation of the dataframe computation graph, write it to the specified file. More...
 
void splitInEqualRanges (std::vector< std::pair< ULong64_t, ULong64_t >> &ranges, int nRecords, unsigned int nSlots)
 

Typedef Documentation

◆ RNode

◆ TResultProxy

template<typename T >
using ROOT::RDF::TResultProxy = typedef RResultPtr<T>

Definition at line 18 of file TResultProxy.hxx.

Function Documentation

◆ AsRNode()

template<typename NodeType >
RNode ROOT::RDF::AsRNode ( NodeType  node)

Cast a RDataFrame node to the common type ROOT::RDF::RNode.

Parameters
[in]nodeAny node of a RDataFrame graph

Definition at line 146 of file RDFHelpers.hxx.

◆ getData()

template<typename T >
std::shared_ptr<arrow::ChunkedArray> ROOT::RDF::getData ( p)

Definition at line 542 of file RArrowDS.cxx.

◆ getNRecords()

int ROOT::RDF::getNRecords ( std::shared_ptr< arrow::Table > &  table,
std::vector< std::string > &  columnNames 
)

Definition at line 535 of file RArrowDS.cxx.

◆ MakeArrowDataFrame()

RDataFrame ROOT::RDF::MakeArrowDataFrame ( std::shared_ptr< arrow::Table >  table,
std::vector< std::string > const &  columnNames 
)

Factory method to create a Apache Arrow RDataFrame.

Creates a RDataFrame using an arrow::Table as input.

Parameters
[in]tablean apache::arrow table to use as a source.
[in]tablethe arrow Table to observe.
[in]columnNamesthe name of the columns to use In case columnNames is empty, we use all the columns found in the table

Definition at line 604 of file RArrowDS.cxx.

◆ MakeCsvDataFrame()

RDataFrame ROOT::RDF::MakeCsvDataFrame ( std::string_view  fileName,
bool  readHeaders = true,
char  delimiter = ',',
Long64_t  linesChunkSize = -1LL 
)

Factory method to create a CSV RDataFrame.

Parameters
[in]fileNamePath of the CSV file.
[in]readHeaderstrue if the CSV file contains headers as first row, false otherwise (default true).
[in]delimiterDelimiter character (default ',').

Definition at line 475 of file RCsvDS.cxx.

◆ MakeLazyDataFrame()

template<typename... ColumnTypes>
RDataFrame ROOT::RDF::MakeLazyDataFrame ( std::pair< std::string, RResultPtr< std::vector< ColumnTypes >>> &&...  colNameProxyPairs)

Factory method to create a Lazy RDataFrame.

Parameters
[in]colNameProxyPairsthe series of pairs to describe the columns of the data source, first element of the pair is the name of the column and the second is the RResultPtr to the column in the parent data frame.

Definition at line 28 of file RLazyDS.hxx.

◆ MakeSqliteDataFrame()

RDataFrame ROOT::RDF::MakeSqliteDataFrame ( std::string_view  fileName,
std::string_view  query 
)

Factory method to create a SQlite RDataFrame.

Parameters
[in]fileNamePath of the sqlite file.
[in]querySQL query that defines the data set.

Definition at line 545 of file RSqliteDS.cxx.

◆ MakeTrivialDataFrame() [1/2]

RInterface< RDFDetail::RLoopManager, RTrivialDS > ROOT::RDF::MakeTrivialDataFrame ( )

Definition at line 123 of file RTrivialDS.cxx.

◆ MakeTrivialDataFrame() [2/2]

RInterface< RDFDetail::RLoopManager, RTrivialDS > ROOT::RDF::MakeTrivialDataFrame ( ULong64_t  size,
bool  skipEvenEntries = false 
)

Definition at line 116 of file RTrivialDS.cxx.

◆ Not()

template<typename F , typename Args = typename ROOT::TypeTraits::CallableTraits<typename std::decay<F>::type>::arg_types_nodecay, typename Ret = typename ROOT::TypeTraits::CallableTraits<typename std::decay<F>::type>::ret_type>
auto ROOT::RDF::Not ( F &&  f) -> decltype(RDFInternal::NotHelper(Args(), std::forward<F>(f)))

Given a callable with signature bool(T1, T2, ...) return a callable with same signature that returns the negated result.

The callable must have one single non-template definition of operator(). This is a limitation with respect to std::not_fn, required for interoperability with RDataFrame.

Definition at line 81 of file RDFHelpers.hxx.

◆ operator!=() [1/3]

template<class T1 , class T2 >
bool ROOT::RDF::operator!= ( const RResultPtr< T1 > &  lhs,
const RResultPtr< T2 > &  rhs 
)

Definition at line 334 of file RResultPtr.hxx.

◆ operator!=() [2/3]

template<class T1 >
bool ROOT::RDF::operator!= ( const RResultPtr< T1 > &  lhs,
std::nullptr_t  rhs 
)

Definition at line 352 of file RResultPtr.hxx.

◆ operator!=() [3/3]

template<class T1 >
bool ROOT::RDF::operator!= ( std::nullptr_t  lhs,
const RResultPtr< T1 > &  rhs 
)

Definition at line 358 of file RResultPtr.hxx.

◆ operator==() [1/3]

template<class T1 , class T2 >
bool ROOT::RDF::operator== ( const RResultPtr< T1 > &  lhs,
const RResultPtr< T2 > &  rhs 
)

Definition at line 328 of file RResultPtr.hxx.

◆ operator==() [2/3]

template<class T1 >
bool ROOT::RDF::operator== ( const RResultPtr< T1 > &  lhs,
std::nullptr_t  rhs 
)

Definition at line 340 of file RResultPtr.hxx.

◆ operator==() [3/3]

template<class T1 >
bool ROOT::RDF::operator== ( std::nullptr_t  lhs,
const RResultPtr< T1 > &  rhs 
)

Definition at line 346 of file RResultPtr.hxx.

◆ PassAsVec()

template<std::size_t N, typename T , typename F >
auto ROOT::RDF::PassAsVec ( F &&  f) -> RDFInternal::PassAsVecHelper<std::make_index_sequence<N>, T, F>

PassAsVec is a callable generator that allows passing N variables of type T to a function as a single collection.

PassAsVec<N, T>(func) returns a callable that takes N arguments of type T, passes them down to function func as an initializer list {t1, t2, t3,..., tN} and returns whatever f({t1, t2, t3, ..., tN}) returns.

Note that for this to work with RDataFrame the type of all columns that the callable is applied to must be exactly T. Example usage together with RDataFrame ("varX" columns must all be float variables):

bool myVecFunc(std::vector<float> args);
df.Filter(PassAsVec<3, float>(myVecFunc), {"var1", "var2", "var3"});

Definition at line 101 of file RDFHelpers.hxx.

◆ RunGraphs()

void ROOT::RDF::RunGraphs ( std::vector< RResultHandle handles)

Trigger the event loop of multiple RDataFrames concurrently.

Parameters
[in]handlesA vector of RResultHandles

This function triggers the event loop of all computation graphs which relate to the given RResultHandles. The advantage compared to running the event loop implicitly by accessing the RResultPtr is that the event loops will run concurrently. Therefore, the overall computation of all results is generally more efficient. It should be noted that user-defined operations (e.g., Filters and Defines) of the different RDataFrame graphs are assumed to be safe to call concurrently.

ROOT::RDataFrame df1("tree1", "file1.root");
auto r1 = df1.Histo1D("var1");
ROOT::RDataFrame df2("tree2", "file2.root");
auto r2 = df2.Sum("var2");
// RResultPtr -> RResultHandle conversion is automatic

Definition at line 23 of file RDFHelpers.cxx.

◆ SaveGraph() [1/2]

template<typename NodeType >
std::string ROOT::RDF::SaveGraph ( NodeType  node)

Create a graphviz representation of the dataframe computation graph, return it as a string.

Parameters
[in]nodeany node of the graph. Called on the head (first) node, it prints the entire graph. Otherwise, only the branch the node belongs to.

Note that SaveGraph is not thread-safe and must not be called concurrently from different threads.

Definition at line 113 of file RDFHelpers.hxx.

◆ SaveGraph() [2/2]

template<typename NodeType >
void ROOT::RDF::SaveGraph ( NodeType  node,
const std::string &  outputFile 
)

Create a graphviz representation of the dataframe computation graph, write it to the specified file.

Parameters
[in]nodeany node of the graph. Called on the head (first) node, it prints the entire graph. Otherwise, only the branch the node belongs to.
[in]outputFilefile where to save the representation.

Note that SaveGraph is not thread-safe and must not be called concurrently from different threads.

Definition at line 127 of file RDFHelpers.hxx.

◆ splitInEqualRanges()

void ROOT::RDF::splitInEqualRanges ( std::vector< std::pair< ULong64_t, ULong64_t >> &  ranges,
int  nRecords,
unsigned int  nSlots 
)

Definition at line 519 of file RArrowDS.cxx.

ROOT::RDF::RunGraphs
void RunGraphs(std::vector< RResultHandle > handles)
Trigger the event loop of multiple RDataFrames concurrently.
Definition: RDFHelpers.cxx:23
ROOT::RDataFrame
ROOT's RDataFrame offers a high level interface for analyses of data stored in TTrees,...
Definition: RDataFrame.hxx:42