7.4 TGraphErrors

Table of Contents

X uncertainties

A TGraphErrors extends TGraph by storing an uncertainty for every point on both the X and Y coordinates. Instead of only arrays of $x_i$ and $y_i$, you provide four arrays: $x_i$, $y_i$, $\sigma_{x,i}$, and $\sigma_{y,i}$, where $\sigma_{x,i}$ and $\sigma_{y,i}$ are the uncertainties on each coordinate.

In ROOT, the class is called TGraphErrors. A typical constructor looks like:

cpp

int n = 5;
double x[5]  = {1, 2, 3, 4, 5};
double y[5]  = {2.1, 4.2, 6.3, 8.1, 10.2};
double ex[5] = {0.1, 0.1, 0.1, 0.1, 0.1};   // X errors
double ey[5] = {0.2, 0.2, 0.3, 0.3, 0.4};   // Y errors
TGraphErrors *g = new TGraphErrors(n, x, y, ex, ey);
g->Draw("AP");

The X uncertainties $\sigma_{x,i}$ are drawn as horizontal error bars centered on each $x_i$. If you set all ex values to zero, the graph still works, but horizontal error bars are not visible.

X uncertainties are usually relevant when the quantity on the X axis is not known exactly. Examples are beam energy with a small spread, calibration constants with uncertainty, or measurement time with a finite resolution. In such cases, each $x_i$ represents a central value, and $\sigma_{x,i}$ represents a one standard deviation spread or another chosen confidence measure.

You can also modify individual X uncertainties after creation:

cpp

g->SetPointError(ipoint, ex_new, ey_new);

where ipoint is the index of the point and ex_new is the new X error. SetPointError always expects both X and Y uncertainties.

To retrieve X errors, you can call:

cpp

double *ex_vals = g->GetEX();

This returns a pointer to the internal array of X uncertainties, which you can read or change carefully.

In TGraphErrors, each point has its own X and Y uncertainty, stored separately. Horizontal error bars are controlled by the X uncertainties EX, and if you forget to fill or set them, ROOT will not draw any horizontal error bars for that point.

When plotting and fitting, X uncertainties may or may not be used by the fit, depending on the fitting method and options. Y uncertainties are typically the main input to chi-square fits, so do not assume X errors are automatically included in the statistical model unless specified in the relevant fitting chapter.

Y uncertainties

Y uncertainties are the most common reason to use TGraphErrors. Each data point $y_i$ has an associated uncertainty $\sigma_{y,i}$, which ROOT shows as a vertical error bar centered on the point.

In the constructor example above, the ey array provides these Y uncertainties. If you only care about Y errors, you can set all X errors to zero:

cpp

double ex[5] = {0, 0, 0, 0, 0};  // ignore X errors

and still take full advantage of Y error bars.

Y uncertainties usually come from counting statistics, instrumental resolution, or error propagation. For instance, if $y_i$ is a measured cross section, $\sigma_{y,i}$ might include both statistical and systematic contributions. The details of how to compute these belong to statistical analysis, but TGraphErrors provides the container and plotting.

You can adjust Y uncertainties point by point:

cpp

int i = 2;
double ex_old, ey_old;
g->GetPointError(i, ex_old, ey_old);
g->SetPointError(i, ex_old, 0.5);  // change only Y error

To access the whole array of Y uncertainties:

cpp

double *ey_vals = g->GetEY();

Do not change the size of this array; it is owned and managed by the TGraphErrors object.

When you draw the graph, the choice of drawing option controls how error bars appear. For example:

cpp

g->Draw("AP");   // axes and points, with error bars by default
g->Draw("PE");   // points with error bars, no axes reset

Some styles can hide markers or lines but still show errors, while others focus on a clean line with visible bars. These fine details are part of graph styling.

In TGraphErrors, Y uncertainties define the vertical error bars and are typically used as the point-by-point uncertainties in fits. Make sure that the EY values are filled correctly, because many fitting methods interpret them as $1\sigma$ errors and build the chi-square as
$$
\chi^2 = \sum_i \frac{\left(y_i - f(x_i)\right)^2}{\sigma_{y,i}^2}.
$$

If you do not provide meaningful Y uncertainties, or leave them all equal, you may still get a visual plot with error bars, but any statistical interpretation based on those errors will be misleading.

Experimental measurements

TGraphErrors is particularly suited to represent experimental measurements where each data point consists of a central value and an uncertainty. In many analyses you have a small or moderate number of measurements, each at some X coordinate (for example energy, angle, time, or bin center), and you want to show both the measured value and its uncertainty.

Typical use cases include cross section measurements as a function of energy, detector efficiency versus threshold, calibration curves relating two measured quantities, or time evolution of a quantity with measurement errors at each time point.

A simple example that reflects a typical experimental dataset is:

cpp

const int n = 4;
double energy[n] = {50., 100., 150., 200.};     // MeV
double sigma[n]  = {1.2,  2.5,  3.1,  3.8};     // arbitrary units
double dE[n]     = {1.0,  1.0,  1.0,  1.0};     // energy resolution
double dSigma[n] = {0.1,  0.2,  0.2,  0.3};     // measurement errors
TGraphErrors *gXS = new TGraphErrors(n, energy, sigma, dE, dSigma);
gXS->SetTitle("Cross section vs energy;Energy (MeV);#sigma (arb. units)");
gXS->Draw("AP");

Here, each point represents an independent measurement. The horizontal bars show the uncertainty in the energy, and the vertical bars show the uncertainty in the cross section. The string passed to SetTitle encodes the plot title and the axis labels in a compact way.

When you later fit a model curve to these measurements, the graph already contains the uncertainties, so the fit can make use of them. The fitting procedures and their statistical interpretation are handled in the dedicated fitting chapters.

You can compare multiple measurements on the same plot by using several TGraphErrors objects and drawing them together, for example with a TMultiGraph. This allows a visual comparison of different experimental conditions or different datasets, each with its own error bars.

For clarity in experimental presentations, it is common to distinguish between purely statistical and total uncertainties. In practice, one often combines them in quadrature and stores the result in the EY array. The underlying decision about which uncertainties to include and how to combine them belongs to the physics and statistics of your analysis, while TGraphErrors provides a straightforward way to store and display the resulting error bars.

When using TGraphErrors for experimental data, ensure that each point’s errors accurately represent the uncertainties you intend to show. The visual impression of error bars heavily influences how others interpret the reliability and precision of your measurements, and any fits or further statistical analysis will typically assume that the stored uncertainties are correct.

7.4 TGraphErrors

X uncertainties

Y uncertainties

Experimental measurements

Comments

Where to Move