18.3. Filtering Data
Table of Contents
`Filter()`
In RDataFrame, Filter() is the central tool to select only the entries (events, rows) that satisfy a given condition. Conceptually, it plays the same role as an if statement inside a manual TTree loop, but it is expressed in a declarative way.
You always call Filter() on an existing RDataFrame object. The method takes at least two arguments: a boolean expression and a string label. The expression is written in C++ and refers to existing columns of the dataframe, either read from branches in a TTree or created with Define().
A typical call looks like this:
ROOT::RDataFrame df("Events", "data.root");
auto df_selected = df.Filter("energy > 5.0", "energy cut");
The first argument "energy > 5.0" is evaluated for every entry. Only entries where it returns true are passed to df_selected. The second argument "energy cut" is a human readable name used in progress reports and in some statistics that RDataFrame can provide. It is optional but strongly recommended.
You can also write more complex logical conditions. RDataFrame uses the same logical operators as C++:
auto df_good = df.Filter("energy > 5.0 && nTracks >= 2", "basic quality selection");
Here, an entry is kept only if both conditions are satisfied. Logical || means at least one condition is satisfied, and ! negates a condition.
Filter() can also take a C++ callable such as a lambda instead of a string expression. This is useful when the condition cannot easily be expressed as a short expression or when you prefer to write explicit C++ code:
auto df_filtered = df.Filter(
[](double energy, int charge) {
return energy > 3.0 && charge != 0;
},
{"energy", "charge"}, // list of columns used as arguments
"non-zero charged particles with E > 3"
);In this form, the second parameter is a list of column names that are passed as arguments to the lambda in the same order.
From the user point of view, Filter() is lazy. The filtering is not executed when you call Filter(). Instead, RDataFrame builds a computation graph. The actual work only happens when you trigger an action such as Histo1D(), Mean(), or Snapshot(). This means you can define many filters and derived columns without paying a cost until you actually request an output.
It is important to remember that Filter() does not modify the original dataframe. Instead, it returns a new RDataFrame node that represents the filtered view. The original df remains unchanged and can be reused for other selections.
Rule: Filter() selects entries where the condition is true and returns a new RDataFrame node. The original dataframe is not modified, and no data processing happens until an action is executed.
In many analyses, Filter() is used directly before histogram creation or statistical operations, for example:
auto df_muons = df.Filter("abs(pdgId) == 13", "select muons");
auto h_pt_muons = df_muons.Histo1D({"h_pt_muons", "Muon p_{T}", 100, 0., 100.}, "pt");Here, only entries that pass the muon selection contribute to the histogram of transverse momentum.
Multiple filters
Real analyses rarely use a single cut. Instead, you typically apply a sequence of cuts that represent different selection steps, such as basic quality requirements, detector acceptance, and final signal region definitions. With RDataFrame you express this as a chain of Filter() calls.
A chain can be written by applying Filter() one after another on the result of the previous filter:
auto df_base = ROOT::RDataFrame("Events", "data.root");
auto df_basic = df_base.Filter("energy > 1.0", "basic energy cut");
auto df_quality= df_basic.Filter("nHits >= 10", "hit quality cut");
auto df_signal = df_quality.Filter("mass > 2.9 && mass < 3.3", "signal mass window");
Each call creates a new node in a computation graph. df_signal sees only the entries that passed all previous filters. You can attach different actions at different stages of the chain:
auto h_all = df_base.Histo1D({"h_all", "All events;mass;Entries", 100, 0., 5.}, "mass");
auto h_basic = df_basic.Histo1D({"h_basic", "After basic cut;mass;Entries", 100, 0., 5.}, "mass");
auto h_signal = df_signal.Histo1D({"h_signal", "Signal region;mass;Entries", 100, 0., 5.}, "mass");All three histograms are produced from a single pass over the data. RDataFrame automatically shares work between the different branches of the graph, which is efficient even when many filters and actions are used together.
You can also express several requirements inside a single Filter() by combining them with && and ||. Often it is clearer to separate logical stages into distinct filters with descriptive labels, because RDataFrame can report statistics for each filter stage. This helps you monitor how many events survive each cut.
The following table illustrates two equivalent ways to implement two cuts on energy and nTracks:
| Style | Example expression | Comment |
|---|---|---|
| Single filter | "energy > 5.0 && nTracks >= 2" | One node, combined logical condition |
| Multiple filters | first "energy > 5.0", then "nTracks >= 2" | Clear separation of cuts and cutflow |
Both styles produce the same final selection. The choice is mainly about readability and about how you want to track cut efficiencies.
Because RDataFrame is lazy, the order in which you write multiple filters in your script matters logically but not in terms of when the code runs. The filters are applied in the order they appear when an action is triggered. If one filter is much more restrictive than another, placing it earlier in the chain can reduce the amount of work done by subsequent filters and computations.
Multiple filters can be mixed with Define() calls that construct new columns. A common pattern is to define derived quantities first, then filter on them:
auto df_with_pt = df_base.Define("pt", "sqrt(px*px + py*py)");
auto df_high_pt = df_with_pt.Filter("pt > 20.0", "high pT selection");
In summary, you construct complex selections in RDataFrame by chaining Filter() calls. Each filter represents a logical step, and the full sequence defines the final event selection used by your actions.
Rule: You can chain several Filter() calls to represent different selection steps. All filters in the chain must be satisfied for an entry to reach the final node, and a single pass over the data can serve all branches and actions of the graph.
Views: 0
Where to Move
Move chapter:
- ☰ 1. Introduction to ROOT
- ☰ 1.1. What Is ROOT?
- ☰ 1.2. Installing ROOT
- ☰ 1.3. Starting ROOT
- ☰ 1.4. Your First ROOT Session
-
- ☰ 2. C++ Basics for ROOT
- ☰ 2.1. Why ROOT Uses C++
- ☰ 2.2. Variables and Data Types
- ☰ 2.3. Operators
- ☰ 2.4. Conditional Statements
- ☰ 2.5. Loops
- ☰ 2.6. Functions
- ☰ 2.7. Arrays and Vectors
-
- ☰ 3. ROOT Macros
- ☰ 3.1. What Is a ROOT Macro?
- ☰ 3.2. Running ROOT Macros
- ☰ 3.3. Functions Inside ROOT Macros
- ☰ 3.4. Compiling ROOT Macros
- ☰ 3.5. Organizing a ROOT Project
-
- ☰ 4. ROOT Objects and the ROOT Object Model
- ☰ 4.1. Introduction to ROOT Classes
- ☰ 4.2. Object Names and Titles
- ☰ 4.3. ROOT Collections
- ☰ 4.4. Inspecting ROOT Objects
-
- ☰ 5. Histograms
- ☰ 5.1. Introduction to Histograms
- ☰ 5.2. Creating a 1D Histogram
- ☰ 5.3. Filling Histograms
- ☰ 5.4. Drawing Histograms
- ☰ 5.5. Histogram Properties
- ☰ 5.6. Accessing Histogram Bins
- ☰ 5.7. Histogram Errors
- ☰ 5.8. Normalizing Histograms
- ☰ 5.9. Combining Histograms
-
- ☰ 6. Two-Dimensional Histograms
- ☰ 6.1. Creating 2D Histograms
- ☰ 6.2. Filling 2D Histograms
- ☰ 6.3. Drawing 2D Histograms
- ☰ 6.4. Projections
- ☰ 6.5. Profiles
-
- ☰ 7. Graphs
- ☰ 7.1. Introduction to TGraph
- ☰ 7.2. Creating a TGraph
- ☰ 7.3. Graph Styling
- ☰ 7.4. TGraphErrors
- ☰ 7.5. TGraphAsymmErrors
- ☰ 7.6. MultiGraph
-
- ☰ 8. Canvases and Plotting
- ☰ 8.1. TCanvas
- ☰ 8.2. Dividing a Canvas
- ☰ 8.3. Drawing Multiple Objects
- ☰ 8.4. Legends
- ☰ 8.5. Text and Annotations
- ☰ 8.6. Logarithmic Axes
- ☰ 8.7. Saving Plots
-
- ☰ 9. Styling ROOT Plots
- ☰ 9.1. ROOT Plot Styles
- ☰ 9.2. Axis Configuration
- ☰ 9.3. Line Styles
- ☰ 9.4. Marker Styles
- ☰ 9.5. Publication-Quality Figures
-
- ☰ 10. Mathematical Functions
- ☰ 10.1. Introduction to TF1
- ☰ 10.2. Built-in Functions
- ☰ 10.3. Custom Functions
- ☰ 10.4. Evaluating Functions
- ☰ 10.5. Function Integrals
-
- ☰ 11. Curve Fitting
- ☰ 11.1. Introduction to Fitting
- ☰ 11.2. Gaussian Fits
- ☰ 11.3. Polynomial Fits
- ☰ 11.4. Custom Fit Functions
- ☰ 11.5. Fit Parameters
- ☰ 11.6. Goodness of Fit
- ☰ 11.7. Fit Residuals
- ☰ 11.8. Fitting Graphs
-
- ☰ 12. ROOT Files
- ☰ 12.1. Introduction to ROOT Files
- ☰ 12.2. Creating ROOT Files
- ☰ 12.3. Writing Objects
- ☰ 12.4. Reading ROOT Files
- ☰ 12.5. Exploring ROOT Files
- ☰ 12.6. Directories Inside ROOT Files
-
- ☰ 13. TTrees
- ☰ 13.1. Introduction to TTrees
- ☰ 13.2. Creating a TTree
- ☰ 13.3. Filling a TTree
- ☰ 13.4. Writing a TTree to a File
- ☰ 13.5. Reading a TTree
- ☰ 13.6. Inspecting TTrees
- ☰ 13.7. Drawing Data from TTrees
- ☰ 13.8. Applying Selection Cuts
- ☰ 13.9. Branch Addresses
-
- ☰ 14. Event-Based Data Analysis
- ☰ 14.1. Understanding Event Data
- ☰ 14.2. Event Loops
- ☰ 14.3. Event Selection
- ☰ 14.4. Derived Quantities
- ☰ 14.5. Analysis Workflow
-
- ☰ 15. Working with Real Experimental Data
- ☰ 15.1. Importing Text Data
- ☰ 15.2. Converting Data to ROOT
- ☰ 15.3. Data Cleaning
- ☰ 15.4. Data Calibration
- ☰ 15.5. Signal and Background
-
- ☰ 16. Random Numbers and Simulations
- ☰ 16.1. Random Number Generation
- ☰ 16.2. Common Distributions
- ☰ 16.3. Simple Monte Carlo Simulation
- ☰ 16.4. Detector Resolution Simulation
- ☰ 16.5. Efficiency Simulation
-
- ☰ 17. Statistical Analysis with ROOT
- ☰ 17.1. Basic Statistics
- ☰ 17.2. Probability Distributions
- ☰ 17.3. Statistical Uncertainties
- ☰ 17.4. Chi-Square Tests
- ☰ 17.5. Confidence Intervals
-
- ☰ 18. Modern ROOT with RDataFrame
- ☰ 18.1. Introduction to RDataFrame
- ☰ 18.2. Loading Data
- ☰ 18.3. Filtering Data
- ☰ 18.4. Defining New Columns
- ☰ 18.5. Creating Histograms
- ☰ 18.6. Statistical Operations
- ☰ 18.7. Saving Results
- ☰ 18.8. Multithreading
-
- ☰ 19. ROOT and Python
- ☰ 19.1. Introduction to PyROOT
- ☰ 19.2. ROOT Objects in Python
- ☰ 19.3. Reading ROOT Files with Python
- ☰ 19.4. PyROOT and NumPy
- ☰ 19.5. PyROOT and Matplotlib
- ☰ 19.6. Choosing Between C++ and Python
-
- ☰ 20. Advanced TTree Techniques
- ☰ 20.1. Trees with Multiple Branches
- ☰ 20.2. Storing std::vector Objects
- ☰ 20.3. TChain
- ☰ 20.4. Friends
- ☰ 20.5. Efficient TTree Analysis
-
- ☰ 21. ROOT for Particle and Nuclear Physics
- ☰ 21.1. Four-Vectors
- ☰ 21.2. Particle Kinematics
- ☰ 21.3. Invariant Mass
- ☰ 21.4. Angular Distributions
- ☰ 21.5. Detector Spectra
-
- ☰ 22. Debugging and Common ROOT Problems
- ☰ 22.1. ROOT Object Ownership
- ☰ 22.2. Null Pointers
- ☰ 22.3. Segmentation Faults
- ☰ 22.4. Missing Histograms
- ☰ 22.5. ROOT File Problems
- ☰ 22.6. TTree Branch Problems
- ☰ 22.7. Histogram Range Problems
- ☰ 22.8. Fit Failures
- ☰ 22.9. Debugging ROOT Macros
-
- ☰ 23. Writing Better ROOT Analysis Code
- ☰ 23.1. Separating Analysis and Plotting
- ☰ 23.2. Using Functions
- ☰ 23.3. Using Header Files
- ☰ 23.4. Naming Conventions
- ☰ 23.5. Avoiding Hard-Coded Values
- ☰ 23.6. Configuration Parameters
- ☰ 23.7. Reproducible Analysis
- ☰ 23.8. Version Control with Git
-
- ☰ 24. Final Project
- ☰ 24.1. Project Overview
- ☰ 24.2. Analyze a complete scientific dataset using ROOT.
- ☰ 24.3. Import the Data
- ☰ 24.4. Explore the Dataset
- ☰ 24.5. Apply Data Selection
- ☰ 24.6. Create Histograms
- ☰ 24.7. Fit the Data
- ☰ 24.8. Calculate Physical Quantities
- ☰ 24.9. Estimate Statistical Uncertainties
- ☰ 24.10. Create Publication-Quality Figures
- ☰ 24.11. Save the Analysis Results
- ☰ 24.12. Write a Short Analysis Report
-
- ☰ 25. Appendices
- ☰ 25.1. A. ROOT Command Cheat Sheet
- ☰ 25.2. B. ROOT Histogram Classes
- ☰ 25.3. C. ROOT Graph Classes
- ☰ 25.4. D. Common TTree Commands
- ☰ 25.5. E. Common Drawing Options
- ☰ 25.6. F. Common Fit Functions
- ☰ 25.7. G. ROOT C++ Cheat Sheet
- ☰ 25.8. H. PyROOT Cheat Sheet
- ☰ 25.9. I. Common ROOT Errors and Solutions
- ☰ 25.10. J. Recommended ROOT Analysis Workflow
-
Comments
Please login to add a comment.
Don't have an account? Register now!