KAHIBARO Bookshelves
Discord Login Register

24.7. Fit the Data

Choosing What to Fit

In the final project you already explored the dataset, created histograms and identified variables of interest. Before you start fitting, decide clearly which physical quantity you want to extract from the data. That choice determines which histogram, which range, and which model function you should use.

For example, if you study an invariant mass distribution that shows a clear peak on top of a smooth background, the natural choice is to fit the corresponding invariant mass histogram with a model that contains both a peak component and a background component. If you study a calibration spectrum, you might fit individual peaks to determine energy calibration parameters instead.

You should work with histograms that have sensible binning and ranges from the previous step. If a histogram is very sparse or dominated by empty bins, consider changing the binning and re-creating it. The quality of your fits depends strongly on whether the histogram represents the important structures in the data with enough statistics in each bin.

It is also useful to decide in advance which physical parameters you expect the fit to determine. Examples include a peak position that corresponds to a mass or energy, a width that reflects detector resolution, or a slope that describes an exponential falloff. Write these expectations down, they will guide both your choice of fit function and your interpretation of the result.

Always select a histogram and a variable that directly match the physical question you want to answer. Do not fit a distribution only because it looks smooth or has a peak.

Setting Up Fit Functions

ROOT uses function objects, usually TF1, to represent fit models. For the final project you will mostly use simple, standard models. A single peak can often be modeled with a Gaussian, background with a polynomial or exponential function, and more complex structures with combinations of these building blocks.

The most convenient approach is to start from ROOT’s built-in function forms. For a Gaussian peak you might use a TF1 like

cpp
TF1 *gausFunc = new TF1("gausFunc", "gaus", xmin, xmax);

where xmin and xmax define the range in which the function is valid. For a polynomial background of order 1 or 2 you might define

cpp
TF1 *polyFunc = new TF1("polyFunc", "pol1", xmin, xmax);

or

cpp
TF1 *polyFunc = new TF1("polyFunc", "pol2", xmin, xmax);

If your distribution clearly has both a peak and a background component, you can combine them into a single TF1 by writing a sum of terms in the expression, for example

cpp
TF1 *signalPlusBkg = new TF1("signalPlusBkg", "gaus(0) + pol1(3)", xmin, xmax);

Here the notation "gaus(0) + pol1(3)" means that the Gaussian uses parameters 0, 1, 2 and the polynomial uses parameters starting at index 3. This indexing becomes important when you read back the fit results.

For some parts of the project you might prefer a custom functional form. For instance, if you model a radioactive decay time distribution, an exponential function is appropriate:

cpp
TF1 *expoFunc = new TF1("expoFunc", "[0]*exp(-x/[1])", xmin, xmax);

In this expression [0] and [1] are parameters that ROOT will adjust during the fit. If algebraic expressions become too complicated, you can instead define a C++ function in your macro and build a TF1 from it, but for most final project analyses simple analytic strings are sufficient.

Whatever form you choose, keep the model as simple as possible while still describing the data. Fitting with too many free parameters can hide physical insight and produce unstable results, especially when the dataset has limited statistics.

Choose the simplest function that can reasonably describe the physical shape of your distribution in the chosen range. Avoid overcomplicated models with unnecessary free parameters.

Choosing Fit Ranges and Initial Parameters

The most common reasons for a difficult or failed fit are a poor choice of fit range and unrealistic starting values for the parameters. You can avoid most problems by setting these carefully using what you learned from visually inspecting the histogram.

To set the fit range, look at the plotted histogram and find the region where your model should be valid. For a narrow resonance peak, this is typically a limited window around the peak where the shape is approximately Gaussian and the background is smooth. You might exclude very low and high values where other effects distort the distribution. When you construct the TF1 you should already reflect this choice by the range you pass to the constructor, for instance

cpp
TF1 *peak = new TF1("peak", "gaus", 0.45, 0.55);

for a peak near 0.5 in your chosen units.

Good initial parameters help the minimizer converge quickly and reliably. You can often estimate them by eye from the plot. For a Gaussian,
$$
f(x) = A \exp\left( -\frac{(x - \mu)^2}{2\sigma^2} \right),
$$
you can approximate $A$ by the peak height, $\mu$ by the position of the maximum, and $\sigma$ by the approximate half-width of the peak divided by a factor of about $1.2$. In ROOT, for the built-in Gaussian, you would set

cpp
gausFunc->SetParameters(ampGuess, meanGuess, sigmaGuess);

Similarly, for an exponential decay,
$$
f(x) = N \exp(-x / \tau),
$$
you can estimate $N$ from the value of the first bin in your fit range and $\tau$ from a rough visual slope.

You can also place reasonable constraints on parameters with SetParLimits(index, min, max) to avoid unphysical values such as negative widths or negative variances. For example, ensuring $\sigma > 0$ or a lifetime parameter $\tau > 0$ stabilizes the fit.

Some histograms might have a long tail, multiple peaks, or very low statistics in certain regions. In these situations, carefully adjust both the range and the constraints to focus the fit on the relevant structure. It is often better to fit a narrow window around a main peak very well than to attempt a poorer fit over a wide region that includes several unrelated features.

Always set the fit range and initial parameters using information from the plotted histogram. Never rely solely on default values.

Performing Fits on Project Histograms

Once you have a histogram and a TF1 with defined range and initial parameters, you are ready to perform the fit. In the final project most fits will be done directly on TH1 objects created earlier in the analysis.

The basic pattern in a macro or ROOT session is:

  1. Draw the histogram on a canvas to check its shape.
  2. Define a TF1 with the chosen function, range, and initial parameters.
  3. Call the histogram’s Fit method.
  4. Inspect both the numerical output and the graphical overlay.

A typical code fragment looks like this:

cpp
TCanvas *c1 = new TCanvas("c1", "Fit example", 800, 600);
hMass->Draw();  // hMass is the histogram you created earlier
TF1 *fitFunc = new TF1("fitFunc", "gaus", 0.45, 0.55);
fitFunc->SetParameters(1000, 0.50, 0.01);  // amplitude, mean, sigma
hMass->Fit(fitFunc, "R");  // "R" enforces the TF1 range
c1->Update();

The "R" option tells ROOT to use the range defined in the TF1, which keeps the fit within the intended window. Other useful options include "Q" to suppress detailed output in batch scripts, "S" to return a TFitResultPtr object, and "0" to fit without immediately drawing. In the project context you will usually want at least to see the fit curve on the histogram as part of your sanity checks.

For more complex shapes one common final project task is to fit a signal on top of a background. This requires a combined function such as a Gaussian plus a polynomial, defined as described earlier. You set initial parameters for both parts and again call Fit:

cpp
TF1 *sigBkg = new TF1("sigBkg", "gaus(0) + pol1(3)", 0.4, 0.6);
// Set Gaussian parameters 0,1,2
sigBkg->SetParameter(0, peakAmpGuess);
sigBkg->SetParameter(1, peakMeanGuess);
sigBkg->SetParameter(2, peakSigmaGuess);
// Set polynomial parameters 3,4
sigBkg->SetParameter(3, offsetGuess);
sigBkg->SetParameter(4, slopeGuess);
hMass->Fit(sigBkg, "R");

In some parts of your project you might also fit graphs rather than histograms, for instance if you calibrate detector response by plotting measured peak positions versus known energies. The procedure is analogous, but you call graph->Fit instead of hist->Fit. The interpretation of parameters works in the same way.

You should run fits inside macros that are part of your project codebase, not purely interactively, so that you can reproduce them easily and keep track of the exact fit options and models used.

Use hist->Fit() or graph->Fit() inside your project macros with clearly defined TF1 objects, explicit fit ranges, and documented options. This makes your fits reproducible and easier to debug.

Extracting Physical Parameters from Fits

After the fit converges, the key step for the final project is to translate the fit parameters into physical quantities. ROOT stores the fitted values in the TF1 object, and you can access them with GetParameter(index) for the central value and GetParError(index) for the uncertainty.

For a Gaussian peak, the standard parametrization in ROOT is:

  • Parameter 0: amplitude $A$,
  • Parameter 1: mean $\mu$,
  • Parameter 2: standard deviation $\sigma$.

If the peak corresponds to a physical mass or energy, the mean gives you the measured value. You can then write in your macro:

cpp
double mean  = fitFunc->GetParameter(1);
double emean = fitFunc->GetParError(1);

and store or print these values for later use in your report. The width parameter can represent detector resolution or the intrinsic width of a resonance, depending on the context. You retrieve it in the same way:

cpp
double sigma  = fitFunc->GetParameter(2);
double esigma = fitFunc->GetParError(2);

For a calibration fit of the form
$$
E_{\text{true}} = p_0 + p_1 \, C,
$$
where $C$ is a measured channel value and $E_{\text{true}}$ is the physical energy, a linear fit returns $p_0$ and $p_1$ as the intercept and slope. These become your calibration constants. In code, for a fit function defined as "pol1", you typically use:

cpp
double p0  = calibFunc->GetParameter(0);
double ep0 = calibFunc->GetParError(0);
double p1  = calibFunc->GetParameter(1);
double ep1 = calibFunc->GetParError(1);

You can then use these parameters in subsequent calculations to convert raw measurements into calibrated physical quantities elsewhere in the analysis.

For exponential fits to lifetimes or attenuation lengths, the relevant parameter is often the characteristic time or length, for example $\tau$ in an expression like
$$
f(t) = N \exp(-t / \tau).
$$
You extract $\tau$ and its error and interpret them according to the experimental context.

Always connect each parameter to a defined physical meaning before reporting it. Do not list all fit parameters blindly. In your final project you should focus on the specific quantities that answer your main physics question, such as a mass, an energy scale, a decay constant, or a resolution.

Use GetParameter() and GetParError() to extract only those parameters that have a clear physical interpretation in your analysis. Always state what each parameter represents.

Using Fit Results for Uncertainties and Plots

The fit not only provides central values for parameters, it also gives you their statistical uncertainties. These uncertainties are essential for the later steps of the project, where you estimate statistical uncertainties and create publication-quality figures.

The standard uncertainties on parameters come directly from GetParError(index). You will use them when you quote final results and when you propagate errors to derived quantities. For example, if your main result is a mass $m$ from a Gaussian mean and you later correct it using a calibration factor $k$, you should combine the corresponding uncertainties to obtain a realistic total error. The detailed methods for error propagation are discussed elsewhere, but you should already ensure that the basic parameter errors from the fit are correctly recorded and stored.

It is good practice to save the fitted function objects alongside your histograms inside ROOT files, so that you can redraw them later without repeating the fit. You can write both the histogram and the TF1 to an output TFile, which keeps a complete record of your analysis state at the end of the fit step.

On the plotting side, you should make sure that your final figures clearly show the data and the fit curve together. This means drawing the histogram with appropriate marker or fill styles and overlaying the fit function as a line with a contrasting color and line width. For example:

cpp
hMass->SetMarkerStyle(20);
hMass->SetMarkerColor(kBlack);
hMass->Draw("E");       // draw with error bars
fitFunc->SetLineColor(kRed);
fitFunc->SetLineWidth(2);
fitFunc->Draw("SAME");

If you plan to display residuals or to annotate the plot with parameter values, you can use TLatex or TText in the plotting chapter of the project. From the fitting perspective, you should make sure that the fit curve is visually consistent with the data in the fit range and that important features like the peak position and width are well captured.

When preparing figures for the report, it is helpful to add the fit model and key parameter values, including uncertainties, in the legend or as text on the plot. This allows readers to see immediately what function was used and what the main quantitative result is.

Always carry forward both fitted parameter values and their uncertainties, and ensure that your final plots show data and fit curves together in a clear, readable way.

Documenting Fit Choices for the Report

Fitting is an interpretive step. Two analysts could choose different fit ranges or models and obtain slightly different results. To make your final project scientifically sound, you must document your choices and keep them consistent between the analysis code and the written report.

In your macros, use clear function names and comments that describe what each fit does, for example:

cpp
// Fit invariant mass peak to extract particle mass and resolution
TF1 *massFit = new TF1("massFit", "gaus(0)+pol1(3)", 0.4, 0.6);

Record in a log or in comments which options you used in Fit, what initial parameters you chose, and any parameter limits you set. When you refine a fit, update the comments and keep older versions under version control instead of deleting them.

When you reach the report-writing stage, you should be able to state succinctly:

  • Which variable you fitted, and which histogram or graph was used.
  • Which model function you chose and why it is appropriate.
  • What fit range you used and why you restricted it as you did.
  • Which fit parameters are interpreted physically and what values with uncertainties you obtained.

Keeping your fitting strategy explicit at this stage of the project will make it much easier to justify your results in the later chapter on calculating physical quantities and in the final analysis report.

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