The system now uses a combination of the Lmod module system and the EasyBuild automatic build framework. Although largely compatible, Lmod has some differences in usage and module names as documented below.

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

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

Loading and unloading modules

Lmod uses a hierarchical module scheme, where 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 may influence the PATH and LD_LIBRARY_PATH, influencing executables and libraries visible to the user. To remove any modifications to the environment by a specific module, you can unload specific modules with the unload option.

module unload foo

While this should work, this could still lead to errors. To circumvent this, consider instead unloading all modules at once, using purge and subsequently loading only the modules you need.

module purge

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

module list

To check which actions would be taken with loading a specific module, 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

From the old TCL module system you are used to having categories, like DEVELOP, CHEMISTRY etc. pp. So if you are looking for chemistry software, you would load the CHEMISTRY module and see what software is installed. This is what is called a "Categorized Module Naming Scheme" or CMNS for short.

With Lmod, this has changed to a Hierarchical Module Naming Scheme (HMNS), which loads additional module paths whenever a module is loaded that was used to build software (e.g., Open MPI only becomes visible once you have loaded the compiler that was used to build that version of Open MPI). This is in contrast to CMNS. 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 categories which are agreed with the colleagues of the TU Darmstadt. Which software is hidden behind the categories can be seen by entering (e.g. for chemistry) the following:

$ 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