gtree.cc

Go to the documentation of this file.

// Implementation of the GTree Qt widget and its internal per-volume cache model.
// Doxygen documentation is authoritative in the header; this file uses short
// non-Doxygen comments to summarize behavior.
 
// c++
#include <cmath>
#include <set>
#include <sstream>
 
// geant4
#include "G4BooleanSolid.hh"
 
// Qt
#include <QHeaderView>
#include <QTextEdit>
#include <QVBoxLayout>
#include <QColorDialog>
#include <QMessageBox>
#include <QSignalBlocker>
#include <QStringList>
#include <QTimer>
 
// gtree
#include "gtree.h"
#include "gtree_options.h"
 
// gemc
#include "gsystemConventions.h"
 
// geant4
#include "G4VisAttributes.hh"
#include "G4Material.hh"
#include "G4VisManager.hh"
#include "G4VViewer.hh"
#include "G4VSceneHandler.hh"
#include "G4VGraphicsSystem.hh"
#include "G4UImanager.hh"
#include "gtouchable.h"
#include "gutilities.h"
 
namespace {
 
std::vector<std::string> splitParams(const std::string& s) {
    std::vector<std::string> result;
    std::istringstream ss(s);
    std::string tok;
    while (std::getline(ss, tok, ',')) {
        const auto a = tok.find_first_not_of(" \t");
        const auto b = tok.find_last_not_of(" \t");
        if (a != std::string::npos)
            result.push_back(tok.substr(a, b - a + 1));
    }
    return result;
}
 
using PDesc = std::vector<const char*>;
 
const PDesc& solidParamDescs(const std::string& solid, std::size_t n) {
    static const std::unordered_map<std::string, PDesc> kFixed = {
        {"G4Box",    {"dx: half length in x",
                      "dy: half length in y",
                      "dz: half length in z"}},
        {"G4Tubs",   {"rin: inner radius",
                      "rout: outer radius",
                      "length: half length in z",
                      "phi start: starting phi angle",
                      "phi total: total phi angle"}},
        {"G4Cons",   {"rin1: inner radius at -dz",
                      "rout1: outer radius at -dz",
                      "rin2: inner radius at +dz",
                      "rout2: outer radius at +dz",
                      "length: half length in z",
                      "phi start: starting phi angle",
                      "phi total: total phi angle"}},
        {"G4Trd",    {"dx1: half length in x at -dz",
                      "dx2: half length in x at +dz",
                      "dy1: half length in y at -dz",
                      "dy2: half length in y at +dz",
                      "z: half length in z"}},
        {"G4Sphere", {"rmin: inner radius",
                      "rmax: outer radius",
                      "sphi: starting phi angle",
                      "dphi: delta phi angle",
                      "stheta: starting theta angle",
                      "dtheta: delta theta angle"}},
        {"G4Paraboloid", {"dz: half length in z",
                          "r1: radius at -dz",
                          "r2: radius at +dz"}},
        {"G4EllipticalTube", {"dx: half length in x",
                              "dy: half length in y",
                              "dz: half length in z"}},
    };
    static const std::unordered_map<std::size_t, PDesc> kTrap = {
        {4,  {"pz: length along Z",
              "py: length along Y",
              "px: length along X (wider side)",
              "pltx: length along X (narrower side)"}},
        {11, {"pDz: half Z length",
              "pTheta: polar angle of line joining base centres",
              "pPhi: azimuthal angle of line joining base centres",
              "pDy1: half Y length at -dz",
              "pDx1: half X length at smaller Y, base at -dz",
              "pDx2: half X length at bigger Y, base at -dz",
              "pAlp1: angle between Y-axis and centre line at -dz",
              "pDy2: half Y length at +dz",
              "pDx3: half X length at smaller Y, base at +dz",
              "pDx4: half X length at bigger Y, base at +dz",
              "pAlp2: angle between Y-axis and centre line at +dz"}},
    };
    static const PDesc kEmpty;
 
    if (solid == "G4Trap") {
        const auto it = kTrap.find(n);
        return it != kTrap.end() ? it->second : kEmpty;
    }
    const auto it = kFixed.find(solid);
    return it != kFixed.end() ? it->second : kEmpty;
}
 
// Format a "number*unit" or bare "number" token: max 3 decimal places,
// values with |x| < 1e-7 are shown as 0.
static QString formatVal(const std::string& token) {
    const auto star = token.find('*');
    const std::string numPart = (star == std::string::npos) ? token : token.substr(0, star);
    const std::string unit    = (star == std::string::npos) ? "" : token.substr(star);
    try {
        std::size_t pos = 0;
        double v = std::stod(numPart, &pos);
        if (pos != numPart.size()) return QString::fromStdString(token);
        if (std::abs(v) < 1e-7) v = 0.0;
        QString s = QString::number(v, 'f', 3);
        while (s.endsWith('0') && s.contains('.')) s.chop(1);
        if (s.endsWith('.')) s.chop(1);
        return s + QString::fromStdString(unit);
    } catch (...) {
        return QString::fromStdString(token);
    }
}
 
QString formatParameters(const std::string& solid, const std::string& paramsStr) {
    if (paramsStr.empty()) return {};
    const auto vals = splitParams(paramsStr);
    if (vals.empty()) return {};
 
    QString html = "Parameters:";
 
    // Polycone: fixed header (phiStart, phiTotal, nplanes) then arrays
    if (solid == "G4Polycone" && vals.size() >= 3) {
        const char* kPcFixed[3] = {
            "phi start: starting phi angle",
            "phi total: total phi angle",
            "nplanes: number of planes"
        };
        for (int i = 0; i < 3 && i < (int)vals.size(); ++i)
            html += QString("<br>&nbsp;&nbsp;<i>%1</i>: %2").arg(kPcFixed[i], formatVal(vals[i]));
        int nplanes = 0;
        try { nplanes = std::stoi(vals[2]); } catch (...) {}
        int idx = 3;
        for (int p = 0; p < nplanes && idx < (int)vals.size(); ++p, ++idx)
            html += QString("<br>&nbsp;&nbsp;<i>z[%1]</i>: %2").arg(p).arg(formatVal(vals[idx]));
        for (int p = 0; p < nplanes && idx < (int)vals.size(); ++p, ++idx)
            html += QString("<br>&nbsp;&nbsp;<i>rin[%1]</i>: %2").arg(p).arg(formatVal(vals[idx]));
        for (int p = 0; p < nplanes && idx < (int)vals.size(); ++p, ++idx)
            html += QString("<br>&nbsp;&nbsp;<i>rout[%1]</i>: %2").arg(p).arg(formatVal(vals[idx]));
        return html;
    }
 
    // G4Trap from 8 vertices (24 params)
    if (solid == "G4Trap" && vals.size() == 24) {
        const char* kAxes[3] = {"x", "y", "z"};
        for (int v = 0; v < 8; ++v)
            for (int c = 0; c < 3; ++c)
                html += QString("<br>&nbsp;&nbsp;<i>v%1%2</i>: %3")
                            .arg(v + 1).arg(kAxes[c]).arg(formatVal(vals[v * 3 + c]));
        return html;
    }
 
    // All other solids (including G4Trap with 4 or 11 params)
    const auto& descs = solidParamDescs(solid, vals.size());
    for (std::size_t i = 0; i < vals.size(); ++i) {
        const QString desc = i < descs.size()
            ? QString::fromStdString(descs[i])
            : QString("missing parameters description");
        html += QString("<br>&nbsp;&nbsp;<i>%1</i>: %2").arg(desc, formatVal(vals[i]));
    }
    return html;
}
 
std::string resolveBooleanOperandName(const std::string& systemName,
                                      const std::string& operand,
                                      const std::unordered_map<std::string, const GVolume*>& gvolumes) {
    if (gvolumes.find(operand) != gvolumes.end()) return operand;
 
    const std::string qualified = systemName.empty() ? operand : systemName + "/" + operand;
    if (gvolumes.find(qualified) != gvolumes.end()) return qualified;
 
    return operand;
}
 
std::string leafName(const std::string& volumeName) {
    const auto slash = volumeName.find_last_of('/');
    return slash == std::string::npos ? volumeName : volumeName.substr(slash + 1);
}
 
QString joinBooleanTokens(const std::vector<std::string>& tokens) {
    QStringList parts;
    for (const auto& token : tokens) {
        parts << QString::fromStdString(token).toHtmlEscaped();
    }
    return parts.join(QStringLiteral(" "));
}
 
QString formatOperationLine(const std::vector<std::string>& tokens,
                            const std::string& systemName,
                            const std::unordered_map<std::string, const GVolume*>& gvolumes) {
    if (tokens.size() != 3) return joinBooleanTokens(tokens);
 
    const auto left  = leafName(resolveBooleanOperandName(systemName, tokens[0], gvolumes));
    const auto right = leafName(resolveBooleanOperandName(systemName, tokens[2], gvolumes));
    return QString("%1 %2 %3").arg(QString::fromStdString(left).toHtmlEscaped(),
                                   QString::fromStdString(tokens[1]).toHtmlEscaped(),
                                   QString::fromStdString(right).toHtmlEscaped());
}
 
void appendNestedBooleanOperationLines(QString& html,
                                       const std::string& volumeName,
                                       const std::string& systemName,
                                       const std::unordered_map<std::string, const GVolume*>& gvolumes,
                                       std::set<std::string>& visited) {
    const auto fullName = resolveBooleanOperandName(systemName, volumeName, gvolumes);
    if (!visited.insert(fullName).second) return;
 
    const auto gvolIt = gvolumes.find(fullName);
    if (gvolIt == gvolumes.end()) return;
 
    const auto solidsOpr = gvolIt->second->getSolidsOpr();
    if (solidsOpr.empty() || solidsOpr == UNINITIALIZEDSTRINGQUANTITY) return;
 
    const auto tokens = gutilities::getStringVectorFromString(solidsOpr);
    if (tokens.size() != 3) return;
 
    html += QString("<br>&nbsp;&nbsp;%1 = %2")
                .arg(QString::fromStdString(leafName(fullName)).toHtmlEscaped(),
                     formatOperationLine(tokens, systemName, gvolumes));
 
    appendNestedBooleanOperationLines(html, tokens[0], systemName, gvolumes, visited);
    appendNestedBooleanOperationLines(html, tokens[2], systemName, gvolumes, visited);
}
 
QString formatBooleanOperationDescription(const std::string& fullName,
                                          const std::string& solidsOpr,
                                          const std::unordered_map<std::string, const GVolume*>& gvolumes) {
    if (solidsOpr.empty() || solidsOpr == UNINITIALIZEDSTRINGQUANTITY) return {};
 
    const auto tokens = gutilities::getStringVectorFromString(solidsOpr);
    if (tokens.size() != 3) {
        return QObject::tr("Boolean Operation: %1").arg(QString::fromStdString(solidsOpr).toHtmlEscaped());
    }
 
    const auto slash = fullName.find_last_of('/');
    const std::string systemName = slash == std::string::npos ? "" : fullName.substr(0, slash);
    QString html = QObject::tr("Boolean Operation: %1").arg(formatOperationLine(tokens, systemName, gvolumes));
 
    std::set<std::string> visited{fullName};
    appendNestedBooleanOperationLines(html, tokens[0], systemName, gvolumes, visited);
    appendNestedBooleanOperationLines(html, tokens[2], systemName, gvolumes, visited);
    return html;
}
 
} // anonymous namespace
 
 
// Cache a volume's hierarchy, material, visualization attributes, and pygemc descriptor.
G4Ttree_item::G4Ttree_item(G4Volume* g4volume, const GVolume* gvolume) {
    if (g4volume == nullptr || g4volume->getLogical() == nullptr || g4volume->getSolid() == nullptr) {
        mother = MOTHEROFUSALL;
        material = "unavailable";
        color = QColor::fromRgbF(1.0, 1.0, 1.0);
        opacity = 1.0;
        is_visible = false;
        return;
    }
 
    auto pvolume = g4volume->getPhysical();
    auto lvolume = g4volume->getLogical();
    auto svolume = g4volume->getSolid();
 
    std::string lname = lvolume->GetName();
    if (lname != ROOTWORLDGVOLUMENAME) {
        auto mlvolume = pvolume != nullptr ? pvolume->GetMotherLogical() : nullptr;
        mother = mlvolume != nullptr ? mlvolume->GetName() : MOTHEROFUSALL;
        material = lvolume->GetMaterial()->GetName();
    }
    else {
        mother = MOTHEROFUSALL;
        material = "G4_Galactic";
    }
 
    // Read visualization attributes from the logical volume.
    auto visAttributes = lvolume->GetVisAttributes();
    if (visAttributes != nullptr) {
        auto gcolor = visAttributes->GetColour();
        color      = QColor::fromRgbF(gcolor.GetRed(), gcolor.GetGreen(), gcolor.GetBlue());
        opacity    = gcolor.GetAlpha();
        is_visible = visAttributes->IsVisible();
    }
    else {
        // No vis attributes assigned (e.g. imported CAD/GDML volumes): fall back to opaque white, visible.
        color      = QColor::fromRgbF(1.0, 1.0, 1.0);
        opacity    = 1.0;
        is_visible = true;
    }
 
    // Physics quantities (mass, volume, density) are computed lazily on first
    // request: see compute_physics_quantities().
    logical_ptr = lvolume;
    solid_ptr = svolume;
 
    if (gvolume) {
        solidType      = gvolume->getType();
        parameters     = gvolume->getParameters();
        position       = gvolume->getPos();
        rotation       = gvolume->getRot();
        motherVolume   = gvolume->getMotherName();
        solidsOpr      = gvolume->getSolidsOpr();
        volDescription = gvolume->getDescription();
    }
}
 
 
// Compute mass, volume, and density on first request. Geant4 estimates a boolean
// solid's cubic volume by Monte Carlo with 1M points by default — seconds per solid —
// so boolean solids use a bounded 100k-point estimate (~1% accuracy, plenty for
// display), and the mass is not propagated to daughters (whose solids may themselves
// be booleans). This keeps volume selection interactive on boolean-heavy systems.
void G4Ttree_item::compute_physics_quantities() const {
    if (physics_computed) return;
    physics_computed = true;
    if (logical_ptr == nullptr || solid_ptr == nullptr) return;
 
    if (dynamic_cast<G4BooleanSolid*>(solid_ptr) != nullptr) {
        volume = solid_ptr->EstimateCubicVolume(100000, 0.001) / CLHEP::cm3;
        density = logical_ptr->GetMaterial()->GetDensity() / (CLHEP::g / CLHEP::cm3);
        mass = volume * density;
    }
    else {
        volume = solid_ptr->GetCubicVolume() / CLHEP::cm3;
        mass = logical_ptr->GetMass(false, false) / CLHEP::g;
        density = volume > 0 ? mass / volume : 0.0;
    }
}
 
 
// Extract a short display name from a full "system/volume" name.
std::string G4Ttree_item::vname_from_v4name(std::string v4name) {
    // return name after '/'
    return v4name.substr(v4name.find_last_of('/') + 1);
}
 
// Extract the system prefix from a full "system/volume" name.
std::string G4Ttree_item::system_from_v4name(std::string v4name) {
    // return name before '/'
    return v4name.substr(0, v4name.find_last_of('/'));
}
 
 
// Construct the widget, build the internal model, create the UI, and connect signals.
GTree::GTree(const std::shared_ptr<GOptions>& gopt,
             std::unordered_map<std::string, G4Volume*> g4volumes_map,
             std::unordered_map<std::string, const GVolume*> gvolumes_map_in,
             QWidget* parent) :
    QWidget(parent),
    GBase(gopt, GTREE_LOGGER),
    gvolumes_map(std::move(gvolumes_map_in)) {
    // Build the internal representation used to populate the UI tree.
    build_tree(g4volumes_map);
 
    // create the UI
    treeWidget = new QTreeWidget(this);
    treeWidget->setColumnCount(3);
    QStringList headers;
    headers << "Visibility" << "Color" << "Name";
    treeWidget->setHeaderLabels(headers);
    treeWidget->header()->setSectionResizeMode(0, QHeaderView::ResizeToContents);
    treeWidget->header()->setSectionResizeMode(1, QHeaderView::ResizeToContents);
    treeWidget->header()->setSectionResizeMode(2, QHeaderView::Stretch);
    treeWidget->setRootIsDecorated(true);
    treeWidget->setAlternatingRowColors(true);
 
    auto* mainLayout = new QHBoxLayout(this);
    mainLayout->addWidget(treeWidget, /*stretch*/ 3);
 
    // Right: property panel has ~same width. Increase stretch to increase
    rightPanel = right_widget();
    mainLayout->addWidget(rightPanel, /*stretch*/ 3);
 
    setLayout(mainLayout);
 
    // populate the tree from g4_systems_tree
    populateTree();
 
    // react to checkboxes
    connect(treeWidget, &QTreeWidget::itemChanged,
            this, &GTree::onItemChanged);
 
 
    // react to clicks / selection to update the right panel
    connect(treeWidget, &QTreeWidget::itemClicked,
            this, &GTree::onTreeItemClicked);
 
    connect(treeWidget, &QTreeWidget::currentItemChanged,
            this, &GTree::onCurrentItemChanged);
 
    // connect GQTButtonsWidget signal button_pressed to slot changeStyle()
    connect(styleButtons->buttonsWidget,
            SIGNAL(currentItemChanged(QListWidgetItem *, QListWidgetItem*)),
            this, SLOT(changeStyle()));
 
 
    // connect slider to slot
    connect(opacitySlider, &QSlider::valueChanged,
            this, &GTree::onOpacitySliderChanged);
 
 
    log->debug(NORMAL, SFUNCTION_NAME, "GTree added");
}
 
// Build the Qt tree view from the internal system/volume model.
void GTree::populateTree() {
    // for each system
    for (auto& [systemName, volMap] : g4_systems_tree) {
        // top-level item for the system
        auto* systemItem = new QTreeWidgetItem(treeWidget);
        systemItem->setText(2, QString::fromStdString(systemName));
        systemItem->setFlags(systemItem->flags() | Qt::ItemIsUserCheckable);
        systemItem->setCheckState(0, Qt::Checked);
 
        // We'll build the volume hierarchy inside this system using a lookup map.
        std::map<std::string, QTreeWidgetItem*> itemLookup;
 
        // --------------------------------------------------------------------
        // 1st pass: create items WITHOUT parents, configure text/data/checkbox
        // --------------------------------------------------------------------
        for (auto& [volName, vptr] : volMap) {
            const G4Ttree_item* vitem = vptr.get();
 
            auto* item = new QTreeWidgetItem; // no parent yet
            item->setText(2, QString::fromStdString(G4Ttree_item::vname_from_v4name(volName)));
            item->setData(2, Qt::UserRole, QString::fromStdString(volName)); // store full v4 name
 
            // checkbox for visibility:
            item->setFlags(item->flags() | Qt::ItemIsUserCheckable);
            item->setCheckState(0, vitem->get_visibility() ? Qt::Checked : Qt::Unchecked);
 
            itemLookup[volName] = item;
        }
 
        // --------------------------------------------------------------------
        // 2nd pass: attach items to their parent (system or mother)
        // --------------------------------------------------------------------
        for (auto& [volName, vptr] : volMap) {
            const G4Ttree_item* vitem = vptr.get();
            auto mother = vitem->get_mother(); // full v4 name of mother
            auto* thisItem = itemLookup[volName];
 
            QTreeWidgetItem* parentItem = systemItem;
 
            // If a mother exists and is present in this system's lookup, attach under it.
            if (!mother.empty() && mother != "root") {
                auto itM = itemLookup.find(mother);
                if (itM != itemLookup.end()) {
                    parentItem = itM->second;
                }
            }
 
            parentItem->addChild(thisItem);
        }
 
        // --------------------------------------------------------------------
        // 3rd pass: create color buttons now that items are in the tree
        // --------------------------------------------------------------------
        for (auto& [volName, vptr] : volMap) {
            const G4Ttree_item* vitem = vptr.get();
            QTreeWidgetItem* item = itemLookup[volName];
 
            auto* colorBtn = new QPushButton(treeWidget);
            QColor c = vitem->get_color();
            colorBtn->setFixedSize(20, 20);
            colorBtn->setFlat(true); // no 3D/bevel look
            colorBtn->setText(QString()); // no text
 
            colorBtn->setStyleSheet(
                QString("QPushButton { background-color: %1; border: 1px solid %2; }")
                .arg(c.name(), palette().color(QPalette::Mid).name())
            );
 
            // Store the full volume name as a property so the slot can retrieve it.
            colorBtn->setProperty("volumeName", QString::fromStdString(volName));
            connect(colorBtn, &QPushButton::clicked, this, &GTree::onColorButtonClicked);
 
            treeWidget->setItemWidget(item, 1, colorBtn);
        }
    }
 
    treeWidget->expandAll();
}
 
 
// Build the internal system/volume model from the provided volume map.
void GTree::build_tree(std::unordered_map<std::string, G4Volume*> g4volumes_map) {
    // loop over map
    for (auto [name, g4volume] : g4volumes_map) {
        if (g4volume == nullptr || g4volume->getLogical() == nullptr ||
            g4volume->getSolid() == nullptr || g4volume->getPhysical() == nullptr) {
            log->info(2, "Skipping non-placed helper volume <", name, "> from tree");
            continue;
        }
 
        // skip the Geant4 world / ROOTWORLDGVOLUMENAME
        // auto lvolume = g4volume->getLogical();
        //
        // if (lvolume && lvolume->GetName() == ROOTWORLDGVOLUMENAME) {
        //     log->info(2, "Skipping world volume >", name, "< from tree");
        //     continue;
        // }
 
        auto system_name = G4Ttree_item::system_from_v4name(name);
 
        // ensure the system exists
        auto& system_tree = g4_systems_tree[system_name];
        const GVolume* gvol = nullptr;
        auto it = gvolumes_map.find(name);
        if (it != gvolumes_map.end()) gvol = it->second;
        system_tree[name] = std::make_unique<G4Ttree_item>(g4volume, gvol);
 
        // do not log mass/volume/density here: reading them triggers the (potentially
        // Monte-Carlo) physics computation for every volume in the tree
        log->info(2, "Adding ", name, " to tree, system_name is ", system_name);
    }
}
 
// Apply visibility checkbox changes to the selected item and its direct children.
void GTree::onItemChanged(QTreeWidgetItem* item, int column) {
    if (column != 0) return; // we care about visibility column only
 
    // is this a volume item? (has stored v4 name in UserRole)
    QVariant v = item->data(2, Qt::UserRole);
 
    // --------------------------------------------------------------------
    // SYSTEM item: no UserRole data → propagate to direct daughters
    // --------------------------------------------------------------------
    if (!v.isValid()) {
        bool visible = (item->checkState(0) == Qt::Checked);
 
        QSignalBlocker blocker(treeWidget); // avoid recursive itemChanged
 
        const int nChildren = item->childCount();
        for (int i = 0; i < nChildren; ++i) {
            QTreeWidgetItem* child = item->child(i);
            QVariant cv = child->data(2, Qt::UserRole);
            if (!cv.isValid())
                continue; // skip non-volume children (shouldn't happen)
 
            const QString fullName = cv.toString();
 
            // sync child checkbox
            child->setCheckState(0, visible ? Qt::Checked : Qt::Unchecked);
 
            // apply to Geant4
            set_visibility(fullName.toStdString(), visible);
        }
 
        return;
    }
 
    // --------------------------------------------------------------------
    // VOLUME item: apply to itself and its direct daughter volumes
    // --------------------------------------------------------------------
    const QString fullName = v.toString();
    bool visible = (item->checkState(0) == Qt::Checked);
 
    QSignalBlocker blocker(treeWidget); // avoid recursive itemChanged
 
    // 1) apply to this volume
    set_visibility(fullName.toStdString(), visible);
 
    // 2) apply same visibility to its direct daughters
    const int nChildren = item->childCount();
    for (int i = 0; i < nChildren; ++i) {
        QTreeWidgetItem* child = item->child(i);
        QVariant cv = child->data(2, Qt::UserRole);
        if (!cv.isValid())
            continue; // skip if not a volume
 
        const QString childName = cv.toString();
 
        // sync child checkbox
        child->setCheckState(0, visible ? Qt::Checked : Qt::Unchecked);
 
        // apply to Geant4
        set_visibility(childName.toStdString(), visible);
    }
}
 
 
// Open the color dialog and apply a new RGB color to the selected volume.
void GTree::onColorButtonClicked() {
    auto* btn = qobject_cast<QPushButton*>(sender());
    if (!btn)
        return;
 
    const QString volName = btn->property("volumeName").toString();
    if (volName.isEmpty())
        return;
 
    QColor initial = Qt::white;
 
    QColor c = QColorDialog::getColor(initial, this, tr("Select color"));
    if (!c.isValid())
        return;
 
    // Update button appearance
    btn->setStyleSheet(
        QString("QPushButton { background-color: %1; border: 1px solid %2; }")
        .arg(c.name(), palette().color(QPalette::Mid).name())
    );
 
    // tell your model
    set_color(volName.toStdString(), c);
}
 
 
// Send a Geant4 UI command to toggle visibility for a specific volume.
void GTree::set_visibility(const std::string& volumeName, bool visible) {
    std::string vis_int = visible ? "1" : "0";
 
    std::string command = "/vis/geometry/set/visibility " + volumeName + " -1 " + vis_int;
 
    // World visibility uses a different depth value.
    if (volumeName == ROOTWORLDGVOLUMENAME) {
        command = "/vis/geometry/set/visibility " + volumeName + " 0 " + vis_int;
    }
 
    gutilities::apply_uimanager_commands(command);
}
 
// Send a Geant4 UI command to set RGB color for a specific volume.
void GTree::set_color(const std::string& volumeName, const QColor& c) {
    G4Ttree_item* item = findTreeItem(volumeName);
    double currentOpacity = item ? item->get_opacity() : 1.0;
    if (item) item->set_color(c);
 
    std::string command = "/vis/geometry/set/colour " + volumeName + " 0 "
        + std::to_string(c.redF()) + " "
        + std::to_string(c.greenF()) + " "
        + std::to_string(c.blueF()) + " "
        + std::to_string(currentOpacity);
 
    gutilities::apply_uimanager_commands(command);
}
 
// Return number of direct children in the Qt tree for the given item.
int GTree::get_ndaughters(QTreeWidgetItem* item) const {
    if (!item) return 0;
    return item->childCount();
}
 
// Find the cached model record for a volume by its full name.
G4Ttree_item* GTree::findTreeItem(const std::string& fullName) {
    for (const auto& [systemName, volMap] : g4_systems_tree) {
        auto it = volMap.find(fullName);
        if (it != volMap.end()) {
            return it->second.get();
        }
    }
    return nullptr;
}
 
 
// Update the right-side panel according to the clicked item.
void GTree::onTreeItemClicked(QTreeWidgetItem* item, int /*column*/) {
    if (!bottomPanel)
        return;
 
    if (!item) {
        bottomPanel->setVisible(false);
        current_volume_name.clear();
        return;
    }
 
    bottomPanel->setVisible(true);
 
    // Is it a volume? (volume items store the full v4 name in UserRole)
    QVariant v = item->data(2, Qt::UserRole);
    bool isVolume = v.isValid();
 
    // Type label
    if (isVolume) {
        typeLabel->setText(QStringLiteral("<b>G4 Volume</b>"));
        current_volume_name = v.toString().toStdString();
    }
    else {
        typeLabel->setText(QStringLiteral("<b>System</b>"));
        current_volume_name.clear();
    }
 
    // Number of direct daughters
    int nd = get_ndaughters(item);
    daughtersLabel->setText(tr("Daughters: %1").arg(nd));
 
    // Name (column 2 text)
    QString itemName = item->text(2);
    nameLabel->setText(tr("Name: %1").arg(itemName));
 
    // Material / density / mass
    if (isVolume) {
        styleButtons->setVisible(true);
 
        const std::string fullName = v.toString().toStdString();
        const G4Ttree_item* titem = findTreeItem(fullName);
 
        if (titem) {
            materialLabel->setText(
                tr("Material: %1").arg(QString::fromStdString(titem->get_material()))
            );
            auto mass = titem->get_mass();
            if (mass < 1000) {
                massLabel->setText(tr("Mass: %1 g").arg(mass));
            }
            else {
                massLabel->setText(tr("Mass: %1 kg").arg(mass / 1000));
            }
            auto volume = titem->get_volume();
            if (volume < 1000000) {
                volumeLabel->setText(tr("Volume: %1 cm3").arg(volume));
            }
            else {
                volumeLabel->setText(tr("Volume: %1 m3").arg(volume / 1000000));
            }
 
            densityLabel->setText(
                tr("Density: %1 g / cm3").arg(titem->get_density())
            );
 
            // pygemc descriptor fields
            const auto solidT = titem->get_solidType();
            solidTypeLabel->setText(solidT.empty() ? QString()
                                                   : tr("Solid: %1").arg(QString::fromStdString(solidT)));
            const auto params = titem->get_parameters();
            const bool hasParams = !params.empty();
            parametersLabel->setVisible(hasParams);
            if (hasParams) parametersLabel->setHtml(formatParameters(solidT, params));
            const auto pos = titem->get_position();
            positionLabel->setText(pos.empty() ? QString()
                                               : tr("Position: %1").arg(QString::fromStdString(pos)));
            const auto rot = titem->get_rotation();
            rotationLabel->setText(rot.empty() ? QString()
                                               : tr("Rotation: %1").arg(QString::fromStdString(rot)));
            const auto mom = titem->get_motherVolume();
            motherLabel->setText(mom.empty() ? QString() : tr("Mother: %1").arg(QString::fromStdString(mom)));
            const auto boolDesc =
                formatBooleanOperationDescription(fullName, titem->get_solidsOpr(), gvolumes_map);
            if (!boolDesc.isEmpty()) {
                descriptionLabel->setText(boolDesc);
            }
            else {
                const auto desc = titem->get_volDescription();
                descriptionLabel->setText(desc.empty() ? QString()
                                                       : tr("Description: %1")
                                                             .arg(QString::fromStdString(desc)));
            }
 
            // Sync the slider position to the cached alpha channel.
            double op = titem->get_opacity();
            int sliderVal = static_cast<int>(op * 100.0 + 0.5);
            {
                QSignalBlocker blocker(opacitySlider);
                opacitySlider->setValue(sliderVal);
            }
            opacityLabel->setText(QString::number(op, 'f', 2));
            opacitySlider->setVisible(true);
        }
 
        // Update the inspect and draw-overlaps buttons with the selected volume's leaf name.
        if (inspectButton) {
            const QString leaf = QString::fromStdString(G4Ttree_item::vname_from_v4name(current_volume_name));
            inspectButton->setText(tr("Inspect %1").arg(leaf));
            inspectButton->setVisible(true);
        }
        if (drawOverlapsButton) {
            const QString leaf = QString::fromStdString(G4Ttree_item::vname_from_v4name(current_volume_name));
            drawOverlapsButton->setText(tr("Draw Logical Overlaps %1").arg(leaf));
            drawOverlapsButton->setVisible(true);
        }
    }
    else {
        styleButtons->setVisible(false);
        opacitySlider->setVisible(false);
        if (inspectButton) inspectButton->setVisible(false);
        if (drawOverlapsButton) drawOverlapsButton->setVisible(false);
        // Systems don't have a single material etc.
        materialLabel->setText(tr(""));
        massLabel->setText(tr(""));
        volumeLabel->setText(tr(""));
        densityLabel->setText(tr(""));
        solidTypeLabel->setText(tr(""));
        parametersLabel->clear();
        parametersLabel->setVisible(false);
        positionLabel->setText(tr(""));
        rotationLabel->setText(tr(""));
        motherLabel->setText(tr(""));
        descriptionLabel->setText(tr(""));
    }
}
 
// Keep the right-side panel updated when selection changes via keyboard navigation.
void GTree::onCurrentItemChanged(QTreeWidgetItem* current, QTreeWidgetItem* previous) {
    Q_UNUSED(previous);
    if (!current)
        return;
 
    // reset styleButtons
    styleButtons->reset_buttons();
 
    // Reuse the same logic as mouse clicks
    onTreeItemClicked(current, 0);
}
 
// Apply a representation command based on the currently selected style button.
void GTree::changeStyle() {
 
    // No-op if no volume is selected (system selected or nothing selected).
    if (current_volume_name.empty())
        return;
 
    int button_index = styleButtons->button_pressed();
 
    if (button_index == 3) {
        // Action button: deselect it immediately (it is not a persistent style toggle).
        {
            QSignalBlocker blocker(styleButtons->buttonsWidget);
            styleButtons->reset_buttons();
        }
        centreTwinkle();
        return;
    }
 
    std::string command;
 
    if (button_index == 0) {
        command = "/vis/geometry/set/forceWireframe " + current_volume_name + " 0 1 ";
    }
    else if (button_index == 1) {
        command = "/vis/geometry/set/forceSolid " + current_volume_name + " 0 1 ";
    }
    else if (button_index == 2) {
        command = "/vis/geometry/set/forceCloud " + current_volume_name + " 0 1 ";
    }
    else {
        // Unknown button index: avoid issuing an empty or malformed UI command.
        return;
    }
 
    gutilities::apply_uimanager_commands(command);
}
 
 
// Centre the viewer on the selected volume and kick off the twinkle animation.
void GTree::centreTwinkle() {
    G4Ttree_item* item = findTreeItem(current_volume_name);
    if (!item) return;
 
    twinkleVolumeName   = current_volume_name;
    twinkleSavedColor   = item->get_color();
    twinkleSavedOpacity = item->get_opacity();
    twinkleTick         = 0;
 
    gutilities::apply_uimanager_commands("/vis/viewer/centreOn " + twinkleVolumeName);
 
    if (!twinkleTimer) {
        twinkleTimer = new QTimer(this);
        connect(twinkleTimer, &QTimer::timeout, this, &GTree::onTwinkleStep);
    }
    if (twinkleTimer->isActive())
        twinkleTimer->stop();
 
    twinkleTimer->start(180);
}
 
 
// Cycle through flash colors, then restore the original colour and alpha.
void GTree::onTwinkleStep() {
    constexpr int kSteps = 5;
    static const QColor kFlash[kSteps] = {
        QColor(255,  50,  50),  // red
        QColor(255, 220,   0),  // yellow
        QColor( 50, 255,  50),  // green
        QColor(  0, 220, 255),  // cyan
        QColor(220,  50, 255),  // magenta
    };
 
    if (twinkleTick < kSteps) {
        set_color(twinkleVolumeName, kFlash[twinkleTick]);
        ++twinkleTick;
    } else {
        twinkleTimer->stop();
        G4Ttree_item* item = findTreeItem(twinkleVolumeName);
        if (item) {
            item->set_color(twinkleSavedColor);
            item->set_opacity(twinkleSavedOpacity);
        }
        const double r = twinkleSavedColor.redF();
        const double g = twinkleSavedColor.greenF();
        const double b = twinkleSavedColor.blueF();
        const std::string cmd = "/vis/geometry/set/colour " + twinkleVolumeName + " 0 "
            + std::to_string(r) + " "
            + std::to_string(g) + " "
            + std::to_string(b) + " "
            + std::to_string(twinkleSavedOpacity);
        gutilities::apply_uimanager_commands(cmd);
    }
}
 
 
// Open the selected volume in a new viewer window of the same driver type.
void GTree::inspectVolume() {
    if (current_volume_name.empty()) return;
 
    G4UImanager* uim = G4UImanager::GetUIpointer();
    if (!uim) return;
 
    // Resolve the active driver and save the viewer name so we can return focus
    // to the original window after opening the inspect window.
    std::string driverName        = "OGLSQt";
    std::string originalViewerName;
    auto* vm = G4VisManager::GetInstance();
    if (vm) {
        const auto* viewer = vm->GetCurrentViewer();
        if (viewer) {
            originalViewerName = viewer->GetName();
            const auto* sh = viewer->GetSceneHandler();
            if (sh) {
                const auto* gs = sh->GetGraphicsSystem();
                if (gs) driverName = gs->GetNickname();
            }
        }
    }
 
    const std::string leafName = G4Ttree_item::vname_from_v4name(current_volume_name);
 
    // Open a new window, populate it with only the target volume, and flush.
    // /vis/open creates a new viewer whose scene handler attaches to the current (full) scene.
    // /vis/scene/create makes a new empty scene but does NOT re-attach the handler.
    // /vis/sceneHandler/attach must come before /vis/scene/add/volume to wire the new handler
    // to the new empty scene; otherwise the first flush renders the full detector.
    uim->ApplyCommand("/vis/open " + driverName);
    uim->ApplyCommand("/vis/scene/create");
    uim->ApplyCommand("/vis/sceneHandler/attach");
    uim->ApplyCommand("/vis/scene/add/volume " + current_volume_name + " -1");
    uim->ApplyCommand("/vis/viewer/set/background 1 1 1 1");
    uim->ApplyCommand("/vis/viewer/set/lineSegmentsPerCircle 100");
    // 2D label: large black text centred near the top of the window.
    // "! !" tells Geant4 to use the colour and layout set by /vis/set/text*.
    uim->ApplyCommand("/vis/set/textColour black");
    uim->ApplyCommand("/vis/set/textLayout centre");
    uim->ApplyCommand("/vis/scene/add/text2D 0 0.85 36 ! ! " + leafName);
    uim->ApplyCommand("/vis/viewer/flush");
 
    // Return Geant4's "current viewer" to the original window so all GUI controls
    // (camera, scene properties, tree widget) continue to act on the main view.
    if (!originalViewerName.empty())
        uim->ApplyCommand("/vis/viewer/select " + originalViewerName);
}
 
 
// Warn that /vis/drawLogicalVolume is not yet usable due to a Geant4 11.4.2 TOOLSSG bug.
void GTree::drawOverlapsWarning() {
    QMessageBox::warning(this,
        tr("Not yet implemented"),
        tr("Draw Logical Overlaps will be implemented when Geant4 fixes the\n"
           "G4ToolsSGSceneHandler::GetOrCreateNode \"World mis-match\" crash\n"
           "triggered by /vis/drawLogicalVolume in Geant4 11.4.2."));
}
 
 
// Convert slider position to alpha and apply it to the currently selected volume.
void GTree::onOpacitySliderChanged(int value) {
    if (current_volume_name.empty())
        return; // no volume selected
 
    double opacity = value / 100.0;
 
    if (opacityLabel) {
        opacityLabel->setText(QString::number(opacity, 'f', 2));
    }
 
    set_opacity(current_volume_name, opacity);
}
 
// Update alpha for a volume while preserving cached RGB components.
void GTree::set_opacity(const std::string& volumeName, double opacity) {
 
    // find current color for this volume from our tree model
    G4Ttree_item* item = findTreeItem(volumeName);
    if (!item) return;
 
    QColor c = item->get_color();
    double r = c.redF();
    double g = c.greenF();
    double b = c.blueF();
 
    // Geant4: r g b alpha
    std::string command = "/vis/geometry/set/colour " + volumeName + " 0 "
        + std::to_string(r) + " "
        + std::to_string(g) + " "
        + std::to_string(b) + " "
        + std::to_string(opacity);
 
    // Keep the model synchronized with the command we are sending.
    item->set_color(c);
    item->set_opacity(opacity);
 
    gutilities::apply_uimanager_commands(command);
}