diff --git a/docs/ACKNOWLEDGEMENT.md b/docs/ACKNOWLEDGEMENT.md
index 45afd765c..6d17f558a 100644
--- a/docs/ACKNOWLEDGEMENT.md
+++ b/docs/ACKNOWLEDGEMENT.md
@@ -598,6 +598,12 @@ by the groups that collected them. European Organization for Nuclear Research an
 deposits are described in IUCrData Raw Data Letters; the letters are cited on the
 [EXTERNAL_TEST_DATA](EXTERNAL_TEST_DATA.md) page, beside the datasets they describe.
 
+**[CXIDB](https://cxidb.org/)**, the Coherent X-ray Imaging Data Bank, is the source of the serial
+(XFEL stills) datasets of the still battery, listed with their DOIs on
+[EXTERNAL_TEST_DATA_STILLS](EXTERNAL_TEST_DATA_STILLS.md). F. R. N. C. Maia, "The Coherent X-ray
+Imaging Data Bank" (2012), Nat. Methods 9, 854-855
+[doi:10.1038/nmeth.2110](https://doi.org/10.1038/nmeth.2110).
+
 **[MXRDR](https://mxrdr.icm.edu.pl/)**, the Macromolecular Xtallography Raw Data Repository
 (ICM, University of Warsaw), releases its data under CC0 and asks that the DOI of the dataset be
 cited.
diff --git a/docs/EXTERNAL_TEST_DATA.md b/docs/EXTERNAL_TEST_DATA.md
index 770a08db5..68a410c86 100644
--- a/docs/EXTERNAL_TEST_DATA.md
+++ b/docs/EXTERNAL_TEST_DATA.md
@@ -12,6 +12,9 @@ exactly this kind of reuse, and this page is where we credit them.
 the table below; the repositories themselves are cited in
 [ACKNOWLEDGEMENT](ACKNOWLEDGEMENT.md).
 
+This page lists the rotation datasets. The serial (XFEL stills) datasets of the still battery are on
+[External test data: serial crystallography](EXTERNAL_TEST_DATA_STILLS.md).
+
 ## Where the values come from
 
 - **Source** is the repository we downloaded from and that repository's own citable DOI for
diff --git a/docs/EXTERNAL_TEST_DATA_STILLS.md b/docs/EXTERNAL_TEST_DATA_STILLS.md
new file mode 100644
index 000000000..583765bf0
--- /dev/null
+++ b/docs/EXTERNAL_TEST_DATA_STILLS.md
@@ -0,0 +1,70 @@
+# External test data: serial crystallography (XFEL stills)
+
+The serial datasets of the still battery (`tools/battery/still_battery.py`, manifest
+`tools/battery/still_manifest.json`). Like the rotation sets on
+[External test data](EXTERNAL_TEST_DATA.md), they were collected by other people, on detectors and in
+file formats we do not produce ourselves, and published for exactly this kind of reuse. All of them
+come from the [Coherent X-ray Imaging Data Bank](https://cxidb.org) (CXIDB).
+
+**None of these data were collected by us.** If you use any of them, cite the dataset DOI below and
+the paper of the entry.
+
+## Where the values come from
+
+- **Dataset DOI**: the CXIDB entry's own DOI, resolved against DataCite before it was written down.
+- **Space group, cell, resolution and R-free** are the values deposited with the PDB entry, read from
+  the RCSB data API. Every entry is a dark or ground state refined against observed data; entries
+  refined against extrapolated structure factors (the time points of a pump-probe series) are not
+  used, because a merge of the measured images cannot be compared with them.
+- **Images** are the frames in the files we use, counted in the files themselves.
+
+## Datasets
+
+| Set | CXIDB, dataset DOI | Facility / beamline | Detector, format | PDB | Space group, d<sub>min</sub> (Å) | Paper |
+|---|---|---|---|---|---|---|
+| `sacla243` | [243](https://cxidb.org/id-243.html), [10.11577/17003933](https://doi.org/10.11577/17003933) | SACLA BL2 | MPCCD, 8 panels of 1024 x 512, 50 µm; Cheetah-SACLA HDF5 | [31JT](https://www.rcsb.org/structure/31JT) | P 2 21 21, 1.63 | Bibi, De Vrieze et al., J. Am. Chem. Soc. (2026) |
+| `sacla237` | [237](https://cxidb.org/id-237.html), [10.11577/2999572](https://doi.org/10.11577/2999572) | SACLA BL2 | MPCCD; Cheetah-SACLA HDF5 | [9S06](https://www.rcsb.org/structure/9S06) | P 21 21 21, 2.05 | Rios-Santacruz et al., Nature (2026) |
+| `sacla236` | [236](https://cxidb.org/id-236.html), [10.11577/3014306](https://doi.org/10.11577/3014306) | SACLA BL2 | MPCCD; Cheetah-SACLA HDF5 | [9V3D](https://www.rcsb.org/structure/9V3D) | P 43 21 2, 1.68 | Kang et al., J. Appl. Cryst. (2026) |
+| `pal86` | [86](https://cxidb.org/id-86.html), [10.11577/1502065](https://doi.org/10.11577/1502065) | PAL-XFEL NCI | Rayonix MX225-HS, 1440 x 1440, 156 µm; Cheetah CXI | [6IG7](https://www.rcsb.org/structure/6IG7) | P 61 2 2, 1.80 | Park et al., Sci. Rep. (2019) |
+| `pal90` | [90](https://cxidb.org/id-90.html), [10.11577/1511590](https://doi.org/10.11577/1511590) | PAL-XFEL NCI | Rayonix MX225-HS; Cheetah CXI | [6IRK](https://www.rcsb.org/structure/6IRK) | I 2 2 2, 1.75 | Lee et al., Sci. Rep. (2019) |
+| `lcls222` | [222](https://cxidb.org/id-222.html), [10.11577/2204603](https://doi.org/10.11577/2204603) | LCLS MFX | Rayonix MX340-HS, 1920 x 1920, 177 µm; LCLS-I XTC | [8TDQ](https://www.rcsb.org/structure/8TDQ) | P 65 2 2, 1.65 | Nguyen et al., J. Am. Chem. Soc. (2023) |
+| `lcls242_s`, `lcls242_t` | [242](https://cxidb.org/id-242.html), [10.11577/3374214](https://doi.org/10.11577/3374214) | LCLS MFX | Rayonix MX340-HS; LCLS-I XTC | [9O4S](https://www.rcsb.org/structure/9O4S) (small cell), [9O4T](https://www.rcsb.org/structure/9O4T) (large cell) | P 1 21 1, 1.95 | Wolff et al., bioRxiv (2026) |
+| `euxfel83` | [83](https://cxidb.org/id-83.html), [10.11577/1464102](https://doi.org/10.11577/1464102) | European XFEL SPB/SFX | AGIPD 1M, 16 x (512 x 128), 200 µm; Cheetah CXI | [6GTH](https://www.rcsb.org/structure/6GTH) | P 32 2 1, 1.69 | Wiedorn et al., Nat. Commun. (2018) |
+| `euxfel152` | [152](https://cxidb.org/id-152.html), [10.11577/1660970](https://doi.org/10.11577/1660970) | European XFEL SPB/SFX | AGIPD 1M; Cheetah CXI | [6U57](https://www.rcsb.org/structure/6U57) | I 2 3, 2.80 | Echelmeier et al., Nat. Commun. (2020) |
+| `alvra103`, `alvra103_int16` | [103](https://cxidb.org/id-103.html), [10.11577/1650020](https://doi.org/10.11577/1650020) | SwissFEL Alvra | JUNGFRAU 16M, 75 µm; SwissFEL HDF5, float32 keV (converted) | [6S0L](https://www.rcsb.org/structure/6S0L) | C 2 2 21, 2.65 | Nass et al., IUCrJ (2020) |
+| `alvra213`, `alvra213_int16` | [213](https://cxidb.org/id-213.html), [10.11577/2282689](https://doi.org/10.11577/2282689) | SwissFEL Alvra | JUNGFRAU 4M, 75 µm; SwissFEL HDF5, float32 keV (converted) | [8BKH](https://www.rcsb.org/structure/8BKH) (dark state) | P 1 21 1, 1.35 | Barends et al., Nature (2024) |
+
+## The files we use
+
+Paths are relative to the still data root of the site config (`tools/battery/README.md`). CXIDB
+serves `https://cxidb.org/data/<entry>/...`; most of it accepts HTTP range requests, so a
+broken download resumes with `curl -C -`.
+
+| Set | Files | Images | Size |
+|---|---|---|---|
+| `sacla243` | `sacla_243/raw_all/run*.h5`: all 87 files of `243/Complete_dark/` | 52,151 | 198 GB |
+| `sacla237` | `sacla_237/raw/`: the 18 files `run130637-0` to `run130642-2` of `237/SACLA_raw/2022Nov/dark_ref/` (the dark reference; the time points are not used) | 10,792 | 48 GB |
+| `sacla236` | `sacla_236/raw/`: the 18 files `run157084-0` to `run157089-2` of `236/Data/lyso01-apo-bigXtal/` | 16,083 | 67 GB |
+| `pal86` | `pal_86/raw/`, `pal_86/raw_more/`: `CXIDB_86_themolysin_{2..25}_SFX_Nam.cxi` (file 1 is truncated on the server and cannot be opened) | 49,193 | 111 GB |
+| `pal90` | `pal_90/raw/`: `CXIDB_90-GI_SFX-filter-r000{1,2}-c00.cxi` | 11,947 | 25 GB |
+| `lcls222` | `lcls_222/xtc/`, `lcls_222/xtc_more/`: `mfx/mfxlu5017/xtc/e1277-r0165-{s00-c00,s00-c01,s01-c00,s01-c01,s02-c00}.xtc` (run 165, the substrate-bound state of 8TDQ) | 8,534 | 72 GB |
+| `lcls242_*` | `lcls_242/xtc/`, `lcls_242/xtc_more/`: `xtc/mfxl1013721-r0256` to `r0267` streams (the two crystal forms are in every run; each set keeps its own form) | ~90,000 | ~700 GB |
+| `euxfel83` | `euxfel_83/raw/`: `XFEL-r0243-c00.cxi`, `XFEL-r0278-c00.cxi`, `XFEL-r0280-c00.cxi` (Cheetah hits, from the entry's `cheetah-calib-mar-v1/hdf5/` tree on the NERSC archive); `euxfel_83/ref/agipd_mar18_v10.geom` from the entry | 2,790 | 4.7 GB |
+| `euxfel152` | `euxfel_152/raw/`: runs r0108, 0110, 0112, 0114, 0115, 0116, 0118, 0123, 0125 extracted from `XFEL2042-runs-cxi.tar` (range requests on the tar members); `euxfel_152/ref/kdo_embedded.geom`, the geometry embedded in the header of the entry's `KDO8PS.stream` | 3,801 | 5.7 GB |
+| `alvra103` | `swissfel_103/raw/`: `Raw_Files/2018-08-07/a2a/run{10..24}.JF06T32V01.h5`; `swissfel_103/ref/jf-16M.geom` from the entry | ~11,000 | ~750 GB |
+| `alvra213` | `swissfel_213/raw/march_dark_MbCO_II-March-06/data/dark/run_*.JF06T08V01.h5`, from `march/march_dark_MbCO_II-March-06.tar.gz` (425 GB; download it to disk and extract, a streamed extraction does not survive a broken connection); `swissfel_213/ref/mbco_march.geom` from the JUNGFRAU geometry template of `2019-MARCH-SwissFEL-MbCO-supplement.tar.gz` | ~38,000 | ~430 GB |
+
+**The `_int16` sets.** The SwissFEL files store converted JUNGFRAU data as uncompressed float32 keV,
+68 MB (JF16M) or 17 MB (JF4M) a frame, which caps reading at about 74 or 295 frames/s at 5 GB/s. The
+`_int16` sets are copies with the same layout in which `/data/data` holds whole photons (keV divided
+by the photon energy, rounded) as int16 with bitshuffle/LZ4, about 25 times smaller; rugnux reads them
+with `--gain 1` and merges them to the same numbers. Make them with
+`tools/battery/still/float32_to_int16.py <in.h5> <out.h5> <photon energy keV>` (h5py and hdf5plugin),
+into `swissfel_103/conv/` (4.57 keV) and `swissfel_213/conv/` (12.037 keV), named `<input>_int16.h5`.
+
+## Not in the battery
+
+- **Time points of pump-probe series** (e.g. the light data of CXIDB 237 and 213): every deposited time
+  point was refined against extrapolated structure factors.
+- **Raw JUNGFRAU data** (ADC values with gain bits that need pedestal and gain correction, e.g. LCLS
+  CXIDB 189 and 214): only converted detector data are read.
diff --git a/docs/TESTS.md b/docs/TESTS.md
index f1e04f93b..8fc489f8e 100644
--- a/docs/TESTS.md
+++ b/docs/TESTS.md
@@ -43,9 +43,14 @@ pipeline is exercised on, and the DOI to cite for each, are listed in
   and compare protocol and the report are described in `tools/battery/README.md`. Each set runs
   once, with one command per arm; [Measuring Rugnux](RUGNUX_BENCHMARKING.md) explains the protocol,
   the REFMAC check and the timing benchmark, and how to take timings that compare.
-* `rugnux_stills_ab.py` - the stills analogue of the battery: scores a change on a serial
-  dataset by what it does to the merge. Takes its dataset list from outside the repository.
-* `rugnux_anomalous.py` - the anomalous-peak-height arbiter, below.
+* `tools/battery/still_battery.py` - the still battery: public serial (XFEL stills) datasets
+  run with their deposition's cell and space group, each merge refined against the deposited model
+  and reported beside the deposition's R-free, with rugnux's wall time and the input's I/O floor.
+  See "The still battery" in `tools/battery/README.md`.
+* `tools/battery/still/rugnux_stills_ab.py` - A/B comparison of argument sets on a fixed stills
+  subset: what one change does to the merge, shell by shell. Takes its dataset list from outside
+  the repository.
+* `tools/battery/rugnux_anomalous.py` - the anomalous-peak-height arbiter, below.
 
 ### The anomalous-peak-height arbiter
 
@@ -64,16 +69,16 @@ statistics we normally reach for:
 units of the map's own sigma, so a uniform intensity rescale cancels exactly, and it is referenced
 to the structure rather than to another program's partiality model.
 
-`rugnux_anomalous.py` measures it: `shelxc` + `anode -a` (CCP4) on each arm's merged reflections,
+`tools/battery/rugnux_anomalous.py` measures it: `shelxc` + `anode -a` (CCP4) on each arm's merged reflections,
 against a model that is placed **once** and then held fixed. It reports, per dataset, the mean site
 height and the off-site noise floor, and, between arms, the **paired per-site** change.
 
 ```
 # compare two arms (each a directory of <id>/<id>.hkl + .mtz)
-./rugnux_anomalous.py --config <table>.json  base=<dir-A>  test=<dir-B>
+tools/battery/rugnux_anomalous.py --config <table>.json  base=<dir-A>  test=<dir-B>
 
 # a parameter scan: numeric labels turn the arms into a curve with a per-dataset optimum
-./rugnux_anomalous.py --config <table>.json \
+tools/battery/rugnux_anomalous.py --config <table>.json \
     0.85='<scan>/{name}/s0p85.hkl' 1.00='<scan>/{name}/s1.hkl' 1.20='<scan>/{name}/s1p2.hkl'
 ```
 
diff --git a/docs/index.rst b/docs/index.rst
index 48a3d1cac..9c2a3dc52 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -83,6 +83,7 @@ Jungfraujoch is distributed under the GPLv3 license.
 
    ACKNOWLEDGEMENT
    EXTERNAL_TEST_DATA
+   EXTERNAL_TEST_DATA_STILLS
    LICENSE
    THIRD_PARTY_NOTICES
    VERSIONING
diff --git a/tools/battery/README.md b/tools/battery/README.md
index 6054d3d35..fcbdc0bee 100644
--- a/tools/battery/README.md
+++ b/tools/battery/README.md
@@ -934,3 +934,55 @@ sets that ran with other processes on the GPU (`gpu_others` > 0) are drawn as th
 segment of their bar rather than dropped; `--uncontended RUN` names a run of the same sets with the
 GPU to itself and `summary.txt` then reports their median slowdown against it.
 
+
+## The still battery
+
+`still_battery.py` is the serial (XFEL stills) counterpart of the rotation battery, for the public
+datasets on [External test data: serial crystallography](../../docs/EXTERNAL_TEST_DATA_STILLS.md)
+(manifest `still_manifest.json`). It shares the site config, the verbs and the run-directory layout
+with `battery.py`, and reports something different: for stills the cell and space group are given, the
+way a serial user runs (`-C`/`-S`), so there is no lattice or symmetry verdict to score. Each set runs
+once and its row says what the merge is worth and what it cost:
+
+| column | meaning |
+|---|---|
+| facility, beamline, detector, dataset, PDB | from the manifest |
+| images | frames in the input files (rugnux's `IMAGES_PROCESSED`); images (deposition) the deposition's own count, where it is known |
+| indexed %, d_min, R_split | rugnux's report (`INDEXING_RATE`, `INCLUDE_RESOLUTION_RANGE`, `R_SPLIT`: whole frames go to one half, as in CrystFEL) |
+| R_free rugnux | `dimple` of the deposited model against our merge, reindexed into the deposition's space group, with the deposition's own free set, at the deposition's resolution |
+| R_free deposited | the entry's published R-free (dark and ground-state entries only) |
+| time, ms/image | wall clock of the rugnux command, which ends with the model validation |
+| I/O floor | the input's bytes over `--io-gbps` (default 5 GB/s): the time reading alone would take from an SSD |
+| page cache | share of the input already in memory when the run started (`fincore`): cold, warm or partial |
+
+The I/O floor and the page-cache state are there because several of these formats are uncompressed
+(XTC, float32 SwissFEL HDF5): a run whose time is at its floor measured the disk, not rugnux, and a
+warm run of a set smaller than the RAM measured neither. For honest timings drop the page cache
+before the run (`sync; echo 3 | sudo tee /proc/sys/vm/drop_caches`) and check that the column says
+cold.
+
+```
+still_battery.py run --rugnux build/rugnux/rugnux [--only pal90,sacla236 | --tier smoke] [--threads N]
+still_battery.py compare RUN_A RUN_B
+still_battery.py report RUN [--out DIR]
+still_battery.py list
+still_battery.py keep RUN --as workstation|server
+```
+
+A run writes `<runs_root>/<YYYYMMDD-HHMM>_<rugnux git>_still-<label>/` with `manifest.json`,
+`results.json`, `report.md` and `work/<set>/` (the rugnux outputs and the dimple run), made
+read-only when done; `keep` copies the three files into `results/<role>/<run>/`, like a rotation run.
+`--tier smoke` runs the sets marked so in the manifest on their first few thousand frames. Data
+paths come from the `"still"` section of the site config:
+
+```json
+"still": {"manifest": "still_manifest.json", "data_root": "/ssd/data/still_test", "private_manifest": null}
+```
+
+`private_manifest` names a local-only manifest of user data (`--private`); such a run gets its own
+run directory and `report_PRIVATE.md`, and `keep` refuses it. Needs `gemmi` (Python), CCP4's
+`dimple` and `reindex`, and `fincore` (util-linux) for the page-cache column.
+
+Data preparation for the `_int16` sets is `still/float32_to_int16.py` (see the stills data page).
+`still/rugnux_stills_ab.py` is the older A/B harness: it compares two argument sets on a fixed
+subset of one dataset, shell by shell, and takes its dataset list from outside the repository.
diff --git a/rugnux_anomalous.py b/tools/battery/rugnux_anomalous.py
similarity index 100%
rename from rugnux_anomalous.py
rename to tools/battery/rugnux_anomalous.py
diff --git a/tools/battery/site.example.json b/tools/battery/site.example.json
index 267dd1209..cb4c30b32 100644
--- a/tools/battery/site.example.json
+++ b/tools/battery/site.example.json
@@ -9,6 +9,7 @@
  "pdb_cache": "/path/to/battery/pdb_cache",
  "cod_cache": "/path/to/battery/cod_cache",
  "shelxl": null,
+ "still": {"manifest": "still_manifest.json", "data_root": "/path/to/battery/still", "private_manifest": null},
  "arms": {
   "open":    {"manifest": "open.json",    "reference": "deposition", "data_root": "/path/to/battery/open"},
   "inhouse": {"manifest": "inhouse.json", "reference": "xds",        "data_root": "/path/to/battery/inhouse"}
diff --git a/tools/battery/still/float32_to_int16.py b/tools/battery/still/float32_to_int16.py
new file mode 100644
index 000000000..ffe6da012
--- /dev/null
+++ b/tools/battery/still/float32_to_int16.py
@@ -0,0 +1,47 @@
+"""Data preparation for the still battery (not product code): copy a SwissFEL converted JUNGFRAU file, replacing /data/data (float32 keV) by int16 photon counts,
+bitshuffle/LZ4, one chunk per frame. Everything else is copied unchanged. NaN -> 0 (what rugnux's reader makes of it).
+usage: float32_to_int16.py <in.h5> <out.h5> <photon_energy_keV>
+Needs h5py and hdf5plugin. The copies are the alvra*_int16 sets of still_manifest.json; read them with --gain 1.
+See docs/EXTERNAL_TEST_DATA_STILLS.md."""
+import os, sys, time, h5py, hdf5plugin, numpy as np
+
+src, dst, e_kev = sys.argv[1], sys.argv[2], float(sys.argv[3])
+t0 = time.time()
+with h5py.File(src, 'r') as fi, h5py.File(dst + '.part', 'w') as fo:
+    for k, v in fi.attrs.items():
+        fo.attrs[k] = v
+    def copy(name, obj):
+        if name == 'data/data':
+            return
+        if isinstance(obj, h5py.Group):
+            g = fo.require_group(name)
+            for k, v in obj.attrs.items():
+                g.attrs[k] = v
+        else:
+            fo.copy(obj, name if '/' not in name else fo.require_group(name.rsplit('/', 1)[0]), name=name.rsplit('/', 1)[-1])
+    fi.visititems(copy)
+    d = fi['data/data']
+    n, h, w = d.shape
+    out = fo.create_dataset('data/data', shape=(n, h, w), dtype='int16', chunks=(1, h, w),
+                            **hdf5plugin.Bitshuffle(nelems=0, cname='lz4'))
+    for k, v in d.attrs.items():
+        out.attrs[k] = v
+    out.attrs['photon_energy_keV_used_for_conversion'] = e_kev
+    out.attrs['conversion'] = 'int16 photons = round(float32 keV / photon_energy_keV), NaN -> 0, clipped to int16; original: ' + src
+    nan = clipped = 0
+    hist = np.zeros(4, dtype=np.int64)  # <0, 0, 1, >=2 photons
+    for i in range(n):
+        x = d[i]
+        bad = np.isnan(x)
+        nan += int(bad.sum())
+        p = np.rint(np.where(bad, 0, x) / e_kev)
+        clipped += int(((p > 32767) | (p < -32768)).sum())
+        p = np.clip(p, -32768, 32767).astype(np.int16)
+        if i % 50 == 0:
+            hist += [(p < 0).sum(), (p == 0).sum(), (p == 1).sum(), (p >= 2).sum()]
+        out[i] = p
+os.rename(dst + '.part', dst)
+s_in, s_out = os.path.getsize(src), os.path.getsize(dst)
+print(f'{os.path.basename(src)} frames {n} in {s_in/1e9:.2f} GB out {s_out/1e9:.3f} GB ratio {s_in/s_out:.1f} '
+      f'MB/frame {s_in/n/1e6:.2f}->{s_out/n/1e6:.3f} time {time.time()-t0:.0f} s nan {nan} clipped {clipped} '
+      f'sampled photon hist <0/0/1/>=2 {hist.tolist()}', flush=True)
diff --git a/rugnux_stills_ab.py b/tools/battery/still/rugnux_stills_ab.py
similarity index 99%
rename from rugnux_stills_ab.py
rename to tools/battery/still/rugnux_stills_ab.py
index c0190da1e..15976377b 100755
--- a/rugnux_stills_ab.py
+++ b/tools/battery/still/rugnux_stills_ab.py
@@ -1,6 +1,9 @@
 #!/usr/bin/env python3
 """
-rugnux_stills_ab.py -- the stills analogue of the rotation battery (tools/battery/).
+rugnux_stills_ab.py -- A/B comparison of two (or more) rugnux argument sets on a fixed stills subset.
+
+The still battery (tools/battery/still_battery.py) reports each public serial dataset against its
+deposition; this script answers the narrower question of whether one change moved the merge.
 
 The battery scores a ROTATION change against a reference: one crystal per directory, one
 deposition or CORRECT.LP to compare with, space-group agreement as the headline. None of
diff --git a/stills_datasets.tsv b/tools/battery/still/stills_datasets.tsv
similarity index 100%
rename from stills_datasets.tsv
rename to tools/battery/still/stills_datasets.tsv
diff --git a/tools/battery/still_battery.py b/tools/battery/still_battery.py
new file mode 100644
index 000000000..2168e33fd
--- /dev/null
+++ b/tools/battery/still_battery.py
@@ -0,0 +1,422 @@
+#!/usr/bin/env python3
+"""Rugnux still battery: run serial (XFEL stills) datasets, refine the deposited model against each
+merge, report, compare.
+
+The rotation battery (battery.py) scores a lattice and a space group. For stills both are given
+(-C/-S, the way a serial user runs), so this battery reports what the merge is worth and what it
+costs instead: indexing rate, R_split, the R-free of the deposited model refined against our merge
+(dimple, with the deposition's own free set) beside the deposition's published R-free, and the wall
+time of the rugnux command with the input's I/O floor next to it.
+
+Usage (README.md in this directory, section "The still battery", is the guide):
+  still_battery.py run --rugnux BIN [--label L] [--only a,b | --tier smoke] [--threads N]
+                       [--no-refine] [--io-gbps G]
+  still_battery.py compare RUN_A RUN_B
+  still_battery.py report RUN [--out DIR]          re-render a run's report.md
+  still_battery.py list                            still runs under the runs root
+  still_battery.py keep RUN --as workstation|server  copy report.md, results.json, manifest.json
+                                                   into results/<role>/<run>/ (committed); refuses a
+                                                   private run
+
+The site config is the rotation battery's (--site, $JFJOCH_BATTERY_SITE, tools/battery/site.json),
+with a "still" section: {"manifest": "still_manifest.json", "data_root": DIR} and optionally
+"private_manifest" for local-only sets. A run writes <runs_root>/<YYYYMMDD-HHMM>_<git>_still-<label>/
+(manifest.json, results.json, report.md, work/<set>/) and is made read-only when done; a run directory
+is never reused.
+"""
+import argparse
+import datetime
+import glob
+import json
+import os
+import re
+import shutil
+import socket
+import subprocess
+import sys
+import time
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+
+import battery  # noqa: E402  binary_info, hardware_info, run_logged, write_json, make_read_only, ...
+import model_check  # noqa: E402  fetch, ccp4_env, RCSB
+
+import gemmi  # noqa: E402
+import numpy as np  # noqa: E402
+
+MANIFEST = os.path.join(HERE, "still_manifest.json")
+KEPT_FILES = ("report.md", "results.json", "manifest.json")
+IO_GBPS = 5.0          # sequential read speed the I/O floor is quoted at (a PCIe 4 NVMe SSD)
+
+COLUMNS = [("facility", "facility"), ("beamline", "beamline"), ("detector", "detector"),
+           ("dataset", "set"), ("PDB", "pdb"), ("images", "images"), ("images (deposition)", "images_deposited"),
+           ("indexed %", "indexed_pct"), ("d_min", "d_min"), ("R_split", "r_split"),
+           ("R_free rugnux", "r_free"), ("R_free deposited", "r_free_deposited"),
+           ("time s", "wall_s"), ("ms/image", "ms_per_image"), ("I/O floor s", "io_floor_s"),
+           ("page cache", "cache")]
+
+
+# ------------------------------------------------------------------ configuration
+
+def load_site(path):
+    path = path or os.environ.get("JFJOCH_BATTERY_SITE") or battery.LOCAL_SITE
+    if not os.path.exists(path):
+        sys.exit(f"no site config at {path}: see site.example.json and README.md")
+    site = json.load(open(path))
+    if "still" not in site:
+        sys.exit(f"{path}: no \"still\" section (see site.example.json)")
+    base = os.path.dirname(os.path.abspath(path))
+    st = site["still"]
+    st["data_root"] = os.path.join(base, st["data_root"])
+    st["manifest"] = os.path.join(HERE, st.get("manifest", "still_manifest.json"))
+    if st.get("private_manifest"):
+        st["private_manifest"] = os.path.join(base, st["private_manifest"])
+    st["runs_root"] = os.path.join(base, st.get("runs_root") or site["runs_root"])
+    st["pdb_cache"] = os.path.join(base, site.get("pdb_cache") or model_check.DEFAULT_CACHE)
+    return st
+
+
+def select(st, only, tier, private):
+    path = st.get("private_manifest") if private else st["manifest"]
+    if not path:
+        sys.exit("--private: the site config names no still private_manifest")
+    sets = json.load(open(path))["sets"]
+    if only:
+        want = [s.strip() for s in only.split(",") if s.strip()]
+        unknown = [w for w in want if w not in {e["id"] for e in sets}]
+        if unknown:
+            sys.exit(f"not in the still manifest: {', '.join(unknown)}")
+        sets = [e for e in sets if e["id"] in want]
+    if tier:
+        sets = [e for e in sets if tier in e.get("tiers", {})]
+    return sets
+
+
+# ------------------------------------------------------------------ one set
+
+def inputs(e, data_root):
+    """The input files: each glob of the row in order, each glob's matches sorted by name."""
+    files = []
+    for pattern in e["inputs"]:
+        files += sorted(glob.glob(os.path.join(data_root, pattern)))
+    return files
+
+
+def page_cache(files):
+    """Fraction of the input bytes already in the page cache (fincore), or None without fincore."""
+    if not shutil.which("fincore") or not files:
+        return None
+    r = subprocess.run(["fincore", "--bytes", "--noheadings", "--output", "RES,SIZE"] + files,
+                       capture_output=True, text=True)
+    res = size = 0
+    for line in r.stdout.splitlines():
+        parts = line.split()
+        if len(parts) == 2:
+            res, size = res + int(parts[0]), size + int(parts[1])
+    return res / size if size else None
+
+
+def cache_state(fraction):
+    if fraction is None:
+        return "unknown"
+    return "cold" if fraction < 0.05 else "warm" if fraction > 0.95 else f"partial {100 * fraction:.0f}%"
+
+
+def frame_limit(e, opts):
+    return (e.get("tiers") or {}).get(opts["tier"], {}).get("images") if opts["tier"] else None
+
+
+def command(binary, e, data_root, opts, model):
+    """The command run, and the same written for a reader: rugnux, the data root as <data>, the input
+    globs instead of the file list, the model as <PDB>.pdb."""
+    head = ["-o", "p", "--no-export-unmerged"] + (["-N", str(opts["threads"])] if opts["threads"] else [])
+    if frame_limit(e, opts):
+        head += ["-e", str(frame_limit(e, opts))]
+    tail = ["--model", model] if model else []
+    cmd = [binary] + head + [a.replace("{data}", data_root) for a in e["args"]] + tail + inputs(e, data_root)
+    short = (["rugnux"] + head + [a.replace("{data}", "<data>") for a in e["args"]]
+             + (["--model", e["pdb"].lower() + ".pdb"] if model else []) + ["<data>/" + p for p in e["inputs"]])
+    return cmd, " ".join(short)
+
+
+def report_keys(path):
+    if not os.path.exists(path):
+        return {}
+    return dict(re.findall(r"^([A-Z_]+)= *(.*?)\s*$", open(path, errors="replace").read(), re.M))
+
+
+def num(s):
+    try:
+        return float(str(s).split()[0].rstrip("%"))
+    except (ValueError, IndexError):
+        return None
+
+
+def free_flags(sf_cif, out_mtz, free):
+    """An MTZ of the deposition's free set (FreeR_flag = 1 free, 0 working) from its -sf.cif. The free
+    set is `status` 'f' where the entry has it, else the pdbx_r_free_flag value held by 1-15% of the
+    reflections; the manifest row may name it instead ({"column": ..., "value": ...})."""
+    rb = gemmi.as_refln_blocks(gemmi.cif.read(sf_cif))[0]
+    h, k, l = (rb.make_int_array("index_" + c, 0) for c in "hkl")
+    col = val = None
+    if free:
+        col, val = free["column"], str(free["value"])
+    else:
+        for c in ("status", "pdbx_r_free_flag"):
+            tag = rb.block.find_values("_refln." + c)
+            if not len(tag):
+                continue
+            vals = [gemmi.cif.as_string(v) for v in tag]
+            counts = {v: vals.count(v) for v in set(vals)}
+            cands = [v for v, n in counts.items() if 0.01 <= n / len(vals) <= 0.15]
+            if c == "status" and "f" in cands:
+                col, val = c, "f"
+                break
+            if c == "pdbx_r_free_flag" and cands:
+                col, val = c, min(cands, key=lambda v: counts[v])
+                break
+    if col is None:
+        return None
+    flags = [1.0 if gemmi.cif.as_string(v) == val else 0.0 for v in rb.block.find_values("_refln." + col)]
+    mtz = gemmi.Mtz(with_base=True)
+    mtz.spacegroup = rb.spacegroup
+    mtz.cell = rb.cell
+    mtz.add_dataset("free")
+    mtz.add_column("FreeR_flag", "I")
+    mtz.set_data(np.column_stack([h, k, l, flags]).astype(np.float32))
+    mtz.write_to_file(out_mtz)
+    return f"{col}={val}"
+
+
+def refine(wd, e, cache):
+    """dimple of the deposited model against our merge, reindexed into the deposition's group, with the
+    deposition's free set, cut at the deposition's resolution. (R_work, R_free, note)."""
+    pdb = e["pdb"].lower()
+    xyz = model_check.fetch(model_check.RCSB + pdb + ".pdb", os.path.join(cache, pdb + ".pdb"))
+    sf = model_check.fetch(model_check.RCSB + pdb + "-sf.cif", os.path.join(cache, pdb + "-sf.cif"))
+    if not (xyz and sf) or not os.path.exists(os.path.join(wd, "p.mtz")):
+        return None, None, "no model, structure factors or merge"
+    free_mtz = os.path.join(wd, "deposited_free.mtz")
+    free = free_flags(sf, free_mtz, e.get("free"))
+    if free is None:
+        return None, None, "no free set in the deposition"
+    env = model_check.ccp4_env()
+    subprocess.run(["reindex", "hklin", "p.mtz", "hklout", "p_sg.mtz"], cwd=wd, env=env,
+                   input=f"SYMM '{e['sg']}'\nEND\n", capture_output=True, text=True)
+    with open(os.path.join(wd, "dimple.out"), "w") as log:
+        subprocess.run(["dimple", "--free-r-flags", free_mtz, "--freecolumn", "FreeR_flag=1", "-I", "IMEAN",
+                        "--reso", str(e["d_cut"]), "p_sg.mtz", xyz, "dimple"],
+                       cwd=wd, env=env, stdout=log, stderr=subprocess.STDOUT)
+    log = os.path.join(wd, "dimple", "dimple.log")
+    m = re.findall(r"R/Rfree\s+\S+\s+->\s+([\d.]+)/([\d.]+)", open(log).read()) if os.path.exists(log) else []
+    if not m:
+        return None, None, "dimple failed"
+    return float(m[-1][0]), float(m[-1][1]), f"free set {free}"
+
+
+def run_one(run_dir, binary, e, st, opts):
+    wd = os.path.join(run_dir, "work", e["id"])
+    os.makedirs(wd)
+    files = inputs(e, st["data_root"])
+    row = {k: e.get(k) for k in ("facility", "beamline", "detector", "pdb", "r_free_deposited",
+                                 "images_deposited", "format")}
+    row.update(set=e["id"], dataset=e.get("cxidb"))
+    if not files:
+        return dict(row, verdict="not_run", reason="no input files under the data root")
+    model = None
+    if e.get("pdb"):
+        pdb = e["pdb"].lower()
+        model = model_check.fetch(model_check.RCSB + pdb + ".pdb", os.path.join(st["pdb_cache"], pdb + ".pdb"))
+    cmd, short = command(binary, e, st["data_root"], opts, model)
+    io_bytes = sum(os.path.getsize(f) for f in files)
+    cached = page_cache(files)
+    t0 = time.time()
+    rc = battery.run_logged(cmd, wd, opts["timeout"])
+    wall = time.time() - t0
+    keys = report_keys(os.path.join(wd, "p_report.txt"))
+    images = num(keys.get("IMAGES_PROCESSED"))
+    rng = keys.get("INCLUDE_RESOLUTION_RANGE", "").split()
+    row.update(command=short, command_run=" ".join(cmd), exit_code=rc, wall_s=round(wall, 1), io_bytes=io_bytes,
+               # with a frame limit (a smoke tier) only part of each file is read: no floor then
+               io_floor_s=None if frame_limit(e, opts) else round(io_bytes / (opts["io_gbps"] * 1e9), 1),
+               cache=cache_state(cached),
+               input_files=len(files), images=int(images) if images else None,
+               ms_per_image=round(1000 * wall / images, 2) if images else None,
+               indexed_pct=round(100 * num(keys["INDEXING_RATE"]), 1) if keys.get("INDEXING_RATE") else None,
+               d_min=num(rng[-1]) if rng else None, r_split=num(keys.get("R_SPLIT")),
+               cc_half_split=num(keys.get("CC_HALF_SPLIT")), r_free_model_check=num(keys.get("R_FREE")))
+    if rc != 0 or not keys:
+        return dict(row, verdict="crash" if rc else "fail", reason=battery.failure_note(os.path.join(wd, "run.log")))
+    if opts["refine"] and e.get("pdb"):
+        row["r_work"], row["r_free"], row["refine_note"] = refine(wd, e, st["pdb_cache"])
+    return dict(row, verdict="done", reason="")
+
+
+# ------------------------------------------------------------------ report
+
+def fmt(v, key):
+    if v is None:
+        return "-"
+    if key == "r_split":
+        return f"{100 * v:.1f}%"
+    if key in ("r_free", "r_free_deposited"):
+        return f"{v:.3f}"
+    if key == "images_deposited" and isinstance(v, (int, float)):
+        return f"{int(v):,}"
+    if key == "images":
+        return f"{v:,}"
+    return str(v)
+
+
+def render(run_dir):
+    man = json.load(open(os.path.join(run_dir, "manifest.json")))
+    res = json.load(open(os.path.join(run_dir, "results.json")))
+    b = man["binary"]
+    hw = man.get("hardware") or {}
+    lines = [f"# Rugnux still battery - {os.path.basename(os.path.normpath(run_dir))}", "",
+             f"- binary: rugnux {b.get('version')} (git {b.get('git')}), {b.get('flags', '?')}",
+             f"- host: {man['host']}; {hw.get('cpu_model', '?')}, {hw.get('threads', '?')} threads, "
+             f"{(hw.get('memory_gib') or 0):.0f} GiB; GPUs: "
+             f"{', '.join(g['name'] for g in hw.get('gpus', [])) or 'none'}",
+             f"- start {man['start']}, end {man.get('end') or 'unfinished'}; subset: {man.get('subset') or 'all sets'}"
+             + ("; ABORTED" if man.get("aborted") else ""),
+             f"- R_free rugnux: dimple of the deposited model against our merge, with the deposition's free set, "
+             f"at its resolution; R_free deposited: the entry's published value. Time: wall clock of the rugnux "
+             f"command (to model validation); I/O floor: input bytes / {man['options']['io_gbps']} GB/s; page "
+             f"cache: share of the input already in memory when the run started.", "",
+             "| " + " | ".join(c for c, _ in COLUMNS) + " |", "|" + "---|" * len(COLUMNS)]
+    for r in res:
+        lines.append("| " + " | ".join(fmt(r.get(k), k) for _, k in COLUMNS) + " |")
+    bad = [r for r in res if r.get("verdict") != "done"]
+    if bad:
+        lines += ["", "## Not processed", ""] + [f"- {r['set']}: {r.get('verdict')} - {r.get('reason')}" for r in bad]
+    lines += ["", "## Commands", ""] + [f"- `{r['set']}`: `{r.get('command', '-')}`" for r in res]
+    name = "report_PRIVATE.md" if man.get("private") else "report.md"
+    open(os.path.join(run_dir, name), "w").write("\n".join(lines) + "\n")
+    return os.path.join(run_dir, name)
+
+
+# ------------------------------------------------------------------ commands
+
+def cmd_run(a, st):
+    sets = select(st, a.only, a.tier, a.private)
+    if not sets:
+        sys.exit("nothing selected")
+    info = battery.binary_info(a.rugnux, a.build_dir)
+    label = "still-" + (a.label or info.get("version") or "run")
+    stamp = datetime.datetime.now().strftime("%Y%m%d-%H%M")
+    run_dir = os.path.join(st["runs_root"], f"{stamp}_{info['git']}_{label}" + ("_private" if a.private else ""))
+    os.makedirs(run_dir)                      # never reuse or overwrite a run directory
+    binary = os.path.join(run_dir, "bin", "rugnux")
+    os.makedirs(os.path.dirname(binary))
+    shutil.copy2(a.rugnux, binary)
+    info.update(copied_from=os.path.realpath(a.rugnux), sha256=battery.sha256(binary))
+    opts = {"threads": a.threads, "timeout": a.timeout, "tier": a.tier, "refine": not a.no_refine,
+            "io_gbps": a.io_gbps}
+    man = {"kind": "still", "label": label, "private": a.private, "subset": a.only or (f"tier {a.tier}" if a.tier else None),
+           "binary": info, "runner_git": battery.git(HERE, "rev-parse", "--short", "HEAD") or "unknown",
+           "host": socket.gethostname(), "hardware": battery.hardware_info(),
+           "start": datetime.datetime.now().isoformat(timespec="seconds"), "end": None, "complete": False,
+           "options": opts, "sets": sets}
+    battery.write_json(os.path.join(run_dir, "manifest.json"), man)
+    print(f"run directory {run_dir}", flush=True)
+    results = []
+    try:
+        for e in sets:
+            row = run_one(run_dir, binary, e, st, opts)
+            results.append(row)
+            battery.write_json(os.path.join(run_dir, "results.json"), results)
+            print(f"[{len(results)}/{len(sets)}] {e['id']:16s} {row['verdict']:8s} img={row.get('images')} "
+                  f"idx={row.get('indexed_pct')}% Rsplit={row.get('r_split')} Rfree={row.get('r_free')} "
+                  f"t={row.get('wall_s')}s io={row.get('io_floor_s')}s {row.get('cache')} {row.get('reason') or ''}",
+                  flush=True)
+    except KeyboardInterrupt:
+        battery.mark_aborted(run_dir, f"interrupted after {len(results)} of {len(sets)} sets")
+        sys.exit(f"aborted; {run_dir} is marked as such")
+    man.update(end=datetime.datetime.now().isoformat(timespec="seconds"), complete=True)
+    battery.write_json(os.path.join(run_dir, "manifest.json"), man)
+    print(f"report {render(run_dir)}", flush=True)
+    battery.make_read_only(run_dir)
+    if any(r["verdict"] in ("crash", "fail") for r in results):
+        sys.exit("some sets failed: " + ", ".join(r["set"] for r in results if r["verdict"] in ("crash", "fail")))
+
+
+def run_path(st, run):
+    return run if os.path.isdir(run) else os.path.join(st["runs_root"], run)
+
+
+def cmd_compare(a, st):
+    ra = {r["set"]: r for r in json.load(open(os.path.join(run_path(st, a.run_a), "results.json")))}
+    rb = {r["set"]: r for r in json.load(open(os.path.join(run_path(st, a.run_b), "results.json")))}
+    keys = [("indexed %", "indexed_pct"), ("d_min", "d_min"), ("R_split", "r_split"), ("R_free", "r_free"),
+            ("time s", "wall_s"), ("cache", "cache")]
+    print("| set | " + " | ".join(f"{c} A -> B" for c, _ in keys) + " |")
+    print("|---|" + "---|" * len(keys))
+    for s in [s for s in ra if s in rb] + [s for s in rb if s not in ra]:
+        x, y = ra.get(s, {}), rb.get(s, {})
+        print(f"| {s} | " + " | ".join(f"{x.get(k, '-')} -> {y.get(k, '-')}" for _, k in keys) + " |")
+
+
+def cmd_list(a, st):
+    for d in sorted(glob.glob(os.path.join(st["runs_root"], "*_still-*"))):
+        man = json.load(open(os.path.join(d, "manifest.json")))
+        state = "aborted" if man.get("aborted") else "complete" if man.get("complete") else "unfinished"
+        print(f"{os.path.basename(d):60s} {state}")
+
+
+def cmd_report(a, st):
+    src = run_path(st, a.run)
+    if a.out:
+        tmp = os.path.join(a.out, os.path.basename(os.path.normpath(src)))
+        os.makedirs(tmp, exist_ok=True)
+        for f in ("manifest.json", "results.json"):
+            shutil.copyfile(os.path.join(src, f), os.path.join(tmp, f))
+        src = tmp
+    print(render(src))
+
+
+def cmd_keep(a, st):
+    src = run_path(st, a.run)
+    man = json.load(open(os.path.join(src, "manifest.json")))
+    if man.get("private") or man.get("kind") != "still":
+        sys.exit(f"{src}: refused - not a public still run")
+    dest = os.path.join(battery.KEPT_ROOT, a.role, os.path.basename(os.path.normpath(src)))
+    os.makedirs(dest, exist_ok=True)
+    for name in KEPT_FILES:
+        shutil.copyfile(os.path.join(src, name), os.path.join(dest, name))
+    print(dest)
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__.split("\n")[0])
+    ap.add_argument("--site")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+    r = sub.add_parser("run")
+    r.add_argument("--rugnux", required=True)
+    r.add_argument("--label")
+    r.add_argument("--only")
+    r.add_argument("--tier")
+    r.add_argument("--private", action="store_true", help="the site's local-only still manifest")
+    r.add_argument("--threads", type=int)
+    r.add_argument("--timeout", type=int, default=6 * 3600)
+    r.add_argument("--build-dir")
+    r.add_argument("--no-refine", action="store_true", help="skip the dimple refinement")
+    r.add_argument("--io-gbps", type=float, default=IO_GBPS)
+    c = sub.add_parser("compare")
+    c.add_argument("run_a")
+    c.add_argument("run_b")
+    p = sub.add_parser("report")
+    p.add_argument("run")
+    p.add_argument("--out")
+    sub.add_parser("list")
+    k = sub.add_parser("keep")
+    k.add_argument("run")
+    k.add_argument("--as", dest="role", required=True, choices=["workstation", "server"])
+    a = ap.parse_args()
+    st = load_site(a.site)
+    {"run": cmd_run, "compare": cmd_compare, "list": cmd_list, "report": cmd_report, "keep": cmd_keep}[a.cmd](a, st)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/battery/still_manifest.json b/tools/battery/still_manifest.json
new file mode 100644
index 000000000..1ab24c8c2
--- /dev/null
+++ b/tools/battery/still_manifest.json
@@ -0,0 +1,17 @@
+{"_comment": "The still battery (still_battery.py). inputs: globs relative to the site's still data_root, each glob's matches sorted by name; {data} in args is the data root. Every set runs with its deposition's cell and space group (-C/-S); r_free_deposited is the entry's published R-free (dark/ground-state entries only); d_cut is the deposition's resolution, used for the dimple refinement. Where to get the data: docs/EXTERNAL_TEST_DATA_STILLS.md.",
+ "sets": [
+ {"id": "sacla243", "cxidb": 243, "facility": "SACLA", "beamline": "BL2", "detector": "MPCCD (8 panels, 50 um)", "format": "Cheetah-SACLA HDF5", "pdb": "31JT", "sg": "P 2 21 21", "d_cut": 1.63, "r_free_deposited": 0.1943, "images_deposited": 52151, "inputs": ["sacla_243/raw_all/run*.h5"], "args": ["-C", "39.36,79.16,145.40,90,90,90", "-S", "P 2 21 21"], "tiers": {}},
+ {"id": "sacla237", "cxidb": 237, "facility": "SACLA", "beamline": "BL2", "detector": "MPCCD (8 panels, 50 um)", "format": "Cheetah-SACLA HDF5", "pdb": "9S06", "sg": "P 21 21 21", "d_cut": 2.05, "r_free_deposited": 0.219, "images_deposited": null, "inputs": ["sacla_237/raw/run13063[7-9]-*.h5", "sacla_237/raw/run13064[0-2]-*.h5"], "args": ["-C", "64.80,71.09,207.26,90,90,90", "-S", "P212121"], "tiers": {}},
+ {"id": "sacla236", "cxidb": 236, "facility": "SACLA", "beamline": "BL2", "detector": "MPCCD (8 panels, 50 um)", "format": "Cheetah-SACLA HDF5", "pdb": "9V3D", "sg": "P 43 21 2", "d_cut": 1.68, "r_free_deposited": 0.2252, "images_deposited": 16083, "inputs": ["sacla_236/raw/run157*.h5"], "args": ["-C", "79.45,79.45,38.15,90,90,90", "-S", "P43212"], "tiers": {"smoke": {"images": 2000}}},
+ {"id": "pal86", "cxidb": 86, "facility": "PAL-XFEL", "beamline": "NCI", "detector": "Rayonix MX225-HS (4x4 binned, 156 um)", "format": "Cheetah CXI", "pdb": "6IG7", "sg": "P 61 2 2", "d_cut": 1.8, "r_free_deposited": 0.2024, "images_deposited": null, "inputs": ["pal_86/raw/*.cxi", "pal_86/raw_more/*.cxi"], "args": ["--detector-distance", "105", "--detect-ice-rings=on", "-C", "92.663,92.663,128.591,90,90,120", "-S", "P6122"], "tiers": {}},
+ {"id": "pal90", "cxidb": 90, "facility": "PAL-XFEL", "beamline": "NCI", "detector": "Rayonix MX225-HS (4x4 binned, 156 um)", "format": "Cheetah CXI", "pdb": "6IRK", "sg": "I 2 2 2", "d_cut": 1.75, "r_free_deposited": 0.203, "images_deposited": null, "inputs": ["pal_90/raw/*.cxi"], "args": ["-C", "93.050,99.000,101.920,90,90,90", "-S", "I222"], "tiers": {"smoke": {"images": 1500}}},
+ {"id": "lcls222", "cxidb": 222, "facility": "LCLS", "beamline": "MFX", "detector": "Rayonix MX340-HS (4x4 binned, 177 um)", "format": "LCLS-I XTC", "pdb": "8TDQ", "sg": "P 65 2 2", "d_cut": 1.65, "r_free_deposited": 0.2012, "images_deposited": null, "inputs": ["lcls_222/xtc/*.xtc", "lcls_222/xtc_more/*.xtc"], "args": ["--detector-distance", "193.43", "--polarization", "0.998", "-C", "78.616,78.616,265.275,90,90,120", "-S", "P6522"], "tiers": {"smoke": {"images": 1500}}},
+ {"id": "lcls242_s", "cxidb": 242, "facility": "LCLS", "beamline": "MFX", "detector": "Rayonix MX340-HS (4x4 binned, 177 um)", "format": "LCLS-I XTC", "pdb": "9O4S", "sg": "P 1 21 1", "d_cut": 1.95, "r_free_deposited": 0.2102, "images_deposited": null, "inputs": ["lcls_242/xtc/*.xtc", "lcls_242/xtc_more/*.xtc"], "args": ["--detector-distance", "199.0", "--polarization", "0.998", "-C", "92.044,93.019,49.014,90,92.69,90", "-S", "P21"], "tiers": {}},
+ {"id": "lcls242_t", "cxidb": 242, "facility": "LCLS", "beamline": "MFX", "detector": "Rayonix MX340-HS (4x4 binned, 177 um)", "format": "LCLS-I XTC", "pdb": "9O4T", "sg": "P 1 21 1", "d_cut": 1.95, "r_free_deposited": 0.2348, "images_deposited": null, "inputs": ["lcls_242/xtc/*.xtc", "lcls_242/xtc_more/*.xtc"], "args": ["--detector-distance", "199.0", "--polarization", "0.998", "-C", "96.031,94.536,50.529,90,91.18,90", "-S", "P21"], "tiers": {}},
+ {"id": "euxfel83", "cxidb": 83, "facility": "European XFEL", "beamline": "SPB/SFX", "detector": "AGIPD 1M (200 um)", "format": "Cheetah CXI", "pdb": "6GTH", "sg": "P 32 2 1", "d_cut": 1.69, "r_free_deposited": 0.2096, "images_deposited": 14445, "inputs": ["euxfel_83/raw/*.cxi"], "args": ["--crystfel-geometry", "{data}/euxfel_83/ref/agipd_mar18_v10.geom", "--gain", "60", "--wavelength", "1.3332", "--refine-geometry=off", "-C", "41.84,41.84,233.28,90,90,120", "-S", "P3221"], "tiers": {}},
+ {"id": "euxfel152", "cxidb": 152, "facility": "European XFEL", "beamline": "SPB/SFX", "detector": "AGIPD 1M (200 um)", "format": "Cheetah CXI", "pdb": "6U57", "sg": "I 2 3", "d_cut": 2.8, "r_free_deposited": 0.2489, "images_deposited": 37006, "inputs": ["euxfel_152/raw/*.cxi"], "args": ["--crystfel-geometry", "{data}/euxfel_152/ref/kdo_embedded.geom", "--gain", "62", "--wavelength", "1.3332", "--refine-geometry=off", "-C", "118,118,118,90,90,90", "-S", "I23"], "tiers": {}},
+ {"id": "alvra103", "cxidb": 103, "facility": "SwissFEL", "beamline": "Alvra", "detector": "JUNGFRAU 16M (75 um)", "format": "SwissFEL HDF5, float32 keV", "pdb": "6S0L", "sg": "C 2 2 21", "d_cut": 2.65, "r_free_deposited": 0.2203, "images_deposited": 199136, "inputs": ["swissfel_103/raw/run*.JF06T32V01.h5"], "args": ["--crystfel-geometry", "{data}/swissfel_103/ref/jf-16M.geom", "--gain", "4.57", "--wavelength", "2.7130", "-C", "40.34,180.66,143.05,90,90,90", "-S", "C2221"], "tiers": {}},
+ {"id": "alvra103_int16", "cxidb": 103, "facility": "SwissFEL", "beamline": "Alvra", "detector": "JUNGFRAU 16M (75 um)", "format": "int16 photons, bitshuffle/LZ4 copy", "pdb": "6S0L", "sg": "C 2 2 21", "d_cut": 2.65, "r_free_deposited": 0.2203, "images_deposited": 199136, "inputs": ["swissfel_103/conv/run*_int16.h5"], "args": ["--crystfel-geometry", "{data}/swissfel_103/ref/jf-16M.geom", "--gain", "1", "--wavelength", "2.7130", "-C", "40.34,180.66,143.05,90,90,90", "-S", "C2221"], "tiers": {}},
+ {"id": "alvra213", "cxidb": 213, "facility": "SwissFEL", "beamline": "Alvra", "detector": "JUNGFRAU 4M (75 um)", "format": "SwissFEL HDF5, float32 keV", "pdb": "8BKH", "sg": "P 1 21 1", "d_cut": 1.35, "r_free_deposited": 0.2271, "images_deposited": null, "inputs": ["swissfel_213/raw/march_dark_MbCO_II-March-06/data/dark/run_*.JF06T08V01.h5"], "args": ["--crystfel-geometry", "{data}/swissfel_213/ref/mbco_march.geom", "--gain", "12.037", "--wavelength", "1.0300", "-C", "64.1,28.8,35.8,90,106.9,90", "-S", "P21"], "tiers": {}},
+ {"id": "alvra213_int16", "cxidb": 213, "facility": "SwissFEL", "beamline": "Alvra", "detector": "JUNGFRAU 4M (75 um)", "format": "int16 photons, bitshuffle/LZ4 copy", "pdb": "8BKH", "sg": "P 1 21 1", "d_cut": 1.35, "r_free_deposited": 0.2271, "images_deposited": null, "inputs": ["swissfel_213/conv/run_*_int16.h5"], "args": ["--crystfel-geometry", "{data}/swissfel_213/ref/mbco_march.geom", "--gain", "1", "--wavelength", "1.0300", "-C", "64.1,28.8,35.8,90,106.9,90", "-S", "P21"], "tiers": {}}
+]}