[Application] Integrate staged batch run with latest main

Author: SilverSupplier

CMakeLists.txt

@@ -82,6 +82,8 @@ add_library(safecrowd_domain STATIC
     src/domain/PopulationSpec.h
     src/domain/ScenarioAuthoring.h
     src/domain/ScenarioAuthoring.cpp
+    src/domain/ScenarioBatchRunner.h
+    src/domain/ScenarioBatchRunner.cpp
     src/domain/ScenarioRiskMetrics.h
     src/domain/ScenarioRiskMetrics.cpp
     src/domain/ScenarioRiskMetricsSystem.cpp
@@ -156,6 +158,7 @@ if (BUILD_TESTING)
         tests/DeterministicRngTests.cpp
         tests/ScenarioSimulationRunnerTests.cpp
         tests/ScenarioAuthoringTests.cpp
+        tests/ScenarioBatchRunnerTests.cpp
     )
 
     target_include_directories(safecrowd_tests
@@ -191,6 +194,7 @@ if (SAFECROWD_BUILD_APP)
         src/application/ProjectNavigatorWidget.h
         src/application/ProjectPersistence.h
         src/application/ScenarioAuthoringWidget.h
+        src/application/ScenarioBatchResultWidget.h
         src/application/ScenarioCanvasWidget.h
         src/application/ScenarioResultWidget.h
         src/application/ScenarioRunWidget.h
@@ -213,6 +217,7 @@ if (SAFECROWD_BUILD_APP)
         src/application/ProjectNavigatorWidget.cpp
         src/application/ProjectPersistence.cpp
         src/application/ScenarioAuthoringWidget.cpp
+        src/application/ScenarioBatchResultWidget.cpp
         src/application/ScenarioCanvasWidget.cpp
         src/application/ScenarioResultWidget.cpp
         src/application/ScenarioRunWidget.cpp

src/application/MainWindow.cpp

@@ -12,6 +12,7 @@
 #include "application/ProjectPersistence.h"
 #include "application/ProjectNavigatorWidget.h"
 #include "application/ScenarioAuthoringWidget.h"
+#include "application/ScenarioBatchResultWidget.h"
 #include "application/ScenarioResultWidget.h"
 #include "application/ScenarioRunWidget.h"
 #include "domain/DemoFixtureService.h"
@@ -73,12 +74,17 @@ ProjectWorkspaceState makeEvacuationScenarioDemoWorkspace() {
     workspace.activeView = ProjectWorkspaceView::ScenarioResult;
     workspace.authoring = std::move(authoring);
     workspace.runningScenario = fixture.alternativeScenario;
+    workspace.runningScenarios = {fixture.baselineScenario, fixture.alternativeScenario};
     workspace.result = SavedScenarioResultState{
-        .scenario = std::move(fixture.alternativeScenario),
+        .scenario = fixture.alternativeScenario,
         .frame = std::move(fixture.frame),
         .risk = std::move(fixture.risk),
         .artifacts = std::move(fixture.artifacts),
     };
+    workspace.batchResult = SavedScenarioBatchResultState{
+        .results = {*workspace.result},
+        .currentResultIndex = 0,
+    };
     return workspace;
 }
 
@@ -410,6 +416,15 @@ void MainWindow::openProject(const ProjectMetadata& metadata) {
         }
         break;
     case ProjectWorkspaceView::ScenarioRun:
+        if (!workspace.runningScenarios.empty()) {
+            showScenarioRun(
+                *importResult.layout,
+                std::move(workspace.runningScenarios),
+                workspace.authoring.has_value()
+                    ? std::make_optional(initialStateFromSaved(*workspace.authoring, *importResult.layout))
+                    : std::nullopt);
+            return;
+        }
         if (workspace.runningScenario.has_value()) {
             showScenarioRun(
                 *importResult.layout,
@@ -421,6 +436,16 @@ void MainWindow::openProject(const ProjectMetadata& metadata) {
         }
         break;
     case ProjectWorkspaceView::ScenarioResult:
+        if (workspace.batchResult.has_value() && workspace.batchResult->results.size() > 1) {
+            showScenarioBatchResult(
+                *importResult.layout,
+                workspace.batchResult->results,
+                workspace.batchResult->currentResultIndex,
+                workspace.authoring.has_value()
+                    ? std::make_optional(initialStateFromSaved(*workspace.authoring, *importResult.layout))
+                    : std::nullopt);
+            return;
+        }
         if (workspace.result.has_value()) {
             showScenarioResult(
                 *importResult.layout,
@@ -477,6 +502,22 @@ void MainWindow::saveCurrentProject() {
     if (auto* authoringWidget = visibleChild<ScenarioAuthoringWidget>(centralWidget())) {
         workspace.activeView = ProjectWorkspaceView::ScenarioAuthoring;
         workspace.authoring = authoringWidget->currentSavedState();
+    } else if (auto* batchResultWidget = visibleChild<ScenarioBatchResultWidget>(centralWidget())) {
+        workspace.activeView = ProjectWorkspaceView::ScenarioResult;
+        if (auto authoring = batchResultWidget->returnAuthoringState(); authoring.has_value()) {
+            workspace.authoring = savedStateFromInitial(*authoring);
+        }
+        workspace.batchResult = SavedScenarioBatchResultState{
+            .results = batchResultWidget->results(),
+            .currentResultIndex = batchResultWidget->currentResultIndex(),
+        };
+        if (!workspace.batchResult->results.empty()) {
+            const auto index = std::clamp(
+                workspace.batchResult->currentResultIndex,
+                0,
+                static_cast<int>(workspace.batchResult->results.size()) - 1);
+            workspace.result = workspace.batchResult->results[static_cast<std::size_t>(index)];
+        }
     } else if (auto* resultWidget = visibleChild<ScenarioResultWidget>(centralWidget())) {
         workspace.activeView = ProjectWorkspaceView::ScenarioResult;
         if (resultWidget->returnAuthoringState().has_value()) {
@@ -494,6 +535,7 @@ void MainWindow::saveCurrentProject() {
             workspace.authoring = savedStateFromInitial(*runWidget->returnAuthoringState());
         }
         workspace.runningScenario = runWidget->scenario();
+        workspace.runningScenarios = runWidget->scenarios();
     }
 
     if (!ProjectPersistence::saveProjectWorkspace(currentProject_, workspace, &errorMessage)) {
@@ -603,10 +645,20 @@ void MainWindow::showScenarioRun(
     const safecrowd::domain::FacilityLayout2D& layout,
     const safecrowd::domain::ScenarioDraft& scenario,
     std::optional<ScenarioAuthoringWidget::InitialState> returnAuthoringState) {
+    showScenarioRun(
+        layout,
+        std::vector<safecrowd::domain::ScenarioDraft>{scenario},
+        std::move(returnAuthoringState));
+}
+
+void MainWindow::showScenarioRun(
+    const safecrowd::domain::FacilityLayout2D& layout,
+    std::vector<safecrowd::domain::ScenarioDraft> scenarios,
+    std::optional<ScenarioAuthoringWidget::InitialState> returnAuthoringState) {
     setCentralWidget(new ScenarioRunWidget(
         currentProject_.name,
         layout,
-        scenario,
+        std::move(scenarios),
         [this]() {
             saveCurrentProject();
         },
@@ -622,8 +674,37 @@ void MainWindow::showScenarioRun(
                 showLayoutReview(currentProject_);
             }
         },
-        this,
-        std::move(returnAuthoringState)));
+        std::move(returnAuthoringState),
+        this));
+}
+
+void MainWindow::showScenarioBatchResult(
+    const safecrowd::domain::FacilityLayout2D& layout,
+    std::vector<SavedScenarioResultState> results,
+    int currentResultIndex,
+    std::optional<ScenarioAuthoringWidget::InitialState> returnAuthoringState) {
+    setCentralWidget(new ScenarioBatchResultWidget(
+        currentProject_.name,
+        layout,
+        std::move(results),
+        [this]() {
+            saveCurrentProject();
+        },
+        [this]() {
+            hasCurrentProject_ = false;
+            currentProject_ = {};
+            showProjectNavigator();
+        },
+        [this]() {
+            if (lastApprovedImportResult_.has_value()) {
+                showLayoutReview(currentProject_, *lastApprovedImportResult_);
+            } else {
+                showLayoutReview(currentProject_);
+            }
+        },
+        std::move(returnAuthoringState),
+        currentResultIndex,
+        this));
 }
 
 void MainWindow::showScenarioResult(

src/application/MainWindow.h

@@ -1,10 +1,12 @@
 #pragma once
 
 #include <optional>
+#include <vector>
 
 #include <QMainWindow>
 
 #include "application/ProjectMetadata.h"
+#include "application/ProjectWorkspaceState.h"
 #include "application/ScenarioAuthoringWidget.h"
 #include "domain/ImportResult.h"
 #include "domain/ScenarioResultArtifacts.h"
@@ -41,6 +43,15 @@ class MainWindow : public QMainWindow {
         const safecrowd::domain::FacilityLayout2D& layout,
         const safecrowd::domain::ScenarioDraft& scenario,
         std::optional<ScenarioAuthoringWidget::InitialState> returnAuthoringState = std::nullopt);
+    void showScenarioRun(
+        const safecrowd::domain::FacilityLayout2D& layout,
+        std::vector<safecrowd::domain::ScenarioDraft> scenarios,
+        std::optional<ScenarioAuthoringWidget::InitialState> returnAuthoringState = std::nullopt);
+    void showScenarioBatchResult(
+        const safecrowd::domain::FacilityLayout2D& layout,
+        std::vector<SavedScenarioResultState> results,
+        int currentResultIndex,
+        std::optional<ScenarioAuthoringWidget::InitialState> returnAuthoringState = std::nullopt);
     void showScenarioResult(
         const safecrowd::domain::FacilityLayout2D& layout,
         const safecrowd::domain::ScenarioDraft& scenario,

src/application/ProjectPersistence.cpp

@@ -1,6 +1,8 @@
 #include "application/ProjectPersistence.h"
 
 #include <algorithm>
+#include <cstddef>
+#include <vector>
 
 #include <QDateTime>
 #include <QDebug>
@@ -1137,6 +1139,46 @@ SavedScenarioResultState resultStateFromJson(const QJsonObject& object) {
     };
 }
 
+QJsonArray scenarioDraftsToJson(const std::vector<safecrowd::domain::ScenarioDraft>& scenarios) {
+    QJsonArray array;
+    for (const auto& scenario : scenarios) {
+        array.append(scenarioDraftToJson(scenario));
+    }
+    return array;
+}
+
+std::vector<safecrowd::domain::ScenarioDraft> scenarioDraftsFromJson(const QJsonArray& array) {
+    std::vector<safecrowd::domain::ScenarioDraft> scenarios;
+    scenarios.reserve(static_cast<std::size_t>(array.size()));
+    for (const auto& value : array) {
+        scenarios.push_back(scenarioDraftFromJson(value.toObject()));
+    }
+    return scenarios;
+}
+
+QJsonObject batchResultStateToJson(const SavedScenarioBatchResultState& batch) {
+    QJsonObject object;
+    QJsonArray results;
+    for (const auto& result : batch.results) {
+        results.append(resultStateToJson(result));
+    }
+    object["results"] = results;
+    object["currentResultIndex"] = batch.currentResultIndex;
+    return object;
+}
+
+SavedScenarioBatchResultState batchResultStateFromJson(const QJsonObject& object) {
+    SavedScenarioBatchResultState batch;
+    for (const auto& value : object.value("results").toArray()) {
+        batch.results.push_back(resultStateFromJson(value.toObject()));
+    }
+    batch.currentResultIndex = object.value("currentResultIndex").toInt(0);
+    if (batch.currentResultIndex < 0 || batch.currentResultIndex >= static_cast<int>(batch.results.size())) {
+        batch.currentResultIndex = 0;
+    }
+    return batch;
+}
+
 QJsonObject workspaceStateToJson(const ProjectWorkspaceState& state) {
     QJsonObject object;
     object["version"] = 1;
@@ -1147,9 +1189,15 @@ QJsonObject workspaceStateToJson(const ProjectWorkspaceState& state) {
     if (state.runningScenario.has_value()) {
         object["runningScenario"] = scenarioDraftToJson(*state.runningScenario);
     }
+    if (!state.runningScenarios.empty()) {
+        object["runningScenarios"] = scenarioDraftsToJson(state.runningScenarios);
+    }
     if (state.result.has_value()) {
         object["result"] = resultStateToJson(*state.result);
     }
+    if (state.batchResult.has_value()) {
+        object["batchResult"] = batchResultStateToJson(*state.batchResult);
+    }
     return object;
 }
 
@@ -1162,9 +1210,22 @@ ProjectWorkspaceState workspaceStateFromJson(const QJsonObject& object) {
     if (object.value("runningScenario").isObject()) {
         state.runningScenario = scenarioDraftFromJson(object.value("runningScenario").toObject());
     }
+    if (object.value("runningScenarios").isArray()) {
+        state.runningScenarios = scenarioDraftsFromJson(object.value("runningScenarios").toArray());
+    } else if (state.runningScenario.has_value()) {
+        state.runningScenarios.push_back(*state.runningScenario);
+    }
     if (object.value("result").isObject()) {
         state.result = resultStateFromJson(object.value("result").toObject());
     }
+    if (object.value("batchResult").isObject()) {
+        state.batchResult = batchResultStateFromJson(object.value("batchResult").toObject());
+    } else if (state.result.has_value()) {
+        state.batchResult = SavedScenarioBatchResultState{
+            .results = {*state.result},
+            .currentResultIndex = 0,
+        };
+    }
     return state;
 }
 

src/application/ProjectWorkspaceState.h

@@ -50,11 +50,18 @@ struct SavedScenarioResultState {
     safecrowd::domain::ScenarioResultArtifacts artifacts{};
 };
 
+struct SavedScenarioBatchResultState {
+    std::vector<SavedScenarioResultState> results{};
+    int currentResultIndex{0};
+};
+
 struct ProjectWorkspaceState {
     ProjectWorkspaceView activeView{ProjectWorkspaceView::LayoutReview};
     std::optional<SavedScenarioAuthoringState> authoring{};
     std::optional<safecrowd::domain::ScenarioDraft> runningScenario{};
+    std::vector<safecrowd::domain::ScenarioDraft> runningScenarios{};
     std::optional<SavedScenarioResultState> result{};
+    std::optional<SavedScenarioBatchResultState> batchResult{};
 };
 
 }  // namespace safecrowd::application

src/application/ScenarioAuthoringWidget.cpp

@@ -1060,12 +1060,12 @@ void ScenarioAuthoringWidget::refreshScenarioSwitcher() {
     scenarioSwitcher_->blockSignals(false);
 }
 
-void ScenarioAuthoringWidget::runFirstStagedBaselineScenario() {
-    const auto* scenario = firstStagedBaselineScenario();
-    if (scenario == nullptr) {
+void ScenarioAuthoringWidget::runStagedScenarios() {
+    auto scenarios = stagedRunnableScenarios();
+    if (scenarios.empty()) {
         if (stagedScenariosLabel_ != nullptr) {
             stagedScenariosLabel_->setText(stagedScenariosLabel_->text()
-                + "\n\nNo staged baseline scenario is ready to run.");
+                + "\n\nNo staged scenario is ready to run.");
         }
         return;
     }
@@ -1078,12 +1078,12 @@ void ScenarioAuthoringWidget::runFirstStagedBaselineScenario() {
     auto* runWidget = new ScenarioRunWidget(
         projectName_,
         layout_,
-        scenario->draft,
+        std::move(scenarios),
         saveProjectHandler_,
         openProjectHandler_,
         backToLayoutReviewHandler_,
-        this,
-        currentInitialState());
+        currentInitialState(),
+        this);
     rootLayout->replaceWidget(shell_, runWidget);
     shell_->hide();
     shell_->deleteLater();
@@ -1307,7 +1307,7 @@ QWidget* ScenarioAuthoringWidget::createScenarioPanel() {
         stageCurrentScenario();
     });
     connect(executeRunButton_, &QPushButton::clicked, this, [this]() {
-        runFirstStagedBaselineScenario();
+        runStagedScenarios();
     });
 
     return inspector;
@@ -1327,13 +1327,16 @@ const ScenarioAuthoringWidget::ScenarioState* ScenarioAuthoringWidget::currentSc
     return &scenarios_[currentScenarioIndex_];
 }
 
-const ScenarioAuthoringWidget::ScenarioState* ScenarioAuthoringWidget::firstStagedBaselineScenario() const {
-    const auto it = std::find_if(scenarios_.begin(), scenarios_.end(), [](const auto& scenario) {
-        return scenario.stagedForRun
-            && scenarioHasOccupants(scenario)
-            && scenario.draft.role == safecrowd::domain::ScenarioRole::Baseline;
-    });
-    return it == scenarios_.end() ? nullptr : &(*it);
+std::vector<safecrowd::domain::ScenarioDraft> ScenarioAuthoringWidget::stagedRunnableScenarios() const {
+    std::vector<safecrowd::domain::ScenarioDraft> staged;
+    for (const auto& scenario : scenarios_) {
+        if (scenario.stagedForRun && scenarioHasOccupants(scenario)) {
+            auto draft = scenario.draft;
+            draft.control.events = scenario.events;
+            staged.push_back(std::move(draft));
+        }
+    }
+    return staged;
 }
 
 }  // namespace safecrowd::application