Evidence · FSL

prelude

prelude is FSL’s phase unwrapping (PRELUDE, Jenkinson 2003). A phase image is known only up to whole cycles of 2π, and prelude finds the cycles, region by region, that make it vary smoothly; fMRIPrep runs it for every phase-difference field map. The replica (larmorx-nc) gives FSL 6.0.7.23’s files, messages and exit status byte for byte in 67 of its 68 compared cases, out of 88, fMRIPrep’s seven calls among them. In the other, a complex128 image, FSL’s values come from memory it never wrote, and the exit status, messages and file names are compared. The clean room (larmorx) gives FSL’s files, messages and exit status byte for byte in 134 of its 138 compared cases, out of 166, fMRIPrep’s seven calls among them; in the other 4, FSL’s values come from memory it never wrote. It unwraps fMRIPrep’s two large calls 97 and 211 times as fast as FSL on one thread, and a large generated map 610 times.

Ports
  • replica larmorx-nc FSL Licence: non-commercial use only: translated from FSL 6.0.7.23's source (fsl-fugue 2603.0, with newimage's complex reader); it runs as a separate program
  • clean room larmorx Apache-2.0: crate larmorx-fsl, written from specs/prelude.md, Jenkinson's paper, FSL's usage text and runs of FSL 6.0.7.23, without FSL's source (2026-11-06 and 07)
Status
replica experimental; clean room experimental
Records
the replica's: standard comparison (FSL 6.0.7.23) · the clean room's: standard comparison (FSL 6.0.7.23) · benchmark fsl-prelude
Reference
prelude · API page fsl-prelude

What is compared

A gradient-echo field map measures the off-resonance field as a phase. The phase difference between two echoes is proportional to the field, but the scanner stores it only modulo 2π. So wherever the field is strong, the stored phase jumps by a whole cycle between neighbouring voxels. Unwrapping adds back the missing cycles.

prelude (Phase Region Expanding Labeller for Unwrapping Discrete Estimates; M. Jenkinson, Fast, automated, N-dimensional phase-unwrapping algorithm, Magnetic Resonance in Medicine 49:193–197, 2003) works in three steps:

  • it splits the phase range into -n intervals (8 by default) and labels the connected regions of voxels whose phase falls in the same interval inside a mask;
  • it merges the regions two at a time. For each pair of touching regions it sums the phase differences across their boundary. From these sums follow the whole number of cycles that best joins the two regions, and how well it does: a measure that grows with the boundary’s size and with how close the joining is to a whole number of cycles. The pair with the largest measure is merged first: the voxels of one region move by that number of cycles, and the merged region’s boundaries with its other neighbours are summed again;
  • when one region remains, every voxel holds its phase plus its region’s whole cycles.

The mask is the given one (-m), or the magnitude’s voxels above a threshold (-t, by default a tenth of the way from the 2nd to the 98th percentile), kept to its largest connected part. The labels are 3D, or 2D slice by slice for images wider than 64 voxels or with --labelslices. -s unwraps each slice on its own and joins the slices after. --removeramps removes the phase’s linear ramp along each axis before unwrapping and restores it after.

Its input is a phase and a magnitude (-p, -a), or a complex image (-c). A phase from 0 to 2π is rewrapped to [−π, π] first, and a phase spanning more than 3π is refused. Besides the unwrapped phase it writes, on request, the mask (--savemask), the regions’ labels (-l) and the phase as read (-r).

fMRIPrep calls prelude for every phase-difference field map, in sdcflows’ phase-difference workflow (fmap_preproc_wf/<estimator>/phdiff_wf/prelude). sdcflows first rescales the scanner’s phase difference to radians from its minimum and maximum (or subtracts two phase images, each rescaled), clips the magnitude and extracts the brain. It then runs prelude --abs=<magnitude> --mask=<brain mask> --phase=<phase difference in rad> --unwrap=<out>, and turns the unwrapped phase into the field in Hz: divided by 2π and by the echo-time difference.

The two ports run beside FSL 6.0.7.23’s prelude on the same files with the same arguments. fMRIPrep’s own outputs are the files it wrote in its runs, with prelude in fMRIPrep 25.2.6’s image.

bash
larmorx fsl prelude --abs=magnitude --mask=brainmask --phase=phasediff_rad --unwrap=unwrapped
larmorx fsl prelude -c complex -o unwrapped --savemask=mask -l labels --removeramps -v

The first is fMRIPrep’s call. The second unwraps a complex image with its ramps removed, saves the mask and the regions’ labels, and prints every message.

python
import larmorx as lx

res = lx.fsl.prelude("phasediff_rad.nii.gz", "magnitude.nii.gz", mask="mask.nii.gz")
# res.unwrapped: an lx.Image, float32, in radians
res = lx.fsl.prelude(complex_image="complex.nii.gz", remove_ramps=True,
                     save_mask=True, save_labels=True)
# res.mask and res.labels: the mask and the regions' labels

The calls above leave implementation at "auto". The API page describes every option. How to read what follows: how to read the evidence.

Its two ports

FSL comes under the FSL Licence, which allows non-commercial use only. So LARMORX has two ports of its FSL programs. The replica is translated from FSL’s source and lives in its own package, larmorx-nc (pip install larmorx-nc). The clean room is in larmorx itself. It is written without FSL’s code, from prelude’s behavioural specification (specs/prelude.md), Jenkinson’s paper, FSL’s usage text and runs of FSL 6.0.7.23 as a black box.

implementation="auto" | "replica" | "clean-room" chooses between them ("original" in 0.1.0rc1). On the command line, larmorx --implementation clean-room fsl prelude ... does the same from the next release; in 0.1.0rc1 it is the environment variable LARMORX_IMPLEMENTATION. auto, and larmorx fsl prelude, take the replica when larmorx-nc is installed, else the clean room.

The replica follows FSL 6.0.7.23. It runs none of FSL’s programs and needs no FSL installation. It keeps FSL’s merging order exactly: the same boundary sums, the same arithmetic in the same order. Only its bookkeeping of the regions and their boundaries is faster (ordered sets).

The clean room has every option, message, exit status and failure case, and the defects with their switches; its record holds every file prelude writes to FSL’s bits (the specification’s threshold, below). It is built for speed:

  • where FSL looks for the next merge by scanning every boundary sum, for the members of the region that joins by scanning every region, and for its neighbours by scanning every region number, the clean room keeps the sums in slots the merges reuse, an indexed heap of the candidate merges keyed by their measure and pair, each region’s list of sums and a weighted union-find of the regions’ whole cycles. So a choice costs a logarithm, and a merge the neighbours of the region that joins;
  • it makes FSL’s choices in FSL’s order with FSL’s arithmetic, so the bits are FSL’s;
  • the linear parts (the mask’s threshold and its largest part, the regions, the ramps, reading and writing) run on the call’s threads in fixed chunks, so the result is the same bits at any thread count;
  • it holds no copy of the phase where none is needed.

The verdicts at a glance

The replica is a translation of FSL’s source, so the question for it is whether it gives FSL’s bytes: every file prelude writes (each image’s header and data: the unwrapped phase, the mask, the labels, the raw phase), its standard output and error, and its exit status.

Agreement, replica against the original: FSL prelude 6.0.7.23 (standard comparison, 88 cases of the record), by category and verdict
fMRIPrep's calls7
options46
output types6
the data panel's phase differences5
errors and messages22
random testing2

Select a segment to list its cases below.

The replica’s record runs 88 cases against FSL 6.0.7.23 (the record):

  • Bit-identical, 67. FSL’s files byte for byte, with FSL’s messages and exit status.
  • Rejected by both, 20. FSL refuses the input or stops, and the replica does the same, with the same message and exit status.
  • Expected divergence, 1. FSL reads a complex128 image with no width, so its values come from memory it never wrote (FSL-265). The exit status, messages and file names are compared.

The cases cover:

  • fMRIPrep’s seven calls on four fMRIPrep runs, fMRIPrep’s own outputs the same too, and the data panel’s two other phase-difference maps;
  • every option: phase and magnitude, or a complex image in both byte orders and widths; the mask and its threshold; 3D and 2D labels and unwrapping; the phase intervals; series with --start and --end; the saved mask, labels and raw phase; the ramps; -v’s messages;
  • every output type, and NaN values in the magnitude and the phase;
  • every message, exit status and failure case of the command line.

Each case also runs the replica’s default, fix, where LARMORX corrects FSL’s deterministic defects and names them (below).

The clean room is written without FSL’s source, so its record holds it to the thresholds of specs/prelude.md §11:

  • FSL’s exit status, standard output and error, and the files’ names;
  • in reproduce, every file prelude writes bit for bit: each image’s header whole, its extension bytes included, but descrip, and its data;
  • in fix, its default, the replica’s fix the same, and the same defects named. Where GLIBC-07 is named (below), the unwrapped phase must keep the replica’s whole cycles on at least 99.9 % of the mask’s voxels.

Each case’s verdict is read from what the record measures.

Agreement, clean room against the original: FSL prelude 6.0.7.23 (standard comparison, 166 cases of the record), by category and verdict
fMRIPrep's calls7
options46
output types6
the data panel's phase differences5
errors and messages22
random testing3
the clean room's own: options19
the clean room's own: images29
the clean room's own: NaN values8
the clean room's own: failures6
the clean room's own: output types8
the clean room's own: fMRIPrep's calls7

Select a segment to list its cases below.

The clean room’s record runs 166 cases against FSL 6.0.7.23 (the record): the replica suite’s 88 cases, with the clean room standing in for the replica’s program and FSL’s runs served by the cache of the original’s runs; 77 of its own (orig-: the specification’s validation plan on generated inputs, every option, image type, orientation, series, complex image, NaN, output type and failure, and fMRIPrep’s seven calls run three ways); and a permanent case of random testing. By what each case measures:

  • Bit-identical, 134. FSL’s files byte for byte, with FSL’s messages and exit status. fMRIPrep’s seven calls are among them, each also against fMRIPrep’s own output.
  • Rejected by both, 28. FSL refuses the input or stops, and the clean room does the same.
  • Expected divergences, 4. FSL reads values from memory it never wrote: a complex128 image (FSL-265), twice, and an image that is not complex given to -c (FSL-263), twice. The exit status, messages and file names are FSL’s; the values are not compared.

In reproduce, 282 of 282 files of its own cases are FSL’s headers and data bit for bit. In fix, 252 of 252 are the replica’s fix bit for bit. On the 5 complex images whose phase it computes with the correctly rounded arctangent (GLIBC-07, below), the unwrapped phase keeps the replica’s whole cycles on every voxel of the mask.

In fMRIPrep: the phase differences of four fMRIPrep runs

fMRIPrep’s seven prelude calls were given to FSL 6.0.7.23 (the record’s runs, served by the cache of the original’s runs), to the replica in reproduce and in fix, and to the clean room in reproduce at 14 threads and at one and in fix. fMRIPrep’s own output stands beside them: prelude in fMRIPrep’s image. Every comparison gives the same bytes. The first table counts what unwrapping did in each call. The second gives the clean room’s comparisons and the benchmark’s seconds.

fMRIPrep’s seven calls, the replica against the original: FSL prelude 6.0.7.23

RunGridVoxels in the maskWhole cycles addedVoxels movedreplica, reproduce, against FSL prelude 6.0.7.23replica against fMRIPrep's outputreplica, fix against reproduce
ds005454-sub-16a GRE phase difference112 × 112 × 70 voxels of 2 × 2 × 2.1 mm187,289-1 to 199,348identicalidenticalidentical
ds002603-sub-01a Philips phase difference at 2 mm128 × 128 × 128 voxels of 2 × 2 × 2 mm265,356-2 to 297,867identicalidenticalidentical
ds002422-sub-02the first of two phase differences64 × 64 × 24 voxels of 3 × 3 × 3.3 mm32,742-1 to 0822identicalidenticalidentical
ds002422-sub-02the second phase difference64 × 64 × 36 voxels of 3.59 × 3.59 × 3.78 mm37,840-1 to 17,370identicalidenticalidentical
ds001600-sub-1two phase images64 × 64 × 44 voxels of 3.75 × 3.75 × 4 mm25,928-1 to 1128identicalidenticalidentical
ds001600-sub-1two phase images of a second protocol64 × 64 × 44 voxels of 3.75 × 3.75 × 4 mm25,925-1 to 1116identicalidenticalidentical
ds001600-sub-1a phase difference64 × 64 × 44 voxels of 3.75 × 3.75 × 4 mm25,9890 to 112,447identicalidenticalidentical

Each call’s unwrapped phase compared byte for byte (the image decompressed, descrip left out): identical, every value. Whole cycles added: FSL’s output minus the wrapped phase rewrapped to [−π, π], in cycles of 2π, inside the mask; voxels moved: those with a nonzero number. The record compares every file, the messages and the exit status too.

fMRIPrep’s seven calls, the clean room against the original: FSL prelude 6.0.7.23

Runclean room, reproduce, against FSL prelude 6.0.7.23clean room against fMRIPrep's outputclean room, fix against the replica's fixclean room, 1 thread against 14Seconds: FSL / replica / clean room at 1 and 12 threads
ds005454-sub-16a GRE phase differenceidenticalidenticalidenticalidentical6.68 / 0.173 / 0.0688 / 0.0528 s
ds002603-sub-01a Philips phase difference at 2 mmidenticalidenticalidenticalidentical28.4 / 0.374 / 0.135 / 0.103 s
ds002422-sub-02the first of two phase differencesidenticalidenticalidenticalidentical0.0684 / 0.0095 / 0.0103 / 0.0105 s
ds002422-sub-02the second phase differenceidenticalidenticalidenticalidentical0.0605 / 0.0142 / 0.0123 / 0.0114 s
ds001600-sub-1two phase imagesidenticalidenticalidenticalidentical0.0818 / 0.0162 / 0.0153 / 0.0146 s
ds001600-sub-1two phase images of a second protocolidenticalidenticalidenticalidentical0.0904 / 0.0181 / 0.016 / 0.0143 s
ds001600-sub-1a phase differenceidenticalidenticalidenticalidentical0.0811 / 0.0166 / 0.0141 / 0.0133 s

The examples’ runs: the clean room’s unwrapped phase compared value by value with FSL 6.0.7.23’s run (the record’s, from the cache of the original’s runs), with fMRIPrep’s own output, with the replica’s default and with its own run at 14 threads. The seconds are the benchmark report’s (docs/benchmarks/fsl-prelude.md: the best of five runs, FSL once, the whole call).

ds005454: a GRE phase difference

The input panels are what prelude is given: the phase difference wrapped into 0 to 2π, the magnitude, and the brain mask drawn over the magnitude. The viewer opens where unwrapping added the most cycles in its slice. The replica’s and the clean room’s differences from FSL and from fMRIPrep’s own output are zero everywhere, at 14 threads and at one.

Worked example

fMRIPrep's call on ds005454-sub-16: a GRE phase difference

What this shows: On fMRIPrep’s own call, unwrapping moves 99,348 of the mask’s 187,289 voxels by whole cycles of 2π, from −1 to 1. Both ports give FSL’s unwrapped phase, every value, and the same values as fMRIPrep’s own output; the clean room the same at 1 and 14 threads. No correction by default changes this call, in either port.

The prelude node fMRIPrep 25.2.6 ran on ds005454-sub-16 (a GRE phase difference (Siemens, 7 T) of a multiband study; sdcflows’ wf_gre16 estimator), given to FSL 6.0.7.23 and to the replica (larmorx-nc) in reproduce and in fix, and to LARMORX’s clean room (Apache-2.0) in reproduce at 14 threads and at one and in fix, its default, with fMRIPrep’s own output beside them. The input panels are what prelude is given: the phase difference wrapped into 0 to 2π, the magnitude, and the brain mask (drawn over the magnitude). Unwrapping adds whole cycles of 2π, region by region, so the phase varies smoothly inside the mask; sdcflows then turns it into the field in Hz.

Data
OpenNeuro ds005454, sub-16 (CC-BY-4.0): the field map’s phase difference and magnitude as sdcflows prepared them; shown inside sdcflows’ brain mask (prelude’s --mask), dilated by 2 voxels (1,573 ml in the mask), so no face shows
Node
fMRIPrep 25.2.6, work/fmriprep_25_2_wf/sub_16_wf/fmap_preproc_wf/wf_gre16/phdiff_wf/prelude
Command
prelude --abs=<sdcflows' clipped magnitude> --mask=<sdcflows' brain mask> --phase=<the phase difference in rad> --unwrap=sub-16_phasediff_rads_unwrapped.nii.gz
Cycles added
99,348 of the 187,289 voxels in the mask moved by whole cycles of 2π, from -1 to 1 (FSL’s output against the wrapped phase rewrapped to [−π, π]; every one a whole number of cycles to 5.9e-07 rad)
Programs
FSL 6.0.7.23 (fsl-fugue 2603.0; ~/fsl-6.0.7.23, never on the PATH) (its runs served from the cache of the original’s runs, as the record ran them); larmorx-nc 0.0.1 (the replica), from LARMORX at commit 069338d2d02d; LARMORX’s clean room (crate larmorx-fsl, Apache-2.0), from LARMORX at commit c292c141c0bb
Grid
112 × 112 × 70 voxels of 2 × 2 × 2.1 mm; shown: 75 × 93 × 70 around the brain

Data shown

Inputds005454-sub-16: phase difference (rad)prelude's --phase in fMRIPrep: sdcflows' au2rads of the scanner's phase difference, 0 to 2π (float32), wrapped
Inputds005454-sub-16: magnitudeprelude's --abs: sdcflows' clipped magnitude (int16, 0 to 255)
OriginalFSL prelude 6.0.7.23the conda installation, as built (the record's run, from the cache of the original's runs)
Replicareplicalarmorx-nc, FSL Licence · reproduce · against FSL prelude 6.0.7.23
Clean roomclean roomlarmorx, Apache-2.0 · reproduce, 14 threads · against FSL prelude 6.0.7.23

Bit-identical878,080 of 878,080 voxels equal

the replica against the originalreplica − FSL prelude 6.0.7.23

Bit-identical878,080 of 878,080 voxels equal

the replica against fMRIPrep's outputreplica − fMRIPrep's output

Bit-identical878,080 of 878,080 voxels equal

the clean room against the originalclean room − FSL prelude 6.0.7.23

Axial slice 30 of 70; the crosshair where FSL's unwrapped phase departs most from the wrapped phase it was given in this slice (the most cycles added); the replica's output equals FSL's everywhere; the clean room's reproduce equals FSL's everywhere too, at 14 threads and at one. The interactive viewer needs JavaScript; the metrics below are complete without it.

Every comparison, computed in float64 over every voxel of the outputs

Comparison (A − B), verdict and reasonmax |Δ|Values that differRMS of Δmax |Δ| ÷ range1 − NCC
The replica against the original and fMRIPrep's output
replica − FSL prelude 6.0.7.23Bit-identicalThe same values, every one, in the unwrapped phase (the record compares every file prelude writes, its messages and its exit status too).identical: 0 of 878,080 values differ
replica − fMRIPrep's outputBit-identicalfMRIPrep’s own unwrapped phase (prelude in fMRIPrep 25.2.6’s image, FSL’s earlier build) holds the same values.identical: 0 of 878,080 values differ
The replica against itself: fix and reproduce
replica, fix − reproduceBit-identicalNo correction of the register applies to this call: fix and reproduce give the same values.identical: 0 of 878,080 values differ
The clean room against the original, fMRIPrep's output and the replica
clean room − FSL prelude 6.0.7.23Bit-identicalThe same values, every one, in the unwrapped phase (the record compares every file prelude writes, its header, its messages and its exit status too).identical: 0 of 878,080 values differ
clean room − fMRIPrep's outputBit-identicalfMRIPrep’s own unwrapped phase (prelude in fMRIPrep 25.2.6’s image, FSL’s earlier build) holds the same values.identical: 0 of 878,080 values differ
clean room − replica, reproduceBit-identicalThe two ports give the same values in reproduce: both FSL’s.identical: 0 of 878,080 values differ
clean room − replica, fixBit-identicalThe two ports give the same values in fix, their default (the record holds every case’s default against the replica’s).identical: 0 of 878,080 values differ
The clean room against itself: thread counts, fix and reproduce
clean room, 1 thread − 14 threadsBit-identicalThe thread count changes nothing: the linear parts run on the call’s threads in fixed chunks, the merging in its one order, so the one-thread result is the 14-thread result bit for bit.identical: 0 of 878,080 values differ
clean room, fix − reproduceBit-identicalNo correction of the register applies to this call: fix and reproduce give the same values.identical: 0 of 878,080 values differ

Δ is A − B in radians, computed in float64 over all 878,080 voxels of the outputs, not only those shown. The replica’s record’s threshold: every file prelude writes bit-identical (images decompressed, descrip left out), with FSL’s exit status and messages. The clean room’s record (fsl-prelude) holds it to specs/prelude.md §11’s thresholds: in reproduce the same, each header whole with its extension bytes but descrip; in fix the replica’s fix, the same, but where GLIBC-07 is named, where the unwrapped phase keeps the replica’s whole cycles on at least 99.9 % of the mask’s voxels.

Provenance of this example
  • Data: OpenNeuro ds005454, sub-16, CC-BY-4.0
  • Inputs: clipped.nii.gz (sha256 da6b994811a1e00b…); clipped_mask.nii.gz (sha256 d748a07583ecf543…); sub-16_phasediff_rads.nii.gz (sha256 c41556eee49fa98d…)
  • Runs: figures cache entry fsl-prelude/fmriprep-ds005454-sub-16-noreconall-wf_gre16, computed 2026-11-06T19:26:21+00:00 with larmorx 069338d2d02d; FSL 6.0.7.23 (fsl-fugue 2603.0; ~/fsl-6.0.7.23, never on the PATH); larmorx-nc 0.0.1; every command, its environment, threads and exit status are in its RUN_INFO.json
  • Runs of the clean room: figures cache entry fsl-prelude/fmriprep-ds005454-sub-16-noreconall-wf_gre16-original, computed 2026-11-07T02:01:53+00:00 with larmorx c292c141c0bb (python -m larmorx with LARMORX_IMPLEMENTATION=original, reproduce at 14 threads and at one, fix, the default at 14), on the replica’s entry’s inputs; every command, its environment, threads and exit status are in its RUN_INFO.json

Every number above is in fsl-prelude.json, exported by python -m larmorx_validation evidence fsl-prelude.

ds002603: a Philips phase difference at 2 mm

Worked example

fMRIPrep's call on ds002603-sub-01: a Philips phase difference at 2 mm

What this shows: On fMRIPrep’s own call, unwrapping moves 97,867 of the mask’s 265,356 voxels by whole cycles of 2π, from −2 to 2. Both ports give FSL’s unwrapped phase, every value, and the same values as fMRIPrep’s own output; the clean room the same at 1 and 14 threads. No correction by default changes this call, in either port.

The prelude node fMRIPrep 25.2.6 ran on ds002603-sub-01 (a Philips phase difference at 2 mm (acq-Mm2), 128 × 128 × 128 voxels; sdcflows’ wf_auto_00000 estimator), given to FSL 6.0.7.23 and to the replica (larmorx-nc) in reproduce and in fix, and to LARMORX’s clean room (Apache-2.0) in reproduce at 14 threads and at one and in fix, its default, with fMRIPrep’s own output beside them. The input panels are what prelude is given: the phase difference wrapped into 0 to 2π, the magnitude, and the brain mask (drawn over the magnitude). Unwrapping adds whole cycles of 2π, region by region, so the phase varies smoothly inside the mask; sdcflows then turns it into the field in Hz.

Data
OpenNeuro ds002603, sub-01 (CC0-1.0): the field map’s phase difference and magnitude as sdcflows prepared them; shown inside sdcflows’ brain mask (prelude’s --mask), dilated by 2 voxels (2,123 ml in the mask), so no face shows
Node
fMRIPrep 25.2.6, work/fmriprep_25_2_wf/sub_01_wf/fmap_preproc_wf/wf_auto_00000/phdiff_wf/prelude
Command
prelude --abs=<sdcflows' clipped magnitude> --mask=<sdcflows' brain mask> --phase=<the phase difference in rad> --unwrap=sub-01_acq-Mm2_phasediff_rads_unwrapped.nii.gz
Cycles added
97,867 of the 265,356 voxels in the mask moved by whole cycles of 2π, from -2 to 2 (FSL’s output against the wrapped phase rewrapped to [−π, π]; every one a whole number of cycles to 5.9e-07 rad)
Programs
FSL 6.0.7.23 (fsl-fugue 2603.0; ~/fsl-6.0.7.23, never on the PATH) (its runs served from the cache of the original’s runs, as the record ran them); larmorx-nc 0.0.1 (the replica), from LARMORX at commit 069338d2d02d; LARMORX’s clean room (crate larmorx-fsl, Apache-2.0), from LARMORX at commit c292c141c0bb
Grid
128 × 128 × 128 voxels of 2 × 2 × 2 mm; shown: 82 × 100 × 84 around the brain
Inputds002603-sub-01: phase difference (rad)prelude's --phase in fMRIPrep: sdcflows' au2rads of the scanner's phase difference, 0 to 2π (float32), wrapped
Inputds002603-sub-01: magnitudeprelude's --abs: sdcflows' clipped magnitude (int16, 0 to 255)
OriginalFSL prelude 6.0.7.23the conda installation, as built (the record's run, from the cache of the original's runs)
Replicareplicalarmorx-nc, FSL Licence · reproduce · against FSL prelude 6.0.7.23
Clean roomclean roomlarmorx, Apache-2.0 · reproduce, 14 threads · against FSL prelude 6.0.7.23

Bit-identical2,097,152 of 2,097,152 voxels equal

the replica against the originalreplica − FSL prelude 6.0.7.23

Bit-identical2,097,152 of 2,097,152 voxels equal

the replica against fMRIPrep's outputreplica − fMRIPrep's output

Bit-identical2,097,152 of 2,097,152 voxels equal

the clean room against the originalclean room − FSL prelude 6.0.7.23

Axial slice 43 of 84; the crosshair where FSL's unwrapped phase departs most from the wrapped phase it was given in this slice (the most cycles added); the replica's output equals FSL's everywhere; the clean room's reproduce equals FSL's everywhere too, at 14 threads and at one. The interactive viewer needs JavaScript; the metrics below are complete without it.

Every comparison, computed in float64 over every voxel of the outputs

Comparison (A − B), verdict and reasonmax |Δ|Values that differRMS of Δmax |Δ| ÷ range1 − NCC
The replica against the original and fMRIPrep's output
replica − FSL prelude 6.0.7.23Bit-identicalThe same values, every one, in the unwrapped phase (the record compares every file prelude writes, its messages and its exit status too).identical: 0 of 2,097,152 values differ
replica − fMRIPrep's outputBit-identicalfMRIPrep’s own unwrapped phase (prelude in fMRIPrep 25.2.6’s image, FSL’s earlier build) holds the same values.identical: 0 of 2,097,152 values differ
The replica against itself: fix and reproduce
replica, fix − reproduceBit-identicalNo correction of the register applies to this call: fix and reproduce give the same values.identical: 0 of 2,097,152 values differ
The clean room against the original, fMRIPrep's output and the replica
clean room − FSL prelude 6.0.7.23Bit-identicalThe same values, every one, in the unwrapped phase (the record compares every file prelude writes, its header, its messages and its exit status too).identical: 0 of 2,097,152 values differ
clean room − fMRIPrep's outputBit-identicalfMRIPrep’s own unwrapped phase (prelude in fMRIPrep 25.2.6’s image, FSL’s earlier build) holds the same values.identical: 0 of 2,097,152 values differ
clean room − replica, reproduceBit-identicalThe two ports give the same values in reproduce: both FSL’s.identical: 0 of 2,097,152 values differ
clean room − replica, fixBit-identicalThe two ports give the same values in fix, their default (the record holds every case’s default against the replica’s).identical: 0 of 2,097,152 values differ
The clean room against itself: thread counts, fix and reproduce
clean room, 1 thread − 14 threadsBit-identicalThe thread count changes nothing: the linear parts run on the call’s threads in fixed chunks, the merging in its one order, so the one-thread result is the 14-thread result bit for bit.identical: 0 of 2,097,152 values differ
clean room, fix − reproduceBit-identicalNo correction of the register applies to this call: fix and reproduce give the same values.identical: 0 of 2,097,152 values differ

Δ is A − B in radians, computed in float64 over all 2,097,152 voxels of the outputs, not only those shown. The replica’s record’s threshold: every file prelude writes bit-identical (images decompressed, descrip left out), with FSL’s exit status and messages. The clean room’s record (fsl-prelude) holds it to specs/prelude.md §11’s thresholds: in reproduce the same, each header whole with its extension bytes but descrip; in fix the replica’s fix, the same, but where GLIBC-07 is named, where the unwrapped phase keeps the replica’s whole cycles on at least 99.9 % of the mask’s voxels.

Provenance of this example
  • Data: OpenNeuro ds002603, sub-01, CC0-1.0
  • Inputs: clipped.nii.gz (sha256 f57cf6848227f2f2…); clipped_mask.nii.gz (sha256 e45979f6a46d1728…); sub-01_acq-Mm2_phasediff_rads.nii.gz (sha256 0fb2a30f7a193ab1…)
  • Runs: figures cache entry fsl-prelude/fmriprep-ds002603-sub-01-noreconall-wf_auto_00000, computed 2026-11-06T19:26:21+00:00 with larmorx 069338d2d02d; FSL 6.0.7.23 (fsl-fugue 2603.0; ~/fsl-6.0.7.23, never on the PATH); larmorx-nc 0.0.1; every command, its environment, threads and exit status are in its RUN_INFO.json
  • Runs of the clean room: figures cache entry fsl-prelude/fmriprep-ds002603-sub-01-noreconall-wf_auto_00000-original, computed 2026-11-07T02:01:52+00:00 with larmorx c292c141c0bb (python -m larmorx with LARMORX_IMPLEMENTATION=original, reproduce at 14 threads and at one, fix, the default at 14), on the replica’s entry’s inputs; every command, its environment, threads and exit status are in its RUN_INFO.json

Every number above is in fsl-prelude.json, exported by python -m larmorx_validation evidence fsl-prelude.

ds002422: two phase differences at 1.5 T

The data panel’s 1.5 T subject has two phase-difference maps, on different grids, each unwrapped by its own call.

Worked example

fMRIPrep's call on ds002422-sub-02: the first of two phase differences

What this shows: On fMRIPrep’s own call, unwrapping moves 822 of the mask’s 32,742 voxels by whole cycles of 2π, from −1 to 0. Both ports give FSL’s unwrapped phase, every value, and the same values as fMRIPrep’s own output; the clean room the same at 1 and 14 threads. No correction by default changes this call, in either port.

The prelude node fMRIPrep 25.2.6 ran on ds002422-sub-02 (the first of two phase differences (1.5 T, run-01); sdcflows’ wf_auto_00000 estimator), given to FSL 6.0.7.23 and to the replica (larmorx-nc) in reproduce and in fix, and to LARMORX’s clean room (Apache-2.0) in reproduce at 14 threads and at one and in fix, its default, with fMRIPrep’s own output beside them. The input panels are what prelude is given: the phase difference wrapped into 0 to 2π, the magnitude, and the brain mask (drawn over the magnitude). Unwrapping adds whole cycles of 2π, region by region, so the phase varies smoothly inside the mask; sdcflows then turns it into the field in Hz.

Data
OpenNeuro ds002422, sub-02 (CC0-1.0): the field map’s phase difference and magnitude as sdcflows prepared them; shown inside sdcflows’ brain mask (prelude’s --mask), dilated by 2 voxels (972 ml in the mask), so no face shows
Node
fMRIPrep 25.2.6, work/fmriprep_25_2_wf/sub_02_wf/fmap_preproc_wf/wf_auto_00000/phdiff_wf/prelude
Command
prelude --abs=<sdcflows' clipped magnitude> --mask=<sdcflows' brain mask> --phase=<the phase difference in rad> --unwrap=sub-02_run-01_phasediff_rads_unwrapped.nii.gz
Cycles added
822 of the 32,742 voxels in the mask moved by whole cycles of 2π, from -1 to 0 (FSL’s output against the wrapped phase rewrapped to [−π, π]; every one a whole number of cycles to 1.8e-07 rad)
Programs
FSL 6.0.7.23 (fsl-fugue 2603.0; ~/fsl-6.0.7.23, never on the PATH) (its runs served from the cache of the original’s runs, as the record ran them); larmorx-nc 0.0.1 (the replica), from LARMORX at commit 069338d2d02d; LARMORX’s clean room (crate larmorx-fsl, Apache-2.0), from LARMORX at commit c292c141c0bb
Grid
64 × 64 × 24 voxels of 3 × 3 × 3.3 mm; shown: 54 × 62 × 24 around the brain
Inputds002422-sub-02: phase difference (rad)prelude's --phase in fMRIPrep: sdcflows' au2rads of the scanner's phase difference, 0 to 2π (float32), wrapped
Inputds002422-sub-02: magnitudeprelude's --abs: sdcflows' clipped magnitude (int16, 0 to 255)
OriginalFSL prelude 6.0.7.23the conda installation, as built (the record's run, from the cache of the original's runs)
Replicareplicalarmorx-nc, FSL Licence · reproduce · against FSL prelude 6.0.7.23
Clean roomclean roomlarmorx, Apache-2.0 · reproduce, 14 threads · against FSL prelude 6.0.7.23

Bit-identical98,304 of 98,304 voxels equal

the replica against the originalreplica − FSL prelude 6.0.7.23

Bit-identical98,304 of 98,304 voxels equal

the replica against fMRIPrep's outputreplica − fMRIPrep's output

Bit-identical98,304 of 98,304 voxels equal

the clean room against the originalclean room − FSL prelude 6.0.7.23

Axial slice 6 of 24; the crosshair where FSL's unwrapped phase departs most from the wrapped phase it was given in this slice (the most cycles added); the replica's output equals FSL's everywhere; the clean room's reproduce equals FSL's everywhere too, at 14 threads and at one. The interactive viewer needs JavaScript; the metrics below are complete without it.

Every comparison, computed in float64 over every voxel of the outputs

Comparison (A − B), verdict and reasonmax |Δ|Values that differRMS of Δmax |Δ| ÷ range1 − NCC
The replica against the original and fMRIPrep's output
replica − FSL prelude 6.0.7.23Bit-identicalThe same values, every one, in the unwrapped phase (the record compares every file prelude writes, its messages and its exit status too).identical: 0 of 98,304 values differ
replica − fMRIPrep's outputBit-identicalfMRIPrep’s own unwrapped phase (prelude in fMRIPrep 25.2.6’s image, FSL’s earlier build) holds the same values.identical: 0 of 98,304 values differ
The replica against itself: fix and reproduce
replica, fix − reproduceBit-identicalNo correction of the register applies to this call: fix and reproduce give the same values.identical: 0 of 98,304 values differ
The clean room against the original, fMRIPrep's output and the replica
clean room − FSL prelude 6.0.7.23Bit-identicalThe same values, every one, in the unwrapped phase (the record compares every file prelude writes, its header, its messages and its exit status too).identical: 0 of 98,304 values differ
clean room − fMRIPrep's outputBit-identicalfMRIPrep’s own unwrapped phase (prelude in fMRIPrep 25.2.6’s image, FSL’s earlier build) holds the same values.identical: 0 of 98,304 values differ
clean room − replica, reproduceBit-identicalThe two ports give the same values in reproduce: both FSL’s.identical: 0 of 98,304 values differ
clean room − replica, fixBit-identicalThe two ports give the same values in fix, their default (the record holds every case’s default against the replica’s).identical: 0 of 98,304 values differ
The clean room against itself: thread counts, fix and reproduce
clean room, 1 thread − 14 threadsBit-identicalThe thread count changes nothing: the linear parts run on the call’s threads in fixed chunks, the merging in its one order, so the one-thread result is the 14-thread result bit for bit.identical: 0 of 98,304 values differ
clean room, fix − reproduceBit-identicalNo correction of the register applies to this call: fix and reproduce give the same values.identical: 0 of 98,304 values differ

Δ is A − B in radians, computed in float64 over all 98,304 voxels of the outputs, not only those shown. The replica’s record’s threshold: every file prelude writes bit-identical (images decompressed, descrip left out), with FSL’s exit status and messages. The clean room’s record (fsl-prelude) holds it to specs/prelude.md §11’s thresholds: in reproduce the same, each header whole with its extension bytes but descrip; in fix the replica’s fix, the same, but where GLIBC-07 is named, where the unwrapped phase keeps the replica’s whole cycles on at least 99.9 % of the mask’s voxels.

Provenance of this example
  • Data: OpenNeuro ds002422, sub-02, CC0-1.0
  • Inputs: clipped.nii.gz (sha256 d3f31c76670abbd6…); clipped_mask.nii.gz (sha256 2e6e4b01b18c1c8f…); sub-02_run-01_phasediff_rads.nii (sha256 ec076a87e64931d1…)
  • Runs: figures cache entry fsl-prelude/fmriprep-ds002422-sub-02-noreconall-wf_auto_00000, computed 2026-11-06T19:26:21+00:00 with larmorx 069338d2d02d; FSL 6.0.7.23 (fsl-fugue 2603.0; ~/fsl-6.0.7.23, never on the PATH); larmorx-nc 0.0.1; every command, its environment, threads and exit status are in its RUN_INFO.json
  • Runs of the clean room: figures cache entry fsl-prelude/fmriprep-ds002422-sub-02-noreconall-wf_auto_00000-original, computed 2026-11-07T02:01:52+00:00 with larmorx c292c141c0bb (python -m larmorx with LARMORX_IMPLEMENTATION=original, reproduce at 14 threads and at one, fix, the default at 14), on the replica’s entry’s inputs; every command, its environment, threads and exit status are in its RUN_INFO.json

Every number above is in fsl-prelude.json, exported by python -m larmorx_validation evidence fsl-prelude.

Worked example

fMRIPrep's call on ds002422-sub-02: the second phase difference

What this shows: On fMRIPrep’s own call, unwrapping moves 7,370 of the mask’s 37,840 voxels by whole cycles of 2π, from −1 to 1. Both ports give FSL’s unwrapped phase, every value, and the same values as fMRIPrep’s own output; the clean room the same at 1 and 14 threads. No correction by default changes this call, in either port.

The prelude node fMRIPrep 25.2.6 ran on ds002422-sub-02 (the second phase difference (1.5 T, run-02), on another grid; sdcflows’ wf_auto_00001 estimator), given to FSL 6.0.7.23 and to the replica (larmorx-nc) in reproduce and in fix, and to LARMORX’s clean room (Apache-2.0) in reproduce at 14 threads and at one and in fix, its default, with fMRIPrep’s own output beside them. The input panels are what prelude is given: the phase difference wrapped into 0 to 2π, the magnitude, and the brain mask (drawn over the magnitude). Unwrapping adds whole cycles of 2π, region by region, so the phase varies smoothly inside the mask; sdcflows then turns it into the field in Hz.

Data
OpenNeuro ds002422, sub-02 (CC0-1.0): the field map’s phase difference and magnitude as sdcflows prepared them; shown inside sdcflows’ brain mask (prelude’s --mask), dilated by 2 voxels (1,847 ml in the mask), so no face shows
Node
fMRIPrep 25.2.6, work/fmriprep_25_2_wf/sub_02_wf/fmap_preproc_wf/wf_auto_00001/phdiff_wf/prelude
Command
prelude --abs=<sdcflows' clipped magnitude> --mask=<sdcflows' brain mask> --phase=<the phase difference in rad> --unwrap=sub-02_run-02_phasediff_rads_unwrapped.nii.gz
Cycles added
7,370 of the 37,840 voxels in the mask moved by whole cycles of 2π, from -1 to 1 (FSL’s output against the wrapped phase rewrapped to [−π, π]; every one a whole number of cycles to 3.5e-07 rad)
Programs
FSL 6.0.7.23 (fsl-fugue 2603.0; ~/fsl-6.0.7.23, never on the PATH) (its runs served from the cache of the original’s runs, as the record ran them); larmorx-nc 0.0.1 (the replica), from LARMORX at commit 069338d2d02d; LARMORX’s clean room (crate larmorx-fsl, Apache-2.0), from LARMORX at commit c292c141c0bb
Grid
64 × 64 × 36 voxels of 3.59 × 3.59 × 3.78 mm; shown: 48 × 55 × 36 around the brain
Inputds002422-sub-02: phase difference (rad)prelude's --phase in fMRIPrep: sdcflows' au2rads of the scanner's phase difference, 0 to 2π (float32), wrapped
Inputds002422-sub-02: magnitudeprelude's --abs: sdcflows' clipped magnitude (int16, 0 to 255)
OriginalFSL prelude 6.0.7.23the conda installation, as built (the record's run, from the cache of the original's runs)
Replicareplicalarmorx-nc, FSL Licence · reproduce · against FSL prelude 6.0.7.23
Clean roomclean roomlarmorx, Apache-2.0 · reproduce, 14 threads · against FSL prelude 6.0.7.23

Bit-identical147,456 of 147,456 voxels equal

the replica against the originalreplica − FSL prelude 6.0.7.23

Bit-identical147,456 of 147,456 voxels equal

the replica against fMRIPrep's outputreplica − fMRIPrep's output

Bit-identical147,456 of 147,456 voxels equal

the clean room against the originalclean room − FSL prelude 6.0.7.23

Axial slice 16 of 36; the crosshair where FSL's unwrapped phase departs most from the wrapped phase it was given in this slice (the most cycles added); the replica's output equals FSL's everywhere; the clean room's reproduce equals FSL's everywhere too, at 14 threads and at one. The interactive viewer needs JavaScript; the metrics below are complete without it.

Every comparison, computed in float64 over every voxel of the outputs

Comparison (A − B), verdict and reasonmax |Δ|Values that differRMS of Δmax |Δ| ÷ range1 − NCC
The replica against the original and fMRIPrep's output
replica − FSL prelude 6.0.7.23Bit-identicalThe same values, every one, in the unwrapped phase (the record compares every file prelude writes, its messages and its exit status too).identical: 0 of 147,456 values differ
replica − fMRIPrep's outputBit-identicalfMRIPrep’s own unwrapped phase (prelude in fMRIPrep 25.2.6’s image, FSL’s earlier build) holds the same values.identical: 0 of 147,456 values differ
The replica against itself: fix and reproduce
replica, fix − reproduceBit-identicalNo correction of the register applies to this call: fix and reproduce give the same values.identical: 0 of 147,456 values differ
The clean room against the original, fMRIPrep's output and the replica
clean room − FSL prelude 6.0.7.23Bit-identicalThe same values, every one, in the unwrapped phase (the record compares every file prelude writes, its header, its messages and its exit status too).identical: 0 of 147,456 values differ
clean room − fMRIPrep's outputBit-identicalfMRIPrep’s own unwrapped phase (prelude in fMRIPrep 25.2.6’s image, FSL’s earlier build) holds the same values.identical: 0 of 147,456 values differ
clean room − replica, reproduceBit-identicalThe two ports give the same values in reproduce: both FSL’s.identical: 0 of 147,456 values differ
clean room − replica, fixBit-identicalThe two ports give the same values in fix, their default (the record holds every case’s default against the replica’s).identical: 0 of 147,456 values differ
The clean room against itself: thread counts, fix and reproduce
clean room, 1 thread − 14 threadsBit-identicalThe thread count changes nothing: the linear parts run on the call’s threads in fixed chunks, the merging in its one order, so the one-thread result is the 14-thread result bit for bit.identical: 0 of 147,456 values differ
clean room, fix − reproduceBit-identicalNo correction of the register applies to this call: fix and reproduce give the same values.identical: 0 of 147,456 values differ

Δ is A − B in radians, computed in float64 over all 147,456 voxels of the outputs, not only those shown. The replica’s record’s threshold: every file prelude writes bit-identical (images decompressed, descrip left out), with FSL’s exit status and messages. The clean room’s record (fsl-prelude) holds it to specs/prelude.md §11’s thresholds: in reproduce the same, each header whole with its extension bytes but descrip; in fix the replica’s fix, the same, but where GLIBC-07 is named, where the unwrapped phase keeps the replica’s whole cycles on at least 99.9 % of the mask’s voxels.

Provenance of this example
  • Data: OpenNeuro ds002422, sub-02, CC0-1.0
  • Inputs: clipped.nii.gz (sha256 4721c8cb03fd0ff7…); clipped_mask.nii.gz (sha256 e5f1290737178ef7…); sub-02_run-02_phasediff_rads.nii (sha256 ac501eebf304c366…)
  • Runs: figures cache entry fsl-prelude/fmriprep-ds002422-sub-02-noreconall-wf_auto_00001, computed 2026-11-06T19:26:22+00:00 with larmorx 069338d2d02d; FSL 6.0.7.23 (fsl-fugue 2603.0; ~/fsl-6.0.7.23, never on the PATH); larmorx-nc 0.0.1; every command, its environment, threads and exit status are in its RUN_INFO.json
  • Runs of the clean room: figures cache entry fsl-prelude/fmriprep-ds002422-sub-02-noreconall-wf_auto_00001-original, computed 2026-11-07T02:01:52+00:00 with larmorx c292c141c0bb (python -m larmorx with LARMORX_IMPLEMENTATION=original, reproduce at 14 threads and at one, fix, the default at 14), on the replica’s entry’s inputs; every command, its environment, threads and exit status are in its RUN_INFO.json

Every number above is in fsl-prelude.json, exported by python -m larmorx_validation evidence fsl-prelude.

ds001600: three field-map protocols

ds001600 holds several field-map protocols of one subject. Two of them store two phase images, which sdcflows subtracts before prelude (acq-v1, acq-v2); one stores a phase difference (acq-v4).

Worked example

fMRIPrep's call on ds001600-sub-1: two phase images

What this shows: On fMRIPrep’s own call, unwrapping moves 128 of the mask’s 25,928 voxels by whole cycles of 2π, from −1 to 1. Both ports give FSL’s unwrapped phase, every value, and the same values as fMRIPrep’s own output; the clean room the same at 1 and 14 threads. No correction by default changes this call, in either port.

The prelude node fMRIPrep 25.2.6 ran on ds001600-sub-1 (two phase images (acq-v1, phase1 and phase2): sdcflows subtracts them; sdcflows’ wf_auto_00000 estimator), given to FSL 6.0.7.23 and to the replica (larmorx-nc) in reproduce and in fix, and to LARMORX’s clean room (Apache-2.0) in reproduce at 14 threads and at one and in fix, its default, with fMRIPrep’s own output beside them. The input panels are what prelude is given: the phase difference wrapped into 0 to 2π, the magnitude, and the brain mask (drawn over the magnitude). Unwrapping adds whole cycles of 2π, region by region, so the phase varies smoothly inside the mask; sdcflows then turns it into the field in Hz.

Data
OpenNeuro ds001600, sub-1 (CC-BY-SA): the field map’s phase difference and magnitude as sdcflows prepared them; shown inside sdcflows’ brain mask (prelude’s --mask), dilated by 2 voxels (1,458 ml in the mask), so no face shows
Node
fMRIPrep 25.2.6, work/fmriprep_25_2_wf/sub_1_wf/fmap_preproc_wf/wf_auto_00000/phdiff_wf/prelude
Command
prelude --abs=<sdcflows' clipped magnitude> --mask=<sdcflows' brain mask> --phase=<the phase difference in rad> --unwrap=sub-1_acq-v1_phase1_rads_phdiff_unwrapped.nii.gz
Cycles added
128 of the 25,928 voxels in the mask moved by whole cycles of 2π, from -1 to 1 (FSL’s output against the wrapped phase rewrapped to [−π, π]; every one a whole number of cycles to 3.5e-07 rad)
Programs
FSL 6.0.7.23 (fsl-fugue 2603.0; ~/fsl-6.0.7.23, never on the PATH) (its runs served from the cache of the original’s runs, as the record ran them); larmorx-nc 0.0.1 (the replica), from LARMORX at commit 069338d2d02d; LARMORX’s clean room (crate larmorx-fsl, Apache-2.0), from LARMORX at commit c292c141c0bb
Grid
64 × 64 × 44 voxels of 3.75 × 3.75 × 4 mm; shown: 45 × 52 × 40 around the brain

Data shown

  • Example fieldmaps (OpenNeuro ds001600, version 1.0.0), Creative Commons Attribution-ShareAlike (CC BY-SA; the dataset gives no version). Attribution: Cieslak M., Elliott M., Satterthwaite T. Example Fieldmaps. OpenNeuro ds001600, version 1.0.0 (Siemens Prisma, University of Pennsylvania). The images shown are adapted from it: reoriented to RAS, cropped to the region shown, masked outside it, and shown as the outputs of the programs compared. Share-alike: the images adapted from this dataset are shared under the same licence, CC BY-SA.
Inputds001600-sub-1: phase difference (rad)prelude's --phase in fMRIPrep: sdcflows' difference of the two phase images, each rescaled to radians, 0 to 2π (float32), wrapped
Inputds001600-sub-1: magnitudeprelude's --abs: sdcflows' clipped magnitude (int16, 0 to 255)
OriginalFSL prelude 6.0.7.23the conda installation, as built (the record's run, from the cache of the original's runs)
Replicareplicalarmorx-nc, FSL Licence · reproduce · against FSL prelude 6.0.7.23
Clean roomclean roomlarmorx, Apache-2.0 · reproduce, 14 threads · against FSL prelude 6.0.7.23

Bit-identical180,224 of 180,224 voxels equal

the replica against the originalreplica − FSL prelude 6.0.7.23

Bit-identical180,224 of 180,224 voxels equal

the replica against fMRIPrep's outputreplica − fMRIPrep's output

Bit-identical180,224 of 180,224 voxels equal

the clean room against the originalclean room − FSL prelude 6.0.7.23

Axial slice 19 of 40; the crosshair where FSL's unwrapped phase departs most from the wrapped phase it was given in this slice (the most cycles added); the replica's output equals FSL's everywhere; the clean room's reproduce equals FSL's everywhere too, at 14 threads and at one. The interactive viewer needs JavaScript; the metrics below are complete without it.

Every comparison, computed in float64 over every voxel of the outputs

Comparison (A − B), verdict and reasonmax |Δ|Values that differRMS of Δmax |Δ| ÷ range1 − NCC
The replica against the original and fMRIPrep's output
replica − FSL prelude 6.0.7.23Bit-identicalThe same values, every one, in the unwrapped phase (the record compares every file prelude writes, its messages and its exit status too).identical: 0 of 180,224 values differ
replica − fMRIPrep's outputBit-identicalfMRIPrep’s own unwrapped phase (prelude in fMRIPrep 25.2.6’s image, FSL’s earlier build) holds the same values.identical: 0 of 180,224 values differ
The replica against itself: fix and reproduce
replica, fix − reproduceBit-identicalNo correction of the register applies to this call: fix and reproduce give the same values.identical: 0 of 180,224 values differ
The clean room against the original, fMRIPrep's output and the replica
clean room − FSL prelude 6.0.7.23Bit-identicalThe same values, every one, in the unwrapped phase (the record compares every file prelude writes, its header, its messages and its exit status too).identical: 0 of 180,224 values differ
clean room − fMRIPrep's outputBit-identicalfMRIPrep’s own unwrapped phase (prelude in fMRIPrep 25.2.6’s image, FSL’s earlier build) holds the same values.identical: 0 of 180,224 values differ
clean room − replica, reproduceBit-identicalThe two ports give the same values in reproduce: both FSL’s.identical: 0 of 180,224 values differ
clean room − replica, fixBit-identicalThe two ports give the same values in fix, their default (the record holds every case’s default against the replica’s).identical: 0 of 180,224 values differ
The clean room against itself: thread counts, fix and reproduce
clean room, 1 thread − 14 threadsBit-identicalThe thread count changes nothing: the linear parts run on the call’s threads in fixed chunks, the merging in its one order, so the one-thread result is the 14-thread result bit for bit.identical: 0 of 180,224 values differ
clean room, fix − reproduceBit-identicalNo correction of the register applies to this call: fix and reproduce give the same values.identical: 0 of 180,224 values differ

Δ is A − B in radians, computed in float64 over all 180,224 voxels of the outputs, not only those shown. The replica’s record’s threshold: every file prelude writes bit-identical (images decompressed, descrip left out), with FSL’s exit status and messages. The clean room’s record (fsl-prelude) holds it to specs/prelude.md §11’s thresholds: in reproduce the same, each header whole with its extension bytes but descrip; in fix the replica’s fix, the same, but where GLIBC-07 is named, where the unwrapped phase keeps the replica’s whole cycles on at least 99.9 % of the mask’s voxels.

Provenance of this example
  • Data: OpenNeuro ds001600, sub-1, CC-BY-SA
  • Inputs: clipped.nii.gz (sha256 bdfb730ff32d3123…); clipped_mask.nii.gz (sha256 d843d0193015ecbf…); sub-1_acq-v1_phase1_rads_phdiff.nii.gz (sha256 dc58395231e6e190…)
  • Runs: figures cache entry fsl-prelude/fmriprep-ds001600-sub-1-noreconall-wf_auto_00000, computed 2026-11-06T19:26:22+00:00 with larmorx 069338d2d02d; FSL 6.0.7.23 (fsl-fugue 2603.0; ~/fsl-6.0.7.23, never on the PATH); larmorx-nc 0.0.1; every command, its environment, threads and exit status are in its RUN_INFO.json
  • Runs of the clean room: figures cache entry fsl-prelude/fmriprep-ds001600-sub-1-noreconall-wf_auto_00000-original, computed 2026-11-07T02:01:52+00:00 with larmorx c292c141c0bb (python -m larmorx with LARMORX_IMPLEMENTATION=original, reproduce at 14 threads and at one, fix, the default at 14), on the replica’s entry’s inputs; every command, its environment, threads and exit status are in its RUN_INFO.json

Every number above is in fsl-prelude.json, exported by python -m larmorx_validation evidence fsl-prelude.

Worked example

fMRIPrep's call on ds001600-sub-1: two phase images of a second protocol

What this shows: On fMRIPrep’s own call, unwrapping moves 116 of the mask’s 25,925 voxels by whole cycles of 2π, from −1 to 1. Both ports give FSL’s unwrapped phase, every value, and the same values as fMRIPrep’s own output; the clean room the same at 1 and 14 threads. No correction by default changes this call, in either port.

The prelude node fMRIPrep 25.2.6 ran on ds001600-sub-1 (two phase images of a second protocol (acq-v2); sdcflows’ wf_auto_00001 estimator), given to FSL 6.0.7.23 and to the replica (larmorx-nc) in reproduce and in fix, and to LARMORX’s clean room (Apache-2.0) in reproduce at 14 threads and at one and in fix, its default, with fMRIPrep’s own output beside them. The input panels are what prelude is given: the phase difference wrapped into 0 to 2π, the magnitude, and the brain mask (drawn over the magnitude). Unwrapping adds whole cycles of 2π, region by region, so the phase varies smoothly inside the mask; sdcflows then turns it into the field in Hz.

Data
OpenNeuro ds001600, sub-1 (CC-BY-SA): the field map’s phase difference and magnitude as sdcflows prepared them; shown inside sdcflows’ brain mask (prelude’s --mask), dilated by 2 voxels (1,458 ml in the mask), so no face shows
Node
fMRIPrep 25.2.6, work/fmriprep_25_2_wf/sub_1_wf/fmap_preproc_wf/wf_auto_00001/phdiff_wf/prelude
Command
prelude --abs=<sdcflows' clipped magnitude> --mask=<sdcflows' brain mask> --phase=<the phase difference in rad> --unwrap=sub-1_acq-v2_phase1_rads_phdiff_unwrapped.nii.gz
Cycles added
116 of the 25,925 voxels in the mask moved by whole cycles of 2π, from -1 to 1 (FSL’s output against the wrapped phase rewrapped to [−π, π]; every one a whole number of cycles to 2.4e-07 rad)
Programs
FSL 6.0.7.23 (fsl-fugue 2603.0; ~/fsl-6.0.7.23, never on the PATH) (its runs served from the cache of the original’s runs, as the record ran them); larmorx-nc 0.0.1 (the replica), from LARMORX at commit 069338d2d02d; LARMORX’s clean room (crate larmorx-fsl, Apache-2.0), from LARMORX at commit c292c141c0bb
Grid
64 × 64 × 44 voxels of 3.75 × 3.75 × 4 mm; shown: 44 × 52 × 40 around the brain

Data shown

  • Example fieldmaps (OpenNeuro ds001600, version 1.0.0), Creative Commons Attribution-ShareAlike (CC BY-SA; the dataset gives no version). Attribution: Cieslak M., Elliott M., Satterthwaite T. Example Fieldmaps. OpenNeuro ds001600, version 1.0.0 (Siemens Prisma, University of Pennsylvania). The images shown are adapted from it: reoriented to RAS, cropped to the region shown, masked outside it, and shown as the outputs of the programs compared. Share-alike: the images adapted from this dataset are shared under the same licence, CC BY-SA.
Inputds001600-sub-1: phase difference (rad)prelude's --phase in fMRIPrep: sdcflows' difference of the two phase images, each rescaled to radians, 0 to 2π (float32), wrapped
Inputds001600-sub-1: magnitudeprelude's --abs: sdcflows' clipped magnitude (int16, 0 to 255)
OriginalFSL prelude 6.0.7.23the conda installation, as built (the record's run, from the cache of the original's runs)
Replicareplicalarmorx-nc, FSL Licence · reproduce · against FSL prelude 6.0.7.23
Clean roomclean roomlarmorx, Apache-2.0 · reproduce, 14 threads · against FSL prelude 6.0.7.23

Bit-identical180,224 of 180,224 voxels equal

the replica against the originalreplica − FSL prelude 6.0.7.23

Bit-identical180,224 of 180,224 voxels equal

the replica against fMRIPrep's outputreplica − fMRIPrep's output

Bit-identical180,224 of 180,224 voxels equal

the clean room against the originalclean room − FSL prelude 6.0.7.23

Axial slice 20 of 40; the crosshair where FSL's unwrapped phase departs most from the wrapped phase it was given in this slice (the most cycles added); the replica's output equals FSL's everywhere; the clean room's reproduce equals FSL's everywhere too, at 14 threads and at one. The interactive viewer needs JavaScript; the metrics below are complete without it.

Every comparison, computed in float64 over every voxel of the outputs

Comparison (A − B), verdict and reasonmax |Δ|Values that differRMS of Δmax |Δ| ÷ range1 − NCC
The replica against the original and fMRIPrep's output
replica − FSL prelude 6.0.7.23Bit-identicalThe same values, every one, in the unwrapped phase (the record compares every file prelude writes, its messages and its exit status too).identical: 0 of 180,224 values differ
replica − fMRIPrep's outputBit-identicalfMRIPrep’s own unwrapped phase (prelude in fMRIPrep 25.2.6’s image, FSL’s earlier build) holds the same values.identical: 0 of 180,224 values differ
The replica against itself: fix and reproduce
replica, fix − reproduceBit-identicalNo correction of the register applies to this call: fix and reproduce give the same values.identical: 0 of 180,224 values differ
The clean room against the original, fMRIPrep's output and the replica
clean room − FSL prelude 6.0.7.23Bit-identicalThe same values, every one, in the unwrapped phase (the record compares every file prelude writes, its header, its messages and its exit status too).identical: 0 of 180,224 values differ
clean room − fMRIPrep's outputBit-identicalfMRIPrep’s own unwrapped phase (prelude in fMRIPrep 25.2.6’s image, FSL’s earlier build) holds the same values.identical: 0 of 180,224 values differ
clean room − replica, reproduceBit-identicalThe two ports give the same values in reproduce: both FSL’s.identical: 0 of 180,224 values differ
clean room − replica, fixBit-identicalThe two ports give the same values in fix, their default (the record holds every case’s default against the replica’s).identical: 0 of 180,224 values differ
The clean room against itself: thread counts, fix and reproduce
clean room, 1 thread − 14 threadsBit-identicalThe thread count changes nothing: the linear parts run on the call’s threads in fixed chunks, the merging in its one order, so the one-thread result is the 14-thread result bit for bit.identical: 0 of 180,224 values differ
clean room, fix − reproduceBit-identicalNo correction of the register applies to this call: fix and reproduce give the same values.identical: 0 of 180,224 values differ

Δ is A − B in radians, computed in float64 over all 180,224 voxels of the outputs, not only those shown. The replica’s record’s threshold: every file prelude writes bit-identical (images decompressed, descrip left out), with FSL’s exit status and messages. The clean room’s record (fsl-prelude) holds it to specs/prelude.md §11’s thresholds: in reproduce the same, each header whole with its extension bytes but descrip; in fix the replica’s fix, the same, but where GLIBC-07 is named, where the unwrapped phase keeps the replica’s whole cycles on at least 99.9 % of the mask’s voxels.

Provenance of this example
  • Data: OpenNeuro ds001600, sub-1, CC-BY-SA
  • Inputs: clipped.nii.gz (sha256 480f4e06845b21ba…); clipped_mask.nii.gz (sha256 1cbf7fc4b622bfcb…); sub-1_acq-v2_phase1_rads_phdiff.nii.gz (sha256 de40bebac24068c7…)
  • Runs: figures cache entry fsl-prelude/fmriprep-ds001600-sub-1-noreconall-wf_auto_00001, computed 2026-11-06T19:26:22+00:00 with larmorx 069338d2d02d; FSL 6.0.7.23 (fsl-fugue 2603.0; ~/fsl-6.0.7.23, never on the PATH); larmorx-nc 0.0.1; every command, its environment, threads and exit status are in its RUN_INFO.json
  • Runs of the clean room: figures cache entry fsl-prelude/fmriprep-ds001600-sub-1-noreconall-wf_auto_00001-original, computed 2026-11-07T02:01:52+00:00 with larmorx c292c141c0bb (python -m larmorx with LARMORX_IMPLEMENTATION=original, reproduce at 14 threads and at one, fix, the default at 14), on the replica’s entry’s inputs; every command, its environment, threads and exit status are in its RUN_INFO.json

Every number above is in fsl-prelude.json, exported by python -m larmorx_validation evidence fsl-prelude.

Worked example

fMRIPrep's call on ds001600-sub-1: a phase difference

What this shows: On fMRIPrep’s own call, unwrapping moves 12,447 of the mask’s 25,989 voxels by whole cycles of 2π, from 0 to 1. Both ports give FSL’s unwrapped phase, every value, and the same values as fMRIPrep’s own output; the clean room the same at 1 and 14 threads. No correction by default changes this call, in either port.

The prelude node fMRIPrep 25.2.6 ran on ds001600-sub-1 (a phase difference (acq-v4); sdcflows’ wf_auto_00002 estimator), given to FSL 6.0.7.23 and to the replica (larmorx-nc) in reproduce and in fix, and to LARMORX’s clean room (Apache-2.0) in reproduce at 14 threads and at one and in fix, its default, with fMRIPrep’s own output beside them. The input panels are what prelude is given: the phase difference wrapped into 0 to 2π, the magnitude, and the brain mask (drawn over the magnitude). Unwrapping adds whole cycles of 2π, region by region, so the phase varies smoothly inside the mask; sdcflows then turns it into the field in Hz.

Data
OpenNeuro ds001600, sub-1 (CC-BY-SA): the field map’s phase difference and magnitude as sdcflows prepared them; shown inside sdcflows’ brain mask (prelude’s --mask), dilated by 2 voxels (1,462 ml in the mask), so no face shows
Node
fMRIPrep 25.2.6, work/fmriprep_25_2_wf/sub_1_wf/fmap_preproc_wf/wf_auto_00002/phdiff_wf/prelude
Command
prelude --abs=<sdcflows' clipped magnitude> --mask=<sdcflows' brain mask> --phase=<the phase difference in rad> --unwrap=sub-1_acq-v4_phasediff_rads_unwrapped.nii.gz
Cycles added
12,447 of the 25,989 voxels in the mask moved by whole cycles of 2π, from 0 to 1 (FSL’s output against the wrapped phase rewrapped to [−π, π]; every one a whole number of cycles to 2.9e-07 rad)
Programs
FSL 6.0.7.23 (fsl-fugue 2603.0; ~/fsl-6.0.7.23, never on the PATH) (its runs served from the cache of the original’s runs, as the record ran them); larmorx-nc 0.0.1 (the replica), from LARMORX at commit 069338d2d02d; LARMORX’s clean room (crate larmorx-fsl, Apache-2.0), from LARMORX at commit c292c141c0bb
Grid
64 × 64 × 44 voxels of 3.75 × 3.75 × 4 mm; shown: 45 × 52 × 39 around the brain

Data shown

  • Example fieldmaps (OpenNeuro ds001600, version 1.0.0), Creative Commons Attribution-ShareAlike (CC BY-SA; the dataset gives no version). Attribution: Cieslak M., Elliott M., Satterthwaite T. Example Fieldmaps. OpenNeuro ds001600, version 1.0.0 (Siemens Prisma, University of Pennsylvania). The images shown are adapted from it: reoriented to RAS, cropped to the region shown, masked outside it, and shown as the outputs of the programs compared. Share-alike: the images adapted from this dataset are shared under the same licence, CC BY-SA.
Inputds001600-sub-1: phase difference (rad)prelude's --phase in fMRIPrep: sdcflows' au2rads of the scanner's phase difference, 0 to 2π (float32), wrapped
Inputds001600-sub-1: magnitudeprelude's --abs: sdcflows' clipped magnitude (int16, 0 to 255)
OriginalFSL prelude 6.0.7.23the conda installation, as built (the record's run, from the cache of the original's runs)
Replicareplicalarmorx-nc, FSL Licence · reproduce · against FSL prelude 6.0.7.23
Clean roomclean roomlarmorx, Apache-2.0 · reproduce, 14 threads · against FSL prelude 6.0.7.23

Bit-identical180,224 of 180,224 voxels equal

the replica against the originalreplica − FSL prelude 6.0.7.23

Bit-identical180,224 of 180,224 voxels equal

the replica against fMRIPrep's outputreplica − fMRIPrep's output

Bit-identical180,224 of 180,224 voxels equal

the clean room against the originalclean room − FSL prelude 6.0.7.23

Axial slice 19 of 39; the crosshair where FSL's unwrapped phase departs most from the wrapped phase it was given in this slice (the most cycles added); the replica's output equals FSL's everywhere; the clean room's reproduce equals FSL's everywhere too, at 14 threads and at one. The interactive viewer needs JavaScript; the metrics below are complete without it.

Every comparison, computed in float64 over every voxel of the outputs

Comparison (A − B), verdict and reasonmax |Δ|Values that differRMS of Δmax |Δ| ÷ range1 − NCC
The replica against the original and fMRIPrep's output
replica − FSL prelude 6.0.7.23Bit-identicalThe same values, every one, in the unwrapped phase (the record compares every file prelude writes, its messages and its exit status too).identical: 0 of 180,224 values differ
replica − fMRIPrep's outputBit-identicalfMRIPrep’s own unwrapped phase (prelude in fMRIPrep 25.2.6’s image, FSL’s earlier build) holds the same values.identical: 0 of 180,224 values differ
The replica against itself: fix and reproduce
replica, fix − reproduceBit-identicalNo correction of the register applies to this call: fix and reproduce give the same values.identical: 0 of 180,224 values differ
The clean room against the original, fMRIPrep's output and the replica
clean room − FSL prelude 6.0.7.23Bit-identicalThe same values, every one, in the unwrapped phase (the record compares every file prelude writes, its header, its messages and its exit status too).identical: 0 of 180,224 values differ
clean room − fMRIPrep's outputBit-identicalfMRIPrep’s own unwrapped phase (prelude in fMRIPrep 25.2.6’s image, FSL’s earlier build) holds the same values.identical: 0 of 180,224 values differ
clean room − replica, reproduceBit-identicalThe two ports give the same values in reproduce: both FSL’s.identical: 0 of 180,224 values differ
clean room − replica, fixBit-identicalThe two ports give the same values in fix, their default (the record holds every case’s default against the replica’s).identical: 0 of 180,224 values differ
The clean room against itself: thread counts, fix and reproduce
clean room, 1 thread − 14 threadsBit-identicalThe thread count changes nothing: the linear parts run on the call’s threads in fixed chunks, the merging in its one order, so the one-thread result is the 14-thread result bit for bit.identical: 0 of 180,224 values differ
clean room, fix − reproduceBit-identicalNo correction of the register applies to this call: fix and reproduce give the same values.identical: 0 of 180,224 values differ

Δ is A − B in radians, computed in float64 over all 180,224 voxels of the outputs, not only those shown. The replica’s record’s threshold: every file prelude writes bit-identical (images decompressed, descrip left out), with FSL’s exit status and messages. The clean room’s record (fsl-prelude) holds it to specs/prelude.md §11’s thresholds: in reproduce the same, each header whole with its extension bytes but descrip; in fix the replica’s fix, the same, but where GLIBC-07 is named, where the unwrapped phase keeps the replica’s whole cycles on at least 99.9 % of the mask’s voxels.

Provenance of this example
  • Data: OpenNeuro ds001600, sub-1, CC-BY-SA
  • Inputs: clipped.nii.gz (sha256 402f4b38c50cc15f…); clipped_mask.nii.gz (sha256 5c7162fc0c069fc0…); sub-1_acq-v4_phasediff_rads.nii.gz (sha256 8694b975103986f4…)
  • Runs: figures cache entry fsl-prelude/fmriprep-ds001600-sub-1-noreconall-wf_auto_00002, computed 2026-11-06T19:26:22+00:00 with larmorx 069338d2d02d; FSL 6.0.7.23 (fsl-fugue 2603.0; ~/fsl-6.0.7.23, never on the PATH); larmorx-nc 0.0.1; every command, its environment, threads and exit status are in its RUN_INFO.json
  • Runs of the clean room: figures cache entry fsl-prelude/fmriprep-ds001600-sub-1-noreconall-wf_auto_00002-original, computed 2026-11-07T02:01:52+00:00 with larmorx c292c141c0bb (python -m larmorx with LARMORX_IMPLEMENTATION=original, reproduce at 14 threads and at one, fix, the default at 14), on the replica’s entry’s inputs; every command, its environment, threads and exit status are in its RUN_INFO.json

Every number above is in fsl-prelude.json, exported by python -m larmorx_validation evidence fsl-prelude.

A NaN first value, and a correction by default

FSL takes the phase’s maximum and minimum from its first value on. So a phase map whose first value is NaN (the first voxel of a masked or divided map) gets a NaN maximum and minimum, and both the range check and the rewrap to [−π, π] are skipped (FSL-272). A phase from 0 to 2π is then unwrapped in other intervals, and some regions come out whole cycles wrong relative to the rest.

It was measured before deciding (rule D): fMRIPrep’s seven maps and a synthetic one, each moved to [0, 2π) with its first value NaN. Seven of the eight came out whole cycles wrong in some regions.

  • The replica’s default, fix, takes the extrema over the values that are numbers. That gives what FSL gives for the same map without the NaN. Its reproduce gives FSL’s bytes.
  • The clean room does the same: its reproduce gives FSL’s bytes with the NaN, and its fix FSL’s result without it (clean room, fix − FSL prelude 6.0.7.23 without the NaN, zero everywhere).

Below, ds002603’s map so changed. Compare FSL prelude with the NaN − FSL without it (the defect) with replica, fix − FSL prelude 6.0.7.23 without the NaN (the correction).

Worked example

A NaN first value, and a correction by default (FSL-272)

What this shows: With its first value NaN, FSL unwraps this map whole cycles wrong in some regions (FSL-272): against its own result without the NaN, most of the mask’s 265,356 voxels move by one whole cycle, a constant offset of the map, and 6,612 (2.5 %) by another number. In reproduce both ports give FSL’s bytes. In fix, their default, both take the phase’s extrema over the values that are numbers and give FSL’s own result for the map without the NaN, bit for bit; the clean room the same at 1 and 14 threads.

fMRIPrep’s call on ds002603’s phase map, the phase moved to [0, 2π) as a scanner’s phase difference in radians comes and its first two values in FSL’s order (background corners) set to NaN, as a masked or divided phase map can hold. FSL takes the phase’s maximum and minimum from its first value on, so both are NaN: the phase is not rewrapped to [−π, π] and is unwrapped in other intervals. The replica’s reproduce gives FSL’s bytes; its default takes the extrema over the values that are numbers and gives what FSL gives for the same map without the NaN. The difference FSL with the NaN − FSL without it shows the defect: whole cycles, and other numbers of them in some regions. The panels open in each image’s own window (FSL’s output with the NaN lies about 2π above the others); choose the brain window to see them on one scale. fMRIPrep’s own calls are not affected: sdcflows rescales the phase from its minimum and maximum, so a NaN anywhere would make every value NaN. Beside them LARMORX’s clean room (Apache-2.0), in reproduce at 14 threads and at one and in fix, its default.

Data
OpenNeuro ds002603, sub-01 (CC0-1.0): fMRIPrep’s phase difference of the field map, changed as described; shown inside sdcflows’ brain mask, dilated by 2 voxels, so no face shows
Command
prelude --abs=<sdcflows' clipped magnitude> --mask=<sdcflows' brain mask> --phase=<the phase difference in rad> --unwrap=uw --savemask=mk
Programs
FSL 6.0.7.23 (fsl-fugue 2603.0; ~/fsl-6.0.7.23, never on the PATH) (its runs served from the cache of the original’s runs, as FSL-272’s measurement ran them); larmorx-nc 0.0.1 (the replica), from LARMORX at commit 069338d2d02d; LARMORX’s clean room (crate larmorx-fsl, Apache-2.0), from LARMORX at commit c292c141c0bb
Grid
128 × 128 × 128 voxels of 2 × 2 × 2 mm; shown: 82 × 100 × 84 around the brain
Inputds002603-sub-01: phase difference, first values NaNfMRIPrep's --phase moved to [0, 2π) (float32), its two first values in FSL's order (background corners, outside the view) NaN
OriginalFSL prelude 6.0.7.23the NaN map · as built, through the cache of the original's runs: neither rewrapped nor range-checked
OriginalFSL prelude 6.0.7.23the same map without the NaN · what FSL gives when the first value is a number
Replicareplicalarmorx-nc, FSL Licence · fix (the default, FSL-272 corrected) · against FSL prelude 6.0.7.23
Clean roomclean roomlarmorx, Apache-2.0 · fix (the default), 14 threads · against FSL prelude 6.0.7.23
the original against itself: with and without the NaNFSL prelude with the NaN − FSL without itscale ±18.8

Bit-identical2,097,152 of 2,097,152 voxels equal

the replica against the original: fix, and FSL without the NaNreplica, fix − FSL prelude 6.0.7.23 without the NaN

Bit-identical2,097,152 of 2,097,152 voxels equal

the clean room against the original: fix, and FSL without the NaNclean room, fix − FSL prelude 6.0.7.23 without the NaN

Axial slice 19 of 84; the slice holding most of the voxels FSL unwraps by another number of cycles than the rest (with the NaN), the crosshair on one of them; the clean room's reproduce equals FSL's everywhere too, at 14 threads and at one. The interactive viewer needs JavaScript; the metrics below are complete without it.

Every comparison, computed in float64 over every voxel of the outputs

Comparison (A − B), verdict and reasonmax |Δ|Values that differRMS of Δmax |Δ| ÷ range1 − NCC
The original against itself: the yardstick
FSL prelude with the NaN − FSL without itreferenceThe defect’s effect, FSL against itself (no verdict): with the NaN first value FSL keeps the phase in 0 to 2π and unwraps it in other intervals than the rewrapped phase. Of the 265,356 mask voxels, its result differs from its own result without the NaN by whole cycles of 2π: -1 in 95, +0 in 2,016, +1 in 258,744, +2 in 4,477 and +3 in 24. Most move by +1 cycle(s), one constant offset of the map; 6,612 voxels (2.5 %) by another number, regions unwrapped whole cycles wrong relative to their neighbours. FSL-27218.8263,763 of 2,097,152 (12.6 %)2.280.7931.76
The replica against the original
replica (reproduce) − FSL prelude 6.0.7.23Bit-identicalThe same values, every one, in the unwrapped phase (the record compares every file prelude writes, its messages and its exit status too).identical: 0 of 2,097,152 values differ
replica, fix − FSL prelude 6.0.7.23 without the NaNBit-identicalThe default gives FSL’s own result for the same map without the NaN, bit for bit: it takes the extrema over the values that are numbers, so it rewraps the phase as FSL does when the first value is one. FSL-272identical: 0 of 2,097,152 values differ
The replica against itself: fix and reproduce
replica, fix − reproduceDeliberate correctionFSL-272, corrected by default with a notice: FSL takes the phase’s maximum and minimum from its first value on, so a NaN first value makes both NaN: the phase from 0 to 2π is not rewrapped to [−π, π] (nor would a range above 3π be refused), and it is unwrapped in other intervals, whole cycles wrong in some regions; the default takes the extrema over the values that are numbers. reproduce gives FSL’s bytes. FSL-27218.8263,763 of 2,097,152 (12.6 %)2.281.071.76
The clean room against the original and the replica
clean room − FSL prelude 6.0.7.23Bit-identicalThe same values, every one, in the unwrapped phase (the record compares every file prelude writes, its header, its messages and its exit status too).identical: 0 of 2,097,152 values differ
clean room, fix − FSL prelude 6.0.7.23 without the NaNBit-identicalThe clean room’s default gives FSL’s own result for the same map without the NaN, bit for bit: it takes the extrema over the values that are numbers, so it rewraps the phase as FSL does when the first value is one. FSL-272identical: 0 of 2,097,152 values differ
clean room − replica, reproduceBit-identicalThe two ports give the same values in reproduce: both FSL’s.identical: 0 of 2,097,152 values differ
clean room − replica, fixBit-identicalThe two ports give the same values in fix, their default (the record holds every case’s default against the replica’s).identical: 0 of 2,097,152 values differ
The clean room against itself: thread counts, fix and reproduce
clean room, 1 thread − 14 threadsBit-identicalThe thread count changes nothing: the linear parts run on the call’s threads in fixed chunks, the merging in its one order, so the one-thread result is the 14-thread result bit for bit.identical: 0 of 2,097,152 values differ
clean room, fix − reproduceDeliberate correctionFSL-272, corrected by default with a notice, as the replica’s default corrects it (the clean room’s default gives the replica’s default bit for bit, and reproduce FSL’s bytes; replica, fix − reproduce above says what the correction changes): 263,763 values differ between the modes, by at most 19 rad. FSL-27218.8263,763 of 2,097,152 (12.6 %)2.281.071.76

Δ is A − B in radians, computed in float64 over all 2,097,152 voxels of the outputs, not only those shown. The replica’s record’s threshold: every file prelude writes bit-identical (images decompressed, descrip left out), with FSL’s exit status and messages. The clean room’s record (fsl-prelude) holds it to specs/prelude.md §11’s thresholds: in reproduce the same, each header whole with its extension bytes but descrip; in fix the replica’s fix, the same, but where GLIBC-07 is named, where the unwrapped phase keeps the replica’s whole cycles on at least 99.9 % of the mask’s voxels.

Provenance of this example
  • Data: OpenNeuro ds002603, sub-01, CC0-1.0
  • Inputs: clipped.nii.gz (sha256 f57cf6848227f2f2…); clipped_mask.nii.gz (sha256 e45979f6a46d1728…); sub-01_acq-Mm2_phasediff_rads.nii.gz (sha256 c614b26a87bb4579…)
  • Runs: figures cache entry fsl-prelude/fsl272-ds002603, computed 2026-11-06T19:26:23+00:00 with larmorx 069338d2d02d; FSL 6.0.7.23 (fsl-fugue 2603.0; ~/fsl-6.0.7.23, never on the PATH); larmorx-nc 0.0.1; every command, its environment, threads and exit status are in its RUN_INFO.json
  • Recipe: validation/investigations/prelude-spec/fsl272_measure.py (FSL-272’s measurement)
  • Runs of the clean room: figures cache entry fsl-prelude/fsl272-ds002603-original, computed 2026-11-07T02:01:53+00:00 with larmorx c292c141c0bb (python -m larmorx with LARMORX_IMPLEMENTATION=original, reproduce at 14 threads and at one, fix, the default at 14), on the replica’s entry’s inputs; every command, its environment, threads and exit status are in its RUN_INFO.json

Every number above is in fsl-prelude.json, exported by python -m larmorx_validation evidence fsl-prelude.

The ramps’ last slice, and a correction by default

With --removeramps, FSL’s loops stop one column, row and slice short. So the last slice is unwrapped with its ramp while the rest is unwrapped without it, and an image of one slice gets no ramp removed at all (FSL-261). The replica’s fix takes every column, row and slice.

fMRIPrep does not ask for the ramps’ removal. Below, its call on ds002422’s second map, whose brain mask reaches the last slice, with --removeramps added. On this map the correction changes only the last bits; the metrics table says where it matters more. The clean room’s fix gives the replica’s fix bit for bit, and its reproduce FSL’s bytes.

Worked example

--removeramps, and a correction by default (FSL-261)

What this shows: With --removeramps added to fMRIPrep’s call, both ports give FSL’s bytes in reproduce. In fix, their default, both remove the ramps over every column, row and slice (FSL-261): on this map that moves 5 of the brain mask’s 105 voxels in the last slice and 880 in the other slices, by at most 4.8 × 10⁻⁷ rad, with the same whole cycles everywhere. The clean room’s fix is the replica’s, bit for bit, and the same at 1 and 14 threads.

fMRIPrep’s call on ds002422’s second phase difference with --removeramps added: prelude estimates the phase’s linear ramp along each axis, removes it before unwrapping and restores it after. FSL’s loops stop one column, row and slice short, so the last slice, which this brain mask reaches, keeps its ramp through the unwrapping while the rest loses it. The replica’s reproduce gives FSL’s bytes; its default takes every column, row and slice (FSL-261), so the ramps are estimated over the whole mask and removed and restored everywhere. fMRIPrep does not ask for the ramps’ removal. Beside them LARMORX’s clean room (Apache-2.0), in reproduce at 14 threads and at one and in fix, its default.

Data
OpenNeuro ds002422, sub-02 (CC0-1.0): fMRIPrep’s inputs of the call; shown inside sdcflows’ brain mask, dilated by 2 voxels, so no face shows
Command
prelude --abs=<sdcflows' clipped magnitude> --mask=<sdcflows' brain mask> --phase=<the phase difference in rad> --unwrap=sub-02_run-02_phasediff_rads_unwrapped.nii.gz --removeramps
Programs
FSL 6.0.7.23 (fsl-fugue 2603.0; ~/fsl-6.0.7.23, never on the PATH) (run for this page through the cache of the original’s runs); larmorx-nc 0.0.1 (the replica), from LARMORX at commit 069338d2d02d; LARMORX’s clean room (crate larmorx-fsl, Apache-2.0), from LARMORX at commit c292c141c0bb
Grid
64 × 64 × 36 voxels of 3.59 × 3.59 × 3.78 mm; shown: 48 × 55 × 36 around the brain
Inputds002422-sub-02 run-02: phase difference (rad)prelude's --phase in fMRIPrep (sdcflows' au2rads, 0 to 2π, float32)
OriginalFSL prelude 6.0.7.23--removeramps · as built, through the cache of the original's runs
Replicareplicalarmorx-nc, FSL Licence · reproduce · against FSL prelude 6.0.7.23
Replicareplicalarmorx-nc, FSL Licence · fix (the default, FSL-261 corrected)
Clean roomclean roomlarmorx, Apache-2.0 · fix (the default), 14 threads

Bit-identical147,456 of 147,456 voxels equal

the replica against the originalreplica − FSL prelude 6.0.7.23
the replica against itself: fix and reproducereplica, fix − reproducescale ±4.77e−7
the clean room against itself: fix and reproduceclean room, fix − reproducescale ±4.77e−7

Coronal slice 23 of 55; the crosshair where the default, fix, differs most from reproduce (FSL's bytes) in this coronal slice; the top slice is the image's last; the clean room's reproduce equals FSL's everywhere too, at 14 threads and at one. The interactive viewer needs JavaScript; the metrics below are complete without it.

Every comparison, computed in float64 over every voxel of the outputs

Comparison (A − B), verdict and reasonmax |Δ|Values that differRMS of Δmax |Δ| ÷ range1 − NCC
The replica against the original
replica − FSL prelude 6.0.7.23Bit-identicalThe same values, every one, in the unwrapped phase (the record compares every file prelude writes, its messages and its exit status too).identical: 0 of 147,456 values differ
The replica against itself: fix and reproduce
replica, fix − reproduceDeliberate correctionFSL-261, corrected by default with a notice: with --removeramps, FSL estimates, removes and restores the linear phase ramps over every column, row and slice but the last (its loops stop one short), so the last slice, here holding part of the brain, is unwrapped with its ramp while the rest is unwrapped without it; the default takes every column, row and slice. reproduce gives FSL’s bytes. Here the brain mask holds 105 voxels of the last slice: 5 of them change, and 880 voxels of the other slices (the ramps estimated over every slice), by at most 4.8e-07 rad (RMS 2.2e-08): the same whole cycles everywhere, only the last bits of the ramps’ removal and restoration move. Not important on this map; the correction matters where the last column, row or slice holds more of the image, or where the image has one slice (FSL then removes no ramp at all): the values the record’s synthetic cases change, opt/removeramps 15,750, opt/removeramps-verbose 11,860, opt/removeramps-slices 4,348, opt/removeramps-one-slice 1,125. FSL-2614.77e−7885 of 147,456 (0.6 %)2.15e−83.76e−81.4e−16
The clean room against the original and the replica
clean room − FSL prelude 6.0.7.23Bit-identicalThe same values, every one, in the unwrapped phase (the record compares every file prelude writes, its header, its messages and its exit status too).identical: 0 of 147,456 values differ
clean room − replica, reproduceBit-identicalThe two ports give the same values in reproduce: both FSL’s.identical: 0 of 147,456 values differ
clean room − replica, fixBit-identicalThe two ports give the same values in fix, their default (the record holds every case’s default against the replica’s).identical: 0 of 147,456 values differ
The clean room against itself: thread counts, fix and reproduce
clean room, 1 thread − 14 threadsBit-identicalThe thread count changes nothing: the linear parts run on the call’s threads in fixed chunks, the merging in its one order, so the one-thread result is the 14-thread result bit for bit.identical: 0 of 147,456 values differ
clean room, fix − reproduceDeliberate correctionFSL-261, corrected by default with a notice, as the replica’s default corrects it (the clean room’s default gives the replica’s default bit for bit, and reproduce FSL’s bytes; replica, fix − reproduce above says what the correction changes): 885 values differ between the modes, by at most 4.8e-07 rad. FSL-2614.77e−7885 of 147,456 (0.6 %)2.15e−83.76e−81.4e−16

Δ is A − B in radians, computed in float64 over all 147,456 voxels of the outputs, not only those shown. The replica’s record’s threshold: every file prelude writes bit-identical (images decompressed, descrip left out), with FSL’s exit status and messages. The clean room’s record (fsl-prelude) holds it to specs/prelude.md §11’s thresholds: in reproduce the same, each header whole with its extension bytes but descrip; in fix the replica’s fix, the same, but where GLIBC-07 is named, where the unwrapped phase keeps the replica’s whole cycles on at least 99.9 % of the mask’s voxels.

Provenance of this example
  • Data: OpenNeuro ds002422, sub-02, CC0-1.0
  • Inputs: clipped.nii.gz (sha256 4721c8cb03fd0ff7…); clipped_mask.nii.gz (sha256 e5f1290737178ef7…); sub-02_run-02_phasediff_rads.nii (sha256 ac501eebf304c366…)
  • Runs: figures cache entry fsl-prelude/ramps-ds002422-run02, computed 2026-11-06T19:26:23+00:00 with larmorx 069338d2d02d; FSL 6.0.7.23 (fsl-fugue 2603.0; ~/fsl-6.0.7.23, never on the PATH); larmorx-nc 0.0.1; every command, its environment, threads and exit status are in its RUN_INFO.json
  • Runs of the clean room: figures cache entry fsl-prelude/ramps-ds002422-run02-original, computed 2026-11-07T02:01:53+00:00 with larmorx c292c141c0bb (python -m larmorx with LARMORX_IMPLEMENTATION=original, reproduce at 14 threads and at one, fix, the default at 14), on the replica’s entry’s inputs; every command, its environment, threads and exit status are in its RUN_INFO.json

Every number above is in fsl-prelude.json, exported by python -m larmorx_validation evidence fsl-prelude.

A phase whose truth is known

On a synthetic phase the truth is known. The record’s case opt/default holds a smooth phase spanning several cycles, with noise, wrapped into [−π, π), and a magnitude from which prelude makes its own mask. FSL’s unwrapped phase, the replica’s and the clean room’s are the true phase inside the mask, every wrap undone.

Worked example

A phase whose truth is known

What this shows: On a synthetic phase whose truth is known, FSL’s unwrapped phase is the true phase in every one of the mask’s 11,860 voxels, to 9.5 × 10⁻⁷ rad, the wrapped phase’s float32 rounding: every wrap undone. Both ports give FSL’s values, every one; the clean room the same at 1 and 14 threads. No correction by default changes this call, in either port.

The record’s case opt/default on the suite’s synthetic phase map (40 × 36 × 12 voxels): a smooth phase spanning several cycles, with noise, wrapped into [−π, π), and a magnitude from which prelude makes its own mask (no --mask). The true phase is an input panel: FSL’s unwrapped phase and the replica’s in fix and in reproduce are the true phase plus one constant number of whole cycles inside the mask (the comparison FSL − the true phase). Beside them LARMORX’s clean room (Apache-2.0), in reproduce at 14 threads and at one and in fix, its default.

Data
synthetic, generated by the comparison suite with seeded random numbers (parity.fsl_prelude_replica._true_phase, _magnitude; oracles/inputs/fsl-prelude-replica/v4); no subject
Case
opt/default of the record (fsl-prelude-replica)
Command
prelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out
Programs
FSL 6.0.7.23 (fsl-fugue 2603.0; ~/fsl-6.0.7.23, never on the PATH) (its runs served from the cache of the original’s runs, as the record ran them); larmorx-nc 0.0.1 (the replica), from LARMORX at commit 069338d2d02d; LARMORX’s clean room (crate larmorx-fsl, Apache-2.0), from LARMORX at commit c292c141c0bb
Grid
40 × 36 × 12 voxels of 2 × 2 × 2.5 mm; shown: 40 × 36 × 12 the whole field of view
Inputthe true phase (rad), inside prelude's maskthe suite's smooth phase: a ramp and a bowl spanning several cycles, with noise (float64, shown in float32); 0 outside the mask, as prelude writes
Inputthe wrapped phase (rad)the true phase wrapped into [−π, π) (float32): prelude's -p
OriginalFSL prelude 6.0.7.23as built (the record's run, from the cache of the original's runs)
Replicareplicalarmorx-nc, FSL Licence · reproduce · against FSL prelude 6.0.7.23
Clean roomclean roomlarmorx, Apache-2.0 · reproduce, 14 threads · against FSL prelude 6.0.7.23
the original against the known answerFSL prelude 6.0.7.23 − the true phasescale ±9.54e−7

Bit-identical17,280 of 17,280 voxels equal

the replica against the originalreplica − FSL prelude 6.0.7.23

Bit-identical17,280 of 17,280 voxels equal

the clean room against the originalclean room − FSL prelude 6.0.7.23

Axial slice 7 of 12; the crosshair where FSL's unwrapped phase departs most from the wrapped phase in this slice; the whole field of view is shown (a synthetic image); the clean room's reproduce equals FSL's everywhere too, at 14 threads and at one. The interactive viewer needs JavaScript; the metrics below are complete without it.

Every comparison, computed in float64 over every voxel of the outputs

Comparison (A − B), verdict and reasonmax |Δ|Values that differRMS of Δmax |Δ| ÷ range1 − NCC
The original against the known answer
FSL prelude 6.0.7.23 − the true phasereferenceWhat unwrapping recovers (no verdict: the truth is not a program’s output): inside prelude’s mask (11,860 voxels) FSL’s unwrapped phase is the true phase plus 0 × 2π in every one of them, to 9.5e-07 rad (the wrapped phase’s float32 rounding): every wrap undone. The one constant whole number of cycles that no unwrapping can know is set by the reference region prelude starts from.9.54e−7486 of 17,280 (2.81 %)7.53e−84.74e−81.88e−16
The replica against the original
replica − FSL prelude 6.0.7.23Bit-identicalThe same values, every one, in the unwrapped phase (the record compares every file prelude writes, its messages and its exit status too).identical: 0 of 17,280 values differ
The replica against itself: fix and reproduce
replica, fix − reproduceBit-identicalNo correction of the register applies to this call: fix and reproduce give the same values.identical: 0 of 17,280 values differ
The clean room against the original and the replica
clean room − FSL prelude 6.0.7.23Bit-identicalThe same values, every one, in the unwrapped phase (the record compares every file prelude writes, its header, its messages and its exit status too).identical: 0 of 17,280 values differ
clean room − replica, reproduceBit-identicalThe two ports give the same values in reproduce: both FSL’s.identical: 0 of 17,280 values differ
clean room − replica, fixBit-identicalThe two ports give the same values in fix, their default (the record holds every case’s default against the replica’s).identical: 0 of 17,280 values differ
The clean room against itself: thread counts, fix and reproduce
clean room, 1 thread − 14 threadsBit-identicalThe thread count changes nothing: the linear parts run on the call’s threads in fixed chunks, the merging in its one order, so the one-thread result is the 14-thread result bit for bit.identical: 0 of 17,280 values differ
clean room, fix − reproduceBit-identicalNo correction of the register applies to this call: fix and reproduce give the same values.identical: 0 of 17,280 values differ

Δ is A − B in radians, computed in float64 over all 17,280 voxels of the outputs, not only those shown. The replica’s record’s threshold: every file prelude writes bit-identical (images decompressed, descrip left out), with FSL’s exit status and messages. The clean room’s record (fsl-prelude) holds it to specs/prelude.md §11’s thresholds: in reproduce the same, each header whole with its extension bytes but descrip; in fix the replica’s fix, the same, but where GLIBC-07 is named, where the unwrapped phase keeps the replica’s whole cycles on at least 99.9 % of the mask’s voxels.

Provenance of this example
  • Data:
  • Inputs: s_mag.nii.gz (sha256 04c0cd4369e66202…); s_ph.nii.gz (sha256 1862a1e0070f0b17…)
  • Runs: figures cache entry fsl-prelude/opt-default, computed 2026-11-06T19:26:23+00:00 with larmorx 069338d2d02d; FSL 6.0.7.23 (fsl-fugue 2603.0; ~/fsl-6.0.7.23, never on the PATH); larmorx-nc 0.0.1; every command, its environment, threads and exit status are in its RUN_INFO.json
  • Runs of the clean room: figures cache entry fsl-prelude/opt-default-original, computed 2026-11-07T02:01:53+00:00 with larmorx c292c141c0bb (python -m larmorx with LARMORX_IMPLEMENTATION=original, reproduce at 14 threads and at one, fix, the default at 14), on the replica’s entry’s inputs; every command, its environment, threads and exit status are in its RUN_INFO.json

Every number above is in fsl-prelude.json, exported by python -m larmorx_validation evidence fsl-prelude.

Random testing

The replica’s random-testing run (2026-11-06), 30 minutes long, drew random calls. Each was run by FSL 6.0.7.23 (through the cache of the original’s runs) and by the replica, every file was compared, and the default, fix, was checked to name a correction exactly where it changes the result.

Random testing, the replica against the original: FSL prelude 6.0.7.23 (50,711 random calls, 2026-11-06)

Cases
Random cases, each compared with FSL 6.0.7.2350,711
bit-identical (every file, the messages, the exit status, the default’s notices)50,702
differing: the random cases’ own mistake, drawn again and agreeing (below)9
fMRIPrep’s call (--abs, --mask, --phase, --unwrap)10,747
phase and magnitude, complex (-c)32,011 / 7,953
one, two or three volumes45,987 / 2,424 / 2,300
a phase in [−π, π), in [0, 2π), unwrapped already19,467 / 11,629 / 915
-s, --labelslices, -f5,553 / 4,825 / 2,993
-m or --mask, -t, -n22,699 / 9,545 / 10,087
--removeramps, -v5,982 / 7,607
--savemask, -l, -r6,063 / 5,998 / 6,080
--start, --end2,286 / 2,406
a magnitude or mask of another size (FSL-271)615
an output type other than NIFTI_GZ15,518
distinct options and settings drawn46
length (minutes; 12 jobs at one thread each)30.2

A random-testing run of the replica, 30 minutes long (seed prelude-trial, larmorx 2f464a937d07): a smooth wrapped phase over a head phantom (or its complex image: the magnitude times a power of a rational unit complex number), random background, 1 to 3 volumes; float32, float64, int16, uint16, complex64 and complex128 images; FSL’s output types; FSL 6.0.7.23 through the cache of the original’s runs (use mode), the replica in reproduce compared file by file, its default, fix, checked to name a correction exactly where it changes the result. The nine differing cases were the random cases’ own mistake (a magnitude of ‘another size’ drawn on a one-slice image by shortening its one-voxel axis, which stayed one voxel, so the replica’s default rightly did not refuse it): the draw was fixed and the nine, drawn again, agree (validation/difftest/triage.toml). Every case in a memory box of 1.5 GiB (peaks below 1.07 GiB).

The clean room’s random-testing run (2026-11-06), also 30 minutes long, drew 23,780 random calls. Each was run by FSL 6.0.7.23 (through the cache of the original’s runs) and by the clean room: its reproduce compared with FSL’s files and its fix with the replica’s, as the record compares.

  • 22,109 agreed.
  • 14 more named GLIBC-07 where the correctly rounded arctangent and glibc’s atan2f differ on a voxel of a complex image, whether or not an output changes, as the specification says.
  • Each of the 1,657 that differed was run again with the part’s final build and put in one category below. 1,650 were the clean room’s own mistake, fixed with a permanent case of the record (difftest/time-step-zero-series): a series whose time step is 0 or negative, which FSL reads as its magnitude (and as 1 for a time step of 0), and which every output keeps.
  • 7 stay open, each a question for the specification with its reproducer. On 6 oblique inputs whose offset is 0, FSL writes a residual of its own matrix arithmetic (1.8 × 10−15 to 3.6 × 10−15) where the clean room writes 0, every other header field and every value the same. On 1, FSL-271 reproduced in the slices mode with a magnitude of more slices and fewer rows than the phase, FSL’s mask at the phase’s indices differs from the clean room’s in one voxel (fix refuses the call in both ports).

Random testing, the clean room against the original: FSL prelude 6.0.7.23 (23,780 random calls, 2026-11-06)

Cases
Random cases, each compared with FSL 6.0.7.2323,780
every file, the messages and the exit status bit for bit (the default checked against the replica’s default)22,109
the same, GLIBC-07 named where the correctly rounded arctangent and glibc’s atan2f differ on a voxel (explained, below)14
differing in the run (each one in a category below)1,657
fMRIPrep’s call (--abs, --mask, --phase, --unwrap)5,055
phase and magnitude, complex (-c)14,952 / 3,773
two or three volumes1,153 / 1,074
-s, --labelslices, -f2,574 / 2,232 / 1,382
--removeramps, -v2,805 / 3,571
a magnitude or mask of another size (FSL-271)265
an output type other than NIFTI_GZ7,254
distinct options and settings drawn46

A random-testing run of the clean room, 30 minutes long (seed prelude-trial, larmorx 78101509a4bf, 6 jobs at 2 threads): random calls, each run by FSL 6.0.7.23 (through the cache of the original’s runs) and by the clean room in fix and in reproduce, compared as the record compares; every case in a memory box of 3 GiB. The differing cases were run again with the part’s final build and each put in one category (below).

The clean room’s differences from the original in the run of 2026-11-06, by category

CategoryCasesReproducer
a LARMORX mistake, fixed: a series whose time step (pixdim[4]) is 0 or negative; FSL reads it as its magnitude, and as 1 for an image with a time axis and a time step of 0, and every output keeps it (the complex image of -c its magnitude, a 0 kept); the clean room kept the stored value (docs/findings/fsl-prelude-original.md, …1,650time-step-zero-series
open: oblique inputs whose qform or sform offset is 0; FSL writes a residual of its own matrix arithmetic there (qoffset or srow’s last value 1.8e-15 to 3.6e-15) where the clean room writes 0, every other header field and every value identical; for the specification: the arithmetic of the offsets FSL writes ba…6prelude-trial-02118-original
open: FSL-271 reproduced in the slices mode (-s) with a magnitude of more slices and fewer rows than the phase (shrunk: a 1 x 4 x 1 phase, a 1 x 3 x 2 magnitude): FSL’s mask at the phase’s voxel indices is [1, 1, 1, 0], the clean room’s [1, 1, 1, 1] (the saved masks identical); the default refuses (FSL-271…1prelude-trial-04928-original
explained: GLIBC-07 named where the correctly rounded arctangent and glibc’s atan2f differ on a voxel of a complex image, whether or not an output changes (the voxel outside the mask, or the phase’s last bit absorbed), as specs/prelude.md §6.4 says; the suite reports it in the replica suite’s check of the corrections by default (the r…14(no reproducer: a notice)

validation/difftest/triage.toml (the entries of fsl-prelude-original): each category with its explanation; the open ones are questions for the specification (docs/findings/fsl-prelude-original.md).

Every case

Each case of the two records, the replica’s and the clean room’s, both against FSL 6.0.7.23 (a column each), with what it tests, its command line, each port’s verdict and the reason. The 78 cases only the clean room’s record holds are its own: orig- and the permanent case random testing gave it. Search, filter by category or verdict (or select a segment of a chart above), sort by a column; #case=<name> links to one case.

166 cases

CaseCategoryWhat it testsreplicaclean roomChecks
fmriprep/ds001600-sub-1-noreconall/wf_auto_00000 worked examplefMRIPrep's callsfMRIPrep's phase-unwrapping call (ds001600-sub-1, sdcflows' wf_auto_00000)
command lineprelude --abs=<sdcflows' clipped magnitude> --mask=<sdcflows' brain mask> --phase=<the phase difference in rad> --unwrap=sub-1_acq-v1_phase1_rads_phdiff_unwrapped.nii.gz
Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages; fMRIPrep’s own unwrapped phase (its image’s prelude) the same

Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages; fMRIPrep’s own unwrapped phase the same

8/8
fmriprep/ds001600-sub-1-noreconall/wf_auto_00001 worked examplefMRIPrep's callsfMRIPrep's phase-unwrapping call (ds001600-sub-1, sdcflows' wf_auto_00001)
command lineprelude --abs=<sdcflows' clipped magnitude> --mask=<sdcflows' brain mask> --phase=<the phase difference in rad> --unwrap=sub-1_acq-v2_phase1_rads_phdiff_unwrapped.nii.gz
Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages; fMRIPrep’s own unwrapped phase (its image’s prelude) the same

Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages; fMRIPrep’s own unwrapped phase the same

8/8
fmriprep/ds001600-sub-1-noreconall/wf_auto_00002 worked examplefMRIPrep's callsfMRIPrep's phase-unwrapping call (ds001600-sub-1, sdcflows' wf_auto_00002)
command lineprelude --abs=<sdcflows' clipped magnitude> --mask=<sdcflows' brain mask> --phase=<the phase difference in rad> --unwrap=sub-1_acq-v4_phasediff_rads_unwrapped.nii.gz
Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages; fMRIPrep’s own unwrapped phase (its image’s prelude) the same

Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages; fMRIPrep’s own unwrapped phase the same

8/8
fmriprep/ds002422-sub-02-noreconall/wf_auto_00000 worked examplefMRIPrep's callsfMRIPrep's phase-unwrapping call (ds002422-sub-02, sdcflows' wf_auto_00000)
command lineprelude --abs=<sdcflows' clipped magnitude> --mask=<sdcflows' brain mask> --phase=<the phase difference in rad> --unwrap=sub-02_run-01_phasediff_rads_unwrapped.nii.gz
Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages; fMRIPrep’s own unwrapped phase (its image’s prelude) the same

Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages; fMRIPrep’s own unwrapped phase the same

8/8
fmriprep/ds002422-sub-02-noreconall/wf_auto_00001 worked examplefMRIPrep's callsfMRIPrep's phase-unwrapping call (ds002422-sub-02, sdcflows' wf_auto_00001)
command lineprelude --abs=<sdcflows' clipped magnitude> --mask=<sdcflows' brain mask> --phase=<the phase difference in rad> --unwrap=sub-02_run-02_phasediff_rads_unwrapped.nii.gz
Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages; fMRIPrep’s own unwrapped phase (its image’s prelude) the same

Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages; fMRIPrep’s own unwrapped phase the same

8/8
fmriprep/ds002603-sub-01-noreconall/wf_auto_00000 worked examplefMRIPrep's callsfMRIPrep's phase-unwrapping call (ds002603-sub-01, sdcflows' wf_auto_00000)
command lineprelude --abs=<sdcflows' clipped magnitude> --mask=<sdcflows' brain mask> --phase=<the phase difference in rad> --unwrap=sub-01_acq-Mm2_phasediff_rads_unwrapped.nii.gz
Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages; fMRIPrep’s own unwrapped phase (its image’s prelude) the same

Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages; fMRIPrep’s own unwrapped phase the same

8/8
fmriprep/ds005454-sub-16-noreconall/wf_gre16 worked examplefMRIPrep's callsfMRIPrep's phase-unwrapping call (ds005454-sub-16, sdcflows' wf_gre16)
command lineprelude --abs=<sdcflows' clipped magnitude> --mask=<sdcflows' brain mask> --phase=<the phase difference in rad> --unwrap=sub-16_phasediff_rads_unwrapped.nii.gz
Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages; fMRIPrep’s own unwrapped phase (its image’s prelude) the same

Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages; fMRIPrep’s own unwrapped phase the same

8/8
opt/default worked exampleoptionsphase and magnitude, the defaults (3D labels and unwrapping)
command lineprelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out
Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6
opt/twopi-maskoptionsa phase from 0 to 2pi (rewrapped) with a mask (fMRIPrep's form)
command lineprelude --abs=<s_mag.nii.gz: synthetic 40 × 36 × 12> --mask=<s_mask.nii.gz: synthetic 40 × 36 × 12> --phase=<s_ph2pi.nii.gz: synthetic 40 × 36 × 12> --unwrap=out
Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages

6/6
opt/verboseoptions-v: every message
command lineprelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out -v
Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6
opt/big-auto-2d-labelsoptionsan image wider than 64 voxels: labels slice by slice, 3D unwrapping
command lineprelude -p <b_ph.nii.gz: synthetic 72 × 70 × 8> -a <b_mag.nii.gz: synthetic 72 × 70 × 8> -o out -v
Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6
opt/big-force3doptions-f on a wide image: 3D labels
command lineprelude -p <b_ph.nii.gz: synthetic 72 × 70 × 8> -a <b_mag.nii.gz: synthetic 72 × 70 × 8> -o out -f
Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6
opt/labelslicesoptions--labelslices
command lineprelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out --labelslices
Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6
opt/slicesoptions-s: masks, labels and unwrapping slice by slice
command lineprelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out -s -v
Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6
opt/slices-force3doptions-s -f: -f wins
command lineprelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out -s -f
Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6
opt/n2options-n 2
command lineprelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out -n 2
Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6
opt/n3options-n 3
command lineprelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out -n 3
Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6
opt/n24options-n 24
command lineprelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out -n 24
Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6
opt/threshoptions-t 300
command lineprelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out -t 300
Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6
opt/thresh-zerooptions-t 0: every voxel
command lineprelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out -t 0
Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6
opt/maskoptions-m
command lineprelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out -m <s_mask.nii.gz: synthetic 40 × 36 × 12>
Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages

6/6
opt/mask-threshoptions-m with -t 0.2
command lineprelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out -m <s_mask.nii.gz: synthetic 40 × 36 × 12> -t 0.2
Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages

6/6
opt/seriesoptionsthree volumes
command lineprelude -p <t_ph.nii.gz: synthetic, three volumes> -a <t_mag.nii.gz: synthetic, three volumes> -o out
Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6
opt/series-mask2optionsthree volumes, a mask of two (the last mask for the third)
command lineprelude -p <t_ph.nii.gz: synthetic, three volumes> -a <t_mag.nii.gz: synthetic, three volumes> -o out -m <t_mask2.nii.gz: synthetic, three volumes>
Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages

6/6
opt/series-start-endoptions--start 1 --end 2
command lineprelude -p <t_ph.nii.gz: synthetic, three volumes> -a <t_mag.nii.gz: synthetic, three volumes> -o out --start=1 --end=2
Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6
opt/series-startoptions--start 2
command lineprelude -p <t_ph.nii.gz: synthetic, three volumes> -a <t_mag.nii.gz: synthetic, three volumes> -o out --start=2
Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6
opt/series-endoptions--end 0
command lineprelude -p <t_ph.nii.gz: synthetic, three volumes> -a <t_mag.nii.gz: synthetic, three volumes> -o out --end=0
Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6
opt/series-savedoptions--savemask, -l and -r with three volumes (FSL-262)
command lineprelude -p <t_ph.nii.gz: synthetic, three volumes> -a <t_mag.nii.gz: synthetic, three volumes> -o out --savemask=m -l l -r r
Bit-identical

every file FSL writes (6/6) byte for byte, with FSL’s exit status and messages; in fix, its default, the replica corrects FSL-262 and names it: 103,680 values change

Bit-identical

every file FSL writes (6/6) byte for byte, with FSL’s exit status and messages

6/6
opt/savedoptions--savemask, -l and -r
command lineprelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out --savemask=m -l l -r r
Bit-identical

every file FSL writes (6/6) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (6/6) byte for byte, with FSL’s exit status and messages

6/6
opt/saved-slicesoptions--savemask, -l, -r with -s
command lineprelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out -s --savemask=m -l l -r r
Bit-identical

every file FSL writes (6/6) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (6/6) byte for byte, with FSL’s exit status and messages

6/6
opt/removerampsoptions--removeramps (FSL-261)
command lineprelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out --removeramps -r r
Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages; in fix, its default, the replica corrects FSL-261 and names it: 15,750 values change

Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages

6/6
opt/removeramps-verboseoptions--removeramps -v (FSL-266: grot)
command lineprelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out --removeramps -v
Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages; in fix, its default, the replica corrects FSL-261, FSL-266 and names it: 11,860 values change

Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages

6/6
opt/removeramps-slicesoptions--removeramps -s
command lineprelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out --removeramps -s
Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages; in fix, its default, the replica corrects FSL-261 and names it: 4,348 values change

Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6
opt/removeramps-one-sliceoptions--removeramps on one slice (FSL-261)
command lineprelude -p <o_ph.nii.gz: synthetic, one slice> -a <o_mag.nii.gz: synthetic, one slice> -o out --removeramps
Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages; in fix, its default, the replica corrects FSL-261 and names it: 1,125 values change

Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6
opt/one-sliceoptionsan image of one slice
command lineprelude -p <o_ph.nii.gz: synthetic, one slice> -a <o_mag.nii.gz: synthetic, one slice> -o out -l l
Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages

6/6
opt/neurologicaloptionsa neurological image (swapped in memory)
command lineprelude -p <n_ph.nii.gz: synthetic, neurological> -a <n_mag.nii.gz: synthetic, neurological> -o out --savemask=m -l l -r r
Bit-identical

every file FSL writes (6/6) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (6/6) byte for byte, with FSL’s exit status and messages

6/6
opt/int16-phaseoptionsan int16 phase with scl_slope
command lineprelude -p <s_ph16.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out
Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6
opt/gap-sliceoptionsa mask with an empty slice between two parts, labels slice by slice (the largest component kept)
command lineprelude -p <b_ph.nii.gz: synthetic 72 × 70 × 8> -a <b_mag.nii.gz: synthetic 72 × 70 × 8> -o out -m <b_mask_gap.nii.gz: synthetic 72 × 70 × 8> -l l
Bit-identical

every file FSL writes (5/5) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (5/5) byte for byte, with FSL’s exit status and messages

6/6
opt/complexoptions-c: a complex64 image
command lineprelude -c <s_cplx.nii.gz: synthetic 40 × 36 × 12> -o out -r r -v
Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6
opt/complex-big-endianoptions-c: a big-endian complex64 image (FSL-264)
command lineprelude -c <s_cplx_be.nii: synthetic 40 × 36 × 12> -o out -r r
Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages; in fix, its default, the replica corrects FSL-264 and names it: 29,140 values change

Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6
opt/complex128options-c: a complex128 image (FSL-265)
command lineprelude -c <s_cplx128.nii.gz: synthetic 40 × 36 × 12> -o out
Expected divergence

FSL’s values come from memory it never wrote (FSL-265: a complex128 image read with no width): 1/2 files bit-identical, the others’ values reported, not compared; the exit status, messages and file names are FSL’s; the default reads the image correctly (11,860 values change)

Expected divergence

FSL’s values come from memory it never wrote (FSL-265: a complex128 image read with no width): 1/2 files bit-identical, the others’ values reported, not compared; the exit status, the messages and the file names are FSL’s

6/6
opt/complex-realoptions-c: a float32 image (FSL-263)
command lineprelude -c <s_real.nii.gz: synthetic 40 × 36 × 12> -o out
Bit-identical

every file FSL writes (2/2) byte for byte, with FSL’s exit status and messages; its default, fix, refuses the call (exit 1), naming FSL-263

Bit-identical

every file FSL writes (2/2) byte for byte, with FSL’s exit status and messages

6/6
opt/complex-int16options-c: an int16 image (FSL-263)
command lineprelude -c <s_real16.nii.gz: synthetic 40 × 36 × 12> -o out
Bit-identical

every file FSL writes (2/2) byte for byte, with FSL’s exit status and messages; its default, fix, refuses the call (exit 1), naming FSL-263

Bit-identical

every file FSL writes (2/2) byte for byte, with FSL’s exit status and messages

6/6
opt/nan-magnitudeoptionsNaN magnitudes (FSL-268)
command lineprelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_nanmag.nii.gz: synthetic 40 × 36 × 12> -o out
Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6
opt/nan-first-magnitudeoptionsa NaN first magnitude voxel (FSL-268)
command lineprelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_nanfirst.nii.gz: synthetic 40 × 36 × 12> -o out
Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages; in fix, its default, the replica corrects FSL-268 and names it: 11,859 values change

Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6
opt/nan-phaseoptionsNaN phases inside the mask (FSL-269)
command lineprelude -p <s_nanph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out
Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6
opt/nan-first-twopioptionsa phase from 0 to 2pi whose first value is NaN: FSL does not rewrap it (FSL-272; the default rewraps it as without the NaN)
command lineprelude -p <s_ph2pi_nanfirst.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out
Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages; in fix, its default, the replica corrects FSL-272 and names it: 4,170 values change

Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6
opt/nan-first-rangeoptionsa phase of range 4pi whose first value is NaN: FSL does not refuse it (FSL-272; the default stops with FSL's range error, status 255)
command lineprelude -p <s_range4pi_nanfirst.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out
Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages; its default, fix, refuses the call (exit 255), naming FSL-272

Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6
opt/nan-phase-firstoptionsNaN phases at the mask's first voxels (FSL-269)
command lineprelude -p <s_nanph_first.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -m <s_mask.nii.gz: synthetic 40 × 36 × 12> -o out -l l
Bit-identical

every file FSL writes (5/5) byte for byte, with FSL’s exit status and messages; in fix, its default, the replica corrects FSL-269 and names it: 3 values change

Bit-identical

every file FSL writes (5/5) byte for byte, with FSL’s exit status and messages

6/6
opt/nan-phase-regionoptionsa NaN phase inside a region of the first phase bin (FSL-269)
command lineprelude -p <s_nanph_bin1.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -m <s_mask.nii.gz: synthetic 40 × 36 × 12> -o out
Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages; in fix, its default, the replica corrects FSL-269 and names it: 2,608 values change

Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages

6/6
opt/nan-phase-slicesoptionsNaN phases with -s (FSL-269)
command lineprelude -p <s_nanph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out -s
Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6
out/niftioutput typesFSLOUTPUTTYPE=NIFTI
command lineFSLOUTPUTTYPE=NIFTI prelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out -l l
Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages

6/6
out/nifti_pairoutput typesFSLOUTPUTTYPE=NIFTI_PAIR
command lineFSLOUTPUTTYPE=NIFTI_PAIR prelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out -l l
Bit-identical

every file FSL writes (6/6) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (6/6) byte for byte, with FSL’s exit status and messages

6/6
out/nifti2_gzoutput typesFSLOUTPUTTYPE=NIFTI2_GZ
command lineFSLOUTPUTTYPE=NIFTI2_GZ prelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out -l l
Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages

6/6
out/nifti_pair_gzoutput typesFSLOUTPUTTYPE=NIFTI_PAIR_GZ
command lineFSLOUTPUTTYPE=NIFTI_PAIR_GZ prelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out -l l
Bit-identical

every file FSL writes (6/6) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (6/6) byte for byte, with FSL’s exit status and messages

6/6
out/nifti2output typesFSLOUTPUTTYPE=NIFTI2
command lineFSLOUTPUTTYPE=NIFTI2 prelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out -l l
Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages

6/6
out/invalidoutput typesFSLOUTPUTTYPE=bogus
command lineFSLOUTPUTTYPE=bogus prelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out
Rejected by both

prelude exits 1; the same from the replica. FTI, NIFTI_PAIR, NIFTI2, NIFTI2_PAIR, NIFTI_GZ, NIFTI_PAIR_GZ, NIFTI2_GZ, NIFTI2_PAIR_GZ, NIFTI_ZST, NIFTI_PAIR_ZST, NIFTI2_ZST, NIFTI2_PAIR_ZST, NIFTI_BZ2, NIFTI_PAIR_BZ2, NIFTI2_BZ2, NIFTI2_PAIR_BZ2

Rejected by both

prelude exits 1; the same from the clean room. FTI, NIFTI_PAIR, NIFTI2, NIFTI2_PAIR, NIFTI_GZ, NIFTI_PAIR_GZ, NIFTI2_GZ, NIFTI2_PAIR_GZ, NIFTI_ZST, NIFTI_PAIR_ZST, NIFTI2_ZST, NIFTI2_PAIR_ZST, NIFTI_BZ2, NIFTI_PAIR_BZ2, NIFTI2_BZ2, NIFTI2_PAIR_BZ2

5/5
opt/long-namesoptionsthe long option names (--phase, --abs, --out, --numphasesplit, --thresh, --labels, --rawphase, --verbose, --slices, --force3D)
command lineprelude --phase=<s_ph.nii.gz: synthetic 40 × 36 × 12> --abs=<s_mag.nii.gz: synthetic 40 × 36 × 12> --out=out --numphasesplit=4 --thresh=200 --labels=l --rawphase=r --verbose --slices
Bit-identical

every file FSL writes (5/5) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (5/5) byte for byte, with FSL’s exit status and messages

6/6
opt/u-aliasoptions-u (the output's other name) and grouped flags -fv
command lineprelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -u out -fv
Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6
panel/ds000256/radsthe data panel's phase differencesthe data panel's ds000256 phase difference in radians (sdcflows' au2rads) and its first magnitude: prelude's own mask
command lineprelude --abs=<ds000256's first magnitude> --phase=<ds000256's in radians (sdcflows' au2rads)> --unwrap=out
Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6
panel/ds000256/optionsthe data panel's phase differencesthe data panel's ds000256 phase difference in radians: -s -v with the mask and labels
command lineprelude -a <ds000256's first magnitude> -p <ds000256's in radians (sdcflows' au2rads)> -o out -s -v --savemask=m -l l
Bit-identical

every file FSL writes (5/5) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (5/5) byte for byte, with FSL’s exit status and messages

6/6
panel/ds004958/radsthe data panel's phase differencesthe data panel's ds004958 phase difference in radians (sdcflows' au2rads) and its first magnitude: prelude's own mask
command lineprelude --abs=<ds004958's first magnitude> --phase=<ds004958's in radians (sdcflows' au2rads)> --unwrap=out
Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6
panel/ds004958/optionsthe data panel's phase differencesthe data panel's ds004958 phase difference in radians: --removeramps -v with the raw phase
command lineprelude -a <ds004958's first magnitude> -p <ds004958's in radians (sdcflows' au2rads)> -o out --removeramps -r r -v
Bit-identical

every file FSL writes (5/5) byte for byte, with FSL’s exit status and messages; in fix, its default, the replica corrects FSL-261, FSL-266 and names it: 8,568 values change

Bit-identical

every file FSL writes (5/5) byte for byte, with FSL’s exit status and messages

6/6
panel/ds000256/rawthe data panel's phase differencesthe data panel's ds000256 phase difference in the scanner's units (FSL's range error)
command lineprelude --abs=<ds000256's first magnitude> --phase=<ds000256's phase difference as the scanner stores it> --unwrap=out
Rejected by both

prelude exits 255; the same from the replica. ERROR: input phase image exceeds allowable phase range. Allowable range is 6.283 radians. Image range is: 8188 radians. Aborting.

Rejected by both

prelude exits 255; the same from the clean room. ERROR: input phase image exceeds allowable phase range. Allowable range is 6.283 radians. Image range is: 8188 radians. Aborting.

5/5
err/helperrors and messages-h
command lineprelude -h
Rejected by both

prelude exits 1; the same from the replica. the raw phase output -l,–labels filename for saving the area labels output --removeramps remove phase ramps during unwrapping -v,–verbose switch on diagnostic messages -h,–help display this message

Rejected by both

prelude exits 1; the same from the clean room. the raw phase output -l,–labels filename for saving the area labels output --removeramps remove phase ramps during unwrapping -v,–verbose switch on diagnostic messages -h,–help display this message

5/5
err/no-argumentserrors and messagesno arguments
command lineprelude
Rejected by both

prelude exits 1; the same from the replica. the raw phase output -l,–labels filename for saving the area labels output --removeramps remove phase ramps during unwrapping -v,–verbose switch on diagnostic messages -h,–help display this message

Rejected by both

prelude exits 1; the same from the clean room. the raw phase output -l,–labels filename for saving the area labels output --removeramps remove phase ramps during unwrapping -v,–verbose switch on diagnostic messages -h,–help display this message

5/5
err/no-outputerrors and messagesno -o
command lineprelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12>
Rejected by both

prelude exits 1; the same from the replica. the raw phase output -l,–labels filename for saving the area labels output --removeramps remove phase ramps during unwrapping -v,–verbose switch on diagnostic messages -h,–help display this message

Rejected by both

prelude exits 1; the same from the clean room. the raw phase output -l,–labels filename for saving the area labels output --removeramps remove phase ramps during unwrapping -v,–verbose switch on diagnostic messages -h,–help display this message

5/5
err/complex-and-phaseerrors and messages-c with -p
command lineprelude -c <s_cplx.nii.gz: synthetic 40 × 36 × 12> -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out
Rejected by both

prelude exits 1; the same from the replica. the area labels output --removeramps remove phase ramps during unwrapping -v,–verbose switch on diagnostic messages -h,–help display this message Cannot specify both --complex AND --phase or --abs.

Rejected by both

prelude exits 1; the same from the clean room. the area labels output --removeramps remove phase ramps during unwrapping -v,–verbose switch on diagnostic messages -h,–help display this message Cannot specify both --complex AND --phase or --abs.

5/5
err/phase-without-abserrors and messages-p without -a
command lineprelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -o out
Rejected by both

prelude exits 1; the same from the replica. saving the area labels output --removeramps remove phase ramps during unwrapping -v,–verbose switch on diagnostic messages -h,–help display this message Both --phase AND --abs must be used together.

Rejected by both

prelude exits 1; the same from the clean room. saving the area labels output --removeramps remove phase ramps during unwrapping -v,–verbose switch on diagnostic messages -h,–help display this message Both --phase AND --abs must be used together.

5/5
err/abs-without-phaseerrors and messages-a without -p
command lineprelude -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out
Rejected by both

prelude exits 1; the same from the replica. saving the area labels output --removeramps remove phase ramps during unwrapping -v,–verbose switch on diagnostic messages -h,–help display this message Both --phase AND --abs must be used together.

Rejected by both

prelude exits 1; the same from the clean room. saving the area labels output --removeramps remove phase ramps during unwrapping -v,–verbose switch on diagnostic messages -h,–help display this message Both --phase AND --abs must be used together.

5/5
err/n1errors and messages-n 1
command lineprelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out -n 1
Rejected by both

prelude exits 1; the same from the replica. ing the area labels output --removeramps remove phase ramps during unwrapping -v,–verbose switch on diagnostic messages -h,–help display this message Always set --numphasesplit greater than 1. NOT 1

Rejected by both

prelude exits 1; the same from the clean room. ing the area labels output --removeramps remove phase ramps during unwrapping -v,–verbose switch on diagnostic messages -h,–help display this message Always set --numphasesplit greater than 1. NOT 1

5/5
err/unknown-optionerrors and messagesan unknown option
command lineprelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out --bogus
Rejected by both

prelude exits 1; the same from the replica. s filename for saving the area labels output --removeramps remove phase ramps during unwrapping -v,–verbose switch on diagnostic messages -h,–help display this message --bogus: Option doesn’t exist!

Rejected by both

prelude exits 1; the same from the clean room. s filename for saving the area labels output --removeramps remove phase ramps during unwrapping -v,–verbose switch on diagnostic messages -h,–help display this message --bogus: Option doesn’t exist!

5/5
err/bad-numbererrors and messages-n abc
command lineprelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out -n abc
Rejected by both

prelude exits 1; the same from the replica. ame for saving the area labels output --removeramps remove phase ramps during unwrapping -v,–verbose switch on diagnostic messages -h,–help display this message -n: Couldn’t set_value! valstr=“abc”!

Rejected by both

prelude exits 1; the same from the clean room. ame for saving the area labels output --removeramps remove phase ramps during unwrapping -v,–verbose switch on diagnostic messages -h,–help display this message -n: Couldn’t set_value! valstr=“abc”!

5/5
err/stray-worderrors and messagesa word that is no option
command lineprelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out extra
Rejected by both

prelude exits 1; the same from the replica. filename for saving the area labels output --removeramps remove phase ramps during unwrapping -v,–verbose switch on diagnostic messages -h,–help display this message extra: is an unrecognised token!

Rejected by both

prelude exits 1; the same from the clean room. filename for saving the area labels output --removeramps remove phase ramps during unwrapping -v,–verbose switch on diagnostic messages -h,–help display this message extra: is an unrecognised token!

5/5
err/missing-fileerrors and messagesa phase image that does not exist
command lineprelude -p nothere -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out
Rejected by both

prelude exits -6; the same from the replica. ead volume nothere Error : No image files match: nothere terminate called after throwing an instance of ‘std::runtime_error’ what(): Failed to read volume nothere Error : No image files match: nothere

Rejected by both

prelude exits -6; the same from the clean room. ead volume nothere Error : No image files match: nothere terminate called after throwing an instance of ‘std::runtime_error’ what(): Failed to read volume nothere Error : No image files match: nothere

5/5
err/no-inputerrors and messagesneither -c nor -p and -a
command lineprelude -o out
Rejected by both

prelude exits -6; the same from the replica. e Exception : #22 :: Failed to read volume Error : No image files match: terminate called after throwing an instance of ‘std::runtime_error’ what(): Failed to read volume Error : No image files match:

Rejected by both

prelude exits -6; the same from the clean room. e Exception : #22 :: Failed to read volume Error : No image files match: terminate called after throwing an instance of ‘std::runtime_error’ what(): Failed to read volume Error : No image files match:

5/5
err/complex-empty-nameerrors and messages--complex= (an empty name)
command lineprelude --complex= -o out
Rejected by both

prelude exits 1; the same from the replica. for saving the area labels output --removeramps remove phase ramps during unwrapping -v,–verbose switch on diagnostic messages -h,–help display this message --complex: Missing non-optional argument!

Rejected by both

prelude exits 1; the same from the clean room. for saving the area labels output --removeramps remove phase ramps during unwrapping -v,–verbose switch on diagnostic messages -h,–help display this message --complex: Missing non-optional argument!

5/5
err/rangeerrors and messagesa phase range above 3pi (exit 255)
command lineprelude -p <s_range.nii.gz: synthetic 40 × 36 × 12> -a <s_mag.nii.gz: synthetic 40 × 36 × 12> -o out
Rejected by both

prelude exits 255; the same from the replica. ERROR: input phase image exceeds allowable phase range. Allowable range is 6.283 radians. Image range is: 14.1372 radians. Aborting.

Rejected by both

prelude exits 255; the same from the clean room. ERROR: input phase image exceeds allowable phase range. Allowable range is 6.283 radians. Image range is: 14.1372 radians. Aborting.

5/5
err/long-option-spaceerrors and messages--start 1 (a long option's value needs =)
command lineprelude -p <t_ph.nii.gz: synthetic, three volumes> -a <t_mag.nii.gz: synthetic, three volumes> -o out --start 1
Rejected by both

prelude exits 1; the same from the replica. e for saving the area labels output --removeramps remove phase ramps during unwrapping -v,–verbose switch on diagnostic messages -h,–help display this message --start: Missing non-optional argument!

Rejected by both

prelude exits 1; the same from the clean room. e for saving the area labels output --removeramps remove phase ramps during unwrapping -v,–verbose switch on diagnostic messages -h,–help display this message --start: Missing non-optional argument!

5/5
err/start-outsideerrors and messages--start beyond the series
command lineprelude -p <t_ph.nii.gz: synthetic, three volumes> -a <t_mag.nii.gz: synthetic, three volumes> -o out --start=5
Rejected by both

prelude exits -6; the same from the replica. Image Exception : #61 :: Invalid t index in [] operator terminate called after throwing an instance of ‘std::runtime_error’ what(): Invalid t index in [] operator

Rejected by both

prelude exits -6; the same from the clean room. Image Exception : #61 :: Invalid t index in [] operator terminate called after throwing an instance of ‘std::runtime_error’ what(): Invalid t index in [] operator

5/5
err/start-negativeerrors and messages--start=-1
command lineprelude -p <t_ph.nii.gz: synthetic, three volumes> -a <t_mag.nii.gz: synthetic, three volumes> -o out --start=-1
Rejected by both

prelude exits -6; the same from the replica. Image Exception : #61 :: Invalid t index in [] operator terminate called after throwing an instance of ‘std::runtime_error’ what(): Invalid t index in [] operator

Rejected by both

prelude exits -6; the same from the clean room. Image Exception : #61 :: Invalid t index in [] operator terminate called after throwing an instance of ‘std::runtime_error’ what(): Invalid t index in [] operator

5/5
err/end-outsideerrors and messages--end beyond the series
command lineprelude -p <t_ph.nii.gz: synthetic, three volumes> -a <t_mag.nii.gz: synthetic, three volumes> -o out --end=5 -r r
Rejected by both

prelude exits -6; the same from the replica. Image Exception : #61 :: Invalid t index in [] operator terminate called after throwing an instance of ‘std::runtime_error’ what(): Invalid t index in [] operator

Rejected by both

prelude exits -6; the same from the clean room. Image Exception : #61 :: Invalid t index in [] operator terminate called after throwing an instance of ‘std::runtime_error’ what(): Invalid t index in [] operator

5/5
err/empty-rangeerrors and messages--end before --start (FSL-270)
command lineprelude -p <t_ph.nii.gz: synthetic, three volumes> -a <t_mag.nii.gz: synthetic, three volumes> -o out --start=2 --end=1 -r r
Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages; its default, fix, refuses the call (exit 1), naming FSL-270

Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6
err/size-mismatcherrors and messagesa magnitude of another size (FSL-271)
command lineprelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag_other.nii.gz: synthetic 40 × 36 × 12> -o out -l l
Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages; its default, fix, refuses the call (exit 1), naming FSL-271

Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages

6/6
err/size-mismatch-largererrors and messagesa magnitude larger than the phase (FSL-271)
command lineprelude -p <s_ph.nii.gz: synthetic 40 × 36 × 12> -a <s_mag_larger.nii.gz: synthetic 40 × 36 × 12> -o out --savemask=m
Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages; its default, fix, refuses the call (exit 1), naming FSL-271

Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages

6/6
err/size-mismatch-sliceserrors and messagesa mask of fewer slices, labels slice by slice (FSL-271)
command lineprelude -p <b_ph.nii.gz: synthetic 72 × 70 × 8> -a <b_mag.nii.gz: synthetic 72 × 70 × 8> -m <b_mask_short.nii.gz: synthetic 72 × 70 × 8> -o out -l l
Bit-identical

every file FSL writes (5/5) byte for byte, with FSL’s exit status and messages; its default, fix, refuses the call (exit 1), naming FSL-271

Bit-identical

every file FSL writes (5/5) byte for byte, with FSL’s exit status and messages

6/6
difftest/nan-phase-verbose-noticerandom testingA NaN phase in a one-voxel mask with -v: FSL-269's correction changes only -v's lines (the size of the starting matrices); its notice compares them (found by the short check before the random-testing run: seed prelude-check, case 2928)
command lineFSLOUTPUTTYPE=NIFTI_GZ prelude --phase=<random testing's input case/fsl-prelude/nan-phase-verbose-notice/phase> --abs=<random testing's input case/fsl-prelude/nan-phase-verbose-notice/magnitude> -o uph -v
Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages; its default, fix, names FSL-269, with the same values

Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6
difftest/ramps-notice-unchangedrandom testing--removeramps with mask voxels in the last planes where FSL's loops give the same result: FSL-261's notice now fires only where the other loops change what the run writes or prints (both computed; found by the short check before the random-testing run: seed prelude-check, cases 189, 972, 1969)
command lineFSLOUTPUTTYPE=NIFTI2_GZ prelude -p <random testing's input case/fsl-prelude/ramps-notice-unchanged/phase> -a <random testing's input case/fsl-prelude/ramps-notice-unchanged/magnitude> -u uph --removeramps -r raw
Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages

Bit-identical

every file FSL writes (4/4) byte for byte, with FSL’s exit status and messages

6/6
orig-options/basicthe clean room's own: optionsthe clean room's own case: an option of the validation plan (specs/prelude.md §11) on a generated phase
command lineprelude -p ph -a mag -o o -v
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

13/13
orig-options/n2the clean room's own: optionsthe clean room's own case: an option of the validation plan (specs/prelude.md §11) on a generated phase
command lineprelude -p ph -a mag -o o -n 2 -v
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

13/13
orig-options/n3the clean room's own: optionsthe clean room's own case: an option of the validation plan (specs/prelude.md §11) on a generated phase
command lineprelude -p ph -a mag -o o -n 3
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

13/13
orig-options/n24the clean room's own: optionsthe clean room's own case: an option of the validation plan (specs/prelude.md §11) on a generated phase
command lineprelude -p ph -a mag -o o -n 24 -v
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

13/13
orig-options/t0the clean room's own: optionsthe clean room's own case: an option of the validation plan (specs/prelude.md §11) on a generated phase
command lineprelude -p ph -a mag -o o -t 0 -v
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

13/13
orig-options/t300the clean room's own: optionsthe clean room's own case: an option of the validation plan (specs/prelude.md §11) on a generated phase
command lineprelude -p ph -a mag -o o -t 300 --savemask=m
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

17/17
orig-options/maskthe clean room's own: optionsthe clean room's own case: an option of the validation plan (specs/prelude.md §11) on a generated phase
command lineprelude -p ph -a mag -m mask -o o -v --savemask=m
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

17/17
orig-options/mask-tthe clean room's own: optionsthe clean room's own case: an option of the validation plan (specs/prelude.md §11) on a generated phase
command lineprelude -p ph -a mag -m mask -t 0.2 -o o --savemask=m
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

17/17
orig-options/maskgapthe clean room's own: optionsthe clean room's own case: an option of the validation plan (specs/prelude.md §11) on a generated phase
command lineprelude -p ph -a mag -m maskgap -o o -v --savemask=m -l lab
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

21/21
orig-options/slicesthe clean room's own: optionsthe clean room's own case: an option of the validation plan (specs/prelude.md §11) on a generated phase
command lineprelude -p ph -a mag -o o -s -v --savemask=m -l lab -r raw
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

25/25
orig-options/labelslicesthe clean room's own: optionsthe clean room's own case: an option of the validation plan (specs/prelude.md §11) on a generated phase
command lineprelude -p ph -a mag -o o --labelslices -v -l lab
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

17/17
orig-options/force3d-slicesthe clean room's own: optionsthe clean room's own case: an option of the validation plan (specs/prelude.md §11) on a generated phase
command lineprelude -p ph -a mag -o o -s -f -v
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

13/13
orig-options/rampsthe clean room's own: optionsthe clean room's own case: an option of the validation plan (specs/prelude.md §11) on a generated phase
command lineprelude -p ph -a mag -o o --removeramps -v -r raw -l lab --savemask=m
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

28/28
orig-options/ramps-slicesthe clean room's own: optionsthe clean room's own case: an option of the validation plan (specs/prelude.md §11) on a generated phase
command lineprelude -p ph -a mag -o o -s --removeramps -v -r raw -l lab --savemask=m
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

28/28
orig-options/ramps-labelslicesthe clean room's own: optionsthe clean room's own case: an option of the validation plan (specs/prelude.md §11) on a generated phase
command lineprelude -p ph -a mag -o o --labelslices --removeramps -r raw
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

18/18
orig-options/ramps-noverbosethe clean room's own: optionsthe clean room's own case: an option of the validation plan (specs/prelude.md §11) on a generated phase
command lineprelude -p ph -a mag -o o --removeramps -r raw
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

18/18
orig-options/grotthe clean room's own: optionsthe clean room's own case: an option of the validation plan (specs/prelude.md §11) on a generated phase
command lineprelude -p ph -a mag -o o -v --removeramps
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

16/16
orig-options/long-namesthe clean room's own: optionsthe clean room's own case: an option of the validation plan (specs/prelude.md §11) on a generated phase
command lineprelude --phase=ph --abs=mag --unwrap=o --numphasesplit=5 --thresh=100 --rawphase=raw --labels=lab --verbose
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

21/21
orig-options/u-groupedthe clean room's own: optionsthe clean room's own case: an option of the validation plan (specs/prelude.md §11) on a generated phase
command lineprelude -p ph -a mag -u o -fvn 4
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

13/13
orig-images/one-slicethe clean room's own: imagesthe clean room's own case: an image the validation plan names (sizes, types, orientation, series, complex images, the time step)
command lineprelude -p ph1 -a mag1 -o o -v -l lab
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

17/17
orig-images/one-slice-rampsthe clean room's own: imagesthe clean room's own case: an image the validation plan names (sizes, types, orientation, series, complex images, the time step)
command lineprelude -p ph1 -a mag1 -o o --removeramps -v -r raw
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

20/20
orig-images/one-slice-sthe clean room's own: imagesthe clean room's own case: an image the validation plan names (sizes, types, orientation, series, complex images, the time step)
command lineprelude -p ph1 -a mag1 -o o -s -v
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

13/13
orig-images/widethe clean room's own: imagesthe clean room's own case: an image the validation plan names (sizes, types, orientation, series, complex images, the time step)
command lineprelude -p phwide -a magwide -o o -v -l lab
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

17/17
orig-images/wide-fthe clean room's own: imagesthe clean room's own case: an image the validation plan names (sizes, types, orientation, series, complex images, the time step)
command lineprelude -p phwide -a magwide -o o -f -v -l lab
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

17/17
orig-images/neurothe clean room's own: imagesthe clean room's own case: an image the validation plan names (sizes, types, orientation, series, complex images, the time step)
command lineprelude -p phneuro -a magneuro -o o -v --savemask=m -l lab -r raw
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

25/25
orig-images/neuro-rampsthe clean room's own: imagesthe clean room's own case: an image the validation plan names (sizes, types, orientation, series, complex images, the time step)
command lineprelude -p phneuro -a magneuro -o o --removeramps -r raw
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

18/18
orig-images/int16-slopethe clean room's own: imagesthe clean room's own case: an image the validation plan names (sizes, types, orientation, series, complex images, the time step)
command lineprelude -p phint -a mag -o o -v -r raw
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

17/17
orig-images/rewrapthe clean room's own: imagesthe clean room's own case: an image the validation plan names (sizes, types, orientation, series, complex images, the time step)
command lineprelude -p ph2pi -a mag -o o -v -r raw
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

17/17
orig-images/seriesthe clean room's own: imagesthe clean room's own case: an image the validation plan names (sizes, types, orientation, series, complex images, the time step)
command lineprelude -p ph3 -a mag3 -o o -v --savemask=m -l lab -r raw
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

26/26
orig-images/series-startthe clean room's own: imagesthe clean room's own case: an image the validation plan names (sizes, types, orientation, series, complex images, the time step)
command lineprelude -p ph3 -a mag3 -o o --start=1 -v
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

13/13
orig-images/series-start-endthe clean room's own: imagesthe clean room's own case: an image the validation plan names (sizes, types, orientation, series, complex images, the time step)
command lineprelude -p ph3 -a mag3 -o o --start=1 --end=1 -r raw
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

17/17
orig-images/series-mask2the clean room's own: imagesthe clean room's own case: an image the validation plan names (sizes, types, orientation, series, complex images, the time step)
command lineprelude -p ph3 -a mag3 -m mask2 -o o -v --savemask=m
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

18/18
orig-images/series-short-magthe clean room's own: imagesthe clean room's own case: an image the validation plan names (sizes, types, orientation, series, complex images, the time step)
command lineprelude -p ph3 -a mag -o o -v --savemask=m -l lab
–Rejected by both

both stop (exit -6): what(): Invalid t index in [] operator

15/16
orig-images/complexthe clean room's own: imagesthe clean room's own case: an image the validation plan names (sizes, types, orientation, series, complex images, the time step)
command lineprelude -c cplx -o o -v --savemask=m -l lab -r raw
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages; by default GLIBC-07 (the correctly rounded arctangent of a complex value against glibc’s atan2f), against the replica’s default: lab.nii.gz (labels) the same; o.nii.gz (the replica’s integer offsets) on 100 % of the mask’s voxels; raw.nii.gz (raw phase): 282 values differ in their last bits

26/26
orig-images/complex-bethe clean room's own: imagesthe clean room's own case: an image the validation plan names (sizes, types, orientation, series, complex images, the time step)
command lineprelude -c cplxbe -o o -v
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages; by default GLIBC-07 (the correctly rounded arctangent of a complex value against glibc’s atan2f), against the replica’s default: o.nii.gz (the replica’s integer offsets) on 100 % of the mask’s voxels

14/14
orig-images/complex128the clean room's own: imagesthe clean room's own case: an image the validation plan names (sizes, types, orientation, series, complex images, the time step)
command lineprelude -c cplx128 -o o -v
–Expected divergence

FSL’s values come from memory it never wrote (FSL-265: a complex128 image, which FSL reads with no width, from memory past an empty buffer): the record compares its exit status, messages and file names, each FSL’s; the default, fix, is checked against the replica’s default

11/11
orig-images/complex-float32the clean room's own: imagesthe clean room's own case: an image the validation plan names (sizes, types, orientation, series, complex images, the time step)
command lineprelude -c notcplx -o o -v
–Expected divergence

FSL’s values come from memory it never wrote (FSL-263: an image that is not complex given to -c, whose bytes FSL reads as complex values past the buffer): the record compares its exit status, messages and file names, each FSL’s; the default, fix, is checked against the replica’s default

9/9
orig-images/complex-int16the clean room's own: imagesthe clean room's own case: an image the validation plan names (sizes, types, orientation, series, complex images, the time step)
command lineprelude -c notcplx16 -o o
–Expected divergence

FSL’s values come from memory it never wrote (FSL-263: an image that is not complex given to -c, whose bytes FSL reads as complex values past the buffer): the record compares its exit status, messages and file names, each FSL’s; the default, fix, is checked against the replica’s default

9/9
orig-images/size-bigthe clean room's own: imagesthe clean room's own case: an image the validation plan names (sizes, types, orientation, series, complex images, the time step)
command lineprelude -p ph -a magbig -o o -v --savemask=m
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

14/14
orig-images/size-smallthe clean room's own: imagesthe clean room's own case: an image the validation plan names (sizes, types, orientation, series, complex images, the time step)
command lineprelude -p ph -a magsmall -o o -v --savemask=m
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

14/14
orig-images/size-maskthe clean room's own: imagesthe clean room's own case: an image the validation plan names (sizes, types, orientation, series, complex images, the time step)
command lineprelude -p ph -a mag -m magsmall -o o --savemask=m
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

14/14
orig-images/time-step-zerothe clean room's own: imagesthe clean room's own case: an image the validation plan names (sizes, types, orientation, series, complex images, the time step)
command lineprelude -p ph3tr0 -a mag3 -o o -r raw -l lab --savemask=m
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

26/26
orig-images/time-step-negativethe clean room's own: imagesthe clean room's own case: an image the validation plan names (sizes, types, orientation, series, complex images, the time step)
command lineprelude -p ph3 -a mag3trneg -o o --savemask=m -m mag3trneg
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

18/18
orig-images/time-step-one-volumethe clean room's own: imagesthe clean room's own case: an image the validation plan names (sizes, types, orientation, series, complex images, the time step)
command lineprelude -p ph3tr0 -a mag3trneg -o o --start=1 --end=1 -r raw --savemask=m
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

21/21
orig-images/time-step-3dthe clean room's own: imagesthe clean room's own case: an image the validation plan names (sizes, types, orientation, series, complex images, the time step)
command lineprelude -p phtrneg -a mag -o o -r raw
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

17/17
orig-images/time-step-4d-onethe clean room's own: imagesthe clean room's own case: an image the validation plan names (sizes, types, orientation, series, complex images, the time step)
command lineprelude -p ph1vol -a mag1vol -o o --savemask=m
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

17/17
orig-images/time-step-complexthe clean room's own: imagesthe clean room's own case: an image the validation plan names (sizes, types, orientation, series, complex images, the time step)
command lineprelude -c cplx2trneg -o o -r raw --savemask=m
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages; by default GLIBC-07 (the correctly rounded arctangent of a complex value against glibc’s atan2f), against the replica’s default: o.nii.gz (the replica’s integer offsets) on 100 % of the mask’s voxels; raw.nii.gz (raw phase): 564 values differ in their last bits

22/22
orig-images/time-step-complex-zerothe clean room's own: imagesthe clean room's own case: an image the validation plan names (sizes, types, orientation, series, complex images, the time step)
command lineprelude -c cplx2tr0 -o o --savemask=m
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages; by default GLIBC-07 (the correctly rounded arctangent of a complex value against glibc’s atan2f), against the replica’s default: o.nii.gz (the replica’s integer offsets) on 100 % of the mask’s voxels

18/18
orig-nan/mag-firstthe clean room's own: NaN valuesthe clean room's own case: NaN values in the magnitude or the phase
command lineprelude -p ph -a magnanfirst -o o -v --savemask=m
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

18/18
orig-nan/mag-insidethe clean room's own: NaN valuesthe clean room's own case: NaN values in the magnitude or the phase
command lineprelude -p ph -a magnaninside -o o -v --savemask=m
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

17/17
orig-nan/mag-first-sthe clean room's own: NaN valuesthe clean room's own case: NaN values in the magnitude or the phase
command lineprelude -p ph -a magnanfirst -o o -s -v --savemask=m
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

18/18
orig-nan/phase-firstthe clean room's own: NaN valuesthe clean room's own case: NaN values in the magnitude or the phase
command lineprelude -p phnanfirst -a mag -o o -v
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

13/13
orig-nan/phase-first-2pithe clean room's own: NaN valuesthe clean room's own case: NaN values in the magnitude or the phase
command lineprelude -p ph2pinanfirst -a mag -o o -v -r raw
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

18/18
orig-nan/phase-insidethe clean room's own: NaN valuesthe clean room's own case: NaN values in the magnitude or the phase
command lineprelude -p phnaninside -a mag -o o -v --savemask=m -l lab -r raw
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

26/26
orig-nan/phase-inside-sthe clean room's own: NaN valuesthe clean room's own case: NaN values in the magnitude or the phase
command lineprelude -p phnaninside -a mag -o o -s -v -l lab
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

18/18
orig-nan/phase-inside-rampsthe clean room's own: NaN valuesthe clean room's own case: NaN values in the magnitude or the phase
command lineprelude -p phnaninside -a mag -o o --removeramps -v -r raw
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

20/20
orig-errors/end-before-startthe clean room's own: failuresthe clean room's own case: a failure of the command line or of the input
command lineprelude -p ph3 -a mag3 -o o --start=2 --end=1 -r raw
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

12/12
orig-errors/end-before-start-outsidethe clean room's own: failuresthe clean room's own case: a failure of the command line or of the input
command lineprelude -p ph3 -a mag3 -o o --start=4 --end=1
–Rejected by both

both stop (exit -6): what(): Invalid t index in [] operator

11/12
orig-errors/complex-as-phasethe clean room's own: failuresthe clean room's own case: a failure of the command line or of the input
command lineprelude -p cplx -a mag -o o
–Rejected by both

both stop (exit -6): what(): Fslread: DT 32 not supported

11/12
orig-errors/complex-as-maskthe clean room's own: failuresthe clean room's own case: a failure of the command line or of the input
command lineprelude -p ph -a mag -m cplx -o o
–Rejected by both

both stop (exit -6): what(): Fslread: DT 32 not supported

11/12
orig-errors/rangethe clean room's own: failuresthe clean room's own case: a failure of the command line or of the input
command lineprelude -p phrange -a mag -o o -v
–Rejected by both

both stop (exit 255): Aborting.

9/9
orig-errors/no-dirthe clean room's own: failuresthe clean room's own case: a failure of the command line or of the input
command lineprelude -p ph -a mag -o nodir/o -v
–Rejected by both

both stop (exit -6): what(): Error: cant open file nodir/o.nii.gz

11/12
orig-types/pairthe clean room's own: output typesthe clean room's own case: an output type (FSLOUTPUTTYPE) (FSLOUTPUTTYPE=NIFTI_PAIR)
command lineprelude -p ph -a mag -o o -l lab --savemask=m -r raw
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

25/25
orig-types/pair-gzthe clean room's own: output typesthe clean room's own case: an output type (FSLOUTPUTTYPE) (FSLOUTPUTTYPE=NIFTI_PAIR_GZ)
command lineprelude -p ph -a mag -o o -l lab
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

17/17
orig-types/pair-zstthe clean room's own: output typesthe clean room's own case: an output type (FSLOUTPUTTYPE) (FSLOUTPUTTYPE=NIFTI_PAIR_ZST)
command lineprelude -p ph -a mag -o o --savemask=m
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

17/17
orig-types/nifti2-pair-bz2the clean room's own: output typesthe clean room's own case: an output type (FSLOUTPUTTYPE) (FSLOUTPUTTYPE=NIFTI2_PAIR_BZ2)
command lineprelude -p ph -a mag -o o -l lab
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

17/17
orig-types/nifti2-gzthe clean room's own: output typesthe clean room's own case: an output type (FSLOUTPUTTYPE) (FSLOUTPUTTYPE=NIFTI2_GZ)
command lineprelude -p ph -a mag -o o --savemask=m
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

17/17
orig-types/nifti-zstthe clean room's own: output typesthe clean room's own case: an output type (FSLOUTPUTTYPE) (FSLOUTPUTTYPE=NIFTI_ZST)
command lineprelude -p ph -a mag -o o -r raw
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

17/17
orig-types/unsetthe clean room's own: output typesthe clean room's own case: an output type (FSLOUTPUTTYPE) (FSLOUTPUTTYPE=None)
command lineprelude -p ph -a mag -o o -v --savemask=m
–Rejected by both

both stop (exit 1): e.g. tcsh or csh users add the line “source ${FSLDIR}/etc/fslconf/fsl.csh”

14/14
orig-types/bogusthe clean room's own: output typesthe clean room's own case: an output type (FSLOUTPUTTYPE) (FSLOUTPUTTYPE=bogus)
command lineprelude -p ph -a mag -o o -v --savemask=m
–Rejected by both

both stop (exit 1): Legal values are: NIFTI, NIFTI_PAIR, NIFTI2, NIFTI2_PAIR, NIFTI_GZ, NIFTI_PAIR_GZ, NIFTI2_GZ, NIFTI2_PAIR_GZ, NIFTI_ZST, NIFTI_PAIR_ZST, NIFTI2_ZST, NIFTI2_PAIR_ZST, NIFTI_BZ2, NIFTI_PAIR_BZ2, NIFTI2_

9/10
orig-fmriprep/ds001600-sub-1-noreconall/wf_auto_00000 worked examplethe clean room's own: fMRIPrep's callsfMRIPrep 25.2.6's call on ds001600-sub-1-noreconall/wf_auto_00000, run three ways: FSL, the clean room in fix and in reproduce, the replica's default
command lineprelude --abs=<sdcflows' clipped magnitude> --mask=<sdcflows' brain mask> --phase=<the phase difference in rad> --unwrap=sub-1_acq-v1_phase1_rads_phdiff_unwrapped.nii.gz
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

15/15
orig-fmriprep/ds001600-sub-1-noreconall/wf_auto_00001 worked examplethe clean room's own: fMRIPrep's callsfMRIPrep 25.2.6's call on ds001600-sub-1-noreconall/wf_auto_00001, run three ways: FSL, the clean room in fix and in reproduce, the replica's default
command lineprelude --abs=<sdcflows' clipped magnitude> --mask=<sdcflows' brain mask> --phase=<the phase difference in rad> --unwrap=sub-1_acq-v2_phase1_rads_phdiff_unwrapped.nii.gz
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

15/15
orig-fmriprep/ds001600-sub-1-noreconall/wf_auto_00002 worked examplethe clean room's own: fMRIPrep's callsfMRIPrep 25.2.6's call on ds001600-sub-1-noreconall/wf_auto_00002, run three ways: FSL, the clean room in fix and in reproduce, the replica's default
command lineprelude --abs=<sdcflows' clipped magnitude> --mask=<sdcflows' brain mask> --phase=<the phase difference in rad> --unwrap=sub-1_acq-v4_phasediff_rads_unwrapped.nii.gz
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

15/15
orig-fmriprep/ds002422-sub-02-noreconall/wf_auto_00000 worked examplethe clean room's own: fMRIPrep's callsfMRIPrep 25.2.6's call on ds002422-sub-02-noreconall/wf_auto_00000, run three ways: FSL, the clean room in fix and in reproduce, the replica's default
command lineprelude --abs=<sdcflows' clipped magnitude> --mask=<sdcflows' brain mask> --phase=<the phase difference in rad> --unwrap=sub-02_run-01_phasediff_rads_unwrapped.nii.gz
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

15/15
orig-fmriprep/ds002422-sub-02-noreconall/wf_auto_00001 worked examplethe clean room's own: fMRIPrep's callsfMRIPrep 25.2.6's call on ds002422-sub-02-noreconall/wf_auto_00001, run three ways: FSL, the clean room in fix and in reproduce, the replica's default
command lineprelude --abs=<sdcflows' clipped magnitude> --mask=<sdcflows' brain mask> --phase=<the phase difference in rad> --unwrap=sub-02_run-02_phasediff_rads_unwrapped.nii.gz
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

15/15
orig-fmriprep/ds002603-sub-01-noreconall/wf_auto_00000 worked examplethe clean room's own: fMRIPrep's callsfMRIPrep 25.2.6's call on ds002603-sub-01-noreconall/wf_auto_00000, run three ways: FSL, the clean room in fix and in reproduce, the replica's default
command lineprelude --abs=<sdcflows' clipped magnitude> --mask=<sdcflows' brain mask> --phase=<the phase difference in rad> --unwrap=sub-01_acq-Mm2_phasediff_rads_unwrapped.nii.gz
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

15/15
orig-fmriprep/ds005454-sub-16-noreconall/wf_gre16 worked examplethe clean room's own: fMRIPrep's callsfMRIPrep 25.2.6's call on ds005454-sub-16-noreconall/wf_gre16, run three ways: FSL, the clean room in fix and in reproduce, the replica's default
command lineprelude --abs=<sdcflows' clipped magnitude> --mask=<sdcflows' brain mask> --phase=<the phase difference in rad> --unwrap=sub-16_phasediff_rads_unwrapped.nii.gz
–Bit-identical

every file FSL writes byte for byte, with FSL’s exit status and messages

15/15
difftest/time-step-zero-seriesrandom testingrandom testing's permanent case: random testing: every file bit-identical–Bit-identical

every file FSL writes (3/3) byte for byte, with FSL’s exit status and messages

6/6

Speed

FSL’s prelude runs on one thread and spends its time in the merging, which scans every boundary sum for each choice: 6.7 s for fMRIPrep’s call on ds005454 (14,678 regions) and 28.4 s on ds002603.

  • The clean room takes 0.069 s and 0.135 s on one thread, 97 and 211 times FSL’s speed and 2.5 and 2.8 times the replica’s; 0.053 s and 0.103 s on 12.
  • On a generated 128³ map of 66,020 regions it takes 0.30 s against FSL’s 184 s (610 times), with 59 MiB against FSL’s 64 MiB.
  • On a 256 × 256 × 160 map of 152,738 regions it takes 2.0 s, where the replica takes 9.4 s and 469 MiB.
  • On fMRIPrep’s small calls every program’s time is mostly its start and its reading and writing.

These timings come from the report: the best of five runs of each call, FSL once, on a machine shared with other work. Every output was checked bit for bit.

Speed, both ports against the original: FSL prelude 6.0.7.23

Seconds for the whole call (reading the images, unwrapping, writing the output), the best of several runs, on a log scale. The factor is how many times faster the clean room is than FSL, both on one thread.

  • FSL prelude 6.0.7.23, 1 thread
  • replica, 1 thread
  • clean room, 1 thread
  • clean room, 12 threads
  1. fMRIPrep's call, ds002603-sub-01 (wf_auto_00000)FSL prelude 6.0.7.23, 1 thread 28.4 sreplica, 1 thread 0.374 sclean room, 1 thread 0.135 sclean room, 12 threads 0.103 s2.1e2×
  2. fMRIPrep's call, ds005454-sub-16 (wf_gre16)FSL prelude 6.0.7.23, 1 thread 6.68 sreplica, 1 thread 0.173 sclean room, 1 thread 0.0688 sclean room, 12 threads 0.0528 s97×
  3. fMRIPrep's call, ds001600-sub-1 (wf_auto_00001)FSL prelude 6.0.7.23, 1 thread 0.0904 sreplica, 1 thread 0.0181 sclean room, 1 thread 0.016 sclean room, 12 threads 0.0143 s5.6×
  4. fMRIPrep's call, ds001600-sub-1 (wf_auto_00000)FSL prelude 6.0.7.23, 1 thread 0.0818 sreplica, 1 thread 0.0162 sclean room, 1 thread 0.0153 sclean room, 12 threads 0.0146 s5.3×
  5. fMRIPrep's call, ds001600-sub-1 (wf_auto_00002)FSL prelude 6.0.7.23, 1 thread 0.0811 sreplica, 1 thread 0.0166 sclean room, 1 thread 0.0141 sclean room, 12 threads 0.0133 s5.8×
  6. fMRIPrep's call, ds002422-sub-02 (wf_auto_00000)FSL prelude 6.0.7.23, 1 thread 0.0684 sreplica, 1 thread 0.0095 sclean room, 1 thread 0.0103 sclean room, 12 threads 0.0105 s6.6×
  7. fMRIPrep's call, ds002422-sub-02 (wf_auto_00001)FSL prelude 6.0.7.23, 1 thread 0.0605 sreplica, 1 thread 0.0142 sclean room, 1 thread 0.0123 sclean room, 12 threads 0.0114 s4.9×
  8. a generated map, 128 × 128 × 128 voxels (66,020 regions)FSL prelude 6.0.7.23, 1 thread 184 sreplica, 1 thread 1.36 sclean room, 1 thread 0.3 sclean room, 12 threads 0.24 s6.1e2×
  9. a generated map, 256 × 256 × 160 voxels (152,738 regions)replica, 1 thread 9.41 sclean room, 1 thread 1.97 sclean room, 12 threads 2.56 s
0.001 s0.01 s0.1 s1 s10 s100 s1000 s

From the benchmark report docs/benchmarks/fsl-prelude.md (the main machine: AMD Ryzen 9 7945HX, 16 cores / 32 threads): fMRIPrep’s calls the best of five runs (FSL once), the generated maps the best of three (FSL once, on the 128³ map only); the machine was shared with other work. FSL’s prelude and the replica run on one thread; the clean room’s output is the same bits at 1 and 12 threads.

Wall-clock seconds and peak memory, both ports against the original: FSL prelude 6.0.7.23 (the benchmark report)

CallFSL 6.0.7.23replica (1 thread)clean room (1 thread)clean room (12 threads)Result
fMRIPrep’s call, ds002603-sub-01 (wf_auto_00000)28.4 s0.374 s0.135 s0.103 severy output FSL’s bit for bit
fMRIPrep’s call, ds005454-sub-16 (wf_gre16)6.68 s0.173 s0.0688 s0.0528 severy output FSL’s bit for bit
fMRIPrep’s call, ds001600-sub-1 (wf_auto_00001)0.0904 s0.0181 s0.016 s0.0143 severy output FSL’s bit for bit
fMRIPrep’s call, ds001600-sub-1 (wf_auto_00000)0.0818 s0.0162 s0.0153 s0.0146 severy output FSL’s bit for bit
fMRIPrep’s call, ds001600-sub-1 (wf_auto_00002)0.0811 s0.0166 s0.0141 s0.0133 severy output FSL’s bit for bit
fMRIPrep’s call, ds002422-sub-02 (wf_auto_00000)0.0684 s0.0095 s0.0103 s0.0105 severy output FSL’s bit for bit
fMRIPrep’s call, ds002422-sub-02 (wf_auto_00001)0.0605 s0.0142 s0.0123 s0.0114 severy output FSL’s bit for bit
a generated map, 128 × 128 × 128 voxels (66,020 regions)184 s, 64 MiB1.36 s, 117 MiB0.3 s, 59 MiB0.24 s, 75 MiBeach program’s output the same bits
a generated map, 256 × 256 × 160 voxels (152,738 regions)not run9.41 s, 469 MiB1.97 s, 210 MiB2.56 s, 211 MiBeach program’s output the same bits

The benchmark report docs/benchmarks/fsl-prelude.md: wall-clock seconds of the whole program (the best of five runs of each fMRIPrep call, of three on the generated maps; FSL once) and on the generated maps the peak resident memory (/usr/bin/time -v), on the main machine with other work beside it. The memory rule (at most 10 % above FSL’s peak plus 8 MiB) is checked at one thread by tests/parity/test_memory_peak.py: fMRIPrep’s call and the 128³ map, as it is and with -s.

Corrections by default

Both ports correct FSL’s deterministic defects by default, fix, and warn. The clean room names the same entries as the replica, and its fix is the replica’s bit for bit but for GLIBC-07 (below). upstream_defects="reproduce" (on the command line --upstream-defects reproduce from the next release, LARMORX_UPSTREAM_DEFECTS=reproduce in 0.1.0rc1) gives FSL’s behaviour byte for byte, where FSL’s behaviour is defined (register).

  • The ramps are taken over every column, row and slice (FSL-261, above).
  • With several volumes, --savemask and -l write one series of every volume’s masks and labels (FSL-262: FSL writes each volume’s to the same file in turn, so only the last is kept).
  • -c with an image that is not complex is refused (FSL-263: FSL reads its bytes as complex values, past the buffer for 16-bit data).
  • A big-endian complex image has each value’s two parts swapped on their own (FSL-264: FSL swaps the eight bytes as one, so the real and imaginary parts change places).
  • A complex128 image is read as such (FSL-265: FSL reads it with no width, from memory past an empty buffer).
  • -v with ramps writes no grot file into the working directory (FSL-266).
  • NaN magnitudes stay out of the threshold’s percentiles and the maximum (FSL-268: in FSL a NaN first voxel empties the mask). NaN phases inside the mask stay out of it and come back as NaN in the output (FSL-269: in FSL a region labelled with a NaN voxel moves by about 231 cycles).
  • --end before --start, which FSL accepts without writing anything (exit status 0), is refused with a reason (FSL-270); so is a magnitude or mask of another size than the phase, which FSL reads by the phase’s indices (FSL-271).
  • The phase’s extrema are taken over its numbers (FSL-272, above).
  • FSL’s two messages that say otherwise than it does (the range allowed, “Removed linear ramps” printed twice) are kept as FSL prints them (FSL-267).

The clean room computes a complex image’s phase with the correctly rounded arctangent on every platform by default. glibc’s atan2f (FSL’s build, and the replica’s) is now and then one unit in the last place from the exact value rounded once. The clean room’s reproduce computes it as glibc 2.35 does, and its fix names GLIBC-07 wherever the two differ on a voxel: the unwrapped phase keeps FSL’s whole cycles, and a few phases differ in their last bit.

Known limits

Both ports are experimental. Each record’s standard comparison holds fMRIPrep’s calls on four fMRIPrep runs and the data panel’s two other phase-difference maps. The full comparisons and the long random-testing runs come in the final validation phase.

Where FSL’s result comes from memory it does not own (a NaN in the sorts of FSL-268 and FSL-269 that reaches outside the values, FSL-263’s and FSL-265’s complex values), both ports refuse in reproduce or fill the values deterministically, with a notice. The records then compare the exit status, the messages and the file names only.

The clean room’s random-testing run left two questions for its specification (above): FSL’s residual in the offsets it writes back for an oblique image, and FSL-271’s reading in the slices mode.

The cross-platform checks (how they work) hold the other five platforms to LARMORX’s own Linux output.

History

  • 2026-11-06: the replica, translated from FSL 6.0.7.23’s source, with every option, message and failure case; twelve defects of FSL found (FSL-261 to FSL-272), eleven of them corrected by default or refused. Its random-testing run, 50,711 calls in 30 minutes.
  • 2026-11-06 and 07: the clean room, written from specs/prelude.md, Jenkinson’s paper, FSL’s usage text and runs of FSL; its first record and its random-testing run (2026-11-06), 23,780 calls in 30 minutes; the permanent case difftest/time-step-zero-series from its triage.
  • 2026-11-11: the clean room’s record made again: every case as before but orig-types/unset (14 of 14 checks, FSL-11 now named), and the files of its own cases in fix 252 of 252 the replica’s bit for bit (248 of 248 before).

Data credits

The data this page shows or names: each dataset with its version, DOI and licence, from LARMORX's test-data catalog. Public-domain dedications (CC0, PDDL) ask nothing; the datasets are cited all the same.