Software - KTA Computer System

Operating System¶

The KTA Computer System runs on AlmaLinux 9, a Linux distribution that is binary compatible with Red Hat Enterprise Linux (RHEL) and is officially supported by CERN.

System-Wide Software¶

The AlmaLinux software repositories contain a wide variety of scientific software that is available on all machines without any additional setup. This includes, among others:

gcc and clang — C/C++ compilers
python — Python interpreter
ROOT — CERN data analysis framework
git, make, cmake — build and version control tools

This list is not exhaustive. If a package you need is missing, you can request its installation by writing to kta.admins@ph.tum.de. If the package is not available in the repositories, see the sections below for alternative installation methods.

Anaconda¶

Anaconda is a widely used Python distribution for scientific computing. It ships with conda, a combined package and environment manager. A global Anaconda installation is available on all machines in the cluster — no personal installation is required.

Activating the base environment¶

To enter the shared conda environment, run:

source /opt/anaconda3/bin/activate

Your prompt will change to indicate you are now inside the base environment:

(base) [ga12abc@nidoking ~]$

Recommended configuration¶

Before creating your first environment, create a $HOME/.condarc file with the following settings:

channels:
  - conda-forge
channel_priority: strict
envs_dirs:
  - /path/outside/your/home/directory
pkgs_dirs:
  - /path/outside/your/home/directory/pkgs

Creating a personal environment¶

From within base, create and use your own environment:

conda create -n MyAwesomeDevEnv
conda activate MyAwesomeDevEnv
conda install root numpy

You can verify that the packages are taken from your new environment:

(MyAwesomeDevEnv) [ga12abc@nidoking ~]$ which root
/scratch8/ga12abc/conda/MyAwesomeDevEnv/bin/root

Spack¶

Spack is a package manager designed for HPC environments. It allows multiple versions of the same package to coexist and handles complex dependency trees — making it well suited for scientific software stacks.

Activating Spack¶

To make the spack command available in your shell, run:

source /tank1/spack/spack/share/spack/setup-env.sh

You can search the full list of packages supported by Spack here.

O2Physics via CVMFS¶

O2Physics is ALICE’s analysis software for Run 3. Pre-built nightly/daily build binaries are distributed by CERN through CVMFS and are available on all terminal servers, compute nodes and managed desktop machines under /cvmfs/alice.cern.ch — no compilation required.

Finding available versions¶

To list the O2Physics versions currently available, run:

/cvmfs/alice.cern.ch/bin/alienv q | grep O2Physics

You will see a long list of tags. The ones relevant for analysis are usually daily-YYYYMMDD-HHMM-N — daily/nightly builds, directly available for analysis.

Interactive use on terminal servers¶

To load a specific version into an interactive shell, use alienv enter with the bare package name (no VO_ALICE@ prefix):

/cvmfs/alice.cern.ch/bin/alienv enter O2Physics/daily-20261102-0000-1

Your prompt changes to indicate the loaded environment:

[ga45can@nidoking ~]$ /cvmfs/alice.cern.ch/bin/alienv enter O2Physics/daily-20261102-0000-1
[O2Physics/daily-20261102-0000-1] ~ > which o2-analysis-cf-femto-producer
/cvmfs/alice.cern.ch/el9-x86_64/Packages/O2Physics/daily-20261102-0000-1/bin/o2-analysis-cf-femto-producer
[O2Physics/daily-20261102-0000-1] ~ > which root
/cvmfs/alice.cern.ch/el9-x86_64/Packages/ROOT/v6-36-10-alice4-6/bin/root
[O2Physics/daily-20261102-0000-1] ~ > alien.py
Welcome to the ALICE GRID
(...)

You now have the O2Physics analysis executables, all supporting software and dependencies, like root and alien.py in PATH. Type exit to leave the environment and return to your normal shell.

Loading it in Slurm job scripts¶

At the top of your sbatch script, load the environment into the current shell with:

#!/bin/bash
#SBATCH --job-name=o2physics_analysis
#SBATCH --partition=kta
#SBATCH --cpus-per-task=4
#SBATCH --mem=8G
#SBATCH --time=02:00:00

eval $(/cvmfs/alice.cern.ch/bin/alienv printenv O2Physics/daily-20261102-0000-1)

# the environment is now loaded in this shell -- run as many commands as you need
o2-analysis-trackselection --configuration json://my_config.json -b

This sets environment variables (PATH, LD_LIBRARY_PATH, etc.) directly in the script’s own shell, so every subsequent command in the script sees the loaded package — unlike enter, no subshell is spawned.

Running a single command without eval

For jobs that only need to run one command, alienv setenv can run it directly inside the environment without an eval:

/cvmfs/alice.cern.ch/bin/alienv setenv O2Physics/daily-20261102-0000-1 -c o2-analysis-trackselection -b

Everything after -c is executed as-is inside the loaded environment.

Compiling Software from Source¶

If a package is not available through the system repositories, Spack, or conda, you can always compile it from source and install it into a directory you own. This gives you full control over the version and build configuration.

Below is a worked example using ROOT, the CERN data analysis framework. The same general pattern — clone, configure with CMake, build, install — applies to most other CMake-based projects.

Example: Building ROOT from source¶

1. Clone the source

git clone https://github.com/root-project/root.git --branch latest-stable --depth=1

Using --depth=1 skips the full commit history and makes the clone much faster. Replace latest-stable with a specific tag (e.g. v6-32-06) if you need a particular version.

2. Create a build directory

Always build out-of-source to keep the source tree clean:

mkdir root-build && cd root-build

3. Configure with CMake

cmake ../root \
    -DCMAKE_INSTALL_PREFIX=$HOME/software/root \
    -Dbuiltin_xrootd=ON \
    -Dmathmore=ON \
    -DCMAKE_BUILD_TYPE=Release

CMAKE_INSTALL_PREFIX sets where ROOT will be installed. Using a path inside your home directory (or a larger storage volume) avoids the need for administrator privileges. Run cmake -L ../root to see a full list of available build options.

4. Compile and install

cmake --build . --parallel $(nproc)
cmake --install .

$(nproc) uses all available cores. If you are compiling on a terminal server, be considerate of other users and limit the core count, e.g. --parallel 8. For large builds like ROOT it is better to run this step as an interactive job on a compute node (see Interactive Jobs).

5. Set up the environment

After installation, source the ROOT environment script to make root, rootcling, and the associated libraries available in your shell:

source $HOME/software/root/bin/thisroot.sh

To load ROOT automatically in every new shell session, add this line to your $HOME/.bashrc.