leonarski_fandClaude Opus 5
ac202a55a1
An image with 65535 or more strong pixels was given up on and reported ZERO spots - silently, no log line, indistinguishable from a frame that did not diffract. 65535 is one pixel in 64 of the JUNGFRAU 4M the number was written for; left fixed while the detectors grew it became one in 276 of an 18-megapixel EIGER, which a strongly diffracting crystal passes on its best frames. On the strong rotation set just added to the battery it cost 767 of 1800 images: peakCountUnfiltered 0 and resolutionEstimate NaN across two blocks of the sweep, the two where the crystal diffracts hardest. Make the bar one pixel in 64 everywhere, and never below the value that stood here, so no smaller detector loses ground. It lived in three places - the host extractor, StrongPixelSet, and SpotExtractorGPU's buffer capacity - now one function. The bar was there for a reason and raising it alone would not have been safe. sparseccl walks a sliding window of the last two lines and tests every pixel in it, which is quadratic in how many strong pixels a line pair holds: a handful for the silicon-tracker hits upstream wrote it for, four thousand for a lit detector line, and 76 seconds for a fully lit frame. But the pixels arrive in raster order, so the window need not be walked at all - a pixel's earlier 8-neighbours are the one to its left and the at most three above it, which is what the GPU extractor already finds by binary search. Keeping the previous line's range and a forward-only cursor gives the same edge set and the same unions in the same order, so the labels are identical, and the fully lit frame now takes 0.16 s. Verified bit-identical on real frames, on fully dense frames, across occupancy 1e-5 to 5e-2, and on 4000 randomised images including ones with blank lines; SpotExtractorGPU's host-vs-device parity test passes untouched. ImagePreprocessorBufferGPU's gather staging was sized to the old constant, with a comment tying it to the caller's give-up. Raising that give-up without it would have run the gather off the end of the device buffer, so it follows the same limit now. Byte-identical .hkl on three battery crystals that never reach the bar. On the strong set, with symmetry, cell and geometry pinned so only the spot list moves: <I/sigma> better in every resolution shell, CC1/2 97.8 -> 98.5%, R_meas 30.5 -> 28.4%, ISa 3.36 -> 3.58, indexing rate 0.772 -> 0.824. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01FBumeJVx4oeXxiBRpkrE5H
37 lines
1.7 KiB
C++
37 lines
1.7 KiB
C++
// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
|
|
// SPDX-License-Identifier: GPL-3.0-only
|
|
|
|
#pragma once
|
|
|
|
#include <memory>
|
|
|
|
#include "ImagePreprocessorBuffer.h"
|
|
#include "../indexing/CUDAMemHelpers.h"
|
|
#include "../spot_finding/SpotFindingSettings.h"
|
|
|
|
class ImagePreprocessorBufferGPU : public ImagePreprocessorBuffer {
|
|
CudaDevicePtr<int32_t> gpu_image;
|
|
CudaRegisteredVector<int32_t> buffer_reg;
|
|
|
|
// Staging for Gather(). Its only caller is ImageSpotFinder::ExtractSpots, which gives up on a frame
|
|
// with StrongPixelLimit or more strong pixels (the connected-component search rejects it anyway),
|
|
// so that is the largest gather that can be asked for. It follows the detector, so this has to as
|
|
// well - sized to a constant while the caller's bar was raised, the gather would run off the end
|
|
// of the buffer rather than merely lose the frame.
|
|
const size_t max_gather;
|
|
CudaDevicePtr<uint32_t> gpu_gather_index;
|
|
CudaDevicePtr<int32_t> gpu_gather_value;
|
|
// Own stream: every analysis engine synchronises its own stream before it returns, so the device
|
|
// image is final by the time a gather is asked for. The NULL stream would serialise all workers.
|
|
CudaStream gather_stream;
|
|
|
|
public:
|
|
// host_mirror = false skips the host copy of the preprocessed image entirely (and with it the
|
|
// page-locking): pass it when every engine reading this buffer runs on the device.
|
|
explicit ImagePreprocessorBufferGPU(size_t npixel, bool host_mirror = true);
|
|
|
|
int32_t *getGPUBuffer() override;
|
|
const int32_t *getGPUBuffer() const override;
|
|
void Gather(const std::vector<uint32_t> &npixel, std::vector<int32_t> &values) const override;
|
|
};
|