KAHIBARO Bookshelves
Discord Login Register

3.5. Organizing a ROOT Project

Source files

In a ROOT analysis, the source files are the parts of your project that contain C++ code and ROOT macros. Even for a small beginner project, it is helpful to separate code from data and output, and to keep similar types of files grouped together. This makes your analysis easier to understand, to debug, and to share with others.

Typical source files for a ROOT project include interactive macros with the .C extension, compiled C++ source files with the .cc or .cpp extension, and header files with the .h or .hh extension. You might also have small helper scripts such as shell scripts or Python scripts that drive ROOT from the command line.

It is common to reserve a dedicated directory for ROOT and C++ source code, for example src/ for implementation files and include/ for header files. In small projects you may keep all macros directly under a single macros/ directory. The key idea is that there is one place where you look for code that you need to edit, and that this place is clearly separated from data and produced plots.

Within your source files, each macro should usually have a clear and limited purpose, such as creating histograms from a TTree, fitting a particular distribution, or producing final plots. If a macro becomes long and contains logic that you want to reuse, you can move that logic into functions defined in separate C++ source files and include the corresponding headers in multiple macros. Even if you are not yet using full CMake or Makefile build systems, grouping related functions into a few .C or .cc files and keeping function declarations in headers makes your project cleaner and avoids code duplication.

When you start to compile macros with ACLiC or build compiled programs that link against ROOT, having code in dedicated source and include directories becomes even more important. ROOT will generate helper files during compilation, and you do not want those mixed with your hand written sources. Keep generated files, such as .d or .so files from ACLiC, either ignored or placed in a separate build directory, so your source directory remains tidy.

A simple rule that helps is: everything you directly edit by hand is a source file and belongs in your source area, and everything that ROOT creates automatically should not be stored together with it.

Always keep your hand written C++ and ROOT macros separate from files generated by ROOT or your operating system. This prevents accidental overwrites and makes it clear what is part of your analysis logic and what is temporary.

Data files

Data files are the inputs to your analysis. They can be large and are usually not meant to be edited manually. In the context of ROOT, the most common data files are ROOT files with the .root extension that contain TTrees, histograms, or other objects. At an earlier stage, you may also have plain text data, such as .txt or .csv files, that you will later convert to ROOT format.

It is useful to store all input data files in one or a few dedicated directories, for example data/ for main input and data/raw/ versus data/processed/ if you have several stages of data preparation. Keeping data in a predictable location makes it easier to write macros that find the correct files, reduces the chance of running on the wrong dataset, and allows you to share code without shipping large files.

In your macros, avoid hard coding absolute paths such as /home/user/Desktop/myfile.root. Instead, use paths relative to the project root, such as data/myfile.root. This keeps your project portable across different machines and accounts.

If you have multiple versions of the same dataset, adopt a simple naming scheme that encodes what each file contains. For example, you can distinguish between run001.root, run002.root, or between data_calibrated.root and data_uncalibrated.root. For text inputs, names like spectrum_raw.csv or events_cleaned.txt can indicate the processing stage.

For large experiments, it is common that the original raw data remains stored elsewhere and that your project only uses smaller derived data files. Even in a beginner setting, you can follow a similar idea by separating original files that you never modify from derived ROOT files that your macros create. This separation makes it less likely that you accidentally overwrite an irreplaceable file.

Never overwrite your original input data files from within a ROOT macro. Always write derived or processed data to new files with different names or into separate directories.

Output files

Output files are the products of your analysis. They can be ROOT files that contain histograms or TTrees, image files with plots, tables of numbers, or logs that record how the analysis ran. Keeping outputs organized is essential if you want to reproduce or compare results.

In ROOT, a typical analysis macro will read data from a .root file, process events, fill histograms, and then write the histograms to a new output .root file using TFile. Another macro may then take that output file and focus only on plotting and fitting. If you place all analysis outputs in a directory such as output/ or results/, you can easily clean it, archive it, or create several versions for different analysis configurations.

Plots that you export using TCanvas::SaveAs() should also be stored in an organized way. You may, for example, separate quick diagnostic plots from final publication style figures. For beginners, a simple separation between output/plots/ and output/fits/ can already be helpful. When naming plot files, include the quantity being plotted and possibly the main selection in the filename, for example pt_spectrum_baseline.png or energy_hist_after_cuts.pdf.

If your macros write ROOT files that contain intermediate histograms or TTrees, give these files names that correspond to the step of the analysis. For instance, histograms_step1.root might contain basic distributions before any selection, and histograms_step2.root might contain only selected signal events. This also allows you to re run only parts of the analysis if needed.

It is also valuable to record which version of your code produced a given output. Even before you use full version control, you can write simple text logs into output/logs/, where each log notes the date, the macro that was run, and the most important settings. As your projects become more complex, those logs help connect specific plots or ROOT files to the exact analysis that created them.

Never manually edit numerical or histogram content inside output ROOT files to fix results. If something is wrong, correct the macro or analysis step and regenerate the outputs. This keeps your analysis reproducible and transparent.

Recommended directory structure

A clear directory structure is one of the most helpful habits you can adopt early when working with ROOT. Even for small projects, a consistent structure makes it easier to find files, to modify the analysis, and to explain your work to collaborators or to your future self.

A simple structure for a beginner level ROOT project might look like the one in the following table, where each directory has a specific purpose:

Directory or filePurpose
src/C++ implementation files and main ROOT macros used for analysis logic
include/Header files with function declarations, class definitions, and constants
macros/Small interactive macros for quick checks and plotting tasks
data/Input data files such as .root, .txt, or .csv that are read by the analysis
output/All output produced by your macros, for example ROOT files and plots
output/plots/Figures saved by canvases, such as PNG or PDF files
output/logs/Log files that record which macros were run and with which settings
config/Optional configuration files containing parameters such as cut values and file lists
README.mdShort description of the project, how to run it, and dependencies

For very small exercises, you might merge some of these directories, but if you practice this style early, it will scale naturally to larger work. It is also common to keep a build/ directory if you start to use a build system for compiling C++ code, and to ignore that directory in version control because it only contains generated files.

Within the data/ and output/ directories you can introduce subdirectories for specific datasets or analysis variants. For instance, if you study two different runs, you could have data/run1/ and data/run2/, with corresponding outputs in output/run1/ and output/run2/. This separation makes it clear which results belong to which input.

When writing macros, try to reflect this structure in your code. For example, read input using relative paths like "data/myrun.root" and write outputs to "output/histograms_myrun.root". This way, moving the entire project to a different computer or directory does not require changes inside the macros.

Finally, combine a good directory layout with simple naming conventions. Use consistent and descriptive names for files and directories, avoid spaces in names, and prefer lowercase and underscores, for example electron_spectrum.C instead of ElectronSpectrum Final.C. This reduces confusion and makes your project friendlier for ROOT macros, command line tools, and version control systems.

Choose a clear project root, keep code, data, and outputs in separate subdirectories, and use relative paths inside your ROOT macros. This combination makes your analyses portable and easier to reproduce.

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