leonarski_fandClaude Opus 5.5
5f731db81d
The rugnux library wrote its results itself: _process.h5 through a FileWriter, the merged/twin/_mr reflection files, the unmerged MTZs, the maps and their MTZ, the placed models, _detector.jpg and _plot.txt, and on a doubled cell it renamed files on disk. It now writes none of them. - MtzTable (common/MtzTable.h): an MTZ file's header, columns and batch headers with no file behind it. It replaces MergedReflectionsMessage and MapCoefficientsMessage in the END message, with one CBOR encoding. WriteMtz (writer/WriteRugnuxFiles.h) is the one serialiser, used by rugnux and jfjoch_writer alike; it refuses a table whose columns differ in length, name a missing dataset, carry a malformed batch header or name a space group gemmi does not know. MergedMtzTable and UnmergedMtzTable build the tables the old writers built. - ProcessResult::outputs (RugnuxOutputs) holds, for the output pass only: the answer's merge (MTZ table plus what the .cif/.hkl are written from), the twin hypothesis' and the model's choice's merges, the unmerged and unmerged-partials tables, the maps (coefficients always; the grids only with ProcessConfig::keep_map_grids), the placed models, the detector JPEG and the per-image plot table, and the start message of the no-lattice _process.h5. Map RMS is taken from the grid in memory, as the CCP4 header stated it, whether or not the map is kept. - The per-image analysis goes to a caller-supplied RugnuxImageSink; rugnux and the viewer give a FileWriter-based ProcessFileSink. The geometry pre-pass no longer makes a _01_process.h5. - The doubled cell keeps both output sets: the answer's in outputs, the other's in DoubledCell::other_outputs with its suffix; the report names files by suffix after the caller's prefix. - The output prefix, write_process_h5 and the observation dump path are gone from ProcessConfig; --dump-observations is a callback. - What used to be gated on having files to write (model validation and MR, the twin-hypothesis merges, the finalist ledger, the scaled fulls, the unmerged tables) is gated on the output pass instead, so a caller with no prefix gets the same results. - RugnuxOutputFiles (new library JFJochRugnuxOutput, linked by rugnux, the viewer and the tests) writes every file from the result with the names and formats rugnux has always used. The viewer writes its job's files the same way. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
78 lines
3.2 KiB
C++
78 lines
3.2 KiB
C++
// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
|
|
// SPDX-License-Identifier: GPL-3.0-only
|
|
|
|
#pragma once
|
|
|
|
#include <QObject>
|
|
#include <QString>
|
|
|
|
#include <atomic>
|
|
#include <chrono>
|
|
#include <memory>
|
|
#include <mutex>
|
|
#include <thread>
|
|
|
|
#include "../rugnux/Rugnux.h"
|
|
#include "../common/DiffractionExperiment.h"
|
|
#include "../common/PixelMask.h"
|
|
#include "../reader/JFJochReaderDataset.h"
|
|
|
|
Q_DECLARE_METATYPE(ProcessResult)
|
|
Q_DECLARE_METATYPE(std::vector<ReportCheck>)
|
|
|
|
// Runs one Rugnux job off the GUI thread and reports back via queued Qt signals. The job
|
|
// opens its own private reader on the file (HDF5 access is globally serialized, so this
|
|
// is safe alongside the interactive reader), so the viewer becomes a processing frontend without
|
|
// blocking the UI. Cancel() is forwarded to Rugnux::Cancel() (atomic) and works from any
|
|
// thread / at any point of the run.
|
|
class JFJochProcessController : public QObject, private RugnuxObserver {
|
|
Q_OBJECT
|
|
public:
|
|
explicit JFJochProcessController(QObject *parent = nullptr);
|
|
~JFJochProcessController() override;
|
|
|
|
bool running() const { return running_; }
|
|
|
|
public slots:
|
|
// Start a job over `file_path` with the given (fully configured) experiment + mask + config.
|
|
// Ignored if a job is already running.
|
|
// The files go to `output_prefix` (none where it is empty), the _process.h5 among them only with
|
|
// `write_process_h5`.
|
|
void start(const QString &file_path, DiffractionExperiment experiment,
|
|
PixelMask pixel_mask, ProcessConfig config, QString output_prefix, bool write_process_h5);
|
|
void cancel();
|
|
|
|
signals:
|
|
void started();
|
|
void phaseChanged(QString phase);
|
|
void progress(quint64 done, quint64 total);
|
|
// `report` is the rugnux result report (the <prefix>_report.txt text), rendered from the run's
|
|
// own results so the viewer can show it without a file; empty for a cancelled run. `checks` is
|
|
// the same report's pathology checklist.
|
|
void finished(ProcessResult result, QString report, std::vector<ReportCheck> checks);
|
|
void failed(QString error);
|
|
// Per-image results accumulated so far, for live dataset-info plots while a job runs (throttled).
|
|
void liveDataset(std::shared_ptr<const JFJochReaderDataset> dataset);
|
|
|
|
private:
|
|
// RugnuxObserver - called from worker threads, forwarded as queued signals.
|
|
void OnPhase(const std::string &phase) override;
|
|
void OnProgress(uint64_t done, uint64_t total) override;
|
|
void OnImageProcessed(const DataMessage &msg) override;
|
|
|
|
void run_(QString file_path, DiffractionExperiment experiment, PixelMask pixel_mask, ProcessConfig config,
|
|
QString output_prefix, bool write_process_h5);
|
|
void joinWorker_();
|
|
|
|
std::thread worker_;
|
|
std::atomic<Rugnux *> active_{nullptr};
|
|
std::atomic<bool> running_{false};
|
|
std::atomic<bool> cancel_pending_{false};
|
|
|
|
// Live per-image results, accumulated by OnImageProcessed (worker threads) and emitted as
|
|
// immutable copies. live_mutex_ guards both the dataset and the throttle timestamp.
|
|
std::mutex live_mutex_;
|
|
std::shared_ptr<JFJochReaderDataset> live_dataset_;
|
|
std::chrono::steady_clock::time_point last_live_emit_;
|
|
};
|