KAHIBARO Bookshelves
Discord Login Register

14.4. Derived Quantities

Calculating new observables

In event based analysis you rarely use only the raw variables stored in a TTree. Instead, you construct new observables that better describe the physics you care about or simplify later selections and plots. These new quantities are calculated event by event, inside the same loop where you read the input branches.

A derived quantity is any value computed from existing event variables. Examples in simple analyses might include the sum or difference of energies from two detectors, the magnitude of a 2D position from its $(x, y)$ coordinates, or the ratio of two measured quantities such as $E / p$. In more advanced particle physics analyses you might compute transverse momentum, invariant mass, missing energy, or angular separations, but those topics are covered in dedicated later chapters.

The basic pattern to compute a new observable in a traditional event loop is:

  1. Read the input branches for the current event.
  2. Use C++ expressions to compute the derived variable.
  3. Use the derived variable immediately, for example to fill a histogram or to apply a selection, or store it for later use.

A minimal event loop that calculates a new observable might look like this:

cpp
TTree *tree = (TTree*)file->Get("Events");
float E1, E2;
tree->SetBranchAddress("E1", &E1);
tree->SetBranchAddress("E2", &E2);
TH1F *hESum = new TH1F("hESum", "Total energy;E_{1}+E_{2};Events", 100, 0, 10);
Long64_t nEntries = tree->GetEntries();
for (Long64_t i = 0; i < nEntries; ++i) {
    tree->GetEntry(i);
    float E_sum = E1 + E2;
    hESum->Fill(E_sum);
}

Here E_sum is a new observable that is not stored in the original TTree but is computed for each event from two existing branches.

You can also create new branches in a new TTree or in a snapshot that store these derived observables. This is useful when the same derived quantity is used in many later analyses, or when you want to decouple heavy calculations from light plotting jobs. A simple pattern is:

cpp
TFile *fin  = TFile::Open("input.root");
TTree *tin  = (TTree*)fin->Get("Events");
float E1, E2;
tin->SetBranchAddress("E1", &E1);
tin->SetBranchAddress("E2", &E2);
TFile *fout = TFile::Open("output.root", "RECREATE");
TTree *tout = new TTree("Events", "Events with derived quantities");
float E_sum;
tout->Branch("E_sum", &E_sum, "E_sum/F");
Long64_t nEntries = tin->GetEntries();
for (Long64_t i = 0; i < nEntries; ++i) {
    tin->GetEntry(i);
    E_sum = E1 + E2;
    tout->Fill();
}
fout->Write();
fout->Close();

Now E_sum is a first class variable stored as a branch in a ROOT file, so any later analysis can read it directly.

In modern ROOT, RDataFrame offers a more concise way to define new observables without writing explicit loops. The Define method creates a new column from existing columns:

cpp
ROOT::RDataFrame df("Events", "input.root");
auto df2 = df.Define("E_sum", "E1 + E2");
auto hESum = df2.Histo1D({"hESum", "Total energy;E_{1}+E_{2};Events", 100, 0, 10}, "E_sum");

Here E_sum behaves like a virtual branch. It is computed when needed, for example when filling hESum, but does not require you to manage memory or loops explicitly.

Whenever you design new observables, pay attention to their physical meaning and units. Clearly name them to avoid confusion. For instance, prefer E_sum or E_total over x1, and keep consistent notation such as pT, eta, phi for kinematic variables. Also be aware of domains where formulas are meaningful, for example avoid divisions by zero and invalid arguments to functions such as sqrt or log.

Always check that your derived quantities are defined for all relevant events. Protect against divisions by zero, negative values inside sqrt, or probabilities outside the interval $[0, 1]$. Invalid inputs often lead to nan values and subtle analysis bugs.

Combining branches

Many derived observables are built by combining two or more branches from the TTree. Conceptually, this is simple: you read several related variables for each event and use them together to form new quantities such as sums, differences, products, ratios, angles, or magnitudes.

At the simplest level, combining branches is just writing C++ expressions that involve multiple variables. For example, if your tree stores Cartesian coordinates x and y for each hit, the radial distance from the origin is:

$$
r = \sqrt{x^2 + y^2}.
$$

In an event loop this becomes:

cpp
float x, y;
tree->SetBranchAddress("x", &x);
tree->SetBranchAddress("y", &y);
TH1F *hR = new TH1F("hR", "Radial distance; r; Events", 100, 0, 100);
for (Long64_t i = 0; i < tree->GetEntries(); ++i) {
    tree->GetEntry(i);
    float r = std::sqrt(x * x + y * y);
    hR->Fill(r);
}

Sometimes the combination involves a simple algebraic operation such as sum or difference. Other times it may involve more complex formulas, for example time of flight from two detector times, or an energy asymmetry defined as:

$$
A = \frac{E_1 - E_2}{E_1 + E_2}.
$$

The C++ code is directly parallel to the formula:

cpp
float E1, E2;
tree->SetBranchAddress("E1", &E1);
tree->SetBranchAddress("E2", &E2);
TH1F *hAsym = new TH1F("hAsym", "Energy asymmetry;A;Events", 100, -1, 1);
for (Long64_t i = 0; i < tree->GetEntries(); ++i) {
    tree->GetEntry(i);
    float denom = E1 + E2;
    if (denom == 0) continue;
    float A = (E1 - E2) / denom;
    hAsym->Fill(A);
}

The same idea extends to more complicated structures such as arrays or std::vector branches, which are discussed in detail in later chapters. For example, you might combine all hits in an event by summing over a vector:

cpp
std::vector<float> *E_hits = nullptr;
tree->SetBranchAddress("E_hits", &E_hits);
TH1F *hETotal = new TH1F("hETotal", "Total hit energy;E_{total};Events", 100, 0, 20);
for (Long64_t i = 0; i < tree->GetEntries(); ++i) {
    tree->GetEntry(i);
    float E_total = 0.0;
    for (float E : *E_hits) {
        E_total += E;
    }
    hETotal->Fill(E_total);
}

In RDataFrame, combining branches becomes a matter of declaring the expression in Define. For the asymmetry above you can write:

cpp
ROOT::RDataFrame df("Events", "input.root");
auto df2 = df.Define("A", "((E1 - E2) / (E1 + E2))");
auto hAsym = df2.Filter("E1 + E2 != 0")
                .Histo1D({"hAsym", "Energy asymmetry;A;Events", 100, -1, 1}, "A");

You can chain several Define calls to build observables step by step, which often makes the code easier to read:

cpp
auto df2 = df.Define("E_sum", "E1 + E2")
             .Define("E_diff", "E1 - E2")
             .Define("A", "E_diff / E_sum");

When combining branches, make sure that the variables you use are consistently defined for each event. For example, if some events have missing measurements or sentinel values, you may want to skip them or repair them before using them in derived formulas. Also, sometimes a combination is meaningful only within a particular physical region. In such cases, pair the calculation with a selection cut that restricts the analysis to the valid domain.

Finally, consider storing frequently used combinations as new branches or in a separate processed TTree. This can greatly simplify later analyses. For example, you might create a reduced tree that contains only high level quantities such as total energy, asymmetries, or event categories, and use that tree for fast plotting and fitting.

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