simjecture 0.1.0__py3-none-any.whl

conjecture_solver/builtin_skills/warpx/scripts/bootstrap_local_cuda.sh

@@ -0,0 +1,82 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Reproduce the non-MPI 2D CUDA + openPMD WarpX runtime on a Linux/WSL host.
+# The source tree is intentionally supplied by the caller: deployments must
+# pin and audit the WarpX release rather than downloading an implicit branch.
+
+usage() {
+    echo "usage: $0 --source WARPX_SOURCE [--jobs N] [--arch N]" >&2
+}
+
+source_tree=""
+jobs=8
+cuda_arch=""
+while (($#)); do
+    case "$1" in
+        --source) source_tree="$2"; shift 2 ;;
+        --jobs) jobs="$2"; shift 2 ;;
+        --arch) cuda_arch="$2"; shift 2 ;;
+        *) usage; exit 2 ;;
+    esac
+done
+[[ -n "$source_tree" ]] || { usage; exit 2; }
+source_tree="$(cd "$source_tree" && pwd)"
+
+script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+repo_root="$(cd "$script_dir/../../.." && pwd)"
+cuda_root="$repo_root/.runtime/cuda-toolkit-12.4"
+io_root="$repo_root/.runtime/warpx-cuda-openpmd-deps"
+python_root="$repo_root/.runtime/warpx-cuda-openpmd"
+
+for command in mamba python3.12 nvidia-smi; do
+    command -v "$command" >/dev/null || {
+        echo "missing deployment prerequisite: $command" >&2
+        exit 2
+    }
+done
+if [[ ! -e /dev/dxg && ! -e /dev/nvidia0 ]]; then
+    echo "no WSL or native NVIDIA device node found" >&2
+    exit 2
+fi
+if [[ -z "$cuda_arch" ]]; then
+    cuda_arch="$(nvidia-smi --query-gpu=compute_cap --format=csv,noheader | head -1 | tr -d '.')"
+fi
+
+mamba create -y -p "$cuda_root" -c conda-forge \
+    cuda-nvcc=12.4 cuda-cudart-dev=12.4 libcublas-dev=12.4 \
+    libcurand-dev=10.3.5.147 libcusparse-dev=12.3.1.170 \
+    cuda-profiler-api=12.4 cuda-nvtx-dev=12.4 \
+    gcc_linux-64=12.4 gxx_linux-64=12.4
+mamba create -y -p "$io_root" -c conda-forge \
+    'hdf5=1.14.6=nompi_*' cmake ninja pkg-config
+
+python3.12 -m venv --system-site-packages "$python_root"
+"$python_root/bin/python" -m pip install --upgrade \
+    pip setuptools wheel packaging picmistandard==0.34.0 \
+    periodictable openpmd-api matplotlib numpy
+
+# Keep Windows toolchains out of discovery under WSL. HDF5_ROOT and the
+# non-MPI build prefix prevent a Windows/MPI HDF5 config from being selected.
+export PATH="$cuda_root/bin:/usr/local/bin:/usr/bin:/bin:$io_root/bin"
+export CUDA_PATH="$cuda_root"
+export HDF5_ROOT="$io_root"
+export CMAKE_PREFIX_PATH="$io_root"
+export PKG_CONFIG_PATH="$io_root/lib/pkgconfig"
+driver_path=""
+[[ -d /usr/lib/wsl/lib ]] && driver_path="/usr/lib/wsl/lib:"
+export LD_LIBRARY_PATH="${driver_path}$cuda_root/lib:$cuda_root/lib64:$io_root/lib"
+export CPATH=/usr/include
+export CC="$cuda_root/bin/x86_64-conda-linux-gnu-cc"
+export CXX="$cuda_root/bin/x86_64-conda-linux-gnu-c++"
+export CUDAHOSTCXX="$CXX"
+export CUDACXX="$cuda_root/bin/nvcc"
+export CMAKE_CUDA_ARCHITECTURES="$cuda_arch"
+export WARPX_COMPUTE=CUDA WARPX_MPI=OFF WARPX_DIMS=2 WARPX_EB=OFF
+export WARPX_OPENPMD=ON WARPX_OPENPMD_INTERNAL=ON
+export WARPX_FFT=OFF WARPX_QED=OFF WARPX_QED_TABLE_GEN=OFF
+export WARPX_PYTHON_IPO=OFF BUILD_PARALLEL="$jobs"
+
+"$python_root/bin/python" -m pip install --no-build-isolation -v "$source_tree"
+"$script_dir/run_local_cuda.sh" "$script_dir/probe_local_cuda.py" \
+    --require-openpmd

conjecture_solver/builtin_skills/warpx/scripts/probe_local_cuda.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""Report whether the loaded WarpX runtime is usable for local CUDA work."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import tempfile
+from pathlib import Path
+
+import numpy as np
+
+
+def hdf5_roundtrip(workdir: Path | None) -> bool:
+    """Write and read one scalar through the openPMD HDF5 backend."""
+    import openpmd_api as io
+
+    def exercise(root: Path) -> bool:
+        path = root / "openpmd-probe.h5"
+        series = io.Series(str(path), io.Access.create)
+        component = series.iterations[0].meshes["probe"][
+            io.Mesh_Record_Component.SCALAR
+        ]
+        component.reset_dataset(io.Dataset(np.dtype("float64"), [1]))
+        component.store_chunk(np.array([1.25]))
+        series.close()
+
+        readback = io.Series(str(path), io.Access.read_only)
+        loaded = readback.iterations[0].meshes["probe"][
+            io.Mesh_Record_Component.SCALAR
+        ].load_chunk()
+        readback.flush()
+        value = float(loaded[0])
+        readback.close()
+        return value == 1.25
+
+    if workdir is not None:
+        workdir.mkdir(parents=True, exist_ok=True)
+        return exercise(workdir)
+    with tempfile.TemporaryDirectory(prefix="warpx-openpmd-probe-") as path:
+        return exercise(Path(path))
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--require-openpmd",
+        action="store_true",
+        help="fail unless a temporary HDF5 openPMD series can be read back",
+    )
+    parser.add_argument("--workdir", type=Path)
+    args = parser.parse_args()
+
+    import amrex.space2d as amrex
+    import openpmd_api as io
+
+    smi = subprocess.run(
+        [
+            "nvidia-smi",
+            "--query-gpu=name,memory.total,compute_cap,driver_version",
+            "--format=csv,noheader,nounits",
+        ],
+        check=True,
+        text=True,
+        capture_output=True,
+    ).stdout.splitlines()[0]
+    name, memory_mib, compute_capability, driver = (
+        item.strip() for item in smi.split(",")
+    )
+
+    openpmd_hdf5 = bool(io.variants.get("hdf5", False))
+    openpmd_roundtrip = openpmd_hdf5 and hdf5_roundtrip(args.workdir)
+    result = {
+        "amrex": {
+            "gpu_backend": str(amrex.Config.gpu_backend),
+            "have_gpu": bool(amrex.Config.have_gpu),
+            "have_mpi": bool(amrex.Config.have_mpi),
+            "have_omp": bool(amrex.Config.have_omp),
+        },
+        "gpu": {
+            "name": name,
+            "memory_mib": int(memory_mib),
+            "compute_capability": compute_capability,
+            "driver": driver,
+        },
+        "openpmd_api": {
+            "version": io.__version__,
+            "hdf5": openpmd_hdf5,
+            "mpi": bool(io.variants.get("mpi", False)),
+        },
+    }
+    usable = result["amrex"]["have_gpu"] and (
+        str(result["amrex"]["gpu_backend"]).upper() == "CUDA"
+    )
+    result["checks"] = {
+        "cuda_warpx": usable,
+        "openpmd_hdf5_reader": openpmd_hdf5,
+        "openpmd_hdf5_roundtrip": openpmd_roundtrip,
+    }
+    print(json.dumps(result, indent=2, sort_keys=True))
+    if not usable:
+        return 1
+    if args.require_openpmd and not openpmd_roundtrip:
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

conjecture_solver/builtin_skills/warpx/scripts/reduced_energy_budget.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+"""Read a pinned single-level WarpX field-plus-particle energy budget safely."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import re
+from pathlib import Path
+from typing import Any
+
+HEADER_TOKEN = re.compile(r"\[(\d+)\]([^\s]+)")
+FIELD_TOTAL_LABEL = "total_lev0(J)"
+PARTICLE_TOTAL_LABEL = "total(J)"
+
+
+def sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def read_table(path: Path) -> tuple[list[str], list[list[float]]]:
+    lines = path.read_text().splitlines()
+    if not lines or not lines[0].startswith("#"):
+        raise ValueError(f"missing WarpX reduced-diagnostic header: {path}")
+    indexed = {int(index): label for index, label in HEADER_TOKEN.findall(lines[0])}
+    if not indexed or sorted(indexed) != list(range(max(indexed) + 1)):
+        raise ValueError(f"non-contiguous reduced-diagnostic header: {path}")
+    labels = [indexed[index] for index in range(len(indexed))]
+    rows: list[list[float]] = []
+    for line_number, line in enumerate(lines[1:], start=2):
+        if not line.strip() or line.startswith("#"):
+            continue
+        try:
+            row = [float(value) for value in line.split()]
+        except ValueError as exc:
+            raise ValueError(f"non-numeric row {line_number}: {path}") from exc
+        if len(row) != len(labels):
+            raise ValueError(
+                f"row {line_number} has {len(row)} columns; header has "
+                f"{len(labels)}: {path}"
+            )
+        if not all(math.isfinite(value) for value in row):
+            raise ValueError(f"non-finite value in row {line_number}: {path}")
+        rows.append(row)
+    if not rows:
+        raise ValueError(f"empty reduced diagnostic: {path}")
+    return labels, rows
+
+
+def exact_column(labels: list[str], required: str, *, path: Path) -> int:
+    matches = [index for index, label in enumerate(labels) if label == required]
+    if len(matches) != 1:
+        raise ValueError(
+            f"expected exactly one {required!r} column in {path}; found {len(matches)}. "
+            "Do not guess or sum total and component columns."
+        )
+    return matches[0]
+
+
+def relative_change(initial: float, final: float, *, name: str) -> float:
+    if initial == 0.0:
+        raise ValueError(f"cannot normalize {name}: initial value is zero")
+    return (final - initial) / abs(initial)
+
+
+def energy_budget(
+    field_path: Path,
+    particle_path: Path,
+    *,
+    time_atol: float,
+) -> dict[str, Any]:
+    field_labels, field_rows = read_table(field_path)
+    particle_labels, particle_rows = read_table(particle_path)
+    field_total_column = exact_column(
+        field_labels, FIELD_TOTAL_LABEL, path=field_path
+    )
+    particle_total_column = exact_column(
+        particle_labels, PARTICLE_TOTAL_LABEL, path=particle_path
+    )
+    if len(field_rows) != len(particle_rows):
+        raise ValueError("field and particle diagnostics have different row counts")
+    for index, (field_row, particle_row) in enumerate(
+        zip(field_rows, particle_rows, strict=True)
+    ):
+        if field_row[0] != particle_row[0] or not math.isclose(
+            field_row[1],
+            particle_row[1],
+            rel_tol=0.0,
+            abs_tol=time_atol,
+        ):
+            raise ValueError(
+                f"field and particle step/time coordinates differ at row {index}"
+            )
+
+    field = [row[field_total_column] for row in field_rows]
+    particle = [row[particle_total_column] for row in particle_rows]
+    combined = [
+        field_value + particle_value
+        for field_value, particle_value in zip(field, particle, strict=True)
+    ]
+    return {
+        "schema_version": "0.1.0",
+        "kind": "warpx_reduced_energy_budget",
+        "selection_policy": (
+            "Select exact non-overlapping total columns from realized headers; "
+            "never add a total column to its component or per-species columns."
+        ),
+        "inputs": {
+            "field_path": str(field_path),
+            "field_sha256": sha256(field_path),
+            "particle_path": str(particle_path),
+            "particle_sha256": sha256(particle_path),
+        },
+        "selected_columns": {
+            "field": {
+                "index": field_total_column,
+                "label": field_labels[field_total_column],
+            },
+            "particle": {
+                "index": particle_total_column,
+                "label": particle_labels[particle_total_column],
+            },
+        },
+        "ignored_columns": {
+            "field": field_labels[field_total_column + 1 :],
+            "particle": particle_labels[particle_total_column + 1 :],
+        },
+        "checks": {
+            "rows_aligned": True,
+            "all_values_finite": True,
+            "exact_field_total_label": True,
+            "exact_particle_total_label": True,
+            "non_overlapping_totals_selected": True,
+        },
+        "points": len(combined),
+        "initial": {
+            "field_J": field[0],
+            "particle_J": particle[0],
+            "combined_J": combined[0],
+        },
+        "final": {
+            "field_J": field[-1],
+            "particle_J": particle[-1],
+            "combined_J": combined[-1],
+        },
+        "relative_change": {
+            "field": relative_change(field[0], field[-1], name="field energy"),
+            "particle": relative_change(
+                particle[0], particle[-1], name="particle energy"
+            ),
+            "combined": relative_change(
+                combined[0], combined[-1], name="combined energy"
+            ),
+        },
+    }
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Compute a single-level WarpX field-plus-particle energy budget by "
+            "exact header identity."
+        )
+    )
+    parser.add_argument("field_energy", type=Path)
+    parser.add_argument("particle_energy", type=Path)
+    parser.add_argument("--output", type=Path)
+    parser.add_argument("--time-atol", type=float, default=1.0e-30)
+    return parser
+
+
+def main() -> int:
+    parser = build_parser()
+    args = parser.parse_args()
+    if args.time_atol < 0.0:
+        parser.error("--time-atol must be non-negative")
+    try:
+        result = energy_budget(
+            args.field_energy,
+            args.particle_energy,
+            time_atol=args.time_atol,
+        )
+    except (OSError, ValueError) as exc:
+        parser.error(str(exc))
+    encoded = json.dumps(result, indent=2, sort_keys=True) + "\n"
+    if args.output is not None:
+        args.output.write_text(encoded)
+    print(encoded, end="")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

conjecture_solver/builtin_skills/warpx/scripts/run_local_cuda.sh

@@ -0,0 +1,39 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Launch the project-local WarpX CUDA runtime under WSL. The WSL driver stub
+# must precede Ubuntu's libcuda, and the source-built wheel bundles pyAMReX in
+# a nested site-packages directory.
+script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+repo_root="$(cd "$script_dir/../../.." && pwd)"
+cuda_root="$repo_root/.runtime/cuda-toolkit-12.4"
+io_root="$repo_root/.runtime/warpx-cuda-openpmd-deps"
+python_root="${WARPX_CUDA_RUNTIME:-$repo_root/.runtime/warpx-cuda-openpmd}"
+if [[ ! -x "$python_root/bin/python" && -z "${WARPX_CUDA_RUNTIME:-}" ]]; then
+    python_root="$repo_root/.runtime/warpx-cuda"
+fi
+if [[ ! -x "$python_root/bin/python" ]]; then
+    echo "missing WarpX CUDA Python runtime: $python_root" >&2
+    exit 2
+fi
+python_site="$($python_root/bin/python -c \
+    "import sysconfig; print(sysconfig.get_paths()['purelib'])")"
+bundled_site="$python_site/pywarpx/site-packages"
+if [[ ! -x "$cuda_root/bin/nvcc" ]]; then
+    echo "missing CUDA 12.4 toolkit: $cuda_root" >&2
+    exit 2
+fi
+
+export CUDA_PATH="$cuda_root"
+driver_path=""
+[[ -d /usr/lib/wsl/lib ]] && driver_path="/usr/lib/wsl/lib:"
+io_path=""
+[[ -d "$io_root/lib" ]] && io_path="$io_root/lib:"
+export LD_LIBRARY_PATH="${driver_path}$cuda_root/lib:$cuda_root/lib64:${io_path}$python_site/pywarpx${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
+export PYTHONPATH="$bundled_site:$python_site${PYTHONPATH:+:$PYTHONPATH}"
+export OMP_NUM_THREADS=1
+export OPENBLAS_NUM_THREADS=1
+export MKL_NUM_THREADS=1
+export NUMEXPR_NUM_THREADS=1
+
+exec "$python_root/bin/python" "$@"