Files
Jungfraujoch/common/ModuleSummation.cpp
leonarski_fandClaude Opus 5.5 4e8ccc2b60 Hybrid summation: the card sums the largest divisor up to 256, the host the rest; through FPGAImagePuller too
For a summation of N frames the card sums d, the largest divisor of N not
above 256 (GetFPGASummation; 256 itself is now summed on the card), and the
host the N/d card images of each image (GetHostSummation): 1000 = 250 x 4, a
prime above 256 = 1 x N. CPUSummation(true) still puts all of it on the host.
The card writes 32-bit where it sums and the host adds to it.

FPGAImagePuller now takes summation on the host, so rugnux live runs on such
collections. Each image thread keeps one int32 module accumulator per module
(ModuleSummation, saturating, error pixels carried, as JFJochReceiverFPGA and
the HLS do), takes the card's images of its image in order, all modules of
each before the next, adds each into the accumulator and returns the card's
buffer; the summed modules then go into the thread's image as before. A
module missing from any card image is missing from the image. The card's
per-frame spots and ROI sums were already not read on this path; the
module statistics are those of the first card image with error, saturated,
packet counts and pixel sum added (ModuleSummation now adds the pixel sum
too). Packets expected per image and the not-blocking give-up distance are
in card images (x N/d).

JFJochReceiverFPGA follows the same split (it has to: the card's summation
is set by the experiment), summing N/d card images instead of N frames; its
end-of-run expected packets no longer multiply the run's total by the
summation a second time.

OpenAPI image_time_us and the broker docs describe the split; C++ model,
frontend client and python client docs regenerated. Tests: the divisor rule,
and N = 256 (card only), 1000 (250 x 4) and 257 (host only) on the mock
through both receivers, pixels against a sum done in the test with error and
saturated pixels and a 32-bit overflow.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HVeDQrPqZ52Tp6rzzZGxf3
2026-11-18 18:49:54 +01:00

135 lines
5.2 KiB
C++

// SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
// SPDX-License-Identifier: GPL-3.0-only
#include "ModuleSummation.h"
#include "JFJochException.h"
ModuleSummation::ModuleSummation(bool in_pixel_signed, uint32_t in_fpga_depth_bytes) {
pixel_signed = in_pixel_signed;
first = true;
is_empty = false;
output_depth_bytes = 4;
fpga_depth_bytes = in_fpga_depth_bytes;
if ((fpga_depth_bytes != 4)
&& (fpga_depth_bytes != 2)
&& (fpga_depth_bytes != 1))
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "FPGA byte depth can be only 1, 2 or 4");
output = std::make_unique<DeviceOutput>();
Clear();
}
void ModuleSummation::Clear() {
std::unique_lock ul(module_summation_mutex);
first = true;
is_empty = false;
memset(output.get(), 0, sizeof(DeviceOutput));
}
ModuleSummation::ModuleSummation(const DiffractionExperiment &experiment) : ModuleSummation(
experiment.IsPixelSigned(), experiment.GetByteDepthFPGA()) {
if (!experiment.IsCPUSummation())
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
"CPU summation not turned on");
if (experiment.GetByteDepthImage() != 4)
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
"CPU summation works only for 32-bit output");
}
const DeviceOutput &ModuleSummation::GetOutput() const {
return *output;
}
DeviceOutput &ModuleSummation::GetOutput() {
return *output;
}
template<class Tdst, class Tsrc>
void Add(DeviceOutput &output, const DeviceOutput &input) {
auto in_pixel = reinterpret_cast<const Tsrc *>(input.pixels);
auto out_pixel = reinterpret_cast<Tdst *>(output.pixels);
Tdst err_val_dst = std::is_signed_v<Tdst> ? std::numeric_limits<Tdst>::min() : std::numeric_limits<Tdst>::max();
Tsrc err_val_src = std::is_signed_v<Tsrc> ? std::numeric_limits<Tsrc>::min() : std::numeric_limits<Tsrc>::max();
for (int i = 0; i < RAW_MODULE_SIZE; i++) {
if ((in_pixel[i] == err_val_src) || (out_pixel[i] == err_val_dst))
out_pixel[i] = err_val_dst;
else if ((in_pixel[i] == std::numeric_limits<Tsrc>::max())
|| (out_pixel[i] == std::numeric_limits<Tdst>::max())
|| (static_cast<int64_t>(out_pixel[i]) + static_cast<int64_t>(in_pixel[i]) >= std::numeric_limits<
Tdst>::max()))
out_pixel[i] = std::numeric_limits<Tdst>::max();
else
out_pixel[i] = out_pixel[i] + in_pixel[i];
}
}
void ModuleSummation::AddFPGAOutput(const DeviceOutput &input, const std::optional<uint32_t> &in_fpga_depth_bytes) {
std::unique_lock ul(module_summation_mutex);
if (first) {
output->module_statistics = input.module_statistics;
first = false;
} else {
output->module_statistics.err_pixels += input.module_statistics.err_pixels;
output->module_statistics.saturated_pixels += input.module_statistics.saturated_pixels;
output->module_statistics.packet_count += input.module_statistics.packet_count;
output->module_statistics.pixel_sum += input.module_statistics.pixel_sum;
}
// The only function not handled is spot finding
switch (in_fpga_depth_bytes.value_or(fpga_depth_bytes)) {
case 2:
if (pixel_signed)
Add<int32_t, int16_t>(*output, input);
else
Add<uint32_t, uint16_t>(*output, input);
break;
case 4:
if (pixel_signed)
Add<int32_t, int32_t>(*output, input);
else
Add<uint32_t, uint32_t>(*output, input);
break;
case 1:
if (pixel_signed)
Add<int32_t, int8_t>(*output, input);
else
Add<uint32_t, uint8_t>(*output, input);
break;
default:
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
"Unknown bit depth");
}
for (int i = 0; i < FPGA_INTEGRATION_BIN_COUNT; i++) {
output->integration_result[i].count += input.integration_result[i].count;
output->integration_result[i].sum += input.integration_result[i].sum;
}
for (int i = 0; i < ADU_HISTO_BIN_COUNT; i++)
output->adu_histogram[i] += input.adu_histogram[i];
for (int i = 0; i < FPGA_ROI_COUNT; i++) {
output->roi_counts[i].sum += input.roi_counts[i].sum;
output->roi_counts[i].sum2 += input.roi_counts[i].sum2;
output->roi_counts[i].good_pixels += input.roi_counts[i].good_pixels;
output->roi_counts[i].sum_x_weighted += input.roi_counts[i].sum_x_weighted;
output->roi_counts[i].sum_y_weighted += input.roi_counts[i].sum_y_weighted;
if (output->roi_counts[i].max_value < input.roi_counts[i].max_value)
output->roi_counts[i].max_value = input.roi_counts[i].max_value;
}
}
void ModuleSummation::AddEmptyOutput() {
std::unique_lock ul(module_summation_mutex);
is_empty = true;
}
bool ModuleSummation::empty() const {
std::unique_lock ul(module_summation_mutex);
return is_empty;
}