Table of Contents

1. Basics
   1. Loading and unloading modules
   2. Searching modules
   3. Personal module collections
2. Example
3. Core compiler
4. Toolchains
   1. Existing Toolchains
      1. Intel-based
      2. GCC-based
5. External documentation

Basics

The RWTH-HPC system uses a module software called Lmod. Modules allow you to access installed software using a simple syntax. We offer a variety of software packages, ranging from simulation suites and performance tools to common software libraries. Many of these are offered in multiple versions. The module command allows you to load new software into your current environment without the need to configure it manually. 

The different modules are grouped into a module hierarchy based on the compiler and possibly the MPI implementation on which they depend. As a consequence, modules can only be loaded when the compiler and MPI they depend on have already been loaded. The purpose of this mechanism is to prevent you from loading incompatible software that would crash on startup or when accessing a certain feature. Some modules, e.g., MATLAB, do not depend on any compiler and can thus be loaded at any time. Other software may depend only on a certain compiler and require no MPI implementation and other modules may have a very strict set of dependencies. We advise browsing around the module system for a bit to familiarize yourself with its concepts.

Loading and unloading modules

Please Note: You can use ml as a shorthand for module.

Lmod uses a hierarchical module scheme in which not all modules are visible at any given time. You can list the module currently available with the avail option.

module avail

You can load a module with the load option.

module load foo

Please Note: If no version is specified, the default version is automatically chosen. If only a single version is available of a certain module, then this will automatically become the default. Default versions of modules are marked with (D) in the list of available modules.

When loading a module, the module system may set module-specific variables in the environment. This will modify the shell environment, influencing executables and libraries visible to the user. You may also be notified that other modules are loaded automatically as a dependency. To remove any modifications to the environment by a specific module, you can unload specific modules with the unload option.

module unload foo

Sometimes you may want to unload all current modules and start with a "fresh" environment. In this case you can use

module purge

To get a list of all loaded modules, you can use the list option.

module list

To check which environment changes a certain module would cause upon loading, you can use the show option

module show foo
module show foo/1.2.3

Please Note: The output will only list the dependent load operations for a specific package. If one of those packages is already loaded it will be omitted in the output.

Searching modules

LMod uses a so-called hierarchical module naming scheme (HMNS), which structures the modules according to whether they rely on a certain compiler or a certain MPI version. A major part of the module tree is hidden in the avail overview until you load the required modules. To facilitate a module overview based on the category that software packages belong to, we introduced categories similar to those we employed in the past. To enable category-based searching for modules in an HMNS, we added the category subcommand to Lmod:
 

$ module category

To get a list of every module in a category execute:
   $ module category Foo
      
------------------------------ List of Categories ------------------------------
cfd  chem  devel  io  material  math  perf  tools

which shows you the available categories. These categories are the same across the NHR4CES systems. The software belonging to a certain category can be viewed with the following command:

$ module category chem

To learn more about a package and how to load it execute:
   $ module spider Bar
      
------------------------------------- chem -------------------------------------
Gaussian (6)   PETSc (1)   QuantumESPRESSO (1)   VASP (2)

If you don't know how a specific module is called or a module is currently not visible to you and you want to search for a software, you can use the spider subcommand.

$ module spider foo

Please Note: Searching for a module with spider is case in-sensitive and also returns partial matches (the search argument is part of an existing module). Further note that spider searches in the module name and the description.

When called only with the module name and no specific version, the output of spider lists all available versions across all toolchains. When called with a specific version, the output lists toolchains that will make it available.

$ module spider foo/1.2.3

To unload a module and load a module with one call, you can use the switch option.

$ module switch foo bar

If you want to reset the module environment to the system default, you can use the reset option.

$ module reset

Personal module collections

You can save a collection of loaded modules to a named collection with the save option.

$ module save <collection-name>

To restore a previously saved collection, you can restore the saved module collection with the restore option.

$ module restore <collection-name>

To list all available personal module collections, you can use the savelist option.

$ module savelist

To remove a specific saved module collection.

$ module disable <collection-name>

Example

Assume you want to know whether a package is available on the cluster, in this example LAMMPS.

1. First check by using spider for a case-insensitive, partial-match search for the package.

   $ module spider LAMMPS
   
   ----------------------------------------------------------------------------
     LAMMPS:
   ----------------------------------------------------------------------------
       Description:
         LAMMPS is a classical molecular dynamics code, and an acronym for
         Large-scale Atomic/Molecular Massively Parallel Simulator. LAMMPS has
         potentials for solid-state materials (metals, semiconductors) and
         soft matter (biomolecules, polymers) and coarse-grained or mesoscopic
         systems. It can be used to model atoms or, more generically, as a
         parallel particle simulator at the atomic, meso, or continuum scale.
         LAMMPS runs on single processors or in parallel using message-passing
         techniques and a spatial-decomposition of the simulation domain. The
         code is designed to be easy to modify or extend with new
         functionality. 
   
        Versions:
           LAMMPS/3Mar2020-Python-3.8.2-kokkos
           LAMMPS/23Jun2022-kokkos
   
   ----------------------------------------------------------------------------
     For detailed information about a specific "LAMMPS" package (including how to load the modules) use the module's full name.
     Note that names that have a trailing (E) are extensions provided by other modules.
     For example:
   
        $ module spider LAMMPS/23Jun2022-kokkos
   ----------------------------------------------------------------------------
   
   

2. As shown on the last line (for the default module of that name), specifying a specific version explicitly, will list the dependencies needed to be loaded before the respective module becomes available.

   $ module spider LAMMPS/23Jun2022-kokkos
   
   ----------------------------------------------------------------------------
     LAMMPS: LAMMPS/23Jun2022-kokkos
   ----------------------------------------------------------------------------
       Description:
         LAMMPS is a classical molecular dynamics code, and an acronym for
         Large-scale Atomic/Molecular Massively Parallel Simulator. LAMMPS has
         potentials for solid-state materials (metals, semiconductors) and
         soft matter (biomolecules, polymers) and coarse-grained or mesoscopic
         systems. It can be used to model atoms or, more generically, as a
         parallel particle simulator at the atomic, meso, or continuum scale.
         LAMMPS runs on single processors or in parallel using message-passing
         techniques and a spatial-decomposition of the simulation domain. The
         code is designed to be easy to modify or extend with new
         functionality. 
   
   
       You will need to load all module(s) on any one of the lines below before the "LAMMPS/23Jun2022-kokkos" module is available to load.
   
         GCC/10.3.0  OpenMPI/4.1.1
    
       Help:
         Description
         ===========
         LAMMPS is a classical molecular dynamics code, and an acronym
         for Large-scale Atomic/Molecular Massively Parallel Simulator. LAMMPS has
         potentials for solid-state materials (metals, semiconductors) and soft matter
         (biomolecules, polymers) and coarse-grained or mesoscopic systems. It can be
         used to model atoms or, more generically, as a parallel particle simulator at
         the atomic, meso, or continuum scale. LAMMPS runs on single processors or in
         parallel using message-passing techniques and a spatial-decomposition of the
         simulation domain. The code is designed to be easy to modify or extend with new
         functionality.
         
         
         More information
         ================
          - Homepage: https://www.lammps.org
   
   

Listed above the "Help:" line are dependencies to make that specific version available. If the package is available for different compiler and MPI combinations (or other dependencies), Lmod will list multiple lines here where each separate line lists all dependencies for that toolchain. In this example loading the corresponding GCC and OpenMPI package will work.

$ module load GCC/10.3.0 OpenMPI/4.1.1 LAMMPS/23Jun2022-kokkos

Please Note: Even though Lmod allows to automatically unload modules of conflicting packages, such families are NOT defined on CLAIX, to explicitly allow for loading multiple compilers into the environment.

Core Compiler

For all packages a certain version of GCC is automatically loaded as GCCcore module. The GCCcore module will be part of the dependencies for making a certain module visible.

Toolchains

Toolchains are so-called meta modules that load a specific Compiler and MPI combination (and in some cases some additional libraries).

Existing Toolchains

Intel-based

GCC-based

External Documentation

• User Guide for Lmod