Third-party dependencies

GEOS makes use of multiple third-party libraries (TPLs) and tools, some of which are mandatory and some optional. We only test against specific versions, and sometimes even require development snapshots (specific git commits). Not all of these guarantee backwards compatibility, so we strongly recommend building with these specific versions.

List of third-party libraries and tools

The tables below list the dependencies and the relevant CMake variables. The exact versions that GEOS is tested with are defined in the thirdPartyLibs CMake script (and, for Spack builds, in scripts/spack_configs/versions.yaml of the same repository), which is the reference. Some of these libraries may have their own system prerequisites.

Libraries

The following libraries are linked to by GEOS:

Name	Enable option	Path variable	Description
Adiak	`ENABLE_CALIPER`	`ADIAK_DIR`	Library for collecting metadata from HPC application runs, and distributing that metadata to subscriber tools.
Caliper	`ENABLE_CALIPER`	`CALIPER_DIR`	Instrumentation and performance profiling library.
conduit	mandatory	`CONDUIT_DIR`	Simplified Data Exchange for HPC Simulations.
CHAI	mandatory	`CHAI_DIR`	Copy-hiding array abstraction to automatically migrate data between memory spaces (includes Umpire).
RAJA	mandatory	`RAJA_DIR`	Collection of C++ software abstractions that enable architecture portability for HPC applications.
fmt	mandatory	`FMT_DIR`	Formatting library.
hdf5	mandatory	`HDF5_DIR`	High-performance data management and storage suite.
pugixml	mandatory	`PUGIXML_DIR`	Light-weight, simple and fast XML parser for C++ with XPath support.
mathpresso	`ENABLE_MATHPRESSO`	`MATHPRESSO_DIR`	Mathematical Expression Parser and JIT Compiler (used by `SymbolicFunction`).
metis	`ENABLE_METIS`	`METIS_DIR`	Serial graph partitioning library.
parmetis	`ENABLE_PARMETIS`	`PARMETIS_DIR`	Parallel graph partitioning library. Should be built with 64-bit `idx_t` type.
scotch	`ENABLE_SCOTCH`	`SCOTCH_DIR`	Graph partitioning library (alternative to ParMETIS).
suitesparse	`ENABLE_SUITESPARSE`	`SUITESPARSE_DIR`	A suite of sparse matrix software.
superlu_dist	`ENABLE_SUPERLU_DIST`	`SUPERLU_DIST_DIR`	General purpose library for the direct solution of large, sparse, nonsymmetric systems of linear equations.
hypre	`ENABLE_HYPRE`	`HYPRE_DIR`	Library of high performance preconditioners and solvers for large sparse linear systems on massively parallel computers.
hypredrive	`ENABLE_HYPREDRV`	`HYPREDRV_DIR`	Driver for configuring hypre solvers from YAML files.
PETSc	`ENABLE_PETSC`	`PETSC_DIR`	Suite of data structures and routines for the scalable (parallel) solution of scientific applications.
Trilinos	`ENABLE_TRILINOS`	`TRILINOS_DIR`	Collection of reusable scientific software libraries, known in particular for linear solvers.
silo	`ENABLE_SILO`	`SILO_DIR`	A Mesh and Field I/O Library and Scientific Database.
VTK	`ENABLE_VTK`	`VTK_DIR`	Open source software for manipulating and displaying scientific data (VTK mesh input and output).

Tools

The following tools are used as part of the build process to support GEOS development:

Name	Enable option	Path variable	Description
doxygen	`ENABLE_DOXYGEN`	`DOXYGEN_EXECUTABLE`	De facto standard tool for generating documentation from annotated C++ sources.
sphinx	`ENABLE_SPHINX`	`SPHINX_EXECUTABLE`	A tool that makes it easy to create intelligent and beautiful documentation.
uncrustify	`ENABLE_UNCRUSTIFY`	`UNCRUSTIFY_EXECUTABLE`	A source code beautifier for C, C++, C#, ObjectiveC, D, Java, Pawn and VALA.

Some other dependencies (GoogleTest, GoogleBenchmark) are provided through BLT build system which is embedded in GEOS source. No actions are needed to build them.

Docker images with all dependencies already compiled are published for every TPL update (see Fastest path: Docker or GitHub Codespaces). The Dockerfiles used to create them are part of the thirdPartyLibs repository.

Building bundled dependencies

To simplify the process of building TPLs, we provide a git repository thirdPartyLibs. It contains a CMake script that downloads the exact TPL versions required and builds all of them in a single command (the build machine therefore needs internet access). A step-by-step example is given in the Quick Start Guide.

The recommended steps to build TPLs are:

Create a host-config file that sets all system-specific CMake variables (compiler and library paths, configuration flags, etc.) Take a look at host-config examples.
Configure via config-build.py script:
```
cd thirdPartyLibs
python3 scripts/config-build.py --hostconfig=/path/to/host-config.cmake --buildtype=Release --installpath=/path/to/install/dir -DNUM_PROC=8
```
The options are the same as for GEOS (see Building GEOS). -DNUM_PROC=N sets the number of cores used to build each library (default: all cores of the machine).
Run the build:
```
cd <buildpath>
make
```
Warning

Do not provide -j argument to make here, since the top-level make only launches sub-project builds. Instead use the -DNUM_PROC option above, which is passed to each sub-project’s make command.

You may also run the CMake configure step manually instead of relying on config-build.py. The full TPL build may take anywhere between 30 minutes and a few hours, depending on your machine, number of threads and libraries enabled.

Note

An exception from the above pattern, sphinx is currently not a part of the TPL bundle and must be installed with your Python or package manager.

Installing dependencies individually

You may also install each individual TPL separately, either manually or through a package manager. This is a more difficult route, since you are responsible for configuring dependencies in a compatible manner. Again, we strongly recommend using the exact versions used by the thirdPartyLibs repository, to avoid possible build problems.

You may look at our TPL CMake script to see how we configure TPL builds.