The public interface to the RDataFrame federation of classes.
Proxied | One of the "node" base types (e.g. RLoopManager, RFilterBase). The user never specifies this type manually. |
DataSource | The type of the RDataSource which is providing the data to the data frame. There is no source by default. |
The documentation of each method features a one liner illustrating how to use the method, for example showing how the majority of the template parameters are automatically deduced requiring no or very little effort by the user.
Definition at line 103 of file RInterface.hxx.
Public Member Functions | |
RInterface (const RInterface &)=default | |
Copy-ctor for RInterface. | |
template<typename T = Proxied, typename = std::enable_if_t<std::is_same<T, RLoopManager>::value, int>> | |
RInterface (const std::shared_ptr< RLoopManager > &proxied) | |
Build a RInterface from a RLoopManager. | |
RInterface (RInterface &&)=default | |
Move-ctor for RInterface. | |
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 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. | |
RResultPtr< ULong64_t > | Count () |
Return the number of entries processed (lazy action). | |
template<typename F , typename std::enable_if_t<!std::is_convertible< F, std::string >::value, int > = 0> | |
RInterface< Proxied, DS_t > | Define (std::string_view name, F expression, const ColumnNames_t &columns={}) |
Define a new column. | |
RInterface< Proxied, DS_t > | Define (std::string_view name, std::string_view expression) |
Define a new column. | |
template<typename F , typename RetType_t = typename TTraits::CallableTraits<F>::ret_type> | |
RInterface< Proxied, DS_t > | DefinePerSample (std::string_view name, F expression) |
Define a new column that is updated when the input sample changes. | |
RInterface< Proxied, DS_t > | DefinePerSample (std::string_view name, std::string_view expression) |
Define a new column that is updated when the input sample changes. | |
template<typename F > | |
RInterface< Proxied, DS_t > | DefineSlot (std::string_view name, F expression, const ColumnNames_t &columns={}) |
Define a new column with a value dependent on the processing slot. | |
template<typename F > | |
RInterface< Proxied, DS_t > | DefineSlotEntry (std::string_view name, F expression, const ColumnNames_t &columns={}) |
Define a new column with a value dependent on the processing slot and the current entry. | |
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 , std::enable_if_t<!std::is_convertible< F, std::string >::value, int > = 0> | |
RInterface< RDFDetail::RFilter< F, Proxied >, DS_t > | Filter (F f, const ColumnNames_t &columns={}, std::string_view name="") |
Append a filter to the call graph. | |
template<typename F > | |
RInterface< RDFDetail::RFilter< F, Proxied >, DS_t > | Filter (F f, const std::initializer_list< std::string > &columns) |
Append a filter to the call graph. | |
template<typename F , std::enable_if_t<!std::is_convertible< F, std::string >::value, int > = 0> | |
RInterface< RDFDetail::RFilter< F, Proxied >, DS_t > | Filter (F f, std::string_view name) |
Append a filter to the call graph. | |
RInterface< RDFDetail::RJittedFilter, DS_t > | Filter (std::string_view expression, std::string_view name="") |
Append a filter to the call graph. | |
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). | |
std::vector< std::string > | GetFilterNames () |
Returns the names of the filters created. | |
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). | |
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). | |
operator RNode () const | |
Cast any RDataFrame node to a common type ROOT::RDF::RNode. | |
RInterface & | operator= (const RInterface &)=default |
Copy-assignment operator for RInterface. | |
RInterface & | operator= (RInterface &&)=default |
Move-assignment operator for RInterface. | |
template<typename V1 , typename V2 , typename W > | |
RResultPtr<::TProfile > | Profile1D (const TProfile1DModel &model) |
Fill and return a one-dimensional profile (lazy action). | |
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). | |
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 , std::enable_if_t<!std::is_convertible< F, std::string >::value, int > = 0> | |
RInterface< Proxied, DS_t > | Redefine (std::string_view name, F expression, const ColumnNames_t &columns={}) |
Overwrite the value and/or type of an existing column. | |
RInterface< Proxied, DS_t > | Redefine (std::string_view name, std::string_view expression) |
Overwrite the value and/or type of an existing column. | |
template<typename F > | |
RInterface< Proxied, DS_t > | RedefineSlot (std::string_view name, F expression, const ColumnNames_t &columns={}) |
Overwrite the value and/or type of an existing column. | |
template<typename F > | |
RInterface< Proxied, DS_t > | RedefineSlotEntry (std::string_view name, F expression, const ColumnNames_t &columns={}) |
Overwrite the value and/or type of an existing column. | |
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. | |
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 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). | |
template<typename F > | |
RInterface< Proxied, DS_t > | Vary (const std::vector< std::string > &colNames, F &&expression, const ColumnNames_t &inputColumns, const std::vector< std::string > &variationTags, std::string_view variationName) |
Register a systematic variation that affects multiple columns simultaneously. | |
template<typename F > | |
RInterface< Proxied, DS_t > | Vary (const std::vector< std::string > &colNames, F &&expression, const ColumnNames_t &inputColumns, std::size_t nVariations, std::string_view variationName) |
Register systematic variations for one or more existing columns using auto-generated tags. | |
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 one or more existing columns. | |
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 one or more existing columns. | |
template<typename F > | |
RInterface< Proxied, DS_t > | Vary (std::initializer_list< std::string > colNames, F &&expression, const ColumnNames_t &inputColumns, const std::vector< std::string > &variationTags, std::string_view variationName) |
Overload to avoid ambiguity between C++20 string, vector<string> construction from init list. | |
template<typename F > | |
RInterface< Proxied, DS_t > | Vary (std::initializer_list< std::string > colNames, F &&expression, const ColumnNames_t &inputColumns, std::size_t nVariations, std::string_view variationName) |
Overload to avoid ambiguity between C++20 string, vector<string> construction from init list. | |
RInterface< Proxied, DS_t > | Vary (std::initializer_list< std::string > colNames, std::string_view expression, std::size_t nVariations, std::string_view variationName) |
Overload to avoid ambiguity between C++20 string, vector<string> construction from init list. | |
template<typename F > | |
RInterface< Proxied, DS_t > | Vary (std::string_view colName, F &&expression, const ColumnNames_t &inputColumns, const std::vector< std::string > &variationTags, std::string_view variationName="") |
Register systematic variations for an existing column. | |
template<typename F > | |
RInterface< Proxied, DS_t > | Vary (std::string_view colName, F &&expression, const ColumnNames_t &inputColumns, std::size_t nVariations, std::string_view variationName="") |
Register systematic variations for an existing columns using auto-generated variation tags. | |
RInterface< Proxied, DS_t > | Vary (std::string_view colName, std::string_view expression, const std::vector< std::string > &variationTags, std::string_view variationName="") |
Register systematic variations for an existing column. | |
RInterface< Proxied, DS_t > | Vary (std::string_view colName, std::string_view expression, std::size_t nVariations, std::string_view variationName="") |
Register systematic variations for an existing column. | |
Public Member Functions inherited from ROOT::RDF::RInterfaceBase | |
RInterfaceBase (RDFDetail::RLoopManager &lm, const RDFInternal::RColumnRegister &colRegister) | |
RInterfaceBase (std::shared_ptr< RDFDetail::RLoopManager > lm) | |
RDFDescription | Describe () |
Return information about the dataframe. | |
ColumnNames_t | GetColumnNames () |
Returns the names of the available columns. | |
std::string | GetColumnType (std::string_view column) |
Return the type of a given column as a string. | |
ColumnNames_t | GetDefinedColumnNames () |
Returns the names of the defined columns. | |
unsigned int | GetNRuns () const |
Gets the number of event loops run. | |
unsigned int | GetNSlots () const |
Gets the number of data processing slots. | |
RVariationsDescription | GetVariations () const |
Return a descriptor for the systematic variations registered in this branch of the computation graph. | |
bool | HasColumn (std::string_view columnName) |
Checks if a column is present in the dataset. | |
Protected Member Functions | |
RInterface (const std::shared_ptr< Proxied > &proxied, RLoopManager &lm, const RDFInternal::RColumnRegister &colRegister) | |
const std::shared_ptr< Proxied > & | GetProxiedPtr () const |
Protected Member Functions inherited from ROOT::RDF::RInterfaceBase | |
void | AddDefaultColumns () |
template<typename... ColumnTypes> | |
void | CheckAndFillDSColumns (ColumnNames_t validCols, TTraits::TypeList< ColumnTypes... > typeList) |
void | CheckIMTDisabled (std::string_view callerName) |
template<typename ActionTag , typename... ColTypes, typename ActionResultType , typename RDFNode , typename HelperArgType = ActionResultType, std::enable_if_t< RDFInternal::RNeedJitting< ColTypes... >::value, int > = 0> | |
RResultPtr< ActionResultType > | CreateAction (const ColumnNames_t &columns, const std::shared_ptr< ActionResultType > &r, const std::shared_ptr< HelperArgType > &helperArg, const std::shared_ptr< RDFNode > &proxiedPtr, const int nColumns=-1) |
Create RAction object, return RResultPtr for the action Overload for the case in which one or more column types were not specified (RTTI + jitting). | |
template<typename ActionTag , typename... ColTypes, typename ActionResultType , typename RDFNode , typename HelperArgType = ActionResultType, std::enable_if_t<!RDFInternal::RNeedJitting< ColTypes... >::value, int > = 0> | |
RResultPtr< ActionResultType > | CreateAction (const ColumnNames_t &columns, const std::shared_ptr< ActionResultType > &r, const std::shared_ptr< HelperArgType > &helperArg, const std::shared_ptr< RDFNode > &proxiedPtr, const int=-1) |
Create RAction object, return RResultPtr for the action Overload for the case in which all column types were specified (no jitting). | |
std::string | DescribeDataset () const |
ColumnNames_t | GetColumnTypeNamesList (const ColumnNames_t &columnList) |
RDFDetail::RLoopManager * | GetLoopManager () const |
ColumnNames_t | GetValidatedColumnNames (const unsigned int nColumns, const ColumnNames_t &columns) |
template<typename RetType > | |
void | SanityChecksForVary (const std::vector< std::string > &colNames, const std::vector< std::string > &variationTags, std::string_view variationName) |
Private Types | |
using | DS_t = DataSource |
using | RFilterBase = RDFDetail::RFilterBase |
using | RLoopManager = RDFDetail::RLoopManager |
using | RRangeBase = RDFDetail::RRangeBase |
Private Member Functions | |
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 >{}) |
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 &) |
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> | |
RResultPtr< RInterface< RLoopManager > > | SnapshotImpl (std::string_view fullTreeName, std::string_view filename, const ColumnNames_t &columnList, const RSnapshotOptions &options) |
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) |
Private Attributes | |
std::shared_ptr< Proxied > | fProxiedPtr |
Smart pointer to the graph node encapsulated by this RInterface. | |
Friends | |
template<typename T , typename W > | |
class | RInterface |
class | RDFInternal::GraphDrawing::GraphCreatorHelper |
void | RDFInternal::TriggerRun (RNode &node) |
Additional Inherited Members | |
Protected Attributes inherited from ROOT::RDF::RInterfaceBase | |
RDFInternal::RColumnRegister | fColRegister |
Contains the columns defined up to this node. | |
RDataSource * | fDataSource = nullptr |
Non-owning pointer to a data-source object. Null if no data-source. RLoopManager has ownership of the object. | |
RDFDetail::RLoopManager * | fLoopManager |
< The RLoopManager at the root of this computation graph. Never null. | |
#include <ROOT/RDF/RInterface.hxx>
|
private |
Definition at line 104 of file RInterface.hxx.
|
private |
Definition at line 105 of file RInterface.hxx.
|
private |
Definition at line 107 of file RInterface.hxx.
|
private |
Definition at line 106 of file RInterface.hxx.
|
default |
Copy-ctor for RInterface.
|
default |
Move-ctor for RInterface.
|
inline |
Build a RInterface from a RLoopManager.
This constructor is only available for RInterface<RLoopManager>.
Definition at line 139 of file RInterface.hxx.
|
inlineprotected |
Definition at line 2948 of file RInterface.hxx.
|
inline |
Execute a user-defined accumulation operation on the processed column values in each processing slot.
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. |
[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) |
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:
Definition at line 2535 of file RInterface.hxx.
|
inline |
Execute a user-defined accumulation operation on the processed column values in each processing slot.
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. |
[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. |
See previous Aggregate overload for more information.
Definition at line 2569 of file RInterface.hxx.
|
inline |
Allow to refer to a column with a different name.
[in] | alias | name of the column alias |
[in] | columnName | of the column to be aliased |
Aliasing an alias is supported.
Definition at line 877 of file RInterface.hxx.
|
inline |
Book execution of a custom action using a user-defined helper object.
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. |
[in] | helper | The Action Helper to be scheduled. |
[in] | columns | The names of the columns on which the helper acts. |
This method books a custom action for execution. The behavior of the action is completely dependent on the Helper object provided by the caller. The minimum required interface for the helper is the following (more methods can be present, e.g. a constructor that takes the number of worker threads is usually useful):
In case this is called without specifying column types, jitting is used, and the Helper class needs to be known to the interpreter.
This action is lazy: upon invocation of this method the calculation is booked but not executed. Also see RResultPtr.
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 2626 of file RInterface.hxx.
|
inline |
Save selected columns in memory.
ColumnTypes | variadic list of branch/column types. |
[in] | columnList | columns to be cached in memory. |
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 (Filter
ed) data that fits in memory and that will be accessed many times.
#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"})
.Types and columns specified:
Types inferred and columns specified (this invocation relies on jitting):
Types inferred and columns selected with a regexp (this invocation relies on jitting):
Definition at line 1115 of file RInterface.hxx.
|
inline |
Save selected columns in memory.
[in] | columnList | columns to be cached in memory |
RDataFrame
that wraps the cached dataset.See the previous overloads for more information.
Definition at line 1127 of file RInterface.hxx.
|
inline |
Save selected columns in memory.
[in] | columnList | columns to be cached in memory. |
RDataFrame
that wraps the cached dataset.See the previous overloads for more information.
Definition at line 1202 of file RInterface.hxx.
|
inline |
Save selected columns in memory.
[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. |
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 1176 of file RInterface.hxx.
|
inlineprivate |
Implementation of cache.
Definition at line 2836 of file RInterface.hxx.
|
inlineprivate |
Definition at line 2937 of file RInterface.hxx.
|
inlineprivate |
Definition at line 2927 of file RInterface.hxx.
|
inline |
Return the number of entries processed (lazy action).
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.
Definition at line 1385 of file RInterface.hxx.
|
inline |
Define a new column.
[in] | name | The name of the defined column. |
[in] | expression | Function, lambda expression, functor class or any other callable object producing the defined value. Returns the value that will be assigned to the defined column. |
[in] | columns | Names of the columns/branches in input to the producer function. |
Define a column that will be visible from all subsequent nodes of the functional chain. The expression
is only evaluated for entries that pass all the preceding filters. A new variable is created called name
, accessible as if it was contained in the dataset from subsequent transformations/actions.
Use cases include:
An exception is thrown if the name of the new column is already in use in this branch of the computation graph.
return
statement (even if it is in a nested scope), RDataFrame will not add another one in front of the expression. So this will not work: Definition at line 329 of file RInterface.hxx.
|
inline |
Define a new column.
[in] | name | The name of the defined column. |
[in] | expression | An expression in C++ which represents the defined value |
The expression is just-in-time compiled and used to produce the column entries. It must be valid C++ syntax in which variable names are substituted with the names of branches/columns.
return
statement (even if it is in a nested scope), RDataFrame will not add another one in front of the expression. So this will not work: Refer to the first overload of this method for the full documentation.
Definition at line 416 of file RInterface.hxx.
|
inlineprivate |
Definition at line 2742 of file RInterface.hxx.
|
inlineprivate |
Definition at line 2793 of file RInterface.hxx.
|
inline |
Define a new column that is updated when the input sample changes.
[in] | name | The name of the defined column. |
[in] | expression | A C++ callable that computes the new value of the defined column. |
The signature of the callable passed as second argument should be T(unsigned int slot, const ROOT::RDF::RSampleInfo &id)
where:
T
is the type of the defined columnslot
is a number in the range [0, nThreads) that is different for each processing thread. This can simplify the definition of thread-safe callables if you are interested in using parallel capabilities of RDataFrame.id
is an instance of a ROOT::RDF::RSampleInfo object which contains information about the sample which is being processed (see the class docs for more information).DefinePerSample() is useful to e.g. define a quantity that depends on which TTree in which TFile is being processed or to inject a callback into the event loop that is only called when the processing of a new sample starts rather than at every entry.
The callable will be invoked once per input TTree or once per multi-thread task, whichever is more often.
Definition at line 557 of file RInterface.hxx.
|
inline |
Define a new column that is updated when the input sample changes.
[in] | name | The name of the defined column. |
[in] | expression | A valid C++ expression as a string, which will be used to compute the defined value. |
The expression is just-in-time compiled and used to produce the column entries. It must be valid C++ syntax and the usage of the special variable names rdfslot_
and rdfsampleinfo_
is permitted, where these variables will take the same values as the slot
and id
parameters described at the DefinePerSample(std::string_view name, F expression) overload. See the documentation of that overload for more information.
rdfslot_
and rdfsampleinfo_
as input parameters. This is for example the correct way to call this overload when working in PyROOT: Definition at line 618 of file RInterface.hxx.
|
inline |
Define a new column with a value dependent on the processing slot.
[in] | name | The name of the defined column. |
[in] | expression | Function, lambda expression, functor class or any other callable object producing the defined value. Returns the value that will be assigned to the defined column. |
[in] | columns | Names of the columns/branches in input to the producer function (excluding the slot number). |
This alternative implementation of Define
is meant as a helper to evaluate new column values in a thread-safe manner. The expression must be a callable of signature R(unsigned int, T1, T2, ...) where T1, T2...
are the types of the columns that the expression takes as input. The first parameter is reserved for an unsigned integer representing a "slot number". RDataFrame guarantees that different threads will invoke the expression with different slot numbers - slot numbers will range from zero to ROOT::GetThreadPoolSize()-1.
The following two calls are equivalent, although DefineSlot
is slightly more performant:
See Define() for more information.
Definition at line 358 of file RInterface.hxx.
|
inline |
Define a new column with a value dependent on the processing slot and the current entry.
[in] | name | The name of the defined column. |
[in] | expression | Function, lambda expression, functor class or any other callable object producing the defined value. Returns the value that will be assigned to the defined column. |
[in] | columns | Names of the columns/branches in input to the producer function (excluding slot and entry). |
This alternative implementation of Define
is meant as a helper in writing entry-specific, thread-safe custom columns. The expression must be a callable of signature R(unsigned int, ULong64_t, T1, T2, ...) where T1, T2...
are the types of the columns that the expression takes as input. The first parameter is reserved for an unsigned integer representing a "slot number". RDataFrame guarantees that different threads will invoke the expression with different slot numbers - slot numbers will range from zero to ROOT::GetThreadPoolSize()-1. The second parameter is reserved for a ULong64_t
representing the current entry being processed by the current thread.
The following two Define
s are equivalent, although DefineSlotEntry
is slightly more performant:
See Define() for more information.
Definition at line 388 of file RInterface.hxx.
|
inline |
Provides a representation of the columns in the dataset.
ColumnTypes | variadic list of branch/column types. |
[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. |
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:
Definition at line 2671 of file RInterface.hxx.
|
inline |
Provides a representation of the columns in the dataset.
[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. |
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 2694 of file RInterface.hxx.
|
inline |
Provides a representation of the columns in the dataset.
[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. |
RDisplay
instance wrapped in a RResultPtr.See the previous overloads for further details.
Definition at line 2733 of file RInterface.hxx.
|
inline |
Provides a representation of the columns in the dataset.
[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. |
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 2717 of file RInterface.hxx.
|
inline |
Return an object of type T on which T::Fill
will be called once per event (lazy action).
Type T must provide at least:
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)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*).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. |
[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 |
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.
Definition at line 2192 of file RInterface.hxx.
|
inline |
Append a filter to the call graph.
[in] | f | Function, lambda expression, functor class or any other callable object. It must return a bool signalling whether the event has passed the selection (true) or not (false). |
[in] | columns | Names of the columns/branches in input to the filter function. |
[in] | name | Optional name of this filter. See Report . |
Append a filter node at the point of the call graph corresponding to the object this method is called on. The callable f
should not have side-effects (e.g. modification of an external or static variable) to ensure correct results when implicit multi-threading is active.
RDataFrame only evaluates filters when necessary: if multiple filters are chained one after another, they are executed in order and the first one returning false causes the event to be discarded. Even if multiple actions or transformations depend on the same filter, it is executed once per entry. If its result is requested more than once, the cached result is served.
return
statement (even if it is in a nested scope), RDataFrame will not add another one in front of the expression. So this will not work: Definition at line 207 of file RInterface.hxx.
|
inline |
Append a filter to the call graph.
[in] | f | Function, lambda expression, functor class or any other callable object. It must return a bool signalling whether the event has passed the selection (true) or not (false). |
[in] | columns | Names of the columns/branches in input to the filter function. |
Refer to the first overload of this method for the full documentation.
Definition at line 246 of file RInterface.hxx.
|
inline |
Append a filter to the call graph.
[in] | f | Function, lambda expression, functor class or any other callable object. It must return a bool signalling whether the event has passed the selection (true) or not (false). |
[in] | name | Optional name of this filter. See Report . |
Refer to the first overload of this method for the full documentation.
Definition at line 230 of file RInterface.hxx.
|
inline |
Append a filter to the call graph.
[in] | expression | The filter expression in C++ |
[in] | name | Optional name of this filter. See Report . |
The expression is just-in-time compiled and used to filter entries. It must be valid C++ syntax in which variable names are substituted with the names of branches/columns.
return
statement (even if it is in a nested scope), RDataFrame will not add another one in front of the expression. So this will not work: Definition at line 276 of file RInterface.hxx.
|
inline |
Execute a user-defined function on each entry (instant action).
[in] | f | Function, lambda expression, functor class or any other callable object performing user defined calculations. |
[in] | columns | Names of the columns/branches in input to the user function. |
The callable f
is invoked once per entry. This is an instant action: upon invocation, an event loop as well as execution of all scheduled actions is triggered. Users are responsible for the thread-safety of this callable when executing with implicit multi-threading enabled (i.e. ROOT::EnableImplicitMT).
Definition at line 1267 of file RInterface.hxx.
|
inline |
Execute a user-defined function requiring a processing slot index on each entry (instant action).
[in] | f | Function, lambda expression, functor class or any other callable object performing user defined calculations. |
[in] | columns | Names of the columns/branches in input to the user function. |
Same as Foreach
, but the user-defined function takes an extra unsigned int
as its first parameter, the processing slot index. This slot index will be assigned a different value, 0
to poolSize - 1
, for each thread of execution. This is meant as a helper in writing thread-safe Foreach
actions when using RDataFrame
after ROOT::EnableImplicitMT()
. The user-defined processing callable is able to follow different streams of processing indexed by the first parameter. ForeachSlot
works just as well with single-thread execution: in that case slot
will always be 0
.
Definition at line 1297 of file RInterface.hxx.
|
inline |
Returns the names of the filters created.
If called on a root node, all the filters in the computation graph will be printed. For any other node, only the filters upstream of that node. Filters without a name are printed as "Unnamed Filter" This is not an action nor a transformation, just a query to the RDataFrame object.
Definition at line 2483 of file RInterface.hxx.
|
inlineprotected |
Definition at line 2954 of file RInterface.hxx.
|
inline |
Fill and return a TGraph object (lazy action).
X | The type of the column used to fill the x axis. |
Y | The type of the column used to fill the y axis. |
[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. |
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.
Definition at line 1881 of file RInterface.hxx.
|
inline |
Fill and return a TGraphAsymmErrors object (lazy action).
[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 |
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.
Definition at line 1934 of file RInterface.hxx.
|
inline |
Fill and return a one-dimensional histogram with the weighted values of a column (lazy action).
V | The type of the column used to fill the histogram. |
W | The type of the column used as weights. |
[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. |
See the description of the first Histo1D() overload for more details.
Definition at line 1522 of file RInterface.hxx.
|
inline |
Fill and return a one-dimensional histogram with the weighted values of a column (lazy action).
V | The type of the column used to fill the histogram. |
W | The type of the column used as weights. |
[in] | model | The returned histogram will be constructed using this as a model. |
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 1576 of file RInterface.hxx.
|
inline |
Fill and return a one-dimensional histogram with the values of a column (lazy action).
V | The type of the column used to fill the histogram. |
[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. |
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.
Definition at line 1460 of file RInterface.hxx.
|
inline |
Fill and return a one-dimensional histogram with the values of a column (lazy action).
V | The type of the column used to fill the histogram. |
[in] | vName | The name of the column that will fill the histogram. |
This overload uses a default model histogram TH1D(name, title, 128u, 0., 0.). The "name" and "title" strings are built starting from the input column name. See the description of the first Histo1D() overload for more details.
Definition at line 1496 of file RInterface.hxx.
|
inline |
Fill and return a one-dimensional histogram with the weighted values of a column (lazy action).
V | The type of the column used to fill the histogram. |
W | The type of the column used as weights. |
[in] | vName | The name of the column that will fill the histogram. |
[in] | wName | The name of the column that will provide the weights. |
This overload uses a default model histogram TH1D(name, title, 128u, 0., 0.). The "name" and "title" strings are built starting from the input column names. See the description of the first Histo1D() overload for more details.
Definition at line 1556 of file RInterface.hxx.
|
inline |
Definition at line 1671 of file RInterface.hxx.
|
inline |
Fill and return a weighted two-dimensional histogram (lazy action).
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. |
[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. |
This action is lazy: upon invocation of this method the calculation is booked but not executed. Also see RResultPtr.
See the documentation of the first Histo2D() overload for more details.
Definition at line 1653 of file RInterface.hxx.
|
inline |
Fill and return a two-dimensional histogram (lazy action).
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. |
[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. |
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.
Definition at line 1610 of file RInterface.hxx.
|
inline |
Definition at line 1773 of file RInterface.hxx.
|
inline |
Fill and return a three-dimensional histogram (lazy action).
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. |
[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. |
This action is lazy: upon invocation of this method the calculation is booked but not executed. Also see RResultPtr.
See the documentation of the first Histo2D() overload for more details.
Definition at line 1754 of file RInterface.hxx.
|
inline |
Fill and return a three-dimensional histogram (lazy action).
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. |
[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. |
This action is lazy: upon invocation of this method the calculation is booked but not executed. Also see RResultPtr.
Definition at line 1705 of file RInterface.hxx.
|
inline |
Fill and return an N-dimensional histogram (lazy action).
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. |
[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) |
This action is lazy: upon invocation of this method the calculation is booked but not executed. See RResultPtr documentation.
Definition at line 1801 of file RInterface.hxx.
|
inline |
Fill and return an N-dimensional histogram (lazy action).
[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) |
This action is lazy: upon invocation of this method the calculation is booked but not executed. Also see RResultPtr.
Definition at line 1835 of file RInterface.hxx.
|
inlineprivate |
Definition at line 2891 of file RInterface.hxx.
|
inline |
Return the maximum of processed column values (lazy action).
T | The type of the branch/column. |
[in] | columnName | The name of the branch/column to be treated. |
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.
Definition at line 2326 of file RInterface.hxx.
|
inline |
Return the mean of processed column values (lazy action).
T | The type of the branch/column. |
[in] | columnName | The name of the branch/column to be treated. |
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.
Definition at line 2355 of file RInterface.hxx.
|
inline |
Return the minimum of processed column values (lazy action).
T | The type of the branch/column. |
[in] | columnName | The name of the branch/column to be treated. |
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.
Definition at line 2296 of file RInterface.hxx.
|
inline |
Cast any RDataFrame node to a common type ROOT::RDF::RNode.
Different RDataFrame methods return different C++ types. All nodes, however, can be cast to this common type at the cost of a small performance penalty. This allows, for example, storing RDataFrame nodes in a vector, or passing them around via (non-template, C++11) helper functions. Example usage:
Note that it is not a problem to pass RNode's by value.
Definition at line 161 of file RInterface.hxx.
|
default |
Copy-assignment operator for RInterface.
|
default |
Move-assignment operator for RInterface.
|
inline |
Fill and return a one-dimensional profile (lazy action).
See the first Profile1D() overload for more details.
Definition at line 2048 of file RInterface.hxx.
|
inline |
Fill and return a one-dimensional profile (lazy action).
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. |
[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. |
This action is lazy: upon invocation of this method the calculation is booked but not executed. Also see RResultPtr.
See the first Profile1D() overload for more details.
Definition at line 2026 of file RInterface.hxx.
|
inline |
Fill and return a one-dimensional profile (lazy action).
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. |
[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. |
This action is lazy: upon invocation of this method the calculation is booked but not executed. Also see RResultPtr.
Definition at line 1981 of file RInterface.hxx.
|
inline |
Fill and return a two-dimensional profile (lazy action).
See the first Profile2D() overload for more details.
Definition at line 2152 of file RInterface.hxx.
|
inline |
Fill and return a two-dimensional profile (lazy action).
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. |
[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. |
This action is lazy: upon invocation of this method the calculation is booked but not executed. Also see RResultPtr.
See the first Profile2D() overload for more details.
Definition at line 2130 of file RInterface.hxx.
|
inline |
Fill and return a two-dimensional profile (lazy action).
V1 | The type of the column used to fill the x axis of the histogram. Inferred if not present. |
V2 | The type of the column used to fill the y axis of the histogram. Inferred if not present. |
V2 | The type of the column used to fill the z axis of the histogram. Inferred if not present. |
[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. |
This action is lazy: upon invocation of this method the calculation is booked but not executed. Also see RResultPtr.
Definition at line 2082 of file RInterface.hxx.
|
inline |
Creates a node that filters entries based on range: [begin, end).
[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. |
Note that in case of previous Ranges and Filters the selected range refers to the transformed dataset. Ranges are only available if EnableImplicitMT has not been called. Multi-thread ranges are not supported.
Definition at line 1226 of file RInterface.hxx.
|
inline |
Creates a node that filters entries based on range.
[in] | end | Final entry number (excluded) considered for this range. 0 means that the range goes until the end of the dataset. |
See the other Range overload for a detailed description.
Definition at line 1247 of file RInterface.hxx.
|
inline |
Overwrite the value and/or type of an existing column.
[in] | name | The name of the column to redefine. |
[in] | expression | Function, lambda expression, functor class or any other callable object producing the defined value. Returns the value that will be assigned to the defined column. |
[in] | columns | Names of the columns/branches in input to the expression. |
The old value of the column can be used as an input for the expression.
An exception is thrown in case the column to redefine does not already exist. See Define() for more information.
Definition at line 448 of file RInterface.hxx.
|
inline |
Overwrite the value and/or type of an existing column.
[in] | name | The name of the column to redefine. |
[in] | expression | An expression in C++ which represents the defined value |
The expression is just-in-time compiled and used to produce the column entries. It must be valid C++ syntax in which variable names are substituted with the names of branches/columns.
The old value of the column can be used as an input for the expression. An exception is thrown in case the column to re-define does not already exist.
Aliases cannot be overridden. See the corresponding Define() overload for more information.
Definition at line 506 of file RInterface.hxx.
|
inline |
Overwrite the value and/or type of an existing column.
[in] | name | The name of the column to redefine. |
[in] | expression | Function, lambda expression, functor class or any other callable object producing the defined value. Returns the value that will be assigned to the defined column. |
[in] | columns | Names of the columns/branches in input to the producer function (excluding slot). |
The old value of the column can be used as an input for the expression. An exception is thrown in case the column to redefine does not already exist.
See DefineSlot() for more information.
Definition at line 467 of file RInterface.hxx.
|
inline |
Overwrite the value and/or type of an existing column.
[in] | name | The name of the column to redefine. |
[in] | expression | Function, lambda expression, functor class or any other callable object producing the defined value. Returns the value that will be assigned to the defined column. |
[in] | columns | Names of the columns/branches in input to the producer function (excluding slot and entry). |
The old value of the column can be used as an input for the expression. An exception is thrown in case the column to re-define does not already exist.
See DefineSlotEntry() for more information.
Definition at line 486 of file RInterface.hxx.
|
inline |
Execute a user-defined reduce operation on the values of a column.
F | The type of the reduce callable. Automatically deduced. |
T | The type of the column to apply the reduction to. Automatically deduced. |
[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. |
See the description of the first Reduce overload for more information.
Definition at line 1367 of file RInterface.hxx.
|
inline |
Execute a user-defined reduce operation on the values of a column.
F | The type of the reduce callable. Automatically deduced. |
T | The type of the column to apply the reduction to. Automatically deduced. |
[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. |
A reduction takes two values of a column and merges them into one (e.g. by summing them, taking the maximum, etc). This action performs the specified reduction operation on all processed column values, returning a single value of the same type. The callable f must satisfy the general requirements of a processing function besides having signature T(T,T)
where T
is the type of column columnName.
The returned reduced value of each thread (e.g. the initial value of a sum) is initialized to a default-constructed T object. This is commonly expected to be the neutral/identity element for the specific reduction operation f
(e.g. 0 for a sum, 1 for a product). If a default-constructed T does not satisfy this requirement, users should explicitly specify an initialization value for T by calling the appropriate Reduce
overload.
This action is lazy: upon invocation of this method the calculation is booked but not executed. Also see RResultPtr.
Definition at line 1344 of file RInterface.hxx.
|
inline |
Gather filtering statistics.
RCutFlowReport
instance wrapped in a RResultPtr.Calling Report
on the main RDataFrame
object gathers stats for all named filters in the call graph. Calling this method on a stored chain state (i.e. a graph node different from the first) gathers the stats for all named filters in the chain section between the original RDataFrame
and that node (included). Stats are gathered in the same order as the named filters have been added to the graph. A RResultPtr<RCutFlowReport> is returned to allow inspection of the effects cuts had.
This action is lazy: upon invocation of this method the calculation is booked but not executed. See RResultPtr documentation.
Definition at line 2448 of file RInterface.hxx.
|
inline |
Save selected columns to disk, in a new TTree treename
in file filename
.
ColumnTypes | variadic list of branch/column types. |
[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. |
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.
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).
#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"})
.To book a Snapshot without triggering the event loop, one needs to set the appropriate flag in RSnapshotOptions
:
Definition at line 962 of file RInterface.hxx.
|
inline |
Save selected columns to disk, in a new TTree treename
in file filename
.
[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. |
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 980 of file RInterface.hxx.
|
inline |
Save selected columns to disk, in a new TTree treename
in file filename
.
[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. |
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 1071 of file RInterface.hxx.
|
inline |
Save selected columns to disk, in a new TTree treename
in file filename
.
[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 |
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 1031 of file RInterface.hxx.
|
inlineprivate |
Definition at line 2801 of file RInterface.hxx.
|
inline |
Return a TStatistic object, filled once per event (lazy action).
V | The type of the value column |
W | The type of the weight column |
[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. |
Definition at line 2250 of file RInterface.hxx.
|
inline |
Return a TStatistic object, filled once per event (lazy action).
V | The type of the value column |
[in] | value | The name of the column with the values to fill the statistics with. |
Definition at line 2218 of file RInterface.hxx.
|
inline |
Return the unbiased standard deviation of processed column values (lazy action).
T | The type of the branch/column. |
[in] | columnName | The name of the branch/column to be treated. |
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.
Definition at line 2383 of file RInterface.hxx.
|
inline |
Return the sum of processed column values (lazy action).
T | The type of the branch/column. |
[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. |
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.
Definition at line 2415 of file RInterface.hxx.
|
inline |
Return a collection of values of a column (lazy action, returns a std::vector by default).
T | The type of the column. |
COLL | The type of collection used to store the values. |
[in] | column | The name of the column to collect the values of. |
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>>
.
This action is lazy: upon invocation of this method the calculation is booked but not executed. Also see RResultPtr.
Definition at line 1417 of file RInterface.hxx.
|
inline |
Register a systematic variation that affects multiple columns simultaneously.
This overload of Vary takes a list of column names as first argument rather than a single name and requires that the expression returns an RVec of RVecs of values: one inner RVec for the variations of each affected column. See the documentation of the first Vary overload for more information.
Example usage:
Definition at line 716 of file RInterface.hxx.
|
inline |
Register systematic variations for one or more existing columns using auto-generated tags.
This overload of Vary takes a nVariations parameter instead of a list of tag names. Tag names will be auto-generated as the sequence 0...nVariations-1. See the documentation of the previous overload for more information.
Definition at line 737 of file RInterface.hxx.
|
inline |
Register systematic variations for one or more existing columns.
[in] | colNames | 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". |
Definition at line 859 of file RInterface.hxx.
|
inline |
Register systematic variations for one or more existing columns.
[in] | colNames | 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". |
Definition at line 824 of file RInterface.hxx.
|
inline |
Overload to avoid ambiguity between C++20 string, vector<string> construction from init list.
Definition at line 725 of file RInterface.hxx.
|
inline |
Overload to avoid ambiguity between C++20 string, vector<string> construction from init list.
Definition at line 753 of file RInterface.hxx.
|
inline |
Overload to avoid ambiguity between C++20 string, vector<string> construction from init list.
Definition at line 836 of file RInterface.hxx.
|
inline |
Register systematic variations for an existing column.
[in] | colName | name of the column for which varied values are provided. |
[in] | expression | a callable that evaluates the varied values for the specified columns. The callable can take any column values as input, similarly to what happens with Filter and Define calls. It must return an RVec of varied values, one for each variation tag, in the same order as the tags. |
[in] | inputColumns | the names of the columns to be passed to the callable. |
[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". |
Vary provides a natural and flexible syntax to define systematic variations that automatically propagate to Filters, Defines and results. RDataFrame usage of columns with attached variations does not change, but for results that depend on any varied quantity a map/dictionary of varied results can be produced with ROOT::RDF::Experimental::VariationsFor (see the example below).
The dictionary will contain a "nominal" value (accessed with the "nominal" key) for the unchanged result, and values for each of the systematic variations that affected the result (via upstream Filters or via direct or indirect dependencies of the column values on some registered variations). The keys will be a composition of variation names and tags, e.g. "pt:up" and "pt:down" for the example below.
In the following example we add up/down variations of pt and fill a histogram with a quantity that depends on pt. We automatically obtain three histograms in output ("nominal", "pt:up" and "pt:down"):
Definition at line 670 of file RInterface.hxx.
|
inline |
Register systematic variations for an existing columns using auto-generated variation tags.
This overload of Vary takes a nVariations parameter instead of a list of tag names. Tag names will be auto-generated as the sequence 0...nVariations-1. See the documentation of the previous overload for more information.
Definition at line 685 of file RInterface.hxx.
|
inline |
Register systematic variations for an existing column.
[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] | 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". colName is used if none is provided. |
Definition at line 778 of file RInterface.hxx.
|
inline |
Register systematic variations for an existing column.
[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. |
See the documentation for the previous overload for more information.
Definition at line 796 of file RInterface.hxx.
|
inlineprivate |
Definition at line 2858 of file RInterface.hxx.
|
friend |
Definition at line 112 of file RInterface.hxx.
|
friend |
Definition at line 109 of file RInterface.hxx.
|
friend |
|
private |
Smart pointer to the graph node encapsulated by this RInterface.
Definition at line 116 of file RInterface.hxx.