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>

frame_serialize/CBORStream2Serializer.cpp

@@ -358,6 +358,34 @@ inline void CBOR_ENC_GRID_SCAN(CborEncoder &encoder, const char* key, const Grid
     cborErr(cbor_encoder_close_container(&encoder, &mapEncoder));
 }
 
+inline void CBOR_ENC_TRANSFORMATIONS(CborEncoder &encoder, const char* key,
+                                     const std::vector<DetectorTransformation> &chain) {
+    if (chain.empty())
+        return;
+
+    CborEncoder arrayEncoder, mapEncoder;
+    cborErr(cbor_encode_text_stringz(&encoder, key));
+    // An ARRAY, not a map: the chain is ordered, base first, and a CBOR map carries no order a
+    // consumer may rely on - RFC 8949 has deterministic encoders sort map keys.
+    cborErr(cbor_encoder_create_array(&encoder, &arrayEncoder, chain.size()));
+    for (const auto &axis: chain) {
+        cborErr(cbor_encoder_create_map(&arrayEncoder, &mapEncoder, CborIndefiniteLength));
+        CBOR_ENC(mapEncoder, "name", axis.GetName());
+        CBOR_ENC(mapEncoder, "transformation_type", axis.IsRotation() ? "rotation" : "translation");
+        CBOR_ENC(mapEncoder, "units", axis.GetUnits());
+        CBOR_ENC(mapEncoder, "vector", axis.GetVector());
+        CBOR_ENC(mapEncoder, "offset", axis.GetOffset());
+        CBOR_ENC(mapEncoder, "depends_on", axis.GetDependsOn());
+        if (!axis.GetEquipment().empty())
+            CBOR_ENC(mapEncoder, "equipment", axis.GetEquipment());
+        if (!axis.GetEquipmentComponent().empty())
+            CBOR_ENC(mapEncoder, "equipment_component", axis.GetEquipmentComponent());
+        CBOR_ENC(mapEncoder, "values", axis.GetValues());
+        cborErr(cbor_encoder_close_container(&arrayEncoder, &mapEncoder));
+    }
+    cborErr(cbor_encoder_close_container(&encoder, &arrayEncoder));
+}
+
 inline void CBOR_ENC_GONIOMETER_MAP(CborEncoder &encoder, const char* key, const StartMessage &msg) {
     CborEncoder mapEncoder;
 
@@ -569,6 +597,8 @@ inline void CBOR_ENC_START_USER_DATA(CborEncoder& encoder, const char* key,
         j["socket_number"] = message.socket_number.value();
     if (message.bit_depth_readout)
         j["bit_depth_readout"] = message.bit_depth_readout.value();
+    if (message.underload_value)
+        j["underload_value"] = message.underload_value.value();
     if (!message.writer_notification_zmq_addr.empty())
         j["writer_notification_zmq_addr"] = message.writer_notification_zmq_addr;
     if (message.summation_mode.has_value())
@@ -688,12 +718,15 @@ void CBORStream2Serializer::SerializeSequenceStart(const StartMessage& message)
 
     if (message.goniometer)
         CBOR_ENC_GONIOMETER_MAP(mapEncoder, "goniometer", message);
-    else if (message.grid_scan)
+    if (message.grid_scan)
         CBOR_ENC_GRID_SCAN(mapEncoder, "grid_scan", message.grid_scan.value());
 
     CBOR_ENC(mapEncoder, "jungfrau_conversion_enabled", message.jungfrau_conversion_enabled);
     CBOR_ENC(mapEncoder, "jungfrau_conversion_factor", message.jungfrau_conversion_factor);
     CBOR_ENC(mapEncoder, "geometry_transformation_enabled", message.geometry_transformation_enabled);
+    // Not a DECTRIS field - stream2 has nothing for the row direction, so a consumer that does not
+    // know this key simply skips it and gets today's behaviour, which is what absence means.
+    CBOR_ENC(mapEncoder, "mirror_y", message.mirror_y);
 
     CBOR_ENC_PIXEL_MASK(mapEncoder, message);
     CBOR_ENC_AZINT_MAP(mapEncoder, message);
@@ -746,6 +779,8 @@ void CBORStream2Serializer::SerializeSequenceEnd(const EndMessage& message) {
     CBOR_ENC(mapEncoder, "end_date", message.end_date);
 
     CBOR_ENC(mapEncoder, "max_image_number", message.max_image_number);
+    // Optional: absent means the writer builds the same chain from the start message itself.
+    CBOR_ENC_TRANSFORMATIONS(mapEncoder, "transformations", message.transformations);
     CBOR_ENC(mapEncoder, "images_collected", message.images_collected_count);
     CBOR_ENC(mapEncoder, "images_sent_to_write", message.images_sent_to_write_count);
     CBOR_ENC(mapEncoder, "data_collection_efficiency", message.efficiency);