simulationrunner.h

Go to the documentation of this file.

 
#ifndef SIMULATIONRUNNER_H
#define SIMULATIONRUNNER_H
 
#include <QDateTime>
#include <QObject>
#include <QString>
#include <QVector>
#include <atomic>
 
class SimulationRunner : public QObject
{
    Q_OBJECT
 
public:
    explicit SimulationRunner(int jobId,
                              const QString &instanceName,
                              const QString &inpPath,
                              const QString &rptPath,
                              const QString &outPath,
                              const QString &engineVersion = "6.0.0",
                              QObject *parent = nullptr);
 
    void start();
 
    void cancel();
 
    void setPaused(bool paused);
    bool isPaused() const { return m_paused.load(); }
 
    int     jobId()   const { return m_jobId; }
    QString outPath() const { return m_outPath; }
    QString inpPath() const { return m_inpPath; }
 
    [[nodiscard]] static QString parseTwoDOutputFile(const QString &inpPath);
 
    [[nodiscard]] static QString parseTwoDOption(const QString &inpPath,
                                                  const QString &key);
 
signals:
    void started(int jobId);
 
    void simulationDatesKnown(int jobId, QDateTime start, QDateTime end);
    void progressChanged(int jobId, double fraction, QDateTime currentSimDate,
                         double runoffErrFrac, double routingErrFrac,
                         double avgTimestepSec, double twoDErrFrac);
    void warningReceived(int jobId, int code, QString message);
    void finished(int jobId, bool success, int errorCode, QString errorMessage,
                  double runoffErrFrac, double routingErrFrac,
                  double twoDErrFrac);
    void twoDSolverStats(int jobId, QString backend, int momentum, int ltsTiers,
                         qint64 steps, QVector<qint64> tierCells);
 
    // ── Slice CF.MVP — 2D inundation viz hooks ─────────────────────────────
    //
    // Emitted once the engine has initialised and 2D is active. Carries the
    // mesh geometry queried via `swmm_2d_*` on the worker thread (read-only
    // calls; safe to make there because the engine's 2D mesh is immutable
    // after SurfaceRouter2D::initialize). The GUI builds an
    // EngineMesh2DSource from these vectors and attaches a
    // SWMM2DResultsLayer to the canvas.
    //
    // `cellFlat` is cell connectivity flattened to [v0,v1,v2,v3, v0,v1,v2,v3,
    // …] — FOUR ints per cell (size = cellCount * 4), v3 = -1 for a triangle
    // (mixed triangle/quad meshes, workplans/TRI_QUAD_MESHING_PLAN_2026-09-06.md)
    // — so it ships as a single QVector<int> (a registered Qt metatype).
    // Cells are in the engine's order (triangles first, then quads); a
    // quad's vertices are in cyclic order.
    void twoDInitialized(int jobId, QString h5Path,
                          QVector<double> vx,
                          QVector<double> vy,
                          QVector<double> vz,
                          QVector<int>    cellFlat);
 
    // Per-tick depth slice from swmm_2d_get_depths_bulk. Rate-limited to the
    // existing kTickIntervalMs budget (≈ 1 Hz). The GUI pushes each slice
    // into the active EngineMesh2DSource and refreshes the layer.
    void twoDDepthsAvailable(int jobId, QVector<float> depths,
                              QDateTime simTime, double elapsedSec);
 
    // ── Slice CF.2 — velocity vector overlay hooks ─────────────────────────
    //
    // Emitted once at twoDInitialized after the engine builds its mesh, this
    // ships the time-invariant edge geometry (length + outward unit normal,
    // both indexed [cell*4 + localEdge] = mesh::edgeSlot, sized
    // mesh::edgeSlotCount(cellCount); the engine's own stride (3 or 4,
    // swmm_2d_edge_stride) is repacked before emission — slot 3 of a
    // triangle is 0). The GUI installs the arrays on the
    // active EngineMesh2DSource so client-side RT0 reconstruction has
    // everything it needs without re-deriving from vertex coords.
    void twoDEdgeGeometryAvailable(int jobId,
                                    QVector<float> length,
                                    QVector<float> nx,
                                    QVector<float> ny);
 
    // Per-tick signed edge flux from swmm_2d_get_edge_flux_bulk, repacked to
    // the same [cell*4 + localEdge] layout as twoDEdgeGeometryAvailable. Same
    // cadence as twoDDepthsAvailable; pushed into EngineMesh2DSource::pushFlux
    // on the GUI thread, paired with the matching depth tick by elapsedSec.
    void twoDFluxAvailable(int jobId, QVector<float> flux,
                            QDateTime simTime, double elapsedSec);
 
    // Per-tick rainfall intensity (m/s) + cumulative rainfall volume (m³)
    // per cell from swmm_2d_get_rainfall_bulk / swmm_2d_get_rain_volume_bulk.
    // Same cadence/pairing as twoDFluxAvailable; pushed into
    // EngineMesh2DSource::pushRainfall so the Rainfall / Rainfall volume
    // cell series are plottable live.
    void twoDRainfallAvailable(int jobId, QVector<float> rainfall,
                               QVector<float> rainCum,
                               QDateTime simTime, double elapsedSec);
 
    // Per-tick SIGNED vertex render depths from
    // swmm_2d_vertex_get_render_depths_bulk (the engine's wet-masked,
    // depth-weighted η_v − z_v reconstruction — dry-cell bed elevations never
    // contribute). Same cadence/pairing as twoDFluxAvailable; pushed into
    // EngineMesh2DSource::pushVertexSignedDepths. Negative values carry the
    // sub-cell shoreline intercept and must not be clamped.
    void twoDVertexDepthsAvailable(int jobId, QVector<double> vdepths,
                                    QDateTime simTime, double elapsedSec);
 
    // Per-tick per-cell water-surface elevation (m) from
    // swmm_2d_get_heads_bulk. Same cadence/pairing as twoDFluxAvailable;
    // pushed into EngineMesh2DSource::pushHeads so a mid-run export writes
    // the solver's head rather than a depth + bed approximation.
    void twoDHeadsAvailable(int jobId, QVector<float> heads,
                            QDateTime simTime, double elapsedSec);
 
    // Per-tick cumulative per-cell maxima (m, m/s) from
    // swmm_2d_get_stat_max_depths / swmm_2d_get_stat_max_velocities — the
    // live ENVELOPES. Monotone, so no time stamp: the receiver keeps the
    // newest payload only (EngineMesh2DSource::setEnvelopes).
    void twoDEnvelopesAvailable(int jobId, QVector<float> maxDepth,
                                QVector<float> maxVel);
 
private:
    // Warning callback — fires on the worker thread during engine
    // open/initialize, posts back via QMetaObject::invokeMethod. The
    // engine's progress callback is only invoked once (in initialize), so
    // progress is polled inline in the step loop instead, not through a
    // registered callback.
    static void warningCallback(void* engine, int code, const char *msg, void *ud);
 
    int     m_jobId;
    QString m_instanceName;
    QString m_inpPath;
    QString m_rptPath;
    QString m_outPath;
    QString m_engineVersion;
 
    std::atomic<bool> m_cancel{false};
    std::atomic<bool> m_paused{false};
    // Back-pressure for the per-tick 2D payload bundle (depths, flux,
    // rainfall, vertex depths — several MB per tick on a big mesh). Counts
    // bundles posted to the GUI thread and not yet consumed; the worker
    // skips a tick's bundle while two are still queued, so a GUI thread that
    // falls behind never accumulates an unbounded event queue.
    std::atomic<int>  m_pending2DTicks{0};
};
 
#endif // SIMULATIONRUNNER_H