gtree.h

Go to the documentation of this file.

#pragma once
 
// gemc
#include <gemc/gqtbuttonswidget/gQtButtonsWidget.h> // Custom toggle button widget
#include <gemc/g4system/g4volume.h>
#include <gemc/gsystem/gvolume.h>
#include <gemc/gbase/gbase.h> // Provides application options/configuration
#include <gemc/goptions/goptions.h>
 
// qt
#include <QWidget>
#include <QTreeWidgetItem>
#include <QColor>
#include <QLabel>
#include <QTextEdit>
#include <QPushButton>
#include <QSlider>
 
class QTimer;
 
// cpp
#include <map>
#include <memory>

class G4Ttree_item
{
public:
    explicit G4Ttree_item(G4Volume* g4volume, const GVolume* gvolume = nullptr);
 
private:
    std::string mother;

    QColor color;

    bool is_visible = true;

    int representation = 1; // 0 = wireframe ; 1 = solid; 2 = cloud

    double opacity = 1.0;

    std::string material;

    mutable double mass = 0.0;

    mutable double volume = 0.0;

    mutable double density = 0.0;

    mutable bool physics_computed = false;

    G4LogicalVolume* logical_ptr = nullptr;

    G4VSolid* solid_ptr = nullptr;

    void compute_physics_quantities() const;

    bool recursive = false;
 
    // pygemc descriptor fields (empty when no GVolume descriptor is available)
    std::string solidType;       
    std::string parameters;      
    std::string position;        
    std::string rotation;        
    std::string motherVolume;    
    std::string solidsOpr;       
    std::string volDescription;  
 
public:
    [[nodiscard]] std::string get_mother() const { return mother; }

    [[nodiscard]] QColor get_color() const { return color; }

    [[nodiscard]] bool get_visibility() const { return is_visible; }

    [[nodiscard]] int get_representation() const { return representation; }

    [[nodiscard]] double get_opacity() const { return opacity; }

    [[nodiscard]] double get_mass() const {
        compute_physics_quantities();
        return mass;
    }

    [[nodiscard]] double get_volume() const {
        compute_physics_quantities();
        return volume;
    }

    [[nodiscard]] double get_density() const {
        compute_physics_quantities();
        return density;
    }

    [[nodiscard]] std::string get_material() const { return material; }

    [[nodiscard]] bool get_recursive() const { return recursive; }

    [[nodiscard]] std::string get_solidType() const { return solidType; }
    [[nodiscard]] std::string get_parameters() const { return parameters; }
    [[nodiscard]] std::string get_position() const { return position; }
    [[nodiscard]] std::string get_rotation() const { return rotation; }
    [[nodiscard]] std::string get_motherVolume() const { return motherVolume; }
    [[nodiscard]] std::string get_solidsOpr() const { return solidsOpr; }
    [[nodiscard]] std::string get_volDescription() const { return volDescription; }

    void set_recursive(bool recursive) { this->recursive = recursive; }

    void set_color(const QColor& c)  { color = c; }

    void set_opacity(double opacity) { this->opacity = opacity; }

    static std::string vname_from_v4name(std::string v4name);

    static std::string system_from_v4name(std::string v4name);
};
 
// map for a single system
using g4tree_map = std::map<std::string, std::unique_ptr<G4Ttree_item>>;

class GTree : public QWidget, public GBase<GTree>
{
    Q_OBJECT
 
public:
    explicit GTree(const std::shared_ptr<GOptions>& gopt,
                   std::unordered_map<std::string, G4Volume*> g4volumes_map,
                   std::unordered_map<std::string, const GVolume*> gvolumes_map = {},
                   QWidget* parent = nullptr);

    GTree(const GTree&) = delete;

    GTree& operator=(const GTree&) = delete;
 
private:
    std::map<std::string, g4tree_map> g4_systems_tree; // map of systems

    std::unordered_map<std::string, const GVolume*> gvolumes_map;

    QTreeWidget* treeWidget = nullptr;
 
    // right-side panel
    QWidget* rightPanel = nullptr;

    QWidget* bottomPanel = nullptr; // appears only when an item is selected

    GQTButtonsWidget* styleButtons;  // left bar buttons
 
    // info labels inside bottomPanel
    QLabel* typeLabel = nullptr;         
    QLabel* daughtersLabel = nullptr;    
    QLabel* nameLabel = nullptr;         
    QLabel* materialLabel = nullptr;     
    QLabel* massLabel = nullptr;         
    QLabel* volumeLabel = nullptr;       
    QLabel* densityLabel = nullptr;      
    QLabel* solidTypeLabel = nullptr;    
    QTextEdit* parametersLabel = nullptr; 
    QLabel* positionLabel = nullptr;     
    QLabel* rotationLabel = nullptr;     
    QLabel* motherLabel = nullptr;       
    QLabel* descriptionLabel = nullptr;  

    QSlider* opacitySlider = nullptr;

    QLabel*  opacityLabel  = nullptr;

    QPushButton* inspectButton = nullptr;

    QPushButton* drawOverlapsButton = nullptr;

    void build_tree(std::unordered_map<std::string, G4Volume*> g4volumes_map);

    void populateTree();

    void set_visibility(const std::string& fullName, bool visible);

    void set_color(const std::string& fullName, const QColor& c);

    void set_opacity(const std::string& volumeName, double opacity);

    QWidget* right_widget();

    int get_ndaughters(QTreeWidgetItem* item) const;

    G4Ttree_item* findTreeItem(const std::string& fullName);

    std::string current_volume_name;
 
    // Twinkle animation state
    QTimer*     twinkleTimer       = nullptr;
    int         twinkleTick        = 0;
    QColor      twinkleSavedColor;
    double      twinkleSavedOpacity = 1.0;
    std::string twinkleVolumeName;

    void centreTwinkle();
 
private slots:
    void onItemChanged(QTreeWidgetItem* item, int column);

    void onColorButtonClicked();

    void onTreeItemClicked(QTreeWidgetItem* item, int column);

    void onCurrentItemChanged(QTreeWidgetItem* current, QTreeWidgetItem* previous);

    void changeStyle();

    void onOpacitySliderChanged(int value);

    void inspectVolume();

    void drawOverlapsWarning();

    void onTwinkleStep();
};