25.2 B. ROOT Histogram Classes

Table of Contents

Overview

ROOT provides a rich set of histogram classes that cover different dimensions, binning schemes, and data types. This appendix summarizes the most commonly used histogram classes, their typical use cases, and some key methods and options.

Histograms in ROOT all derive, directly or indirectly, from the base class TH1. For 2D and 3D histograms the base classes are TH2 and TH3. Concrete classes mostly differ by the data type used to store bin contents and by whether they use regular or variable binning.

Important:
All histogram classes described here follow the same conceptual rules:

A histogram has a fixed number of bins per axis once constructed.
It always has underflow and overflow bins on every axis.
Use Fill() to add data and Draw() to visualize it.
Call Sumw2() if you need correct bin errors with weighted entries.

One-dimensional histogram classes

The most frequently used 1D histogram classes are summarized in the following table.

Class	Base	Bin content type	Typical use case
`TH1C`	TH1	`Char_t`	Very small integer counts, low memory use
`TH1S`	TH1	`Short_t`	Small integer counts
`TH1I`	TH1	`Int_t`	Integer counts, larger ranges
`TH1F`	TH1	`Float_t`	Floating point contents, most common choice
`TH1D`	TH1	`Double_t`	High precision floating point

In practice, beginners mostly use TH1F and TH1D. The choice is usually between speed and memory on one side and numerical precision on the other.

A typical constructor for a 1D histogram with uniform binning looks like:

cpp

TH1F h("h", "Title;X axis;Y axis", nbins, x_min, x_max);

For variable binning, you pass an array of bin edges:

cpp

double edges[] = {0.0, 0.5, 1.0, 2.0};
TH1F h("h", "Variable bins", 3, edges);

Rule of thumb:
Use TH1F for general purpose analysis and plotting.
Use TH1D if you expect very large weights or you perform calculations where numerical precision is critical.

Two-dimensional histogram classes

For two dimensional distributions, you use TH2 based classes. These store a value in each 2D bin, conceptually similar to a matrix, and are useful for correlations between two observables, response matrices, and similar problems.

Class	Bin content type	Typical use case
`TH2C`	`Char_t`	Very small integer counts, memory saving
`TH2S`	`Short_t`	Small integer counts
`TH2I`	`Int_t`	Integer counts
`TH2F`	`Float_t`	General 2D histograms, most common
`TH2D`	`Double_t`	High precision 2D histograms

Typical uniform binning constructor:

cpp

TH2F h2("h2", "Title;X;Y",
        nx, x_min, x_max,
        ny, y_min, y_max);

Variable binning can be applied on one or both axes by passing arrays of bin edges for x and y.

Important:
The total number of bins in a 2D histogram is
$N_{\text{tot}} = (N_x + 2)(N_y + 2)$
The extra 2 in each dimension accounts for underflow and overflow along that axis.

Three-dimensional histogram classes

Three dimensional histograms are less common but very useful for multidimensional detector studies, response modeling, and advanced analyses.

Class	Bin content type	Typical use case
`TH3C`	`Char_t`	Very small integer counts
`TH3S`	`Short_t`	Small integer counts
`TH3I`	`Int_t`	Integer counts
`TH3F`	`Float_t`	General 3D histograms
`TH3D`	`Double_t`	High precision 3D histograms

Typical constructor:

cpp

TH3F h3("h3", "Title;X;Y;Z",
        nx, x_min, x_max,
        ny, y_min, y_max,
        nz, z_min, z_max);

As with TH1 and TH2, variable binning is possible along any axis by providing arrays of edges.

The total bin count including all underflow and overflow bins is:
$$
N_{\text{tot}} = (N_x + 2)(N_y + 2)(N_z + 2).
$$

Profile histograms

Profile histograms are special histogram types that store the mean value of one variable as a function of another, together with the associated statistical information.

They are based on the idea that if you fill a 2D histogram with points $(x, y)$, you may be interested in the average of $y$ for each $x$ bin instead of the full distribution.

The main classes are:

Class	Dimension	Meaning
`TProfile`	1D	Profile of $y$ vs $x$
`TProfile2D`	2D	Profile of $z$ vs $(x, y)$
`TProfile3D`	3D	Profile of $t$ vs $(x, y, z)$

Typical constructor for a 1D profile:

cpp

TProfile p("p", "Profile;X;Mean Y",
           nbins, x_min, x_max);

Filling a profile is similar to filling a 2D histogram:

cpp

p.Fill(x_value, y_value);

Internally, profiles accumulate the sum of y, the sum of y^2, and the number of entries per bin. When you draw a profile, ROOT displays the mean value of y per bin and the corresponding uncertainty.

Key concept:
Profiles are for the mean of a quantity as a function of another variable.
They are not equivalent to projecting a 2D histogram, which gives you full distributions of one variable at fixed bins of the other.

Specialized histogram classes

ROOT also provides several specialized histogram and histogram related classes. These are less common for beginners but become important in more advanced analyses.

Class	Description	Typical use case
`THStack`	Stack of 1D histograms	Stacked plots of components
`TProfile2D`	2D profile histogram	Mean z vs (x, y) surfaces
`TProfile3D`	3D profile histogram	Higher dimensional profiles
`THn`	N dimensional histogram (generic)	Very high dimensional data
`THnF`	N dimensional, float contents	Fast N dimensional histograms
`THnD`	N dimensional, double contents	Precise N dimensional histograms

In everyday work, THStack is often used for visualization of contributions from different processes or samples in one combined plot, while THnF and THnD serve more niche high dimensional analysis purposes.

Choosing the right histogram class

Beginners are usually safe with a small subset of these classes. The table below offers a practical guide.

Goal	Recommended class
Simple 1D distribution	`TH1F` or `TH1D`
Correlation between two variables	`TH2F` or `TH2D`
3D distribution	`TH3F` or `TH3D`
Mean of a variable vs another variable	`TProfile`
Several 1D histograms in a stacked plot	`THStack` + `TH1F`
Very large weights, high precision sums	`TH1D`, `TH2D`, `TH3D`

Practical rule set:

Start with TH1F, TH2F and TH3F for most tasks.
Switch to TH1D or related double precision classes if you see numerical issues or handle very large datasets or weights.
Use TProfile and its variants when you care about the mean of one quantity as a function of one or more other variables.

This appendix is intended as a quick reference. For detailed usage, methods, and advanced options of each class, consult the ROOT class reference documentation.