diff --git a/submissions/MRzero-RapiSim-direct-mzaiss/RUN.md b/submissions/MRzero-RapiSim-direct-mzaiss/RUN.md new file mode 100644 index 0000000..32b3d09 --- /dev/null +++ b/submissions/MRzero-RapiSim-direct-mzaiss/RUN.md @@ -0,0 +1,88 @@ +# MRzero plugin / RapiSim direct-sampler submission + +Five cases were run through the MRzero ChatGPT plugin's `rapisim_simulate` +service on 2026-10-27, for GitHub user `mzaiss`, with ChatGPT assistance. +These are new service runs, not copies of an existing challenge entry. + +## Inputs and settings + +Inputs are pinned to challenge commit +`4c0d86e74aebf56d2e27b69c1f273483d4b7dbb9`. All four Pulseq files, +the two phantom JSON files, and their referenced density/off-resonance NIfTIs +were checked against the repository blob hashes. Their SHA-256 hashes are +recorded in `provenance.json`. + +The original 181 x 217 x 4 phantom grid and NIfTI world placement are retained; +there is no resampling. Each ZIP contains one original JSON and the two +referenced NIfTIs, without modifying their contents. The unreferenced B1+ map +is not included. The service supplies the BIfTI defaults for missing +properties: B1+ = B1- = 1, ADC = 0, and T2' = infinity for cases 0-3. +Case 4 uses the published T2' values. The phantom's B0 = 3 T and +gyro = 42.5764 MHz/T, and the original Pulseq definitions, are retained. +The tool does not offer a separate scanner-constant override. + +| Cases | Sampler | `min_mag` | `compute_signal_stats` | +|---|---|---:|---| +| 0, 1, 3, 4 | direct | 1e-7 | true | +| 2 | direct | 1e-10 | true | + +The direct sampler does not use the interpolation kernel setting. +The service returns one coil, with shape `(samples, 1)` and dtype +`complex128`. Export removes only the singleton coil dimension and writes +the complex dataset `signal`. No normalization, conjugation, phase change, +filtering, sample reordering, or reconstruction is applied. + +The backend version/commit, hardware, RF discretization, internal time step, +and compute timings were not reported. `tool_date` identifies the run; +version, hardware, and timing fields are left empty/null. No relative speed +claim is made. Backend upgrades may change a future rerun. + +## Reproduce the preparation and export + +`reproduce.py` prepares inputs and exports service results. It is not a +local RapiSim implementation and does not execute the remote simulation. +Run from the repository root; Python 3.12, NumPy, and h5py were used. + +```sh +python -m pip install numpy h5py +python submissions/MRzero-RapiSim-direct-mzaiss/reproduce.py prepare --output-dir /tmp/rapisim-inputs +``` + +This verifies all input hashes, creates deterministic phantom ZIPs, and +writes `simulation_calls.json`. Upload those ZIPs and the four unchanged +`.seq` files using the MRzero plugin's file upload tools. Check that the +returned hashes match `provenance.json`, then invoke `rapisim_simulate` +once per recorded case with the exact `arguments` object in that manifest. + +Save each returned signal as `caseN_signal.npy` in one directory, then run: + +```sh +python submissions/MRzero-RapiSim-direct-mzaiss/reproduce.py export --signals-dir /tmp/rapisim-signals --output-dir /tmp/rapisim-h5 +``` + +Alternatively, add `--download` to retrieve the recorded results from the +service CAS URLs. Those URLs may not remain available indefinitely; the +submitted HDF5 files preserve the full raw signals. The exporter verifies +the recorded SHA-256 hashes, shapes, types, finite values, and lossless HDF5 +round trip. A future backend run that produces different bytes will fail +the original checksum check and needs its own updated provenance. + +## Validation + +All five signals are finite and nonzero. Case 0 has 1024 samples and cases +1-4 have 4096. In every submitted run, summing the five per-tissue signal +contributions exactly reproduces the total signal. The HDF5 values are +identical to the downloaded NumPy values. + +Cases 0, 1, 3, and 4 produced byte-identical outputs at cutoffs 1e-6 and 1e-7. +TSE was checked at 1e-6, 1e-7, 1e-8, 1e-9, 1e-10, and 1e-11. Its 1e-10 +and 1e-11 outputs have identical content hashes; the submitted result uses +1e-10. Intermediate relative L2 differences and output hashes are recorded +in `provenance.json`. This checks cutoff sensitivity, not agreement with an +independent physics ground truth. + +The challenge's validator can be run with: + +```sh +python .github/scripts/validate_submission.py submissions/MRzero-RapiSim-direct-mzaiss +``` diff --git a/submissions/MRzero-RapiSim-direct-mzaiss/case0.h5 b/submissions/MRzero-RapiSim-direct-mzaiss/case0.h5 new file mode 100644 index 0000000..15078cd Binary files /dev/null and b/submissions/MRzero-RapiSim-direct-mzaiss/case0.h5 differ diff --git a/submissions/MRzero-RapiSim-direct-mzaiss/case1.h5 b/submissions/MRzero-RapiSim-direct-mzaiss/case1.h5 new file mode 100644 index 0000000..4c3489a Binary files /dev/null and b/submissions/MRzero-RapiSim-direct-mzaiss/case1.h5 differ diff --git a/submissions/MRzero-RapiSim-direct-mzaiss/case2.h5 b/submissions/MRzero-RapiSim-direct-mzaiss/case2.h5 new file mode 100644 index 0000000..43fb04e Binary files /dev/null and b/submissions/MRzero-RapiSim-direct-mzaiss/case2.h5 differ diff --git a/submissions/MRzero-RapiSim-direct-mzaiss/case3.h5 b/submissions/MRzero-RapiSim-direct-mzaiss/case3.h5 new file mode 100644 index 0000000..5a9a46d Binary files /dev/null and b/submissions/MRzero-RapiSim-direct-mzaiss/case3.h5 differ diff --git a/submissions/MRzero-RapiSim-direct-mzaiss/case4.h5 b/submissions/MRzero-RapiSim-direct-mzaiss/case4.h5 new file mode 100644 index 0000000..89beeb4 Binary files /dev/null and b/submissions/MRzero-RapiSim-direct-mzaiss/case4.h5 differ diff --git a/submissions/MRzero-RapiSim-direct-mzaiss/provenance.json b/submissions/MRzero-RapiSim-direct-mzaiss/provenance.json new file mode 100644 index 0000000..37e0eab --- /dev/null +++ b/submissions/MRzero-RapiSim-direct-mzaiss/provenance.json @@ -0,0 +1,311 @@ +{ + "schema_version": 1, + "run_date": "2026-10-27", + "github_submitter": "mzaiss", + "challenge_repository": "https://github.com/MRsources/BlochSimulationChallenge", + "challenge_commit": "4c0d86e74aebf56d2e27b69c1f273483d4b7dbb9", + "tool": "mrzero.rapisim_simulate", + "tool_version": null, + "tool_commit": null, + "hardware": null, + "timing_note": "No backend compute timings or same-machine MRzero benchmark were exposed; submission timings are null.", + "input_sha256": { + "sequences/case0_fid.seq": "028337d068137eadce333dc0207ad9ee0941bfa2f666ff58fb2320a8d6fd9633", + "sequences/case1_gre.seq": "dbda1eb763af0473a283b2e43d021c4cc2efd6e7b0ada1826b37c753fd17e846", + "sequences/case2_tse.seq": "b640e687776374c4f1a5a6b8fc3c584bc4e5567e757a7e2ca884c28341935fa8", + "sequences/case3_epi.seq": "538086b96118e981cc23b8b58c46230fbb6364005103714f9c69fad9e9976e4c", + "phantoms/brainweb/challenge-brain-4mm.json": "33e78dac495e1ce6f9e58be120e626636b3287416eb9e038ec730f632e315372", + "phantoms/brainweb/challenge-brain-4mm-t2star.json": "7e8afd13d3fdbd29322aa64351a044d39bac84b1b6e136755c16ac00cf30f5cc", + "phantoms/brainweb/subj05.nii.gz": "cef00f7346f628e809870d83bf685eecf7e41861a5f70eb22759c7ee01f3f985", + "phantoms/brainweb/subj05_dB0.nii.gz": "e9ff77aa974d5720de491a852a3ccd055a6edab7056a57c95a8756222bc7c522" + }, + "phantom_archives": [ + { + "file_name": "challenge-brain-4mm.zip", + "sha256": "b06dd19ca3047c528ecd7163187f414e9ea84a54a2df9f66b492da40c43f8498", + "members": [ + "challenge-brain-4mm.json", + "subj05.nii.gz", + "subj05_dB0.nii.gz" + ] + }, + { + "file_name": "challenge-brain-4mm-t2star.zip", + "sha256": "20352e68045e2a3ea7f588058a9501e54a01bacd3109f7c6ad62a2a31b4d60e5", + "members": [ + "challenge-brain-4mm-t2star.json", + "subj05.nii.gz", + "subj05_dB0.nii.gz" + ] + } + ], + "scanner": { + "B0_T": 3.0, + "gyro_MHz_per_T": 42.5764, + "larmor_Hz": 127729200.0, + "source": "Unmodified phantom system and Pulseq definitions; no scanner override is exposed by this tool." + }, + "phantom": { + "grid_shape": [ + 181, + 217, + 4 + ], + "voxel_size_mm": [ + 1, + 1, + 1 + ], + "nonempty_voxels": 97653, + "resampled": false, + "tissue_stats_order": [ + "csf", + "fat", + "gm", + "vessels", + "wm" + ], + "default_properties": { + "B1+": [ + 1 + ], + "B1-": [ + 1 + ], + "ADC": 0 + }, + "T2_prime": "infinite for cases 0-3, published values for case 4" + }, + "postprocessing": "Only remove the singleton coil axis and write complex128 to the HDF5 signal dataset. No normalization, phase rotation, conjugation, filtering, reordering, or reconstruction.", + "runs": [ + { + "case": 0, + "arguments": { + "sequence": "028337d068137eadce333dc0207ad9ee0941bfa2f666ff58fb2320a8d6fd9633", + "phantom": "b06dd19ca3047c528ecd7163187f414e9ea84a54a2df9f66b492da40c43f8498", + "sampler": "direct", + "min_mag": 1e-07, + "compute_signal_stats": true + }, + "output_signal": { + "sha256": "7f0422a2ca4fb1e0bbe61a9657fc522e49aa9306df5d016f0488721053fb530a", + "url": "https://mrx-org--mcp-gateway-func.modal.run/files/7f0422a2ca4fb1e0bbe61a9657fc522e49aa9306df5d016f0488721053fb530a" + }, + "output_stats": { + "sha256": "a129969fd640774d58882e4e109521d43efea0d82c4434c5ea7e2c55f4db2f05", + "url": "https://mrx-org--mcp-gateway-func.modal.run/files/a129969fd640774d58882e4e109521d43efea0d82c4434c5ea7e2c55f4db2f05" + }, + "validation": { + "service_shape": [ + 1024, + 1 + ], + "dtype": "complex128", + "all_finite": true, + "nonzero": true, + "tissue_sum_max_abs_error": 0.0 + } + }, + { + "case": 1, + "arguments": { + "sequence": "dbda1eb763af0473a283b2e43d021c4cc2efd6e7b0ada1826b37c753fd17e846", + "phantom": "b06dd19ca3047c528ecd7163187f414e9ea84a54a2df9f66b492da40c43f8498", + "sampler": "direct", + "min_mag": 1e-07, + "compute_signal_stats": true + }, + "output_signal": { + "sha256": "2044466a858eca99fca70af217a810215ebdf4ddff763f8f72256df5fc22a67e", + "url": "https://mrx-org--mcp-gateway-func.modal.run/files/2044466a858eca99fca70af217a810215ebdf4ddff763f8f72256df5fc22a67e" + }, + "output_stats": { + "sha256": "34320a80c5e103573b636646a6dc10457848aa7a38d734d5407906067043ddd2", + "url": "https://mrx-org--mcp-gateway-func.modal.run/files/34320a80c5e103573b636646a6dc10457848aa7a38d734d5407906067043ddd2" + }, + "validation": { + "service_shape": [ + 4096, + 1 + ], + "dtype": "complex128", + "all_finite": true, + "nonzero": true, + "tissue_sum_max_abs_error": 0.0 + } + }, + { + "case": 2, + "arguments": { + "sequence": "b640e687776374c4f1a5a6b8fc3c584bc4e5567e757a7e2ca884c28341935fa8", + "phantom": "b06dd19ca3047c528ecd7163187f414e9ea84a54a2df9f66b492da40c43f8498", + "sampler": "direct", + "min_mag": 1e-10, + "compute_signal_stats": true + }, + "output_signal": { + "sha256": "6515b3b87367e5735903420cf17db6df55d6fadac22309c4b7ed77048fdf8b48", + "url": "https://mrx-org--mcp-gateway-func.modal.run/files/6515b3b87367e5735903420cf17db6df55d6fadac22309c4b7ed77048fdf8b48" + }, + "output_stats": { + "sha256": "97207e33f4fbd3a636217704c7cb42623d587ec032dd40a5a462f9370f9defcb", + "url": "https://mrx-org--mcp-gateway-func.modal.run/files/97207e33f4fbd3a636217704c7cb42623d587ec032dd40a5a462f9370f9defcb" + }, + "validation": { + "service_shape": [ + 4096, + 1 + ], + "dtype": "complex128", + "all_finite": true, + "nonzero": true, + "tissue_sum_max_abs_error": 0.0 + } + }, + { + "case": 3, + "arguments": { + "sequence": "538086b96118e981cc23b8b58c46230fbb6364005103714f9c69fad9e9976e4c", + "phantom": "b06dd19ca3047c528ecd7163187f414e9ea84a54a2df9f66b492da40c43f8498", + "sampler": "direct", + "min_mag": 1e-07, + "compute_signal_stats": true + }, + "output_signal": { + "sha256": "9ade703848507f72b52255015aef79e9b0a05259d7356cafbc6be2b36d48d765", + "url": "https://mrx-org--mcp-gateway-func.modal.run/files/9ade703848507f72b52255015aef79e9b0a05259d7356cafbc6be2b36d48d765" + }, + "output_stats": { + "sha256": "0ba209bacaad5800c62599e7966240f5c32df9d3d8e7a8b11326edbf72e7fa07", + "url": "https://mrx-org--mcp-gateway-func.modal.run/files/0ba209bacaad5800c62599e7966240f5c32df9d3d8e7a8b11326edbf72e7fa07" + }, + "validation": { + "service_shape": [ + 4096, + 1 + ], + "dtype": "complex128", + "all_finite": true, + "nonzero": true, + "tissue_sum_max_abs_error": 0.0 + } + }, + { + "case": 4, + "arguments": { + "sequence": "538086b96118e981cc23b8b58c46230fbb6364005103714f9c69fad9e9976e4c", + "phantom": "20352e68045e2a3ea7f588058a9501e54a01bacd3109f7c6ad62a2a31b4d60e5", + "sampler": "direct", + "min_mag": 1e-07, + "compute_signal_stats": true + }, + "output_signal": { + "sha256": "c63ec5d73dc7313680167f9c54dfedabad24adfde8dfddb1b6f0ea971be19cd8", + "url": "https://mrx-org--mcp-gateway-func.modal.run/files/c63ec5d73dc7313680167f9c54dfedabad24adfde8dfddb1b6f0ea971be19cd8" + }, + "output_stats": { + "sha256": "e6abf0c93c4f13fbc5f7223bf3d9a651971c0a13481288579ce03a4eeb888c41", + "url": "https://mrx-org--mcp-gateway-func.modal.run/files/e6abf0c93c4f13fbc5f7223bf3d9a651971c0a13481288579ce03a4eeb888c41" + }, + "validation": { + "service_shape": [ + 4096, + 1 + ], + "dtype": "complex128", + "all_finite": true, + "nonzero": true, + "tissue_sum_max_abs_error": 0.0 + } + } + ], + "cutoff_checks": [ + { + "case": 0, + "min_mag_coarse": 1e-06, + "min_mag_fine": 1e-07, + "coarse_signal_sha256": "7f0422a2ca4fb1e0bbe61a9657fc522e49aa9306df5d016f0488721053fb530a", + "fine_signal_sha256": "7f0422a2ca4fb1e0bbe61a9657fc522e49aa9306df5d016f0488721053fb530a", + "relative_l2_change": 0.0, + "byte_identical": true + }, + { + "case": 1, + "min_mag_coarse": 1e-06, + "min_mag_fine": 1e-07, + "coarse_signal_sha256": "2044466a858eca99fca70af217a810215ebdf4ddff763f8f72256df5fc22a67e", + "fine_signal_sha256": "2044466a858eca99fca70af217a810215ebdf4ddff763f8f72256df5fc22a67e", + "relative_l2_change": 0.0, + "byte_identical": true + }, + { + "case": 3, + "min_mag_coarse": 1e-06, + "min_mag_fine": 1e-07, + "coarse_signal_sha256": "9ade703848507f72b52255015aef79e9b0a05259d7356cafbc6be2b36d48d765", + "fine_signal_sha256": "9ade703848507f72b52255015aef79e9b0a05259d7356cafbc6be2b36d48d765", + "relative_l2_change": 0.0, + "byte_identical": true + }, + { + "case": 4, + "min_mag_coarse": 1e-06, + "min_mag_fine": 1e-07, + "coarse_signal_sha256": "c63ec5d73dc7313680167f9c54dfedabad24adfde8dfddb1b6f0ea971be19cd8", + "fine_signal_sha256": "c63ec5d73dc7313680167f9c54dfedabad24adfde8dfddb1b6f0ea971be19cd8", + "relative_l2_change": 0.0, + "byte_identical": true + }, + { + "case": 2, + "min_mag_coarse": 1e-06, + "min_mag_fine": 1e-07, + "coarse_signal_sha256": "e3d46051ce958b834de4df283ea8489897c4c75ce3c9cbfe91e100fedad35cd9", + "fine_signal_sha256": "439ab9946f95920343700ba1ea2cbfade5bf76560d869c59626dc34c92b504a9", + "relative_l2_change": 0.00044292466062749615, + "byte_identical": false + }, + { + "case": 2, + "min_mag_coarse": 1e-07, + "min_mag_fine": 1e-08, + "coarse_signal_sha256": "439ab9946f95920343700ba1ea2cbfade5bf76560d869c59626dc34c92b504a9", + "fine_signal_sha256": "b0b5fd967b9b30cb0e24558345a771edc74a99c73c83f1008b6c55334b4e51f1", + "relative_l2_change": 0.00032122665535318446, + "byte_identical": false + }, + { + "case": 2, + "min_mag_coarse": 1e-08, + "min_mag_fine": 1e-09, + "coarse_signal_sha256": "b0b5fd967b9b30cb0e24558345a771edc74a99c73c83f1008b6c55334b4e51f1", + "fine_signal_sha256": "eb52cb70ebd08d55e8010c6391161aa0bf2c6ff4981fe8223a822e086af4ce5c", + "relative_l2_change": 0.0003122309974439452, + "byte_identical": false + }, + { + "case": 2, + "min_mag_coarse": 1e-09, + "min_mag_fine": 1e-10, + "coarse_signal_sha256": "eb52cb70ebd08d55e8010c6391161aa0bf2c6ff4981fe8223a822e086af4ce5c", + "fine_signal_sha256": "6515b3b87367e5735903420cf17db6df55d6fadac22309c4b7ed77048fdf8b48", + "relative_l2_change": 0.00010919443851155955, + "byte_identical": false + }, + { + "case": 2, + "min_mag_coarse": 1e-10, + "min_mag_fine": 1e-11, + "coarse_signal_sha256": "6515b3b87367e5735903420cf17db6df55d6fadac22309c4b7ed77048fdf8b48", + "fine_signal_sha256": "6515b3b87367e5735903420cf17db6df55d6fadac22309c4b7ed77048fdf8b48", + "relative_l2_change": 0.0, + "byte_identical": true + } + ], + "limitations": [ + "Remote backend version/commit and hardware were not reported; tool_date identifies the run.", + "The cutoff sweep tests sensitivity to this exposed parameter, not agreement with an independent physics ground truth.", + "The service does not expose RF-discretization or internal time-step settings.", + "CAS URLs may not remain available indefinitely; the submitted HDF5 files preserve the raw results." + ] +} diff --git a/submissions/MRzero-RapiSim-direct-mzaiss/reproduce.py b/submissions/MRzero-RapiSim-direct-mzaiss/reproduce.py new file mode 100644 index 0000000..57b9f2e --- /dev/null +++ b/submissions/MRzero-RapiSim-direct-mzaiss/reproduce.py @@ -0,0 +1,102 @@ +"""Prepare exact inputs and export MRzero plugin results; not a local solver. + +Requires numpy and h5py for export. See RUN.md for the service simulation step. +""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import urllib.request +import zipfile +from pathlib import Path + + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] + + +def checked_bytes(path: Path, expected: str) -> bytes: + data = path.read_bytes() + actual = hashlib.sha256(data).hexdigest() + if actual != expected: + raise ValueError(f"SHA-256 mismatch for {path}: {actual} != {expected}") + return data + + +def prepare(manifest: dict, output: Path) -> None: + output.mkdir(parents=True, exist_ok=True) + for name, digest in manifest["input_sha256"].items(): + checked_bytes(ROOT / name, digest) + for archive in manifest["phantom_archives"]: + target = output / archive["file_name"] + with zipfile.ZipFile(target, "w", compression=zipfile.ZIP_STORED) as handle: + for name in archive["members"]: + info = zipfile.ZipInfo(name, date_time=(1980, 1, 1, 0, 0, 0)) + info.compress_type = zipfile.ZIP_STORED + info.external_attr = 0o644 << 16 + handle.writestr(info, (ROOT / "phantoms/brainweb" / name).read_bytes()) + checked_bytes(target, archive["sha256"]) + print(f"Verified {target}: {archive['sha256']}") + calls = [{"case": run["case"], "tool": manifest["tool"], "arguments": run["arguments"]} + for run in manifest["runs"]] + (output / "simulation_calls.json").write_text(json.dumps(calls, indent=2) + "\n") + print("Upload the archives and original .seq files through the MRzero plugin,") + print("then execute the recorded calls in simulation_calls.json.") + + +def export(manifest: dict, signals: Path, output: Path, download: bool) -> None: + import h5py + import numpy as np + + signals.mkdir(parents=True, exist_ok=True) + output.mkdir(parents=True, exist_ok=True) + for run in manifest["runs"]: + case = run["case"] + source = signals / f"case{case}_signal.npy" + artifact = run["output_signal"] + if download: + with urllib.request.urlopen(artifact["url"], timeout=120) as response: + data = response.read() + if hashlib.sha256(data).hexdigest() != artifact["sha256"]: + raise ValueError(f"Downloaded signal checksum mismatch for case {case}") + source.write_bytes(data) + checked_bytes(source, artifact["sha256"]) + raw = np.load(source, allow_pickle=False) + count = 1024 if case == 0 else 4096 + if raw.shape != (count, 1) or raw.dtype != np.dtype("complex128"): + raise ValueError(f"Unexpected signal shape/dtype: {raw.shape}, {raw.dtype}") + if not np.isfinite(raw).all() or not np.any(raw): + raise ValueError(f"Nonfinite or all-zero signal for case {case}") + # The service returns (samples, coils); the published phantom has one coil. + # Remove only the singleton coil dimension. Preserve values and ADC order. + signal = raw[:, 0] + target = output / f"case{case}.h5" + with h5py.File(target, "w") as handle: + handle.create_dataset("signal", data=signal, track_times=False) + with h5py.File(target, "r") as handle: + if not np.array_equal(handle["signal"][()], signal): + raise ValueError(f"HDF5 round-trip changed the signal for case {case}") + print(f"Exported {target}: complex128, {count} finite samples") + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) + sub = parser.add_subparsers(dest="command", required=True) + prep = sub.add_parser("prepare", help="verify inputs, make ZIPs, list service calls") + prep.add_argument("--output-dir", type=Path, required=True) + exp = sub.add_parser("export", help="export the recorded service results to HDF5") + exp.add_argument("--signals-dir", type=Path, required=True) + exp.add_argument("--output-dir", type=Path, default=HERE) + exp.add_argument("--download", action="store_true", help="retrieve recorded CAS results") + args = parser.parse_args() + manifest = json.loads((HERE / "provenance.json").read_text()) + if args.command == "prepare": + prepare(manifest, args.output_dir) + else: + export(manifest, args.signals_dir, args.output_dir, args.download) + + +if __name__ == "__main__": + main() diff --git a/submissions/MRzero-RapiSim-direct-mzaiss/submission.json b/submissions/MRzero-RapiSim-direct-mzaiss/submission.json new file mode 100644 index 0000000..326d9e4 --- /dev/null +++ b/submissions/MRzero-RapiSim-direct-mzaiss/submission.json @@ -0,0 +1,39 @@ +{ + "group": "mzaiss", + "tool_name": "MRzero plugin / RapiSim (direct)", + "tool_version": "", + "tool_commit": "", + "tool_date": "2026-10-27", + "solver": "RapiSim, direct sampler; min_mag=1e-7 for cases 0,1,3,4 and 1e-10 for case 2; compute_signal_stats=true", + "project_page": "", + "paper": "", + "hardware": "", + "cases": [ + { + "case": 0, + "runtime_s": null, + "mrzero_runtime_s": null + }, + { + "case": 1, + "runtime_s": null, + "mrzero_runtime_s": null + }, + { + "case": 2, + "runtime_s": null, + "mrzero_runtime_s": null + }, + { + "case": 3, + "runtime_s": null, + "mrzero_runtime_s": null + }, + { + "case": 4, + "runtime_s": null, + "mrzero_runtime_s": null + } + ], + "setup_notes": "Run through the MRzero ChatGPT plugin. Unmodified challenge inputs at commit 4c0d86e74aebf56d2e27b69c1f273483d4b7dbb9; native 181x217x4 grid, no resampling. Phantom B0=3 T and gyro=42.5764 MHz/T retained. Defaults: B1+=B1-=1, ADC=0, T2 prime infinite unless specified. Raw complex128 output is preserved with only the singleton coil axis removed. State-cutoff checks and input/output hashes are in provenance.json. Backend version, commit, hardware, and compute timings are not exposed; tool_date records the run, and timings remain null. Prepared with ChatGPT assistance." +}