page build code · Wiki · Development / openfoam

Linux, Unix-like systems
Darwin (Mac-OS)
- Known issues
Windows

Linux, Unix-like systems

Version	Build
v2006	Build
v1912	Build
v1906	Build

Older versions use a general build guide webpage, which will be replaced by alternative content in the future.

Packaging systems

System	Links	Status	Notes
spack	package openfoam	Actively maintained by OpenCFD	notes
EasyBuild	package OpenFOAM	Maintained independently, with input from OpenCFD
debian	See precompiled	Actively maintained by OpenCFD
RPM-based	See precompiled	Actively maintained by OpenCFD

spack

The installation of openfoam with spack will generally require the latest (development version) of spack. If this is available, you can install openfoam in various configurations and dependencies, but typically can simply install directly:

$ spack install openfoam

OpenFOAM session

Depending on how your packaging system has handled things, an openfoam session command may be available as an alternative to the openfoam-selector mechanism. On the openSUSE installation, for example:

/usr/bin/openfoam -> openfoam1912
/usr/bin/openfoam1912
/usr/bin/openfoam-selector
/usr/bin/openfoam-selector-menu

Using openfoam -help displays some useful information.

Calling it without any arguments opens an interactive bash session with an OpenFOAM environment and your usual ~/.bashrc environment.

$ openfoam

Using: OpenFOAM-1912 - see www.openfoam.com
Arch:  linux64GccDPInt32Opt (mpi=openmpi-system)
OpenFOAM shell session - use exit to quit

OpenFOAM-1912:~/
mark$

If called with arguments, it will setup an OpenFOAM environment before executing a single command. For example,

$ blockMesh -help
blockMesh: Command not found.

$ openfoam blockMesh -help

Usage: blockMesh [OPTIONS]
Options:
   ...

Although the OpenFOAM environment is sourced after your home ~/.bashrc, it is advisable to ensure that there are no circular references from within your ~/.bashrc file.

Different compiler versions

By default, OpenFOAM handles newer/older non-system compilers as ThirdParty installations and uses the combination of WM_COMPILER and WM_COMPILER_TYPE to select them. In some cases, however, it can be much more convenient for the user to install prebuilt compiler binaries as system compilers (eg, using deb or rpm packages). This poses a slight problem since the OpenFOAM build rules normally use the main compiler name (gcc, clang etc) without any additional version information, but the various system compilers are frequently installed with versioned names such as gcc-8, clang-9 etc.

Here is a simple way to solve this, using clang-9 on openSUSE for the example:

Install the desired system compiler. In this case clang-9 from tools:compiler which installs /usr/bin/clang-9 and /usr/bin/clang++-9.
Next override the OpenFOAM compiler calls, but without blindly rewriting everything.

We create a new directory for our special rules:
```
mkdir wmake/rules/linux64Clang90
```
Inside this directory, we add a general rules file (wmake/rules/linux64Clang90/general) with the following contents:
```
# Override compiler calls for llvm-9

cc          = clang-9
CC          = clang++-9 -std=c++11
```
Or if this shall be restricted to system compilers only:
```
# Override compiler calls for llvm-9
ifeq ($(WM_COMPILER_TYPE),system)
    cc      = clang-9
    CC      = clang++-9 -std=c++11
endif
```
The final step is to select this compiler definition with the following combination:
```
# Preferences for system Clang90

export WM_COMPILER=Clang90
export WM_COMPILER_TYPE=system
```
If this change represents your standard default compiler definition, then place the information into the etc/prefs.sh file (see the etc/bashrc file for some details) and re-source your OpenFOAM environment.

If you would like to selectively enable this compiler definition, a common means is to place the same definition information into a user configuration file (for example, ~/.OpenFOAM/clang90) and then specify that configuration when sourcing your OpenFOAM environment. For example,
```
source /path/to/OpenFOAM-version/etc/bashrc  clang90
```
The bashrc will locate and use the configuration file, after which the compiler will be properly selected. To verify that this is indeed the case:
```
wmake -show-cxx
```
should display the selected compiler. You may also wish to verify its path:
```
wmake -show-path-cxx
```
For older versions, which $(wmake -show-cxx) instead.

Darwin (Mac-OS)

The support for Darwin is complete, but is less well tested than Linux.

The Darwin build (and operation) requires a case-sensitive file system, which is often created as a disk image and mounted (for older systems).
Compilation uses the system clang compiler.

Known issues

CGAL

ThirdParty CGAL will normally need to be compiled without mpfr/gmp. This should be done manually prior to building OpenFOAM or other ThirdParty. Eg,
```
cd $WM_THIRD_PARTY_DIR
./makeCGAL gmp-none mpfr-none
```
The wmake/rules/darwin64Clang/CGAL file has been adjusted to eliminate references to gmp/mpfr libraries.

Windows

Starting with v1906, Windows source compilation is supported via cross-compilation using the mingw compiler on 64bit Linux to generate a Win64 target. See the version-relevant build information.