Downloading and building
Basic system requirements
Operating sytem
Atlas requires a POSIX compliant operating system. This includes:
- Linux
- MacOSX (Darwin)
Compilers
Atlas requires a C++ compiler that supports the C++11 standard. The optional Atlas Fortran API requires a Fortran compiler that supports the Fortran 2008 standard.
Tested compilers include:
- GNU 6.3, 7.3, 8.3
- Intel 18, 19
- PGI 17.7, 19.10
- Cray 8.7
- Clang C++ 7, 9 + GNU Fortran
CMake
- Minimum required version: 3.6 or greater
- Recommended version: 3.14 or greater
CMake is often already available on your system. If version requirements are incompatible, prebuilt CMake binary distribution may be downloaded here
Dependencies
Atlas is distributed as Git repository and is officially maintained at the ECMWF github space. It however relies on several dependencies to be pre-installed. Following figure illustrates how the dependencies interconnect. Below are links to each of them, with installation instructions.
Atlas aims to stay compatible with latest versions of dependencies (as of Atlas release date), and hence latest versions of dependencies are recommended. Please contact us if in doubt.
Required dependencies
For C++ API of Atlas:
- C++ compiler: C++11 standard support required
- CMake: Build system (meta-build system) used to compile Atlas
- ecbuild: It implements some CMake macros that are used within the Atlas build system. For more brief information and to install, check the ecbuild installation instructions
- eckit: It implements some useful C++ functionalities useful for Atlas. For more brief information and to install, check the eckit installation instructions
For Fortran API of Atlas, additional required dependencies:
- Fortran compiler: Fortran 2008 standard support required.
- fckit : It implements some useful Fortran functionalities. This is only needed when Fortran bindings are required. For more brief information and to install, check the fckit installation instructions
- Python : Required to generate Fortran interfaces
Optional dependencies
- MPI: Required for distributed memory parallelisation.
- OpenMP: Required for shared memory parallelisation. For use see. As OpenMP is implemented within compilers, it is not possible to install it yourself.
- CGAL: Required for enabling tesselation using Delaunay triangulation of unstructured grids.
- Eigen3 : Linear algebra library that should not impact any Atlas internal performance.
- FFTW – FFT library that improves efficiency of inverse spherical harmonics transforms (TransLocal). (Version 3.3.4 minimum required)
- BLAS / LAPACK – Linear Algebra libraries that improve efficiency of inverse spherical harmonics transforms (TransLocal). This library is typically available on the system, and preferred implementation is available within Intels MKL library.
- transi – For enabling IFS spherical harmonics transforms (TransIFS). This exposes an MPI parallel implementation for both direct and inverse spherical harmonics transforms. Note that transi is currently not open-source and requires a license agreement with ECMWF! For more brief information and to install, check the transi installation instructions
- GridTools – For enabling GPU capability using CUDA in C++ or OpenACC in Fortran (compiler permitting).
- Proj – For enabling Proj4 projections for grids. This is allows for projections that are not natively supported in Atlas.
Installation Instructions
Before building, make sure all Required dependencies are available, as well as the required Optional dependencies for the desired Optional features detailed below.
Once we have downloaded, compiled and installed required dependencies, we can now proceed to download and install.
Downloading Atlas
atlas is officially maintained and available from its ECMWF github page.
The master
branch tracks the latest stable release, whereas the develop
branch tracks the latest developments.
To download the project at the latest release we can type on the terminal the commands reported below:
git clone -b master https://github.com/ecmwf/atlas.git
Building Atlas
The atlas build system is based on CMake which tries to automatically detect compilers and project dependencies. To avoid suprises make sure that the following environment variables are pointing to the correct compiler.
CC
– Path to C compilerCXX
– Path to C++ compilerFortran
– Path to Fortran compiler
Other environment variables which may help CMake (version greater than 3.12) in finding required and optional dependencies for Atlas:
ecbuild_ROOT
– Path to ecbuild install prefixeckit_ROOT
– Path to eckit install prefixfckit_ROOT
– Path to fckit install prefixtransi_ROOT
– Path to transi install prefixGridTools_ROOT
– Path to GridTools install prefixCGAL_ROOT
– Path to CGAL install prefixFFTW_ROOT
– Path to FFTW install prefixPROJ4_ROOT
– Path to Proj install prefixEigen3_ROOT
– Path to Eigen install prefix
atlas can be configured and installed as follows, to a given path-to-install
as shown below:
cd atlas mkdir build && cd build cmake ../ -DCMAKE_INSTALL_PREFIX=<path-to-install> make -j8
The number 8
in the argument -j8
to make
speeds up compilation by using 8 threads.
This number can be tuned to maximise compilation speed.
Optional features
FORTRAN
This feature enables the compilation of the Atlas Fortran interface and is ON
by default.
It requires availability of the package fckit and a python executable. If not available,
this feature will be disabled automatically.
MPI
This feature enables the capability of Atlas to have parallel distributed data structures and algorithms. It requires the availability of MPI.
OMP
This feature enables the capability of OpenMP shared memory parallelism for algorithms within Atlas and is ON
by default,
but depends on the OpenMP implementation within the compilers.
TESSELATION
This feature, ON
by default, enables the Delaunay mesh generator,
which allows to generate a mesh by tesselating an unstructured grid using Delaunay triangulation.
It requires the availability of the CGAL optional dependency.
GRIDTOOLS_STORAGE
With this feature enabled, the underlying data memory storage is handled by GridTools
. It therefore depends on the availability
of GridTools.
When GridTools
is compiled with CUDA available, then the Atlas arrays are allocated both on the host (CPU) and device (GPU).
It is then possible to use atlas fields within CUDA kernels, and OpenACC.
ACC
This feature allows the use of OpenACC, provided that the feature GRIDTOOLS_STORAGE
is also enabled.
It is ON
by default, but depends on the OpenACC implementation within the compilers.
TRANS
This feature, ON
by default, enables the TransIFS spectral transforms capability.
It allows to perform direct and inverse spectral transforms in an MPI distributed parallel context.
The scope is limited only to global (Reduced) Gaussian grids!
It requires the availability of the transi optional dependency, which requires private access permissions at ECMWF,
as it is not open-source.
PROJ
This feature, OFF
by default grid projections defined by Proj, and relies on the package Proj to be available.
TESTS
This feature enables the compilation of Atlas unit tests.
Testing Atlas
The Atlas tests are managed by ctest
which is bundled with the CMake software.
To launch the tests, navigate to the build directory and execute
ctest --output-on-failure
To run only tests matching a certain regular expression, execute
ctest --output-on-failure -R <regex>
To get output from tests that pass, execute
Installing Atlas
To install atlas, navigate to the build directory, and simply execute
make install
Inspecting the Atlas installation
Once installation of atlas is complete, an executable called atlas
can be found within the Atlas install directory. Executing
export PATH=$atlas_ROOT/bin:$PATH
returns information respectively on:
- the version,
- a more detailed git-version-controlled identifier
- a more complete view on all the features that Atlas has been compiled with,
as well as compiler and compile flag information.
Also printed is the versions of used dependencies such as eckit and transi.
Note that the output may vary in your case depending on features and versions.