gui.cc

Go to the documentation of this file.

// gui
#include "gui.h"
#include "gtree.h"
#include "g4SceneProperties.h"
#include "physicsView.h"
#ifdef GEMC_HAS_QTCHARTS
#include "gAnalysisView.h"
#endif
 
// geant4
#include "G4UImanager.hh"
 
// c++
#include <algorithm>
#include <utility>
 
 
namespace {
void resetSceneBeforeGeometryReload(G4UImanager* g4uim) {
    if (!g4uim) { return; }
 
    g4uim->ApplyCommand("/vis/viewer/set/autoRefresh false");
    g4uim->ApplyCommand("/vis/scene/endOfEventAction accumulate 0");
    g4uim->ApplyCommand("/vis/scene/endOfRunAction refresh");
    g4uim->ApplyCommand("/vis/scene/removeModel all");
    g4uim->ApplyCommand("/vis/viewer/clearTransients");
    g4uim->ApplyCommand("/vis/viewer/clear");
    g4uim->ApplyCommand("/vis/viewer/set/autoRefresh true");
    g4uim->ApplyCommand("/vis/viewer/flush");
    g4uim->ApplyCommand("/vis/viewer/clearTransients");
}
 
void resetEventDrawingBeforeRun(G4UImanager* g4uim) {
    if (!g4uim) { return; }
 
    g4uim->ApplyCommand("/vis/viewer/set/autoRefresh false");
    g4uim->ApplyCommand("/vis/scene/endOfEventAction accumulate 0");
    g4uim->ApplyCommand("/vis/scene/endOfRunAction refresh");
    g4uim->ApplyCommand("/vis/viewer/clearTransients");
    g4uim->ApplyCommand("/vis/viewer/clear");
    g4uim->ApplyCommand("/vis/viewer/flush");
    g4uim->ApplyCommand("/vis/viewer/clearTransients");
}
 
void restoreSceneModels(G4UImanager* g4uim, const std::shared_ptr<GOptions>& gopts, bool includeEventModels) {
    if (!g4uim) { return; }
 
    const auto g4view = g4display::getG4View(gopts);
    G4SceneProperties g4SceneProperties(gopts);
 
    g4uim->ApplyCommand("/vis/viewer/set/autoRefresh false");
    g4uim->ApplyCommand("/vis/scene/removeModel all");
    g4uim->ApplyCommand("/vis/viewer/clearTransients");
    g4uim->ApplyCommand("/vis/viewer/clear");
    g4uim->ApplyCommand("/vis/drawVolume");
    g4uim->ApplyCommand("/vis/viewer/set/background " + g4view.background);
    g4uim->ApplyCommand("/vis/viewer/set/numberOfCloudPoints " + std::to_string(g4view.cloudPoints));
    for (const auto& command : g4SceneProperties.addSceneDecorations(gopts)) { g4uim->ApplyCommand(command); }
    for (const auto& command : g4SceneProperties.addSceneTexts(gopts)) { g4uim->ApplyCommand(command); }
    if (includeEventModels) {
        const auto decorations = g4display::getG4Decorations(gopts);
        g4uim->ApplyCommand("/vis/scene/add/trajectories smooth");
        g4uim->ApplyCommand("/vis/modeling/trajectories/create/drawByCharge");
        g4uim->ApplyCommand("/vis/modeling/trajectories/drawByCharge-0/default/setDrawStepPts true");
        g4uim->ApplyCommand("/vis/modeling/trajectories/drawByCharge-0/default/setStepPtsSize 2");
        g4uim->ApplyCommand("/vis/scene/add/hits");
        g4uim->ApplyCommand("/vis/scene/endOfEventAction accumulate 10000");
        if (decorations.eventID) {
            g4uim->ApplyCommand("/vis/scene/add/eventID " + std::to_string(decorations.eventIDSize));
        }
    }
    g4uim->ApplyCommand("/vis/viewer/set/autoRefresh true");
    g4uim->ApplyCommand("/vis/viewer/flush");
}
}
 
 
GemcGUI::GemcGUI(std::shared_ptr<GOptions>             gopts,
                 std::shared_ptr<EventDispenser>       ed,
                 GDetectorConstruction*                dc,
                 std::shared_ptr<GAnalysisAccumulator> analyzer,
                 bool                                  viewerAlreadyInitialized,
                 QWidget*                              parent) :
    QWidget(parent),
    eventDispenser(ed),
    analysisAccumulator(std::move(analyzer)),
    guiOptions(gopts),
    detectorConstruction(dc),
    viewerInitialized(viewerAlreadyInitialized) {
 
    // Create the left navigation pane first; right content initialization uses it to sync selection state.
    createLeftButtons();           // instantiates leftButtons
 
    // The board is a long-lived widget attached to this GUI; it is used by other pages (e.g. dialog).
    auto* gboard = new GBoard(gopts, this);
 
    // Session object ties together options and the board; it is kept alive for the GUI lifetime.
    guiSession = std::make_unique<GUI_Session>(gopts, gboard);
 
    // Create the right stacked content pages (display, dialog, setup, tree) and synchronize default selection.
    createRightContent(gopts, dc, gboard); // instantiates rightContent: g4control, g4dialog, etc
 
    // Top row control buttons (run controls and counters).
    auto* topLayout = new QHBoxLayout;
    createTopButtons(topLayout);
 
    // Bottom row contains left navigation and right content; stretch factor favors the content area.
    auto* bottomLayout = new QHBoxLayout;
    bottomLayout->setContentsMargins(0, 0, 0, 0);
    bottomLayout->setSpacing(6);
    // second argument is stretch factor. Right content can have 10 times more space.
    bottomLayout->addWidget(leftButtons, 1);
    bottomLayout->addWidget(rightContent, 10);
 
    // Main layout: top controls, bottom panes, and board.
    auto* mainLayout = new QVBoxLayout;
    mainLayout->setContentsMargins(6, 6, 6, 6);
    mainLayout->setSpacing(6);
    mainLayout->addLayout(topLayout);
    mainLayout->addLayout(bottomLayout, 1);
    mainLayout->addWidget(gboard, 0);
 
    setLayout(mainLayout);
    setWindowTitle(tr("GEMC: Geant4 Monte-Carlo"));
    setMinimumWidth(1000);
    setMinimumHeight(760);
    resize(1000, std::max(sizeHint().height(), 760));
    QTimer::singleShot(0, this, [this]() {
        adjustSize();
        const int preferredHeight = std::max(sizeHint().height(), 760);
        setMinimumHeight(preferredHeight);
        resize(std::max(1000, sizeHint().width()), preferredHeight);
    });
 
    // Timer used for cycle mode; timeouts are connected to cycleBeamOn().
    gtimer = new QTimer(this);
    connect(gtimer, SIGNAL(timeout()), this, SLOT(cycleBeamOn()));
 
    // Page switching: left button selection drives the stacked widget page index.
    connect(leftButtons->buttonsWidget,
            SIGNAL(currentItemChanged(QListWidgetItem *, QListWidgetItem*)),
            this, SLOT(change_page(QListWidgetItem *, QListWidgetItem*)));
}
 
 
void GemcGUI::updateGui() {
    // The translated label may reorder words and parameters; never parse it as simulation state.
    displayedEventCount += nEvents->text().toULongLong();
    eventNumberLabel->setText(tr("Event Number: %1").arg(displayedEventCount));
}
 
 
void GemcGUI::resetVisualizationBeforeGeometryReload() {
#ifdef GEMC_HAS_QTCHARTS
    if (analysisView != nullptr) { analysisView->clearForGeometryReload(); }
#endif
    resetSceneBeforeGeometryReload(G4UImanager::GetUIpointer());
}
 
void GemcGUI::refreshVisualizationFromOptions() {
    if (!detectorConstruction || !detectorConstruction->has_built_geometry()) { return; }
 
    auto* g4uim = G4UImanager::GetUIpointer();
    if (!g4uim) { return; }
 
    restoreSceneModels(g4uim, guiOptions, false);
    visualizationNeedsRunRestore = true;
}
 
void GemcGUI::refreshGeometryTree() {
    if (!rightContent || !detectorConstruction || !guiOptions || !geometryTree) { return; }
 
    geometryReloadedSinceRun = true;
 
    const int treeIndex = rightContent->indexOf(geometryTree);
    if (treeIndex < 0) { return; }
 
    const int currentIndex = rightContent->currentIndex();
    auto* g4uim = G4UImanager::GetUIpointer();
    if (!g4uim) { return; }
 
    const auto g4volumes = detectorConstruction->has_built_geometry()
                         ? detectorConstruction->get_g4volumes_map()
                         : std::unordered_map<std::string, G4Volume*>{};
    const auto gvolumes = detectorConstruction->has_built_geometry()
                        ? detectorConstruction->get_gvolumes_flat_map()
                        : std::unordered_map<std::string, const GVolume*>{};
    const auto gmirrors = detectorConstruction->has_built_geometry()
                        ? detectorConstruction->get_gmirrors_flat_map()
                        : std::unordered_map<std::string, const GMirror*>{};
    auto* refreshedTree = new GTree(guiOptions, g4volumes, gvolumes, nullptr, gmirrors);
 
    rightContent->removeWidget(geometryTree);
    geometryTree->deleteLater();
    geometryTree = refreshedTree;
    rightContent->insertWidget(treeIndex, geometryTree);
    rightContent->setCurrentIndex(currentIndex == treeIndex ? treeIndex : currentIndex);
 
    if (g4volumes.size() > 1) {
        if (!viewerInitialized) {
            // First geometry load: no viewer exists yet; create the named scene and open one.
            G4SceneProperties g4SceneProperties(guiOptions);
            auto commands = g4SceneProperties.scene_commands(guiOptions);
            for (const auto& command : commands) { g4uim->ApplyCommand(command); }
            viewerInitialized = true;
        }
 
        restoreSceneModels(g4uim, guiOptions, false);
    }
}
 
void GemcGUI::prepareGeometryForBeamOn() {
    if ((!geometryReloadedSinceRun && !visualizationNeedsRunRestore) || !detectorConstruction) { return; }
    if (!detectorConstruction->has_built_geometry()) { return; }
 
    auto* g4uim = G4UImanager::GetUIpointer();
    resetEventDrawingBeforeRun(g4uim);
 
    if (geometryReloadedSinceRun) {
        detectorConstruction->prepare_geometry_for_run();
        if (eventDispenser) {
            eventDispenser->resetRunContext();
        }
    }
 
    // Restore visualization models after geometry reinitialization.
    // The run reinitialization can replace the world volume, so restore the same
    // persistent models used by refreshGeometryTree() before BeamOn draws events.
    restoreSceneModels(g4uim, guiOptions, true);
 
    geometryReloadedSinceRun = false;
    visualizationNeedsRunRestore = false;
}
 
 
GemcGUI::~GemcGUI() {
    // All widgets are owned via Qt parent/child relationships once placed into the layout hierarchy.
    // Rely on Qt to destroy children when GemcGUI is destroyed.
}
 
 
void GemcGUI::change_page(QListWidgetItem* current, QListWidgetItem* previous) {
 
    // Qt may emit selection changes with a null current item; fall back to the previous selection.
    if (!current)
        current = previous;
 
    // The left button widget provides the active page index; apply it to the stacked widget.
    int thisIndex = leftButtons->button_pressed();
    rightContent->setCurrentIndex(thisIndex);
    if (rightContent->currentWidget() == physicsView) { physicsView->refreshProcesses(); }
}