template<typename Proxied, typename DataSource = void>
class ROOT::RDF::RInterface< Proxied, DataSource >

The public interface to the RDataFrame federation of classes.

Template Parameters

Proxied	One of the "node" base types (e.g. RLoopManager, RFilterBase). The user never specifies this type manually.
DataSource	The type of the RDataSource which is providing the data to the data frame. There is no source by default.

The documentation of each method features a one liner illustrating how to use the method, for example showing how the majority of the template parameters are automatically deduced requiring no or very little effort by the user.

Definition at line 87 of file RInterface.hxx.

Public Member Functions
	RInterface (const RInterface &)=default
	Copy-ctor for RInterface. More...

template<typename T = Proxied, typename std::enable_if< std::is_same< T, RLoopManager >::value, int >::type = 0>
	RInterface (const std::shared_ptr< Proxied > &proxied)
	Only enabled when building a RInterface<RLoopManager> More...

	RInterface (RInterface &&)=default
	Move-ctor for RInterface. More...

template<typename AccFun , typename MergeFun , typename R = typename TTraits::CallableTraits<AccFun>::ret_type, typename ArgTypes = typename TTraits::CallableTraits<AccFun>::arg_types, typename ArgTypesNoDecay = typename TTraits::CallableTraits<AccFun>::arg_types_nodecay, typename U = TTraits::TakeFirstParameter_t<ArgTypes>, typename T = TTraits::TakeFirstParameter_t<TTraits::RemoveFirstParameter_t<ArgTypes>>>
RResultPtr< U >	Aggregate (AccFun aggregator, MergeFun merger, std::string_view columnName, const U &aggIdentity)
	Execute a user-defined accumulation operation on the processed column values in each processing slot. More...

template<typename AccFun , typename MergeFun , typename R = typename TTraits::CallableTraits<AccFun>::ret_type, typename ArgTypes = typename TTraits::CallableTraits<AccFun>::arg_types, typename U = TTraits::TakeFirstParameter_t<ArgTypes>, typename T = TTraits::TakeFirstParameter_t<TTraits::RemoveFirstParameter_t<ArgTypes>>>
RResultPtr< U >	Aggregate (AccFun aggregator, MergeFun merger, std::string_view columnName="")
	Execute a user-defined accumulation operation on the processed column values in each processing slot. More...

RInterface< Proxied, DS_t >	Alias (std::string_view alias, std::string_view columnName)
	Allow to refer to a column with a different name. More...

template<typename... ColumnTypes, typename Helper >
RResultPtr< typename Helper::Result_t >	Book (Helper &&helper, const ColumnNames_t &columns={})
	Book execution of a custom action using a user-defined helper object. More...

template<typename... ColumnTypes>
RInterface< RLoopManager >	Cache (const ColumnNames_t &columnList)
	Save selected columns in memory. More...

RInterface< RLoopManager >	Cache (const ColumnNames_t &columnList)
	Save selected columns in memory. More...

RInterface< RLoopManager >	Cache (std::initializer_list< std::string > columnList)
	Save selected columns in memory. More...

RInterface< RLoopManager >	Cache (std::string_view columnNameRegexp="")
	Save selected columns in memory. More...

RResultPtr< ULong64_t >	Count ()
	Return the number of entries processed (lazy action) More...

template<typename F , typename std::enable_if<!std::is_convertible< F, std::string >::value, int >::type = 0>
RInterface< Proxied, DS_t >	Define (std::string_view name, F expression, const ColumnNames_t &columns={})
	Creates a custom column. More...

RInterface< Proxied, DS_t >	Define (std::string_view name, std::string_view expression)
	Creates a custom column. More...

template<typename F >
RInterface< Proxied, DS_t >	DefineSlot (std::string_view name, F expression, const ColumnNames_t &columns={})
	Creates a custom column with a value dependent on the processing slot. More...

template<typename F >
RInterface< Proxied, DS_t >	DefineSlotEntry (std::string_view name, F expression, const ColumnNames_t &columns={})
	Creates a custom column with a value dependent on the processing slot and the current entry. More...

template<typename... ColumnTypes>
RResultPtr< RDisplay >	Display (const ColumnNames_t &columnList, const int &nRows=5)
	Provides a representation of the columns in the dataset. More...

RResultPtr< RDisplay >	Display (const ColumnNames_t &columnList, const int &nRows=5)
	Provides a representation of the columns in the dataset. More...

RResultPtr< RDisplay >	Display (std::initializer_list< std::string > columnList, const int &nRows=5)
	Provides a representation of the columns in the dataset. More...

RResultPtr< RDisplay >	Display (std::string_view columnNameRegexp="", const int &nRows=5)
	Provides a representation of the columns in the dataset. More...

template<typename T >
RResultPtr< T >	Fill (T &&model, const ColumnNames_t &bl)
	Return an object of type T on which `T::Fill` will be called once per event (lazy action) More...

template<typename FirstColumn , typename... OtherColumns, typename T >
RResultPtr< T >	Fill (T &&model, const ColumnNames_t &columnList)
	Return an object of type T on which `T::Fill` will be called once per event (lazy action) More...

template<typename F , typename std::enable_if<!std::is_convertible< F, std::string >::value, int >::type = 0>
RInterface< RDFDetail::RFilter< F, Proxied >, DS_t >	Filter (F f, const ColumnNames_t &columns={}, std::string_view name="")

template<typename F >
RInterface< RDFDetail::RFilter< F, Proxied >, DS_t >	Filter (F f, const std::initializer_list< std::string > &columns)
	Append a filter to the call graph. More...

template<typename F , typename std::enable_if<!std::is_convertible< F, std::string >::value, int >::type = 0>
RInterface< RDFDetail::RFilter< F, Proxied >, DS_t >	Filter (F f, std::string_view name)
	Append a filter to the call graph. More...

RInterface< RDFDetail::RJittedFilter, DS_t >	Filter (std::string_view expression, std::string_view name="")
	Append a filter to the call graph. More...

template<typename F >
void	Foreach (F f, const ColumnNames_t &columns={})
	Execute a user-defined function on each entry (instant action) More...

template<typename F >
void	ForeachSlot (F f, const ColumnNames_t &columns={})
	Execute a user-defined function requiring a processing slot index on each entry (instant action) More...

ColumnNames_t	GetColumnNames ()
	Returns the names of the available columns. More...

std::string	GetColumnType (std::string_view column)
	Return the type of a given column as a string. More...

ColumnNames_t	GetDefinedColumnNames ()
	Returns the names of the defined columns. More...

std::vector< std::string >	GetFilterNames ()
	Returns the names of the filters created. More...

template<typename V1 = RDFDetail::RInferredType, typename V2 = RDFDetail::RInferredType>
RResultPtr<::TGraph >	Graph (std::string_view v1Name="", std::string_view v2Name="")
	Fill and return a graph (lazy action) More...

template<typename V = RDFDetail::RInferredType, typename W = RDFDetail::RInferredType>
RResultPtr<::TH1D >	Histo1D (const TH1DModel &model, std::string_view vName, std::string_view wName)
	Fill and return a one-dimensional histogram with the weighted values of a column (lazy action) More...

template<typename V , typename W >
RResultPtr<::TH1D >	Histo1D (const TH1DModel &model={"", "", 128u, 0., 0.})
	Fill and return a one-dimensional histogram with the weighted values of a column (lazy action) More...

template<typename V = RDFDetail::RInferredType>
RResultPtr<::TH1D >	Histo1D (const TH1DModel &model={"", "", 128u, 0., 0.}, std::string_view vName="")
	Fill and return a one-dimensional histogram with the values of a column (lazy action) More...

template<typename V = RDFDetail::RInferredType>
RResultPtr<::TH1D >	Histo1D (std::string_view vName)
	Fill and return a one-dimensional histogram with the values of a column (lazy action) More...

template<typename V = RDFDetail::RInferredType, typename W = RDFDetail::RInferredType>
RResultPtr<::TH1D >	Histo1D (std::string_view vName, std::string_view wName)
	Fill and return a one-dimensional histogram with the weighted values of a column (lazy action) More...

template<typename V1 , typename V2 , typename W >
RResultPtr<::TH2D >	Histo2D (const TH2DModel &model)

template<typename V1 = RDFDetail::RInferredType, typename V2 = RDFDetail::RInferredType, typename W = RDFDetail::RInferredType>
RResultPtr<::TH2D >	Histo2D (const TH2DModel &model, std::string_view v1Name, std::string_view v2Name, std::string_view wName)
	Fill and return a weighted two-dimensional histogram (lazy action) More...

template<typename V1 = RDFDetail::RInferredType, typename V2 = RDFDetail::RInferredType>
RResultPtr<::TH2D >	Histo2D (const TH2DModel &model, std::string_view v1Name="", std::string_view v2Name="")
	Fill and return a two-dimensional histogram (lazy action) More...

template<typename V1 , typename V2 , typename V3 , typename W >
RResultPtr<::TH3D >	Histo3D (const TH3DModel &model)

template<typename V1 = RDFDetail::RInferredType, typename V2 = RDFDetail::RInferredType, typename V3 = RDFDetail::RInferredType, typename W = RDFDetail::RInferredType>
RResultPtr<::TH3D >	Histo3D (const TH3DModel &model, std::string_view v1Name, std::string_view v2Name, std::string_view v3Name, std::string_view wName)
	Fill and return a three-dimensional histogram (lazy action) More...

template<typename V1 = RDFDetail::RInferredType, typename V2 = RDFDetail::RInferredType, typename V3 = RDFDetail::RInferredType>
RResultPtr<::TH3D >	Histo3D (const TH3DModel &model, std::string_view v1Name="", std::string_view v2Name="", std::string_view v3Name="")
	Fill and return a three-dimensional histogram (lazy action) More...

template<typename T = RDFDetail::RInferredType>
RResultPtr< RDFDetail::MaxReturnType_t< T > >	Max (std::string_view columnName="")
	Return the maximum of processed column values (lazy action) More...

template<typename T = RDFDetail::RInferredType>
RResultPtr< double >	Mean (std::string_view columnName="")
	Return the mean of processed column values (lazy action) More...

template<typename T = RDFDetail::RInferredType>
RResultPtr< RDFDetail::MinReturnType_t< T > >	Min (std::string_view columnName="")
	Return the minimum of processed column values (lazy action) More...

	operator RNode () const
	Cast any RDataFrame node to a common type ROOT::RDF::RNode. More...

RInterface &	operator= (const RInterface &)=default
	Copy-assignment operator for RInterface. More...

template<typename V1 , typename V2 , typename W >
RResultPtr<::TProfile >	Profile1D (const TProfile1DModel &model)

template<typename V1 = RDFDetail::RInferredType, typename V2 = RDFDetail::RInferredType, typename W = RDFDetail::RInferredType>
RResultPtr<::TProfile >	Profile1D (const TProfile1DModel &model, std::string_view v1Name, std::string_view v2Name, std::string_view wName)
	Fill and return a one-dimensional profile (lazy action) More...

template<typename V1 = RDFDetail::RInferredType, typename V2 = RDFDetail::RInferredType>
RResultPtr<::TProfile >	Profile1D (const TProfile1DModel &model, std::string_view v1Name="", std::string_view v2Name="")
	Fill and return a one-dimensional profile (lazy action) More...

template<typename V1 , typename V2 , typename V3 , typename W >
RResultPtr<::TProfile2D >	Profile2D (const TProfile2DModel &model)

template<typename V1 = RDFDetail::RInferredType, typename V2 = RDFDetail::RInferredType, typename V3 = RDFDetail::RInferredType, typename W = RDFDetail::RInferredType>
RResultPtr<::TProfile2D >	Profile2D (const TProfile2DModel &model, std::string_view v1Name, std::string_view v2Name, std::string_view v3Name, std::string_view wName)
	Fill and return a two-dimensional profile (lazy action) More...

template<typename V1 = RDFDetail::RInferredType, typename V2 = RDFDetail::RInferredType, typename V3 = RDFDetail::RInferredType>
RResultPtr<::TProfile2D >	Profile2D (const TProfile2DModel &model, std::string_view v1Name="", std::string_view v2Name="", std::string_view v3Name="")
	Fill and return a two-dimensional profile (lazy action) More...

RInterface< RDFDetail::RRange< Proxied >, DS_t >	Range (unsigned int begin, unsigned int end, unsigned int stride=1)
	Creates a node that filters entries based on range: [begin, end) More...

RInterface< RDFDetail::RRange< Proxied >, DS_t >	Range (unsigned int end)
	Creates a node that filters entries based on range. More...

template<typename F , typename T = typename TTraits::CallableTraits<F>::ret_type>
RResultPtr< T >	Reduce (F f, std::string_view columnName, const T &redIdentity)
	Execute a user-defined reduce operation on the values of a column. More...

template<typename F , typename T = typename TTraits::CallableTraits<F>::ret_type>
RResultPtr< T >	Reduce (F f, std::string_view columnName="")
	Execute a user-defined reduce operation on the values of a column. More...

RResultPtr< RCutFlowReport >	Report ()
	Gather filtering statistics. More...

template<typename... ColumnTypes>
RResultPtr< RInterface< RLoopManager > >	Snapshot (std::string_view treename, std::string_view filename, const ColumnNames_t &columnList, const RSnapshotOptions &options=RSnapshotOptions())
	Save selected columns to disk, in a new TTree `treename` in file `filename`. More...

RResultPtr< RInterface< RLoopManager > >	Snapshot (std::string_view treename, std::string_view filename, const ColumnNames_t &columnList, const RSnapshotOptions &options=RSnapshotOptions())
	Save selected columns to disk, in a new TTree `treename` in file `filename`. More...

RResultPtr< RInterface< RLoopManager > >	Snapshot (std::string_view treename, std::string_view filename, std::initializer_list< std::string > columnList, const RSnapshotOptions &options=RSnapshotOptions())
	Save selected columns to disk, in a new TTree `treename` in file `filename`. More...

RResultPtr< RInterface< RLoopManager > >	Snapshot (std::string_view treename, std::string_view filename, std::string_view columnNameRegexp="", const RSnapshotOptions &options=RSnapshotOptions())
	Save selected columns to disk, in a new TTree `treename` in file `filename`. More...

template<typename T = RDFDetail::RInferredType>
RResultPtr< double >	StdDev (std::string_view columnName="")
	Return the unbiased standard deviation of processed column values (lazy action) More...

template<typename T = RDFDetail::RInferredType>
RResultPtr< RDFDetail::SumReturnType_t< T > >	Sum (std::string_view columnName="", const RDFDetail::SumReturnType_t< T > &initValue=RDFDetail::SumReturnType_t< T >{})
	Return the sum of processed column values (lazy action) More...

template<typename T , typename COLL = std::vector<T>>
RResultPtr< COLL >	Take (std::string_view column="")
	Return a collection of values of a column (lazy action, returns a std::vector by default) More...

Protected Member Functions
	RInterface (const std::shared_ptr< Proxied > &proxied, RLoopManager &lm, RDFInternal::RBookedCustomColumns columns, RDataSource *ds)

template<typename... ColumnTypes, std::size_t... S>
RDFInternal::RBookedCustomColumns	CheckAndFillDSColumns (ColumnNames_t validCols, std::index_sequence< S... >, TTraits::TypeList< ColumnTypes... >)

RLoopManager *	GetLoopManager () const

const std::shared_ptr< Proxied > &	GetProxiedPtr () const

ColumnNames_t	GetValidatedColumnNames (const unsigned int nColumns, const ColumnNames_t &columns)
	Prepare the call to the GetValidatedColumnNames routine, making sure that GetBranchNames, which is expensive in terms of runtime, is called at most once. More...

Private Types
using	ColumnNames_t = RDFDetail::ColumnNames_t

using	DS_t = DataSource

using	HeadNode_t = ::ROOT::RDF::RResultPtr< RInterface< RLoopManager, void > >

using	RFilterBase = RDFDetail::RFilterBase

using	RLoopManager = RDFDetail::RLoopManager

using	RRangeBase = RDFDetail::RRangeBase

Private Member Functions
void	AddDefaultColumns ()

template<typename... BranchTypes, std::size_t... S>
RInterface< RLoopManager >	CacheImpl (const ColumnNames_t &columnList, std::index_sequence< S... > s)
	Implementation of cache. More...

void	CheckIMTDisabled (std::string_view callerName)

template<typename ActionTag , typename... BranchTypes, typename ActionResultType , typename std::enable_if<!RDFInternal::TNeedJitting< BranchTypes... >::value, int >::type = 0>
RResultPtr< ActionResultType >	CreateAction (const ColumnNames_t &columns, const std::shared_ptr< ActionResultType > &r)

template<typename ActionTag , typename... BranchTypes, typename ActionResultType , typename std::enable_if< RDFInternal::TNeedJitting< BranchTypes... >::value, int >::type = 0>
RResultPtr< ActionResultType >	CreateAction (const ColumnNames_t &columns, const std::shared_ptr< ActionResultType > &r, const int nColumns=-1)

template<typename F , typename CustomColumnType , typename RetType = typename TTraits::CallableTraits<F>::ret_type>
std::enable_if< std::is_default_constructible< RetType >::value, RInterface< Proxied, DS_t > >::type	DefineImpl (std::string_view name, F &&expression, const ColumnNames_t &columns)

template<typename F , typename CustomColumnType , typename RetType = typename TTraits::CallableTraits<F>::ret_type, bool IsFStringConv = std::is_convertible<F, std::string>::value, bool IsRetTypeDefConstr = std::is_default_constructible<RetType>::value>
std::enable_if<!IsFStringConv &&!IsRetTypeDefConstr, RInterface< Proxied, DS_t > >::type	DefineImpl (std::string_view, F, const ColumnNames_t &)

std::vector< std::string >	GetColumnTypeNamesList (const ColumnNames_t &columnList)

template<typename... ColumnTypes>
RResultPtr< RInterface< RLoopManager > >	SnapshotImpl (std::string_view treename, std::string_view filename, const ColumnNames_t &columnList, const RSnapshotOptions &options)
	Implementation of snapshot. More...

Private Attributes
RDFInternal::RBookedCustomColumns	fCustomColumns
	Contains the custom columns defined up to this node. More...

RDataSource *	fDataSource = nullptr
	Non-owning pointer to a data-source object. Null if no data-source. RLoopManager has ownership of the object. More...

RLoopManager *	fLoopManager

std::shared_ptr< Proxied >	fProxiedPtr
	Smart pointer to the graph node encapsulated by this RInterface. More...

Friends
template<typename T , typename W >
class	RInterface

std::string	cling::printValue (::ROOT::RDataFrame *tdf)

ColumnNames_t	RDFInternal::ConvertRegexToColumns (const RNode &node, std::string_view columnNameRegexp, std::string_view callerName)

HeadNode_t	RDFInternal::CreateSnaphotRDF (const ColumnNames_t &validCols, const std::string &fullTreeName, const std::string &fileName, bool isLazy, RLoopManager &loopManager, std::unique_ptr< RDFInternal::RActionBase > actionPtr)

class	RDFInternal::GraphDrawing::GraphCreatorHelper

#include <ROOT/RDF/RInterface.hxx>

Member Typedef Documentation

◆ ColumnNames_t

template<typename Proxied , typename DataSource = void>

using ROOT::RDF::RInterface< Proxied, DataSource >::ColumnNames_t = RDFDetail::ColumnNames_t

private

Definition at line 89 of file RInterface.hxx.

◆ DS_t

template<typename Proxied , typename DataSource = void>

using ROOT::RDF::RInterface< Proxied, DataSource >::DS_t = DataSource

private

Definition at line 88 of file RInterface.hxx.

◆ HeadNode_t

template<typename Proxied , typename DataSource = void>

using ROOT::RDF::RInterface< Proxied, DataSource >::HeadNode_t = ::ROOT::RDF::RResultPtr<RInterface<RLoopManager, void> >

private

Definition at line 98 of file RInterface.hxx.

◆ RFilterBase

template<typename Proxied , typename DataSource = void>

using ROOT::RDF::RInterface< Proxied, DataSource >::RFilterBase = RDFDetail::RFilterBase

private

Definition at line 90 of file RInterface.hxx.

◆ RLoopManager

template<typename Proxied , typename DataSource = void>

using ROOT::RDF::RInterface< Proxied, DataSource >::RLoopManager = RDFDetail::RLoopManager

private

Definition at line 92 of file RInterface.hxx.

◆ RRangeBase

template<typename Proxied , typename DataSource = void>

using ROOT::RDF::RInterface< Proxied, DataSource >::RRangeBase = RDFDetail::RRangeBase

private

Definition at line 91 of file RInterface.hxx.

Constructor & Destructor Documentation

◆ RInterface() [1/4]

template<typename Proxied , typename DataSource = void>

ROOT::RDF::RInterface< Proxied, DataSource >::RInterface ( const RInterface< Proxied, DataSource > & )

default

Copy-ctor for RInterface.

◆ RInterface() [2/4]

template<typename Proxied , typename DataSource = void>

ROOT::RDF::RInterface< Proxied, DataSource >::RInterface ( RInterface< Proxied, DataSource > && )

default

Move-ctor for RInterface.

◆ RInterface() [3/4]

template<typename Proxied , typename DataSource = void>

template<typename T = Proxied, typename std::enable_if< std::is_same< T, RLoopManager >::value, int >::type = 0>

ROOT::RDF::RInterface< Proxied, DataSource >::RInterface ( const std::shared_ptr< Proxied > & proxied )

inline

Only enabled when building a RInterface<RLoopManager>

Definition at line 134 of file RInterface.hxx.

◆ RInterface() [4/4]

template<typename Proxied , typename DataSource = void>

ROOT::RDF::RInterface< Proxied, DataSource >::RInterface	(	const std::shared_ptr< Proxied > &	proxied,
		RLoopManager &	lm,
		RDFInternal::RBookedCustomColumns	columns,
		RDataSource *	ds
	)

inlineprotected

Definition at line 2059 of file RInterface.hxx.

Member Function Documentation

◆ AddDefaultColumns()

template<typename Proxied , typename DataSource = void>

void ROOT::RDF::RInterface< Proxied, DataSource >::AddDefaultColumns ( )

inlineprivate

Definition at line 1801 of file RInterface.hxx.

◆ Aggregate() [1/2]

template<typename Proxied , typename DataSource = void>

template<typename AccFun , typename MergeFun , typename R = typename TTraits::CallableTraits<AccFun>::ret_type, typename ArgTypes = typename TTraits::CallableTraits<AccFun>::arg_types, typename ArgTypesNoDecay = typename TTraits::CallableTraits<AccFun>::arg_types_nodecay, typename U = TTraits::TakeFirstParameter_t<ArgTypes>, typename T = TTraits::TakeFirstParameter_t<TTraits::RemoveFirstParameter_t<ArgTypes>>>

RResultPtr< U > ROOT::RDF::RInterface< Proxied, DataSource >::Aggregate	(	AccFun	aggregator,
		MergeFun	merger,
		std::string_view	columnName,
		const U &	aggIdentity
	)

inline

Execute a user-defined accumulation operation on the processed column values in each processing slot.

Template Parameters

F	The type of the aggregator callable. Automatically deduced.
U	The type of the aggregator variable. Must be default-constructible, copy-constructible and copy-assignable. Automatically deduced.
T	The type of the column to apply the reduction to. Automatically deduced.

Parameters

[in]	aggregator	A callable with signature `U(U,T)` or `void(U&,T)`, where T is the type of the column, U is the type of the aggregator variable
[in]	merger	A callable with signature `U(U,U)` or `void(std::vector<U>&)` used to merge the results of the accumulations of each thread
[in]	columnName	The column to be aggregated. If omitted, the first default column is used instead.
[in]	aggIdentity	The aggregator variable of each thread is initialised to this value (or is default-constructed if the parameter is omitted)

Returns: the result of the aggregation wrapped in a RResultPtr.

An aggregator callable takes two values, an aggregator variable and a column value. The aggregator variable is initialized to aggIdentity or default-constructed if aggIdentity is omitted. This action calls the aggregator callable for each processed entry, passing in the aggregator variable and the value of the column columnName. If the signature is U(U,T) the aggregator variable is then copy-assigned the result of the execution of the callable. Otherwise the signature of aggregator must be void(U&,T).

The merger callable is used to merge the partial accumulation results of each processing thread. It is only called in multi-thread executions. If its signature is U(U,U) the aggregator variables of each thread are merged two by two. If its signature is void(std::vector<U>& a) it is assumed that it merges all aggregators in a[0].

This action is lazy: upon invocation of this method the calculation is booked but not executed. See RResultPtr documentation.

Definition at line 1634 of file RInterface.hxx.

◆ Aggregate() [2/2]

template<typename Proxied , typename DataSource = void>

template<typename AccFun , typename MergeFun , typename R = typename TTraits::CallableTraits<AccFun>::ret_type, typename ArgTypes = typename TTraits::CallableTraits<AccFun>::arg_types, typename U = TTraits::TakeFirstParameter_t<ArgTypes>, typename T = TTraits::TakeFirstParameter_t<TTraits::RemoveFirstParameter_t<ArgTypes>>>

RResultPtr< U > ROOT::RDF::RInterface< Proxied, DataSource >::Aggregate	(	AccFun	aggregator,
		MergeFun	merger,
		std::string_view	columnName = `""`
	)

inline

Execute a user-defined accumulation operation on the processed column values in each processing slot.

Template Parameters

F	The type of the aggregator callable. Automatically deduced.
U	The type of the aggregator variable. Must be default-constructible, copy-constructible and copy-assignable. Automatically deduced.
T	The type of the column to apply the reduction to. Automatically deduced.

Parameters

[in]	aggregator	A callable with signature `U(U,T)` or `void(U,T)`, where T is the type of the column, U is the type of the aggregator variable
[in]	merger	A callable with signature `U(U,U)` or `void(std::vector<U>&)` used to merge the results of the accumulations of each thread
[in]	columnName	The column to be aggregated. If omitted, the first default column is used instead.

Returns: the result of the aggregation wrapped in a RResultPtr.

See previous Aggregate overload for more information.

Definition at line 1671 of file RInterface.hxx.

◆ Alias()

template<typename Proxied , typename DataSource = void>

RInterface< Proxied, DS_t > ROOT::RDF::RInterface< Proxied, DataSource >::Alias	(	std::string_view	alias,
		std::string_view	columnName
	)

inline

Allow to refer to a column with a different name.

Parameters

[in]	alias	name of the column alias
[in]	columnName	of the column to be aliased

Returns: the first node of the computation graph for which the alias is available.

Aliasing an alias is supported.

Example usage:

auto df_with_alias = df.Alias("simple_name", "very_long&complex_name!!!");

Definition at line 411 of file RInterface.hxx.

◆ Book()

template<typename Proxied , typename DataSource = void>

template<typename... ColumnTypes, typename Helper >

RResultPtr< typename Helper::Result_t > ROOT::RDF::RInterface< Proxied, DataSource >::Book	(	Helper &&	helper,
		const ColumnNames_t &	columns = `{}`
	)

inline

Book execution of a custom action using a user-defined helper object.

Template Parameters

ColumnTypes	List of types of columns used by this action.
Helper	The type of the user-defined helper. See below for the required interface it should expose.

Parameters

[in]	helper	The Action Helper to be scheduled.
[in]	columns	The names of the columns on which the helper acts.

Returns: the result of the helper wrapped in a RResultPtr.

This method books a custom action for execution. The behavior of the action is completely dependent on the Helper object provided by the caller. The minimum required interface for the helper is the following (more methods can be present, e.g. a constructor that takes the number of worker threads is usually useful):

Helper must publicly inherit from ROOT::Detail::RDF::RActionImpl<Helper>
Helper(Helper &&): a move-constructor is required. Copy-constructors are discouraged.
Result_t: alias for the type of the result of this action helper. Must be default-constructible.
void Exec(unsigned int slot, ColumnTypes...columnValues): each working thread shall call this method during the event-loop, possibly concurrently. No two threads will ever call Exec with the same 'slot' value: this parameter is there to facilitate writing thread-safe helpers. The other arguments will be the values of the requested columns for the particular entry being processed.
void InitTask(TTreeReader *, unsigned int slot): each working thread shall call this method during the event loop, before processing a batch of entries (possibly read from the TTreeReader passed as argument, if not null). This method can be used e.g. to prepare the helper to process a batch of entries in a given thread. Can be no-op.
void Initialize(): this method is called once before starting the event-loop. Useful for setup operations. Can be no-op.
void Finalize(): this method is called at the end of the event loop. Commonly used to finalize the contents of the result.
Result_t &PartialUpdate(unsigned int slot): this method is optional, i.e. can be omitted. If present, it should return the value of the partial result of this action for the given 'slot'. Different threads might call this method concurrently, but will always pass different 'slot' numbers.
std::shared_ptr<Result_t> GetResultPtr() const: return a shared_ptr to the result of this action (of type Result_t). The RResultPtr returned by Book will point to this object.

See $ROOTSYS/tree/treeplayer/inc/ROOT/RDF/ActionHelpers.hxx for the helpers used by standard RDF actions.

Definition at line 1713 of file RInterface.hxx.

◆ Cache() [1/4]

template<typename Proxied , typename DataSource = void>

template<typename... ColumnTypes>

RInterface< RLoopManager > ROOT::RDF::RInterface< Proxied, DataSource >::Cache ( const ColumnNames_t & columnList )

inline

Save selected columns in memory.

Template Parameters

ColumnTypes variadic list of branch/column types.

Parameters

[in] columns to be cached in memory.

Returns: a RDataFrame that wraps the cached dataset.

This action returns a new RDataFrame object, completely detached from the originating RDataFrame. The new dataframe only contains the cached columns and stores their content in memory for fast, zero-copy subsequent access.

Use Cache if you know you will only need a subset of the (Filtered) data that fits in memory and that will be accessed many times.

Definition at line 599 of file RInterface.hxx.

◆ Cache() [2/4]

template<typename Proxied , typename DataSource = void>

RInterface< RLoopManager > ROOT::RDF::RInterface< Proxied, DataSource >::Cache ( const ColumnNames_t & columnList )

inline

Save selected columns in memory.

Parameters

[in] columns to be cached in memory

Returns: a RDataFrame that wraps the cached dataset.

See the previous overloads for more information.

Definition at line 611 of file RInterface.hxx.

◆ Cache() [3/4]

template<typename Proxied , typename DataSource = void>

RInterface< RLoopManager > ROOT::RDF::RInterface< Proxied, DataSource >::Cache ( std::initializer_list< std::string > columnList )

inline

Save selected columns in memory.

Parameters

[in] columns to be cached in memory.

Returns: a RDataFrame that wraps the cached dataset.

See the previous overloads for more information.

Definition at line 676 of file RInterface.hxx.

◆ Cache() [4/4]

template<typename Proxied , typename DataSource = void>

RInterface< RLoopManager > ROOT::RDF::RInterface< Proxied, DataSource >::Cache ( std::string_view columnNameRegexp = "" )

inline

Save selected columns in memory.

Parameters

[in] a regular expression to select the columns

Returns: a RDataFrame that wraps the cached dataset.

The existing columns are matched against the regeular expression. If the string provided is empty, all columns are selected. See the previous overloads for more information.

Definition at line 664 of file RInterface.hxx.

◆ CacheImpl()

template<typename Proxied , typename DataSource = void>

template<typename... BranchTypes, std::size_t... S>

RInterface< RLoopManager > ROOT::RDF::RInterface< Proxied, DataSource >::CacheImpl	(	const ColumnNames_t &	columnList,
		std::index_sequence< S... >	s
	)

inlineprivate

Implementation of cache.

Definition at line 2037 of file RInterface.hxx.

◆ CheckAndFillDSColumns()

template<typename Proxied , typename DataSource = void>

template<typename... ColumnTypes, std::size_t... S>

RDFInternal::RBookedCustomColumns ROOT::RDF::RInterface< Proxied, DataSource >::CheckAndFillDSColumns	(	ColumnNames_t	validCols,
		std::index_sequence< S... >	,
		TTraits::TypeList< ColumnTypes... >
	)

inlineprotected

Definition at line 2079 of file RInterface.hxx.

◆ CheckIMTDisabled()

template<typename Proxied , typename DataSource = void>

void ROOT::RDF::RInterface< Proxied, DataSource >::CheckIMTDisabled ( std::string_view callerName )

inlineprivate

Definition at line 1859 of file RInterface.hxx.

◆ Count()

template<typename Proxied , typename DataSource = void>

RResultPtr< ULong64_t > ROOT::RDF::RInterface< Proxied, DataSource >::Count ( )

inline

Return the number of entries processed (lazy action)

Returns: the number of entries wrapped in a RResultPtr.

Useful e.g. for counting the number of entries passing a certain filter (see also Report). This action is lazy: upon invocation of this method the calculation is booked but not executed. See RResultPtr documentation.

Definition at line 830 of file RInterface.hxx.

◆ CreateAction() [1/2]

template<typename Proxied , typename DataSource = void>

template<typename ActionTag , typename... BranchTypes, typename ActionResultType , typename std::enable_if<!RDFInternal::TNeedJitting< BranchTypes... >::value, int >::type = 0>

RResultPtr< ActionResultType > ROOT::RDF::RInterface< Proxied, DataSource >::CreateAction	(	const ColumnNames_t &	columns,
		const std::shared_ptr< ActionResultType > &	r
	)

inlineprivate

Definition at line 1871 of file RInterface.hxx.

◆ CreateAction() [2/2]

template<typename Proxied , typename DataSource = void>

template<typename ActionTag , typename... BranchTypes, typename ActionResultType , typename std::enable_if< RDFInternal::TNeedJitting< BranchTypes... >::value, int >::type = 0>

RResultPtr< ActionResultType > ROOT::RDF::RInterface< Proxied, DataSource >::CreateAction	(	const ColumnNames_t &	columns,
		const std::shared_ptr< ActionResultType > &	r,
		const int	nColumns = `-1`
	)

inlineprivate

Definition at line 1894 of file RInterface.hxx.

◆ Define() [1/2]

template<typename Proxied , typename DataSource = void>

template<typename F , typename std::enable_if<!std::is_convertible< F, std::string >::value, int >::type = 0>

RInterface< Proxied, DS_t > ROOT::RDF::RInterface< Proxied, DataSource >::Define	(	std::string_view	name,
		F	expression,
		const ColumnNames_t &	columns = `{}`
	)

inline

Creates a custom column.

Parameters

[in]	name	The name of the custom column.
[in]	expression	Function, lambda expression, functor class or any other callable object producing the temporary value. Returns the value that will be assigned to the custom column.
[in]	columns	Names of the columns/branches in input to the producer function.

Returns: the first node of the computation graph for which the new quantity is defined.

Create a custom column that will be visible from all subsequent nodes of the functional chain. The expression is only evaluated for entries that pass all the preceding filters. A new variable is created called name, accessible as if it was contained in the dataset from subsequent transformations/actions.

Use cases include:

caching the results of complex calculations for easy and efficient multiple access
extraction of quantities of interest from complex objects

An exception is thrown if the name of the new column is already in use in this branch of the computation graph.

Example usage:

// assuming a function with signature:
double myComplexCalculation(const RVec<float> &muon_pts);
// we can pass it directly to Define
auto df_with_define = df.Define("newColumn", myComplexCalculation, {"muon_pts"});
// alternatively, we can pass the body of the function as a string, as in Filter:
auto df_with_define = df.Define("newColumn", "x*x + y*y");

Definition at line 299 of file RInterface.hxx.

◆ Define() [2/2]

template<typename Proxied , typename DataSource = void>

RInterface< Proxied, DS_t > ROOT::RDF::RInterface< Proxied, DataSource >::Define	(	std::string_view	name,
		std::string_view	expression
	)

inline

Creates a custom column.

Parameters

[in]	name	The name of the custom column.
[in]	expression	An expression in C++ which represents the temporary value

Returns: the first node of the computation graph for which the new quantity is defined.

The expression is just-in-time compiled and used to produce the column entries. It must be valid C++ syntax in which variable names are substituted with the names of branches/columns.

Refer to the first overload of this method for the full documentation.

Definition at line 375 of file RInterface.hxx.

◆ DefineImpl() [1/2]

template<typename Proxied , typename DataSource = void>

template<typename F , typename CustomColumnType , typename RetType = typename TTraits::CallableTraits<F>::ret_type>

std::enable_if< std::is_default_constructible< RetType >::value, RInterface< Proxied, DS_t > >::type ROOT::RDF::RInterface< Proxied, DataSource >::DefineImpl	(	std::string_view	name,
		F &&	expression,
		const ColumnNames_t &	columns
	)

inlineprivate

Definition at line 1921 of file RInterface.hxx.

◆ DefineImpl() [2/2]

template<typename Proxied , typename DataSource = void>

template<typename F , typename CustomColumnType , typename RetType = typename TTraits::CallableTraits<F>::ret_type, bool IsFStringConv = std::is_convertible<F, std::string>::value, bool IsRetTypeDefConstr = std::is_default_constructible<RetType>::value>

std::enable_if<!IsFStringConv &&!IsRetTypeDefConstr, RInterface< Proxied, DS_t > >::type ROOT::RDF::RInterface< Proxied, DataSource >::DefineImpl	(	std::string_view	,
		F	,
		const ColumnNames_t &
	)

inlineprivate

Definition at line 1975 of file RInterface.hxx.

◆ DefineSlot()

template<typename Proxied , typename DataSource = void>

template<typename F >

RInterface< Proxied, DS_t > ROOT::RDF::RInterface< Proxied, DataSource >::DefineSlot	(	std::string_view	name,
		F	expression,
		const ColumnNames_t &	columns = `{}`
	)

inline

Creates a custom column with a value dependent on the processing slot.

Parameters

[in]	name	The name of the custom column.
[in]	expression	Function, lambda expression, functor class or any other callable object producing the temporary value. Returns the value that will be assigned to the custom column.
[in]	columns	Names of the columns/branches in input to the producer function (excluding the slot number).

Returns: the first node of the computation graph for which the new quantity is defined.

This alternative implementation of Define is meant as a helper in writing thread-safe custom columns. The expression must be a callable of signature R(unsigned int, T1, T2, ...) where T1, T2... are the types of the columns that the expression takes as input. The first parameter is reserved for an unsigned integer representing a "slot number". RDataFrame guarantees that different threads will invoke the expression with different slot numbers - slot numbers will range from zero to ROOT::GetImplicitMTPoolSize()-1.

The following two calls are equivalent, although DefineSlot is slightly more performant:

int function(unsigned int, double, double);
df.Define("x", function, {"tdfslot_", "column1", "column2"})
df.DefineSlot("x", function, {"column1", "column2"})

See Define for more information.

Definition at line 328 of file RInterface.hxx.

◆ DefineSlotEntry()

template<typename Proxied , typename DataSource = void>

template<typename F >

RInterface< Proxied, DS_t > ROOT::RDF::RInterface< Proxied, DataSource >::DefineSlotEntry	(	std::string_view	name,
		F	expression,
		const ColumnNames_t &	columns = `{}`
	)

inline

Creates a custom column with a value dependent on the processing slot and the current entry.

Parameters

[in]	name	The name of the custom column.
[in]	expression	Function, lambda expression, functor class or any other callable object producing the temporary value. Returns the value that will be assigned to the custom column.
[in]	columns	Names of the columns/branches in input to the producer function (excluding slot and entry).

Returns: the first node of the computation graph for which the new quantity is defined.

This alternative implementation of Define is meant as a helper in writing entry-specific, thread-safe custom columns. The expression must be a callable of signature R(unsigned int, ULong64_t, T1, T2, ...) where T1, T2... are the types of the columns that the expression takes as input. The first parameter is reserved for an unsigned integer representing a "slot number". RDataFrame guarantees that different threads will invoke the expression with different slot numbers - slot numbers will range from zero to ROOT::GetImplicitMTPoolSize()-1. The second parameter is reserved for a ULong64_t representing the current entry being processed by the current thread.

The following two Defines are equivalent, although DefineSlotEntry is slightly more performant:

int function(unsigned int, ULong64_t, double, double);
Define("x", function, {"tdfslot_", "tdfentry_", "column1", "column2"})
DefineSlotEntry("x", function, {"column1", "column2"})

See Define for more information.

Definition at line 358 of file RInterface.hxx.

◆ Display() [1/4]

template<typename Proxied , typename DataSource = void>

template<typename... ColumnTypes>

RResultPtr< RDisplay > ROOT::RDF::RInterface< Proxied, DataSource >::Display	(	const ColumnNames_t &	columnList,
		const int &	nRows = `5`
	)

inline

Provides a representation of the columns in the dataset.

Template Parameters

ColumnTypes variadic list of branch/column types.

Parameters

[in]	columnList	Names of the columns to be displayed.
[in]	rows	Number of events for each column to be displayed.

Returns: the RDisplay instance wrapped in a RResultPtr.

This function returns a RResultPtr<RDisplay> containing all the entries to be displayed, organized in a tabular form. RDisplay will either print on the standard output a summarized version through Print() or will return a complete version through AsString().

Definition at line 1748 of file RInterface.hxx.

◆ Display() [2/4]

template<typename Proxied , typename DataSource = void>

RResultPtr< RDisplay > ROOT::RDF::RInterface< Proxied, DataSource >::Display	(	const ColumnNames_t &	columnList,
		const int &	nRows = `5`
	)

inline

Provides a representation of the columns in the dataset.

Parameters

[in]	columnList	Names of the columns to be displayed.
[in]	rows	Number of events for each column to be displayed.

Returns: the RDisplay instance wrapped in a RResultPtr.

This overload automatically infers the column types. See the previous overloads for further details.

Definition at line 1764 of file RInterface.hxx.

◆ Display() [3/4]

template<typename Proxied , typename DataSource = void>

RResultPtr< RDisplay > ROOT::RDF::RInterface< Proxied, DataSource >::Display	(	std::initializer_list< std::string >	columnList,
		const int &	nRows = `5`
	)

inline

Provides a representation of the columns in the dataset.

Parameters

[in]	columnList	Names of the columns to be displayed.
[in]	nRows	Number of events for each column to be displayed.

Returns: the RDisplay instance wrapped in a RResultPtr.

See the previous overloads for further details.

Definition at line 1794 of file RInterface.hxx.

◆ Display() [4/4]

template<typename Proxied , typename DataSource = void>

RResultPtr< RDisplay > ROOT::RDF::RInterface< Proxied, DataSource >::Display	(	std::string_view	columnNameRegexp = `""`,
		const int &	nRows = `5`
	)

inline

Provides a representation of the columns in the dataset.

Parameters

[in]	columnNameRegexp	A regular expression to select the columns.
[in]	rows	Number of events for each column to be displayed.

Returns: the RDisplay instance wrapped in a RResultPtr.

The existing columns are matched against the regular expression. If the string provided is empty, all columns are selected. See the previous overloads for further details.

Definition at line 1781 of file RInterface.hxx.

◆ Fill() [1/2]

template<typename Proxied , typename DataSource = void>

template<typename T >

RResultPtr< T > ROOT::RDF::RInterface< Proxied, DataSource >::Fill	(	T &&	model,
		const ColumnNames_t &	bl
	)

inline

Return an object of type T on which T::Fill will be called once per event (lazy action)

This overload infers the types of the columns specified in columnList at runtime and just-in-time compiles the method with these types. See previous overload for more information.

Template Parameters

T	The type of the object to fill. Automatically deduced.

Parameters

[in]	model	The model to be considered to build the new return value.
[in]	columnList	The name of the columns read to fill the object.

Returns: the filled object wrapped in a RResultPtr.

This overload of Fill infers the type of the specified columns at runtime and just-in-time compiles the previous overload. Check the previous overload for more details on Fill.

Definition at line 1365 of file RInterface.hxx.

◆ Fill() [2/2]

template<typename Proxied , typename DataSource = void>

template<typename FirstColumn , typename... OtherColumns, typename T >

RResultPtr< T > ROOT::RDF::RInterface< Proxied, DataSource >::Fill	(	T &&	model,
		const ColumnNames_t &	columnList
	)

inline

Return an object of type T on which T::Fill will be called once per event (lazy action)

T must be a type that provides a copy- or move-constructor and a T::Fill method that takes as many arguments as the column names pass as columnList. The arguments of T::Fill must have type equal to the one of the specified columns (these types are passed as template parameters to this method).

Template Parameters

FirstColumn	The first type of the column the values of which are used to fill the object.
OtherColumns	A list of the other types of the columns the values of which are used to fill the object.
T	The type of the object to fill. Automatically deduced.

Parameters

[in]	model	The model to be considered to build the new return value.
[in]	columnList	A list containing the names of the columns that will be passed when calling `Fill`

Returns: the filled object wrapped in a RResultPtr.

The user gives up ownership of the model object. The list of column names to be used for filling must always be specified. This action is lazy: upon invocation of this method the calculation is booked but not executed. See RResultPtr documentation.

Definition at line 1343 of file RInterface.hxx.

◆ Filter() [1/4]

template<typename Proxied , typename DataSource = void>

template<typename F , typename std::enable_if<!std::is_convertible< F, std::string >::value, int >::type = 0>

RInterface< RDFDetail::RFilter< F, Proxied >, DS_t > ROOT::RDF::RInterface< Proxied, DataSource >::Filter	(	F	f,
		const ColumnNames_t &	columns = `{}`,
		std::string_view	name = `""`
	)

inline

\brief Append a filter to the call graph.
\param[in] f Function, lambda expression, functor class or any other callable object. It must return a `bool`
signalling whether the event has passed the selection (true) or not (false).
\param[in] columns Names of the columns/branches in input to the filter function.
\param[in] name Optional name of this filter. See `Report`.
\return the filter node of the computation graph.

Append a filter node at the point of the call graph corresponding to the
object this method is called on.
The callable `f` should not have side-effects (e.g. modification of an
external or static variable) to ensure correct results when implicit
multi-threading is active.

RDataFrame only evaluates filters when necessary: if multiple filters
are chained one after another, they are executed in order and the first
one returning false causes the event to be discarded.
Even if multiple actions or transformations depend on the same filter,
it is executed once per entry. If its result is requested more than
once, the cached result is served.

### Example usage:
~~~{.cpp}
// C++ callable (function, functor class, lambda...) that takes two parameters of the types of "x" and "y"
auto filtered = df.Filter(myCut, {"x", "y"}); */

// /** // String: it must contain valid C++ except that column names can be used instead of variable names auto filtered = df.Filter("x*y > 0"); ~~~

Definition at line 195 of file RInterface.hxx.

◆ Filter() [2/4]

template<typename Proxied , typename DataSource = void>

template<typename F >

RInterface< RDFDetail::RFilter< F, Proxied >, DS_t > ROOT::RDF::RInterface< Proxied, DataSource >::Filter	(	F	f,
		const std::initializer_list< std::string > &	columns
	)

inline

Append a filter to the call graph.

Parameters

[in]	f	Function, lambda expression, functor class or any other callable object. It must return a `bool` signalling whether the event has passed the selection (true) or not (false).
[in]	columns	Names of the columns/branches in input to the filter function.

Returns: the filter node of the computation graph.

Refer to the first overload of this method for the full documentation.

Definition at line 236 of file RInterface.hxx.

◆ Filter() [3/4]

template<typename Proxied , typename DataSource = void>

template<typename F , typename std::enable_if<!std::is_convertible< F, std::string >::value, int >::type = 0>

RInterface< RDFDetail::RFilter< F, Proxied >, DS_t > ROOT::RDF::RInterface< Proxied, DataSource >::Filter	(	F	f,
		std::string_view	name
	)

inline

Append a filter to the call graph.

Parameters

[in]	f	Function, lambda expression, functor class or any other callable object. It must return a `bool` signalling whether the event has passed the selection (true) or not (false).
[in]	name	Optional name of this filter. See `Report`.

Returns: the filter node of the computation graph.

Refer to the first overload of this method for the full documentation.

Definition at line 220 of file RInterface.hxx.

◆ Filter() [4/4]

template<typename Proxied , typename DataSource = void>

RInterface< RDFDetail::RJittedFilter, DS_t > ROOT::RDF::RInterface< Proxied, DataSource >::Filter	(	std::string_view	expression,
		std::string_view	name = `""`
	)

inline

Append a filter to the call graph.

Parameters

[in]	expression	The filter expression in C++
[in]	name	Optional name of this filter. See `Report`.

Returns: the filter node of the computation graph.

The expression is just-in-time compiled and used to filter entries. It must be valid C++ syntax in which variable names are substituted with the names of branches/columns.

Refer to the first overload of this method for the full documentation.

Definition at line 252 of file RInterface.hxx.

◆ Foreach()

template<typename Proxied , typename DataSource = void>

template<typename F >

void ROOT::RDF::RInterface< Proxied, DataSource >::Foreach	(	F	f,
		const ColumnNames_t &	columns = `{}`
	)

inline

Execute a user-defined function on each entry (instant action)

Parameters

[in]	f	Function, lambda expression, functor class or any other callable object performing user defined calculations.
[in]	columns	Names of the columns/branches in input to the user function.

The callable f is invoked once per entry. This is an instant action: upon invocation, an event loop as well as execution of all scheduled actions is triggered. Users are responsible for the thread-safety of this callable when executing with implicit multi-threading enabled (i.e. ROOT::EnableImplicitMT).

Definition at line 730 of file RInterface.hxx.

◆ ForeachSlot()

template<typename Proxied , typename DataSource = void>

template<typename F >

void ROOT::RDF::RInterface< Proxied, DataSource >::ForeachSlot	(	F	f,
		const ColumnNames_t &	columns = `{}`
	)

inline

Execute a user-defined function requiring a processing slot index on each entry (instant action)

Parameters

[in]	f	Function, lambda expression, functor class or any other callable object performing user defined calculations.
[in]	columns	Names of the columns/branches in input to the user function.

Same as Foreach, but the user-defined function takes an extra unsigned int as its first parameter, the processing slot index. This slot index will be assigned a different value, 0 to poolSize - 1, for each thread of execution. This is meant as a helper in writing thread-safe Foreach actions when using RDataFrame after ROOT::EnableImplicitMT(). The user-defined processing callable is able to follow different streams of processing indexed by the first parameter. ForeachSlot works just as well with single-thread execution: in that case slot will always be 0.

Definition at line 755 of file RInterface.hxx.

◆ GetColumnNames()

template<typename Proxied , typename DataSource = void>

ColumnNames_t ROOT::RDF::RInterface< Proxied, DataSource >::GetColumnNames ( )

inline

Returns the names of the available columns.

Returns: the container of column names.

This is not an action nor a transformation, just a query to the RDataFrame object.

Definition at line 1523 of file RInterface.hxx.

◆ GetColumnType()

template<typename Proxied , typename DataSource = void>

std::string ROOT::RDF::RInterface< Proxied, DataSource >::GetColumnType ( std::string_view column )

inline

Return the type of a given column as a string.

Returns: the type of the required column.

This is not an action nor a transformation, just a query to the RDataFrame object.

Definition at line 1555 of file RInterface.hxx.

◆ GetColumnTypeNamesList()

template<typename Proxied , typename DataSource = void>

std::vector< std::string > ROOT::RDF::RInterface< Proxied, DataSource >::GetColumnTypeNamesList ( const ColumnNames_t & columnList )

inlineprivate

Definition at line 1849 of file RInterface.hxx.

◆ GetDefinedColumnNames()

template<typename Proxied , typename DataSource = void>

ColumnNames_t ROOT::RDF::RInterface< Proxied, DataSource >::GetDefinedColumnNames ( )

inline

Returns the names of the defined columns.

Returns: the container of the defined column names.

This is not an action nor a transformation, just a simple utility to get the columns names that have been defined up to the node. If no custom column has been defined, e.g. on a root node, it returns an empty array.

Definition at line 1590 of file RInterface.hxx.

◆ GetFilterNames()

template<typename Proxied , typename DataSource = void>

std::vector< std::string > ROOT::RDF::RInterface< Proxied, DataSource >::GetFilterNames ( )

inline

Returns the names of the filters created.

Returns: the container of filters names.

If called on a root node, all the filters in the computation graph will be printed. For any other node, only the filters upstream of that node. Filters without a name are printed as "Unnamed Filter" This is not an action nor a transformation, just a query to the RDataFrame object.

Definition at line 1581 of file RInterface.hxx.

◆ GetLoopManager()

template<typename Proxied , typename DataSource = void>

RLoopManager * ROOT::RDF::RInterface< Proxied, DataSource >::GetLoopManager ( ) const

inlineprotected

Definition at line 2065 of file RInterface.hxx.

◆ GetProxiedPtr()

template<typename Proxied , typename DataSource = void>

const std::shared_ptr< Proxied > & ROOT::RDF::RInterface< Proxied, DataSource >::GetProxiedPtr ( ) const

inlineprotected

Definition at line 2067 of file RInterface.hxx.

◆ GetValidatedColumnNames()

template<typename Proxied , typename DataSource = void>

ColumnNames_t ROOT::RDF::RInterface< Proxied, DataSource >::GetValidatedColumnNames	(	const unsigned int	nColumns,
		const ColumnNames_t &	columns
	)

inlineprotected

Prepare the call to the GetValidatedColumnNames routine, making sure that GetBranchNames, which is expensive in terms of runtime, is called at most once.

Definition at line 2071 of file RInterface.hxx.

◆ Graph()

template<typename Proxied , typename DataSource = void>

template<typename V1 = RDFDetail::RInferredType, typename V2 = RDFDetail::RInferredType>

RResultPtr<::TGraph > ROOT::RDF::RInterface< Proxied, DataSource >::Graph	(	std::string_view	v1Name = `""`,
		std::string_view	v2Name = `""`
	)

inline

Fill and return a graph (lazy action)

Template Parameters

V1	The type of the column used to fill the x axis of the graph.
V2	The type of the column used to fill the y axis of the graph.

Parameters

[in]	v1Name	The name of the column that will fill the x axis.
[in]	v2Name	The name of the column that will fill the y axis.

Returns: the graph wrapped in a RResultPtr.

Columns can be of a container type (e.g. std::vector<double>), in which case the graph is filled with each one of the elements of the container. If Multithreading is enabled, the order in which points are inserted is undefined. If the Graph has to be drawn, it is suggested to the user to sort it on the x before printing. A name and a title to the graph is given based on the input column names.

This action is lazy: upon invocation of this method the calculation is booked but not executed. See RResultPtr documentation.

Definition at line 1154 of file RInterface.hxx.

◆ Histo1D() [1/5]

template<typename Proxied , typename DataSource = void>

template<typename V = RDFDetail::RInferredType, typename W = RDFDetail::RInferredType>

RResultPtr<::TH1D > ROOT::RDF::RInterface< Proxied, DataSource >::Histo1D	(	const TH1DModel &	model,
		std::string_view	vName,
		std::string_view	wName
	)

inline

Fill and return a one-dimensional histogram with the weighted values of a column (lazy action)

Template Parameters

V	The type of the column used to fill the histogram.
W	The type of the column used as weights.

Parameters

[in]	model	The returned histogram will be constructed using this as a model.
[in]	vName	The name of the column that will fill the histogram.
[in]	wName	The name of the column that will provide the weights.

Returns: the monodimensional histogram wrapped in a RResultPtr.

See the description of the first Histo1D overload for more details.

Definition at line 938 of file RInterface.hxx.

◆ Histo1D() [2/5]

template<typename Proxied , typename DataSource = void>

template<typename V , typename W >

RResultPtr<::TH1D > ROOT::RDF::RInterface< Proxied, DataSource >::Histo1D ( const TH1DModel & model = {"", "", 128u, 0., 0.} )

inline

Fill and return a one-dimensional histogram with the weighted values of a column (lazy action)

Template Parameters

V	The type of the column used to fill the histogram.
W	The type of the column used as weights.

Parameters

[in] model The returned histogram will be constructed using this as a model.

Returns: the monodimensional histogram wrapped in a RResultPtr.

This overload will use the first two default columns as column names. See the description of the first Histo1D overload for more details.

Definition at line 982 of file RInterface.hxx.

◆ Histo1D() [3/5]

template<typename Proxied , typename DataSource = void>

template<typename V = RDFDetail::RInferredType>

RResultPtr<::TH1D > ROOT::RDF::RInterface< Proxied, DataSource >::Histo1D	(	const TH1DModel &	model = `{"", "", 128u, 0., 0.}`,
		std::string_view	vName = `""`
	)

inline

Fill and return a one-dimensional histogram with the values of a column (lazy action)

Template Parameters

V	The type of the column used to fill the histogram.

Parameters

[in]	model	The returned histogram will be constructed using this as a model.
[in]	vName	The name of the column that will fill the histogram.

Returns: the monodimensional histogram wrapped in a RResultPtr.

Columns can be of a container type (e.g. std::vector<double>), in which case the histogram is filled with each one of the elements of the container. In case multiple columns of container type are provided (e.g. values and weights) they must have the same length for each one of the events (but possibly different lengths between events). This action is lazy: upon invocation of this method the calculation is booked but not executed. See RResultPtr documentation. The user gives up ownership of the model histogram.

Definition at line 895 of file RInterface.hxx.

◆ Histo1D() [4/5]

template<typename Proxied , typename DataSource = void>

template<typename V = RDFDetail::RInferredType>

RResultPtr<::TH1D > ROOT::RDF::RInterface< Proxied, DataSource >::Histo1D ( std::string_view vName )

inline

Fill and return a one-dimensional histogram with the values of a column (lazy action)

Template Parameters

V	The type of the column used to fill the histogram.

Parameters

[in] vName The name of the column that will fill the histogram.

Returns: the monodimensional histogram wrapped in a RResultPtr.

This overload uses a default model histogram TH1D(name, title, 128u, 0., 0.). The "name" and "title" strings are built starting from the input column name. See the description of the first Histo1D overload for more details.

Definition at line 920 of file RInterface.hxx.

◆ Histo1D() [5/5]

template<typename Proxied , typename DataSource = void>

template<typename V = RDFDetail::RInferredType, typename W = RDFDetail::RInferredType>

RResultPtr<::TH1D > ROOT::RDF::RInterface< Proxied, DataSource >::Histo1D	(	std::string_view	vName,
		std::string_view	wName
	)

inline

Fill and return a one-dimensional histogram with the weighted values of a column (lazy action)

Template Parameters

V	The type of the column used to fill the histogram.
W	The type of the column used as weights.

Parameters

[in]	vName	The name of the column that will fill the histogram.
[in]	wName	The name of the column that will provide the weights.

Returns: the monodimensional histogram wrapped in a RResultPtr.

This overload uses a default model histogram TH1D(name, title, 128u, 0., 0.). The "name" and "title" strings are built starting from the input column names. See the description of the first Histo1D overload for more details.

Definition at line 964 of file RInterface.hxx.

◆ Histo2D() [1/3]

template<typename Proxied , typename DataSource = void>

template<typename V1 , typename V2 , typename W >

RResultPtr<::TH2D > ROOT::RDF::RInterface< Proxied, DataSource >::Histo2D ( const TH2DModel & model )

inline

Definition at line 1056 of file RInterface.hxx.

◆ Histo2D() [2/3]

template<typename Proxied , typename DataSource = void>

template<typename V1 = RDFDetail::RInferredType, typename V2 = RDFDetail::RInferredType, typename W = RDFDetail::RInferredType>

RResultPtr<::TH2D > ROOT::RDF::RInterface< Proxied, DataSource >::Histo2D	(	const TH2DModel &	model,
		std::string_view	v1Name,
		std::string_view	v2Name,
		std::string_view	wName
	)

inline

Fill and return a weighted two-dimensional histogram (lazy action)

Template Parameters

V1	The type of the column used to fill the x axis of the histogram.
V2	The type of the column used to fill the y axis of the histogram.
W	The type of the column used for the weights of the histogram.

Parameters

[in]	model	The returned histogram will be constructed using this as a model.
[in]	v1Name	The name of the column that will fill the x axis.
[in]	v2Name	The name of the column that will fill the y axis.
[in]	wName	The name of the column that will provide the weights.

Returns: the bidimensional histogram wrapped in a RResultPtr.

This action is lazy: upon invocation of this method the calculation is booked but not executed. See RResultPtr documentation. The user gives up ownership of the model histogram.

Definition at line 1038 of file RInterface.hxx.

◆ Histo2D() [3/3]

template<typename Proxied , typename DataSource = void>

template<typename V1 = RDFDetail::RInferredType, typename V2 = RDFDetail::RInferredType>

RResultPtr<::TH2D > ROOT::RDF::RInterface< Proxied, DataSource >::Histo2D	(	const TH2DModel &	model,
		std::string_view	v1Name = `""`,
		std::string_view	v2Name = `""`
	)

inline

Fill and return a two-dimensional histogram (lazy action)

Template Parameters

V1	The type of the column used to fill the x axis of the histogram.
V2	The type of the column used to fill the y axis of the histogram.

Parameters

[in]	model	The returned histogram will be constructed using this as a model.
[in]	v1Name	The name of the column that will fill the x axis.
[in]	v2Name	The name of the column that will fill the y axis.

Returns: the bidimensional histogram wrapped in a RResultPtr.

Columns can be of a container type (e.g. std::vector<double>), in which case the histogram is filled with each one of the elements of the container. In case multiple columns of container type are provided (e.g. values and weights) they must have the same length for each one of the events (but possibly different lengths between events). This action is lazy: upon invocation of this method the calculation is booked but not executed. See RResultPtr documentation. The user gives up ownership of the model histogram.

Definition at line 1004 of file RInterface.hxx.

◆ Histo3D() [1/3]

template<typename Proxied , typename DataSource = void>

template<typename V1 , typename V2 , typename V3 , typename W >

RResultPtr<::TH3D > ROOT::RDF::RInterface< Proxied, DataSource >::Histo3D ( const TH3DModel & model )

inline

Definition at line 1132 of file RInterface.hxx.

◆ Histo3D() [2/3]

template<typename Proxied , typename DataSource = void>

template<typename V1 = RDFDetail::RInferredType, typename V2 = RDFDetail::RInferredType, typename V3 = RDFDetail::RInferredType, typename W = RDFDetail::RInferredType>

RResultPtr<::TH3D > ROOT::RDF::RInterface< Proxied, DataSource >::Histo3D	(	const TH3DModel &	model,
		std::string_view	v1Name,
		std::string_view	v2Name,
		std::string_view	v3Name,
		std::string_view	wName
	)

inline

Fill and return a three-dimensional histogram (lazy action)

Template Parameters

V1	The type of the column used to fill the x axis of the histogram. Inferred if not present.
V2	The type of the column used to fill the y axis of the histogram. Inferred if not present.
V3	The type of the column used to fill the z axis of the histogram. Inferred if not present.
W	The type of the column used for the weights of the histogram. Inferred if not present.

Parameters

[in]	model	The returned histogram will be constructed using this as a model.
[in]	v1Name	The name of the column that will fill the x axis.
[in]	v2Name	The name of the column that will fill the y axis.
[in]	v3Name	The name of the column that will fill the z axis.
[in]	wName	The name of the column that will provide the weights.

Returns: the tridimensional histogram wrapped in a RResultPtr.

This action is lazy: upon invocation of this method the calculation is booked but not executed. See RResultPtr documentation. The user gives up ownership of the model histogram.

Definition at line 1113 of file RInterface.hxx.

◆ Histo3D() [3/3]

template<typename Proxied , typename DataSource = void>

template<typename V1 = RDFDetail::RInferredType, typename V2 = RDFDetail::RInferredType, typename V3 = RDFDetail::RInferredType>

RResultPtr<::TH3D > ROOT::RDF::RInterface< Proxied, DataSource >::Histo3D	(	const TH3DModel &	model,
		std::string_view	v1Name = `""`,
		std::string_view	v2Name = `""`,
		std::string_view	v3Name = `""`
	)

inline

Fill and return a three-dimensional histogram (lazy action)

Template Parameters

V1	The type of the column used to fill the x axis of the histogram. Inferred if not present.
V2	The type of the column used to fill the y axis of the histogram. Inferred if not present.
V3	The type of the column used to fill the z axis of the histogram. Inferred if not present.

Parameters

[in]	model	The returned histogram will be constructed using this as a model.
[in]	v1Name	The name of the column that will fill the x axis.
[in]	v2Name	The name of the column that will fill the y axis.
[in]	v3Name	The name of the column that will fill the z axis.

Returns: the tridimensional histogram wrapped in a RResultPtr.

This action is lazy: upon invocation of this method the calculation is booked but not executed. See RResultPtr documentation. The user gives up ownership of the model histogram.

Definition at line 1077 of file RInterface.hxx.

◆ Max()

template<typename Proxied , typename DataSource = void>

template<typename T = RDFDetail::RInferredType>

RResultPtr< RDFDetail::MaxReturnType_t< T > > ROOT::RDF::RInterface< Proxied, DataSource >::Max ( std::string_view columnName = "" )

inline

Return the maximum of processed column values (lazy action)

Template Parameters

T	The type of the branch/column.

Parameters

[in] columnName The name of the branch/column to be treated.

Returns: the maximum value of the selected column wrapped in a RResultPtr.

If T is not specified, RDataFrame will infer it from the data and just-in-time compile the correct template specialization of this method. If the type of the column is inferred, the return type is double, the type of the column otherwise.

This action is lazy: upon invocation of this method the calculation is booked but not executed. See RResultPtr documentation.

Definition at line 1408 of file RInterface.hxx.

◆ Mean()

template<typename Proxied , typename DataSource = void>

template<typename T = RDFDetail::RInferredType>

RResultPtr< double > ROOT::RDF::RInterface< Proxied, DataSource >::Mean ( std::string_view columnName = "" )

inline

Return the mean of processed column values (lazy action)

Template Parameters

T	The type of the branch/column.

Parameters

[in] columnName The name of the branch/column to be treated.

Returns: the mean value of the selected column wrapped in a RResultPtr.

If T is not specified, RDataFrame will infer it from the data and just-in-time compile the correct template specialization of this method.

This action is lazy: upon invocation of this method the calculation is booked but not executed. See RResultPtr documentation.

Definition at line 1428 of file RInterface.hxx.

◆ Min()

template<typename Proxied , typename DataSource = void>

template<typename T = RDFDetail::RInferredType>

RResultPtr< RDFDetail::MinReturnType_t< T > > ROOT::RDF::RInterface< Proxied, DataSource >::Min ( std::string_view columnName = "" )

inline

Return the minimum of processed column values (lazy action)

Template Parameters

T	The type of the branch/column.

Parameters

[in] columnName The name of the branch/column to be treated.

Returns: the minimum value of the selected column wrapped in a RResultPtr.

If T is not specified, RDataFrame will infer it from the data and just-in-time compile the correct template specialization of this method. If the type of the column is inferred, the return type is double, the type of the column otherwise.

This action is lazy: upon invocation of this method the calculation is booked but not executed. See RResultPtr documentation.

Definition at line 1387 of file RInterface.hxx.

◆ operator RNode()

template<typename Proxied , typename DataSource = void>

ROOT::RDF::RInterface< Proxied, DataSource >::operator RNode ( ) const

inline

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

Different RDataFrame methods return different C++ types. All nodes, however, can be cast to this common type at the cost of a small performance penalty. This allows, for example, storing RDataFrame nodes in a vector, or passing them around via (non-template, C++11) helper functions. Example usage:

// a function that conditionally adds a Range to a RDataFrame node.
RNode MaybeAddRange(RNode df, bool mustAddRange)
{
   return mustAddRange ? df.Range(1) : df;
}
// use as :
ROOT::RDataFrame df(10);
auto maybeRanged = MaybeAddRange(df, true);

Note that it is not a problem to pass RNode's by value.

Definition at line 158 of file RInterface.hxx.

◆ operator=()

template<typename Proxied , typename DataSource = void>

RInterface & ROOT::RDF::RInterface< Proxied, DataSource >::operator= ( const RInterface< Proxied, DataSource > & )

default

Copy-assignment operator for RInterface.

◆ Profile1D() [1/3]

template<typename Proxied , typename DataSource = void>

template<typename V1 , typename V2 , typename W >

RResultPtr<::TProfile > ROOT::RDF::RInterface< Proxied, DataSource >::Profile1D ( const TProfile1DModel & model )

inline

Definition at line 1242 of file RInterface.hxx.

◆ Profile1D() [2/3]

template<typename Proxied , typename DataSource = void>

template<typename V1 = RDFDetail::RInferredType, typename V2 = RDFDetail::RInferredType, typename W = RDFDetail::RInferredType>

RResultPtr<::TProfile > ROOT::RDF::RInterface< Proxied, DataSource >::Profile1D	(	const TProfile1DModel &	model,
		std::string_view	v1Name,
		std::string_view	v2Name,
		std::string_view	wName
	)

inline

Fill and return a one-dimensional profile (lazy action)

Template Parameters

V1	The type of the column the values of which are used to fill the profile. Inferred if not present.
V2	The type of the column the values of which are used to fill the profile. Inferred if not present.
W	The type of the column the weights of which are used to fill the profile. Inferred if not present.

Parameters

[in]	model	The model to be considered to build the new return value.
[in]	v1Name	The name of the column that will fill the x axis.
[in]	v2Name	The name of the column that will fill the y axis.
[in]	wName	The name of the column that will provide the weights.

Returns: the monodimensional profile wrapped in a RResultPtr.

This action is lazy: upon invocation of this method the calculation is booked but not executed. See RResultPtr documentation. The user gives up ownership of the model profile object.

Definition at line 1223 of file RInterface.hxx.

◆ Profile1D() [3/3]

template<typename Proxied , typename DataSource = void>

template<typename V1 = RDFDetail::RInferredType, typename V2 = RDFDetail::RInferredType>

RResultPtr<::TProfile > ROOT::RDF::RInterface< Proxied, DataSource >::Profile1D	(	const TProfile1DModel &	model,
		std::string_view	v1Name = `""`,
		std::string_view	v2Name = `""`
	)

inline

Fill and return a one-dimensional profile (lazy action)

Template Parameters

V1	The type of the column the values of which are used to fill the profile. Inferred if not present.
V2	The type of the column the values of which are used to fill the profile. Inferred if not present.

Parameters

[in]	model	The model to be considered to build the new return value.
[in]	v1Name	The name of the column that will fill the x axis.
[in]	v2Name	The name of the column that will fill the y axis.

Returns: the monodimensional profile wrapped in a RResultPtr.

This action is lazy: upon invocation of this method the calculation is booked but not executed. See RResultPtr documentation. The user gives up ownership of the model profile object.

Definition at line 1188 of file RInterface.hxx.

◆ Profile2D() [1/3]

template<typename Proxied , typename DataSource = void>

template<typename V1 , typename V2 , typename V3 , typename W >

RResultPtr<::TProfile2D > ROOT::RDF::RInterface< Proxied, DataSource >::Profile2D ( const TProfile2DModel & model )

inline

Definition at line 1320 of file RInterface.hxx.

◆ Profile2D() [2/3]

template<typename Proxied , typename DataSource = void>

template<typename V1 = RDFDetail::RInferredType, typename V2 = RDFDetail::RInferredType, typename V3 = RDFDetail::RInferredType, typename W = RDFDetail::RInferredType>

RResultPtr<::TProfile2D > ROOT::RDF::RInterface< Proxied, DataSource >::Profile2D	(	const TProfile2DModel &	model,
		std::string_view	v1Name,
		std::string_view	v2Name,
		std::string_view	v3Name,
		std::string_view	wName
	)

inline

Fill and return a two-dimensional profile (lazy action)

Template Parameters

V1	The type of the column used to fill the x axis of the histogram. Inferred if not present.
V2	The type of the column used to fill the y axis of the histogram. Inferred if not present.
V3	The type of the column used to fill the z axis of the histogram. Inferred if not present.
W	The type of the column used for the weights of the histogram. Inferred if not present.

Parameters

[in]	model	The returned histogram will be constructed using this as a model.
[in]	v1Name	The name of the column that will fill the x axis.
[in]	v2Name	The name of the column that will fill the y axis.
[in]	v3Name	The name of the column that will fill the z axis.
[in]	wName	The name of the column that will provide the weights.

Returns: the bidimensional profile wrapped in a RResultPtr.

This action is lazy: upon invocation of this method the calculation is booked but not executed. See RResultPtr documentation. The user gives up ownership of the model profile.

Definition at line 1300 of file RInterface.hxx.

◆ Profile2D() [3/3]

template<typename Proxied , typename DataSource = void>

template<typename V1 = RDFDetail::RInferredType, typename V2 = RDFDetail::RInferredType, typename V3 = RDFDetail::RInferredType>

RResultPtr<::TProfile2D > ROOT::RDF::RInterface< Proxied, DataSource >::Profile2D	(	const TProfile2DModel &	model,
		std::string_view	v1Name = `""`,
		std::string_view	v2Name = `""`,
		std::string_view	v3Name = `""`
	)

inline

Fill and return a two-dimensional profile (lazy action)

Template Parameters

V1	The type of the column used to fill the x axis of the histogram. Inferred if not present.
V2	The type of the column used to fill the y axis of the histogram. Inferred if not present.
V2	The type of the column used to fill the z axis of the histogram. Inferred if not present.

Parameters

[in]	model	The returned profile will be constructed using this as a model.
[in]	v1Name	The name of the column that will fill the x axis.
[in]	v2Name	The name of the column that will fill the y axis.
[in]	v3Name	The name of the column that will fill the z axis.

Returns: the bidimensional profile wrapped in a RResultPtr.

This action is lazy: upon invocation of this method the calculation is booked but not executed. See RResultPtr documentation. The user gives up ownership of the model profile.

Definition at line 1263 of file RInterface.hxx.

◆ Range() [1/2]

template<typename Proxied , typename DataSource = void>

RInterface< RDFDetail::RRange< Proxied >, DS_t > ROOT::RDF::RInterface< Proxied, DataSource >::Range	(	unsigned int	begin,
		unsigned int	end,
		unsigned int	stride = `1`
	)

inline

Creates a node that filters entries based on range: [begin, end)

Parameters

[in]	begin	Initial entry number considered for this range.
[in]	end	Final entry number (excluded) considered for this range. 0 means that the range goes until the end of the dataset.
[in]	stride	Process one entry of the [begin, end) range every `stride` entries. Must be strictly greater than 0.

Returns: the first node of the computation graph for which the event loop is limited to a certain range of entries.

Note that in case of previous Ranges and Filters the selected range refers to the transformed dataset. Ranges are only available if EnableImplicitMT has not been called. Multi-thread ranges are not supported.

Definition at line 693 of file RInterface.hxx.

◆ Range() [2/2]

template<typename Proxied , typename DataSource = void>

RInterface< RDFDetail::RRange< Proxied >, DS_t > ROOT::RDF::RInterface< Proxied, DataSource >::Range ( unsigned int end )

inline

Creates a node that filters entries based on range.

Parameters

[in] end Final entry number (excluded) considered for this range. 0 means that the range goes until the end of the dataset.

Returns: a node of the computation graph for which the range is defined.

See the other Range overload for a detailed description.

Definition at line 715 of file RInterface.hxx.

◆ Reduce() [1/2]

template<typename Proxied , typename DataSource = void>

template<typename F , typename T = typename TTraits::CallableTraits<F>::ret_type>

RResultPtr< T > ROOT::RDF::RInterface< Proxied, DataSource >::Reduce	(	F	f,
		std::string_view	columnName,
		const T &	redIdentity
	)

inline

Execute a user-defined reduce operation on the values of a column.

Template Parameters

F	The type of the reduce callable. Automatically deduced.
T	The type of the column to apply the reduction to. Automatically deduced.

Parameters

[in]	f	A callable with signature `T(T,T)`
[in]	columnName	The column to be reduced. If omitted, the first default column is used instead.
[in]	redIdentity	The reduced object of each thread is initialised to this value.

Returns: the reduced quantity wrapped in a RResultPtr.

See the description of the first Reduce overload for more information.

Definition at line 818 of file RInterface.hxx.

◆ Reduce() [2/2]

template<typename Proxied , typename DataSource = void>

template<typename F , typename T = typename TTraits::CallableTraits<F>::ret_type>

RResultPtr< T > ROOT::RDF::RInterface< Proxied, DataSource >::Reduce	(	F	f,
		std::string_view	columnName = `""`
	)

inline

Execute a user-defined reduce operation on the values of a column.

Template Parameters

F	The type of the reduce callable. Automatically deduced.
T	The type of the column to apply the reduction to. Automatically deduced.

Parameters

[in]	f	A callable with signature `T(T,T)`
[in]	columnName	The column to be reduced. If omitted, the first default column is used instead.

Returns: the reduced quantity wrapped in a RResultPtr.

A reduction takes two values of a column and merges them into one (e.g. by summing them, taking the maximum, etc). This action performs the specified reduction operation on all processed column values, returning a single value of the same type. The callable f must satisfy the general requirements of a processing function besides having signature T(T,T) where T is the type of column columnName.

The returned reduced value of each thread (e.g. the initial value of a sum) is initialized to a default-constructed T object. This is commonly expected to be the neutral/identity element for the specific reduction operation f (e.g. 0 for a sum, 1 for a product). If a default-constructed T does not satisfy this requirement, users should explicitly specify an initialization value for T by calling the appropriate Reduce overload.

This action is lazy: upon invocation of this method the calculation is booked but not executed. See RResultPtr documentation.

Definition at line 799 of file RInterface.hxx.

◆ Report()

template<typename Proxied , typename DataSource = void>

RResultPtr< RCutFlowReport > ROOT::RDF::RInterface< Proxied, DataSource >::Report ( )

inline

Gather filtering statistics.

Returns: the resulting RCutFlowReport instance wrapped in a RResultPtr.

Calling Report on the main RDataFrame object gathers stats for all named filters in the call graph. Calling this method on a stored chain state (i.e. a graph node different from the first) gathers the stats for all named filters in the chain section between the original RDataFrame and that node (included). Stats are gathered in the same order as the named filters have been added to the graph. A RResultPtr<RCutFlowReport> is returned to allow inspection of the effects cuts had.

This action is lazy: upon invocation of this method the calculation is booked but not executed. See RResultPtr documentation.

Definition at line 1496 of file RInterface.hxx.

◆ Snapshot() [1/4]

template<typename Proxied , typename DataSource = void>

template<typename... ColumnTypes>

RResultPtr< RInterface< RLoopManager > > ROOT::RDF::RInterface< Proxied, DataSource >::Snapshot	(	std::string_view	treename,
		std::string_view	filename,
		const ColumnNames_t &	columnList,
		const RSnapshotOptions &	options = `RSnapshotOptions()`
	)

inline

Save selected columns to disk, in a new TTree treename in file filename.

Template Parameters

ColumnTypes variadic list of branch/column types.

Parameters

[in]	treename	The name of the output TTree.
[in]	filename	The name of the output TFile.
[in]	columnList	The list of names of the columns/branches to be written.
[in]	options	RSnapshotOptions struct with extra options to pass to TFile and TTree.

Returns: a RDataFrame that wraps the snapshotted dataset.

Support for writing of nested branches is limited (although RDataFrame is able to read them) and dot ('.') characters in input column names will be replaced by underscores ('_') in the branches produced by Snapshot. When writing a variable size array through Snapshot, it is required that the column indicating its size is also written out and it appears before the array in the columnList.

Example invocations:

// without specifying template parameters (column types automatically deduced)
df.Snapshot("outputTree", "outputFile.root", {"x", "y"});
 
// specifying template parameters ("x" is `int`, "y" is `float`)
df.Snapshot<int, float>("outputTree", "outputFile.root", {"x", "y"});

Using Snapshot as a lazy action

To book a Snapshot without triggering the event loop, one needs to set the appropriate flag in RSnapshotOptions:

RSnapshotOptions opts;
opts.fLazy = true;
df.Snapshot("outputTree", "outputFile.root", {"x"}, opts);

Definition at line 470 of file RInterface.hxx.

◆ Snapshot() [2/4]

template<typename Proxied , typename DataSource = void>

RResultPtr< RInterface< RLoopManager > > ROOT::RDF::RInterface< Proxied, DataSource >::Snapshot	(	std::string_view	treename,
		std::string_view	filename,
		const ColumnNames_t &	columnList,
		const RSnapshotOptions &	options = `RSnapshotOptions()`
	)

inline

Save selected columns to disk, in a new TTree treename in file filename.

Parameters

[in]	treename	The name of the output TTree.
[in]	filename	The name of the output TFile.
[in]	columnList	The list of names of the columns/branches to be written.
[in]	options	RSnapshotOptions struct with extra options to pass to TFile and TTree.

Returns: a RDataFrame that wraps the snapshotted dataset.

This function returns a RDataFrame built with the output tree as a source. The types of the columns are automatically inferred and do not need to be specified.

See above for a more complete description and example usages.

Definition at line 488 of file RInterface.hxx.

◆ Snapshot() [3/4]

template<typename Proxied , typename DataSource = void>

RResultPtr< RInterface< RLoopManager > > ROOT::RDF::RInterface< Proxied, DataSource >::Snapshot	(	std::string_view	treename,
		std::string_view	filename,
		std::initializer_list< std::string >	columnList,
		const RSnapshotOptions &	options = `RSnapshotOptions()`
	)

inline

Save selected columns to disk, in a new TTree treename in file filename.

Parameters

[in]	treename	The name of the output TTree.
[in]	filename	The name of the output TFile.
[in]	columnList	The list of names of the columns/branches to be written.
[in]	options	RSnapshotOptions struct with extra options to pass to TFile and TTree.

Returns: a RDataFrame that wraps the snapshotted dataset.

This function returns a RDataFrame built with the output tree as a source. The types of the columns are automatically inferred and do not need to be specified.

See above for a more complete description and example usages.

Definition at line 577 of file RInterface.hxx.

◆ Snapshot() [4/4]

template<typename Proxied , typename DataSource = void>

RResultPtr< RInterface< RLoopManager > > ROOT::RDF::RInterface< Proxied, DataSource >::Snapshot	(	std::string_view	treename,
		std::string_view	filename,
		std::string_view	columnNameRegexp = `""`,
		const RSnapshotOptions &	options = `RSnapshotOptions()`
	)

inline

Save selected columns to disk, in a new TTree treename in file filename.

Parameters

[in]	treename	The name of the output TTree.
[in]	filename	The name of the output TFile.
[in]	columnNameRegexp	The regular expression to match the column names to be selected. The presence of a '^' and a '$' at the end of the string is implicitly assumed if they are not specified. See the documentation of TRegexp for more details. An empty string signals the selection of all columns.
[in]	options	RSnapshotOptions struct with extra options to pass to TFile and TTree

Returns: a RDataFrame that wraps the snapshotted dataset.

This function returns a RDataFrame built with the output tree as a source. The types of the columns are automatically inferred and do not need to be specified.

See above for a more complete description and example usages.

Definition at line 555 of file RInterface.hxx.

◆ SnapshotImpl()

template<typename Proxied , typename DataSource = void>

template<typename... ColumnTypes>

RResultPtr< RInterface< RLoopManager > > ROOT::RDF::RInterface< Proxied, DataSource >::SnapshotImpl	(	std::string_view	treename,
		std::string_view	filename,
		const ColumnNames_t &	columnList,
		const RSnapshotOptions &	options
	)

inlineprivate

Implementation of snapshot.

Parameters

[in]	treename	The name of the TTree
[in]	filename	The name of the TFile
[in]	columnList	The list of names of the branches to be written The implementation exploits Foreach. The association of the addresses to the branches takes place at the first event. This is possible because since there are no copies, the address of the value passed by reference is the address pointing to the storage of the read/created object in/by the TTreeReaderValue/TemporaryBranch

Definition at line 1993 of file RInterface.hxx.

◆ StdDev()

template<typename Proxied , typename DataSource = void>

template<typename T = RDFDetail::RInferredType>

RResultPtr< double > ROOT::RDF::RInterface< Proxied, DataSource >::StdDev ( std::string_view columnName = "" )

inline

Return the unbiased standard deviation of processed column values (lazy action)

Template Parameters

T	The type of the branch/column.

Parameters

[in] columnName The name of the branch/column to be treated.

Returns: the standard deviation value of the selected column wrapped in a RResultPtr.

If T is not specified, RDataFrame will infer it from the data and just-in-time compile the correct template specialization of this method.

This action is lazy: upon invocation of this method the calculation is booked but not executed. See RResultPtr documentation.

Definition at line 1447 of file RInterface.hxx.

◆ Sum()

template<typename Proxied , typename DataSource = void>

template<typename T = RDFDetail::RInferredType>

RResultPtr< RDFDetail::SumReturnType_t< T > > ROOT::RDF::RInterface< Proxied, DataSource >::Sum	(	std::string_view	columnName = `""`,
		const RDFDetail::SumReturnType_t< T > &	initValue = `RDFDetail::SumReturnType_t<T>{}`
	)

inline

Return the sum of processed column values (lazy action)

Template Parameters

T	The type of the branch/column.

Parameters

[in]	columnName	The name of the branch/column.
[in]	initValue	Optional initial value for the sum. If not present, the column values must be default-constructible.

Returns: the sum of the selected column wrapped in a RResultPtr.

If T is not specified, RDataFrame will infer it from the data and just-in-time compile the correct template specialization of this method. If the type of the column is inferred, the return type is double, the type of the column otherwise.

This action is lazy: upon invocation of this method the calculation is booked but not executed. See RResultPtr documentation.

Definition at line 1470 of file RInterface.hxx.

◆ Take()

template<typename Proxied , typename DataSource = void>

template<typename T , typename COLL = std::vector<T>>

RResultPtr< COLL > ROOT::RDF::RInterface< Proxied, DataSource >::Take ( std::string_view column = "" )

inline

Return a collection of values of a column (lazy action, returns a std::vector by default)

Template Parameters

T	The type of the column.
COLL	The type of collection used to store the values.

Parameters

[in] column The name of the column to collect the values of.

Returns: the content of the selected column wrapped in a RResultPtr.

The collection type to be specified for C-style array columns is RVec<T>: in this case the returned collection is a std::vector<RVec<T>>.

Example usage:

// In this case intCol is a std::vector<int>
auto intCol = rdf.Take<int>("integerColumn");
// Same content as above but in this case taken as a RVec<int>
auto intColAsRVec = rdf.Take<int, RVec<int>>("integerColumn");
// In this case intCol is a std::vector<RVec<int>>, a collection of collections
auto cArrayIntCol = rdf.Take<RVec<int>>("cArrayInt");

This action is lazy: upon invocation of this method the calculation is booked but not executed. See RResultPtr documentation.

Definition at line 862 of file RInterface.hxx.

Friends And Related Function Documentation

◆ RInterface

template<typename Proxied , typename DataSource = void>

template<typename T , typename W >

friend class RInterface

friend

Definition at line 107 of file RInterface.hxx.

◆ cling::printValue

template<typename Proxied , typename DataSource = void>

std::string cling::printValue ( ::ROOT::RDataFrame * tdf )

friend

◆ RDFInternal::ConvertRegexToColumns

template<typename Proxied , typename DataSource = void>

ColumnNames_t RDFInternal::ConvertRegexToColumns	(	const RNode &	node,
		std::string_view	columnNameRegexp,
		std::string_view	callerName
	)

friend

◆ RDFInternal::CreateSnaphotRDF

template<typename Proxied , typename DataSource = void>

HeadNode_t RDFInternal::CreateSnaphotRDF	(	const ColumnNames_t &	validCols,
		const std::string &	fullTreeName,
		const std::string &	fileName,
		bool	isLazy,
		RLoopManager &	loopManager,
		std::unique_ptr< RDFInternal::RActionBase >	actionPtr
	)

friend

◆ RDFInternal::GraphDrawing::GraphCreatorHelper

template<typename Proxied , typename DataSource = void>

friend class RDFInternal::GraphDrawing::GraphCreatorHelper

friend

Definition at line 94 of file RInterface.hxx.

Member Data Documentation

◆ fCustomColumns

template<typename Proxied , typename DataSource = void>

RDFInternal::RBookedCustomColumns ROOT::RDF::RInterface< Proxied, DataSource >::fCustomColumns

private

Contains the custom columns defined up to this node.

Definition at line 116 of file RInterface.hxx.

◆ fDataSource

template<typename Proxied , typename DataSource = void>

RDataSource* ROOT::RDF::RInterface< Proxied, DataSource >::fDataSource = nullptr

private

Non-owning pointer to a data-source object. Null if no data-source. RLoopManager has ownership of the object.

Definition at line 113 of file RInterface.hxx.

◆ fLoopManager

template<typename Proxied , typename DataSource = void>

RLoopManager* ROOT::RDF::RInterface< Proxied, DataSource >::fLoopManager

private

Definition at line 111 of file RInterface.hxx.

◆ fProxiedPtr

template<typename Proxied , typename DataSource = void>

std::shared_ptr<Proxied> ROOT::RDF::RInterface< Proxied, DataSource >::fProxiedPtr

private

Smart pointer to the graph node encapsulated by this RInterface.

The RLoopManager at the root of this computation graph. Never null.

Definition at line 109 of file RInterface.hxx.

Libraries for ROOT::RDF::RInterface< Proxied, DataSource >:

[legend]

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Friends

Member Typedef Documentation

◆ ColumnNames_t

◆ DS_t

◆ HeadNode_t

◆ RFilterBase

◆ RLoopManager

◆ RRangeBase

Constructor & Destructor Documentation

◆ RInterface() [1/4]

◆ RInterface() [2/4]

◆ RInterface() [3/4]

◆ RInterface() [4/4]

Member Function Documentation

◆ AddDefaultColumns()

◆ Aggregate() [1/2]

◆ Aggregate() [2/2]

◆ Alias()

Example usage:

◆ Book()

◆ Cache() [1/4]

◆ Cache() [2/4]

◆ Cache() [3/4]

◆ Cache() [4/4]

◆ CacheImpl()

◆ CheckAndFillDSColumns()

◆ CheckIMTDisabled()

◆ Count()

◆ CreateAction() [1/2]

◆ CreateAction() [2/2]

◆ Define() [1/2]

Example usage:

◆ Define() [2/2]

◆ DefineImpl() [1/2]

◆ DefineImpl() [2/2]

◆ DefineSlot()

◆ DefineSlotEntry()

◆ Display() [1/4]

◆ Display() [2/4]

◆ Display() [3/4]

◆ Display() [4/4]

◆ Fill() [1/2]

◆ Fill() [2/2]

◆ Filter() [1/4]

◆ Filter() [2/4]

◆ Filter() [3/4]

◆ Filter() [4/4]

◆ Foreach()

◆ ForeachSlot()

◆ GetColumnNames()

◆ GetColumnType()

◆ GetColumnTypeNamesList()

◆ GetDefinedColumnNames()

◆ GetFilterNames()

◆ GetLoopManager()

◆ GetProxiedPtr()

◆ GetValidatedColumnNames()

◆ Graph()

◆ Histo1D() [1/5]

◆ Histo1D() [2/5]

◆ Histo1D() [3/5]

◆ Histo1D() [4/5]

◆ Histo1D() [5/5]

◆ Histo2D() [1/3]

◆ Histo2D() [2/3]

◆ Histo2D() [3/3]

◆ Histo3D() [1/3]

◆ Histo3D() [2/3]

◆ Histo3D() [3/3]

◆ Max()

◆ Mean()

◆ Min()

◆ operator RNode()

◆ operator=()

◆ Profile1D() [1/3]