Refinement GPU: the robust scale fit on the card, the pool back in every trial slot

The score's robust fine pass (pseudo-Huber IRLS of ModelScaleBox::robust) on the device, so that refinement on
a GPU no longer fits its scale on the host every cycle - with the trials side by side that was a robust grid
search on one thread per slot (13-133 s per refinement on the seven timing sets, against 1.7-8 s before the
score commit).

- ModelScaleGPU: the weights multiply the WSSR and J^T J / J^T r in scale_sums (a weight row per fit,
  reserved at the first robust fit); robust_residuals / robust_weights kernels; the median of each fit's
  first residuals taken on the host as FitModelScale takes it (nth_element at n/2, on the fits' threads);
  LevMarBatch split out of FitBatch so that the rounds restart from where a fit stands. FitSolvent(...,
  robust) refits the coarse winner in the fine pass, as FitModelScale's robust fit does; the plain fit is
  unchanged.
- ModelScaleGPUPool::Fit(..., robust); its streams at the highest priority: a fit is a chain of small
  launches the host waits on, and on a card shared with the trials' long kernels each wait queued behind
  them (refit.scale 58-87 ms -> 14-45 ms per cycle, the result the same to the bit).
- Refinement: the main context and every trial slot fit on their pool (robust); the CPU engine keeps
  FitModelScale's robust fit.

The card's fit is FitModelScale's to rounding (float residuals and weights, the steps' anisotropic factor in
float), deterministic run to run and whichever engine a fit takes: R-work/R-free of the 14 parity sets on
the GPU equal the CPU engine's to 4 digits (largest difference 1.4e-6 on the 3.6 A set).
Test: ModelScaleGPUPool_RobustMatchesFitModelScale (one reflection in fifty a 4x outlier, five cells).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015CeEGgpKdfkCTJb3YNMJcu
(cherry picked from commit d15f048cbd7ed2d6b430f9f9cb5018ca284da8f0)

image_analysis/structure_refinement/ModelScaling.cpp

@@ -471,15 +471,26 @@ double SolventBMax(const gemmi::Model &model) {
 }
 
 #ifdef JFJOCH_USE_CUDA
+// A fit is a chain of small launches, each waited for by the host's Levenberg-Marquardt: on a card shared with
+// long kernels (refinement's trials side by side) every wait would queue behind them, so the stream goes first.
+int HighestStreamPriority() {
+    int least = 0, greatest = 0;
+    cudaDeviceGetStreamPriorityRange(&least, &greatest);
+    return greatest;
+}
+
 struct ModelScaleGPUPool::Engine {
     CudaStream stream;
     ModelScaleGPU scale;
     CudaDevicePtr<float2> fcalc, fmask;
-    explicit Engine(size_t max_points) : scale(stream, max_points), fcalc(max_points), fmask(max_points) {}
+    explicit Engine(size_t max_points)
+        : stream(cudaStreamNonBlocking, HighestStreamPriority()), scale(stream, max_points), fcalc(max_points),
+          fmask(max_points) {}
 };
 
-size_t ModelScaleGPUPool::DeviceBytes(size_t max_points, size_t engines) {
-    return engines * (ModelScaleGPU::DeviceBytes(max_points) + 2 * max_points * sizeof(float2));
+size_t ModelScaleGPUPool::DeviceBytes(size_t max_points, size_t engines, bool robust) {
+    return engines * (ModelScaleGPU::DeviceBytes(max_points) + 2 * max_points * sizeof(float2) +
+                      (robust ? ModelScaleGPU::RobustBytes(max_points) : 0));
 }
 
 ModelScaleGPUPool::ModelScaleGPUPool(int device, size_t max_points, size_t engines)
@@ -500,7 +511,7 @@ ModelScaleGPUPool::~ModelScaleGPUPool() {
     set_gpu(current);
 }
 
-ModelScaleReport ModelScaleGPUPool::Fit(gemmi::Scaling<float> &scaling, double b_hi, size_t nthreads) {
+ModelScaleReport ModelScaleGPUPool::Fit(gemmi::Scaling<float> &scaling, double b_hi, size_t nthreads, bool robust) {
     const size_t n = scaling.points.size();
     std::vector<std::array<int, 3>> hkl(n);
     std::vector<double> stol2(n);
@@ -543,11 +554,11 @@ ModelScaleReport ModelScaleGPUPool::Fit(gemmi::Scaling<float> &scaling, double b
         if (cudaMemcpyAsync(e->fcalc, fc.data(), n * sizeof(float2), cudaMemcpyHostToDevice, e->stream) != cudaSuccess
             || cudaMemcpyAsync(e->fmask, fm.data(), n * sizeof(float2), cudaMemcpyHostToDevice, e->stream) != cudaSuccess)
             throw JFJochException(JFJochExceptionCategory::GPUCUDAError, "ModelScaleGPUPool: the upload failed");
-        fit = e->scale.FitSolvent(e->fcalc, e->fmask, b_hi);
+        fit = e->scale.FitSolvent(e->fcalc, e->fmask, b_hi, robust, nthreads);
     } catch (const ModelScaleGPUTooFewReflections &) {
         set_gpu(current);
         release();
-        return FitModelScale(scaling, {.b_hi = b_hi}, nthreads);
+        return FitModelScale(scaling, {.b_hi = b_hi, .robust = robust}, nthreads);
     } catch (...) {
         set_gpu(current);
         release();