OpenFOAM: parameter sweeps, automation and parallel computing

The difference between the mean pressures on the inlet and outlet patches collects everything that happens in the domain: the loss caused by the cylinder, any friction on the side boundaries, the momentum-flux difference between two non-uniform velocity profiles and the wake not yet recovered at the outlet section. That is why it changes when the outlet is moved downstream, even with the same cylinder.

The force on the cylinder alone is obtained by integrating pressure and viscous stresses over its surface, with the forces function object (or forceCoeffs for dimensionless coefficients) applied to the cylinder patch. The exact patch name is in constant/polyMesh/boundary after blockMesh and mirrorMesh. In incompressible cases p is kinematic and the force must be converted to newtons with a declared reference density, exactly like the Δp in this guide: the version 14 keywords are in the forces API documentation.

# patch names and types after mesh generation
less constant/polyMesh/boundary

For a cylinder of diameter D in a stream of velocity U and kinematic viscosity ν, the parameter governing the regime is Re = U·D/ν. The case viscosity is in constant/physicalProperties, the diameter follows from the geometry in system/blockMeshDict. In the campaign the velocity changes by a factor of 4 (from 0.005 to 0.020 m/s), so Re changes by a factor of 4 as well.

For a circular cylinder in an unbounded stream the wake is steady up to Re ≈ 47; above it periodic vortex shedding appears. If the campaign range crosses this threshold, some cases will be steady and others periodic: for the latter the last recorded sample depends on the phase of the oscillation and the comparison must use time averages over a whole number of periods. Confinement shifts the threshold, so it must be checked in the logs and samples, not assumed.

# case viscosity and geometry
foamDictionary constant/physicalProperties -entry nu -value
less system/blockMeshDict

foamDictionary parses the dictionary the way OpenFOAM does, so it is more reliable than sed or grep on files with macros, comments and sub-dictionaries. Nested entries are addressed with a slash.

foamDictionary 0/U -keywords                         # top-level keywords
foamDictionary 0/U -entry Uinlet -value             # velocity value
foamDictionary 0/U -entry boundaryField/inlet       # condition on the inlet patch
foamDictionary -expand 0/U                          # file with $Uinlet macros substituted
foamDictionary system/controlDict -entry endTime -value
foamDictionary system/controlDict -entry functions -keywords

The last line is the quickest way to check, after preparation, that the controlDict of each case contains pIn, pOut, qIn and qOut. Always read the tutorial Allrun as well (cat "$FOAM_TUTORIALS/incompressibleFluid/cylinder/Allrun"): it is the official description of the sequence the scripts reproduce.

config/velocities.csv: one row per case, mandatory header, decimal point.

case_id,U_m_s
U005,0.005
U010,0.010
U015,0.015
U020,0.020

config/measurement_functions.foam: the functions block the script appends to the controlDict of each case.

// Tutorial package: quantities measured during the solver run.
// This block is appended to the clean OpenFOAM-14 cylinder controlDict.
functions
{
    pIn
    {
        type surfaceFieldValue;
        libs ("libfieldFunctionObjects.so");
        patch inlet;
        operation areaAverage;
        fields (p);
        writeControl writeTime;
        writeFields false;
        log true;
    }
    pOut
    {
        type surfaceFieldValue;
        libs ("libfieldFunctionObjects.so");
        patch outlet;
        operation areaAverage;
        fields (p);
        writeControl writeTime;
        writeFields false;
        log true;
    }
    qIn
    {
        type surfaceFieldValue;
        libs ("libfieldFunctionObjects.so");
        patch inlet;
        operation sum;
        fields (phi);
        writeControl writeTime;
        writeFields false;
        log true;
    }
    qOut
    {
        type surfaceFieldValue;
        libs ("libfieldFunctionObjects.so");
        patch outlet;
        operation sum;
        fields (phi);
        writeControl writeTime;
        writeFields false;
        log true;
    }
}

The scripts are distributed under the GNU GPL version 3 or later; the OpenFOAM tutorial files are not included in the package and remain under their own licence. The full text of the four scripts is given further on, in the sections where they are used.

file scripts/*.sh config/velocities.csv      # reports "with CRLF line terminators" and "with BOM"
grep -c $'\r' scripts/run_campaign.sh          # lines with CR: must be 0
sed -i 's/\r$//' scripts/*.sh                 # fix if dos2unix is not installed

The CSV is more forgiving than the scripts: prepare_campaign.sh strips any trailing \r from each field itself, so a CSV with Windows line endings is read correctly. It does not tolerate the BOM that some programs (Excel above all) add at the start of UTF-8 files: the header becomes “\ufeffcase_id”, is not recognised as the header, fails the name check and the script stops with ERROR: invalid row and exit code 3. In Notepad++ choose Encoding → UTF-8 (without BOM) before saving.

bash -n only checks syntax: it executes nothing, so it does not catch missing environment variables or wrong paths. The scripts perform those checks themselves at start-up.

#!/usr/bin/env bash
# GPL-3.0-or-later. Prepare fresh, isolated cases from the official
# OpenFOAM Foundation 14 incompressibleFluid/cylinder tutorial.
set -Eeuo pipefail
root=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd -P)
source_case="${FOAM_TUTORIALS:-}/incompressibleFluid/cylinder"
case_root="$root/work/cases"

if ! command -v foamVersion >/dev/null 2>&1 || ! command -v foamDictionary >/dev/null 2>&1; then
  echo "ERROR: source the OpenFOAM Foundation 14 environment first." >&2; exit 2
fi
if [[ "$(foamVersion)" != *14* ]]; then
  echo "ERROR: this package targets OpenFOAM Foundation 14, got: $(foamVersion)" >&2; exit 2
fi
if [[ ! -f "$source_case/0/U" || ! -f "$source_case/system/blockMeshDict" ]]; then
  echo "ERROR: missing official tutorial at $source_case" >&2; exit 2
fi
if [[ ! -d "$case_root" ]]; then mkdir -p -- "$case_root"; fi

while IFS=, read -r name speed || [[ -n "${name:-}" ]]; do
  name=${name%$'\r'}; speed=${speed%$'\r'}
  [[ "$name" == case_id || -z "$name" ]] && continue
  if [[ ! "$name" =~ ^[A-Za-z0-9_-]+$ || ! "$speed" =~ ^(0|[0-9]+)(\.[0-9]+)?([eE][-+]?[0-9]+)?$ ]] ||
     ! awk -v v="$speed" 'BEGIN{exit !(v>0 && v<=1)}'; then
    echo "ERROR: invalid row: $name,$speed" >&2; exit 3
  fi
  case_dir="$case_root/$name"
  if [[ -e "$case_dir" ]]; then
    echo "SKIP existing case $case_dir (no overwrite)"; continue
  fi
  mkdir -- "$case_dir"
  # Copy only case INPUTS, never any pre-existing results or solver logs.
  cp -a -- "$source_case/0" "$source_case/constant" "$source_case/system" "$case_dir/"
  if [[ -d "$case_dir/constant/polyMesh" ]]; then
    echo "ERROR: source unexpectedly contains a mesh; review case $case_dir" >&2; exit 4
  fi
  foamDictionary "$case_dir/0/U" -entry Uinlet -set "$speed" >/dev/null
  cat "$root/config/measurement_functions.foam" >> "$case_dir/system/controlDict"
  printf 'case_id,U_m_s\n%s,%s\n' "$name" "$speed" > "$case_dir/parameters.csv"
  (cd "$case_dir" && sha256sum 0/U system/controlDict system/fvSolution system/fvSchemes constant/physicalProperties constant/momentumTransport > input.sha256)
  printf 'PREPARED\n' > "$case_dir/status.txt"
  echo "CREATED $name U=$speed m/s"
done < "$root/config/velocities.csv"

• set -Eeuo pipefail: the first failing command, an undefined variable or an error inside a pipe stops the script.
• Three preliminary checks, all with exit code 2: OpenFOAM environment loaded (foamVersion and foamDictionary available), version containing “14”, tutorial present with 0/U and system/blockMeshDict.
• Each CSV row is validated: name made only of letters, digits, hyphen and underscore; numeric velocity between 0 (excluded) and 1 m/s. An invalid row stops everything with exit code 3. For velocities above 1 m/s, change the v>0 && v<=1 condition in the awk line.
• If the case directory exists, SKIP is printed and the next row is processed: this is the mechanism that prevents overwriting.
• Only 0, constant and system are copied; if the copy already contained a constant/polyMesh the script stops with exit code 4, because the mesh must be generated in the case, not inherited.
• foamDictionary … -set writes the velocity, the measurement block is appended to the controlDict, then parameters.csv, the input.sha256 fingerprint and the PREPARED status are written.

The fingerprint covers six files: 0/U, system/controlDict, system/fvSolution, system/fvSchemes, constant/physicalProperties and constant/momentumTransport. Changes to these files after preparation block the case; changes to other files (for example system/blockMeshDict or system/decomposeParDict) are not detected and must be documented by hand.

# manual check of a prepared case
cd work/cases/U015
cat parameters.csv status.txt
sha256sum -c input.sha256
foamDictionary 0/U -entry Uinlet -value

#!/usr/bin/env bash
# GPL-3.0-or-later. Sequential campaign, optional MPI per case.
# Never deletes, force-recreates or overwrites existing case results.
set -Eeuo pipefail
root=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd -P)
case_root="$root/work/cases"
np=1
resume=0
while (($#)); do
  case "$1" in
    --np) (($#>=2)) || { echo '--np requires an argument' >&2; exit 2; }; np=$2; shift 2 ;;
    --resume) resume=1; shift ;;
    *) echo "Usage: bash scripts/run_campaign.sh [--np N] [--resume]" >&2; exit 2 ;;
  esac
done
[[ "$np" =~ ^[1-9][0-9]*$ ]] || { echo 'ERROR: --np must be positive integer' >&2; exit 2; }
command -v foamRun >/dev/null 2>&1 || { echo 'ERROR: source OpenFOAM first' >&2; exit 2; }
[[ -d "$case_root" ]] || { echo 'ERROR: run prepare_campaign.sh first' >&2; exit 2; }

execute_case() (
  set -Eeuo pipefail
  case_dir="$1"
  cd "$case_dir"
  name=$(basename "$case_dir")
  if [[ -f .completed ]]; then echo "$name: SKIP completed"; return 0; fi
  if [[ -f .run_started && "$resume" -eq 0 ]]; then
    echo "$name: SKIP unfinished previous run; inspect logs and use --resume explicitly" >&2
    return 8
  fi
  if [[ -f .nproc && "$(cat .nproc)" != "$np" ]]; then
    echo "$name: ERROR, processor count changed; use the original --np" >&2
    return 5
  fi
  if [[ ! -f .nproc ]]; then printf '%s\n' "$np" > .nproc; fi
  stamp=$(date -u +%Y%m%dT%H%M%SZ)_$$
  mkdir -p logs
  printf 'RUNNING\n' > status.txt
  : > .run_started
  fail() { printf 'FAILED\n' > status.txt; echo "$name: FAILED; see logs/$stamp.*" >&2; }
  # Catch accidental edits after preparation: use a fresh identifier for revisions.
  if ! sha256sum -c input.sha256 > "logs/$stamp.input-check.log" 2>&1; then
    echo "$name: ERROR: inputs differ from recorded hashes" >&2
    printf 'FAILED\n' > status.txt
    return 7
  fi
  step() {
    tag=$1; shift
    echo "$name: $tag"
    # Explicit check: bash errexit is disabled inside functions called by `if`.
    if "$@" > "logs/$stamp.$tag.log" 2>&1; then
      return 0
    else
      rc=$?; fail; return "$rc"
    fi
  }
  # Stage stamps prevent repeated mirrorMesh or skipped partial preparations.
  # Before retrying a failed *blockMesh* inspect mesh state: never force-clean.
  if [[ ! -f .block_mesh_done ]]; then
    if [[ -f constant/polyMesh/points ]]; then
      echo 'ERROR: mesh exists without stage marker; inspect manually' >&2; return 4
    fi
    step blockMesh blockMesh || return $?
    : > .block_mesh_done
  fi
  if [[ ! -f .mirror_mesh_done ]]; then
    step mirrorMesh mirrorMesh || return $?
    : > .mirror_mesh_done
  fi
  if [[ ! -f .mesh_checked ]]; then
    step checkMesh checkMesh || return $?
    : > .mesh_checked
  fi
  if ((np>1)); then
    command -v mpirun >/dev/null 2>&1 || { echo 'ERROR: mpirun missing' >&2; return 3; }
    if [[ ! -d processor0 ]]; then step decomposePar decomposePar || return $?; fi
    step foamRun mpirun -np "$np" foamRun -parallel || return $?
    step reconstructPar reconstructPar -latestTime || return $?
  else
    [[ ! -d processor0 ]] || { echo 'ERROR: parallel case cannot be resumed in serial' >&2; return 4; }
    step foamRun foamRun || return $?
  fi
  # Completion here means exit status 0 + data presence, NOT physical convergence.
  for measurement in pIn pOut qIn qOut; do
    find "postProcessing/$measurement" -type f -name '*.dat' -print -quit 2>/dev/null | grep -q . || {
      echo "ERROR: missing measurement $measurement" >&2; fail; return 6;
    }
  done
  printf 'SOLVER_FINISHED\n' > status.txt
  : > .completed
  echo "$name: SOLVER_FINISHED (check physical quality independently)"
)
failures=0
for case_dir in "$case_root"/*; do
  [[ -d "$case_dir" ]] || continue
  if ! execute_case "$case_dir"; then failures=$((failures + 1)); fi
done
if ((failures)); then echo "Campaign has $failures failed case(s)" >&2; exit 1; fi

The execute_case function has its body in round brackets: it runs in a subshell, so the cd into the case and the error settings do not leak into the main loop. A failing case returns a non-zero code, the loop counts the failure and moves to the next case; at the end the script exits with 1 if at least one case failed.

The step function checks the exit code of each command explicitly because, as the comment in the script says, Bash errexit does not apply inside functions called from an if. Each stage writes to logs/<date>_<pid>.<stage>.log, with the date in UTC.

If the connection drops without tmux, status.txt stays at RUNNING and the .run_started marker is present: on the next launch the case is skipped with code 8 until --resume is chosen explicitly.

decomposePar reads system/decomposeParDict and creates as many subdomains as numberOfSubdomains says. The script passes --np only to mpirun: the dictionary is neither created nor changed. Before a campaign with --np 4, check in every case that the file exists and that the number matches; otherwise decomposePar fails or creates a number of processor* directories different from the MPI processes and foamRun -parallel stops.

for d in work/cases/*/; do
  printf '%s: ' "$d"
  foamDictionary "$d/system/decomposeParDict" -entry numberOfSubdomains -value 2>/dev/null || echo 'MISSING'
done

A minimal dictionary, to be copied into system/ of each case before the launch (the file is not covered by input.sha256, so the addition must be recorded):

FoamFile
{
    format      ascii;
    class       dictionary;
    object      decomposeParDict;
}

numberOfSubdomains 4;

method          scotch;

With T1 the serial run time and Tn the time with n processes, the speed-up is S = T1/Tn and the efficiency E = S/n. An efficiency close to 1 means the cores are well used; low values mean communication and synchronisation outweigh computation. As a practical order of magnitude, parallel runs start to pay off when each process handles at least tens of thousands of cells: the cell count is in the checkMesh log.

# mesh cells and times recorded by foamRun
grep -m1 "cells:" work/cases/U015/logs/*.checkMesh.log
grep ExecutionTime work/cases/U015/logs/*.foamRun.log | tail -n 1
# server load before choosing --np
nproc; free -h; uptime

Do not start more processes than there are free physical cores: on an overloaded server the MPI processes wait for each other and the run becomes slower than in serial.

Each function object writes into postProcessing/<name>/<start time>/ a text file (typically surfaceFieldValue.dat): header lines beginning with #, then one row per write with the time in the first column and the value in the second. If the run restarts from a later time, a new subdirectory with the new start time is created.

collect_results.py reads all the *.dat files of each measurement, discards headers and non-numeric rows and takes the sample with the largest time: that is why it also copes with restarts. It then checks that the four times coincide and, if they do not, marks the case INCOMPLETE_DATA.

With writeControl writeTime a sample is written only when the fields are written. For a denser history, useful to see whether Δp has settled, use writeControl timeStep; with writeInterval 1; (or another interval). The change must be made in config/measurement_functions.foam before preparation: afterwards it would change the controlDict recorded in the fingerprint and the case would be blocked.

ls work/cases/U015/postProcessing/*/*/
tail -n 3 work/cases/U015/postProcessing/pIn/*/*.dat

With outward normals, the inflow is negative. With example values Qin = −1.000·10⁻³ m³/s and Qout = +0.998·10⁻³ m³/s the sum is −2·10⁻⁶ m³/s and the imbalance is εQ = 100 · 2·10⁻⁶ / 1.000·10⁻³ = 0.2 %.

In an incompressible constant-density flow, continuity holds at every step, transients included: the imbalance therefore mostly reflects the pressure-solver tolerance. A large value is usually not physical: it points to an open patch left out of the sum, a wrong sign or two samples taken at different times. If the domain has other patches with flow, they must be added to the balance.

#!/usr/bin/env python3
# GPL-3.0-or-later. No third-party dependencies. Run on Windows or Linux.
"""Read the last numerical records of four OpenFOAM surfaceFieldValue outputs.

Values are NOT convergence/validation certificates. CFD runs are required
before real measurements exist. Assumes OpenFOAM Foundation 14 cylinder case:
p is kinematic pressure [m2/s2]; phi is volumetric flux [m3/s].
"""
import argparse
import csv
import math
from pathlib import Path


def read_measurement(case: Path, name: str):
    files = sorted((case / 'postProcessing' / name).glob('**/*.dat'))
    samples = []
    for file in files:
        for raw in file.read_text(encoding='utf-8', errors='replace').splitlines():
            line = raw.strip()
            if not line or line.startswith('#'):
                continue
            fields = line.split()
            if len(fields) < 2:
                continue
            try:
                t, value = float(fields[0]), float(fields[1])
            except ValueError:
                continue
            if math.isfinite(t) and math.isfinite(value):
                samples.append((t, value))
    if not samples:
        raise ValueError(f'No numerical rows found for {name}')
    return max(samples, key=lambda r: r[0])


def main():
    p = argparse.ArgumentParser()
    p.add_argument('--root', type=Path, default=Path(__file__).resolve().parents[1])
    p.add_argument('--rho', type=float, default=1000.0,
                   help='Fluid density kg/m3, default 1000; NOT inferred from tutorial')
    p.add_argument('--output', type=Path, help='CSV destination; default ROOT/results.csv')
    args = p.parse_args()
    if args.rho <= 0 or not math.isfinite(args.rho):
        p.error('rho must be a positive finite number')
    case_root = args.root / 'work' / 'cases'
    if not case_root.is_dir():
        p.error(f'No cases found: {case_root}')
    fields = ['case_id', 'U_m_s', 'status', 'time', 'pIn_m2_s2', 'pOut_m2_s2',
              'DeltaP_Pa', 'qIn_m3_s', 'qOut_m3_s', 'imbalance_percent', 'notes']
    records = []
    for case in sorted(p for p in case_root.iterdir() if p.is_dir()):
        parameters = case / 'parameters.csv'
        if not parameters.is_file():
            continue
        with parameters.open(encoding='utf-8', newline='') as f:
            cfg = next(csv.DictReader(f))
        row = {key: '' for key in fields}
        row.update(case_id=case.name, U_m_s=cfg['U_m_s'])
        status_file = case / 'status.txt'
        row['status'] = status_file.read_text(encoding='utf-8').strip() if status_file.exists() else 'UNKNOWN'
        if not (case / '.completed').exists():
            row['notes'] = 'No .completed marker; do not treat as finished'
        else:
            try:
                out = {n: read_measurement(case, n) for n in ('pIn', 'pOut', 'qIn', 'qOut')}
                times = [out[n][0] for n in out]
                if max(times) - min(times) > 1e-7 * max(1.0, max(abs(t) for t in times)):
                    raise ValueError('Measurement times differ; inspect files')
                pin, pout, qin, qout = (out[n][1] for n in ('pIn', 'pOut', 'qIn', 'qOut'))
                row['time'] = format(max(times), '.10g')
                row['pIn_m2_s2'] = format(pin, '.10g')
                row['pOut_m2_s2'] = format(pout, '.10g')
                row['DeltaP_Pa'] = format((pin-pout)*args.rho, '.10g')
                row['qIn_m3_s'] = format(qin, '.10g')
                row['qOut_m3_s'] = format(qout, '.10g')
                denom = max(abs(qin), abs(qout))
                row['imbalance_percent'] = format(100*abs(qin+qout)/denom, '.6g') if denom else ''
                row['notes'] = 'Last recorded sample, NOT a convergence test'
            except (ValueError, OSError) as exc:
                row['status'] = 'INCOMPLETE_DATA'
                row['notes'] = str(exc)
        records.append(row)
    output = args.output or args.root / 'results.csv'
    output.parent.mkdir(parents=True, exist_ok=True)
    with output.open('w', encoding='utf-8', newline='') as f:
        writer = csv.DictWriter(f, fieldnames=fields)
        writer.writeheader()
        writer.writerows(records)
    print(f'Wrote {len(records)} row(s): {output}')
    for row in records:
        print(row['case_id'], row['status'], row['DeltaP_Pa'], row['notes'])


if __name__ == '__main__':
    main()

• --root: package folder (by default the one containing scripts/); --rho: density in kg/m³, must be positive and finite; --output: CSV destination, by default results.csv in the package folder.
• A case without .completed appears in the CSV with the status read from status.txt and the note “No .completed marker”, without numbers.
• If the times of the four measurements differ beyond a relative tolerance of 10⁻⁷, the case becomes INCOMPLETE_DATA.
• Numbers are written with 10 significant digits and a decimal point.

The file uses a comma as separator and a point as decimal separator. Excel configured for a locale with decimal commas, opened by double-click, expects semicolons and decimal commas, and puts everything in one column or turns numbers into dates. Use Data → From Text/CSV instead, choose the “Comma” delimiter and, in Transform Data, set the locale of the numeric columns to “English (United States)”. Alternatively, LibreOffice Calc asks for separator and language when opening the file.

#!/usr/bin/env python3
# GPL-3.0-or-later. Optional matplotlib package on Windows/Linux.
import argparse
import csv
import math
from pathlib import Path

p = argparse.ArgumentParser()
p.add_argument('csvfile', type=Path, nargs='?', default=Path('results.csv'))
p.add_argument('--output', type=Path, default=Path('DeltaP_vs_U.png'))
a = p.parse_args()
with a.csvfile.open(encoding='utf-8-sig', newline='') as f:
    rows = list(csv.DictReader(f))
points = []
for r in rows:
    if r['status'] != 'SOLVER_FINISHED' or not r['DeltaP_Pa']:
        continue
    try:
        u, dp = float(r['U_m_s']), float(r['DeltaP_Pa'])
    except ValueError:
        continue
    if math.isfinite(u) and math.isfinite(dp):
        points.append((u, dp))
if not points:
    raise SystemExit('No finished CFD results; refusing to create a misleading plot')
points.sort()
try:
    import matplotlib.pyplot as plt
except ImportError as e:
    raise SystemExit('Install matplotlib: python -m pip install matplotlib') from e
fig, ax = plt.subplots(figsize=(7, 4.5))
ax.plot([p[0] for p in points], [p[1] for p in points], '-o')
ax.set_xlabel('Inlet velocity [m/s]')
ax.set_ylabel('Pressure difference [Pa]')
ax.set_title('OpenFOAM campaign - final samples (not validated)')
ax.grid(True, alpha=.3)
fig.tight_layout()
fig.savefig(a.output, dpi=175)
print('Saved:', a.output)

The script refuses to produce the plot if no case is SOLVER_FINISHED with a Δp value: an empty plot, or one made of incomplete cases, would be misleading. The output file name is changed with --output.

When viscous effects dominate, the pressure drop grows roughly linearly with velocity; when inertial effects dominate it grows roughly with the square. The local exponent between two consecutive cases is n = ln(ΔP₂/ΔP₁) / ln(U₂/U₁): values near 1 indicate a viscous regime, near 2 an inertial regime, intermediate values a transition. It is a physical plausibility check that needs no external data.

# local exponents from results.csv (standard library only)
import csv, math
rows = [r for r in csv.DictReader(open("results.csv", encoding="utf-8"))
        if r["status"] == "SOLVER_FINISHED" and r["DeltaP_Pa"]]
pts = sorted((float(r["U_m_s"]), float(r["DeltaP_Pa"])) for r in rows)
for (u1, p1), (u2, p2) in zip(pts, pts[1:]):
    if p1 > 0 and p2 > 0:
        print(f"{u1:g} -> {u2:g} m/s: n = {math.log(p2/p1)/math.log(u2/u1):.3f}")

With --resume the script accepts cases that have .run_started but not .completed. Stages already finished (.block_mesh_done, .mirror_mesh_done, .mesh_checked) are not repeated; in parallel, if processor0 exists, decomposePar is skipped and foamRun -parallel restarts from the existing subdomains. The input fingerprint is checked again at every launch.

Practical consequence: if the controlDict is edited during a run (for example changing endTime or stopAt to stop it), the file no longer matches the fingerprint and on the next --resume the case stops with code 7. This is the intended behaviour: the change must be recorded and, as a rule, a new case is created. Regenerating input.sha256 is possible but must be a conscious decision written into the campaign record.

# processes still running and their state
pgrep -af foamRun
find work/cases -name status.txt -exec sh -c 'echo "$1: $(cat "$1")"' _ {} \;
ls -a work/cases/U015

Run in the package folder once the campaign is over, they record versions and fingerprints and produce an archive without the processor* directories, which take a lot of space and can be rebuilt.

{ date -u; uname -a; foamVersion; mpirun --version 2>&1 | head -n 1; } > campaign_environment.txt
find work/cases -path '*/processor*' -prune -o -type f -print0 | sort -z | xargs -0 sha256sum > campaign_files.sha256
tar czf "cylinder_campaign_$(date -u +%Y%m%d).tar.gz" --exclude='processor*' config scripts work results.csv campaign_environment.txt campaign_files.sha256
sha256sum cylinder_campaign_*.tar.gz

The archive fingerprint, written into the record, makes it possible to show later that the data analysed are the ones produced. If results.csv does not exist yet, remove it from the tar line.

• A. On the second run of prepare_campaign.sh the four original rows produce SKIP existing case … and only the new one produces CREATED U025 U=0.025 m/s. Check: foamDictionary work/cases/U025/0/U -entry Uinlet -value must return 0.025.
• B. Cases live in work/cases inside the package folder, so two independent campaigns are obtained with two copies of the package (for example cylinder_campaign_np1 and cylinder_campaign_np4). The .nproc marker in any case prevents mixing the two modes in the same case. For the 4-process version, prepare the decomposeParDict first.
• C. Besides imbalance_percent, compute the local exponent between consecutive cases and check that the measurement time is the same in all cases: comparing a settled case with one still in its transient produces a meaningless curve.