K Kuck: Created page with "Note that the instructions provided below refer to R 4.5.1! = General information = [https://rspatial.github.io/terra/ '''terra'''] is a R package for spatial data analysis with vectors (points, lines, polygons) and raster (grid) data. [https://github.com/r-spatial/sf '''sf'''] is a R package that provides [https://en.wikipedia.org/wiki/Simple_Features simple feature] access for R. In order to install those, we need to fulfill the..."

2025-11-25T14:48:18Z

Created page with "Note that the instructions provided below refer to R 4.5.1! = General information = [https://rspatial.github.io/terra/ '''terra'''] is a R package for spatial data analysis with vectors (points, lines, polygons) and raster (grid) data. [https://github.com/r-spatial/sf '''sf'''] is a R package that provides [https://en.wikipedia.org/wiki/Simple_Features simple feature] access for R. In order to install those, we need to fulfill the..."

New page

Note that the instructions provided below refer to R 4.5.1!

= General information =
[https://rspatial.github.io/terra/ '''terra'''] is a R package for spatial data analysis with vectors (points, lines, polygons) and raster (grid) data.

[https://github.com/r-spatial/sf '''sf'''] is a R package that provides [https://en.wikipedia.org/wiki/Simple_Features simple feature] access for R.

In order to install those, we need to fulfill the following [https://cran.r-project.org/web/packages/terra/index.html system requirements]:
* [https://gdal.org/ GDAL] 2.2.3 or higher
* [https://proj.org/ PROJ] 4.9.3 or higher
* [https://libgeos.org/ GEOS] 3.4.0 or higher

These packages are not available centrally on the cluster, but can be installed manually (to the <code>$HOME</code>-directory). Specifically, to install these packages, they need to be built from source.

= Installation =

Please enter (or copy & paste) the code, presented in the boxes below, directly into your shell/command line on bwUniCluster. The whole process will take approximately 45 minutes.

First, for compilation we obtain an interactive session with multiple cores (on a compute node):
<pre>
# Obtain interactive session
salloc -n 8 -t 60 -p cpu
</pre>

== Preparations ==
Prepare an <code>.R/Makevars</code> file (if it does not already exist). This file specifies how R should compile the packages (i.e., sets some 'compiler flags').

If an <code>.R/Makevars</code> file is present in your home directory (<code>$HOME</code>), check whether the flags displayed below are already set and apply adjustments, if necessary:
<pre>
cat $HOME/.R/Makevars

CXX14=g++
CXX17=g++
CFLAGS+=-O3 -fPIC -malign-data=cacheline -finline-functions -m64 -Wno-implicit-function-declaration
CXXFLAGS+=-O3 -fPIC -malign-data=cacheline -finline-functions -m64 -Wno-implicit-function-declaration
CXX14FLAGS += -std=c++14
CXX17FLAGS += -std=c++17 -fPIC
</pre>

Please run the following lines of code to set the flags, if necessary:
<pre>
mkdir -p ~/.R

echo "CXX14=g++" > $HOME/.R/Makevars
echo "CXX17=g++" >> $HOME/.R/Makevars
echo "CFLAGS+=-O3 -fPIC -malign-data=cacheline -finline-functions -m64 -Wno-implicit-function-declaration" >> $HOME/.R/Makevars
echo "CXXFLAGS+=-O3 -fPIC -malign-data=cacheline -finline-functions -m64 -Wno-implicit-function-declaration" >> $HOME/.R/Makevars
echo "CXX14FLAGS += -std=c++14" >> $HOME/.R/Makevars
echo "CXX17FLAGS += -std=c++17 -fPIC" >> $HOME/.R/Makevars
</pre>

Next, we create the directories for the source code and installation targets, respectively. Furthermore, we load all (software) modules relevant for compilation and ensure that the compilers are found:

<pre>
# We install the libraries into the ~/sw/R directory.
mkdir -p ~/sw/R

# Source directory.
mkdir -p ~/src

# Load required modules.
module purge
module load devel/python/3.13.3-gnu-14.2

# Check that the GNU compiler 14.2 is loaded.
gcc --version

# Set compiler for cmake and make.
export CC=$(which gcc)
export CXX=$(which g++)
</pre>

Since the Python 3.13.3 module is missing some required packages, we install them in a virtual environment in <code>$HOME</code>:
<pre>
# We create a virtual environment "terra" for additional dependencies
python3.13 -m venv terra
source terra/bin/activate
python -m pip install --upgrade pip
pip install numpy setuptools ruamel.yaml
</pre>

== Install external programs ==

First, we download the sources of GDAL, PROJ, GEOS (and their dependencies) and install them:

=== Install PROJ ===
<pre>
# Download and unpack the PROJ source code:
PROJ_VER=9.7.0
cd $HOME/src
wget http://download.osgeo.org/proj/proj-$PROJ_VER.tar.gz
tar xf proj-$PROJ_VER.tar.gz

cd proj-$PROJ_VER
mkdir build && cd build

# Compile and install PROJ:
cmake -DCMAKE_INSTALL_PREFIX="$HOME/sw/R" ..
cmake --build . -j 8
cmake --build . --target install
</pre>

=== Install GDAL ===
Building GDAL requires newer versions of <code>OpenEXR</code> and <code>libdeflate</code> then available on the system.

<pre>
# Download and unpack the libdeflate source code:
cd $HOME/src
git clone https://github.com/ebiggers/libdeflate

cd libdeflate
mkdir build && cd build

# Compile libdeflate
cmake -DCMAKE_INSTALL_PREFIX="$HOME/sw/R" \
-DCMAKE_PREFIX_PATH="$HOME/sw/R" \
-DCMAKE_BUILD_TYPE=Release ..
cmake --build . -j 8
cmake --build . --target install

# Download and unpack the OpenEXR source code:
OPENEXR_VER=3.4.4
cd $HOME/src
wget https://github.com/AcademySoftwareFoundation/openexr/releases/download/v$OPENEXR_VER/openexr-$OPENEXR_VER.tar.gz
tar xf openexr-$OPENEXR_VER.tar.gz

cd openexr-$OPENEXR_VER/
mkdir build && cd build

# Compile OpenEXR:
cmake -DCMAKE_INSTALL_PREFIX="$HOME/sw/R" -DCMAKE_BUILD_TYPE=Release ..
cmake --build . -j 8
cmake --build . --target install
</pre>

Now, all necessary dependencies are available and we can build <code>GDAL</code>:

<pre>
# Download and unpack the GDAL source code:
cd $HOME/src
GDAL_VER=3.12.0
wget http://download.osgeo.org/gdal/$GDAL_VER/gdal-$GDAL_VER.tar.gz
tar xf gdal-$GDAL_VER.tar.gz

cd gdal-$GDAL_VER
mkdir build && cd build

cmake -DCMAKE_INSTALL_PREFIX="$HOME/sw/R" \
-DCMAKE_PREFIX_PATH="$HOME/sw/R" \
-DCMAKE_BUILD_TYPE=Release ..
cmake --build . -j 8
cmake --build . --target install
</pre>

=== Install GEOS ===

The last external package that needs to be compiled and installed is <code>GEOS</code>:
<pre>
# Download and unpack the GEOS source code.
cd $HOME/src
GEOS_VER=3.14.1
wget http://download.osgeo.org/geos/geos-$GEOS_VER.tar.bz2
tar xf geos-$GEOS_VER.tar.bz2

cd geos-$GEOS_VER
mkdir build && cd build

# Compile GEOS:
cmake -DCMAKE_INSTALL_PREFIX="$HOME/sw/R" \
-DCMAKE_PREFIX_PATH="$HOME/sw/R" \
-DCMAKE_BUILD_TYPE=Release ..
make -j 8
ctest j 8
make install
</pre>

<pre>
cd $HOME/src
UDUNITS_VER=2.2.28

wget https://downloads.unidata.ucar.edu/udunits/$UDUNITS_VER/udunits-$UDUNITS_VER.tar.gz
tar -xzf udunits-$UDUNITS_VER.tar.gz
cd udunits-$UDUNITS_VER

./configure --prefix="$HOME/sw/R"
make -j 8
make check -j 8
make install

</pre>

== Install the R packages ==

In order to install the two R packages, we need to inform R where to find <code>PROJ</code>, <code>GDAL</code> and <code>GEOS</code>, so we export the necessary paths:

<pre>
export LD_LIBRARY_PATH=$HOME/sw/R/lib64:$HOME/sw/R/lib:$LD_LIBRARY_PATH
export PATH=$PATH:$HOME/sw/R/bin
export PKG_CONFIG_PATH=$PKG_CONFIG_PATH:$HOME/sw/R/lib64/pkgconfig
export GDAL_DATA=$HOME/sw/R/share/gdal
</pre>

Additionally, the R package installation features compilation of built-in C++ code, for which we specify compilation options ('compiler flags')

<pre>
export CFLAGS+=-I$HOME/sw/R/include
#export CXXFLAGS+=-I$HOME/sw/R/include
export UDUNITS2_INCLUDE=$HOME/sw/R/include
export UDUNITS2_LIBS=$HOME/sw/R/lib
</pre>

Now, we install <code>terra</code> and <code>sf</code> from within <code>R</code>.

<pre>
module load math/R

R -q
R> install.packages("terra")
R> library(terra)

R> install.packages("sf")
R> install.packages("sf", type = "source", configure.args = c("--with-udunits2-include=$HOME/sw/R/include", "--with-udunits2-lib=$HOME/sw/R/lib"))
R> library(sf)
</pre>

= Preparations to use the terra and sf packages =
Since <code>terra</code> and <code>sf</code> depend on the external programs we installed, several environment variables have to be set before using the packages to allow R to address these programs.

We recommend to add the export commands

<pre>
export LD_LIBRARY_PATH=$HOME/sw/R/lib:$HOME/sw/R/lib64:$LD_LIBRARY_PATH
export PATH=$PATH:$HOME/sw/R/bin
export PKG_CONFIG_PATH=$PKG_CONFIG_PATH:$HOME/sw/R/lib64/pkgconfig
export GDAL_DATA=$HOME/sw/R/share/gdal
export UDUNITS2_LIBS=$HOME/sw/R/lib
</pre>

to your [[BwUniCluster_2.0_Slurm_common_Features#sbatch_Examples | batch job scripts]] that use <code>terra</code> and <code>sf</code> or to use them in an [[BwUniCluster_2.0_Batch_Queues | interactive session]].

Furthermore, Python 3.13 and the virtual environment terra (created above) should be loaded:
<pre>
module load devel/python/3.13.3-gnu-14.2
source terra/bin/activate
</pre>

Then, R can be loaded:
<pre>
module load math/R/4.5.1
</pre>

BwUniCluster3.0/Software/R/terra - Revision history