4.4. Inspecting ROOT Objects
Table of Contents
`Print()`
To understand what is inside a ROOT object, the first tool you will use is the Print() method. Almost every ROOT class inherits from TObject, so it usually provides its own version of Print(). This makes Print() a universal way to inspect an object from the command line or from a macro.
You call it with the usual C++ method syntax. For example, if you have a histogram:
TH1F *h = new TH1F("h", "Example", 100, 0, 1);
h->Fill(0.3);
h->Fill(0.7);
h->Print();ROOT prints a short summary that depends on the class. For a histogram this includes the name and title, number of bins, statistics such as the number of entries, and sometimes the memory address. For other objects, such as graphs or trees, it prints an overview of their internal content.
Many classes support an optional argument to Print() that switches between summary and detailed output. The exact strings are class specific, but you will often see patterns like:
h->Print("all"); // more detailed info for some classes
tree->Print(); // summary of branches
tree->Print("*"); // list of branches and leaves in detail
If you are not sure what a particular object holds, or you have just retrieved it from a file and want to check that it is the right one, Print() is the quickest textual inspection tool.
Always use Print() when you want a fast textual summary of a ROOT object. It is safe, does not modify the object, and works for almost all classes.
`Draw()`
Where Print() gives text, Draw() gives you a graphical representation. Many ROOT objects can represent themselves visually: histograms as binned distributions, graphs as sets of points, trees as projected variables, functions as curves, and so on. For such classes, Draw() is the standard way to send the object to a TCanvas.
The simplest usage is just:
h->Draw();
If there is no current canvas, ROOT creates one automatically and draws the histogram. If a canvas already exists, ROOT draws into the current pad. Repeating Draw() updates the same pad unless you change to a different one.
Most drawable classes accept an optional string argument that controls the drawing style or options:
h->Draw("E"); // draw histogram with error bars
gr->Draw("AP"); // TGraph: axes and points
tree->Draw("x"); // draw a 1D histogram of branch "x"
The list of available options depends on the class, and later chapters will describe them in detail. In the context of inspecting objects, the important point is that Draw() is often the fastest way to get an intuitive feel for the content. For example, if you open a file and retrieve an unknown histogram:
TH1 *h = (TH1*)f->Get("some_hist");
h->Draw();you immediately see its distribution and range, and you can interact with it in the canvas, check axes, zoom, or open the statistics box.
If you draw several objects, inspect their overlay with the "SAME" option:
h1->Draw();
h2->Draw("SAME");This is useful to compare their shapes during an interactive session.
Use Draw() whenever you need a quick visual check of an object. It does not permanently change the data, but it helps you spot obvious problems such as empty histograms, wrong units, or unexpected ranges.
`ClassName()`
ROOT uses a rich class hierarchy, so it is common to encounter pointers or references to base classes such as TH1, TObject, or TNamed, while the actual object is of a more specific derived type. The ClassName() method tells you the dynamic type of the object at runtime.
For any TObject *obj, you can ask:
cout << obj->ClassName() << endl;This prints the name of the real class, for example:
TH1F
TGraphErrors
TTree
TDirectoryFileThis is especially useful when you retrieve objects from a file or a collection without knowing their exact type in advance:
TObject *obj = f->Get("my_object");
obj->Print();
cout << "Class is: " << obj->ClassName() << endl;Once you know the class, you can decide how to cast it correctly and which methods make sense:
if (strcmp(obj->ClassName(), "TH1F") == 0) {
TH1F *h = (TH1F*)obj;
h->Draw();
}
You will use ClassName() frequently when exploring unfamiliar files or debugging code that manipulates generic TObject pointers.
ClassName() always reports the true dynamic type of a ROOT object, not just the static type of the pointer. Use it to confirm what kind of object you are dealing with before casting or calling class-specific methods.
ROOT object browser
ROOT also provides a graphical object browser to explore files, directories, canvases, and objects interactively. You start it from the ROOT prompt with:
new TBrowser();This opens a window with a tree-like view on the left and a display area on the right. The browser can show:
- ROOT files and their internal directory structure
- TTrees, histograms, graphs, functions, and other objects
- Open canvases and the objects drawn on them
When you click on a .root file in the browser, ROOT opens it and shows its contents as a hierarchy of directories and objects. Clicking on an object usually triggers a default action, for example drawing a histogram in a new canvas. Right-clicking gives a context menu with operations such as Draw, Inspect, Dump, or Print.
The browser is particularly helpful when you are not sure what is stored in a file. Instead of writing code, you can:
- Start ROOT.
- Create a
TBrowser. - Navigate to your file and click to open it.
- Inspect object names, types, and quickly draw them.
You can also inspect canvases and pads. If a canvas is open, it will appear in the browser, and expanding it shows the individual primitives that have been drawn. This helps you understand how a complicated plot is built from histograms, graphs, and text objects.
Although the object browser is a graphical tool, it is tightly connected to the same inspection methods described above. For many objects, the context menu entries internally call methods like Draw() or Print(). You can use it as a visual companion to your command line exploration.
Use the ROOT object browser as an interactive map of your ROOT environment. It lets you explore files, objects, and canvases without writing code, and complements Print(), Draw(), and ClassName() for quick inspection.
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!