OpenCMT/uLib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

starting udate geant sloid

Browse Source
This commit is contained in:
AndreaRigoni
2026-04-16 11:07:06 +00:00
parent 83af9a180f
commit 987d783fdb
10 changed files with 220 additions and 132 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
app/gcompose/src/ContextPanel.cpp
View File

@@ -10,6 +10,7 @@
#include <QList>
#include <QShortcut>
#include <QItemSelectionModel>
#include <functional>
ContextPanel::ContextPanel(QWidget* parent)
: QWidget(parent)
@@ -105,15 +106,34 @@ void ContextPanel::selectObject(uLib::Object* obj) {
return;
}
for (int i = 0; i < m_model->rowCount(); ++i) {
QModelIndex idx = m_model->index(i, 0);
if (idx.internalPointer() == obj) {
QSignalBlocker blocker(m_treeView->selectionModel());
m_treeView->selectionModel()->select(idx, QItemSelectionModel::ClearAndSelect | QItemSelectionModel::Rows);
m_treeView->scrollTo(idx);
m_propertiesPanel->setObject(obj); // Explicitly update properties too
return;
// Recursive search helper
std::function<QModelIndex(const QModelIndex&)> findIdx = [&](const QModelIndex& parent) -> QModelIndex {
for (int i = 0; i < m_model->rowCount(parent); ++i) {
QModelIndex idx = m_model->index(i, 0, parent);
if (idx.internalPointer() == obj) return idx;
if (m_model->rowCount(idx) > 0) {
QModelIndex childIdx = findIdx(idx);
if (childIdx.isValid()) return childIdx;
}
}
return QModelIndex();
};
QModelIndex targetIdx = findIdx(QModelIndex());
if (targetIdx.isValid()) {
QSignalBlocker blocker(m_treeView->selectionModel());
// Expand parents so the selection is visible
QModelIndex p = targetIdx.parent();
while (p.isValid()) {
m_treeView->expand(p);
p = p.parent();
}
m_treeView->selectionModel()->select(targetIdx, QItemSelectionModel::ClearAndSelect | QItemSelectionModel::Rows);
m_treeView->scrollTo(targetIdx);
m_propertiesPanel->setObject(obj);
}
}

64
src/HEP/Geant/Solid.cpp
View File

@@ -35,12 +35,14 @@
#include <Geant4/G4TriangularFacet.hh>
#include <Geant4/G4Box.hh>
#include <Geant4/G4PVPlacement.hh>
#include <cstddef>
#include "Math/Dense.h"
#include "Math/Transform.h"
#include "Solid.h"
#include "uLibInterface.hh"
namespace uLib {
namespace Geant {
@@ -55,18 +57,17 @@ public:
};
Solid::Solid()
: m_Name("unnamed_solid"), m_Material(NULL), m_Logical(NULL), m_Physical(NULL),
m_Position(new G4ThreeVector(0,0,0)), m_Rotation(NULL) {}
: m_Material(nullptr), m_Logical(nullptr) {
}
Solid::Solid(const char *name)
: m_Name(name), m_Material(NULL), m_Logical(NULL), m_Physical(NULL),
m_Position(new G4ThreeVector(0,0,0)), m_Rotation(NULL) {}
Solid::~Solid() {
if (m_Position) delete m_Position;
if (m_Rotation) delete m_Rotation;
: m_Name(name), m_Material(nullptr), m_Logical(nullptr) {
}
Solid::~Solid() {}
void Solid::Update() {}
void Solid::SetNistMaterial(const char *name) {
G4NistManager *nist = G4NistManager::Instance();
G4Material *mat = nist->FindOrBuildMaterial(name);
@@ -85,32 +86,12 @@ void Solid::SetMaterial(G4Material *material) {
}
void Solid::SetTransform(Matrix4f transform) {
uLib::AffineTransform t;
t.SetMatrix(transform);
// 2. Extract position and rotation for Geant4
Vector3f pos = t.GetPosition();
if (!m_Position) m_Position = new G4ThreeVector();
*m_Position = G4ThreeVector(pos(0), pos(1), pos(2));
// Create a G4 rotation matrix from the 4x4 matrix
Matrix3f m = t.GetRotation();
if (!m_Rotation) m_Rotation = new G4RotationMatrix();
m_Rotation->set(G4ThreeVector(m(0,0), m(1,0), m(2,0)),
G4ThreeVector(m(0,1), m(1,1), m(2,1)),
G4ThreeVector(m(0,2), m(1,2), m(2,2)));
// 3. If object is already placed, update its transformation
if (m_Physical) {
m_Physical->SetTranslation(*m_Position);
m_Physical->SetRotation(m_Rotation);
}
std::cout << "Solid " << GetName() << " position: " << pos << " rotation: " << m << std::endl;
this->Updated();
m_Transform.FromMatrix(transform);
m_Transform.Updated();
}
void Solid::SetParent(Solid *parent) {
if (!m_Logical) {
std::cerr << "logical volume not created for solid " << GetName() << std::endl;
@@ -133,8 +114,8 @@ void Solid::SetParent(Solid *parent) {
// G4PVPlacement
m_Physical = new G4PVPlacement(
m_Rotation, // Rotation
*m_Position, // Position (translation) inside the parent
ToG4Transform(m_Transform), // Rotation
GetPosition(), // Position (translation) inside the parent
m_Logical, // The logical volume of this solid (the child)
GetName(), // Name of the physical volume
parentLogical, // The logical volume of the parent (nullptr if it's the World volume)
@@ -182,15 +163,15 @@ void TessellatedSolid::Update() {
BoxSolid::BoxSolid(const char *name) :
BaseClass(name),
m_Density(1.0),
m_ContainerBox(new ContainerBox()),
m_Solid(new G4Box(name, 0.5, 0.5, 0.5))
{
Object::connect(m_ContainerBox, &ContainerBox::Updated, this, &BoxSolid::Update);
Update();
}
m_Solid(new G4Box(name, 1, 1, 1))
{}
BoxSolid::BoxSolid(const char *name, ContainerBox *box) : BaseClass(name) {
m_Solid = new G4Box(name, 0.5, 0.5, 0.5);
BoxSolid::BoxSolid(const char *name, ContainerBox *box) :
BaseClass(name),
m_Density(1.0) {
m_Solid = new G4Box(name, 1, 1, 1);
m_ContainerBox = box;
Object::connect(box, &ContainerBox::Updated, this, &BoxSolid::Update);
if (m_Logical) {
@@ -199,6 +180,7 @@ BoxSolid::BoxSolid(const char *name, ContainerBox *box) : BaseClass(name) {
Update();
}
void BoxSolid::Update() {
if (m_ContainerBox) {
Vector3f size = m_ContainerBox->GetSize();

87
src/HEP/Geant/Solid.h
View File

@@ -28,11 +28,15 @@
#include "Core/Object.h"
#include "Geant/Matter.h"
#include "Math/Transform.h"
#include <Geant4/G4LogicalVolume.hh>
#include "Math/ContainerBox.h"
#include "Math/Dense.h"
#include "Math/TriangleMesh.h"
class G4Material;
class G4LogicalVolume;
class G4TessellatedSolid;
@@ -42,28 +46,17 @@ namespace uLib {
namespace Geant {
class Solid : public Object {
public:
uLibTypeMacro(Solid, Object)
ULIB_SERIALIZE_ACCESS
ULIB_DECLARE_PROPERTIES(Solid)
public:
Solid();
Solid(const char *name);
virtual ~Solid();
void SetNistMaterial(const char *name);
void SetMaterial(G4Material *material);
void SetSizeUnit(const char *unit);
// Implementiamo SetParent qui, per tutti.
virtual void SetParent(Solid *parent);
// Setters per la posizione (necessari per il piazzamento)
void SetTransform(Matrix4f transform);
uLibGetMacro(Material, G4Material *)
uLibGetSetMacro(Logical, G4LogicalVolume *)
uLibGetSetMacro(Physical, G4VPhysicalVolume *)
virtual G4VSolid* GetG4Solid() const { return nullptr; }
inline const char *GetName() const {
@@ -72,20 +65,57 @@ public:
template < typename Ar >
void serialize(Ar &ar, const unsigned int version) {
ar & boost::serialization::make_nvp("Name", m_Name);
ar & HRP("Name", m_Name);
ar & HRP("Material", m_Material);
}
protected:
public slots:
virtual void Update();
protected:
std::string m_Name;
G4Material *m_Material;
G4LogicalVolume *m_Logical;
G4VPhysicalVolume *m_Physical; // <-- Memorizza l'oggetto posizionato
G4ThreeVector *m_Position; // <-- Offset rispetto al centro del padre
G4RotationMatrix* m_Rotation; // <-- Rotazione rispetto al padre
};
class LogicalVolume : public Object {
uLibTypeMacro(LogicalVolume, Object)
ULIB_SERIALIZE_ACCESS
ULIB_DECLARE_PROPERTIES(LogicalVolume)
public:
LogicalVolume();
LogicalVolume(const char *name);
virtual ~LogicalVolume();
virtual G4VSolid* GetG4Solid() const { return nullptr; }
inline const char *GetName() const {
return m_Logical ? m_Logical->GetName().c_str() : m_Name.c_str();
}
template < typename Ar >
void serialize(Ar &ar, const unsigned int version) {
ar & HRP("Name", m_Name);
ar & HRP("Material", m_Material);
}
public slots:
virtual void Update();
protected:
std::string m_Name;
Material *m_Material;
G4LogicalVolume *m_Logical;
};
@@ -95,8 +125,10 @@ public:
TessellatedSolid();
TessellatedSolid(const char *name);
void SetMesh(TriangleMesh &mesh);
uLibGetMacro(Solid, G4TessellatedSolid *)
virtual G4VSolid* GetG4Solid() const override { return (G4VSolid*)m_Solid; }
const TriangleMesh& GetMesh() const { return m_Mesh; }
@@ -115,9 +147,11 @@ private :
class BoxSolid : public Solid {
uLibTypeMacro(BoxSolid, Solid)
ULIB_SERIALIZE_ACCESS
ULIB_DECLARE_PROPERTIES(BoxSolid)
public:
uLibTypeMacro(BoxSolid, Solid)
BoxSolid(const char *name = "");
BoxSolid(const char *name, ContainerBox *box);
@@ -128,14 +162,15 @@ public:
template < typename Ar >
void serialize(Ar &ar, const unsigned int version) {
ar & boost::serialization::base_object<BaseClass>(*this);
ar & m_ContainerBox;
// ar & boost::serialization::base_object<BaseClass>(*this);
ar & HRP("Density", m_Density, "g/cm3");
}
public slots:
void Update();
private:
float m_Density;
ContainerBox *m_ContainerBox;
G4Box *m_Solid;
};

51
src/HEP/Geant/uLibInterface.hh Normal file
View File

@@ -0,0 +1,51 @@
#ifndef ULIB_GEANT_ULIB_INTERFACE_HH
#define ULIB_GEANT_ULIB_INTERFACE_HH
#include "Math/Transform.h"
#include <Geant4/G4Transform3D.hh>
#include <Geant4/G4ThreeVector.hh>
#include <Geant4/G4RotationMatrix.hh>
namespace uLib {
namespace Geant {
/**
* @brief Converts a uLib::Matrix4f to a Geant4 G4Transform3D.
*/
inline G4Transform3D ToG4Transform(const Matrix4f& m) {
return G4Transform3D(
m(0, 0), m(0, 1), m(0, 2), m(0, 3),
m(1, 0), m(1, 1), m(1, 2), m(1, 3),
m(2, 0), m(2, 1), m(2, 2), m(2, 3)
);
}
/**
* @brief Converts a uLib::AffineTransform to a Geant4 G4Transform3D.
*/
inline G4Transform3D ToG4Transform(const AffineTransform& at) {
return ToG4Transform(at.GetMatrix());
}
/**
* @brief Converts a uLib::Vector3f to a Geant4 G4ThreeVector.
*/
inline G4ThreeVector ToG4Vector(const Vector3f& v) {
return G4ThreeVector(v(0), v(1), v(2));
}
/**
* @brief Converts a uLib::Matrix3f to a Geant4 G4RotationMatrix.
*/
inline G4RotationMatrix ToG4Rotation(const Matrix3f& m) {
G4RotationMatrix rot;
rot.set(G4ThreeVector(m(0, 0), m(1, 0), m(2, 0)),
G4ThreeVector(m(0, 1), m(1, 1), m(2, 1)),
G4ThreeVector(m(0, 2), m(1, 2), m(2, 2)));
return rot;
}
} // namespace Geant
} // namespace uLib
#endif // ULIB_GEANT_ULIB_INTERFACE_HH

1
src/Math/Transform.h
View File

@@ -246,6 +246,7 @@ uLibTypeMacro(TRS, AffineTransform) ULIB_SERIALIZE_ACCESS
}
Matrix4f GetMatrix() const { return this->GetAffineMatrix().matrix(); }
};
inline std::ostream &operator<<(std::ostream &os, const TRS &trs) {

25
src/Vtk/HEP/Geant/vtkBoxSolid.cpp
View File

@@ -26,36 +26,11 @@ namespace Vtk {
BoxSolid::BoxSolid(Geant::BoxSolid *content)
: GeantSolid(content), m_BoxContent(content) {
this->InstallPipe();
// Connect the model's Updated event to updateTransform to ensure VTK sync
m_UpdateConnection = Object::connect(m_BoxContent, &uLib::Object::Updated, this, &BoxSolid::Update);
// Initial sync
this->Update();
}
BoxSolid::~BoxSolid() {
}
void BoxSolid::Update() {
ConnectionBlock blocker(m_UpdateConnection);
// Ensure base GeantSolid logic (G4Polyhedron and Transform) runs
this->GeantSolid::Update();
// Ensure base Prop3D properties (color, opacity, etc) are applied
this->Prop3D::Update();
}
void BoxSolid::SyncFromVtk() {
this->Prop3D::SyncFromVtk();
if (auto* proxy = vtkProp3D::SafeDownCast(this->GetProxyProp())) {
if (vtkMatrix4x4* mat = proxy->GetUserMatrix()) {
m_BoxContent->SetTransform(VtkToMatrix4f(mat));
}
}
}
void BoxSolid::serialize_display(uLib::Archive::display_properties_archive &ar,
const unsigned int version) {
// Expose Geant solid properties and underlying Box/TRS properties

8
src/Vtk/HEP/Geant/vtkBoxSolid.h
View File

@@ -48,13 +48,6 @@ public:
BoxSolid(Geant::BoxSolid *content);
virtual ~BoxSolid();
virtual void Update() override;
virtual void SyncFromVtk() override;
virtual uLib::Object *GetContent() const override {
return m_BoxContent ? (::uLib::Object*)m_BoxContent->GetObject() : nullptr;
}
virtual void serialize_display(uLib::Archive::display_properties_archive &ar,
const unsigned int version = 0) override;
@@ -67,7 +60,6 @@ protected:
virtual void InstallPipe() override;
Geant::BoxSolid *m_BoxContent;
uLib::Connection m_UpdateConnection;
ULIB_DECLARE_PROPERTIES(BoxSolid)
};

70
src/Vtk/HEP/Geant/vtkGeantSolid.cpp
View File

@@ -24,6 +24,7 @@
//////////////////////////////////////////////////////////////////////////////*/
#include "vtkGeantSolid.h"
#include "Core/Monitor.h"
#include <vtkActor.h>
#include <vtkPolyData.h>
@@ -34,6 +35,7 @@
#include <vtkSmartPointer.h>
#include <vtkTransform.h>
#include <vtkMatrix4x4.h>
#include "Vtk/Math/vtkDense.h"
#include <Geant4/G4VSolid.hh>
#include <Geant4/G4Polyhedron.hh>
@@ -45,6 +47,14 @@ namespace Vtk {
GeantSolid::GeantSolid(Content *content)
: m_SolidActor(vtkActor::New()), m_Content(content) {
this->InstallPipe();
if (m_Content) {
m_UpdateConnection = Object::connect(m_Content, &uLib::Object::Updated, [this]() {
std::cout << "GeantSolid: Signal Updated received." << std::endl;
this->Update();
});
// Mandatory initial update to generate geometry and apply initial transform
this->Update();
}
}
GeantSolid::~GeantSolid() {
@@ -58,8 +68,21 @@ vtkPolyData *GeantSolid::GetPolyData() const {
}
void GeantSolid::Update() {
ConnectionBlock blocker(m_UpdateConnection);
this->UpdateGeometry();
this->UpdateTransform();
this->Prop3D::Update();
}
void GeantSolid::SyncFromVtk() {
if (!m_Content) return;
this->Prop3D::SyncFromVtk();
if (auto* proxy = vtkProp3D::SafeDownCast(this->GetProxyProp())) {
if (vtkMatrix4x4* mat = proxy->GetUserMatrix()) {
m_Content->SetTransform(VtkToMatrix4f(mat));
}
}
}
void GeantSolid::UpdateGeometry() {
@@ -114,33 +137,36 @@ void GeantSolid::UpdateTransform() {
if (!m_Content || !m_SolidActor)
return;
// Apply the Geant4 transform (position/rotation) if placed
if (m_Content->GetPhysical()) {
auto *phys = m_Content->GetPhysical();
G4ThreeVector pos = phys->GetTranslation();
const G4RotationMatrix *rot = phys->GetRotation();
// Apply the Geant4 transform (position/rotation/scaling)
G4ThreeVector pos = m_Content->GetPosition();
const G4RotationMatrix *rot = m_Content->GetRotation();
G4ThreeVector scale = m_Content->GetScaling();
vtkSmartPointer<vtkTransform> transform = vtkSmartPointer<vtkTransform>::New();
transform->Identity();
transform->Translate(pos.x(), pos.y(), pos.z());
std::cout << "GeantSolid: Updating transform. Pos: " << pos.x() << " " << pos.y() << " " << pos.z()
<< " Scale: " << scale.x() << " " << scale.y() << " " << scale.z() << std::endl;
if (rot) {
// G4RotationMatrix stores the inverse of the rotation for placement
G4RotationMatrix invRot = rot->inverse();
double elements[16] = {
invRot.xx(), invRot.xy(), invRot.xz(), 0,
invRot.yx(), invRot.yy(), invRot.yz(), 0,
invRot.zx(), invRot.zy(), invRot.zz(), 0,
0, 0, 0, 1
};
vtkSmartPointer<vtkMatrix4x4> mat = vtkSmartPointer<vtkMatrix4x4>::New();
mat->DeepCopy(elements);
transform->Concatenate(mat);
}
vtkNew<vtkTransform> transform;
transform->Identity();
transform->Translate(pos.x(), pos.y(), pos.z());
if (rot) {
G4RotationMatrix invRot = *rot;
double elements[16] = {
invRot.xx(), invRot.xy(), invRot.xz(), 0,
invRot.yx(), invRot.yy(), invRot.yz(), 0,
invRot.zx(), invRot.zy(), invRot.zz(), 0,
0, 0, 0, 1
};
vtkNew<vtkMatrix4x4> mat;
mat->DeepCopy(elements);
transform->Concatenate(mat);
}
transform->Scale(scale.x(), scale.y(), scale.z());
m_SolidActor->SetUserTransform(transform);
m_SolidActor->Modified();
}
}
void GeantSolid::InstallPipe() {
vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();

8
src/Vtk/HEP/Geant/vtkGeantSolid.h
View File

@@ -52,15 +52,19 @@ public:
virtual class vtkPolyData *GetPolyData() const override;
virtual void Update() override;
virtual void SyncFromVtk() override;
virtual void UpdateGeometry();
virtual void UpdateTransform();
virtual uLib::Object *GetContent() const override { return (uLib::Object*)m_Content; }
protected:
virtual void InstallPipe();
vtkActor *m_SolidActor;
Content *m_Content;
vtkActor *m_SolidActor;
uLib::Connection m_UpdateConnection;
};
} // namespace Vtk

2
src/Vtk/vtkObjectsContext.h
View File

@@ -33,6 +33,8 @@ public:
/** @brief Synchronizes all managed prop3ds back to their models. */
virtual void SyncFromVtk() override;
virtual Object* GetContent() const override { return (Object*)m_Context; }
public:
virtual void Prop3DAdded(Prop3D* prop3d);
virtual void Prop3DRemoved(Prop3D* prop3d);