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

Import Geant4 10.5.0.beta source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2018-06-29 10:58:11 +02:00
parent fe81a77428
commit 6aa23be517
1581 changed files with 124288 additions and 83758 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/visualization/OpenGL/src/G4OpenGLQtViewer.cc
+37 -12
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4OpenGLQtViewer.cc 107329 2017-11-08 16:41:26Z gcosmo $
// $Id: G4OpenGLQtViewer.cc 110480 2018-05-25 07:25:18Z gcosmo $
//
//
// G4OpenGLQtViewer : Class to provide Qt specific
@@ -57,6 +57,7 @@
#include <CLHEP/Units/SystemOfUnits.h>
#include <typeinfo>
#include <mutex>
#include <qlayout.h>
#include <qlabel.h>
@@ -94,19 +95,18 @@
#include <qcursor.h>
#include <qthread.h>
#ifdef G4MULTITHREADED
#include "G4Threading.hh"
#endif
#ifdef G4MULTITHREADED
namespace
{
G4Mutex mWaitForVisSubThreadQtOpenGLContextMoved = G4MUTEX_INITIALIZER;
G4Mutex mWaitForVisSubThreadQtOpenGLContextInitialized = G4MUTEX_INITIALIZER;
// avoid unused variable warning
#ifdef G4MULTITHREADED
G4Condition c1_VisSubThreadQtOpenGLContextInitialized = G4CONDITION_INITIALIZER;
G4Condition c2_VisSubThreadQtOpenGLContextMoved = G4CONDITION_INITIALIZER;
}
#endif
}
//////////////////////////////////////////////////////////////////////////////
void G4OpenGLQtViewer::CreateMainWindow (
@@ -270,6 +270,12 @@ G4OpenGLQtViewer::G4OpenGLQtViewer (
,fLastHighlightName(0)
,fIsDeleting(false)
{
lWaitForVisSubThreadQtOpenGLContextInitialized
= new G4AutoLock(mWaitForVisSubThreadQtOpenGLContextInitialized,
std::defer_lock);
lWaitForVisSubThreadQtOpenGLContextMoved
= new G4AutoLock(mWaitForVisSubThreadQtOpenGLContextMoved,
std::defer_lock);
// launch Qt if not
if (QCoreApplication::instance () == NULL) {
@@ -511,6 +517,10 @@ G4OpenGLQtViewer::~G4OpenGLQtViewer (
delete fTreeIconClosed;
G4cout <<removeTempFolder().toStdString().c_str() <<G4endl;
delete lWaitForVisSubThreadQtOpenGLContextInitialized;
delete lWaitForVisSubThreadQtOpenGLContextMoved;
}
@@ -3283,7 +3293,7 @@ void G4OpenGLQtViewer::addNonPVSceneTreeElement(
const G4Text& g4Text = dynamic_cast<const G4Text&>(visible);
color = fSceneHandler.GetTextColour(g4Text);
}
catch (std::bad_cast) {
catch (const std::bad_cast&) {
color = fSceneHandler.GetColour();
}
if (modelShortName == "") {
@@ -4708,7 +4718,9 @@ void G4OpenGLQtViewer::DoneWithMasterThread()
// Called by Main Thread !
// Useful to avoid two vis thread at the same time
G4MUTEXLOCK(&mWaitForVisSubThreadQtOpenGLContextInitialized);
//G4MUTEXLOCK(&mWaitForVisSubThreadQtOpenGLContextInitialized);
if(!lWaitForVisSubThreadQtOpenGLContextInitialized->owns_lock())
lWaitForVisSubThreadQtOpenGLContextInitialized->lock();
}
void G4OpenGLQtViewer::SwitchToVisSubThread()
@@ -4725,9 +4737,14 @@ void G4OpenGLQtViewer::SwitchToVisSubThread()
// - Wait for the vis thread to set its QThread
G4CONDITIONBROADCAST(&c1_VisSubThreadQtOpenGLContextInitialized);
// a condition without a locked mutex is an undefined behavior.
// we check if the mutex owns the lock, and if not, we lock it
if(!lWaitForVisSubThreadQtOpenGLContextMoved->owns_lock())
lWaitForVisSubThreadQtOpenGLContextMoved->lock();
// Unlock the vis thread if it is Qt Viewer
G4CONDITIONWAIT(&c2_VisSubThreadQtOpenGLContextMoved, &mWaitForVisSubThreadQtOpenGLContextMoved);
G4CONDITIONWAIT(&c2_VisSubThreadQtOpenGLContextMoved,
lWaitForVisSubThreadQtOpenGLContextMoved);
// make context current
qGLW->makeCurrent();
@@ -4760,7 +4777,10 @@ void G4OpenGLQtViewer::SwitchToMasterThread()
}
// Useful to avoid two vis thread at the same time
G4MUTEXUNLOCK(&mWaitForVisSubThreadQtOpenGLContextInitialized);
//G4MUTEXUNLOCK(&mWaitForVisSubThreadQtOpenGLContextInitialized);
if(lWaitForVisSubThreadQtOpenGLContextInitialized->owns_lock())
lWaitForVisSubThreadQtOpenGLContextInitialized->unlock();
qGLW->makeCurrent();
}
@@ -4773,9 +4793,14 @@ void G4OpenGLQtViewer::MovingToVisSubThread(){
return;
}
// - Wait for the vis sub thread to set its QThread
G4CONDITIONWAIT( &c1_VisSubThreadQtOpenGLContextInitialized, &mWaitForVisSubThreadQtOpenGLContextInitialized);
// a condition without a locked mutex is an undefined behavior.
// we check if the mutex owns the lock, and if not, we lock it
if(!lWaitForVisSubThreadQtOpenGLContextInitialized->owns_lock())
lWaitForVisSubThreadQtOpenGLContextInitialized->lock();
// - Wait for the vis sub thread to set its QThread
G4CONDITIONWAIT(&c1_VisSubThreadQtOpenGLContextInitialized,
lWaitForVisSubThreadQtOpenGLContextInitialized);
// Set current QThread for the way back
SetQGLContextMainThread(QThread::currentThread());
source/visualization/OpenGL/src/G4OpenGLStoredQtSceneHandler.cc
+2 -2
View File
@@ -62,7 +62,7 @@ G4bool G4OpenGLStoredQtSceneHandler::ExtraPOProcessing
fPOList[currentPOListIndex].fpG4TextPlus = pG4TextPlus;
usesGLCommands = false;
}
catch (std::bad_cast) {} // No special action if not text. Just carry on.
catch (const std::bad_cast&) {} // No special action if not text. Just carry on.
G4PhysicalVolumeModel* pPVModel =
dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
@@ -128,7 +128,7 @@ G4bool G4OpenGLStoredQtSceneHandler::ExtraTOProcessing
fTOList[currentTOListIndex].fpG4TextPlus = pG4TextPlus;
usesGLCommands = false;
}
catch (std::bad_cast) {} // Do nothing if not text.
catch (const std::bad_cast&) {} // Do nothing if not text.
return usesGLCommands;
}
source/visualization/OpenGL/src/G4OpenGLStoredQtViewer.cc
+8 -1
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4OpenGLStoredQtViewer.cc 103926 2017-05-03 13:43:27Z gcosmo $
// $Id: G4OpenGLStoredQtViewer.cc 109510 2018-04-26 07:15:57Z gcosmo $
//
//
// Class G4OpenGLStoredQtViewer : a class derived from G4OpenGLQtViewer and
@@ -119,6 +119,8 @@ G4bool G4OpenGLStoredQtViewer::CompareForKernelVisit(G4ViewParameters& lastVP)
(lastVP.IsCullingInvisible () != fVP.IsCullingInvisible ()) ||
(lastVP.IsDensityCulling () != fVP.IsDensityCulling ()) ||
(lastVP.IsCullingCovered () != fVP.IsCullingCovered ()) ||
(lastVP.GetCBDAlgorithmNumber() !=
fVP.GetCBDAlgorithmNumber()) ||
(lastVP.IsSection () != fVP.IsSection ()) ||
// Section (DCUT) implemented locally. But still need to visit
// kernel if status changes so that back plane culling can be
@@ -172,6 +174,11 @@ G4bool G4OpenGLStoredQtViewer::CompareForKernelVisit(G4ViewParameters& lastVP)
}
***************************************************************/
if (lastVP.GetCBDAlgorithmNumber() > 0) {
if (lastVP.GetCBDParameters().size() != fVP.GetCBDParameters().size()) return true;
else if (lastVP.GetCBDParameters() != fVP.GetCBDParameters()) return true;
}
if (lastVP.IsExplode () &&
(lastVP.GetExplodeFactor () != fVP.GetExplodeFactor ()))
return true;
source/visualization/OpenGL/src/G4OpenGLStoredSceneHandler.cc
+13 -13
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4OpenGLStoredSceneHandler.cc 108544 2018-02-16 09:47:30Z gcosmo $
// $Id: G4OpenGLStoredSceneHandler.cc 110480 2018-05-25 07:25:18Z gcosmo $
//
//
// Andrew Walkden 10th February 1997
@@ -102,8 +102,8 @@ G4OpenGLStoredSceneHandler::PO& G4OpenGLStoredSceneHandler::PO::operator=
G4OpenGLStoredSceneHandler::TO::TO():
fDisplayListId(0),
fPickName(0),
fStartTime(-DBL_MAX),
fEndTime(DBL_MAX),
fStartTime(-G4VisAttributes::fVeryLongTime),
fEndTime(G4VisAttributes::fVeryLongTime),
fpG4TextPlus(0),
fMarkerOrPolyline(false)
{}
@@ -123,8 +123,8 @@ G4OpenGLStoredSceneHandler::TO::TO(G4int id, const G4Transform3D& tr):
fDisplayListId(id),
fTransform(tr),
fPickName(0),
fStartTime(-DBL_MAX),
fEndTime(DBL_MAX),
fStartTime(-G4VisAttributes::fVeryLongTime),
fEndTime(G4VisAttributes::fVeryLongTime),
fpG4TextPlus(0),
fMarkerOrPolyline(false)
{}
@@ -203,7 +203,8 @@ G4bool G4OpenGLStoredSceneHandler::AddPrimitivePreamble(const G4Polyhedron& visi
return AddPrimitivePreambleInternal(visible, false, false);
}
G4bool G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(const G4Visible& visible, bool isMarker, bool isPolyline)
G4bool G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal
(const G4Visible& visible, bool isMarker, bool isPolyline)
{
// Get applicable vis attributes for all primitives.
fpVisAttribs = fpViewer->GetApplicableVisAttributes(visible.GetVisAttributes());
@@ -212,10 +213,10 @@ G4bool G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(const G4Visible&
G4bool transparency_enabled = true;
G4bool isMarkerNotHidden = true;
G4OpenGLViewer* pViewer = dynamic_cast<G4OpenGLViewer*>(fpViewer);
if (pViewer) {
transparency_enabled = pViewer->transparency_enabled;
isMarkerNotHidden = pViewer->fVP.IsMarkerNotHidden();
G4OpenGLViewer* pOGLViewer = dynamic_cast<G4OpenGLViewer*>(fpViewer);
if (pOGLViewer) {
transparency_enabled = pOGLViewer->transparency_enabled;
isMarkerNotHidden = pOGLViewer->fVP.IsMarkerNotHidden();
}
G4bool isTransparent = opacity < 1.;
@@ -260,7 +261,6 @@ G4bool G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(const G4Visible&
if (fThirdPassForNonHiddenMarkers) {
if (!treatAsNotHidden) {
return false; // No further processing.
}
}
} // fThreePassCapable
@@ -432,8 +432,8 @@ end_of_display_list_reuse_test:
glMatrixMode (GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
if (pViewer) {
pViewer->g4GlOrtho (-1., 1., -1., 1., -G4OPENGL_FLT_BIG, G4OPENGL_FLT_BIG);
if (pOGLViewer) {
pOGLViewer->g4GlOrtho (-1., 1., -1., 1., -G4OPENGL_FLT_BIG, G4OPENGL_FLT_BIG);
}
glMatrixMode (GL_MODELVIEW);
glPushMatrix();
source/visualization/OpenGL/src/G4OpenGLStoredViewer.cc
+65 -12
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4OpenGLStoredViewer.cc 101714 2016-11-22 08:53:13Z gcosmo $
// $Id: G4OpenGLStoredViewer.cc 109510 2018-04-26 07:15:57Z gcosmo $
//
//
// Andrew Walkden 7th February 1997
@@ -78,6 +78,8 @@ G4bool G4OpenGLStoredViewer::CompareForKernelVisit(G4ViewParameters& lastVP) {
(lastVP.IsCullingInvisible () != fVP.IsCullingInvisible ()) ||
(lastVP.IsDensityCulling () != fVP.IsDensityCulling ()) ||
(lastVP.IsCullingCovered () != fVP.IsCullingCovered ()) ||
(lastVP.GetCBDAlgorithmNumber() !=
fVP.GetCBDAlgorithmNumber()) ||
(lastVP.IsSection () != fVP.IsSection ()) ||
// Section (DCUT) implemented locally. But still need to visit
// kernel if status changes so that back plane culling can be
@@ -122,15 +124,46 @@ G4bool G4OpenGLStoredViewer::CompareForKernelVisit(G4ViewParameters& lastVP) {
}
***************************************************************/
if (lastVP.GetCBDAlgorithmNumber() > 0) {
if (lastVP.GetCBDParameters().size() != fVP.GetCBDParameters().size()) return true;
else if (lastVP.GetCBDParameters() != fVP.GetCBDParameters()) return true;
}
if (lastVP.IsExplode () &&
(lastVP.GetExplodeFactor () != fVP.GetExplodeFactor ()))
return true;
// Time window parameters operate on the existing database so no need
// to rebuild even if they change.
return false;
}
void G4OpenGLStoredViewer::DrawDisplayLists () {
// We moved these from G4OpenGLViewer to G4ViewParamaters. To avoid
// editing many lines below we introduce these convenient aliases.
#define CONVENIENT_DOUBLE_ALIAS(q) const G4double& f##q = fVP.Get##q();
#define CONVENIENT_BOOL_ALIAS(q) const G4bool& f##q = fVP.Is##q();
CONVENIENT_DOUBLE_ALIAS(StartTime)
CONVENIENT_DOUBLE_ALIAS(EndTime)
CONVENIENT_DOUBLE_ALIAS(FadeFactor)
CONVENIENT_BOOL_ALIAS(DisplayHeadTime)
CONVENIENT_DOUBLE_ALIAS(DisplayHeadTimeX)
CONVENIENT_DOUBLE_ALIAS(DisplayHeadTimeY)
CONVENIENT_DOUBLE_ALIAS(DisplayHeadTimeSize)
CONVENIENT_DOUBLE_ALIAS(DisplayHeadTimeRed)
CONVENIENT_DOUBLE_ALIAS(DisplayHeadTimeGreen)
CONVENIENT_DOUBLE_ALIAS(DisplayHeadTimeBlue)
CONVENIENT_BOOL_ALIAS(DisplayLightFront)
CONVENIENT_DOUBLE_ALIAS(DisplayLightFrontX)
CONVENIENT_DOUBLE_ALIAS(DisplayLightFrontY)
CONVENIENT_DOUBLE_ALIAS(DisplayLightFrontZ)
CONVENIENT_DOUBLE_ALIAS(DisplayLightFrontT)
CONVENIENT_DOUBLE_ALIAS(DisplayLightFrontRed)
CONVENIENT_DOUBLE_ALIAS(DisplayLightFrontGreen)
CONVENIENT_DOUBLE_ALIAS(DisplayLightFrontBlue)
const G4Planes& cutaways = fVP.GetCutawayPlanes();
G4bool cutawayUnion = fVP.IsCutaway() &&
fVP.GetCutawayMode() == G4ViewParameters::cutawayUnion;
@@ -209,14 +242,14 @@ void G4OpenGLStoredViewer::DrawDisplayLists () {
glLoadIdentity();
G4OpenGLTransform3D oglt (po.fTransform);
glMultMatrixd (oglt.GetGLMatrix ());
fOpenGLSceneHandler.G4OpenGLSceneHandler::AddPrimitive
(po.fpG4TextPlus->fG4Text);
// This text is from a PODL. We don't want to create a new PODL.
AddPrimitiveForASingleFrame(po.fpG4TextPlus->fG4Text);
} else {
glPushMatrix();
G4OpenGLTransform3D oglt (po.fTransform);
glMultMatrixd (oglt.GetGLMatrix ());
fOpenGLSceneHandler.G4OpenGLSceneHandler::AddPrimitive
(po.fpG4TextPlus->fG4Text);
// This text is from a PODL. We don't want to create a new PODL.
AddPrimitiveForASingleFrame(po.fpG4TextPlus->fG4Text);
glPopMatrix();
}
@@ -238,7 +271,7 @@ void G4OpenGLStoredViewer::DrawDisplayLists () {
G4Transform3D lastMatrixTransform;
G4bool first = true;
for (size_t iTO = 0;
iTO < fG4OpenGLStoredSceneHandler.fTOList.size(); ++iTO) {
if (TOSelected(iTO)) {
@@ -294,8 +327,8 @@ void G4OpenGLStoredViewer::DrawDisplayLists () {
} else {
glColor3d(c.GetRed(),c.GetGreen(),c.GetBlue());
}
fOpenGLSceneHandler.G4OpenGLSceneHandler::AddPrimitive
(to.fpG4TextPlus->fG4Text);
// This text is from a TODL. We don't want to create a new TODL.
AddPrimitiveForASingleFrame(to.fpG4TextPlus->fG4Text);
if (to.fpG4TextPlus->fProcessing2D) {
glMatrixMode (GL_PROJECTION);
glPopMatrix();
@@ -362,7 +395,7 @@ void G4OpenGLStoredViewer::DrawDisplayLists () {
} while (true);
// Display time at "head" of time range, which is fEndTime...
if (fDisplayHeadTime && fEndTime < DBL_MAX) {
if (fDisplayHeadTime && fEndTime < G4VisAttributes::fVeryLongTime) {
glMatrixMode (GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
@@ -378,7 +411,7 @@ void G4OpenGLStoredViewer::DrawDisplayLists () {
fDisplayHeadTimeGreen,
fDisplayHeadTimeBlue));
headTimeText.SetVisAttributes(&visAtts);
fOpenGLSceneHandler.G4OpenGLSceneHandler::AddPrimitive(headTimeText);
AddPrimitiveForASingleFrame(headTimeText);
glMatrixMode (GL_PROJECTION);
glPopMatrix();
glMatrixMode (GL_MODELVIEW);
@@ -386,7 +419,7 @@ void G4OpenGLStoredViewer::DrawDisplayLists () {
}
// Display light front...
if (fDisplayLightFront && fEndTime < DBL_MAX) {
if (fDisplayLightFront && fEndTime < G4VisAttributes::fVeryLongTime) {
G4double lightFrontRadius = (fEndTime - fDisplayLightFrontT) * c_light;
if (lightFrontRadius > 0.) {
G4Point3D lightFrontCentre(fDisplayLightFrontX, fDisplayLightFrontY, fDisplayLightFrontZ);
@@ -431,10 +464,30 @@ void G4OpenGLStoredViewer::DrawDisplayLists () {
glColor3d(fDisplayLightFrontRed,
fDisplayLightFrontGreen,
fDisplayLightFrontBlue);
fOpenGLSceneHandler.G4OpenGLSceneHandler::AddPrimitive(lightFront);
AddPrimitiveForASingleFrame(lightFront);
}
}
}
}
void G4OpenGLStoredViewer::AddPrimitiveForASingleFrame(const G4Text& text)
{
// We don't want this to get into a display list or a TODL or a PODL so
// use the fMemoryForDisplayLists flag.
G4bool memoryForDisplayListsKeep = fG4OpenGLStoredSceneHandler.fMemoryForDisplayLists;
fG4OpenGLStoredSceneHandler.fMemoryForDisplayLists = false;
fG4OpenGLStoredSceneHandler.G4OpenGLStoredSceneHandler::AddPrimitive(text);
fG4OpenGLStoredSceneHandler.fMemoryForDisplayLists = memoryForDisplayListsKeep;
}
void G4OpenGLStoredViewer::AddPrimitiveForASingleFrame(const G4Circle& circle)
{
// We don't want this to get into a display list or a TODL or a PODL so
// use the fMemoryForDisplayLists flag.
G4bool memoryForDisplayListsKeep = fG4OpenGLStoredSceneHandler.fMemoryForDisplayLists;
fG4OpenGLStoredSceneHandler.fMemoryForDisplayLists = false;
fG4OpenGLStoredSceneHandler.G4OpenGLStoredSceneHandler::AddPrimitive(circle);
fG4OpenGLStoredSceneHandler.fMemoryForDisplayLists = memoryForDisplayListsKeep;
}
#endif
source/visualization/OpenGL/src/G4OpenGLViewer.cc
+1 -19
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4OpenGLViewer.cc 107329 2017-11-08 16:41:26Z gcosmo $
// $Id: G4OpenGLViewer.cc 108131 2018-01-09 13:23:26Z gcosmo $
//
//
// Andrew Walkden 27th March 1996
@@ -74,24 +74,6 @@ background (G4Colour(0.,0.,0.)),
transparency_enabled (true),
antialiasing_enabled (false),
haloing_enabled (false),
fStartTime(-DBL_MAX),
fEndTime(DBL_MAX),
fFadeFactor(0.),
fDisplayHeadTime(false),
fDisplayHeadTimeX(-0.9),
fDisplayHeadTimeY(-0.9),
fDisplayHeadTimeSize(24.),
fDisplayHeadTimeRed(0.),
fDisplayHeadTimeGreen(1.),
fDisplayHeadTimeBlue(1.),
fDisplayLightFront(false),
fDisplayLightFrontX(0.),
fDisplayLightFrontY(0.),
fDisplayLightFrontZ(0.),
fDisplayLightFrontT(0.),
fDisplayLightFrontRed(0.),
fDisplayLightFrontGreen(1.),
fDisplayLightFrontBlue(0.),
fRot_sens(1.),
fPan_sens(0.01),
fWinSize_x(0),
source/visualization/OpenGL/src/G4OpenGLViewerMessenger.cc
+60 -34
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4OpenGLViewerMessenger.cc 101105 2016-11-07 08:09:26Z gcosmo $
// $Id: G4OpenGLViewerMessenger.cc 109510 2018-04-26 07:15:57Z gcosmo $
#ifdef G4VIS_BUILD_OPENGL_DRIVER
@@ -122,7 +122,8 @@ G4OpenGLViewerMessenger::G4OpenGLViewerMessenger()
fpCommandDisplayHeadTime =
new G4UIcommand("/vis/ogl/set/displayHeadTime", this);
fpCommandDisplayHeadTime->SetGuidance
("Display head time of range in 2D text.");
("DEPRECATED. Use /vis/viewer/set/timeWindow/displayHeadTime."
"\n Display head time of range in 2D text.");
parameter = new G4UIparameter ("displayHeadTime", 'b', omitable = false);
parameter->SetDefaultValue(false);
fpCommandDisplayHeadTime->SetParameter(parameter);
@@ -155,7 +156,8 @@ G4OpenGLViewerMessenger::G4OpenGLViewerMessenger()
fpCommandDisplayLightFront =
new G4UIcommand("/vis/ogl/set/displayLightFront", this);
fpCommandDisplayLightFront->SetGuidance
("Display the light front at head time.");
("DEPRECATED. Use /vis/viewer/set/timeWindow/displayLightFront."
"\n Display the light front at head time.");
fpCommandDisplayLightFront->SetGuidance
("Tip: The trajectories can appear of jump ahead of the light front"
"\nbecause their time range overlaps the viewer's time range. To"
@@ -209,9 +211,11 @@ G4OpenGLViewerMessenger::G4OpenGLViewerMessenger()
fpCommandEndTime =
new G4UIcommand("/vis/ogl/set/endTime", this);
fpCommandEndTime->SetGuidance("Set end and range of track time.");
fpCommandEndTime->SetGuidance
("DEPRECATED. Use /vis/viewer/set/timeWindow/endTime."
"\n Set end and range of time window.");
parameter = new G4UIparameter ("end-time", 'd', omitable = false);
parameter->SetDefaultValue(DBL_MAX);
parameter->SetDefaultValue(G4VisAttributes::fVeryLongTime);
fpCommandEndTime->SetParameter(parameter);
parameter = new G4UIparameter ("end-time-unit", 's', omitable = false);
parameter->SetDefaultValue("ns");
@@ -234,7 +238,8 @@ G4OpenGLViewerMessenger::G4OpenGLViewerMessenger()
fpCommandFade = new G4UIcmdWithADouble("/vis/ogl/set/fade", this);
fpCommandFade->SetGuidance
("0: no fade; 1: maximum fade with time within range.");
("DEPRECATED. Use /vis/viewer/set/timeWindow/fadeFactor."
"\n 0: no fade; 1: maximum fade with time within range.");
fpCommandFade->SetParameterName("fadefactor", omitable = false);
fpCommandFade->SetRange("fadefactor>=0.&&fadefactor<=1.");
fpCommandFade->SetDefaultValue(0.);
@@ -284,9 +289,11 @@ G4OpenGLViewerMessenger::G4OpenGLViewerMessenger()
fpCommandStartTime =
new G4UIcommand("/vis/ogl/set/startTime", this);
fpCommandStartTime->SetGuidance("Set start and range of track time.");
fpCommandStartTime->SetGuidance
("DEPRECATED. Use /vis/viewer/set/timeWindow/startTime."
"\n Set start and range of time window.");
parameter = new G4UIparameter ("start-time", 'd', omitable = false);
parameter->SetDefaultValue(-DBL_MAX);
parameter->SetDefaultValue(-G4VisAttributes::fVeryLongTime);
fpCommandStartTime->SetParameter(parameter);
parameter = new G4UIparameter ("start-time-unit", 's', omitable = false);
parameter->SetDefaultValue("ns");
@@ -500,13 +507,16 @@ void G4OpenGLViewerMessenger::SetNewValue
std::istringstream iss(newValue);
iss >> display >> screenX >> screenY
>> screenSize >> red >> green >> blue;
pOGLSViewer->fDisplayHeadTime = command->ConvertToBool(display);
pOGLSViewer->fDisplayHeadTimeX = screenX;
pOGLSViewer->fDisplayHeadTimeY = screenY;
pOGLSViewer->fDisplayHeadTimeSize = screenSize;
pOGLSViewer->fDisplayHeadTimeRed = red;
pOGLSViewer->fDisplayHeadTimeGreen = green;
pOGLSViewer->fDisplayHeadTimeBlue = blue;
pOGLSViewer->fVP.SetDisplayHeadTime(command->ConvertToBool(display));
pOGLSViewer->fVP.SetDisplayHeadTimeX(screenX);
pOGLSViewer->fVP.SetDisplayHeadTimeY(screenY);
pOGLSViewer->fVP.SetDisplayHeadTimeSize(screenSize);
pOGLSViewer->fVP.SetDisplayHeadTimeRed(red);
pOGLSViewer->fVP.SetDisplayHeadTimeGreen(green);
pOGLSViewer->fVP.SetDisplayHeadTimeBlue(blue);
G4cout
<< "DEPRECATED. Use /vis/viewer/set/timeWindow/displayHeadTime."
<< G4endl;
return;
}
@@ -519,18 +529,21 @@ void G4OpenGLViewerMessenger::SetNewValue
>> originX >> originY >> originZ >> unitS
>> originT >> unitT
>> red >> green >> blue;
pOGLSViewer->fDisplayLightFront = command->ConvertToBool(display);
pOGLSViewer->fDisplayLightFrontX =
command->ConvertToDimensionedDouble(G4String(originX + ' ' + unitS));
pOGLSViewer->fDisplayLightFrontY =
command->ConvertToDimensionedDouble(G4String(originY + ' ' + unitS));
pOGLSViewer->fDisplayLightFrontZ =
command->ConvertToDimensionedDouble(G4String(originZ + ' ' + unitS));
pOGLSViewer->fDisplayLightFrontT =
command->ConvertToDimensionedDouble(G4String(originT + ' ' + unitT));
pOGLSViewer->fDisplayLightFrontRed = red;
pOGLSViewer->fDisplayLightFrontGreen = green;
pOGLSViewer->fDisplayLightFrontBlue = blue;
pOGLSViewer->fVP.SetDisplayLightFront(command->ConvertToBool(display));
pOGLSViewer->fVP.SetDisplayLightFrontX
(command->ConvertToDimensionedDouble(G4String(originX + ' ' + unitS)));
pOGLSViewer->fVP.SetDisplayLightFrontY
(command->ConvertToDimensionedDouble(G4String(originY + ' ' + unitS)));
pOGLSViewer->fVP.SetDisplayLightFrontZ
(command->ConvertToDimensionedDouble(G4String(originZ + ' ' + unitS)));
pOGLSViewer->fVP.SetDisplayLightFrontT
(command->ConvertToDimensionedDouble(G4String(originT + ' ' + unitT)));
pOGLSViewer->fVP.SetDisplayLightFrontRed(red);
pOGLSViewer->fVP.SetDisplayLightFrontGreen(green);
pOGLSViewer->fVP.SetDisplayLightFrontBlue(blue);
G4cout
<< "DEPRECATED. Use /vis/viewer/set/timeWindow/displayLightFront."
<< G4endl;
return;
}
@@ -541,23 +554,31 @@ void G4OpenGLViewerMessenger::SetNewValue
std::istringstream iss(newValue);
iss >> end_time_string >> end_time_unit
>> time_range_string >> time_range_unit;
pOGLSViewer->fEndTime = command->ConvertToDimensionedDouble
(G4String(end_time_string + ' ' + end_time_unit));
pOGLSViewer->fVP.SetEndTime
(command->ConvertToDimensionedDouble
(G4String(end_time_string + ' ' + end_time_unit)));
G4double timeRange = command->ConvertToDimensionedDouble
(G4String(time_range_string + ' ' + time_range_unit));
if (timeRange > 0.) {
pOGLSViewer->fStartTime = pOGLSViewer->fEndTime - timeRange;
pOGLSViewer->fVP.SetStartTime
(pOGLSViewer->fVP.GetEndTime() - timeRange);
}
if (pOGLSViewer->fVP.IsAutoRefresh())
G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
G4cout
<< "DEPRECATED. Use /vis/viewer/set/timeWindow/endTime."
<< G4endl;
return;
}
if (command == fpCommandFade)
{
pOGLSViewer->fFadeFactor = command->ConvertToDouble(newValue);
pOGLSViewer->fVP.SetFadeFactor(command->ConvertToDouble(newValue));
if (pOGLSViewer->fVP.IsAutoRefresh())
G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
G4cout
<< "DEPRECATED. Use /vis/viewer/set/timeWindow/fadeFactor."
<< G4endl;
return;
}
@@ -568,15 +589,20 @@ void G4OpenGLViewerMessenger::SetNewValue
std::istringstream iss(newValue);
iss >> start_time_string >> start_time_unit
>> time_range_string >> time_range_unit;
pOGLSViewer->fStartTime = command->ConvertToDimensionedDouble
(G4String(start_time_string + ' ' + start_time_unit));
pOGLSViewer->fVP.SetStartTime
(command->ConvertToDimensionedDouble
(G4String(start_time_string + ' ' + start_time_unit)));
G4double timeRange = command->ConvertToDimensionedDouble
(G4String(time_range_string + ' ' + time_range_unit));
if (timeRange > 0.) {
pOGLSViewer->fEndTime = pOGLSViewer->fStartTime + timeRange;
pOGLSViewer->fVP.SetEndTime
(pOGLSViewer->fVP.GetStartTime() + timeRange);
}
if (pOGLSViewer->fVP.IsAutoRefresh())
G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/refresh");
G4cout
<< "DEPRECATED. Use /vis/viewer/set/timeWindow/startTime."
<< G4endl;
return;
}