AcquisitionManager

AcquisitionManager is the object that drives a single Experiment from the moment hardware initialization completes through the end of the acquisition loop. It owns the in-progress experiment shared pointer, accumulates FID waveforms and auxiliary sensor readings into the per-experiment storage tree, and emits the lifecycle signals that coordinate the main window, the hardware layer, and the batch layer. All acquisitions in Blackchirp — single-experiment runs as well as multi-experiment batch sequences — pass through AcquisitionManager. The user-facing acquisition workflow is described in Experiment Setup.

The manager lives on a dedicated QThread ("AcquisitionManagerThread") created in MainWindow. Its slots and signal emissions execute on that thread. The GUI thread uses QMetaObject::invokeMethod to cross the thread boundary when calling AcquisitionManager::beginExperiment(). Waveform processing is further dispatched to the Qt thread pool via QtConcurrent::run; the processing result is handed back to the AM thread through a QFutureWatcher<FtmwProcessingResult> so that state mutations remain thread-confined.

The immediate collaborators are:

Experiment — the in-progress experiment shared pointer; the AM writes FID data and aux readings into its storage objects and queries it for completion status.
HardwareManager (cross-thread) — receives beginAcquisition and endAcquisition to start and stop hardware triggers; provides aux data via its auxData signal; applies clock settings in response to newClockSettings.
FidStorageBase — the FID storage layer embedded in the experiment; waveform data accumulate here.
AuxDataStorage — the auxiliary sensor storage embedded in the experiment; each timed aux-data point is committed here.
BatchManager (GUI thread, queued connection) — receives experimentComplete after every acquisition loop ends and decides whether to start the next experiment.
LifStorage (LIF mode only) — the LIF storage object embedded in the experiment when a LIF scan is configured.

State machine

AcquisitionManager tracks its phase through the AcquisitionState enum.

State	Meaning
`Idle`	No experiment is running. The manager is ready for a new `beginExperiment` call.
`Acquiring`	An experiment is active. Waveform data, aux readings, and validation checks are processed as they arrive.
`Paused`	Acquisition is suspended. Incoming data are dropped until `resume()` is called.

The typical lifecycle of a single experiment is:

MainWindow::experimentInitialized receives HardwareManager::experimentInitialized, calls Experiment::initialize(), and invokes beginExperiment(exp) on the AM thread.
beginExperiment transitions to Acquiring, emits newClockSettings (FTMW experiments), emits beginAcquisition, starts the aux-data interval timer, and starts the FTMW drain timer for buffered-waveform modes.
During the loop, the aux-data timer fires periodically; each firing calls auxDataTick, which collects FTMW shot counts (and optional phase/chirp metrics), calls processAuxData, and emits auxDataSignal so HardwareManager can read sensor values.
processAuxData stores the readings in AuxDataStorage and re-emits them as auxData(map, timestamp) for plot widgets.
processValidationData checks each incoming sensor value against its configured limit; a violation triggers abort.
FTMW waveforms arrive through a WaveformBuffer polled by the drain timer. Batches of entries are dispatched to a worker via QtConcurrent::run; the QFutureWatcher<FtmwProcessingResult> delivers the result back to the AM thread. A processing failure calls abort.
checkComplete is called after each processing batch. If Experiment::canBackup is true it launches a concurrent backup via QtConcurrent::run (the QFutureWatcher<void> emits backupComplete when done). If Experiment::isComplete is true it calls finishAcquisition.
pause and resume toggle between Acquiring and Paused without stopping hardware. While Paused the drain timer still fires but skips processing.
abort marks the experiment as aborted and calls finishAcquisition.
finishAcquisition stops the drain timer, signals the worker to exit, waits for the worker to finish, emits endAcquisition, transitions to Idle, calls Experiment::finalSave, and emits experimentComplete.

Note

AcquisitionManager::experimentComplete is a signal; the identically named BatchManager::experimentComplete is a slot. The two are connected via a queued connection that crosses the AM thread into the GUI thread, and this signal-to-slot handoff is what advances a batch from one experiment to the next.

Backups

The acquisition loop launches periodic backups of the in-progress experiment on a worker thread via QtConcurrent::run. QFutureWatcher raises the backupComplete signal on the AM thread when each backup finishes, and FtmwViewWidget connects to it to refresh its list of available backups.

API Reference

struct FtmwProcessingResult

Result of a worker-thread waveform-processing batch.

Returned by the QtConcurrent worker to the AcquisitionManager event loop so that side-effect operations (advance, signals, abort) remain on the AM thread. The struct is the sole cross-thread data contract between the waveform-processing worker and the manager.

Public Members

int entriesProcessed = {0}: Number of waveform entries processed in this batch.

bool success = {true}: false if a fatal processing error occurred.

QString errorString: Non-empty when success is false; describes the error.

QString warningString: Non-empty when a non-fatal anomaly was detected.

class AcquisitionManager : public QObject

Drives a single Experiment from hardware initialization through acquisition-loop completion.

AcquisitionManager owns the in-progress Experiment shared pointer, accumulates FID data and auxiliary sensor readings into the per-experiment storage tree, and emits the signals that notify the main window, HardwareManager, and BatchManager of lifecycle events.

The manager lives on a dedicated QThread (“AcquisitionManagerThread”) created in MainWindow. All public slots and signal emissions execute on that thread. Callers on other threads must use QMetaObject::invokeMethod or queued signal/slot connections — direct calls from the GUI thread are not safe.

Waveform processing is dispatched to the Qt thread pool via QtConcurrent::run; the result is returned to the AM thread through a QFutureWatcher so that all state mutations remain thread-confined.