Navigation and service

Software on JUROPATEST

Access to installed software on JUROPATEST is organized through a hierarchy of modules.

Loading a module sets your environment variables to give you access to a specific set of software and its dependencies. The hierarchical organization of the modules ensures that you get a consistent set of dependencies, e.g., all built with the same compiler version or all relying on the same implementation of MPI.

Then module hierarchy is built upon toolchains. Toolchains modules in the lowest level contain just a compiler suite (e.g., Intel compilers icc and ifort).

Toolchains in the second level contain a compiler suite and a compatible implementation of MPI.

The third and highest level contains "full toolchains", with a compiler suite, an MPI implementation, and compatible mathematical libraries such as SCALAPACK.

An application is only accessible to the user when its module is loaded. You can load the application module only when the toolchain modules containing its dependencies are loaded first.

Dictionary of hierarchical toolchain module shortcuts

Here is a quick reference to the tools provided by each toolchain module:

Compilers

GCC: Gnu compilers including front ends for C, C++, Objective-C, Fortran, Java, and Ada
ifort: Intel Fortran compiler
icc: Intel C and C++ compilers
iccifort: icc + ifort (Intel C and Fortran compilers together)

Compilers+MPI

gpsmpi2: GCC + Parastation MPICH MPI
ipsmpi2: iccifort + Parastation MPICH MPI
iimpi: iccifort + Intel MPI

FullToolchains

gpsolf: gpsmipi + OpenBLAS, FFTW and ScaLAPACK
intel-para: ipsmpi2 + Intel Math Kernel Library (imkl)
intel: iimpi + Intel Math Kernel Library (imkl)

Modules for compilers, MPI libraries and math libraries may also be loaded separately and sequentially.

Using the Lmod module command

This is a very brief overview. More complete information is available through the module man page or the Lmod User Guide.

Users should load, unload and query modules though the Lmod module command. Several useful module commands are:

module avail

shows what modules are compatible available to load right now, given the toolchain modules you have already loaded. The command

module load <modulename>/<moduleversion>

loads a specific version of a module. For example,

module load GCC/4.9.1

gives you access to the Gnu compilers.

module list

lists what modules are currently loaded. The command

module unload <modulename>/<moduleversion>

unloads a module.

module purge

unloads all modules

module spider <modulename>

finds the location of a module within the module hierarchy.

Quick Start Example

Upon login type:

module avail

Lmod will present you with the list of modules that are available to load immediately. These are classified into four levels:
Core, Compilers, Compilers+MPI and FullToolchains.

Modules listed under Core have no dependencies.

If the application module you need is displayed at this point you may load it directly with

module load <modulename>/<moduleversion>

If the software package is built with a toolchain that you do not have loaded, it will not be visible to module avail. In this case you can find the module and the necessary toolchain using module spider.

Finding and loading a Module

Suppose you are a user who would like to run OpenFOAM. If you do not know the dependencies of the application OpenFOAM, type

module spider OpenFOAM

(You may even type part of the name, e.g. module spider foam).
Lmod then tells you that version 2.3.0 is installed. To get the module dependencies, repeat the spider query with the full modulename/version:

module spider OpenFOAM/2.3.0

The output reads (in part):

This module can only be loaded through the following modules:

intel-para/2015.03

intel/2015.03

Now we can load an OpenFOAM built with either the intel-para toolchain (Intel compilers + parastation MPI) or the intel toolchain (Intel compilers + Intel MPI).

Now we can load an OpenFOAM dependent on either Intel compilers (icc or ifort) and Parastation MPICH MPI, or Intel compilers and an Intel MPI (impi). Let us say we choose the intel-para toolchain. We then use module load:

module load intel-para/2015.03

Now again issue the command:

module avail

In the long list of available applications you can now find

OpenFOAM/2.3.0

Load it with

module load OpenFOAM/2.3.0

Now you can check your loaded modules with:

module list

You will see your loaded modules which include OpenFOAM and its dependencies:

Currently Loaded Modules:
1) zlib/.1.2.8
2) binutils/.2.24
3) ncurses/.5.9
4) libatomic_ops/.7.4.2
5) gc/.7.4.2
6) util-wrapper/1.0
7) GCC/.4.9.2-bare
8) popt/.1.16
9) pscom/.5.0.45-1
10) ipsmpi/2015.03

11) iccifort/2015.2.164
12) icc/2015.2.164
13) ifort/2015.2.164
14) psmpi/5.1.1-1
15) imkl/11.2.2.164
16) intel-para/2015.03
17) libreadline/6.3
18) SCOTCH/6.0.3
19) OpenFOAM/2.3.0

Most of the modules listed are components of the intel-para toolchain.

As noted above, the recommended toolchain is intel-para. Loading the intel-para module at login will make most applications available without the need to use the spider.

Accessing Old Software

Software on JUROPATEST is organized in stages. By default only the most recent stage with up-to-date software is available. To access older (or in development) versions of software installations, you must manually extend your module path using the command

module use /usr/local/software/juropatest/OtherStages

Link to Scientific Application Software