KAHIBARO Bookshelves
Discord Login Register

13.9. Branch Addresses

`SetBranchAddress()`

To do low level work with TTrees you often need to read branch data entry by entry inside your own event loop. The central tool for this in C++ ROOT is the member function TTree::SetBranchAddress(). It tells the tree where in memory it should copy the data of a given branch when you call GetEntry().

Conceptually, a branch in a TTree holds a column of values, one value per entry. When you call:

cpp
tree->SetBranchAddress("branchName", &variablePointer);

you are giving ROOT the address of a variable or object, and ROOT promises to fill it with the content of branchName whenever you read an entry.

SetBranchAddress() does not copy data immediately.
The data are copied only when you call GetEntry(entryIndex).
Also, the pointer or variable you pass must stay valid for the entire time you read entries.

The typical steps are:

  1. Declare variables (or pointers) that will receive the data.
  2. Call SetBranchAddress() once for each branch.
  3. Loop over entries and call GetEntry(i) in the loop.
  4. Use the now filled variables for your analysis.

A minimal example for simple numeric branches looks like this:

cpp
TFile *f = TFile::Open("data.root");
TTree *t = (TTree*)f->Get("tree");
// Variables to hold branch data
Float_t energy;
Int_t   charge;
// Connect branches to variables
t->SetBranchAddress("energy", &energy);
t->SetBranchAddress("charge", &charge);
// Now you can loop over entries and use energy, charge

Here the branch "energy" is assumed to store a floating point value compatible with Float_t and "charge" an integer compatible with Int_t. ROOT will automatically convert between some compatible numeric types, but the safest approach is to match the exact type used when the tree was written.

You can check the structure and types with:

cpp
t->Print();

and adapt your receiving variables accordingly.

When branches contain C arrays, you provide a pointer to the first element of the array. For example:

cpp
Int_t    nHits;
Float_t  hitE[100];
// "nHits" is the number of hits in this event
t->SetBranchAddress("nHits", &nHits);
t->SetBranchAddress("hitE",  hitE);

In this case each entry may have a different number of active elements, up to the maximum that was used when the tree was created. Typically the branch definition encodes this, such as hitE[nHits]/F. When reading, you always provide the full array and use nHits to know how many elements are valid for a given entry.

For branches that store objects, particularly std::vector<T> branches, you provide a pointer to a pointer. A common pattern is:

cpp
std::vector<float> *pt = nullptr;
t->SetBranchAddress("pt", &pt);

After GetEntry(i), pt points to a vector owned by the tree entry, and you can access its contents like a normal std::vector<float>.

When using SetBranchAddress():

  1. Use the correct C++ type for each branch.
  2. Do not let the receiving variables go out of scope while reading.
  3. For std::vector branches, use a pointer to a pointer, for example std::vector<float> *v = nullptr; and pass &v.
  4. Always call GetEntry(entry) before using the variables for that entry.

For more advanced use cases, SetBranchAddress() has overloads that allow you to work directly with a TBranch * object, or to specify custom TClass and TBranch addresses, but for typical beginner analysis the simple name plus address form is sufficient.

Reading data manually

Once branch addresses are connected, you can manually drive the event loop and process your data entry by entry. This gives you full control over the flow of analysis, conditional logic, and interaction with histograms or other objects.

The skeleton of a manual reading loop is always the same:

  1. Obtain the number of entries using GetEntries().
  2. Loop over the entry index from 0 to nEntries - 1.
  3. Call GetEntry(i) inside the loop to load that entry’s data into your variables.
  4. Use the variables to perform calculations and fill histograms or graphs.

A typical example for a tree with simple scalar branches might look like this:

cpp
TFile *f = TFile::Open("data.root");
TTree *t = (TTree*)f->Get("tree");
// Variables to be filled
Float_t energy;
Int_t   charge;
// Connect branches
t->SetBranchAddress("energy", &energy);
t->SetBranchAddress("charge", &charge);
// Prepare some histograms
TH1F *hEnergy = new TH1F("hEnergy", "Energy;E;Entries", 100, 0.0, 10.0);
TH1F *hCharge = new TH1F("hCharge", "Charge;Q;Entries", 5, -2.5, 2.5);
// Event loop
Long64_t nEntries = t->GetEntries();
for (Long64_t i = 0; i < nEntries; ++i) {
    t->GetEntry(i);            // fills energy and charge
    // Apply a simple selection
    if (energy > 0.5) {
        hEnergy->Fill(energy);
    }
    hCharge->Fill(charge);
}

Within the loop, after GetEntry(i), the variables energy and charge contain the values for entry i. You can apply arbitrary logic, combine values, and pass results to other functions.

For branches with variable length arrays, you use the companion size variable to know how many elements to loop over for each entry:

cpp
Int_t   nHits;
Float_t hitE[100];
t->SetBranchAddress("nHits", &nHits);
t->SetBranchAddress("hitE",  hitE);
TH1F *hHitE = new TH1F("hHitE", "Hit energies;E;Hits", 100, 0, 5);
Long64_t nEntries = t->GetEntries();
for (Long64_t i = 0; i < nEntries; ++i) {
    t->GetEntry(i);
    for (Int_t j = 0; j < nHits; ++j) {
        hHitE->Fill(hitE[j]);
    }
}

For branches storing std::vector objects, the pattern is similar but you treat the variable as a pointer to a vector. The tree will manage the underlying vector allocation:

cpp
std::vector<float> *pt  = nullptr;
std::vector<float> *eta = nullptr;
t->SetBranchAddress("pt",  &pt);
t->SetBranchAddress("eta", &eta);
TH1F *hPt  = new TH1F("hPt",  "Transverse momentum;p_{T};Entries", 100, 0, 100);
TH1F *hEta = new TH1F("hEta", "Pseudorapidity;#eta;Entries", 60, -3, 3);
Long64_t nEntries = t->GetEntries();
for (Long64_t i = 0; i < nEntries; ++i) {
    t->GetEntry(i);
    const std::size_t n = pt->size();
    for (std::size_t j = 0; j < n; ++j) {
        hPt->Fill(pt->at(j));
        hEta->Fill(eta->at(j));
    }
}

Here, after each GetEntry(i), the pointers pt and eta refer to vectors filled with the particle transverse momentum and pseudorapidity for that event. You access them like any standard vector.

Manual reading has several important implications and advantages.

First, you control which branches you actually read. If you are interested in only a few branches, you can disable others to speed up I/O and reduce memory usage:

cpp
t->SetBranchStatus("*", 0);          // disable all
t->SetBranchStatus("energy", 1);     // enable only what you need
t->SetBranchStatus("charge", 1);

You then call SetBranchAddress() only for the enabled branches that you need.

Second, you can embed complex selection and computation logic in your loop. You can compute derived quantities, build new observables from several branches, and apply multi step cuts that would be awkward to express as a single selection string.

For example, computing a derived quantity from two branches:

cpp
Float_t px, py;
t->SetBranchAddress("px", &px);
t->SetBranchAddress("py", &py);
TH1F *hPt = new TH1F("hPt", "p_{T};p_{T};Entries", 100, 0, 100);
Long64_t nEntries = t->GetEntries();
for (Long64_t i = 0; i < nEntries; ++i) {
    t->GetEntry(i);
    Float_t pt = std::sqrt(px*px + py*py);  // derived quantity
    hPt->Fill(pt);
}

Third, manual reading is the foundation for more advanced workflows, such as mixing data from several trees, performing complex event selection, or integrating with external libraries. Even if later you move to higher level interfaces, understanding manual reading with SetBranchAddress() will help you reason about performance, memory usage, and the true structure of your data.

Views: 0

Comments

Please login to add a comment.

Don't have an account? Register now!

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