lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 11.2.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2023-12-08 10:43:34 +01:00
parent dd1f179cda
commit 860a2b92bf
3962 changed files with 139318 additions and 164259 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/visualization/management/include/G4VViewer.hh
+4 -24
View File
@@ -48,6 +48,7 @@
class G4VSceneHandler;
// clang-format off
class G4VViewer {
public: // With description
@@ -173,7 +174,7 @@ public: // With description
SceneTreeScene() = default;
~SceneTreeScene() = default;
void SetViewer(G4VViewer* pViewer) {fpViewer = pViewer;}
void SetModel(G4VModel* pModel);
void SetModel(G4VModel* pModel); // ...and more (see .cc)
private:
void ProcessVolume(const G4VSolid& solid) override;
std::list<G4SceneTreeItem>::iterator FindOrInsertModel
@@ -183,6 +184,8 @@ public: // With description
G4int depth, const G4String& partialPathString, const G4String& fullPathString);
G4VViewer* fpViewer = nullptr;
G4VModel* fpModel = nullptr;
G4int fMaximumExpandedDepth = 0; // To be calculated in SetModel
const G4int fMaximumExpanded = 30; // So as not to swamp the GUI
};
SceneTreeScene& AccessSceneTreeScene() {return fSceneTreeScene;}
G4SceneTreeItem& AccessSceneTree() {return fSceneTree;}
@@ -245,29 +248,6 @@ protected:
// Set the touchable colour attribute.
// Changes the Vis Attribute Modifiers WITHOUT triggering a rebuild.
class G4Spline
{
public:
// Constructors and destructor
G4Spline();
~G4Spline();
// Operations
void AddSplinePoint(const G4Vector3D& v);
G4Vector3D GetInterpolatedSplinePoint(G4float t); // t = 0...1; 0=vp[0] ... 1=vp[max]
G4int GetNumPoints();
G4Vector3D GetPoint(int);
// method for computing the Catmull-Rom parametric equation
// given a time (t) and a vector quadruple (p1,p2,p3,p4).
G4Vector3D CatmullRom_Eq(G4float t, const G4Vector3D& p1, const G4Vector3D& p2,
const G4Vector3D& p3, const G4Vector3D& p4);
private:
std::vector<G4Vector3D> vp;
G4float delta_t;
};
//////////////////////////////////////////////////////////////
// Data members
G4VSceneHandler& fSceneHandler; // Abstract scene for this view.
source/visualization/management/include/G4VViewer.icc
+33 -20
View File
@@ -25,66 +25,79 @@
//
//
//
//
//
// John Allison 30th December 1996
inline void G4VViewer::Initialise () {}
inline void G4VViewer::Initialise() {}
inline void G4VViewer::ResetView () {
inline void G4VViewer::ResetView()
{
fVP = fDefaultVP;
}
inline void G4VViewer::RefreshView () {
SetView(); ClearView(); DrawView();
inline void G4VViewer::RefreshView()
{
SetView();
ClearView();
DrawView();
}
inline G4int G4VViewer::GetViewId () const {
inline G4int G4VViewer::GetViewId() const
{
return fViewId;
}
inline const G4String& G4VViewer::GetName () const {
inline const G4String& G4VViewer::GetName() const
{
return fName;
}
inline const G4String& G4VViewer::GetShortName () const {
inline const G4String& G4VViewer::GetShortName() const
{
return fShortName;
}
inline G4VSceneHandler* G4VViewer::GetSceneHandler () const {
inline G4VSceneHandler* G4VViewer::GetSceneHandler() const
{
return &fSceneHandler;
}
inline const G4ViewParameters& G4VViewer::GetViewParameters () const {
inline const G4ViewParameters& G4VViewer::GetViewParameters() const
{
return fVP;
}
inline const G4ViewParameters& G4VViewer::GetDefaultViewParameters () const {
inline const G4ViewParameters& G4VViewer::GetDefaultViewParameters() const
{
return fDefaultVP;
}
inline const std::vector<G4ModelingParameters::VisAttributesModifier>*
G4VViewer::GetPrivateVisAttributesModifiers() const {
return 0;
G4VViewer::GetPrivateVisAttributesModifiers() const
{
return 0;
}
inline void G4VViewer::SetDefaultViewParameters (const G4ViewParameters& vp) {
inline void G4VViewer::SetDefaultViewParameters(const G4ViewParameters& vp)
{
fDefaultVP = vp;
}
inline const G4VisAttributes* G4VViewer::GetApplicableVisAttributes
(const G4VisAttributes* pVisAttribs) const
inline const G4VisAttributes*
G4VViewer::GetApplicableVisAttributes(const G4VisAttributes* pVisAttribs) const
{
// If pVisAttribs is zero, pick up the default vis attributes from
// the view parameters.
if (!pVisAttribs)
pVisAttribs = GetViewParameters().GetDefaultVisAttributes();
if (!pVisAttribs) pVisAttribs = GetViewParameters().GetDefaultVisAttributes();
return pVisAttribs;
}
inline void G4VViewer::SetNeedKernelVisit (G4bool need) {
inline void G4VViewer::SetNeedKernelVisit(G4bool need)
{
fNeedKernelVisit = need;
}
inline G4double G4VViewer::GetKernelVisitElapsedTimeSeconds () const {
inline G4double G4VViewer::GetKernelVisitElapsedTimeSeconds() const
{
return fKernelVisitElapsedTimeSeconds;
}
source/visualization/management/include/G4VisExecutive.hh
+10 -1
View File
@@ -120,10 +120,19 @@ class G4VisExecutive: public G4VisManager {
public: // With description
G4VisExecutive (const G4String& verbosityString = "warnings");
G4VisExecutive(const G4String& verbosityString = "warnings");
G4VisExecutive(int argc, char** argv, const G4String& system = "",
const G4String& verbosityString = "warnings");
private:
void SetDefaultsByArgument(const G4String& system);
void SetDefaultsByEnvironment();
void SetDefaultsByFile(int argc, char** argv);
void SetDefaultsByBatch();
void SetDefaultsByBuildFlags();
G4bool fSelected;
void RegisterGraphicsSystems();
void RegisterModelFactories();
source/visualization/management/include/G4VisExecutive.icc
+185 -5
View File
@@ -123,6 +123,15 @@
#ifdef G4VIS_USE_VTK
#include "G4Vtk.hh" // no_geant4_module_check
#include "G4VtkOffscreen.hh" // no_geant4_module_check
#undef G4VIS_USE_TOOLSSG_X11_GLES
#undef G4VIS_USE_TOOLSSG_XT_GLES
#undef G4VIS_USE_TOOLSSG_QT_GLES
#undef G4VIS_USE_TOOLSSG_WINDOWS_GLES
#undef G4VIS_USE_OPENGLQT
#undef G4VIS_USE_OPENGLXM
#undef G4VIS_USE_OPENGLX
#undef G4VIS_USE_OPENGLWIN32
#endif
#ifdef G4VIS_USE_VTK_QT
@@ -133,6 +142,13 @@
#include <QtGlobal>
#endif
#include "G4UImanager.hh"
#include "G4UIsession.hh"
#include "G4UIbatch.hh"
#include <cstdlib>
#include <sstream>
// The inline keyword prevents the compiler making an external
// reference even though they cannot actually be inlined since they
// are virtual functions. This prevents a "multiple definition" error
@@ -142,10 +158,158 @@
// since after instantiation the object can be treated as a
// G4VisManager.
inline
G4VisExecutive::G4VisExecutive(int argc, char** argv, const G4String& system,
const G4String& verbosityString):
G4VisManager(verbosityString),
fSelected(false)
{
if (!fSelected) SetDefaultsByArgument(system);
if (!fSelected) SetDefaultsByEnvironment();
if (!fSelected) SetDefaultsByFile(argc, argv);
if (!fSelected) SetDefaultsByBatch();
if (!fSelected) SetDefaultsByBuildFlags();
}
inline
G4VisExecutive::G4VisExecutive (const G4String& verbosityString):
G4VisManager(verbosityString)
{}
G4VisManager(verbosityString),
fSelected(false)
{
if (!fSelected) SetDefaultsByEnvironment();
if (!fSelected) SetDefaultsByBatch();
if (!fSelected) SetDefaultsByBuildFlags();
}
inline
void G4VisExecutive::SetDefaultsByArgument(const G4String& system)
{
// 1st priority: selection by G4VisExecuitive argument
if (!system.empty()) {
fDefaultGraphicsSystemName = system;
fDefaultGraphicsSystemBasis = "G4VisExecuitive argument";
fSelected = true;
}
}
inline
void G4VisExecutive::SetDefaultsByEnvironment()
{
// 2nd priority: by environment variable
if (auto g4env = std::getenv("G4VIS_DEFAULT_DRIVER")) {
G4String graphicsSystem, windowSizeHint;
std::istringstream iss(g4env);
iss >> graphicsSystem >> windowSizeHint;
if (!graphicsSystem.empty()) {
fDefaultGraphicsSystemName = graphicsSystem;
fDefaultGraphicsSystemBasis = "environment G4VIS_DEFAULT_DRIVER";
fSelected = true;
}
if (!windowSizeHint.empty()) {
fDefaultXGeometryString = windowSizeHint;
fDefaultXGeometryStringBasis = "environment G4VIS_DEFAULT_DRIVER";
}
}
}
inline
void G4VisExecutive::SetDefaultsByFile(int argc, char** argv)
{
// 3rd priority: in $HOME/.g4session
// Find ~/.g4session - simply return if it does not exist
const char* home = std::getenv("HOME");
if (home == nullptr) return;
G4String homedir = home;
#ifndef WIN32
G4String filename = homedir + "/.g4session";
#else
G4String filename = homedir + "\\.g4session";
#endif
std::ifstream g4session(filename);
if (g4session.fail()) return;
// Find app name
if (argc < 1) return;
G4String appInput = argv[0];
G4String appName = "";
size_t islash = appInput.find_last_of("/\\");
if (islash == G4String::npos) appName = appInput;
else appName = appInput.substr(islash + 1, appInput.size() - islash - 1);
// Scan ~/.g4session
G4String line;
// First line is the user-chosen default: session, graphics system, windo wize hint
G4String applicableSession, applicableGraphicsSystem, applicableWindowSizeHint;
std::getline(g4session,line);
auto hash = line.find_first_of('#'); line = line.substr(0,hash);
std::istringstream iss(line);
iss >> applicableSession >> applicableGraphicsSystem >> applicableWindowSizeHint;
// Read subsequent lines
while (g4session.good()) {
G4String app, session, graphicsSystem, windowSizeHint;
std::getline(g4session,line);
hash = line.find_first_of('#'); line = line.substr(0,hash);
std::istringstream iss1(line);
iss1 >> app >> session >> graphicsSystem >> windowSizeHint;
if (app == appName) {
if (!session.empty()) applicableSession = session; // See G4UIExecutive
if (!graphicsSystem.empty()) applicableGraphicsSystem = graphicsSystem;
if (!windowSizeHint.empty()) applicableWindowSizeHint = windowSizeHint;
}
}
if (!applicableGraphicsSystem.empty()) {
fDefaultGraphicsSystemName = applicableGraphicsSystem;
fDefaultGraphicsSystemBasis = "~/.g4session";
fSelected = true;
}
if (!applicableWindowSizeHint.empty()) {
fDefaultXGeometryString = applicableWindowSizeHint;
fDefaultXGeometryStringBasis = "~/.g4session";
}
}
inline
void G4VisExecutive::SetDefaultsByBatch()
{
// 4th, special case for batch session
G4UIsession* session = G4UImanager::GetUIpointer()->GetBaseSession();
if (session == nullptr // Usual case - pure batch
|| dynamic_cast<G4UIbatch*>(session)) { // From a macro from batch
// Choose an offscreen or file-writing system
fDefaultGraphicsSystemName = "TSG_OFFSCREEN";
fDefaultGraphicsSystemBasis = "batch session";
fSelected = true;
}
}
inline
void G4VisExecutive::SetDefaultsByBuildFlags()
{
// 5th, by cpp flags
#if defined G4VIS_USE_OPENGLQT || G4VIS_USE_OPENGLXM ||\
G4VIS_USE_OPENGLX || G4VIS_USE_OPENGLWIN32
fDefaultGraphicsSystemName = "OGL";
#elif defined G4VIS_USE_OI || G4VIS_USE_OIX
fDefaultGraphicsSystemName = "OI";
#elif defined G4VIS_USE_TOOLSSG_QT_GLES || G4VIS_USE_TOOLSSG_X11_GLES ||\
G4VIS_USE_TOOLSSG_XT_GLES || G4VIS_USE_TOOLSSG_WINDOWS_GLES
fDefaultGraphicsSystemName = "TSG";
#elif defined G4VIS_USE_VTK || G4VIS_USE_VTK_QT
fDefaultGraphicsSystemName = "Vtk";
#elif defined G4VIS_USE_TOOLSSG_QT_ZB || G4VIS_USE_TOOLSSG_X11_ZB ||\
G4VIS_USE_TOOLSSG_XT_ZB || G4VIS_USE_TOOLSSG_WINDOWS_ZB
fDefaultGraphicsSystemName = "TSG";
#elif defined G4VIS_USE_QT3D
fDefaultGraphicsSystemName = "Qt3D";
#else
// Choose a graphics system not needing external packages or libraries
fDefaultGraphicsSystemName = "TSG_OFFSCREEN";
#endif
fDefaultGraphicsSystemBasis = "build flags";
fSelected = true;
}
inline void
G4VisExecutive::RegisterGraphicsSystems () {
@@ -158,7 +322,6 @@ G4VisExecutive::RegisterGraphicsSystems () {
RegisterGraphicsSystem (new G4VRML2File);
RegisterGraphicsSystem (new G4GMocrenFile);
RegisterGraphicsSystem (new G4ToolsSGOffscreen);
G4VGraphicsSystem* tsg_offscreen = new G4ToolsSGOffscreen;
RegisterGraphicsSystem(tsg_offscreen);
tsg_offscreen->AddNickname("TSG_FILE");
@@ -320,8 +483,10 @@ G4VisExecutive::RegisterGraphicsSystems () {
#ifdef G4VIS_USE_TOOLSSG_QT_GLES
tsg_qt_gles->AddNickname("TSG");
# if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
G4cout << " Qt6: Asking ToolsSG to stand in for OpenGL" << G4endl;
tsg_qt_gles->AddNickname("OGL");
if (fVerbosity >= startup) {
G4cout << " Qt6: Asking ToolsSG to stand in for OpenGL" << G4endl;
tsg_qt_gles->AddNickname("OGL");
}
# endif
#elif defined(G4VIS_USE_TOOLSSG_XT_GLES)
tsg_xt_gles->AddNickname("TSG");
@@ -329,11 +494,26 @@ G4VisExecutive::RegisterGraphicsSystems () {
tsg_x11_gles->AddNickname("TSG");
#elif defined(G4VIS_USE_TOOLSSG_WINDOWS_GLES)
tsg_windows_gles->AddNickname("TSG");
#else
#ifdef G4VIS_USE_TOOLSSG_QT_ZB
tsg_qt_zb->AddNickname("TSG");
#elif G4VIS_USE_TOOLSSG_WINDOWS_ZB
tsg_windows_zb->AddNickname("TSG");
#else
tsg_offscreen->AddNickname("TSG");
#endif
#endif
#ifdef G4VIS_USE_VTK
if (fVerbosity >= startup) {
G4cout
<< " VTK: OpenGL-based drivers suppressed because of compatibility issues."
<< G4endl;
}
G4Vtk* vtkN = new G4Vtk();
G4VtkOffscreen* vtkOS = new G4VtkOffscreen();
RegisterGraphicsSystem(vtkN);
RegisterGraphicsSystem(vtkOS);
# ifdef G4VIS_USE_VTK_QT
vtkN->AddNickname("VTKQt_FALLBACK");
# endif
source/visualization/management/include/G4VisManager.hh
+16 -1
View File
@@ -412,6 +412,10 @@ public: // With description
G4int GetMaxEventQueueSize () const;
G4bool GetWaitOnEventQueueFull () const;
#endif
const G4String& GetDefaultGraphicsSystemName() const;
const G4String& GetDefaultXGeometryString () const;
const G4String& GetDefaultGraphicsSystemBasis() const;
const G4String& GetDefaultXGeometryStringBasis() const;
void SetCurrentGraphicsSystem (G4VGraphicsSystem*);
void SetCurrentScene (G4Scene*);
@@ -438,6 +442,10 @@ public: // With description
void SetMaxEventQueueSize (G4int);
void SetWaitOnEventQueueFull (G4bool);
#endif
void SetDefaultGraphicsSystemName(const G4String&);
void SetDefaultXGeometryString (const G4String&);
void SetDefaultGraphicsSystemBasis(const G4String&);
void SetDefaultXGeometryStringBasis(const G4String&);
/////////////////////////////////////////////////////////////////////
// Utility functions.
@@ -477,11 +485,19 @@ protected:
void RegisterMessengers (); // Command messengers.
const G4int fVerbose;
// No longer used. Use fVerbosity and access functions instead.
// fVerbose is kept for backwards compatibility for some user
// examples. (It is used in the derived user vis managers to print
// available graphics systems.) It is initialised to 1 in the
// constructor and cannot be changed.
static Verbosity fVerbosity;
G4String fDefaultGraphicsSystemName;
G4String fDefaultXGeometryString;
G4String fDefaultGraphicsSystemBasis;
G4String fDefaultXGeometryStringBasis;
private:
// Function templates to implement the Draw methods (to avoid source
@@ -515,7 +531,6 @@ private:
G4GraphicsSystemList fAvailableGraphicsSystems;
G4SceneList fSceneList;
G4SceneHandlerList fAvailableSceneHandlers;
static Verbosity fVerbosity;
std::vector<G4UImessenger*> fMessengerList;
std::vector<G4UIcommand*> fDirectoryList;
G4VisStateDependent* fpStateDependent; // Friend state dependent class.
source/visualization/management/include/G4VisManager.icc
+32
View File
@@ -134,6 +134,22 @@ inline G4bool G4VisManager::GetWaitOnEventQueueFull () const {
#endif
inline const G4String& G4VisManager::GetDefaultGraphicsSystemName () const {
return fDefaultGraphicsSystemName;
}
inline const G4String& G4VisManager::GetDefaultXGeometryString () const {
return fDefaultXGeometryString;
}
inline const G4String& G4VisManager::GetDefaultGraphicsSystemBasis () const {
return fDefaultGraphicsSystemBasis;
}
inline const G4String& G4VisManager::GetDefaultXGeometryStringBasis () const {
return fDefaultXGeometryStringBasis;
}
inline G4SceneList& G4VisManager::SetSceneList () {
return fSceneList;
}
@@ -203,3 +219,19 @@ inline void G4VisManager::SetWaitOnEventQueueFull (G4bool wait) {
}
#endif
inline void G4VisManager::SetDefaultGraphicsSystemName (const G4String& name) {
fDefaultGraphicsSystemName = name;
}
inline void G4VisManager::SetDefaultXGeometryString (const G4String& string) {
fDefaultXGeometryString = string;
}
inline void G4VisManager::SetDefaultGraphicsSystemBasis (const G4String& basis) {
fDefaultGraphicsSystemBasis = basis;
}
inline void G4VisManager::SetDefaultXGeometryStringBasis (const G4String& basis) {
fDefaultXGeometryStringBasis = basis;
}