v1.0.0.rc-162 (#72)

**Files written by Jungfraujoch now import correctly in DIALS, XDS and pyFAI.** A tilted detector, a grid scan, a still recorded at a goniometer position, and saturated or unreadable pixels were each described in a way that a third-party program acted on wrongly. If you process Jungfraujoch data outside Jungfraujoch, prefer this release to any earlier one.

* HDF5: the detector tilt (`rot1`/`rot2`/`rot3`) is exported correctly in the NXmx transformation chain; untilted geometries are unaffected.
* HDF5: a still recorded at a goniometer position is no longer read back as a single image, and a grid scan records a stationary spindle so a program that requires a rotation axis can open it.
* HDF5: the sample transformation chain is written in mounting order, with a Smargon head position told apart from the spindle, one entry per image, `module_offset` as a float unit vector, and `offset_units` on every offset.
* HDF5: saturated, underloaded and unreadable pixels are described so a downstream program masks them - `saturation_value`, `underload_value`, `error_value` and `bit_depth_readout` are written correctly, and a data file missing next to a VDS master reads as the error marker rather than as zero counts.
* HDF5: the rotation axis is read back under whatever name it carries, and `mirror_y` records whether the assembled image is mirrored in Y relative to the detector's raw readout.
* A grid scan and a goniometer axis can both be set; they are no longer alternatives.
* `images_per_file` is chosen from the acquisition when it is not given: a rotation sweep of at most 20000 images goes into a single data file, a grid scan splits on whole fast-axis rows, and stills and serial keep 1000.
* The writer refuses a stream whose start message declares a different pixel format than its images carry, and a DECTRIS detector sending signed images is no longer declared unsigned.
* The image stream can carry the sample transformation chain (`transformations`, in the END message); a producer that does not send it gets the same chain built by the writer.
* rugnux: fixing the space group with `-S` no longer prevents the lattice from being found - a lattice indexed in a different setting is reindexed into that group's own setting, and a run whose crystal does not have that group's lattice stops and names the cell it indexed as, rather than reporting statistics that cannot describe it.
* rugnux: the per-image resolution estimate now predicts the resolution the merged data reach rather than the highest-resolution spot found, and is reported as `SPOT_RESOLUTION_ESTIMATE`.
* rugnux: two runs of the same command on the same images produce the same merged intensities; the azimuthal profile written alongside them is not yet reproducible in the same way.
* rugnux: the offline lattice refinement is bounded by iterations rather than by a wall clock, so a loaded machine can no longer refine to a different lattice; a live acquisition keeps its real-time bound.
* rugnux: the detector-frame modulation correction is fitted on a grid spanning the detector, so whether it is applied no longer depends on how far integration reached.
* rugnux: the geometry pre-pass no longer writes `<prefix>_01.mtz`, `_01.cif`, `_01.hkl` and `_01_image.dat`; the refined second pass writes those files under `<prefix>`, and that is the result to use.
* rugnux: `_process.h5` describes the pixel format of the images it links to, and is written on a thread of its own.
* rugnux: the detector geometry is also logged in XDS's convention (`ORGX`/`ORGY`, detector axis vectors, rotation axis), so it can be compared with an XDS refinement.
* rugnux: an image integrated in pyFAI through the `.poni` file written by `--mode calibration` comes out with the correct azimuth, and the file declares pyFAI's `orientation`, which needs pyFAI 2024.01 or newer. Radial integration is unchanged.
* rugnux: a rotation run is substantially faster throughout - beam-stop detection, first-pass indexing, geometry refinement, integration, scaling and merging - and observations outside the scaling resolution range are dropped as they are ingested. The refined geometry, the space group chosen and the merged statistics are unchanged.
* Faster spot finding and indexing, on the broker as well as in rugnux; the spots found and the lattices indexed are unchanged.
* A run reserves substantially less GPU memory: nothing is allocated for buffers that are never read, and a worker builds only the engines it uses.
* rugnux: with `-N` left at its default the per-image loop of `--mode mx` uses at most 16 workers per GPU, rather than one per hardware thread; an explicit `-N` is obeyed as given.
* CUDA 12 builds now contain device code for Volta, so the RHEL 8 packages and the portable Linux `.tgz` run on a V100; the CUDA 13 artefacts (RHEL 9, Ubuntu, Windows) remain Turing and newer.
* The build resolves a single Eigen for the whole project, and refuses to configure if Ceres picks up a different one; a build that mixed two Eigen versions was undefined behaviour and crashed at -O2.
* Documentation: a security page, and the supported GPU generations and minimum NVIDIA driver version of every released artefact.

**Breaking change to OpenAPI** - regenerate the client (`jfjoch-client` 1.0.0-rc.162, `frontend/src/client`):
* `dataset_settings.images_per_file` is no longer `default: 1000` and no longer accepts `0`; it is optional, and its minimum is 1. A client sending `0` (previously "one file for the whole run") is now rejected - omit the field instead, which for a rotation sweep gives the same single file.
* `file_writer_format` now defaults to `NXmxVDS`, matching the server's own default and the layout recommended for DIALS, XDS and CrystFEL. A generated client that fills in schema defaults and does not set the format explicitly will write VDS masters where it previously wrote legacy ones; set `NXmxLegacy` explicitly to keep them.

---------

Co-authored-by: jungfrau <jungfrau@mx-aare-test.psi.ch>
Reviewed-on: #72
Co-authored-by: Filip Leonarski <filip.leonarski@psi.ch>

image_analysis/image_preprocessing/BSLZ4DecoderGPU.h

@@ -16,15 +16,21 @@ struct BSLZ4BlockDesc {
     uint32_t nelem;     // elements in this block (the last one is usually shorter)
 };
 
-// What DecodeShuffled() leaves on the device: the LZ4 output, still bitshuffled, plus everything the
-// un-transpose needs to finish the image. The tail is the handful of elements bitshuffle stores
-// verbatim; it is already on the device inside the uploaded chunk, so it is handed over as a device
-// pointer rather than copied again from the host.
+// One chunk, on the device, with everything the rest of the decode needs to finish the image. The
+// tail is the handful of elements bitshuffle stores verbatim; it is already on the device inside the
+// uploaded chunk, so it is handed over as a device pointer rather than copied again from the host.
+//
+// DecodeShuffled() fills in `shuffled` - the LZ4 output, still bitshuffled. UploadCompressed()
+// leaves it null and hands over `compressed` and `status` instead, so the caller can run the LZ4
+// pass itself.
 struct BSLZ4ShuffledImage {
     const uint8_t *shuffled = nullptr;
+    const uint8_t *compressed = nullptr;   // the uploaded chunk; desc[].in_off indexes into it
     const BSLZ4BlockDesc *desc = nullptr;
+    uint32_t *status = nullptr;            // where a caller-run LZ4 pass flags a bad block
     int nblocks = 0;
     uint32_t elem_size = 0;
+    uint32_t block_bytes = 0;              // uncompressed bytes in a full bitshuffle block
     const uint8_t *tail_src = nullptr;
     uint32_t tail_elems = 0;
     uint32_t tail_elem0 = 0;    // index of the first tail element in the image
@@ -73,19 +79,39 @@ class BSLZ4DecoderGPU {
     size_t max_blocks = 0;
 
     void EnsureCompressedCapacity(size_t bytes);
+    void EnsureUncompressedCapacity(size_t bytes);
     void EnsureBlockCapacity(size_t nblocks);
 
+    // Scan the container and upload it, stopping short of decoding the blocks.
+    BSLZ4ShuffledImage PrepareChunk(const CompressedImage &image);
+
 public:
     BSLZ4DecoderGPU(size_t max_uncompressed_bytes, std::shared_ptr<CudaStream> stream);
 
     // True when this image can be decoded on the device. Everything else must go the host route.
     static bool Supports(const CompressedImage &image);
 
+    // The uncompressed size of one bitshuffle block, straight out of the chunk header, so a caller
+    // that wants to decode the blocks in shared memory can size that memory before it commits to
+    // the route. Zero when the chunk is too short to hold a header, which the decode then reports.
+    static uint32_t BlockBytes(const CompressedImage &image);
+
     // Locate the blocks, upload the chunk, and run the LZ4 pass. The result is still bitshuffled -
     // the caller finishes it, either with Decode()'s un-transpose or by fusing the un-transpose into
     // its own kernel. Work is queued on the decoder's stream and the caller synchronises.
     BSLZ4ShuffledImage DecodeShuffled(const CompressedImage &image);
 
+    // Upload the chunk and locate its blocks, and stop there. For a caller that runs the LZ4 pass
+    // in its OWN kernel, decoding each block into shared memory and consuming it there, so the
+    // bitshuffled bytes never reach device memory. Such a caller must call QueueDecodeStatus()
+    // once that kernel is queued.
+    BSLZ4ShuffledImage UploadCompressed(const CompressedImage &image);
+
+    // Queue the device-side failure flag back to the host. DecodeShuffled() does this itself; a
+    // caller that decodes the blocks in its own kernel does it after queueing that kernel, or the
+    // flag ThrowIfDecodeFailed() reads is the one from before the decode.
+    void QueueDecodeStatus();
+
     // Decode into gpu_out, which must hold image.GetUncompressedSize() bytes. The plain raw-bytes
     // path: DecodeShuffled() plus the un-transpose. Used by the tests and by any caller that wants
     // the decompressed image rather than a preprocessed one.