12.2. Creating ROOT Files
Table of Contents
TFile
To create a ROOT file you always start with the class TFile. A TFile object represents an open .root file that can contain histograms, graphs, functions, TTrees, and even subdirectories. Once you understand how to create and control a TFile, saving and organizing analysis results becomes straightforward.
At the simplest level you create a file by constructing a TFile object with a filename and a mode string. The filename should usually end with .root, and can be either a relative path such as "results.root" or an absolute path such as "/home/user/analysis/results.root".
A minimal example in an interactive ROOT session looks like this:
TFile f("myoutput.root", "RECREATE");
When this line runs, ROOT opens (or creates) the file on disk and associates it with the variable f. As long as f is alive and the file is open, you can write objects into it using methods such as Write() on the objects you create, or f.Write() to write everything that is attached to the current file or its directories.
You can also create a file using the static function TFile::Open, which returns a pointer:
TFile *f = TFile::Open("myoutput.root", "RECREATE");This form is common in macros and in larger analysis code, because you can later check whether the pointer is valid and whether the file was opened correctly.
A useful pattern when you want to immediately write something after creating the file is:
TFile *f = TFile::Open("histos.root", "RECREATE");
// create objects here (for example histograms) and write them
h1->Write();
h2->Write();
// close the file when done
f->Close();
Closing the file is important. When you call Close(), ROOT flushes all buffers and ensures the file is complete and readable later. If you forget to close a file in a macro, it will usually be closed automatically when the process exits, but it is good practice to close explicitly, especially when you write many files or when your program continues running after writing.
You can check if a TFile is open and good by using methods such as:
if (!f || f->IsZombie()) {
// handle error: file could not be opened or created
}This kind of check is useful if a filename may not be writable, or if you open remote files.
For writing analysis output it is common to create the file once at the beginning of your macro, then create all histograms and other objects, fill them during your event loop, and finally write and close the file at the end. The details of writing objects and the role of TDirectory are covered in later sections of this ROOT Files chapter.
Always ensure that each output TFile is explicitly closed with Close() once all objects have been written, to avoid incomplete or corrupted ROOT files.
File modes
The second argument to the TFile constructor or to TFile::Open is the file mode string. This short code tells ROOT whether to create a new file, overwrite an existing one, or open a file only for reading. Using the correct mode is essential to protect your data and to control how analysis output is updated.
The most common modes are summarized in the table below:
| Mode string | Meaning | Typical use |
|---|---|---|
"READ" | Open an existing file for reading only | Inspecting or analyzing existing data files |
"UPDATE" | Open an existing file for reading and writing, create if needed | Add objects to an existing file, or update them |
"RECREATE" | Create a new file, overwrite any existing file of same name | Fresh output for a new analysis run |
"NEW" | Create a new file, fail if the file already exists | Protect existing results from being overwritten |
A file opened in "READ" mode does not allow writing. If you try to call Write() on objects or on the file itself, nothing will be saved. Use this mode when you are absolutely sure you will not modify the file and you want to avoid accidental changes.
In contrast, "UPDATE" opens a file for both reading and writing. If the file does not exist yet, ROOT will create it. This mode is useful if you want to add new histograms or TTrees to an existing result file. Be aware that using "UPDATE" repeatedly can gradually grow the file size because updated objects may be stored as new versions. Managing versions and file size is a more advanced topic, but it is worth knowing that "UPDATE" favors flexibility over strict reproducibility of the original file contents.
The "RECREATE" mode is very common in analysis macros. When you use:
TFile f("results.root", "RECREATE");
ROOT will create results.root if it does not exist, or overwrite it completely if it does. Any previous contents are lost. This is convenient during development because you can rerun your macro multiple times and always get a clean, fresh output file.
The "NEW" mode is similar to "RECREATE", but safer. With:
TFile *f = TFile::Open("results.root", "NEW");
ROOT will create results.root only if it does not already exist. If the file is already present, TFile::Open will fail and typically return a null pointer or a zombie file. This mode is useful when you want to ensure that you never overwrite previous output, for example in a production analysis or when running large batch jobs where each run must keep its own results.
Internally, file modes also control how ROOT handles directories inside the file, and how objects with identical names are replaced or versioned. For absolute beginners, the key ideas are simple:
Use "READ" when you only want to inspect data, "RECREATE" for clean new output that can overwrite old files, "NEW" to protect existing results from being overwritten, and "UPDATE" when you intentionally want to add or modify content in an existing ROOT file.
Be deliberate about which mode you choose, since it determines whether your previous analysis results are preserved or replaced.
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!