Skip to content
NAISS Logo Allocations Support Training Software naiss.se

Psi4

Arrhenius

How to install Psi4

Start an interactive session on a GPU node:

interactive -A naiss202t-u-xyz-gpu --partition gpu --gpus=1  -t 02:00:00

Load the build environment and modules:

ml GPU/buildenv-gcccuda/2026.03-cu13.0
ml GPU/Python/3.13.5-bare-gcc-2025b-eb

Create a suitable folder in your project:

mkdir -p /your-project-folder/Psi4 
cd /your-project-folder/Psi4 

Export the following environment variables:

export CUDA_HOME=/software/sse2/el9_gh200/manual/CUDA/13.0.3_580.126.20
export MAGMA_ROOT="$PWD/opt/magma-2.10.0-cuda13"
export PSI4_ROOT="$PWD/opt/psi4-1.11-gh200"
export WORK="$PWD/src/psi4-gh200"
export PATH="$CUDA_HOME/bin:$PATH"
export LD_LIBRARY_PATH="$CUDA_HOME/targets/sbsa-linux/lib${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
export OPENBLAS_ROOT=/software/sse2/el9_gh200/manual/OpenBLAS/0.3.32/g14/hpc1/openmp/lp64
export MATH_ROOT="$OPENBLAS_ROOT"
export OPENBLAS_LIB="$OPENBLAS_ROOT/lib/libopenblas.so"

Start with installations, first MAGMA

mkdir -p "$WORK" "$PWD/opt"
cd "$WORK"
git clone --branch v2.10.0 --depth 1 https://github.com/icl-utk-edu/magma.git magma-2.10.0
cd "$WORK/magma-2.10.0"

# apply a small patch
cat > make.inc <<EOF
BACKEND = cuda
GPU_TARGET = sm_90
CUDADIR = $CUDA_HOME
CC = gcc
CXX = g++
FORT = gfortran
NVCC = $CUDA_HOME/bin/nvcc
EOF

# generate make
make generate

# now cmake
cd ..
cmake --fresh \
    -S "$WORK/magma-2.10.0" \
    -B "$WORK/build-magma" \
    -DCMAKE_BUILD_TYPE=Release \
    -DCMAKE_INSTALL_PREFIX="$MAGMA_ROOT" \
    -DCMAKE_C_COMPILER="$(which gcc)" -DCMAKE_CXX_COMPILER="$(which g++)" -DCMAKE_Fortran_COMPILER="$(which gfortran)" \
    -DCMAKE_CUDA_COMPILER="$CUDA_HOME/bin/nvcc" -DCUDAToolkit_ROOT="$CUDA_HOME" -DMAGMA_ENABLE_CUDA=ON \
    -DGPU_TARGET=sm_90 -DBLA_VENDOR=OpenBLAS  -DBUILD_SHARED_LIBS=ON

cmake --build "$WORK/build-magma" --target lib --parallel 8
cmake --build "$WORK/build-magma" --parallel 8
cmake --install "$WORK/build-magma"

Install Python dependencies in an isolated environment:

cd /your-project-folder/Psi4 
python3 -m venv --system-site-packages "$PWD/opt/psi4-venv-py313"
source "$PWD/opt/psi4-venv-py313/bin/activate"
python -m pip install --upgrade pip setuptools wheel
python -m pip install --no-cache-dir networkx pint 'pydantic>=2.11' psutil py-cpuinfo packaging 'qcelemental>=0.50.4' 'qcengine>=0.50.0' 'qcmanybody>=0.7.1'
python -m pip install --no-cache-dir 'git+https://github.com/psi-rking/optking.git@0.5.0'

Install Eigen3

cd $WORK

export EIGEN_ROOT="$(dirname "$PSI4_ROOT")/eigen-3.4.0"
export CPLUS_INCLUDE_PATH="$EIGEN_ROOT/include${CPLUS_INCLUDE_PATH:+:$CPLUS_INCLUDE_PATH}"
git clone --branch 3.4.0 --depth 1 https://gitlab.com/libeigen/eigen.git eigen-3.4.0

cmake -S "$WORK/eigen-3.4.0" -B "$WORK/build-eigen" -DCMAKE_INSTALL_PREFIX="$EIGEN_ROOT" \
      -DBUILD_TESTING=OFF -DEIGEN_BUILD_TESTING=OFF -DEIGEN_BUILD_DOC=OFF

cmake --install "$WORK/build-eigen"

export EIGEN3_DIR="$(find "$EIGEN_ROOT" -type f -name Eigen3Config.cmake -printf '%h\n' -quit )"

Now install Psi4

cd "$WORK"
git clone --branch v1.11 --depth 1 https://github.com/psi4/psi4.git psi4-1.11

cd "$WORK/psi4-1.11"
cp external/upstream/gauxc/CMakeLists.txt external/upstream/gauxc/CMakeLists.txt.orig
# apply a patch
python - <<'PY'
from pathlib import Path
path = Path("external/upstream/gauxc/CMakeLists.txt")
text = path.read_text()
old = "NOT DEFINED ${CMAKE_CUDA_ARCHITECTURES}"
new = 'NOT DEFINED CMAKE_CUDA_ARCHITECTURES'
if old not in text:
    raise SystemExit("Expected CMake condition not found; no changes made.")
path.write_text(text.replace(old, new, 1))
print("Patched:", path)
PY

cd $WORK/build-psi4-gh200
python - <<'PY'
import os
from pathlib import Path
import shutil

build = Path(os.environ["WORK"]) / "build-psi4-gh200"

headers = [
    build / "stage/include/pybind11/typing.h",
    build / (
        "external/upstream/pybind11/"
        "pybind11_external-prefix/src/pybind11_external/"
        "include/pybind11/typing.h"
    ),
]

for path in headers:
    if not path.is_file():
        print("Not found, skipping:", path)
        continue

    text = path.read_text()

    if "#include <algorithm>" in text:
        print("Already fixed:", path)
        continue

    if "#pragma once" not in text:
        raise RuntimeError(f"Unexpected header structure: {path}")

    shutil.copy2(path, str(path) + ".backup")

    text = text.replace(
        "#pragma once",
        "#pragma once\n#include <algorithm>",
        1
    )

    path.write_text(text)
    print("Patched:", path)
PY


cmake --fresh -S "$WORK/psi4-1.11" \
    -B "$WORK/build-psi4-gh200" \
    -DCMAKE_BUILD_TYPE=Release \
    -DCMAKE_INSTALL_PREFIX="$PSI4_ROOT" \
    -DCMAKE_C_COMPILER="$(which gcc)" \
    -DCMAKE_CXX_COMPILER="$(which g++)" -DCMAKE_Fortran_COMPILER="$(which gfortran)" \
    -DPython_EXECUTABLE="$(which python)" -DCMAKE_CUDA_COMPILER="$CUDA_HOME/bin/nvcc" \
    -DCUDAToolkit_ROOT="$CUDA_HOME" -DCMAKE_CUDA_ARCHITECTURES=90 -DEigen3_ROOT="$EIGEN_ROOT" \
    -DEigen3_DIR="$EIGEN3_DIR" -DCMAKE_PREFIX_PATH="$EIGEN_ROOT;$MAGMA_ROOT"  -DBLAS_TYPE=OPENBLAS  -DLAPACK_TYPE=OPENBLAS \
    -DENABLE_gauxc=ON  -Dgauxc_ENABLE_GPU=ON -Dgauxc_ENABLE_MAGMA=ON

cmake --build "$WORK/build-psi4-gh200" --target libint2_external --parallel 8
cmake --build "$WORK/build-psi4-gh200" --parallel 8
cmake --install "$WORK/build-psi4-gh200"

How to use Psi4

Example job script for a GPU run on 1 GPU card:

#!/bin/bash
#SBATCH -A XXXX-XX-XX
#SBATCH -J psi4-test
#SBATCH -t 00:15:00
#SBATCH -p gpu
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=4
#SBATCH --gpus=1

# load the same environment used to build Psi4
module load GPU/buildenv-gcccuda/2026.03-cu13.0
module load GPU/Python/3.13.5-bare-gcc-2025b-eb

# paths to your installation
export PSI4_BASE="/your-project-folder/Psi4"
export PSI4_ROOT="$PSI4_BASE/opt/psi4-1.11-gh200"
export MAGMA_ROOT="$PSI4_BASE/opt/magma-2.10.0-cuda13"
export PSI4_VENV="$PSI4_BASE/opt/psi4-venv-py313"
export CUDA_HOME="/software/sse2/el9_gh200/manual/CUDA/13.0.3_580.126.20"
export OPENBLAS_ROOT="/software/sse2/el9_gh200/manual/OpenBLAS/0.3.32/g14/hpc1/openmp/lp64"

# activate Python and expose Psi4
source "$PSI4_VENV/bin/activate"
export PATH="$PSI4_ROOT/bin:$PATH"
export LD_LIBRARY_PATH="$PSI4_ROOT/lib:$MAGMA_ROOT/lib:$CUDA_HOME/targets/sbsa-linux/lib:$OPENBLAS_ROOT/lib${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"

# CPU threading
export OMP_NUM_THREADS="${SLURM_CPUS_PER_TASK:-4}"
export OPENBLAS_NUM_THREADS="$OMP_NUM_THREADS"
export OMP_PROC_BIND=close
export OMP_PLACES=cores

# return to the calculation directory
cd "$SLURM_SUBMIT_DIR"

# Set Psi4 scratch directory
export PSI_SCRATCH="${SLURM_TMPDIR:-${TMPDIR:-$PWD/scratch-$SLURM_JOB_ID}}"
mkdir -p "$PSI_SCRATCH"

psi4 --version

# Run GPU GauXC test
srun --cpu-bind=cores psi4 -i input.dat -o output.out -n "$OMP_NUM_THREADS"