Amber¶

#!/bin/bash
#
# build-amber.sh — build Amber26 + AmberTools26 on Alps Grace-Hopper (daint gh200)
# inside the `amber/26.6` uenv.
#
# Prerequisites (see the Amber user guide):
#   * the amber uenv is loaded WITH the amber view, e.g.
#       uenv start --view=amber amber/26.6:rc3
#   * the Amber source archives have been extracted and AMBER_ROOT points at the
#     directory that contains ambertools26_src/ and pmemd26_src/.
#
# Usage:
#   export AMBER_ROOT=/path/to/amber      # dir containing ambertools26_src & pmemd26_src
#   ./build-amber.sh [cpu|gpu]            # default: gpu (MPI+CUDA build for GH200)
#
# The install goes into $AMBERHOME (default $AMBER_ROOT/amber26). Serial, MPI, CPU and
# CUDA executables all install side-by-side into the same $AMBERHOME/bin.
#
# On success, this script also packages $AMBERHOME as its own "amber-build" uenv by calling
# squash-amber.sh (must be in the same directory) — see that script and the Amber user guide.

set -euo pipefail

# ---------------------------------------------------------------------------
# 0. configuration
# ---------------------------------------------------------------------------
config="${1:-gpu}"

: "${AMBER_ROOT:?Set AMBER_ROOT to the directory containing ambertools26_src and pmemd26_src}"
: "${AMBERHOME:=$AMBER_ROOT/amber26}"
: "${NJOBS:=64}"

AMBERTOOLS_SRC="$AMBER_ROOT/ambertools26_src"
AMBER_SRC="$AMBER_ROOT/pmemd26_src"

case "$config" in
  cpu) amber_mpi=off; amber_cuda=off; amber_openmp=on ;;
  gpu) amber_mpi=on;  amber_cuda=on;  amber_openmp=off ;;
  *)   echo "usage: $0 [cpu|gpu]" >&2; exit 1 ;;
esac

# sanity: make sure we are inside the amber uenv view
if [[ "$(command -v cmake || true)" != /user-environment/* ]]; then
  echo "ERROR: this does not look like the amber uenv view." >&2
  echo "       start it first with:  uenv start --view=amber amber/26.6:rc3" >&2
  exit 1
fi
for d in "$AMBERTOOLS_SRC" "$AMBER_SRC"; do
  [[ -d "$d" ]] || { echo "ERROR: missing source directory $d" >&2; exit 1; }
done

AMBERTOOLS_BUILD="$AMBER_ROOT/build-ambertools-$config"
AMBER_BUILD="$AMBER_ROOT/build-amber-$config"

echo "=================================================================="
echo " Amber26 build"
echo "   config     : $config  (MPI=$amber_mpi CUDA=$amber_cuda OPENMP=$amber_openmp)"
echo "   AMBER_ROOT : $AMBER_ROOT"
echo "   AMBERHOME  : $AMBERHOME"
echo "   jobs       : $NJOBS"
echo "=================================================================="

# ---------------------------------------------------------------------------
# common CMake options
#   -DCMAKE_Fortran_FLAGS=-fPIC : required on Grace-Hopper (COMMON block size)
#   -DDOWNLOAD_MINICONDA=false  : never let Amber install its own conda (~115k inodes)
#   -DBUILD_PYTHON=on           : use the Python + packages provided by the uenv
#   -DBUILD_QUICK=off           : Quick's GPU build takes hours; enable only if you need it
#   -DCHECK_UPDATES=false       : don't phone home during configure
# ---------------------------------------------------------------------------
common_cmake=(
  -DCMAKE_INSTALL_PREFIX="$AMBERHOME"
  -DCOMPILER=GNU
  -DMPI="$amber_mpi" -DCUDA="$amber_cuda" -DOPENMP="$amber_openmp"
  -DDOWNLOAD_MINICONDA=false -DBUILD_PYTHON=on
  -DCMAKE_Fortran_FLAGS="-fPIC"
  -DBUILD_QUICK=off
  -DCHECK_UPDATES=false
)

# ---------------------------------------------------------------------------
# 1. AmberTools
# ---------------------------------------------------------------------------
echo; echo "### [1/2] AmberTools : configure"
rm -rf "$AMBERTOOLS_BUILD"; mkdir -p "$AMBERTOOLS_BUILD"; cd "$AMBERTOOLS_BUILD"
cmake "${common_cmake[@]}" "$AMBERTOOLS_SRC"

echo; echo "### [1/2] AmberTools : build (warnings -> at-error.log)"
make -j"$NJOBS" 2> at-error.log

echo; echo "### [1/2] AmberTools : install"
make install 2>> at-error.log

# ---------------------------------------------------------------------------
# 2. Amber / PMEMD
# ---------------------------------------------------------------------------
echo; echo "### [2/2] Amber/PMEMD : configure"
rm -rf "$AMBER_BUILD"; mkdir -p "$AMBER_BUILD"; cd "$AMBER_BUILD"
cmake "${common_cmake[@]}" -DPMEMD_ONLY=true "$AMBER_SRC"

echo; echo "### [2/2] Amber/PMEMD : build (warnings -> amber-error.log)"
make -j"$NJOBS" 2> amber-error.log

echo; echo "### [2/2] Amber/PMEMD : install"
make install 2>> amber-error.log

echo
echo "=================================================================="
echo " DONE. Installed into $AMBERHOME"
echo " pmemd executables:"
ls "$AMBERHOME"/bin/ | grep -iE 'pmemd|sander' | sed 's/^/   /'
echo
echo " Activate this installation in a new shell with:"
echo "   uenv start --view=amber amber/26.6:rc3"
echo "   source $AMBERHOME/amber.sh"
echo "=================================================================="

# ---------------------------------------------------------------------------
# 3. package $AMBERHOME as its own uenv, so it survives SCRATCH cleanup and stops
#    consuming inodes there (see squash-amber.sh).
# ---------------------------------------------------------------------------
script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
AMBERHOME="$AMBERHOME" "$script_dir/squash-amber.sh"

#!/bin/bash
#
# test-amber.sh — quick smoke test of an Amber26 installation built with the amber uenv.
#
# Runs a short GB simulation on one GPU with pmemd.cuda, and (if srun is available and you
# have >=2 GPUs) a short PME simulation across 2 GPUs with pmemd.cuda.MPI.
#
# Usage (inside the amber uenv, with the build already installed):
#   uenv start --view=amber amber/26.6:rc3
#   export AMBERHOME=/path/to/amber26        # or: source /path/to/amber26/amber.sh
#   ./test-amber.sh
#
set -euo pipefail

: "${AMBERHOME:?Set AMBERHOME to your Amber install (e.g. \$AMBER_ROOT/amber26)}"
work="$(mktemp -d "${SCRATCH:-/tmp}/amber-smoketest.XXXXXX")"
cd "$work"
echo "smoke-test working dir: $work"

# Locate a small GB test case (ACE-ALA3-NME) from the extracted pmemd sources.
# Set PMEMD_SRC to the pmemd26_src directory so the script can find it.
gb="${PMEMD_SRC:-}/test/cuda/gb_ala3"
if [[ -n "${PMEMD_SRC:-}" && -f "$gb/prmtop" ]]; then
  cp "$gb/prmtop" "$gb/inpcrd" .
else
  echo "NOTE: set PMEMD_SRC=\$AMBER_ROOT/pmemd26_src to auto-locate a test case." >&2
  echo "      Skipping — provide prmtop + inpcrd in $work to run this test." >&2
  exit 0
fi

cat > mdin <<'EOF'
GB smoke test
 &cntrl
  imin=0, irest=1, ntx=5, nstlim=20, dt=0.002, ntb=0,
  ntf=2, ntc=2, ntpr=5, ntwx=0, ntwr=0,
  cut=9999.0, rgbmax=9999.0, igb=1, ntt=0, ig=71277,
 /
EOF

echo "=== [1] pmemd.cuda : single-GPU GB run ==="
"$AMBERHOME/bin/pmemd.cuda" -O -i mdin -p prmtop -c inpcrd -o out.serial -r rst.serial
grep -iE "GPU IN USE|Device Name" out.serial | head -2
grep -q "Final Performance" out.serial && echo "  -> single-GPU run OK"

if command -v srun >/dev/null 2>&1 && [[ -x "$AMBERHOME/bin/pmemd.cuda.MPI" ]]; then
  echo "=== [2] pmemd.cuda.MPI : 2-GPU run (needs a real system; using JAC if present) ==="
  jac="${PMEMD_SRC}/test/cuda/jac"
  if [[ -f "$jac/prmtop" && -f "$jac/inpcrd.equil" ]]; then
    cp "$jac/prmtop" jac.prmtop; cp "$jac/inpcrd.equil" jac.inpcrd
    cat > mdin.jac <<'EOF'
JAC PME smoke test
 &cntrl
  ntx=5, irest=1, ntb=2, nstlim=50, dt=0.002, cut=8.0,
  ntt=1, ntc=2, ntf=2, ntp=1, taup=1.0, temp0=300.0,
  ntpr=10, ntwx=0, ntwr=0, ig=71277,
 /
EOF
    # --overlap: without it, srun can hang ("step creation temporarily disabled") when run
    # inside an interactive allocation that already has a step running (e.g. the login bash).
    srun --overlap -n2 "$AMBERHOME/bin/pmemd.cuda.MPI" -O -i mdin.jac -p jac.prmtop -c jac.inpcrd -o out.jacmpi -r rst.jacmpi
    grep -iE "Peer to Peer support" out.jacmpi | head -1
    grep -q "A V E R A G E" out.jacmpi && echo "  -> 2-GPU MPI run OK"
  else
    echo "  (JAC test case not found — skipping multi-GPU test)"
  fi
fi

echo "=== smoke test complete ==="

#!/bin/bash
#
# squash-amber.sh — package a built Amber26 installation ($AMBERHOME) as its own
# "amber-build" uenv, so it survives SCRATCH cleanup and stops consuming inodes there.
#
# The resulting image mounts at the exact $AMBERHOME path it was built at, and provides a
# single "amber-build" view that puts $AMBERHOME/bin on PATH and sets AMBERHOME. It is
# designed to be loaded ALONGSIDE the amber uenv (for CUDA/MPI/Python/...), not standalone:
#
#   uenv start amber/26.6:rc3,amber-build/2026:v1 --view=amber,amber-build
#
# Called automatically by build-amber.sh after a successful install. Can also be run by hand:
#
#   export AMBERHOME=/path/to/amber26   # an existing Amber install (built with build-amber.sh)
#   ./squash-amber.sh
#
set -euo pipefail

: "${AMBERHOME:?Set AMBERHOME to an existing Amber install (e.g. \$AMBER_ROOT/amber26)}"
: "${OUTPUT:=$(dirname "$AMBERHOME")/store.squashfs}"

# sanity: make sure this looks like a real Amber install
shopt -s nullglob
pmemd_bins=("$AMBERHOME"/bin/pmemd*)
shopt -u nullglob
[[ ${#pmemd_bins[@]} -gt 0 ]] || { echo "ERROR: no pmemd* executables found in $AMBERHOME/bin -- is AMBERHOME correct?" >&2; exit 1; }

echo "=================================================================="
echo " squash-amber: packaging \$AMBERHOME as the 'amber-build' uenv"
echo "   AMBERHOME : $AMBERHOME"
echo "   image     : $OUTPUT"
echo "=================================================================="

# ---------------------------------------------------------------------------
# 1. meta/env.json — a single view ("amber-build") that only adds $AMBERHOME/bin to PATH
#    (+ AMBERHOME, + LD_LIBRARY_PATH if $AMBERHOME/lib exists). It deliberately does NOT set
#    CC/CUDA_HOME/MPICC/etc: those come from the "amber" view, loaded alongside this one.
# ---------------------------------------------------------------------------
echo; echo "### [1/2] writing meta/env.json"
mkdir -p "$AMBERHOME/meta"
python3 - "$AMBERHOME" <<'PYEOF'
import json, os, sys

amberhome = sys.argv[1]

view = {
    "description": "Amber26 tools built with build-amber.sh. Load alongside the amber view for CUDA/MPI/Python.",
    "recipe_variables": {"list": {}, "scalar": {}},
    "root": amberhome,
    "env": {
        "version": 1,
        "values": {
            "list": {
                "PATH": [{"op": "prepend", "value": [f"{amberhome}/bin"]}],
            },
            "scalar": {
                "AMBERHOME": amberhome,
            },
        },
    },
}

libdir = os.path.join(amberhome, "lib")
if os.path.isdir(libdir):
    view["env"]["values"]["list"]["LD_LIBRARY_PATH"] = [{"op": "prepend", "value": [libdir]}]

env_json = {
    "name": "amber-build",
    "description": "Amber26 built with the amber uenv, must be loaded alongside amber.",
    "mount": amberhome,
    "default-view": "amber-build",
    "modules": None,
    "views": {"amber-build": view},
}

out = os.path.join(amberhome, "meta", "env.json")
with open(out, "w") as f:
    json.dump(env_json, f, indent=2)
    f.write("\n")
print(f"  -> wrote {out}")
PYEOF

# ---------------------------------------------------------------------------
# 2. mksquashfs — use the copy bundled in the amber uenv's store (a build-time-only
#    dependency, not linked into the "amber" view), falling back to PATH.
# ---------------------------------------------------------------------------
echo; echo "### [2/2] building $OUTPUT"
mksquashfs_bin="$(find /user-environment -maxdepth 4 -iname mksquashfs -type f 2>/dev/null | head -n1)"
if [[ -z "$mksquashfs_bin" ]]; then
  mksquashfs_bin="$(command -v mksquashfs || true)"
fi
[[ -n "$mksquashfs_bin" && -x "$mksquashfs_bin" ]] || {
  echo "ERROR: mksquashfs not found (expected inside the amber uenv store, e.g." >&2
  echo "       /user-environment/linux-*/squashfs-*/bin/mksquashfs). Is the amber uenv loaded?" >&2
  exit 1
}
echo "  using $mksquashfs_bin"
rm -f "$OUTPUT"
"$mksquashfs_bin" "$AMBERHOME" "$OUTPUT" -noappend

uenv_cfg="$(uenv config 2>/dev/null | awk '$1=="user:"{print $2}')"

echo
echo "=================================================================="
echo " DONE. Packaged $(du -h "$OUTPUT" | cut -f1) image: $OUTPUT"
echo
echo " The default uenv repository (\$SCRATCH/.uenv-images) lives on the same file system"
echo " this is meant to escape -- register the image in a repository on \$STORE instead:"
echo
echo "   uenv image add amber-build/2026:v1@daint%gh200 $OUTPUT"
echo
echo " Then use it alongside the amber uenv (the 'amber-build' view relies on 'amber' for"
echo " CUDA/MPI/Python):"
echo
echo "   uenv start amber/26.6:v1,amber-build/2026:v1 --view=amber,amber-build"
echo
echo " Once registered, empty out $AMBERHOME's *contents* to reclaim its inodes:"
echo "   rm -rf $AMBERHOME && mkdir -p $AMBERHOME"
echo " Leave the directory itself in place -- uenv mounts onto it but does not create it,"
echo " so it must still exist (empty) at this exact path for the amber-build uenv to start."
echo "=================================================================="