Ayemanf02/openfoam-cases

CAE Commons: OpenFOAM cases with manifests

Every OpenFOAM case the caeharness verdict engine (https://github.com/cae-commons/caeharness) is tested on, in one place. Each case comes with a manifest: a machine-readable description of what the case is (its OpenFOAM version, solver, mesh, how it runs, which files are inputs). Every fact carries the source it was read from, or is marked unknown with the reason.

Source	Cases	What they are
cases/platform/	173	Broken cases submitted to a CFD help platform as simulated user uploads, each with the uploader's problem description (notes.txt). OpenFOAM 10 (167) and OpenFOAM v2406 (6).
cases/fixtures/	10	The harness's own test cases: a good cavity and pitzDaily, and eight with one injected fault each.
answer_keys/	10 + 3	Ground truth, kept apart from the cases: the fixtures' injected faults and three case specs (problem, tolerances, reference data).

Layout

cases/
  platform/<batch>/<upload>/
    case.tgz        the case as uploaded (scrubbed: see "Privacy")
    meta.json       solver, declared OpenFOAM version, sizes, sha256 of case.tgz and of the delivery
    notes.txt       the uploader's problem description
    manifest.json   the case's manifest
  fixtures/<case>/
    case.tgz        the fixture (scrubbed, its answer key left out)
    manifest.json
answer_keys/
  fixtures/<case>/fault.json      the injected fault, its fix and the expected first failing tier
  specs/<spec>/                   a case spec: problem.yaml or spec.yaml, tiers.yaml, reference/, realizations/
coverage.csv        one row per case, one column per manifest fact: where it came from, or why it is unknown
LICENSE, LICENSE-GPL-3.0

Never give answer_keys/ to a model that is being evaluated. The harness serves a model the case's input files only; the answer keys are what its result is checked against.

The manifest

Why it exists

Real uploads come in many shapes (a folder, a tarball with the case nested inside, logs and outputs mixed in with inputs) and from two OpenFOAM families (Foundation 10, ESI v2406) that spell files, logs and solvers differently. Instead of converting cases into one layout, which would make a repair diff no longer apply to what the user uploaded, the harness normalizes the description of a case. The user's own files are never rewritten; the manifest says where everything is and what it means.

What it consists of

{
  "schema_version": 1,
  "source_kind": "upload_dir",          // dir | archive | upload_dir
  "origin": "cases/platform/batch3/025_f-auto-Cavity-1",
  "facts": {
    "root":    {"value": "Cavity_1", "source": "unpack", "evidence": []},
    "dialect": {"value": "v2406", "source": "log.pisoFoam",
                "evidence": ["log.pisoFoam: version 2406, website www.openfoam.com, build ... -> ['v2406']"]},
    "solver":  {"value": "pisoFoam", "source": "log.pisoFoam", "evidence": []},
    "recipe":  {"value": "allrun", "source": "Allrun", "evidence": []},
    ...
  },
  "unknown": {"fields_required": "no simulationType in constant/momentumTransport"}
}

Ten facts, each either known (value, source, evidence) or unknown (a reason), exactly once:

Fact	What it says	How it is derived
root	the case folder inside the upload ("" when the upload is the case)	the one folder holding system/controlDict; none or several is unknown, with the candidates
dialect	which OpenFOAM version's words and installation the case needs	see "Version detection" below
solver	the solver the case runs	trust order: the Allrun's last solver, else the one solver log, else controlDict's application; utilities (setFields) and converters (*ToFoam) never count
solver_family	incompressible, compressible, buoyant, reacting, multiphase, ...	the solver looked up in the version's [families] table (only solvers proved present in that version's installation)
mesh_source	how the mesh is made: blockMesh, snappyHexMesh, extrudeMesh, imported:<converter>, prebuilt	the Allrun's mesh tools and converters, the mesh dictionaries in system/, a shipped constant/polyMesh
recipe	how the case is run: allrun (its own script) or derived (mesh, then the application)	the version's script name; derived only when a solver is named
time_window	startTime, endTime, deltaT, writeControl, writeInterval, adjustTimeStep	read with the same entry rule the harness's own controlDict edits use; a macro or #include makes it unknown, so those edits know in advance they cannot apply
inputs	the files and folders that are the case (system, constant, 0, root files such as Allrun)	the version's input list; outputs, logs, postProcessing/ and time folders are not inputs
answer_key	ground-truth files found in the case (e.g. fault.json)	never an input: the harness asserts the two lists are disjoint
fields_required	the fields the selected turbulence/laminar model reads (e.g. kEpsilon: k, epsilon, nut)	the model read from the version's turbulence file (momentumTransport for 10, turbulenceProperties for v2406), looked up in the version's [models] table; fields present but unused, and required but missing, are in its evidence

Only three unknowns stop a case from running (blocked_by): root, dialect and recipe. Any other unknown only narrows what can be checked; the case still runs, and its failure is the evidence a repair needs.

Version detection

A case is never run on a default version. In order:

1. The solver logs' banner (Version:, Website:, Build: at the top of every log.*). Each version's dictionary in the harness lists what its banner looks like; exactly one match decides. Banners naming two versions are unknown, never a pick. (Present in 182 of 183 cases here; it agreed with meta.json in all 172 platform cases that have one.)
2. The declared version (meta.json's solver_version), when no log has a banner and nothing in the case contradicts it. Dictionary header comments are only corroboration: tutorials copy them across versions (all six v2406 uploads carry OpenFOAM 10 headers), so they can veto a declaration but never choose a version.
3. A probe of the installed versions, when neither decides: does that installation have the case's solver, and does it parse the case's controlDict? Exactly one yes decides (source: probe:<version>). One platform case is decided this way: 049_wind-varying-h2leak has no logs, declares 10, carries v2406 headers, and its solver (buoyantReactingFoam) exists in OpenFOAM 10 only.
4. Otherwise unknown, with every reason.

A person can override with --version; the manifest then says source: override and keeps what detection said, and the harness warns when the two disagree.

Supporting another OpenFOAM version is data, not code: a dictionary file for it (its banner, file names, log words, solver and model tables) and an installation (a container image) for the harness to run it in.

How the manifest talks to the harness

upload ─→ ingest ─→ manifest ─→ CaseAdapter ─→ run in the version's image ─→ logs ─→ verdict (T0–T3) ─→ repair

• CaseAdapter(manifest) is the only thing the rest of the harness asks about a case. A manifest with an unknown root, dialect or recipe makes no adapter: the refusal names each reason, before anything runs.
• v0 is a copy of the manifest's inputs, taken from its root, in its dialect. The user's tree is not touched; outputs and the answer key never reach it.
• The baseline run goes into the container image the dialect names, runs the case's own Allrun (or the derived recipe), and writes the logs the verdict reads. OpenFOAM itself never sees the manifest: it is handed an ordinary case folder.
• The verdict's gates (T0 execution, T1 mesh, T2 numbers not broken, T3 settled) read only the evidence of that run; the manifest does not change what they judge.
• Repair reads the version from the manifest kept in the case's store, proposes a patch to a copy of the inputs, and reruns it in the same image. A diff is relative to the case root, and root records where that sat in the upload, so a fix applies back to the user's own files.

The manifest.json files here are a published snapshot, written by the harness's own ingest from the files as published. The harness does not trust them as input: it ingests every case it is given itself.

Coverage

coverage.csv has one row per case and one column per fact. At the time of building: no case is blocked (every case has a root, a dialect and a recipe). The unknowns are broken cases, not unhandled layouts: 3 cases whose controlDict names a utility instead of a solver, 1 whose solver exists in no installed version, and 16 whose turbulence settings are not a valid model (no simulationType, or a model that does not exist).

Privacy

The platform cases were rewritten before publication: solver-banner host names became <host>; absolute paths under home, HPC, /opt (except OpenFOAM's own install folders) and /mnt prefixes became <path>, as did every banner Case : path whatever its prefix; logs were scrubbed even when MPI output put a NUL byte in them; scheduler logs and OpenFOAM's generated build folders (dynamicCode/, whose compiled objects carried build-machine paths) were not copied. A scan for API keys, tokens, private-key blocks and e-mail addresses ran over the result and found nothing; an independent scan of every unpacked archive found no personal path and no real host name. meta.json records the rule set (scrub_rules_version), the delivered archive's sha256 (sha256_raw) and the published one's (sha256). The fixtures went through the same scrub.

Licenses

• Apache-2.0 (LICENSE): the manifests, meta.json, notes.txt, coverage.csv, the solver logs, and every case file the collaborators wrote themselves.
• GPL-3.0 (LICENSE-GPL-3.0): files copied or adapted from tutorials shipped with OpenFOAM (copyright the OpenFOAM Foundation for OpenFOAM 10, OpenCFD Ltd for v2406). Most platform cases and the fixtures started from one; their files stay under upstream's GPL-3.0.
• Reference data under answer_keys/specs/*/reference/ carries its own LICENSE.md.
• OpenFOAM® is a registered trademark of OpenCFD Ltd. This dataset is not affiliated with or endorsed by OpenCFD or the OpenFOAM Foundation.