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

Import Geant4 10.6.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2019-12-06 15:12:28 +01:00
parent b2a62ae692
commit 5baee230e9
2997 changed files with 141580 additions and 98673 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/visualization/management/src/G4VGraphicsSystem.cc
+1 -1
View File
@@ -94,7 +94,7 @@ std::ostream& operator << (std::ostream& os, const G4VGraphicsSystem& gs)
os << "threeD: Passive 3D (with stored structures)";
break;
case G4VGraphicsSystem::threeDInteractive:
os << "threeDInteractive: 3D with \"pick\" functionality.";
os << "threeDInteractive: 3D with mouse control and \"pick\" functionality.";
break;
case G4VGraphicsSystem::virtualReality:
os << "virtualReality";
source/visualization/management/src/G4VSceneHandler.cc
+19 -9
View File
@@ -75,6 +75,7 @@
#include "G4VHit.hh"
#include "G4VDigi.hh"
#include "G4ScoringManager.hh"
#include "G4VScoringMesh.hh"
#include "G4DefaultLinearColorMap.hh"
#include "Randomize.hh"
#include "G4StateManager.hh"
@@ -308,6 +309,10 @@ void G4VSceneHandler::AddSolid (const G4Polyhedra& polyhedra) {
AddSolidT (polyhedra);
}
void G4VSceneHandler::AddSolid (const G4TessellatedSolid& tess) {
AddSolidT (tess);
}
void G4VSceneHandler::AddSolid (const G4VSolid& solid) {
AddSolidT (solid);
}
@@ -335,6 +340,7 @@ void G4VSceneHandler::AddCompound (const G4VDigi& digi) {
}
void G4VSceneHandler::AddCompound (const G4THitsMap<G4double>& hits) {
using MeshScoreMap = G4VScoringMesh::MeshScoreMap;
//G4cout << "AddCompound: hits: " << &hits << G4endl;
G4bool scoreMapHits = false;
G4ScoringManager* scoringManager = G4ScoringManager::GetScoringManagerIfExist();
@@ -377,6 +383,7 @@ void G4VSceneHandler::AddCompound (const G4THitsMap<G4double>& hits) {
}
void G4VSceneHandler::AddCompound (const G4THitsMap<G4StatDouble>& hits) {
using MeshScoreMap = G4VScoringMesh::MeshScoreMap;
//G4cout << "AddCompound: hits: " << &hits << G4endl;
G4bool scoreMapHits = false;
G4ScoringManager* scoringManager = G4ScoringManager::GetScoringManagerIfExist();
@@ -1041,7 +1048,8 @@ G4ViewParameters::DrawingStyle G4VSceneHandler::GetDrawingStyle
// it can be overriddden by the ForceDrawingStyle flag in the vis
// attributes.
const G4ViewParameters& vp = fpViewer->GetViewParameters();
G4ViewParameters::DrawingStyle style = vp.GetDrawingStyle();
const G4ViewParameters::DrawingStyle viewerStyle = vp.GetDrawingStyle();
G4ViewParameters::DrawingStyle resultantStyle = viewerStyle;
if (pVisAttribs -> IsForceDrawingStyle ()) {
G4VisAttributes::ForcedDrawingStyle forcedStyle =
pVisAttribs -> GetForcedDrawingStyle ();
@@ -1049,15 +1057,15 @@ G4ViewParameters::DrawingStyle G4VSceneHandler::GetDrawingStyle
// has been requested we wish to preserve this sometimes.
switch (forcedStyle) {
case (G4VisAttributes::solid):
switch (style) {
switch (viewerStyle) {
case (G4ViewParameters::hlr):
style = G4ViewParameters::hlhsr;
resultantStyle = G4ViewParameters::hlhsr;
break;
case (G4ViewParameters::wireframe):
style = G4ViewParameters::hsr;
resultantStyle = G4ViewParameters::hsr;
break;
case (G4ViewParameters::cloud):
style = G4ViewParameters::hsr;
resultantStyle = G4ViewParameters::hsr;
break;
case (G4ViewParameters::hlhsr):
case (G4ViewParameters::hsr):
@@ -1065,7 +1073,7 @@ G4ViewParameters::DrawingStyle G4VSceneHandler::GetDrawingStyle
}
break;
case (G4VisAttributes::cloud):
style = G4ViewParameters::cloud;
resultantStyle = G4ViewParameters::cloud;
break;
case (G4VisAttributes::wireframe):
default:
@@ -1073,11 +1081,11 @@ G4ViewParameters::DrawingStyle G4VSceneHandler::GetDrawingStyle
// main uses is in displaying the consituent solids of a Boolean
// solid and their surfaces overlap with the resulting Booean
// solid, making a mess if hlr is specified.
style = G4ViewParameters::wireframe;
resultantStyle = G4ViewParameters::wireframe;
break;
}
}
return style;
return resultantStyle;
}
G4int G4VSceneHandler::GetNumberOfCloudPoints
@@ -1086,7 +1094,9 @@ G4int G4VSceneHandler::GetNumberOfCloudPoints
// has forced through the vis attributes, thereby over-riding the
// current view parameter.
G4int numberOfCloudPoints = fpViewer->GetViewParameters().GetNumberOfCloudPoints();
if (pVisAttribs -> GetForcedNumberOfCloudPoints() > 0) {
if (pVisAttribs -> IsForceDrawingStyle() &&
pVisAttribs -> GetForcedDrawingStyle() == G4VisAttributes::cloud &&
pVisAttribs -> GetForcedNumberOfCloudPoints() > 0) {
numberOfCloudPoints = pVisAttribs -> GetForcedNumberOfCloudPoints();
}
return numberOfCloudPoints;
source/visualization/management/src/G4ViewParameters.cc
+43 -29
View File
@@ -29,8 +29,6 @@
// John Allison 19th July 1996
// View parameters and options.
#include <sstream>
#include "G4ViewParameters.hh"
#include "G4VisManager.hh"
@@ -39,6 +37,9 @@
#include "G4SystemOfUnits.hh"
#include "G4Polyhedron.hh"
#include <sstream>
#include <cmath>
G4ViewParameters::G4ViewParameters ():
fDrawingStyle (wireframe),
fNumberOfCloudPoints(10000),
@@ -1455,42 +1456,55 @@ G4ViewParameters* G4ViewParameters::CatmullRomCubicSplineInterpolation
// Catmull-Rom cubic spline interpolation
#define INTERPOLATE(param) \
/* This works out the interpolated param in i'th interval */ \
/* Assumes n >= 1 */ \
if (i == 0) { \
/* First interval */ \
mi = v[1].param - v[0].param; \
/* If there is only one interval, make start and end slopes equal */ \
/* (This results in a linear interpolation) */ \
if (n == 1) mi1 = mi; \
/* else the end slope of the interval takes account of the next waypoint along */ \
else mi1 = 0.5 * (v[2].param - v[0].param); \
} else if (i >= n - 1) { \
/* Similarly for last interval */ \
mi1 = v[i+1].param - v[i].param; \
/* If there is only one interval, make start and end slopes equal */ \
if (n == 1) mi = mi1; \
/* else the start slope of the interval takes account of the previous waypoint */ \
else mi = 0.5 * (v[i+1].param - v[i-1].param); \
} else { \
/* Full Catmull-Rom slopes use previous AND next waypoints */ \
mi = 0.5 * (v[i+1].param - v[i-1].param); \
mi1 = 0.5 * (v[i+2].param - v[i ].param); \
} \
real = h00 * v[i].param + h10 * mi + h01 * v[i+1].param + h11 * mi1;
/* This works out the interpolated param in i'th interval */ \
/* Assumes n >= 1 */ \
if (i == 0) { \
/* First interval */ \
mi = v[1].param - v[0].param; \
/* If there is only one interval, make start and end slopes equal */ \
/* (This results in a linear interpolation) */ \
if (n == 1) mi1 = mi; \
/* else the end slope of the interval takes account of the next waypoint along */ \
else mi1 = 0.5 * (v[2].param - v[0].param); \
} else if (i >= n - 1) { \
/* Similarly for last interval */ \
mi1 = v[i+1].param - v[i].param; \
/* If there is only one interval, make start and end slopes equal */ \
if (n == 1) mi = mi1; \
/* else the start slope of the interval takes account of the previous waypoint */ \
else mi = 0.5 * (v[i+1].param - v[i-1].param); \
} else { \
/* Full Catmull-Rom slopes use previous AND next waypoints */ \
mi = 0.5 * (v[i+1].param - v[i-1].param); \
mi1 = 0.5 * (v[i+2].param - v[i ].param); \
} \
real = h00 * v[i].param + h10 * mi + h01 * v[i+1].param + h11 * mi1;
#define INTERPOLATELOG(param) \
if (i == 0) { \
mi = std::log(v[1].param) - std::log(v[0].param); \
if (n == 1) mi1 = mi; \
else mi1 = 0.5 * (std::log(v[2].param) - std::log(v[0].param)); \
} else if (i >= n - 1) { \
mi1 = std::log(v[i+1].param) - std::log(v[i].param); \
if (n == 1) mi = mi1; \
else mi = 0.5 * (std::log(v[i+1].param) - std::log(v[i-1].param)); \
} else { \
mi = 0.5 * (std::log(v[i+1].param) - std::log(v[i-1].param)); \
mi1 = 0.5 * (std::log(v[i+2].param) - std::log(v[i ].param)); \
} \
real = std::exp(h00 * std::log(v[i].param) + h10 * mi + h01 * std::log(v[i+1].param) + h11 * mi1);
// Real parameters
INTERPOLATE(fVisibleDensity);
if (real < 0.) real = 0.;
holdingValues.fVisibleDensity = real;
INTERPOLATE(fExplodeFactor);
if (real < 0.) real = 0.;
INTERPOLATELOG(fExplodeFactor);
holdingValues.fExplodeFactor = real;
INTERPOLATE(fFieldHalfAngle);
if (real < 0.) real = 0.;
holdingValues.fFieldHalfAngle = real;
INTERPOLATE(fZoomFactor);
if (real < 0.) real = 0.;
INTERPOLATELOG(fZoomFactor);
holdingValues.fZoomFactor = real;
INTERPOLATE(fDolly);
holdingValues.fDolly = real;
source/visualization/management/src/G4VisCommands.cc
+7 -5
View File
@@ -275,8 +275,7 @@ G4String G4VisCommandReviewKeptEvents::GetCurrentValue (G4UIcommand*)
void G4VisCommandReviewKeptEvents::SetNewValue (G4UIcommand*, G4String newValue)
{
static bool reviewing = false;
if (reviewing) {
if (fpVisManager->GetReviewingKeptEvents()) {
G4cout <<
"\"/vis/reviewKeptEvents\" not allowed within an already started review."
"\n No action taken."
@@ -333,9 +332,12 @@ void G4VisCommandReviewKeptEvents::SetNewValue (G4UIcommand*, G4String newValue)
G4VVisManager* keepConcreteInstance = fpVisManager->GetConcreteInstance();
fpVisManager->Enable();
// Start on clean view
UImanager->ApplyCommand("/vis/viewer/rebuild");
// Event by event refreshing...
reviewing = true;
fpVisManager->SetReviewingKeptEvents(true);
G4bool currentRefreshAtEndOfEvent = pScene->GetRefreshAtEndOfEvent();
pScene->SetRefreshAtEndOfEvent(true);
if (macroFileName.empty()) {
@@ -400,7 +402,7 @@ void G4VisCommandReviewKeptEvents::SetNewValue (G4UIcommand*, G4String newValue)
}
}
pScene->SetRefreshAtEndOfEvent(currentRefreshAtEndOfEvent);
reviewing = false;
fpVisManager->SetReviewingKeptEvents(false);
if (keepConcreteInstance) fpVisManager->Enable();
else fpVisManager->Disable();
source/visualization/management/src/G4VisCommandsCompound.cc
+17 -3
View File
@@ -84,18 +84,32 @@ void G4VisCommandDrawTree::SetNewValue(G4UIcommand*, G4String newValue) {
G4Scene* keepScene = fpVisManager->GetCurrentScene();
G4VSceneHandler* keepSceneHandler = fpVisManager->GetCurrentSceneHandler();
G4VViewer* keepViewer = fpVisManager->GetCurrentViewer();
G4VisManager::Verbosity keepVisVerbosity = fpVisManager->GetVerbosity();
G4UImanager* UImanager = G4UImanager::GetUIpointer();
G4int keepVerbose = UImanager->GetVerboseLevel();
G4int keepUIVerbose = UImanager->GetVerboseLevel();
G4int newVerbose(0);
if (keepVerbose >= 2 ||
if (keepUIVerbose >= 2 ||
fpVisManager->GetVerbosity() >= G4VisManager::confirmations)
newVerbose = 2;
UImanager->SetVerboseLevel(newVerbose);
G4bool keepAbleness = fpVisManager->GetConcreteInstance()? true: false;
UImanager->ApplyCommand(G4String("/vis/open " + system));
if (fErrorCode == 0) {
if (!keepAbleness) { // Enable temporarily
fpVisManager->SetVerboseLevel("Quiet");
UImanager->ApplyCommand("/vis/enable");
fpVisManager->SetVerboseLevel(keepVisVerbosity);
}
UImanager->ApplyCommand(G4String("/vis/drawVolume " + pvname));
UImanager->ApplyCommand("/vis/viewer/flush");
if (!keepAbleness) { // Disable again
fpVisManager->SetVerboseLevel("Quiet");
UImanager->ApplyCommand("/vis/disable");
fpVisManager->SetVerboseLevel(keepVisVerbosity);
}
if (keepViewer) {
if (fpVisManager->GetVerbosity() >= G4VisManager::warnings) {
G4cout << "Reverting to " << keepViewer->GetName() << G4endl;
@@ -106,7 +120,7 @@ void G4VisCommandDrawTree::SetNewValue(G4UIcommand*, G4String newValue) {
fpVisManager->SetCurrentViewer(keepViewer);
}
}
UImanager->SetVerboseLevel(keepVerbose);
UImanager->SetVerboseLevel(keepUIVerbose);
}
////////////// /vis/drawView ///////////////////////////////////////
source/visualization/management/src/G4VisCommandsSceneAdd.cc
+76 -79
View File
@@ -247,7 +247,7 @@ G4VisCommandSceneAddArrow2D::Arrow2D::Arrow2D
}
void G4VisCommandSceneAddArrow2D::Arrow2D::operator()
(G4VGraphicsScene& sceneHandler, const G4Transform3D&)
(G4VGraphicsScene& sceneHandler, const G4Transform3D&, const G4ModelingParameters*)
{
sceneHandler.BeginPrimitives2D();
sceneHandler.AddPrimitive(fShaftPolyline);
@@ -444,7 +444,7 @@ void G4VisCommandSceneAddDate::SetNewValue (G4UIcommand*, G4String newValue)
new G4CallbackModel<G4VisCommandSceneAddDate::Date>(date);
model->SetType("Date");
model->SetGlobalTag("Date");
model->SetGlobalDescription("Date");
model->SetGlobalDescription("Date: " + newValue);
const G4String& currentSceneName = pScene -> GetName ();
G4bool successful = pScene -> AddRunDurationModel (model, warn);
if (successful) {
@@ -460,7 +460,7 @@ void G4VisCommandSceneAddDate::SetNewValue (G4UIcommand*, G4String newValue)
}
void G4VisCommandSceneAddDate::Date::operator()
(G4VGraphicsScene& sceneHandler, const G4Transform3D&)
(G4VGraphicsScene& sceneHandler, const G4Transform3D&, const G4ModelingParameters*)
{
G4String time;
if (fDate == "-") {
@@ -681,19 +681,32 @@ void G4VisCommandSceneAddEventID::SetNewValue (G4UIcommand*, G4String newValue)
else if (layoutString(0) == 'c') layout = G4Text::centre;
else if (layoutString(0) == 'r') layout = G4Text::right;
EventID* eventID = new EventID(fpVisManager, size, x, y, layout);
G4VModel* model =
new G4CallbackModel<G4VisCommandSceneAddEventID::EventID>(eventID);
model->SetType("EventID");
model->SetGlobalTag("EventID");
model->SetGlobalDescription("EventID");
const G4String& currentSceneName = pScene -> GetName ();
G4bool successful = pScene -> AddEndOfEventModel (model, warn);
if (successful) {
// For End of Event (only for reviewing kept events one by one)
EventID* eoeEventID
= new EventID(forEndOfEvent, fpVisManager, size, x, y, layout);
G4VModel* eoeModel =
new G4CallbackModel<G4VisCommandSceneAddEventID::EventID>(eoeEventID);
eoeModel->SetType("EoEEventID");
eoeModel->SetGlobalTag("EoEEventID");
eoeModel->SetGlobalDescription("EoEEventID: " + newValue);
G4bool successfulEoE = pScene -> AddEndOfEventModel (eoeModel, warn);
// For End of Run
EventID* eorEventID
= new EventID(forEndOfRun, fpVisManager, size, x, y, layout);
G4VModel* eorModel =
new G4CallbackModel<G4VisCommandSceneAddEventID::EventID>(eorEventID);
eorModel->SetType("EoREventID");
eorModel->SetGlobalTag("EoREventID");
eorModel->SetGlobalDescription("EoREventID: " + newValue);
G4bool successfulEoR = pScene -> AddEndOfRunModel (eorModel, warn);
if (successfulEoE && successfulEoR) {
if (verbosity >= G4VisManager::confirmations) {
const G4String& currentSceneName = pScene -> GetName ();
G4cout << "EventID has been added to scene \""
<< currentSceneName << "\"."
<< G4endl;
<< currentSceneName << "\"."
<< G4endl;
}
}
else G4VisCommandsSceneAddUnsuccessful(verbosity);
@@ -702,75 +715,57 @@ void G4VisCommandSceneAddEventID::SetNewValue (G4UIcommand*, G4String newValue)
}
void G4VisCommandSceneAddEventID::EventID::operator()
(G4VGraphicsScene& sceneHandler, const G4Transform3D&)
(G4VGraphicsScene& sceneHandler, const G4Transform3D&, const G4ModelingParameters* mp)
{
const G4Run* currentRun = 0;
G4RunManager* runManager = G4RunManager::GetRunManager();
#ifdef G4MULTITHREADED
if (G4Threading::IsMultithreadedApplication()) {
runManager = G4MTRunManager::GetMasterRunManager();
}
#endif
if (runManager) currentRun = runManager->GetCurrentRun();
if (!runManager) return;
G4VModel* model = fpVisManager->GetCurrentSceneHandler()->GetModel();
const G4ModelingParameters* mp = 0;
const G4Event* currentEvent = 0;
if (model) {
mp = model->GetModelingParameters();
currentEvent = mp->GetEvent();
} else {
G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
if (verbosity >= G4VisManager::errors) {
G4cerr << "ERROR: No model defined for this SceneHandler : "
<< fpVisManager->GetCurrentSceneHandler()->GetName()
<< G4endl;
const G4Run* currentRun = runManager->GetCurrentRun();
if (!currentRun) return;
const G4int currentRunID = currentRun->GetRunID();
std::ostringstream oss;
switch (fForWhat) {
case forEndOfEvent:
{
// Only use if reviewing kept events
if (!fpVisManager->GetReviewingKeptEvents()) return;
const G4Event* currentEvent = mp->GetEvent();
if (!currentEvent) return;
G4int eventID = currentEvent->GetEventID();
oss << "Run " << currentRunID << " Event " << eventID;
break;
}
}
if (currentRun && currentEvent) {
G4int runID = currentRun->GetRunID();
G4int eventID = currentEvent->GetEventID();
std::ostringstream oss;
if (fpVisManager->GetCurrentScene()->GetRefreshAtEndOfEvent()) {
oss << "Run " << runID << " Event " << eventID;
} else {
G4int nEvents = 0;
#ifdef G4MULTITHREADED
if (G4Threading::G4GetThreadId() != G4Threading::MASTER_ID) {
// Vis sub-thread - run in progress
#else
G4StateManager* stateManager = G4StateManager::GetStateManager();
G4ApplicationState state = stateManager->GetCurrentState();
if (state == G4State_EventProc) {
// Run in progress
#endif
nEvents = currentRun->GetNumberOfEventToBeProcessed();
} else {
// Rebuilding from kept events
const std::vector<const G4Event*>* events =
currentRun->GetEventVector();
if (events) nEvents = events->size();
}
#ifndef G4MULTITHREADED
// In sequential mode we can recognise the last event and avoid
// drawing the event ID. But for MT mode there is no way of
// knowing so we have to accept that the event ID will be drawn
// at each event, the same characters over and over - but hey!
if (eventID < nEvents - 1) return; // Not last event.
#endif
oss << "Run " << runID << " (" << nEvents << " event";
case forEndOfRun:
{
// Only use if NOT reviewing kept events
if (fpVisManager->GetReviewingKeptEvents()) return;
const G4int nEvents = currentRun->GetNumberOfEventToBeProcessed();
const auto* events = currentRun->GetEventVector();
size_t nKeptEvents = events? events->size(): 0;
oss << "Run " << currentRunID << " (" << nEvents << " event";
if (nEvents != 1) oss << 's';
oss << ')';
oss << ", " << nKeptEvents << " kept)";
break;
}
G4Text text(oss.str(), G4Point3D(fX, fY, 0.));
text.SetScreenSize(fSize);
text.SetLayout(fLayout);
G4VisAttributes textAtts(G4Colour(0.,1.,1));
text.SetVisAttributes(textAtts);
sceneHandler.BeginPrimitives2D();
sceneHandler.AddPrimitive(text);
sceneHandler.EndPrimitives2D();
default:
return;
}
G4Text text(oss.str(), G4Point3D(fX, fY, 0.));
text.SetScreenSize(fSize);
text.SetLayout(fLayout);
G4VisAttributes textAtts(G4Colour(0.,1.,1));
text.SetVisAttributes(textAtts);
sceneHandler.BeginPrimitives2D();
sceneHandler.AddPrimitive(text);
sceneHandler.EndPrimitives2D();
}
////////////// /vis/scene/add/extent ///////////////////////////////////////
@@ -874,7 +869,7 @@ fExtent(xmin,xmax,ymin,ymax,zmin,zmax)
{}
void G4VisCommandSceneAddExtent::Extent::operator()
(G4VGraphicsScene&, const G4Transform3D&)
(G4VGraphicsScene&, const G4Transform3D&, const G4ModelingParameters*)
{}
////////////// /vis/scene/add/frame ///////////////////////////////////////
@@ -937,7 +932,7 @@ void G4VisCommandSceneAddFrame::SetNewValue (G4UIcommand*, G4String newValue)
}
void G4VisCommandSceneAddFrame::Frame::operator()
(G4VGraphicsScene& sceneHandler, const G4Transform3D&)
(G4VGraphicsScene& sceneHandler, const G4Transform3D&, const G4ModelingParameters*)
{
G4Polyline frame;
frame.push_back(G4Point3D( fSize, fSize, 0.));
@@ -1159,7 +1154,7 @@ G4VisCommandSceneAddLine::Line::Line
}
void G4VisCommandSceneAddLine::Line::operator()
(G4VGraphicsScene& sceneHandler, const G4Transform3D&)
(G4VGraphicsScene& sceneHandler, const G4Transform3D&, const G4ModelingParameters*)
{
sceneHandler.BeginPrimitives();
sceneHandler.AddPrimitive(fPolyline);
@@ -1244,7 +1239,7 @@ G4VisCommandSceneAddLine2D::Line2D::Line2D
}
void G4VisCommandSceneAddLine2D::Line2D::operator()
(G4VGraphicsScene& sceneHandler, const G4Transform3D&)
(G4VGraphicsScene& sceneHandler, const G4Transform3D&, const G4ModelingParameters*)
{
sceneHandler.BeginPrimitives2D();
sceneHandler.AddPrimitive(fPolyline);
@@ -1814,7 +1809,7 @@ G4VisCommandSceneAddLogo::G4Logo::~G4Logo() {
}
void G4VisCommandSceneAddLogo::G4Logo::operator()
(G4VGraphicsScene& sceneHandler, const G4Transform3D& transform) {
(G4VGraphicsScene& sceneHandler, const G4Transform3D& transform, const G4ModelingParameters*) {
sceneHandler.BeginPrimitives(transform);
sceneHandler.AddPrimitive(*fpG);
sceneHandler.AddPrimitive(*fp4);
@@ -1898,7 +1893,7 @@ void G4VisCommandSceneAddLogo2D::SetNewValue (G4UIcommand*, G4String newValue)
}
void G4VisCommandSceneAddLogo2D::Logo2D::operator()
(G4VGraphicsScene& sceneHandler, const G4Transform3D&)
(G4VGraphicsScene& sceneHandler, const G4Transform3D&, const G4ModelingParameters*)
{
G4Text text("Geant4", G4Point3D(fX, fY, 0.));
text.SetScreenSize(fSize);
@@ -2612,7 +2607,7 @@ G4VisCommandSceneAddText2D::G4Text2D::G4Text2D(const G4Text& text):
{}
void G4VisCommandSceneAddText2D::G4Text2D::operator()
(G4VGraphicsScene& sceneHandler, const G4Transform3D& transform) {
(G4VGraphicsScene& sceneHandler, const G4Transform3D& transform, const G4ModelingParameters*) {
sceneHandler.BeginPrimitives2D(transform);
sceneHandler.AddPrimitive(fText);
sceneHandler.EndPrimitives2D();
@@ -2858,7 +2853,9 @@ void G4VisCommandSceneAddUserAction::AddVisAction
if (i != visExtentMap.end()) extent = i->second;
if (warn) {
if (extent.GetExtentRadius() <= 0.) {
G4cout << "WARNING: User Vis Action extent is null." << G4endl;
G4cout
<< "WARNING: User Vis Action \"" << name << "\" extent is null."
<< G4endl;
}
}
source/visualization/management/src/G4VisCommandsSet.cc
+4 -1
View File
@@ -522,7 +522,10 @@ G4VisCommandSetVolumeForField::G4VisCommandSetVolumeForField ()
G4UIparameter* parameter;
fpCommand = new G4UIcommand("/vis/set/volumeForField", this);
fpCommand->SetGuidance
("Sets a volume and optional copy number \"/vis/scene/add/*Field\" commands.");
("Sets a volume for \"/vis/scene/add/*Field\" commands.");
fpCommand->SetGuidance
("Takes a volume name or a /regular expression/ -- see guidance for"
"\n\"/vis/drawVolume\"");
parameter = new G4UIparameter ("physical-volume-name", 's', omitable = true);
parameter -> SetDefaultValue ("none");
fpCommand -> SetParameter (parameter);
source/visualization/management/src/G4VisCommandsViewer.cc
+4 -3
View File
@@ -1363,7 +1363,7 @@ void G4VisCommandViewerInterpolate::SetNewValue (G4UIcommand*, G4String newValue
#else // WIN32 (popen is not available in Windows)
std::experimental::filesystem::v1::path filePattern(pattern);
std::filesystem::path filePattern = pattern.c_str();
// Default pattern : *.g4view
// Translated to a regexp : ^.*\\.g4view
@@ -1400,10 +1400,11 @@ void G4VisCommandViewerInterpolate::SetNewValue (G4UIcommand*, G4String newValue
// Build view vector of way points
// Add "./" for empty paths
G4String parentPath(filePattern.parent_path().string().length() ? filePattern.parent_path().string() : std::string("./"));
std::filesystem::path parentPathPattern = parentPath.c_str();
// Iterate through files in directory and apply regex match to filter appropriate files
std::regex result_pattern_regex (result_pattern, std::regex_constants::basic | std::regex_constants::icase);
for (auto iter = std::experimental::filesystem::v1::directory_iterator(parentPath);
iter != std::experimental::filesystem::v1::directory_iterator() && safetyCount++ < safety;
for (auto iter = std::filesystem::directory_iterator(parentPathPattern);
iter != std::filesystem::directory_iterator() && safetyCount++ < safety;
++iter)
{
const auto& file = iter->path();
source/visualization/management/src/G4VisCommandsViewerDefault.cc
+4 -6
View File
@@ -64,8 +64,8 @@ void G4VisCommandViewerDefaultHiddenEdge::SetNewValue(G4UIcommand*, G4String new
G4ViewParameters vp = fpVisManager->GetDefaultViewParameters();
G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle();
if (G4UIcommand::ConvertToBool(newValue)) {
switch (existingStyle) { // true
if (G4UIcommand::ConvertToBool(newValue)) { // true
switch (existingStyle) {
case G4ViewParameters::wireframe:
vp.SetDrawingStyle(G4ViewParameters::hlr);
break;
@@ -77,12 +77,11 @@ void G4VisCommandViewerDefaultHiddenEdge::SetNewValue(G4UIcommand*, G4String new
case G4ViewParameters::hlhsr:
break;
case G4ViewParameters::cloud:
G4cout << "No effect in cloud style" << G4endl;
break;
}
}
else {
switch (existingStyle) { // false
else { // false
switch (existingStyle) {
case G4ViewParameters::wireframe:
break;
case G4ViewParameters::hlr:
@@ -94,7 +93,6 @@ void G4VisCommandViewerDefaultHiddenEdge::SetNewValue(G4UIcommand*, G4String new
vp.SetDrawingStyle(G4ViewParameters::hsr);
break;
case G4ViewParameters::cloud:
G4cout << "No effect in cloud style" << G4endl;
break;
}
}
source/visualization/management/src/G4VisCommandsViewerSet.cc
+4 -8
View File
@@ -889,8 +889,8 @@ void G4VisCommandsViewerSet::SetNewValue
else if (command == fpCommandEdge) {
G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle();
if (G4UIcommand::ConvertToBool(newValue)) {
switch (existingStyle) { // true
if (G4UIcommand::ConvertToBool(newValue)) { // true
switch (existingStyle) {
case G4ViewParameters::wireframe:
break;
case G4ViewParameters::hlr:
@@ -901,7 +901,6 @@ void G4VisCommandsViewerSet::SetNewValue
case G4ViewParameters::hlhsr:
break;
case G4ViewParameters::cloud:
G4cout << "No effect in cloud style" << G4endl;
break;
}
}
@@ -917,7 +916,6 @@ void G4VisCommandsViewerSet::SetNewValue
vp.SetDrawingStyle(G4ViewParameters::hsr);
break;
case G4ViewParameters::cloud:
G4cout << "No effect in cloud style" << G4endl;
break;
}
}
@@ -978,7 +976,6 @@ void G4VisCommandsViewerSet::SetNewValue
case G4ViewParameters::hlhsr:
break;
case G4ViewParameters::cloud:
G4cout << "No effect in cloud style" << G4endl;
break;
}
}
@@ -995,7 +992,6 @@ void G4VisCommandsViewerSet::SetNewValue
vp.SetDrawingStyle(G4ViewParameters::hsr);
break;
case G4ViewParameters::cloud:
G4cout << "No effect in cloud style" << G4endl;
break;
}
}
@@ -1220,7 +1216,7 @@ void G4VisCommandsViewerSet::SetNewValue
vp.SetDrawingStyle(G4ViewParameters::hlr);
break;
case G4ViewParameters::cloud:
vp.SetDrawingStyle(G4ViewParameters::cloud);
vp.SetDrawingStyle(G4ViewParameters::wireframe);
break;
}
}
@@ -1237,7 +1233,7 @@ void G4VisCommandsViewerSet::SetNewValue
case G4ViewParameters::hlhsr:
break;
case G4ViewParameters::cloud:
vp.SetDrawingStyle(G4ViewParameters::cloud);
vp.SetDrawingStyle(G4ViewParameters::hsr);
break;
}
}
source/visualization/management/src/G4VisManager.cc
+18 -3
View File
@@ -113,6 +113,7 @@ G4VisManager::G4VisManager (const G4String& verbosityString):
fKeptLastEvent (false),
fDrawEventOnlyIfToBeKept (false),
fpRequestedEvent (0),
fReviewingKeptEvents (false),
fAbortReviewKeptEvents (false),
fIsDrawGroup (false),
fDrawGroupNestingDepth (0),
@@ -690,7 +691,7 @@ void G4VisManager::Disable() {
"\n \"/tracking/storeTrajectory 0\""
"\nbut don't forget to re-enable with"
"\n \"/vis/enable\""
"\n \"/tracking/storeTrajectory " << currentTrajectoryType << "\" (for your case)."
"\n \"/tracking/storeTrajectory " << currentTrajectoryType << '\"'
<< G4endl;
}
}
@@ -1307,9 +1308,16 @@ void G4VisManager::GeometryHasChanged () {
if (fVerbosity >= warnings) {
G4cout << "WARNING: The current scene \""
<< fpScene -> GetName ()
<< "\" has no models."
<< "\" has no run duration models."
<< "\n Use \"/vis/scene/add/volume\" or create a new scene."
<< G4endl;
}
fpSceneHandler->ClearTransientStore();
fpSceneHandler->ClearStore();
fpViewer->NeedKernelVisit();
fpViewer->SetView();
fpViewer->ClearView();
fpViewer->FinishView();
}
}
@@ -1338,9 +1346,16 @@ void G4VisManager::NotifyHandlers () {
if (fVerbosity >= warnings) {
G4cout << "WARNING: The current scene \""
<< fpScene -> GetName ()
<< "\" has no models."
<< "\" has no run duration models."
<< "\n Use \"/vis/scene/add/volume\" or create a new scene."
<< G4endl;
}
fpSceneHandler->ClearTransientStore();
fpSceneHandler->ClearStore();
fpViewer->NeedKernelVisit();
fpViewer->SetView();
fpViewer->ClearView();
fpViewer->FinishView();
}
}