Build Packages / Build documentation (push) Successful in 48s
Build Packages / build:portable:linux-x86_64:nocuda (push) Successful in 15m47s
Build Packages / build:portable:linux-x86_64:cuda (push) Successful in 23m19s
Build Packages / build:portable:windows-x86_64:nocuda (push) Successful in 18m47s
Build Packages / build:portable:macos-arm64:nocuda (push) Successful in 5m54s
Build Packages / build:rugnux:linux-aarch64:cuda (push) Successful in 11m27s
Build Packages / build:jfjoch:ubuntu2204:cuda (push) Successful in 26m59s
Build Packages / Unit tests (push) Successful in 1h50m25s
Build Packages / Validation Battery (push) Successful in 46m38s
Build Packages / build:jfjoch:rocky8:nocuda (push) Successful in 32m52s
Build Packages / build:jfjoch:rocky9:nocuda (push) Successful in 32m32s
Build Packages / build:jfjoch:ubuntu2204:nocuda (push) Successful in 28m34s
Build Packages / build:jfjoch:ubuntu2404:nocuda (push) Successful in 29m19s
Build Packages / build:jfjoch:rocky8:cuda-sls9 (push) Successful in 30m11s
Build Packages / build:jfjoch:rocky9:cuda-sls9 (push) Successful in 33m58s
Build Packages / build:jfjoch:rocky8:cuda (push) Successful in 31m26s
Build Packages / build:jfjoch:rocky9:cuda (push) Successful in 34m4s
Build Packages / HDF5 consumer tests (DIALS, XDS) (push) Successful in 32m17s
Build Packages / Generate python client (push) Successful in 32s
Build Packages / Create release (push) Successful in 9s
Build Packages / build:jfjoch:ubuntu2404:cuda (push) Successful in 31m50s
Build Packages / build:portable:windows-x86_64:cuda (push) Successful in 19m38s
* jfjoch_broker (experimental): Live Rugnux covers serial collections from DECTRIS detectors; a rotation collection too large for the image buffer falls back to standard per-image processing with a warning, and a stream that ends without its end message finishes the collection instead of hanging it. * jfjoch_broker (experimental): Live Rugnux settings to build the solvent during refinement and to process a rotation collection as stills, a Clear action for the last result, a `_report.txt` for live rotation runs, R-free reported for the refined model, and ice-ring detection on by default for rotation as in the command line. * jfjoch_broker (experimental): More complete and reproducible live serial merges, analysed for twinning, pseudo-translation and anisotropy, with merging statistics by resolution shell in the live status. * jfjoch_writer: Live results with large models are written reliably; update jfjoch_writer together with jfjoch_broker. * Rugnux: Several masters can be processed together with `--force-still`, including grid scans; more robust and faster merging of several sweeps; improved twinning, pseudo-translation, anisotropy, anomalous-signal and space-group decisions. * Rugnux: Molecular replacement places the copies of a multi-copy solution together; the pseudo-translation warning quotes the Patterson peak and is not raised once a model is placed; the report advises on extending the rotation or reorienting the crystal where the coverage would gain from it. * Web frontend: Light and dark modes, a phone layout, a hideable page list, a redesigned Rugnux live page with step-through of the Fo-Fc peaks in the structure view. * jfjoch_viewer: A broker URL given on the command line follows the running collection. Reviewed-on: #97 Co-authored-by: Filip Leonarski <filip.leonarski@psi.ch>
134 lines
5.2 KiB
C++
134 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 "JFJochReceiverLite.h"
|
|
#include "../common/CUDAWrapper.h"
|
|
|
|
using namespace std::chrono_literals;
|
|
|
|
int64_t JFJochReceiverLite::NumberOfThreads(int64_t requested_thread_number,
|
|
const DiffractionExperiment &in_experiment) {
|
|
int64_t number_of_images = in_experiment.GetImageNum();
|
|
auto image_time = in_experiment.GetImageTime();
|
|
|
|
if (requested_thread_number <= 0)
|
|
return 1;
|
|
|
|
// For very small datasets no need to go multithreaded
|
|
if (number_of_images < 4)
|
|
return 1;
|
|
|
|
if (number_of_images < 16)
|
|
return std::min<int64_t>(2, requested_thread_number);
|
|
|
|
// For 100 Hz, there is no reason to go for a very large number of threads
|
|
if (number_of_images < 256 || (image_time >= 10ms))
|
|
return std::min<int64_t>(16, requested_thread_number);
|
|
|
|
return requested_thread_number;
|
|
}
|
|
|
|
JFJochReceiverLite::JFJochReceiverLite(const DiffractionExperiment &in_experiment,
|
|
const PixelMask &in_pixel_mask,
|
|
ImagePuller &in_image_puller,
|
|
ImagePusher &in_image_pusher,
|
|
Logger &in_logger,
|
|
int64_t forward_and_sum_nthreads,
|
|
const SpotFindingSettings &in_spot_finding_settings,
|
|
JFJochReceiverCurrentStatus &in_current_status,
|
|
JFJochReceiverPlots &in_plots,
|
|
ImageBuffer &in_image_buffer,
|
|
ZMQPreviewSocket *in_zmq_preview_socket,
|
|
ZMQMetadataSocket *in_zmq_metadata_socket,
|
|
IndexerThreadPool *indexing_thread_pool)
|
|
: JFJochReceiverStream(in_experiment,
|
|
in_pixel_mask,
|
|
in_image_puller,
|
|
in_image_pusher,
|
|
in_logger,
|
|
NumberOfThreads(forward_and_sum_nthreads, in_experiment),
|
|
in_spot_finding_settings,
|
|
in_current_status,
|
|
in_plots,
|
|
in_image_buffer,
|
|
in_zmq_preview_socket,
|
|
in_zmq_metadata_socket),
|
|
// retain_outcomes=false: the receiver indexes only, there is no scaling or merging at the end
|
|
indexer(experiment, indexing_thread_pool, false, /*real_time=*/true),
|
|
analysis(nthreads) {
|
|
StartThreads();
|
|
}
|
|
|
|
JFJochReceiverLite::~JFJochReceiverLite() {
|
|
cancelled = true;
|
|
JoinThreads();
|
|
}
|
|
|
|
void JFJochReceiverLite::ImageThread(uint32_t id) {
|
|
logger.Debug("Thread {} started", id);
|
|
|
|
try {
|
|
pin_gpu();
|
|
} catch (const JFJochException &e) {
|
|
logger.Warning("Error pinning GPU {}", e.what());
|
|
}
|
|
|
|
WaitForImages();
|
|
|
|
try {
|
|
// The analysis works on the assembled image; an image in raw module layout is only forwarded.
|
|
if (experiment.IsGeometryTransformed())
|
|
analysis[id] = std::make_unique<MXAnalysisWithoutFPGA>(experiment, *az_int_mapping, pixel_mask, indexer,
|
|
/*enable_fused_adaptive_gpu=*/true);
|
|
} catch (const JFJochException &e) {
|
|
Cancel(e);
|
|
return;
|
|
}
|
|
|
|
PollImages(id);
|
|
|
|
logger.Debug("Thread {} finished", id);
|
|
}
|
|
|
|
void JFJochReceiverLite::AddToEndMessage(EndMessage &message) {
|
|
JFJochReceiverStream::AddToEndMessage(message);
|
|
AddIndexingToEndMessage(message, indexer);
|
|
}
|
|
|
|
void JFJochReceiverLite::OnImage(uint32_t id, DataMessage &data_msg, std::chrono::steady_clock::time_point received) {
|
|
auto start = std::chrono::high_resolution_clock::now();
|
|
|
|
CountImage(data_msg);
|
|
|
|
auto image_start_time = std::chrono::high_resolution_clock::now();
|
|
|
|
AzimuthalIntegrationProfile profile(*az_int_mapping);
|
|
if (analysis[id]) {
|
|
// Indexing only: integration is rugnux's (live or offline), not the Lite receiver's.
|
|
SpotFindingSettings settings = GetSpotFindingSettings();
|
|
settings.quick_integration = false;
|
|
analysis[id]->AnalyzeStreamImage(data_msg, profile, settings);
|
|
}
|
|
|
|
auto image_end_time = std::chrono::high_resolution_clock::now();
|
|
std::chrono::duration<float> image_duration = image_end_time - image_start_time;
|
|
|
|
data_msg.processing_time_s = image_duration.count();
|
|
StampImage(data_msg, image_puller.GetCurrentFifoUtilization());
|
|
AddToAverages(data_msg);
|
|
|
|
plots.Add(data_msg, profile);
|
|
scan_result.Add(data_msg);
|
|
|
|
if (!serialmx_filter.ApplyFilter(data_msg))
|
|
++images_skipped;
|
|
else
|
|
ForwardImage(data_msg, image_buffer.GetImageSlot());
|
|
|
|
auto end = std::chrono::high_resolution_clock::now();
|
|
std::chrono::duration<float> duration_total = end - start;
|
|
logger.Debug("Thread {} Image {:6d} processing {:8.04f} s analysis {:8.04f} s",
|
|
id, data_msg.number, duration_total.count(), image_duration.count());
|
|
}
|
|
|