v1.0.0-rc.178 (#88)

* Rugnux: Processes serial crystallography data from XFELs - SACLA (MPCCD), PAL-XFEL and European XFEL (CXI), LCLS (XTC) and SwissFEL Alvra (JUNGFRAU with a CrystFEL module geometry) - with several files or Jungfraujoch master files merged in one run (`rugnux *_master.h5`).
* Rugnux: Stills processing takes a known unit cell and space group as a starting point, finds the beam centre (and, with a cell, the detector distance) from the images, detects the saturation level in other facilities' files and refines the placement of individual detector panels.
* Rugnux: The stills report gives R_split and CC1/2 from frame half-sets, comparable with CrystFEL.
* jfjoch_viewer: Opens the same XFEL file formats.
* Validation: A stills battery checks Rugnux against deposited structures from SACLA, PAL-XFEL, LCLS, European XFEL and SwissFEL.
* Rugnux: More reliable convergence of rotation scaling, and live molecular replacement starts as soon as the model is uploaded.
* jfjoch_broker: Initialize clears the previous dataset's bearer tokens, image buffer and live Rugnux status, and a slow CUDA JIT cache is reported at start.

Reviewed-on: #88
Co-authored-by: Filip Leonarski <filip.leonarski@psi.ch>

image_analysis/structure_refinement/ModelValidation.cpp

@@ -41,6 +41,7 @@
 #include "ModelFFT.h"
 #include "ModelGrid.h"   // PutModelDensityOnGrid, PutMaskOnGrid
 #include "RigidBodyRefine.h"
+#include "MolecularReplacement.h"   // the warm-up of a prediction
 #include "SigmaA.h"
 #ifdef JFJOCH_USE_CUDA
 #include "ModelStructureFactorsGPU.h"
@@ -1964,8 +1965,7 @@ ModelValidationResult ValidateAgainstModel(const std::vector<MergedReflection> &
                                            const ModelValidationSchedule &schedule,
                                            const gemmi::Op *twin_law,
                                            const gemmi::Structure *placed) {
-    if (const auto w = LastWarmUp(); w.valid())
-        w.wait();
+    WaitForModelWarmUp();
 #ifdef JFJOCH_USE_CUDA
     // A CUDA failure ends the validation, not the run, and nothing is moved to the CPU part way through:
     // the validation reports why it did not finish, and a validation that did not finish decides nothing,
@@ -1989,6 +1989,11 @@ ModelValidationResult ValidateAgainstModel(const std::vector<MergedReflection> &
 #endif
 }
 
+void WaitForModelWarmUp() {
+    if (const auto w = LastWarmUp(); w.valid())
+        w.wait();
+}
+
 void WarmUpModelValidation(std::shared_ptr<const RugnuxModel> model, size_t nthreads, Logger logger) {
 #ifdef JFJOCH_USE_CUDA
     if (!model || get_gpu_count() == 0)
@@ -2002,6 +2007,26 @@ void WarmUpModelValidation(std::shared_ptr<const RugnuxModel> model, size_t nthr
         // Held for as long as it runs: work beside a run waits for it where the card is too small for both.
         GPUWorkBeside beside;
         Logger quiet = Logger::Buffered();
+        if (const SearchModel search = PrepareSearchModel(*model); search.failure_reason.empty() && search.predicted) {
+            std::string failure;
+            try {
+                const MolecularReplacementWarmUp w = WarmUpMolecularReplacement(*model, nthreads);
+                failure = w.failure_reason;
+                if (w.placed) {
+                    ModelValidationSchedule placed_elsewhere;
+                    placed_elsewhere.fit_test = false;
+                    failure = Validate(w.merged, w.cell, *model, quiet, &w.space_group, false, nthreads, 0.0, {},
+                                       placed_elsewhere, nullptr, true, w.placed.get()).failure_reason;
+                }
+            } catch (const std::exception &e) {
+                cuda_clear_error();
+                failure = e.what();
+            }
+            logger.Info("Molecular replacement warm-up on the GPU: {:.2f} s{}",
+                        std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count(),
+                        failure.empty() ? "" : " (did not finish: " + failure + ")");
+            return;
+        }
         const double d_min = model->structure.resolution > 0.0 ? model->structure.resolution : 2.0;
         std::vector<MergedReflection> fake = ModelReferenceIntensities(*model, std::nullopt, nullptr, d_min, quiet);
         for (size_t i = 0; i < fake.size(); i++) {