15.4. Data Calibration
Table of Contents
Calibration constants
In many real experiments the raw numbers recorded by detectors are not yet expressed in meaningful physical units. An ADC channel value, a time-to-digital count, or a pixel intensity must be converted to quantities such as energy, time, or position. This conversion is called calibration, and the numerical factors you determine to perform it are the calibration constants.
In a ROOT-based analysis, calibration constants are typically obtained from special calibration runs, test pulses, or well known reference signals. For example, a scintillator coupled to a photomultiplier tube might be exposed to gamma rays of known energies, or a time detector might be illuminated with a pulser that has a precise repetition period. From these reference data, you extract a relationship between the raw measurement and the physical quantity.
It is useful to distinguish between different types of calibration constants. A common minimal set consists of an offset and a gain factor. The offset describes the value your detector reports when the true quantity is zero. The gain describes how much the detector response changes when the true quantity increases by one unit. For some detectors you also need non-linear terms or separate constants for different regions or channels.
In ROOT, calibration constants often appear as C++ variables, configuration parameters read from text files, or stored objects in a ROOT file. A typical workflow is to determine the constants once in a dedicated calibration macro, write them to a file, then read that file in all later analysis steps. This ensures that all your histograms, fits, and derived quantities use a consistent calibration.
When dealing with many channels, for example in a multi-strip detector or a calorimeter with many cells, you usually have a separate set of calibration constants per channel. This can be stored in arrays, std::vector objects, or even in a TTree or TTree friend. ROOT provides enough flexibility to apply channel-specific calibrations efficiently in event loops or RDataFrame expressions.
Calibration constants also have uncertainties. These uncertainties propagate into the final physics results. While a full treatment of uncertainty propagation belongs to statistical analysis, you should already keep in mind that poorly determined calibration constants can dominate the total error budget. Refining calibration, checking stability over time, and comparing different calibration methods are important quality checks in real data analysis.
A basic linear calibration from a raw value $x_{\text{raw}}$ to a calibrated value $x_{\text{cal}}$ uses two constants:
$$x_{\text{cal}} = a \, x_{\text{raw}} + b$$
Here $a$ is the gain (slope) and $b$ is the offset (intercept). These constants must be determined from calibration data and then applied consistently to all measurements.
Linear calibration
The simplest and most widely used calibration model assumes a linear relationship between the raw detector output and the physical quantity of interest. Under this assumption, the detector behaves like an ideal ruler: equal steps in the true quantity produce equal steps in the recorded value. In ROOT, linear calibration is very convenient to implement, because you can work directly with simple formulas, TF1 functions, and straight-line fits.
Suppose you perform a calibration run and obtain several pairs of values $(x_{\text{raw}}, x_{\text{true}})$, where $x_{\text{true}}$ is a known reference. You want to find $a$ and $b$ such that $x_{\text{true}} \approx a x_{\text{raw}} + b$. To do this in ROOT, you can create a TGraph with the raw value on one axis and the known true value on the other, then fit it with a linear function. For example, a TF1 defined with the expression "[0]*x + [1]" has parameter [0] as the slope and [1] as the intercept. After fitting, you read these parameters and use them as your calibration constants.
Alternatively, when your calibration information appears as identifiable peaks in a histogram, you may proceed in two steps. First, fit each peak with an appropriate function, often a Gaussian, to extract its peak position in raw units. Second, match each raw peak position to the known physical value and again fit a straight line through the set of points. This is very common in spectroscopic calibration tasks.
The linear model itself is simple to apply in analysis code. Once the slope and intercept are known, you can define a new variable in a ROOT macro or RDataFrame expression that computes $x_{\text{cal}}$ event by event. In traditional event loops, this often appears as a per-entry calculation inside the loop, followed by filling histograms with the calibrated quantity instead of the raw one. In RDataFrame, you can use Define to create a calibrated column that is then used for histograms or further processing.
Despite its simplicity, linear calibration requires careful validation. You should check that the residuals $x_{\text{true}} - x_{\text{cal}}$ are small and show no systematic structure across the calibration range. If you see significant curvature, or if different regions of the detector behave differently, a purely linear model might be insufficient. In that case, you may need piecewise linear calibration or higher-order polynomial terms, which go beyond the strict linear assumption.
In many practical situations, the detector response is approximately linear over the range of interest, so a straight-line calibration is entirely adequate. For beginners, focusing on a robust linear calibration is an excellent starting point for turning real experimental data into physically meaningful quantities.
The key rule for linear calibration in ROOT is:
- Determine $a$ and $b$ from calibration data, usually by fitting.
- Apply $x_{\text{cal}} = a x_{\text{raw}} + b$ to every event.
- Use $x_{\text{cal}}$ in all physics histograms and fits, not the raw $x_{\text{raw}}$.
Skipping the third step, and accidentally mixing calibrated and uncalibrated values, is a common and serious analysis mistake.
Energy calibration
Energy calibration is a specific and very common application of the general calibration idea. Many detectors, such as scintillators, semiconductor detectors, calorimeters, and HPGe crystals, measure signals that are proportional to the energy deposited by particles or photons. However, the raw quantity is often an ADC channel or integrated charge, not energy in keV or MeV. To interpret your spectra physically, you must convert channel numbers to energy through an energy calibration.
A typical energy calibration uses well known lines from radioactive sources. For example, you might record a gamma spectrum from a source with prominent peaks at known energies. In the raw histogram, each peak appears at some channel value. By fitting these peaks, you obtain their centroids in channel units. Each centroid then forms a calibration point that links a raw channel to a precise energy. Once you have several such points, you can fit a linear function $E = a C + b$ where $E$ is the energy and $C$ is the channel number.
ROOT provides all the necessary tools to implement this procedure. You can use TH1 histograms to hold the raw spectrum, TF1 functions to fit the peaks, and TGraph or direct TF1 fitting to determine the global calibration. After you have found the slope and offset of the energy calibration, you can either convert the axis of an existing histogram or, more commonly in real analyses, recompute and refill histograms using energy instead of channel in event-based processing.
In practice, energy calibration may depend on detector channel, time, or operating conditions. For multi-channel systems, each channel gets its own pair of energy calibration constants, stored for example in arrays indexed by channel number. During event loops or in RDataFrame, you take the channel-specific calibration constants and apply them to each event entry. ROOT handles large numbers of channels easily, so it is mainly up to you to organize the constants clearly and apply them consistently.
An energy calibration is only useful if you know its quality. After applying the calibration, you should check that the known lines in a validation spectrum appear at the correct energies, and that any residual shifts are within acceptable limits. For more precise work you might include non-linear terms in the calibration function, but for many beginners' experiments a simple linear calibration is appropriate over the region of interest.
Once the energy calibration is established, it becomes central to later analysis steps such as peak identification, energy resolution studies, and determination of physical quantities like Q-values or excitation energies. All subsequent physics results drawn from spectra are meaningful only because the association between channel and energy has been calibrated and verified.
For a linear energy calibration the central formula is:
$$E = a \, C + b$$
where $C$ is the measured channel number, $E$ is the calibrated energy, $a$ is the energy per channel, and $b$ is the energy offset. Always perform physics interpretations, such as identifying lines or computing Q-values, using $E$, not the raw channel $C$.
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!