Files
leonarski_f 4809c1622c
Build Packages / build:portable:linux-x86_64:nocuda (push) Successful in 16m43s
Build Packages / build:jfjoch:ubuntu2404:nocuda (push) Successful in 28m46s
Build Packages / build:jfjoch:rocky8:cuda-sls9 (push) Successful in 32m5s
Build Packages / build:jfjoch:rocky9:cuda (push) Successful in 39m44s
Build Packages / build:portable:macos-arm64:nocuda (push) Successful in 5m7s
Build Packages / Create release (push) Successful in 8s
Build Packages / Build documentation (push) Successful in 49s
Build Packages / build:portable:linux-x86_64:cuda (push) Successful in 22m30s
Build Packages / build:jfjoch:rocky8:nocuda (push) Successful in 31m54s
Build Packages / build:rugnux:linux-aarch64:cuda (push) Successful in 11m29s
Build Packages / build:portable:windows-x86_64:nocuda (push) Successful in 23m51s
Build Packages / build:jfjoch:ubuntu2204:nocuda (push) Successful in 26m7s
Build Packages / build:jfjoch:ubuntu2204:cuda (push) Successful in 29m38s
Build Packages / build:portable:windows-x86_64:cuda (push) Successful in 28m6s
Build Packages / HDF5 consumer tests (DIALS, XDS) (push) Successful in 29m44s
Build Packages / build:jfjoch:rocky9:nocuda (push) Successful in 33m22s
Build Packages / Generate python client (push) Successful in 47s
Build Packages / build:jfjoch:rocky9:cuda-sls9 (push) Successful in 34m6s
Build Packages / Unit tests (push) Successful in 1h2m47s
Build Packages / build:jfjoch:rocky8:cuda (push) Successful in 35m59s
Build Packages / build:jfjoch:ubuntu2404:cuda (push) Successful in 34m8s
Build Packages / Validation Battery (push) Successful in 38m31s
v1.0.0-rc.187 (#98)
* Rugnux: Refinement several times faster, one protocol on the CPU and the GPU, parts of it on the Apple GPU; its random draws are the same on every platform.
* Rugnux: Refinement follows common practice: the free set decides only the restraint weights and the displacement model (isotropic, TLS or anisotropic, by Hamilton's test), everything else is decided on the working set; lower R-free for placed and predicted models.
* Rugnux: Restraint dictionaries via `--restraints` (or among the inputs) and more built-in ligands; a model whose space group is a subgroup of the data's is refined in its own group; reflections plus a model select `--mode refine` on their own.
* Rugnux: `-C` fixes the crystal system on the axes as typed; `-S` alone fixes the space group only, the cell is still found and reduced; a space group or cell stored in the input file is ignored, with a line in the log.
* Rugnux: More reliable multi-sweep merging; `--mode scale` merges several stills runs as one; `_plot.txt` and the report name each input; a second crystal form is reported for stills given a cell.
* jfjoch_broker (experimental): Live Rugnux on FPGA detectors (JUNGFRAU) takes the same path as a DECTRIS stream, rotation and serial alike, model step included, with analysis threads per GPU; frames waiting for the analysis can be viewed; no host stage drops a frame - a source faster than the analysis is held at the card.
* jfjoch_broker: Summation of more than 256 frames per image is split between the card and the host (`summation_mode` is then `hybrid`), and live Rugnux runs on such collections; pedestal runs take a receiver of their own.
* jfjoch_broker (experimental): `stills_downsample` analyses 1 of every N serial images (chosen by a hash; the first 2000 all; the others written without analysis; reset to 1 by `/initialize`); `max_spot_count` left out means 250 for per-image indexing and up to 1000 for live stills; the live status gives the merge before the model work, the fitted resolution and the anomalous peak height of each unexplained blob.
* jfjoch_broker: Without a `pcie` entry the broker runs on a mock of the card instead of the HLS simulation; its spot, ROI and azimuthal results are zero then.
* Web frontend: Redesigned Rugnux live page; Vite 8, TypeScript 6, Mol* 5.13 and dependency security updates.
* Tools: `jfjoch_fpga_stills_test` measures live stills on the cards with a stored dataset; `jfjoch_fpga_test` loses the HLS-simulation option.
* Other: FFTW no longer fetched or linked (the CPU FFT indexer keeps the name `FFTW`); PCIe driver now GPL-2.0-or-later and third-party notices complete; several crash fixes.

Reviewed-on: #98
Co-authored-by: Filip Leonarski <filip.leonarski@psi.ch>
2026-11-19 20:49:28 +01:00

107 lines
5.7 KiB
C++

// SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
// SPDX-License-Identifier: GPL-3.0-only
#pragma once
#include "../fpga/pcie_driver/jfjoch_fpga.h"
#include <cstdint>
#include <cstddef>
#include <chrono>
#include <array>
#include <cmath>
constexpr float WVL_1A_IN_KEV = 12.39854f;
constexpr size_t CONVERTED_MODULE_LINES = 514;
constexpr size_t CONVERTED_MODULE_COLS = 1030;
constexpr size_t CONVERTED_MODULE_SIZE = CONVERTED_MODULE_LINES * CONVERTED_MODULE_COLS;
constexpr size_t JUNGFRAU_PACKET_SIZE_BYTES = 8192;
constexpr int MAX_IMAGE_NUMBER = 2*1024*1024;
// Defaults for images_per_file when the acquisition does not ask for a particular number; see
// DiffractionExperiment::GetImagesPerFile.
constexpr int64_t DEFAULT_IMAGES_PER_FILE = 1000;
// Above this, a rotation sweep is split rather than written to one file.
constexpr int64_t ROTATION_SINGLE_FILE_IMAGE_LIMIT = 20000;
constexpr std::chrono::nanoseconds MIN_COUNT_TIME = std::chrono::microseconds(3);
constexpr std::chrono::nanoseconds MIN_STORAGE_CELL_DELAY = std::chrono::nanoseconds(2100);
constexpr std::chrono::nanoseconds MIN_FRAME_TIME_JUNGFRAU_HALF_SPEED = std::chrono::microseconds(1000);
constexpr std::chrono::nanoseconds MIN_FRAME_TIME_JUNGFRAU_FULL_SPEED = std::chrono::microseconds(470);
constexpr std::chrono::nanoseconds MIN_FRAME_TIME_EIGER = std::chrono::microseconds(250);
constexpr std::chrono::nanoseconds MAX_COUNT_TIME_JUNGFRAU = std::chrono::microseconds(2000);
constexpr std::chrono::nanoseconds FRAME_TIME_PEDE_G1G2 = std::chrono::microseconds(10*1000);
constexpr std::chrono::nanoseconds PSI_JUNGFRAU_READOUT_TIME = std::chrono::microseconds(20);
constexpr std::chrono::nanoseconds PSI_EIGER_READOUT_TIME = std::chrono::microseconds(20);
constexpr std::chrono::nanoseconds DARK_MASK_FRAME_TIME = std::chrono::milliseconds(10);
constexpr float MIN_ENERGY_KEV = 0.001;
constexpr float MAX_ENERGY_KEV = 500.0;
constexpr float DEFAULT_G0_FACTOR = 41.0f;
constexpr float DEFAULT_G1_FACTOR = -1.439f;
constexpr float DEFAULT_G2_FACTOR = -0.1145f;
constexpr float DEFAULT_HG0_FACTOR = 100.0f;
constexpr int MAX_SPOT_COUNT = 64 * 1024;
// Spots kept per image where none is given: the broker's per-image indexing (rugnux live stills takes its own default)
constexpr int DEFAULT_MAX_SPOT_COUNT = 250;
// Three spots fit any lattice at all; one short of ViableCellMinSpots (default 9) is where a fitted
// lattice stops being distinguishable from a random one, so a spot list shorter than this is never
// worth handing to indexing - and the frame gate needs the same count to validate a frame
// (AnalyzeIndexing), so a shorter list could never index anything anyway.
constexpr int MIN_SPOT_COUNT = 10;
constexpr uint32_t MASK_PEDESTAL_G0_RMS_LIMIT = (1U<<4);
constexpr size_t PEDESTAL_MIN_IMAGE_COUNT = 128;
constexpr uint16_t PEDESTAL_WRONG = (UINT16_MAX);
constexpr size_t PEDESTAL_G0_WRONG_GAIN_ALLOWED_COUNT = 2;
constexpr size_t MESSAGE_SIZE_FOR_START_END = (256*1024*1024); // pessimistic highest value
constexpr float LAB6_CELL_A = 4.156468f;
// Hexagonal-ice ring positions. The first eleven are the measured ones from:
// Moreau, Atakisi, Thorne, Acta Cryst D77, 2021, 540,554
// https://journals.iucr.org/d/issues/2021/04/00/tz5104/index.html
// That paper's Table 1 stops at 1.522 A because it says so in its own words - "pure hexagonal ice has
// 11 diffraction rings between 4 and 1.5 A resolution" - and its subject was detecting ice in the PDB,
// not masking it. Ice does not stop there, and on a detector that reaches past 1.5 A the rings it does
// not list are the ones left in the data: one strongly diffracting set had 44% of every frame's spots
// in ice bands, and beyond 1.5 A its spots were ice and nothing else.
//
// The rest are calculated, because past that paper there is nothing measured to copy. Ice Ih is
// P6_3/mmc with O on 4f, so enumerating hkl is not enough - most of what it emits is extinguished by
// the oxygen sublattice rather than by the space group, which is why (004) at 1.830 A and (104) at
// 1.657 A are absent from the measured list although they lie inside its range and its reflection
// conditions allow them. Structure factors were computed instead (oxygen only - the hydrogens are
// half-occupancy disordered and scatter X-rays weakly) and the lines kept are those reaching 3% of the
// strongest. That reproduces the measured eleven exactly, and every line it drops in their range
// computes to zero, which is what makes the same rule trustworthy below 1.522 A.
// Following Roettger, Endriss, Ihringer, Doyle & Kuhs (1994) Acta Cryst. B50, 644-648 for the cell.
//
// It stops at 1.170 A: below that the calculated real lines fall to 2-3% while the extinct ones rise
// to about 1%, and an oxygen-only calculation cannot separate them honestly any further.
constexpr std::array<float, 19> ICE_RING_RES_A = {3.895, 3.661, 3.438, 2.667, 2.249, 2.068, 1.947,
1.916, 1.882, 1.719, 1.522,
1.472, 1.443, 1.371, 1.366, 1.298, 1.261, 1.224,
1.170};
// True when resolution d (Angstrom) sits within half_width of a hexagonal-ice powder ring, in the
// q = 2*pi/d units the spot-finder uses (ice_ring_width_Q_recipA). Used to drop ice-contaminated
// reflections from scaling/merging when ice-ring handling is enabled.
inline bool IsOnIceRing(float d_A, float half_width_q_recipA) {
if (!(d_A > 0.0f))
return false;
constexpr float two_pi = 6.283185307f;
const float q = two_pi / d_A;
for (const float ice_d : ICE_RING_RES_A)
if (std::fabs(q - two_pi / ice_d) < half_width_q_recipA)
return true;
return false;
}