Files
leonarski_fandClaude Opus 5.5 8bad85f9f4 Live stills in JFJochReceiverRugnux, not in JFJochReceiverFPGA
With rugnux live mode on, a serial collection from a DECTRIS detector now runs the
whole live stills workflow instead of per-image analysis only: the frames wait in the
image buffer for a pre-pass that fixes the beam centre, distance and mask, are analysed
on the GPU at that geometry, and are merged at half and three quarters of the images and
after the last. With a model, it is placed, mapped and refined on each merge. The start
message waits for the pre-pass, the end message carries the merged data, and /rugnux/status
and the frontend report the run. The receiver uses only what a puller delivers, a
DataMessage with a compressed image, so a later FPGA puller feeds the same code.

FPGA users lose this until that puller exists: JFJochReceiverFPGA has no stills path any
more, so a JUNGFRAU or PSI EIGER collection with rugnux on runs image by image on the
card's results, as with the mode off, with /rugnux/status idle, no pre-pass and no live
merge.

From a stream there are no module packets: efficiency is the images received over those
expected, a frame not delivered leaves no entry, and per-image collection efficiency, ADU
histograms and pulse IDs are absent.

The dark frames of the mask sequence always stay with JFJochReceiverLite. Selection used to
look only at the goniometer, so POST /pedestal after a rotation /start with rugnux on went
to the rugnux receiver and returned an empty mask. Frames numbered outside the collection
are dropped: the analysis keeps per-image results by number, and they corrupted the heap.

Carries the behaviour of the live commits of rc184, updated for this receiver: the geometry
fixed when the pre-pass ends (the running refinement is removed), the q range fixed, the
pre-pass holding more frames until the geometry can be fitted, frames arriving during it
waiting in the whole image buffer, the indexer pool's device memory report, the stills model
step on provisional merges and after the last image, /cancel cutting it, and the model and
Mol* viewer of a serial run during the collection.

Rotation on this receiver is unchanged: end to end, the old and new receiver wrote a
byte-identical MTZ.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-07 14:50:39 +01:00

97 lines
3.1 KiB
C++

// SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
// SPDX-License-Identifier: GPL-3.0-only
#pragma once
#include "ThreadSafeFIFO.h"
#include "DiffractionExperiment.h"
class ZeroCopyReturnValue;
enum class ImageBufferEntryStatus {Empty, InPreparation, Sending, Idle};
struct ImageBufferStatus {
std::vector<int64_t> images_in_the_buffer;
int64_t min_image_number;
int64_t max_image_number;
int64_t total_slots;
int64_t available_slots;
int64_t preparation_slots;
int64_t sending_slots;
std::optional<int64_t> current_counter;
};
struct ImageBufferEntry {
int64_t image_number = -1;
size_t image_size = 0;
int64_t readers = 0;
ImageBufferEntryStatus status = ImageBufferEntryStatus::Empty;
bool indexed = false;
};
class ImageBuffer {
mutable std::mutex m;
std::condition_variable cv_preview_done;
std::condition_variable cv_preparation_done;
std::condition_variable cv_send_done;
uint8_t *buffer;
const size_t buffer_size;
size_t slot_size = 0;
int64_t slot_count = 0;
std::queue<uint32_t> free_slots;
std::vector<ImageBufferEntry> v;
std::vector<ZeroCopyReturnValue> send_buffer_zero_copy_ret_val;
int64_t slots_preparation = 0;
int64_t slots_sending = 0;
int64_t slots_in_preview = 0;
int64_t slots_idle = 0;
bool disable_requests = true; // All requests fail in this state
int64_t counter = 0; // Counter is increased when something changes in the image buffer
std::mutex start_message_mutex;
std::vector<uint8_t> start_message;
// Assumes existing lock
bool FinalizeInternal(std::unique_lock<std::mutex> &ul,
std::chrono::microseconds timeout = std::chrono::milliseconds(2500));
std::optional<uint32_t> getHandle(int64_t image_number) const;
std::optional<uint32_t> getHandleMaxImage() const;
std::optional<uint32_t> getHandleMaxIndexedImage() const;
uint8_t *GetBufferLocation(size_t id); // image metadata + image
public:
constexpr static int64_t MaxImage = -1;
constexpr static int64_t MaxIndexedImage = -2;
explicit ImageBuffer(size_t buffer_size_bytes);
~ImageBuffer();
ImageBuffer(const ImageBuffer &) = delete;
ImageBuffer &operator=(const ImageBuffer &) = delete;
void StartMeasurement(size_t buffer_location_size);
void StartMeasurement(const DiffractionExperiment& experiment);
// Nullptr where no more than `keep_free` slots are free.
ZeroCopyReturnValue *GetImageSlot(int64_t keep_free = 0);
void ReadyToSend(uint32_t location, int64_t image_number, size_t image_size, bool indexed);
void ReleaseSlot(uint32_t location);
int64_t GetAvailSlots() const;
size_t GetBufferSize() const;
bool CheckIfBufferReturned(std::chrono::microseconds timeout);
bool Finalize(std::chrono::microseconds timeout);
bool GetImage(std::vector<uint8_t> &out_v, int64_t image_number = MaxImage);
void SaveStartMessage(const std::vector<uint8_t> &msg);
void GetStartMessage(std::vector<uint8_t> &out_v);
ImageBufferStatus GetStatus() const;
};