ROOT::RDF Namespace Reference

Namespaces
namespace	Experimental
namespace	Internal

Classes
class	RArrowDS
	RDataFrame data source class to interface with Apache Arrow. More...
class	RCsvDS
	RDataFrame data source class for reading CSV files. More...
class	RCutFlowReport
class	RDataSource
	RDataSource defines an API that RDataFrame can use to read arbitrary data formats. More...
class	RDFDescription
	A DFDescription contains useful information about a given RDataFrame computation graph. More...
class	RDFTypeNameGetter
	Helper to get the contents of a given column. More...
class	RDisplay
	This class is the textual representation of the content of a columnar dataset. More...
class	RInterface
	The public interface to the RDataFrame federation of classes. More...
class	RInterfaceBase
class	RLazyDS
	A RDataSource implementation which is built on top of result proxies. More...
class	RResultHandle
	A type-erased version of RResultPtr and RResultMap. More...
class	RResultPtr
	Smart pointer for the return type of actions. More...
class	RSampleInfo
	This type represents a sample identifier, to be used in conjunction with RDataFrame features such as DefinePerSample() and per-sample callbacks. More...
struct	RSnapshotOptions
	A collection of options to steer the creation of the dataset on file. More...
class	RSqliteDS
	RSqliteDS is an RDF data source implementation for SQL result sets from sqlite3 files. More...
class	RTrivialDS
	A simple data-source implementation, for demo purposes. More...
class	RVariationsDescription
	A descriptor for the systematic variations known to a given RDataFrame node. More...
class	TCutInfo
class	TH1DModel
	A struct which stores the parameters of a TH1D. More...
class	TH2DModel
	A struct which stores the parameters of a TH2D. More...
class	TH3DModel
	A struct which stores the parameters of a TH3D. More...
class	THnDModel
	A struct which stores the parameters of a THnD. More...
class	TProfile1DModel
	A struct which stores the parameters of a TProfile. More...
class	TProfile2DModel
	A struct which stores the parameters of a TProfile2D. More...
class	VerifyValidColumnType
	Helper to determine if a given Column is a supported type. More...

Typedefs
using	ColumnNames_t = std::vector<std::string>
using	RNode = RInterface<::ROOT::Detail::RDF::RNodeBase, void>
using	SampleCallback_t = std::function<void(unsigned int, const ROOT::RDF::RSampleInfo &)>
	The type of a data-block callback, registered with an RDataFrame computation graph via e.g.
template<typename T>
using	TResultProxy = RResultPtr<T>

Functions
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.
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.
RInterface< Proxied, DS_t >	Alias (std::string_view alias, std::string_view columnName)
	Allow to refer to a column with a different name.
template<typename NodeType>
RNode	AsRNode (NodeType node)
	Cast a RDataFrame node to the common type ROOT::RDF::RNode.
template<typename FirstColumn = RDFDetail::RInferredType, typename... OtherColumns, typename Helper>
RResultPtr< typename std::decay_t< Helper >::Result_t >	Book (Helper &&helper, const ColumnNames_t &columns={})
	Book execution of a custom action using a user-defined helper object.
template<typename... ColumnTypes>
RInterface< RLoopManager >	Cache (const ColumnNames_t &columnList)
	Save selected columns in memory.
RInterface< RLoopManager >	Cache (const ColumnNames_t &columnList)
	Save selected columns in memory.
RInterface< RLoopManager >	Cache (std::initializer_list< std::string > columnList)
	Save selected columns in memory.
RInterface< RLoopManager >	Cache (std::string_view columnNameRegexp="")
	Save selected columns in memory.
template<typename... ColTypes, std::size_t... S>
RInterface< RLoopManager >	CacheImpl (const ColumnNames_t &columnList, std::index_sequence< S... >)
	Implementation of cache.
template<typename Helper, typename ActionResultType, typename... Others>
RResultPtr< ActionResultType >	CallCreateActionWithoutColsIfPossible (const std::shared_ptr< ActionResultType > &, const std::shared_ptr< Helper > &, Others...)
template<typename Helper, typename ActionResultType>
auto	CallCreateActionWithoutColsIfPossible (const std::shared_ptr< ActionResultType > &resPtr, const std::shared_ptr< Helper > &hPtr, TTraits::TypeList< RDFDetail::RInferredType >) -> decltype(hPtr->Exec(0u), RResultPtr< ActionResultType >{})
RResultPtr< ULong64_t >	Count ()
	Return the number of entries processed (lazy action).
template<typename F, typename DefineType, typename RetType = typename TTraits::CallableTraits<F>::ret_type>
std::enable_if_t< std::is_default_constructible< RetType >::value, RInterface< Proxied, DS_t > >	DefineImpl (std::string_view name, F &&expression, const ColumnNames_t &columns, const std::string &where)
template<typename F, typename DefineType, 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_t<!IsFStringConv &&!IsRetTypeDefConstr, RInterface< Proxied, DS_t > >	DefineImpl (std::string_view, F, const ColumnNames_t &, const std::string &)
template<typename... ColumnTypes>
RResultPtr< RDisplay >	Display (const ColumnNames_t &columnList, size_t nRows=5, size_t nMaxCollectionElements=10)
	Provides a representation of the columns in the dataset.
RResultPtr< RDisplay >	Display (const ColumnNames_t &columnList, size_t nRows=5, size_t nMaxCollectionElements=10)
	Provides a representation of the columns in the dataset.
RResultPtr< RDisplay >	Display (std::initializer_list< std::string > columnList, size_t nRows=5, size_t nMaxCollectionElements=10)
	Provides a representation of the columns in the dataset.
RResultPtr< RDisplay >	Display (std::string_view columnNameRegexp="", size_t nRows=5, size_t nMaxCollectionElements=10)
	Provides a representation of the columns in the dataset.
template<typename FirstColumn = RDFDetail::RInferredType, typename... OtherColumns, typename T>
RResultPtr< std::decay_t< 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).
template<typename F>
void	Foreach (F f, const ColumnNames_t &columns={})
	Execute a user-defined function on each entry (instant action).
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).
RDataFrame	FromArrow (std::shared_ptr< arrow::Table > table, std::vector< std::string > const &columnNames)
	Factory method to create a Apache Arrow RDataFrame.
RDataFrame	FromCSV (std::string_view fileName, bool readHeaders=true, char delimiter=',', Long64_t linesChunkSize=-1LL, std::unordered_map< std::string, char > &&colTypes={})
	Factory method to create a CSV RDataFrame.
RDataFrame	FromSqlite (std::string_view fileName, std::string_view query)
	Factory method to create a SQlite RDataFrame.
template<typename T>
std::shared_ptr< arrow::ChunkedArray >	getData (T p)
std::vector< std::string >	GetFilterNames ()
	Returns the names of the filters created.
int	getNRecords (std::shared_ptr< arrow::Table > &table, std::vector< std::string > &columnNames)
const std::shared_ptr< Proxied > &	GetProxiedPtr () const
template<typename X = RDFDetail::RInferredType, typename Y = RDFDetail::RInferredType>
RResultPtr<::TGraph >	Graph (std::string_view x="", std::string_view y="")
	Fill and return a TGraph object (lazy action).
template<typename X = RDFDetail::RInferredType, typename Y = RDFDetail::RInferredType, typename EXL = RDFDetail::RInferredType, typename EXH = RDFDetail::RInferredType, typename EYL = RDFDetail::RInferredType, typename EYH = RDFDetail::RInferredType>
RResultPtr<::TGraphAsymmErrors >	GraphAsymmErrors (std::string_view x="", std::string_view y="", std::string_view exl="", std::string_view exh="", std::string_view eyl="", std::string_view eyh="")
	Fill and return a TGraphAsymmErrors object (lazy action).
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).
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).
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).
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).
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).
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).
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).
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).
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).
template<typename FirstColumn, typename... OtherColumns>
RResultPtr<::THnD >	HistoND (const THnDModel &model, const ColumnNames_t &columnList)
	Fill and return an N-dimensional histogram (lazy action).
RResultPtr<::THnD >	HistoND (const THnDModel &model, const ColumnNames_t &columnList)
	Fill and return an N-dimensional histogram (lazy action).
RInterface< Proxied, DS_t >	JittedVaryImpl (const std::vector< std::string > &colNames, std::string_view expression, const std::vector< std::string > &variationTags, std::string_view variationName, bool isSingleColumn)
template<typename... ColumnTypes>
RDataFrame	MakeLazyDataFrame (std::pair< std::string, RResultPtr< std::vector< ColumnTypes > > > &&... colNameProxyPairs)
	Factory method to create a Lazy RDataFrame.
RInterface< RDFDetail::RLoopManager >	MakeTrivialDataFrame ()
	Make a RDF wrapping a RTrivialDS with infinite entries, for demo purposes.
RInterface< RDFDetail::RLoopManager >	MakeTrivialDataFrame (ULong64_t size, bool skipEvenEntries=false)
	Make a RDF wrapping a RTrivialDS with the specified amount of entries.
template<typename T = RDFDetail::RInferredType>
RResultPtr< RDFDetail::MaxReturnType_t< T > >	Max (std::string_view columnName="")
	Return the maximum of processed column values (lazy action).
template<typename T = RDFDetail::RInferredType>
RResultPtr< double >	Mean (std::string_view columnName="")
	Return the mean of processed column values (lazy action).
template<typename T = RDFDetail::RInferredType>
RResultPtr< RDFDetail::MinReturnType_t< T > >	Min (std::string_view columnName="")
	Return the minimum of processed column values (lazy action).
template<typename F, typename Args = typename ROOT::TypeTraits::CallableTraits<std::decay_t<F>>::arg_types_nodecay, typename Ret = typename ROOT::TypeTraits::CallableTraits<std::decay_t<F>>::ret_type>
auto	Not (F &&f) -> decltype(RDFInternal::NotHelper(Args(), std::forward< F >(f)))
	Given a callable with signature bool(T1, T2, ...) return a callable with same signature that returns the negated result.
template<class T1, class T2>
bool	operator!= (const RResultPtr< T1 > &lhs, const RResultPtr< T2 > &rhs)
template<class T1>
bool	operator!= (const RResultPtr< T1 > &lhs, std::nullptr_t rhs)
template<class T1>
bool	operator!= (std::nullptr_t lhs, const RResultPtr< T1 > &rhs)
std::ostream &	operator<< (std::ostream &os, const RDFDescription &description)
template<class T1, class T2>
bool	operator== (const RResultPtr< T1 > &lhs, const RResultPtr< T2 > &rhs)
template<class T1>
bool	operator== (const RResultPtr< T1 > &lhs, std::nullptr_t rhs)
template<class T1>
bool	operator== (std::nullptr_t lhs, const RResultPtr< T1 > &rhs)
template<std::size_t N, typename T, typename F>
auto	PassAsVec (F &&f) -> RDFInternal::PassAsVecHelper< std::make_index_sequence< N >, T, F >
	PassAsVec is a callable generator that allows passing N variables of type T to a function as a single collection.
template<typename V1, typename V2, typename W>
RResultPtr<::TProfile >	Profile1D (const TProfile1DModel &model)
	Fill and return a one-dimensional profile (lazy action). See the first Profile1D() overload for more details.
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).
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).
template<typename V1, typename V2, typename V3, typename W>
RResultPtr<::TProfile2D >	Profile2D (const TProfile2DModel &model)
	Fill and return a two-dimensional profile (lazy action). See the first Profile2D() overload for more details.
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).
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).
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).
RInterface< RDFDetail::RRange< Proxied >, DS_t >	Range (unsigned int end)
	Creates a node that filters entries based on range.
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.
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.
RResultPtr< RCutFlowReport >	Report ()
	Gather filtering statistics.
	RInterface (const std::shared_ptr< Proxied > &proxied, RLoopManager &lm, const RDFInternal::RColumnRegister &colRegister)
unsigned int	RunGraphs (std::vector< RResultHandle > handles)
	Trigger the event loop of multiple RDataFrames concurrently.
template<typename NodeType>
std::string	SaveGraph (NodeType node)
	Create a graphviz representation of the dataframe computation graph, return it as a string.
template<typename NodeType>
void	SaveGraph (NodeType node, const std::string &outputFile)
	Create a graphviz representation of the dataframe computation graph, write it to the specified file.
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.
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.
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.
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.
template<typename... ColumnTypes>
RResultPtr< RInterface< RLoopManager > >	SnapshotImpl (std::string_view fullTreeName, std::string_view filename, const ColumnNames_t &columnList, const RSnapshotOptions &options)
void	splitInEqualRanges (std::vector< std::pair< ULong64_t, ULong64_t > > &ranges, int nRecords, unsigned int nSlots)
template<typename V = RDFDetail::RInferredType, typename W = RDFDetail::RInferredType>
RResultPtr< TStatistic >	Stats (std::string_view value, std::string_view weight)
	Return a TStatistic object, filled once per event (lazy action).
template<typename V = RDFDetail::RInferredType>
RResultPtr< TStatistic >	Stats (std::string_view value="")
	Return a TStatistic object, filled once per event (lazy action).
template<typename T = RDFDetail::RInferredType>
RResultPtr< double >	StdDev (std::string_view columnName="")
	Return the unbiased standard deviation of processed column values (lazy action).
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).
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).
RInterface< Proxied, DS_t >	Vary (const std::vector< std::string > &colNames, std::string_view expression, const std::vector< std::string > &variationTags, std::string_view variationName)
	Register systematic variations for multiple existing columns using custom variation tags.
RInterface< Proxied, DS_t >	Vary (const std::vector< std::string > &colNames, std::string_view expression, std::size_t nVariations, std::string_view variationName)
	Register systematic variations for multiple existing columns using auto-generated variation tags.
RInterface< Proxied, DS_t >	Vary (std::initializer_list< std::string > colNames, std::string_view expression, std::size_t nVariations, std::string_view variationName)
	Register systematic variations for multiple existing columns using auto-generated variation tags.
template<typename Proxied, typename DataSource = void>
ROOT::RDF::RInterface RInterfaceBase	Vary (std::string_view colName, std::string_view expression, std::size_t nVariations, std::string_view variationName="")
template<bool IsSingleColumn, typename F>
RInterface< Proxied, DS_t >	VaryImpl (const std::vector< std::string > &colNames, F &&expression, const ColumnNames_t &inputColumns, const std::vector< std::string > &variationTags, std::string_view variationName)

Variables
ROOT::RDF::RInterface	Proxied
	Register systematic variations for a single existing column using auto-generated variation tags.

Typedef Documentation

ColumnNames_t

typedef std::vector< std::string > ROOT::RDF::ColumnNames_t = std::vector<std::string>

Definition at line 35 of file RInterfaceBase.hxx.

RNode

typedef RInterface<::ROOT::Detail::RDF::RNodeBase, void > ROOT::RDF::RNode = RInterface<::ROOT::Detail::RDF::RNodeBase, void>

Definition at line 57 of file InterfaceUtils.hxx.

SampleCallback_t

using ROOT::RDF::SampleCallback_t = std::function<void(unsigned int, const ROOT::RDF::RSampleInfo &)>

The type of a data-block callback, registered with an RDataFrame computation graph via e.g.

DefinePerSample() or by certain actions (e.g. Snapshot()).

Definition at line 134 of file RSampleInfo.hxx.

TResultProxy

template<typename T>

using ROOT::RDF::TResultProxy = RResultPtr<T>

Definition at line 18 of file TResultProxy.hxx.

Function Documentation

Aggregate() [1/2]

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::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.

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 initialized 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. Also see RResultPtr.

Example usage:

auto aggregator = [](double acc, double x) { return acc * x; };
ROOT::EnableImplicitMT();
// If multithread is enabled, the aggregator function will be called by more threads
// and will produce a vector of partial accumulators.
// The merger function performs the final aggregation of these partial results.
auto merger = [](std::vector<double> &accumulators) {
   for (auto i : ROOT::TSeqU(1u, accumulators.size())) {
      accumulators[0] *= accumulators[i];
   }
};
 
// The accumulator is initialized at this value by every thread.
double initValue = 1.;
 
// Multiplies all elements of the column "x"
auto result = d.Aggregate(aggregator, merger, "x", initValue);

Definition at line 2710 of file RInterface.hxx.

Aggregate() [2/2]

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::Aggregate	(	AccFun	aggregator,
		MergeFun	merger,
		std::string_view	columnName = "" )

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 2744 of file RInterface.hxx.

Alias()

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

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 1045 of file RInterface.hxx.

AsRNode()

template<typename NodeType>

RNode ROOT::RDF::AsRNode

(

NodeType

node

)

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

Parameters

[in]

node

Any node of a RDataFrame graph

Definition at line 158 of file RDFHelpers.hxx.

Book()

template<typename FirstColumn = RDFDetail::RInferredType, typename... OtherColumns, typename Helper>

RResultPtr< typename std::decay_t< Helper >::Result_t > ROOT::RDF::Book	(	Helper &&	helper,
		const ColumnNames_t &	columns = {} )

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

Template Parameters

FirstColumn	The type of the first column used by this action. Inferred together with OtherColumns if not present.
OtherColumns	A list of the types of the other 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 required interface for the helper is described below (more methods that the ones required can be present, e.g. a constructor that takes the number of worker threads is usually useful):

Mandatory interface

• Helper must publicly inherit from ROOT::Detail::RDF::RActionImpl<Helper>
• Helper::Result_t: public alias for the type of the result of this action helper. Result_t must be default-constructible.
• Helper(Helper &&): a move-constructor is required. Copy-constructors are discouraged.
• 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. Note that this method can be called before Initialize(), because the RResultPtr is constructed before the event loop is started.
• void Initialize(): this method is called once before starting the event-loop. Useful for setup operations. It must reset the state of the helper to the expected state at the beginning of the event loop: the same helper, or copies of it, might be used for multiple event loops (e.g. in the presence of systematic variations).
• void InitTask(TTreeReader *, unsigned int slot): each working thread shall call this method during the event loop, before processing a batch of entries. The pointer passed as argument, if not null, will point to the TTreeReader that RDataFrame has set up to read the task's batch of entries. It is passed to the helper to allow certain advanced optimizations it should not usually serve any purpose for the Helper. This method is often no-op for simple helpers.
• 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 Finalize(): this method is called at the end of the event loop. Commonly used to finalize the contents of the result.
• std::string GetActionName(): it returns a string identifier for this type of action that RDataFrame will use in diagnostics, SaveGraph(), etc.

Optional methods

If these methods are implemented they enable extra functionality as per the description below.

• Result_t &PartialUpdate(unsigned int slot): if present, it must return the value of the partial result of this action for the given 'slot'. Different threads might call this method concurrently, but will do so with different 'slot' numbers. RDataFrame leverages this method to implement RResultPtr::OnPartialResult().
• ROOT::RDF::SampleCallback_t GetSampleCallback(): if present, it must return a callable with the appropriate signature (see ROOT::RDF::SampleCallback_t) that will be invoked at the beginning of the processing of every sample, as in DefinePerSample().
• Helper MakeNew(void *newResult): if implemented, it enables varying the action's result with VariationsFor(). It takes a type-erased new result that can be safely cast to a std::shared_ptr<Result_t> * (a pointer to shared pointer) and should be used as the action's output result.

In case Book is called without specifying column types as template arguments, corresponding typed code will be just-in-time compiled by RDataFrame. In that case the Helper class needs to be known to the ROOT interpreter.

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

Examples

See this tutorial for an example implementation of an action helper.

It is also possible to inspect the code used by built-in RDataFrame actions at ActionHelpers.hxx.

Definition at line 2815 of file RInterface.hxx.

Cache() [1/4]

template<typename... ColumnTypes>

RInterface< RLoopManager > ROOT::RDF::Cache

(

const ColumnNames_t &

columnList

)

Save selected columns in memory.

Template Parameters

ColumnTypes

variadic list of branch/column types.

Parameters

[in]

columnList

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.

Note

Cache will refuse to process columns with names of the form #columnname. These are special columns made available by some data sources (e.g. RNTupleDS) that represent the size of column columnname, and are not meant to be written out with that name (which is not a valid C++ variable name). Instead, go through an Alias(): df.Alias("nbar", "#bar").Cache<std::size_t>(..., {"nbar"}).

Example usage:

Types and columns specified:

auto cache_some_cols_df = df.Cache<double, MyClass, int>({"col0", "col1", "col2"});

Types inferred and columns specified (this invocation relies on jitting):

auto cache_some_cols_df = df.Cache({"col0", "col1", "col2"});

Types inferred and columns selected with a regexp (this invocation relies on jitting):

auto cache_all_cols_df = df.Cache(myRegexp);

Definition at line 1290 of file RInterface.hxx.

Cache() [2/4]

RInterface< RLoopManager > ROOT::RDF::Cache

(

const ColumnNames_t &

columnList

)

Save selected columns in memory.

Parameters

[in]

columnList

columns to be cached in memory

Returns

a RDataFrame that wraps the cached dataset.

See the previous overloads for more information.

Definition at line 1302 of file RInterface.hxx.

Cache() [3/4]

RInterface< RLoopManager > ROOT::RDF::Cache

(

std::initializer_list< std::string >

columnList

)

Save selected columns in memory.

Parameters

[in]

columnList

columns to be cached in memory.

Returns

a RDataFrame that wraps the cached dataset.

See the previous overloads for more information.

Definition at line 1377 of file RInterface.hxx.

Cache() [4/4]

RInterface< RLoopManager > ROOT::RDF::Cache

(

std::string_view

columnNameRegexp = ""

)

Save selected columns in memory.

Parameters

[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. The dialect supported is PCRE via the TPRegexp class. An empty string signals the selection of all columns.

Returns

a RDataFrame that wraps the cached dataset.

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

Definition at line 1351 of file RInterface.hxx.

CacheImpl()

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

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

private

Implementation of cache.

Definition at line 3031 of file RInterface.hxx.

CallCreateActionWithoutColsIfPossible() [1/2]

template<typename Helper, typename ActionResultType, typename... Others>

RResultPtr< ActionResultType > ROOT::RDF::CallCreateActionWithoutColsIfPossible ( const std::shared_ptr< ActionResultType > & , const std::shared_ptr< Helper > & , Others...  )

private

Definition at line 3132 of file RInterface.hxx.

CallCreateActionWithoutColsIfPossible() [2/2]

template<typename Helper, typename ActionResultType>

auto ROOT::RDF::CallCreateActionWithoutColsIfPossible ( const std::shared_ptr< ActionResultType > & resPtr, const std::shared_ptr< Helper > & hPtr, TTraits::TypeList< RDFDetail::RInferredType >  ) -> decltype(hPtr->Exec(0u), RResultPtr<ActionResultType>{})

private

Definition at line 3122 of file RInterface.hxx.

Count()

RResultPtr< ULong64_t > ROOT::RDF::Count

(

)

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. Also see RResultPtr.

Example usage:

auto nEntriesAfterCuts = myFilteredDf.Count();

Definition at line 1560 of file RInterface.hxx.

DefineImpl() [1/2]

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

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

private

Definition at line 2931 of file RInterface.hxx.

DefineImpl() [2/2]

template<typename F, typename DefineType, 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_t<!IsFStringConv &&!IsRetTypeDefConstr, RInterface< Proxied, DS_t > > ROOT::RDF::DefineImpl ( std::string_view , F , const ColumnNames_t & , const std::string &  )

private

Definition at line 2982 of file RInterface.hxx.

Display() [1/4]

template<typename... ColumnTypes>

RResultPtr< RDisplay > ROOT::RDF::Display	(	const ColumnNames_t &	columnList,
		size_t	nRows = 5,
		size_t	nMaxCollectionElements = 10 )

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]	nRows	Number of events for each column to be displayed.
[in]	nMaxCollectionElements	Maximum number of collection elements to display per row.

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 RDisplay::Print() or will return a complete version through RDisplay::AsString().

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

Example usage:

// Preparing the RResultPtr<RDisplay> object with all columns and default number of entries
auto d1 = rdf.Display("");
// Preparing the RResultPtr<RDisplay> object with two columns and 128 entries
auto d2 = d.Display({"x", "y"}, 128);
// Printing the short representations, the event loop will run
d1->Print();
d2->Print();

Definition at line 2860 of file RInterface.hxx.

Display() [2/4]

RResultPtr< RDisplay > ROOT::RDF::Display	(	const ColumnNames_t &	columnList,
		size_t	nRows = 5,
		size_t	nMaxCollectionElements = 10 )

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.
[in]	nMaxCollectionElements	Maximum number of collection elements to display per row.

Returns

the RDisplay instance wrapped in a RResultPtr.

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

Invoked when no types are specified to Display

Definition at line 2883 of file RInterface.hxx.

Display() [3/4]

RResultPtr< RDisplay > ROOT::RDF::Display	(	std::initializer_list< std::string >	columnList,
		size_t	nRows = 5,
		size_t	nMaxCollectionElements = 10 )

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.
[in]	nMaxCollectionElements	Number of maximum elements in collection.

Returns

the RDisplay instance wrapped in a RResultPtr.

See the previous overloads for further details.

Definition at line 2922 of file RInterface.hxx.

Display() [4/4]

RResultPtr< RDisplay > ROOT::RDF::Display	(	std::string_view	columnNameRegexp = "",
		size_t	nRows = 5,
		size_t	nMaxCollectionElements = 10 )

Provides a representation of the columns in the dataset.

Parameters

[in]	columnNameRegexp	A regular expression to select the columns.
[in]	nRows	Number of events for each column to be displayed.
[in]	nMaxCollectionElements	Maximum number of collection elements to display per row.

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 2906 of file RInterface.hxx.

Fill()

template<typename FirstColumn = RDFDetail::RInferredType, typename... OtherColumns, typename T>

RResultPtr< std::decay_t< T > > ROOT::RDF::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).

Type T must provide at least:

• a copy-constructor
• a Fill method that accepts as many arguments and with same types as the column names passed as columnList (these types can also be passed as template parameters to this method)
• a Merge method with signature Merge(TCollection *) or Merge(const std::vector<T *>&) that merges the objects passed as argument into the object on which Merge was called (an analogous of TH1::Merge). Note that if the signature that takes a TCollection* is used, then T must inherit from TObject (to allow insertion in the TCollection*).

Template Parameters

FirstColumn	The first type of the column the values of which are used to fill the object. Inferred together with OtherColumns if not present.
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. Also see RResultPtr.

Example usage:

MyClass obj;
// Deduce column types (this invocation needs jitting internally, and in this case
// MyClass needs to be known to the interpreter)
auto myFilledObj = myDf.Fill(obj, {"col0", "col1"});
// explicit column types
auto myFilledObj = myDf.Fill<float, float>(obj, {"col0", "col1"});

Definition at line 2367 of file RInterface.hxx.

Foreach()

template<typename F>

void ROOT::RDF::Foreach	(	F	f,
		const ColumnNames_t &	columns = {} )

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).

Example usage:

myDf.Foreach([](int i){ std::cout << i << std::endl;}, {"myIntColumn"});

Definition at line 1442 of file RInterface.hxx.

ForeachSlot()

template<typename F>

void ROOT::RDF::ForeachSlot	(	F	f,
		const ColumnNames_t &	columns = {} )

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.

Example usage:

myDf.ForeachSlot([](unsigned int s, int i){ std::cout << "Slot " << s << ": "<< i << std::endl;}, {"myIntColumn"});

Definition at line 1472 of file RInterface.hxx.

FromArrow()

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

Factory method to create a Apache Arrow RDataFrame.

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

Parameters

[in]	table	an apache::arrow table to use as a source / to observe.
[in]	columnNames	the name of the columns to use In case columnNames is empty, we use all the columns found in the table

Definition at line 606 of file RArrowDS.cxx.

FromCSV()

RDataFrame ROOT::RDF::FromCSV	(	std::string_view	fileName,
		bool	readHeaders = true,
		char	delimiter = ',',
		Long64_t	linesChunkSize = -1LL,
		std::unordered_map< std::string, char > &&	colTypes = {} )

Factory method to create a CSV RDataFrame.

Parameters

[in]	fileName	Path of the CSV file.
[in]	readHeaders	true if the CSV file contains headers as first row, false otherwise (default true).
[in]	delimiter	Delimiter character (default ',').
[in]	linesChunkSize	bunch of lines to read, use -1 to read all
[in]	colTypes	Allow user to specify custom column types, accepts an unordered map with keys being column type, values being type alias ('O' for boolean, 'D' for double, 'L' for Long64_t, 'T' for std::string)

Definition at line 558 of file RCsvDS.cxx.

FromSqlite()

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

Factory method to create a SQlite RDataFrame.

Parameters

[in]	fileName	Path of the sqlite file.
[in]	query	SQL query that defines the data set.

Definition at line 543 of file RSqliteDS.cxx.

getData()

template<typename T>

std::shared_ptr< arrow::ChunkedArray > ROOT::RDF::getData

(

T

p

)

Definition at line 542 of file RArrowDS.cxx.

GetFilterNames()

std::vector< std::string > ROOT::RDF::GetFilterNames

(

)

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.

Example usage:

auto filtNames = d.GetFilterNames();
for (auto &&filtName : filtNames) std::cout << filtName << std::endl;

Definition at line 2658 of file RInterface.hxx.

getNRecords()

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

Definition at line 535 of file RArrowDS.cxx.

GetProxiedPtr()

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

protected

Definition at line 3149 of file RInterface.hxx.

Graph()

template<typename X = RDFDetail::RInferredType, typename Y = RDFDetail::RInferredType>

RResultPtr<::TGraph > ROOT::RDF::Graph	(	std::string_view	x = "",
		std::string_view	y = "" )

Fill and return a TGraph object (lazy action).

Template Parameters

X	The type of the column used to fill the x axis.
Y	The type of the column used to fill the y axis.

Parameters

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

Returns

the TGraph wrapped in a RResultPtr.

Columns can be of a container type (e.g. std::vector<double>), in which case the TGraph 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 TGraph is given based on the input column names.

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

Example usage:

// Deduce column types (this invocation needs jitting internally)
auto myGraph1 = myDf.Graph("xValues", "yValues");
// Explicit column types
auto myGraph2 = myDf.Graph<int, float>("xValues", "yValues");

Note

Differently from other ROOT interfaces, the returned TGraph is not associated to gDirectory and the caller is responsible for its lifetime (in particular, a typical source of confusion is that if result histograms go out of scope before the end of the program, ROOT might display a blank canvas).

Definition at line 2056 of file RInterface.hxx.

GraphAsymmErrors()

template<typename X = RDFDetail::RInferredType, typename Y = RDFDetail::RInferredType, typename EXL = RDFDetail::RInferredType, typename EXH = RDFDetail::RInferredType, typename EYL = RDFDetail::RInferredType, typename EYH = RDFDetail::RInferredType>

RResultPtr<::TGraphAsymmErrors > ROOT::RDF::GraphAsymmErrors	(	std::string_view	x = "",
		std::string_view	y = "",
		std::string_view	exl = "",
		std::string_view	exh = "",
		std::string_view	eyl = "",
		std::string_view	eyh = "" )

Fill and return a TGraphAsymmErrors object (lazy action).

Parameters

[in]	x	The name of the column that will fill the x axis.
[in]	y	The name of the column that will fill the y axis.
[in]	exl	The name of the column of X low errors
[in]	exh	The name of the column of X high errors
[in]	eyl	The name of the column of Y low errors
[in]	eyh	The name of the column of Y high errors

Returns

the TGraphAsymmErrors 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.

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

Example usage:

// Deduce column types (this invocation needs jitting internally)
auto myGAE1 = myDf.GraphAsymmErrors("xValues", "yValues", "exl", "exh", "eyl", "eyh");
// Explicit column types
using f = float
auto myGAE2 = myDf.GraphAsymmErrors<f, f, f, f, f, f>("xValues", "yValues", "exl", "exh", "eyl", "eyh");

Note

Differently from other ROOT interfaces, the returned TGraphAsymmErrors is not associated to gDirectory and the caller is responsible for its lifetime (in particular, a typical source of confusion is that if result histograms go out of scope before the end of the program, ROOT might display a blank canvas).

Definition at line 2109 of file RInterface.hxx.

Histo1D() [1/5]

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

RResultPtr<::TH1D > ROOT::RDF::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).

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.

Example usage:

// Deduce column type (this invocation needs jitting internally)
auto myHist1 = myDf.Histo1D({"histName", "histTitle", 64u, 0., 128.}, "myValue", "myweight");
// Explicit column type
auto myHist2 = myDf.Histo1D<float, int>({"histName", "histTitle", 64u, 0., 128.}, "myValue", "myweight");

Definition at line 1697 of file RInterface.hxx.

Histo1D() [2/5]

template<typename V, typename W>

RResultPtr<::TH1D > ROOT::RDF::Histo1D

(

const TH1DModel &

model = {"", "", 128u, 0., 0.}

)

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 1751 of file RInterface.hxx.

Histo1D() [3/5]

template<typename V = RDFDetail::RInferredType>

RResultPtr<::TH1D > ROOT::RDF::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).

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. Also see RResultPtr.

Example usage:

// Deduce column type (this invocation needs jitting internally)
auto myHist1 = myDf.Histo1D({"histName", "histTitle", 64u, 0., 128.}, "myColumn");
// Explicit column type
auto myHist2 = myDf.Histo1D<float>({"histName", "histTitle", 64u, 0., 128.}, "myColumn");

Note

Differently from other ROOT interfaces, the returned histogram is not associated to gDirectory and the caller is responsible for its lifetime (in particular, a typical source of confusion is that if result histograms go out of scope before the end of the program, ROOT might display a blank canvas).

Definition at line 1635 of file RInterface.hxx.

Histo1D() [4/5]

template<typename V = RDFDetail::RInferredType>

RResultPtr<::TH1D > ROOT::RDF::Histo1D

(

std::string_view

vName

)

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.

Example usage:

// Deduce column type (this invocation needs jitting internally)
auto myHist1 = myDf.Histo1D("myColumn");
// Explicit column type
auto myHist2 = myDf.Histo1D<float>("myColumn");

Definition at line 1671 of file RInterface.hxx.

Histo1D() [5/5]

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

RResultPtr<::TH1D > ROOT::RDF::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).

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.

Example usage:

// Deduce column types (this invocation needs jitting internally)
auto myHist1 = myDf.Histo1D("myValue", "myweight");
// Explicit column types
auto myHist2 = myDf.Histo1D<float, int>("myValue", "myweight");

Definition at line 1731 of file RInterface.hxx.

Histo2D() [1/3]

template<typename V1, typename V2, typename W>

RResultPtr<::TH2D > ROOT::RDF::Histo2D

(

const TH2DModel &

model

)

Definition at line 1846 of file RInterface.hxx.

Histo2D() [2/3]

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

RResultPtr<::TH2D > ROOT::RDF::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).

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. Also see RResultPtr.

Example usage:

// Deduce column types (this invocation needs jitting internally)
auto myHist1 = myDf.Histo2D({"histName", "histTitle", 64u, 0., 128., 32u, -4., 4.}, "myValueX", "myValueY", "myWeight");
// Explicit column types
auto myHist2 = myDf.Histo2D<float, float, double>({"histName", "histTitle", 64u, 0., 128., 32u, -4., 4.}, "myValueX", "myValueY", "myWeight");

See the documentation of the first Histo2D() overload for more details.

Definition at line 1828 of file RInterface.hxx.

Histo2D() [3/3]

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

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

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. Also see RResultPtr.

Example usage:

// Deduce column types (this invocation needs jitting internally)
auto myHist1 = myDf.Histo2D({"histName", "histTitle", 64u, 0., 128., 32u, -4., 4.}, "myValueX", "myValueY");
// Explicit column types
auto myHist2 = myDf.Histo2D<float, float>({"histName", "histTitle", 64u, 0., 128., 32u, -4., 4.}, "myValueX", "myValueY");

Note

Differently from other ROOT interfaces, the returned histogram is not associated to gDirectory and the caller is responsible for its lifetime (in particular, a typical source of confusion is that if result histograms go out of scope before the end of the program, ROOT might display a blank canvas).

Definition at line 1785 of file RInterface.hxx.

Histo3D() [1/3]

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

RResultPtr<::TH3D > ROOT::RDF::Histo3D

(

const TH3DModel &

model

)

Definition at line 1948 of file RInterface.hxx.

Histo3D() [2/3]

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

RResultPtr<::TH3D > ROOT::RDF::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).

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. Also see RResultPtr.

Example usage:

// Deduce column types (this invocation needs jitting internally)
auto myHist1 = myDf.Histo3D({"name", "title", 64u, 0., 128., 32u, -4., 4., 8u, -2., 2.},
                            "myValueX", "myValueY", "myValueZ", "myWeight");
// Explicit column types
using d_t = double;
auto myHist2 = myDf.Histo3D<d_t, d_t, float, d_t>({"name", "title", 64u, 0., 128., 32u, -4., 4., 8u, -2., 2.},
                                                   "myValueX", "myValueY", "myValueZ", "myWeight");

See the documentation of the first Histo2D() overload for more details.

Definition at line 1929 of file RInterface.hxx.

Histo3D() [3/3]

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

RResultPtr<::TH3D > ROOT::RDF::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).

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. Also see RResultPtr.

Example usage:

// Deduce column types (this invocation needs jitting internally)
auto myHist1 = myDf.Histo3D({"name", "title", 64u, 0., 128., 32u, -4., 4., 8u, -2., 2.},
                            "myValueX", "myValueY", "myValueZ");
// Explicit column types
auto myHist2 = myDf.Histo3D<double, double, float>({"name", "title", 64u, 0., 128., 32u, -4., 4., 8u, -2., 2.},
                                                   "myValueX", "myValueY", "myValueZ");

Note

Differently from other ROOT interfaces, the returned histogram is not associated to gDirectory and the caller is responsible for its lifetime (in particular, a typical source of confusion is that if result histograms go out of scope before the end of the program, ROOT might display a blank canvas).

Definition at line 1880 of file RInterface.hxx.

HistoND() [1/2]

template<typename FirstColumn, typename... OtherColumns>

RResultPtr<::THnD > ROOT::RDF::HistoND	(	const THnDModel &	model,
		const ColumnNames_t &	columnList )

Fill and return an N-dimensional histogram (lazy action).

Template Parameters

FirstColumn	The first type of the column the values of which are used to fill the object. Inferred if not present.
OtherColumns	A list of the other types of the columns the values of which are used to fill the object.

Parameters

[in]	model	The returned histogram will be constructed using this as a model.
[in]	columnList	A list containing the names of the columns that will be passed when calling Fill. (N columns for unweighted filling, or N+1 columns for weighted filling)

Returns

the N-dimensional histogram wrapped in a RResultPtr.

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

Example usage:

auto myFilledObj = myDf.HistoND<float, float, float, float>({"name","title", 4,
                                               {40,40,40,40}, {20.,20.,20.,20.}, {60.,60.,60.,60.}},
                                              {"col0", "col1", "col2", "col3"});

Definition at line 1976 of file RInterface.hxx.

HistoND() [2/2]

RResultPtr<::THnD > ROOT::RDF::HistoND	(	const THnDModel &	model,
		const ColumnNames_t &	columnList )

Fill and return an N-dimensional histogram (lazy action).

Parameters

[in]	model	The returned histogram will be constructed using this as a model.
[in]	columnList	A list containing the names of the columns that will be passed when calling Fill (N columns for unweighted filling, or N+1 columns for weighted filling)

Returns

the N-dimensional histogram wrapped in a RResultPtr.

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

Example usage:

auto myFilledObj = myDf.HistoND({"name","title", 4,
                                               {40,40,40,40}, {20.,20.,20.,20.}, {60.,60.,60.,60.}},
                                              {"col0", "col1", "col2", "col3"});

Definition at line 2010 of file RInterface.hxx.

JittedVaryImpl()

RInterface< Proxied, DS_t > ROOT::RDF::JittedVaryImpl ( const std::vector< std::string > & colNames, std::string_view expression, const std::vector< std::string > & variationTags, std::string_view variationName, bool isSingleColumn )

private

Definition at line 3086 of file RInterface.hxx.

MakeLazyDataFrame()

template<typename... ColumnTypes>

RDataFrame ROOT::RDF::MakeLazyDataFrame

(

std::pair< std::string, RResultPtr< std::vector< ColumnTypes > > > &&...

colNameProxyPairs

)

Factory method to create a Lazy RDataFrame.

Parameters

[in]

colNameProxyPairs

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

Definition at line 29 of file RLazyDS.hxx.

MakeTrivialDataFrame() [1/2]

RInterface< RDFDetail::RLoopManager > ROOT::RDF::MakeTrivialDataFrame

(

)

Make a RDF wrapping a RTrivialDS with infinite entries, for demo purposes.

Definition at line 130 of file RTrivialDS.cxx.

MakeTrivialDataFrame() [2/2]

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

Make a RDF wrapping a RTrivialDS with the specified amount of entries.

Constructing an RDataFrame as RDataFrame(nEntries) is a superior alternative. If size is std::numeric_limits<ULong64_t>::max(), this acts as an infinite data-source: it returns entries from GetEntryRanges forever or until a Range stops the event loop (for test purposes).

Definition at line 123 of file RTrivialDS.cxx.

Max()

template<typename T = RDFDetail::RInferredType>

RResultPtr< RDFDetail::MaxReturnType_t< T > > ROOT::RDF::Max

(

std::string_view

columnName = ""

)

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. Also see RResultPtr.

Example usage:

// Deduce column type (this invocation needs jitting internally)
auto maxVal0 = myDf.Max("values");
// Explicit column type
auto maxVal1 = myDf.Max<double>("values");

Definition at line 2501 of file RInterface.hxx.

Mean()

template<typename T = RDFDetail::RInferredType>

RResultPtr< double > ROOT::RDF::Mean

(

std::string_view

columnName = ""

)

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. Also see RResultPtr.

Example usage:

// Deduce column type (this invocation needs jitting internally)
auto meanVal0 = myDf.Mean("values");
// Explicit column type
auto meanVal1 = myDf.Mean<double>("values");

Definition at line 2530 of file RInterface.hxx.

Min()

template<typename T = RDFDetail::RInferredType>

RResultPtr< RDFDetail::MinReturnType_t< T > > ROOT::RDF::Min

(

std::string_view

columnName = ""

)

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. Also see RResultPtr.

Example usage:

// Deduce column type (this invocation needs jitting internally)
auto minVal0 = myDf.Min("values");
// Explicit column type
auto minVal1 = myDf.Min<double>("values");

Definition at line 2471 of file RInterface.hxx.

Not()

template<typename F, typename Args = typename ROOT::TypeTraits::CallableTraits<std::decay_t<F>>::arg_types_nodecay, typename Ret = typename ROOT::TypeTraits::CallableTraits<std::decay_t<F>>::ret_type>

auto ROOT::RDF::Not

(

F &&

f

)

-> decltype(RDFInternal::NotHelper(Args(), std::forward<F>(f)))

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

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

Definition at line 83 of file RDFHelpers.hxx.

operator!=() [1/3]

template<class T1, class T2>

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

Definition at line 407 of file RResultPtr.hxx.

operator!=() [2/3]

template<class T1>

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

Definition at line 425 of file RResultPtr.hxx.

operator!=() [3/3]

template<class T1>

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

Definition at line 431 of file RResultPtr.hxx.

operator<<()

std::ostream & ROOT::RDF::operator<<	(	std::ostream &	os,
		const RDFDescription &	description )

Definition at line 37 of file RDFDescription.cxx.

operator==() [1/3]

template<class T1, class T2>

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

Definition at line 401 of file RResultPtr.hxx.

operator==() [2/3]

template<class T1>

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

Definition at line 413 of file RResultPtr.hxx.

operator==() [3/3]

template<class T1>

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

Definition at line 419 of file RResultPtr.hxx.

PassAsVec()

template<std::size_t N, typename T, typename F>

auto ROOT::RDF::PassAsVec

(

F &&

f

)

-> RDFInternal::PassAsVecHelper<std::make_index_sequence<N>, T, F>

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

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

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

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

Definition at line 103 of file RDFHelpers.hxx.

Profile1D() [1/3]

template<typename V1, typename V2, typename W>

RResultPtr<::TProfile > ROOT::RDF::Profile1D

(

const TProfile1DModel &

model

)

Fill and return a one-dimensional profile (lazy action). See the first Profile1D() overload for more details.

Definition at line 2223 of file RInterface.hxx.

Profile1D() [2/3]

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

RResultPtr<::TProfile > ROOT::RDF::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).

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. Also see RResultPtr.

Example usage:

// Deduce column types (this invocation needs jitting internally)
auto myProf1 = myDf.Profile1D({"profName", "profTitle", 64u, -4., 4.}, "xValues", "yValues", "weight");
// Explicit column types
auto myProf2 = myDf.Profile1D<int, float, double>({"profName", "profTitle", 64u, -4., 4.},
                                                  "xValues", "yValues", "weight");

See the first Profile1D() overload for more details.

Definition at line 2201 of file RInterface.hxx.

Profile1D() [3/3]

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

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

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. Also see RResultPtr.

Example usage:

// Deduce column types (this invocation needs jitting internally)
auto myProf1 = myDf.Profile1D({"profName", "profTitle", 64u, -4., 4.}, "xValues", "yValues");
// Explicit column types
auto myProf2 = myDf.Graph<int, float>({"profName", "profTitle", 64u, -4., 4.}, "xValues", "yValues");

Note

Differently from other ROOT interfaces, the returned profile is not associated to gDirectory and the caller is responsible for its lifetime (in particular, a typical source of confusion is that if result histograms go out of scope before the end of the program, ROOT might display a blank canvas).

Definition at line 2156 of file RInterface.hxx.

Profile2D() [1/3]

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

RResultPtr<::TProfile2D > ROOT::RDF::Profile2D

(

const TProfile2DModel &

model

)

Fill and return a two-dimensional profile (lazy action). See the first Profile2D() overload for more details.

Definition at line 2327 of file RInterface.hxx.

Profile2D() [2/3]

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

RResultPtr<::TProfile2D > ROOT::RDF::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).

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. Also see RResultPtr.

Example usage:

// Deduce column types (this invocation needs jitting internally)
auto myProf1 = myDf.Profile2D({"profName", "profTitle", 40, -4, 4, 40, -4, 4, 0, 20},
                              "xValues", "yValues", "zValues", "weight");
// Explicit column types
auto myProf2 = myDf.Profile2D<int, float, double, int>({"profName", "profTitle", 40, -4, 4, 40, -4, 4, 0, 20},
                                                       "xValues", "yValues", "zValues", "weight");

See the first Profile2D() overload for more details.

Definition at line 2305 of file RInterface.hxx.

Profile2D() [3/3]

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

RResultPtr<::TProfile2D > ROOT::RDF::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).

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 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. Also see RResultPtr.

Example usage:

// Deduce column types (this invocation needs jitting internally)
auto myProf1 = myDf.Profile2D({"profName", "profTitle", 40, -4, 4, 40, -4, 4, 0, 20},
                              "xValues", "yValues", "zValues");
// Explicit column types
auto myProf2 = myDf.Profile2D<int, float, double>({"profName", "profTitle", 40, -4, 4, 40, -4, 4, 0, 20},
                                                  "xValues", "yValues", "zValues");

Note

Differently from other ROOT interfaces, the returned profile is not associated to gDirectory and the caller is responsible for its lifetime (in particular, a typical source of confusion is that if result histograms go out of scope before the end of the program, ROOT might display a blank canvas).

Definition at line 2257 of file RInterface.hxx.

Range() [1/2]

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

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.

Example usage:

auto d_0_30 = d.Range(0, 30); // Pick the first 30 entries
auto d_15_end = d.Range(15, 0); // Pick all entries from 15 onwards
auto d_15_end_3 = d.Range(15, 0, 3); // Stride: from event 15, pick an event every 3

Definition at line 1401 of file RInterface.hxx.

Range() [2/2]

RInterface< RDFDetail::RRange< Proxied >, DS_t > ROOT::RDF::Range

(

unsigned int

end

)

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 1422 of file RInterface.hxx.

Reduce() [1/2]

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

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

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 initialized to this value.

Returns

the reduced quantity wrapped in a RResultPtr.

Example usage:

auto sumOfIntColWithOffset = d.Reduce([](int x, int y) { return x + y; }, "intCol", 42);

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

Definition at line 1542 of file RInterface.hxx.

Reduce() [2/2]

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

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

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 ROOT::RDF: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.

Example usage:

auto sumOfIntCol = d.Reduce([](int x, int y) { return x + y; }, "intCol");

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

Definition at line 1519 of file RInterface.hxx.

Report()

RResultPtr< RCutFlowReport > ROOT::RDF::Report

(

)

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.

Example usage:

auto filtered = d.Filter(cut1, {"b1"}, "Cut1").Filter(cut2, {"b2"}, "Cut2");
auto cutReport = filtered3.Report();
cutReport->Print();

Definition at line 2623 of file RInterface.hxx.

RInterface()

ROOT::RDF::RInterface ( const std::shared_ptr< Proxied > & proxied, RLoopManager & lm, const RDFInternal::RColumnRegister & colRegister )

protected

Definition at line 3143 of file RInterface.hxx.

RunGraphs()

unsigned int ROOT::RDF::RunGraphs

(

std::vector< RResultHandle >

handles

)

Trigger the event loop of multiple RDataFrames concurrently.

Parameters

[in]

handles

A vector of RResultHandles

Returns

The number of distinct computation graphs that have been processed

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

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

Definition at line 66 of file RDFHelpers.cxx.

SaveGraph() [1/2]

template<typename NodeType>

std::string ROOT::RDF::SaveGraph

(

NodeType

node

)

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

Parameters

[in]

node

any node of the graph. Called on the head (first) node, it prints the entire graph. Otherwise, only the branch the node belongs to.

The output can be displayed with a command akin to dot -Tpng output.dot > output.png && open output.png.

Note that "hanging" Defines, i.e. Defines without downstream nodes, will not be displayed by SaveGraph as they are effectively optimized away from the computation graph.

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

Definition at line 120 of file RDFHelpers.hxx.

SaveGraph() [2/2]

template<typename NodeType>

void ROOT::RDF::SaveGraph	(	NodeType	node,
		const std::string &	outputFile )

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

Parameters

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

The output can be displayed with a command akin to dot -Tpng output.dot > output.png && open output.png.

Note that "hanging" Defines, i.e. Defines without downstream nodes, will not be displayed by SaveGraph as they are effectively optimized away from the computation graph.

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

Definition at line 139 of file RDFHelpers.hxx.

Snapshot() [1/4]

template<typename... ColumnTypes>

RResultPtr< RInterface< RLoopManager > > ROOT::RDF::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.

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.

By default, in case of TTree or TChain inputs, Snapshot will try to write out all top-level branches. For other types of inputs, all columns returned by GetColumnNames() will be written out. If friend trees or chains are present, by default all friend top-level branches that have names that do not collide with names of branches in the main TTree/TChain will be written out. Since v6.24, Snapshot will also write out friend branches with the same names of branches in the main TTree/TChain with names of the form <friendname>_<branchname> in order to differentiate them from the branches in the main tree/chain.

Writing to a sub-directory

Snapshot supports writing the TTree in a sub-directory inside the TFile. It is sufficient to specify the path to the TTree as part of the TTree name, e.g. df.Snapshot("subdir/t", "f.root") write TTree t in the sub-directory subdir of file f.root (creating file and sub-directory as needed).

Attention

In multi-thread runs (i.e. when EnableImplicitMT() has been called) threads will loop over clusters of entries in an undefined order, so Snapshot will produce outputs in which (clusters of) entries will be shuffled with respect to the input TTree. Using such "shuffled" TTrees as friends of the original trees would result in wrong associations between entries in the main TTree and entries in the "shuffled" friend. Since v6.22, ROOT will error out if such a "shuffled" TTree is used in a friendship.

Note

In case no events are written out (e.g. because no event passes all filters) the behavior of Snapshot in single-thread and multi-thread runs is different: in single-thread runs, Snapshot will write out a TTree with the specified name and zero entries; in multi-thread runs, no TTree object will be written out to disk.

Snapshot will refuse to process columns with names of the form #columnname. These are special columns made available by some data sources (e.g. RNTupleDS) that represent the size of column columnname, and are not meant to be written out with that name (which is not a valid C++ variable name). Instead, go through an Alias(): df.Alias("nbar", "#bar").Snapshot(..., {"nbar"}).

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"});

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 1130 of file RInterface.hxx.

Snapshot() [2/4]

RResultPtr< RInterface< RLoopManager > > ROOT::RDF::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.

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 1148 of file RInterface.hxx.

Snapshot() [3/4]

RResultPtr< RInterface< RLoopManager > > ROOT::RDF::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.

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 1246 of file RInterface.hxx.

Snapshot() [4/4]

RResultPtr< RInterface< RLoopManager > > ROOT::RDF::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.

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. The dialect supported is PCRE via the TPRegexp class. 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 1206 of file RInterface.hxx.

SnapshotImpl()

template<typename... ColumnTypes>

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

private

Definition at line 2990 of file RInterface.hxx.

splitInEqualRanges()

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

Definition at line 519 of file RArrowDS.cxx.

Stats() [1/2]

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

RResultPtr< TStatistic > ROOT::RDF::Stats	(	std::string_view	value,
		std::string_view	weight )

Return a TStatistic object, filled once per event (lazy action).

Template Parameters

V	The type of the value column
W	The type of the weight column

Parameters

[in]	value	The name of the column with the values to fill the statistics with.
[in]	weight	The name of the column with the weights to fill the statistics with.

Returns

the filled TStatistic object wrapped in a RResultPtr.

Example usage:

// Deduce column types (this invocation needs jitting internally)
auto stats0 = myDf.Stats("values", "weights");
// Explicit column types
auto stats1 = myDf.Stats<int, float>("values", "weights");

Definition at line 2425 of file RInterface.hxx.

Stats() [2/2]

template<typename V = RDFDetail::RInferredType>

RResultPtr< TStatistic > ROOT::RDF::Stats

(

std::string_view

value = ""

)

Return a TStatistic object, filled once per event (lazy action).

Template Parameters

V	The type of the value column

Parameters

[in]

value

The name of the column with the values to fill the statistics with.

Returns

the filled TStatistic object wrapped in a RResultPtr.

Example usage:

// Deduce column type (this invocation needs jitting internally)
auto stats0 = myDf.Stats("values");
// Explicit column type
auto stats1 = myDf.Stats<float>("values");

Definition at line 2393 of file RInterface.hxx.

StdDev()

template<typename T = RDFDetail::RInferredType>

RResultPtr< double > ROOT::RDF::StdDev

(

std::string_view

columnName = ""

)

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. Also see RResultPtr.

Example usage:

// Deduce column type (this invocation needs jitting internally)
auto stdDev0 = myDf.StdDev("values");
// Explicit column type
auto stdDev1 = myDf.StdDev<double>("values");

Definition at line 2558 of file RInterface.hxx.

Sum()

template<typename T = RDFDetail::RInferredType>

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

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. Also see RResultPtr.

Example usage:

// Deduce column type (this invocation needs jitting internally)
auto sum0 = myDf.Sum("values");
// Explicit column type
auto sum1 = myDf.Sum<double>("values");

Definition at line 2590 of file RInterface.hxx.

Take()

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

RResultPtr< COLL > ROOT::RDF::Take

(

std::string_view

column = ""

)

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. Also see RResultPtr.

Definition at line 1592 of file RInterface.hxx.

Vary() [1/4]

RInterface< Proxied, DS_t > ROOT::RDF::Vary	(	const std::vector< std::string > &	colNames,
		std::string_view	expression,
		const std::vector< std::string > &	variationTags,
		std::string_view	variationName )

Register systematic variations for multiple existing columns using custom variation tags.

Parameters

[in]	colNames	set of names of the columns for which varied values are provided.
[in]	expression	a string containing valid C++ code that evaluates to an RVec or RVecs containing the varied values for the specified columns.
[in]	variationTags	names for each of the varied values, e.g. "up" and "down".
[in]	variationName	a generic name for this set of varied values, e.g. "ptvariation".

This overload adds the possibility for the expression used to evaluate the varied values to be just-in-time compiled. The example below shows how Vary() is used while dealing with multiple columns. The tags are defined as {"down", "up"}.

auto nominal_hx =
    df.Vary({"x", "y"}, "ROOT::RVec<ROOT::RVecD>{{x*0.9, x*1.1}, {y*0.9, y*1.1}}", {"down", "up"}, "xy")
      .Histo1D("x", "y");
 
auto hx = ROOT::RDF::Experimental::VariationsFor(nominal_hx);
hx["nominal"].Draw();
hx["xy:down"].Draw("SAME");
hx["xy:up"].Draw("SAME");

See also

This Vary() overload for more information.

Definition at line 1027 of file RInterface.hxx.

Vary() [2/4]

RInterface< Proxied, DS_t > ROOT::RDF::Vary	(	const std::vector< std::string > &	colNames,
		std::string_view	expression,
		std::size_t	nVariations,
		std::string_view	variationName )

Register systematic variations for multiple existing columns using auto-generated variation tags.

Parameters

[in]	colNames	set of names of the columns for which varied values are provided.
[in]	expression	a string containing valid C++ code that evaluates to an RVec or RVecs containing the varied values for the specified columns.
[in]	nVariations	number of variations returned by the expression. The corresponding tags will be "0", "1", etc.
[in]	variationName	a generic name for this set of varied values, e.g. "ptvariation".

This overload adds the possibility for the expression used to evaluate the varied values to be just-in-time compiled. It takes an nVariations parameter instead of a list of tag names. The varied results will be accessible via the keys of the dictionary with the form variationName:N where N is the corresponding sequential tag starting at 0 and going up to nVariations - 1. The example below shows how Vary() is used while dealing with multiple columns.

auto nominal_hx =
    df.Vary({"x", "y"}, "ROOT::RVec<ROOT::RVecD>{{x*0.9, x*1.1}, {y*0.9, y*1.1}}", 2, "xy")
      .Histo1D("x", "y");
 
auto hx = ROOT::RDF::Experimental::VariationsFor(nominal_hx);
hx["nominal"].Draw();
hx["xy:0"].Draw("SAME");
hx["xy:1"].Draw("SAME");

See also

This Vary() overload for more information.

Definition at line 975 of file RInterface.hxx.

Vary() [3/4]

RInterface< Proxied, DS_t > ROOT::RDF::Vary	(	std::initializer_list< std::string >	colNames,
		std::string_view	expression,
		std::size_t	nVariations,
		std::string_view	variationName )

Register systematic variations for multiple existing columns using auto-generated variation tags.

Parameters

[in]	colNames	set of names of the columns for which varied values are provided.
[in]	expression	a string containing valid C++ code that evaluates to an RVec containing the varied values for the specified column.
[in]	nVariations	number of variations returned by the expression. The corresponding tags will be "0", "1", etc.
[in]	variationName	a generic name for this set of varied values, e.g. "ptvariation". colName is used if none is provided.

Note

This overload ensures that the ambiguity between C++20 string, vector<string> construction from init list is avoided.

See also

This Vary() overload for more information.

Definition at line 999 of file RInterface.hxx.

Vary() [4/4]

template<typename Proxied, typename DataSource = void>

ROOT::RDF::RInterface RInterfaceBase ROOT::RDF::Vary	(	std::string_view	colName,
		std::string_view	expression,
		std::size_t	nVariations,
		std::string_view	variationName = "" )

Definition at line 91 of file RInterface.hxx.

VaryImpl()

template<bool IsSingleColumn, typename F>

RInterface< Proxied, DS_t > ROOT::RDF::VaryImpl ( const std::vector< std::string > & colNames, F && expression, const ColumnNames_t & inputColumns, const std::vector< std::string > & variationTags, std::string_view variationName )

private

Definition at line 3053 of file RInterface.hxx.

Variable Documentation

Proxied

ROOT::RDF::RInterface ROOT::RDF::Proxied

Register systematic variations for a single existing column using auto-generated variation tags.

Parameters

[in]	colName	name of the column for which varied values are provided.
[in]	expression	a string containing valid C++ code that evaluates to an RVec containing the varied values for the specified column.
[in]	nVariations	number of variations returned by the expression. The corresponding tags will be "0", "1", etc.
[in]	variationName	a generic name for this set of varied values, e.g. "ptvariation". colName is used if none is provided.

This overload adds the possibility for the expression used to evaluate the varied values to be a just-in-time compiled. The example below shows how Vary() is used while dealing with a single column. The variation tags are auto-generated.

auto nominal_hx =
    df.Vary("pt", "ROOT::RVecD{pt*0.9, pt*1.1}", 2)
      .Histo1D("pt");
 
auto hx = ROOT::RDF::Experimental::VariationsFor(nominal_hx);
hx["nominal"].Draw();
hx["pt:0"].Draw("SAME");
hx["pt:1"].Draw("SAME");

See also

This Vary() overload for more information.