Installing ROOT

Installing ROOT on Linux

ROOT can be installed on Linux in several ways. The exact steps depend on your distribution and on whether you prefer a ready-made binary, a package manager, or building from source. For an absolute beginner, using precompiled binaries is usually the easiest. Building from source is powerful, but it is more advanced and covered elsewhere.

You should start by checking the official ROOT website at https://root.cern for the latest recommended method and version. The download section provides precompiled binaries for common Linux distributions. Typically you will download a compressed archive, extract it, and then set a few environment variables so that your shell and ROOT can find each other.

Assume you have downloaded a binary for Linux called something like root_v6.xx.xx.Linux-ubuntu20-x86_64-gcc9.4.tar.gz. You would extract it in a directory of your choice, for example in your home directory. In a terminal this usually looks like:
tar -xf root_v6.xx.xx.Linux-ubuntu20-x86_64-gcc9.4.tar.gz
This creates a directory, for example root, which contains the ROOT installation.

Inside this directory there is a script called thisroot.sh. You need to source this script in every shell where you want to use ROOT, or add it to your shell startup file so it is set up automatically. For a Bash shell this looks like:
source /path/to/root/bin/thisroot.sh
Replace /path/to/root with the actual location of your ROOT directory.

Sourcing thisroot.sh adjusts your PATH and other environment variables so that the root command is available in your terminal. After this, typing root at the prompt should start the ROOT interactive shell.

If you use another shell such as zsh, you can still use the same script with the same source command. For csh or tcsh there is a corresponding thisroot.csh script.

If you plan to use ROOT frequently, add the source /path/to/root/bin/thisroot.sh line to your ~/.bashrc or ~/.zshrc so that it runs automatically when you open a new terminal.

Installing ROOT with package managers

Many Linux distributions provide ROOT directly through their native package managers. This can be convenient because installation and updates are handled in the same way as for other system packages. However, the ROOT version in the distribution repositories may sometimes be older than the one on the official ROOT website.

On Debian based distributions such as Ubuntu, you can usually install ROOT with:
sudo apt install root-system
or with a more specific package name like root-system-bin plus additional components such as root-system-common. The exact package set can change between releases, so consult your distribution documentation or search with:
apt search root-system

On Fedora and other RPM based systems you might use:
sudo dnf install root
or:
sudo yum install root
Again, package names may differ slightly, so it is good to search:
dnf search root

Some scientific Linux distributions and third party repositories provide more recent ROOT builds tailored for high energy physics environments. In that case, you may need to enable an additional software repository before installing.

When you install ROOT with a system package manager, the root executable is usually placed in a standard directory such as /usr/bin, so you do not need to run thisroot.sh. The package also takes care of installing libraries and headers into the usual system locations. After installation, you can usually start ROOT simply by typing:
root
in a new terminal.

If your distribution provides multiple ROOT versions, you might see versioned executables such as root5 and root6. Make sure you are using the intended version for this course, typically ROOT 6 or later. You can check the version after starting ROOT, which is discussed in the verification section later in this chapter.

Installing ROOT with Conda

If you already use Conda for Python or scientific software, installing ROOT through Conda can be a very convenient option. Conda isolates software environments, which reduces conflicts between different versions of libraries. This can be especially useful on shared systems or when you want to experiment with different ROOT versions.

ROOT is available from the conda-forge channel. First ensure that the channel is enabled in your Conda configuration. You can do this with:
conda config --add channels conda-forge
and often it is also helpful to make sure conda-forge has high priority.

It is usually best to create a dedicated Conda environment for ROOT, for example:
conda create -n root-env root -c conda-forge
This command creates an environment called root-env and installs ROOT and its dependencies into it. Once the environment is created, you activate it with:
conda activate root-env
After activation, the root command should be in your path and ready to use.

If you want ROOT together with a specific Python version and other tools, you can include them in the same environment creation:
conda create -n root-env python=3.11 root -c conda-forge
This can be a good starting point if you plan to use both ROOT and PyROOT in the same workflow later, although the detailed use of PyROOT is covered in a separate chapter.

One advantage of using Conda is that you do not need to manually manage environment variables or source thisroot.sh. Conda handles the required PATH and library paths when you activate the environment. To stop using ROOT from this environment, simply run:
conda deactivate

Verifying the installation

After installing ROOT by any method, you should verify that it works and that the version is appropriate. This helps you detect problems early before you start building analyses.

First, open a new terminal. If you installed from a binary tarball, make sure you have sourced thisroot.sh in that terminal. If you installed with a package manager or Conda and followed the steps above, no extra command should be needed beyond possibly activating your Conda environment.

Next, type:
root
and press Enter. The ROOT banner should appear, showing the ROOT version, build information, and a prompt that looks like:
root [0]
If the shell responds with “command not found” or similar, your PATH is not set correctly, or the installation is incomplete.

To check the ROOT version from inside the ROOT prompt, you can inspect the banner or execute:
gROOT->GetVersion();
or:
gROOT->GetVersionInt();
In most environments, the version string is also displayed at startup, for example:
ROOT 6.xx/yy
Knowing the exact version is helpful when you follow tutorials or compare behavior with others.

You should also test a very simple command to confirm that the interpreter runs correctly. For example, at the ROOT prompt:
root [0] 1+1
ROOT should respond with:
(int) 2
or a similar result. If this works, the interpreter is functioning.

To leave ROOT, you can type:
.q
at the ROOT prompt. If the terminal returns to the normal shell prompt without errors, ROOT is shutting down cleanly.

Views: 13