| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // 26 //
27 // 27 //
28 // GEANT4 Visualization Manager - John Allison 28 // GEANT4 Visualization Manager - John Allison 02/Jan/1996.
29 // Michael Kelsey 31 Jan 2019 -- Add new comm 29 // Michael Kelsey 31 Jan 2019 -- Add new command for electric field
30 30
31 #include "G4VisManager.hh" 31 #include "G4VisManager.hh"
32 32
33 #include "G4VisCommands.hh" 33 #include "G4VisCommands.hh"
34 #include "G4VisCommandsCompound.hh" 34 #include "G4VisCommandsCompound.hh"
35 #include "G4VisCommandsGeometry.hh" 35 #include "G4VisCommandsGeometry.hh"
36 #include "G4VisCommandsGeometrySet.hh" 36 #include "G4VisCommandsGeometrySet.hh"
37 #include "G4VisCommandsMultithreading.hh" 37 #include "G4VisCommandsMultithreading.hh"
38 #include "G4VisCommandsSet.hh" 38 #include "G4VisCommandsSet.hh"
39 #include "G4VisCommandsScene.hh" 39 #include "G4VisCommandsScene.hh"
40 #include "G4VisCommandsSceneAdd.hh" 40 #include "G4VisCommandsSceneAdd.hh"
41 #include "G4VisCommandsPlotter.hh" <<
42 #include "G4VisCommandsSceneHandler.hh" 41 #include "G4VisCommandsSceneHandler.hh"
43 #include "G4VisCommandsTouchable.hh" 42 #include "G4VisCommandsTouchable.hh"
44 #include "G4VisCommandsTouchableSet.hh" 43 #include "G4VisCommandsTouchableSet.hh"
45 #include "G4VisCommandsViewer.hh" 44 #include "G4VisCommandsViewer.hh"
46 #include "G4VisCommandsViewerDefault.hh" 45 #include "G4VisCommandsViewerDefault.hh"
47 #include "G4VisCommandsViewerSet.hh" 46 #include "G4VisCommandsViewerSet.hh"
48 #include "G4UImanager.hh" 47 #include "G4UImanager.hh"
49 #include "G4VisStateDependent.hh" 48 #include "G4VisStateDependent.hh"
50 #include "G4UIdirectory.hh" 49 #include "G4UIdirectory.hh"
51 #include "G4VGraphicsSystem.hh" 50 #include "G4VGraphicsSystem.hh"
52 #include "G4VSceneHandler.hh" 51 #include "G4VSceneHandler.hh"
53 #include "G4VViewer.hh" 52 #include "G4VViewer.hh"
54 #include "G4VPhysicalVolume.hh" 53 #include "G4VPhysicalVolume.hh"
55 #include "G4LogicalVolume.hh" 54 #include "G4LogicalVolume.hh"
56 #include "G4VSolid.hh" 55 #include "G4VSolid.hh"
57 #include "G4Vector3D.hh" 56 #include "G4Vector3D.hh"
58 #include "G4Point3D.hh" 57 #include "G4Point3D.hh"
59 #include "G4RotationMatrix.hh" 58 #include "G4RotationMatrix.hh"
60 #include "G4Polyline.hh" 59 #include "G4Polyline.hh"
61 #include "G4Polyhedron.hh" 60 #include "G4Polyhedron.hh"
62 #include "G4NullModel.hh" 61 #include "G4NullModel.hh"
63 #include "G4ModelingParameters.hh" 62 #include "G4ModelingParameters.hh"
64 #include "G4TransportationManager.hh" 63 #include "G4TransportationManager.hh"
65 #include "G4VisCommandModelCreate.hh" 64 #include "G4VisCommandModelCreate.hh"
66 #include "G4VisCommandsListManager.hh" 65 #include "G4VisCommandsListManager.hh"
67 #include "G4VisModelManager.hh" 66 #include "G4VisModelManager.hh"
68 #include "G4VModelFactory.hh" 67 #include "G4VModelFactory.hh"
69 #include "G4VisFilterManager.hh" 68 #include "G4VisFilterManager.hh"
70 #include "G4VTrajectoryModel.hh" 69 #include "G4VTrajectoryModel.hh"
71 #include "G4TrajectoryDrawByCharge.hh" 70 #include "G4TrajectoryDrawByCharge.hh"
72 #include "Randomize.hh" 71 #include "Randomize.hh"
73 #include "G4RunManager.hh" 72 #include "G4RunManager.hh"
74 #include "G4RunManagerFactory.hh" <<
75 #include "G4EventManager.hh" 73 #include "G4EventManager.hh"
76 #include "G4Run.hh" 74 #include "G4Run.hh"
77 #include "G4Event.hh" 75 #include "G4Event.hh"
78 #include <map> 76 #include <map>
79 #include <set> 77 #include <set>
80 #include <vector> 78 #include <vector>
81 #include <sstream> 79 #include <sstream>
82 80
>> 81 #ifdef G4MULTITHREADED
>> 82 #include "G4MTRunManager.hh"
83 #include "G4Threading.hh" 83 #include "G4Threading.hh"
84 #include "G4AutoLock.hh" 84 #include "G4AutoLock.hh"
85 #include "G4GeometryWorkspace.hh" // no_geant4 << 85 #include "G4GeometryWorkspace.hh"
86 #include "G4SolidsWorkspace.hh" 86 #include "G4SolidsWorkspace.hh"
87 #include <deque> 87 #include <deque>
88 #include <typeinfo> 88 #include <typeinfo>
>> 89 #ifdef G4VIS_USE_STD11
89 #include <chrono> 90 #include <chrono>
90 #include <thread> 91 #include <thread>
91 #include <utility> << 92 #endif
92 << 93 #endif
93 #define G4warn G4cout <<
94 <<
95 // Local threading related variables <<
96 namespace { <<
97 G4bool mtRunInProgress = false; <<
98 std::deque<const G4Event*> mtVisEventQueue; <<
99 G4Thread* mtVisSubThread = 0; <<
100 [[maybe_unused]] G4Mutex mtVisSubThreadMutex <<
101 // G4Mutex visBeginOfRunMutex = G4MUTEX_INI <<
102 // G4Mutex visBeginOfEventMutex = G4MUTEX_I <<
103 G4Mutex visEndOfEventMutex = G4MUTEX_INITIAL <<
104 // G4Mutex visEndOfRunMutex = G4MUTEX_INITI <<
105 G4bool isSubEventRunManagerType = false; <<
106 G4bool isValidViewForRun = false; <<
107 G4bool isFakeRun = false; <<
108 } <<
109 94
110 // Class statics <<
111 G4VisManager* G4VisManager::fpInstance = 0; 95 G4VisManager* G4VisManager::fpInstance = 0;
112 96
113 G4VisManager::Verbosity G4VisManager::fVerbosi 97 G4VisManager::Verbosity G4VisManager::fVerbosity = G4VisManager::warnings;
114 98
115 G4VisManager::G4VisManager (const G4String& ve << 99 G4VisManager::G4VisManager (const G4String& verbosityString):
116 : fVerbose (1) << 100 fVerbose (1),
117 , fDefaultGraphicsSystemName("OGL") / << 101 fInitialised (false),
118 , fDefaultXGeometryString ("600x600-0+0") / << 102 fpGraphicsSystem (0),
119 , fDefaultGraphicsSystemBasis ("G4VisManager i << 103 fpScene (0),
120 , fDefaultXGeometryStringBasis("G4VisManager i << 104 fpSceneHandler (0),
121 , fInitialised (false) << 105 fpViewer (0),
122 , fpGraphicsSystem (0) << 106 fpStateDependent (0),
123 , fpScene (0) << 107 fEventRefreshing (false),
124 , fpSceneHandler (0) << 108 fTransientsDrawnThisRun (false),
125 , fpViewer (0) << 109 fTransientsDrawnThisEvent (false),
126 , fpStateDependent (0) << 110 fNoOfEventsDrawnThisRun (0),
127 , fEventRefreshing (false) << 111 fNKeepRequests (0),
128 , fTransientsDrawnThisRun (false) << 112 fEventKeepingSuspended (false),
129 , fTransientsDrawnThisEvent (false) << 113 fKeptLastEvent (false),
130 , fNoOfEventsDrawnThisRun (0) << 114 fDrawEventOnlyIfToBeKept (false),
131 , fNKeepForPostProcessingRequests (0) << 115 fpRequestedEvent (0),
132 , fNKeepTheEventRequests (0) << 116 fReviewingKeptEvents (false),
133 , fEventKeepingSuspended (false) << 117 fAbortReviewKeptEvents (false),
134 , fDrawEventOnlyIfToBeKept (false) << 118 fIsDrawGroup (false),
135 , fpRequestedEvent (0) << 119 fDrawGroupNestingDepth (0),
136 , fReviewingKeptEvents (false) << 120 fIgnoreStateChanges (false)
137 , fAbortReviewKeptEvents (false) << 121 #ifdef G4MULTITHREADED
138 , fReviewingPlots (false) <<
139 , fAbortReviewPlots (false) <<
140 , fIsDrawGroup (false) <<
141 , fDrawGroupNestingDepth (0) <<
142 , fIgnoreStateChanges (false) <<
143 , fMaxEventQueueSize (100) 122 , fMaxEventQueueSize (100)
144 , fWaitOnEventQueueFull (true) 123 , fWaitOnEventQueueFull (true)
145 // All other objects use default constructors. << 124 #endif
>> 125 // All other objects use default constructors.
146 { 126 {
147 fpTrajDrawModelMgr = new G4VisModelManager<G 127 fpTrajDrawModelMgr = new G4VisModelManager<G4VTrajectoryModel>("/vis/modeling/trajectories");
148 fpTrajFilterMgr = new G4VisFilterManager<G4V 128 fpTrajFilterMgr = new G4VisFilterManager<G4VTrajectory>("/vis/filtering/trajectories");
149 fpHitFilterMgr = new G4VisFilterManager<G4VH 129 fpHitFilterMgr = new G4VisFilterManager<G4VHit>("/vis/filtering/hits");
150 fpDigiFilterMgr = new G4VisFilterManager<G4V 130 fpDigiFilterMgr = new G4VisFilterManager<G4VDigi>("/vis/filtering/digi");
151 131
152 VerbosityGuidanceStrings.push_back 132 VerbosityGuidanceStrings.push_back
153 ("Simple graded message scheme - digit or 133 ("Simple graded message scheme - digit or string (1st character defines):");
154 VerbosityGuidanceStrings.push_back 134 VerbosityGuidanceStrings.push_back
155 (" 0) quiet, // Nothing is printe 135 (" 0) quiet, // Nothing is printed.");
156 VerbosityGuidanceStrings.push_back 136 VerbosityGuidanceStrings.push_back
157 (" 1) startup, // Startup and endup 137 (" 1) startup, // Startup and endup messages are printed...");
158 VerbosityGuidanceStrings.push_back 138 VerbosityGuidanceStrings.push_back
159 (" 2) errors, // ...and errors..." 139 (" 2) errors, // ...and errors...");
160 VerbosityGuidanceStrings.push_back 140 VerbosityGuidanceStrings.push_back
161 (" 3) warnings, // ...and warnings.. 141 (" 3) warnings, // ...and warnings...");
162 VerbosityGuidanceStrings.push_back 142 VerbosityGuidanceStrings.push_back
163 (" 4) confirmations, // ...and confirming 143 (" 4) confirmations, // ...and confirming messages...");
164 VerbosityGuidanceStrings.push_back 144 VerbosityGuidanceStrings.push_back
165 (" 5) parameters, // ...and parameters 145 (" 5) parameters, // ...and parameters of scenes and views...");
166 VerbosityGuidanceStrings.push_back 146 VerbosityGuidanceStrings.push_back
167 (" 6) all // ...and everything 147 (" 6) all // ...and everything available.");
168 148
169 if (fpInstance) { 149 if (fpInstance) {
170 G4Exception 150 G4Exception
171 ("G4VisManager::G4VisManager", 151 ("G4VisManager::G4VisManager",
172 "visman0001", FatalException, 152 "visman0001", FatalException,
173 "Attempt to Construct more than one Vis 153 "Attempt to Construct more than one VisManager");
174 } 154 }
175 155
176 fpInstance = this; 156 fpInstance = this;
177 SetConcreteInstance(this); 157 SetConcreteInstance(this);
178 158
179 fpStateDependent = new G4VisStateDependent ( 159 fpStateDependent = new G4VisStateDependent (this);
180 // No need to delete this; G4StateManager do 160 // No need to delete this; G4StateManager does this.
181 161
182 fVerbosity = GetVerbosityValue(verbosityStri 162 fVerbosity = GetVerbosityValue(verbosityString);
183 if (fVerbosity >= startup) { 163 if (fVerbosity >= startup) {
184 G4cout 164 G4cout
185 << "Visualization Manager instantiating with 165 << "Visualization Manager instantiating with verbosity \""
186 << VerbosityString(fVerbosity) 166 << VerbosityString(fVerbosity)
187 << "\"..." << G4endl; 167 << "\"..." << G4endl;
188 } 168 }
189 169
190 // Note: The specific graphics systems must 170 // Note: The specific graphics systems must be instantiated in a
191 // higher level library to avoid circular de 171 // higher level library to avoid circular dependencies. Also,
192 // some specifically need additional externa 172 // some specifically need additional external libararies that the
193 // user must supply. Therefore we ask the u 173 // user must supply. Therefore we ask the user to implement
194 // RegisterGraphicsSystems() and RegisterMod 174 // RegisterGraphicsSystems() and RegisterModelFactories()
195 // in a subclass. We have to wait for the s 175 // in a subclass. We have to wait for the subclass to instantiate
196 // so RegisterGraphicsSystems() cannot be ca 176 // so RegisterGraphicsSystems() cannot be called from this
197 // constructor; it is called from Initialise 177 // constructor; it is called from Initialise(). So we ask the
198 // user: 178 // user:
199 // (a) to write a subclass and implement 179 // (a) to write a subclass and implement RegisterGraphicsSystems()
200 // and RegisterModelFactories(). See 180 // and RegisterModelFactories(). See
201 // visualization/include/G4VisExecutiv 181 // visualization/include/G4VisExecutive.hh/icc as an example.
202 // (b) instantiate the subclass. 182 // (b) instantiate the subclass.
203 // (c) invoke the Initialise() method of t 183 // (c) invoke the Initialise() method of the subclass.
204 // For example: 184 // For example:
205 // ... 185 // ...
>> 186 // #ifdef G4VIS_USE
206 // // Instantiate and initialise Visualiza 187 // // Instantiate and initialise Visualization Manager.
207 // G4VisManager* visManager = new G4VisExe 188 // G4VisManager* visManager = new G4VisExecutive;
208 // visManager -> SetVerboseLevel (Verbose) 189 // visManager -> SetVerboseLevel (Verbose);
209 // visManager -> Initialise (); 190 // visManager -> Initialise ();
>> 191 // #endif
210 // // (Don't forget to delete visManager;) 192 // // (Don't forget to delete visManager;)
211 // ... 193 // ...
212 194
213 // Make top level command directory... 195 // Make top level command directory...
214 // vis commands should *not* be broadcast to << 196 // Vis commands should *not* be broadcast to threads (2nd argument).
215 G4bool propagateToWorkers; << 197 G4UIcommand* directory = new G4UIdirectory ("/vis/",false);
216 auto directory = new G4UIdirectory ("/vis/", <<
217 directory -> SetGuidance ("Visualization com 198 directory -> SetGuidance ("Visualization commands.");
218 // Request commands in name order <<
219 directory -> Sort(); // Ordering propagates <<
220 fDirectoryList.push_back (directory); 199 fDirectoryList.push_back (directory);
221 200
222 // Instantiate *basic* top level commands so 201 // Instantiate *basic* top level commands so that they can be used
223 // immediately after instantiation of the vi 202 // immediately after instantiation of the vis manager. Other top
224 // level and lower level commands are instan 203 // level and lower level commands are instantiated later in
225 // RegisterMessengers. 204 // RegisterMessengers.
226 G4VVisCommand::SetVisManager (this); // Set 205 G4VVisCommand::SetVisManager (this); // Sets shared pointer
227 RegisterMessenger(new G4VisCommandVerbose); 206 RegisterMessenger(new G4VisCommandVerbose);
228 RegisterMessenger(new G4VisCommandInitialize 207 RegisterMessenger(new G4VisCommandInitialize);
229 } 208 }
230 209
231 G4VisManager::~G4VisManager() << 210 G4VisManager::~G4VisManager () {
232 { << 211 fpInstance = 0;
233 G4UImanager* UImanager = G4UImanager::GetUIp << 212 size_t i;
234 UImanager->SetCoutDestination(nullptr); <<
235 std::size_t i; <<
236 for (i = 0; i < fSceneList.size (); ++i) { 213 for (i = 0; i < fSceneList.size (); ++i) {
237 delete fSceneList[i]; 214 delete fSceneList[i];
238 } 215 }
239 for (i = 0; i < fAvailableSceneHandlers.size 216 for (i = 0; i < fAvailableSceneHandlers.size (); ++i) {
240 if (fAvailableSceneHandlers[i] != NULL) { 217 if (fAvailableSceneHandlers[i] != NULL) {
241 delete fAvailableSceneHandlers[i]; 218 delete fAvailableSceneHandlers[i];
242 } 219 }
243 } 220 }
244 for (i = 0; i < fAvailableGraphicsSystems.si 221 for (i = 0; i < fAvailableGraphicsSystems.size (); ++i) {
245 if (fAvailableGraphicsSystems[i]) { 222 if (fAvailableGraphicsSystems[i]) {
246 delete fAvailableGraphicsSystems[i]; 223 delete fAvailableGraphicsSystems[i];
247 } 224 }
248 } 225 }
249 if (fVerbosity >= startup) { 226 if (fVerbosity >= startup) {
250 G4cout << "Graphics systems deleted." << G 227 G4cout << "Graphics systems deleted." << G4endl;
251 G4cout << "Visualization Manager deleting. 228 G4cout << "Visualization Manager deleting..." << G4endl;
252 } 229 }
253 for (i = 0; i < fMessengerList.size (); ++i) 230 for (i = 0; i < fMessengerList.size (); ++i) {
254 delete fMessengerList[i]; 231 delete fMessengerList[i];
255 } 232 }
256 for (i = 0; i < fDirectoryList.size (); ++i) 233 for (i = 0; i < fDirectoryList.size (); ++i) {
257 delete fDirectoryList[i]; 234 delete fDirectoryList[i];
258 } 235 }
259 236
260 delete fpDigiFilterMgr; 237 delete fpDigiFilterMgr;
261 delete fpHitFilterMgr; 238 delete fpHitFilterMgr;
262 delete fpTrajFilterMgr; 239 delete fpTrajFilterMgr;
263 delete fpTrajDrawModelMgr; 240 delete fpTrajDrawModelMgr;
264 fpInstance = 0; <<
265 } 241 }
266 242
267 G4VisManager* G4VisManager::GetInstance () { 243 G4VisManager* G4VisManager::GetInstance () {
268 if (!fpInstance) { 244 if (!fpInstance) {
269 G4Exception 245 G4Exception
270 ("G4VisManager::GetInstance", 246 ("G4VisManager::GetInstance",
271 "visman0002", FatalException, "VisManag 247 "visman0002", FatalException, "VisManager not yet instantiated");
272 } 248 }
273 return fpInstance; 249 return fpInstance;
274 } 250 }
275 251
276 void G4VisManager::Initialise () { 252 void G4VisManager::Initialise () {
277 253
278 if (fInitialised && fVerbosity >= warnings) 254 if (fInitialised && fVerbosity >= warnings) {
279 G4warn << "WARNING: G4VisManager::Initiali << 255 G4cout << "WARNING: G4VisManager::Initialise: already initialised."
280 << G4endl; 256 << G4endl;
281 return; 257 return;
282 } 258 }
283 259
284 if (fVerbosity >= startup) { 260 if (fVerbosity >= startup) {
285 G4cout << "Visualization Manager initialis 261 G4cout << "Visualization Manager initialising..." << G4endl;
286 } 262 }
287 263
288 if (fVerbosity >= parameters) { 264 if (fVerbosity >= parameters) {
289 G4cout << 265 G4cout <<
290 "\nYou have instantiated your own Visual 266 "\nYou have instantiated your own Visualization Manager, inheriting"
291 "\n G4VisManager and implementing Regis 267 "\n G4VisManager and implementing RegisterGraphicsSystems(), in which"
292 "\n you should, normally, instantiate d 268 "\n you should, normally, instantiate drivers which do not need"
293 "\n external packages or libraries, and 269 "\n external packages or libraries, and, optionally, drivers under"
294 "\n control of environment variables." 270 "\n control of environment variables."
295 "\n Also you should implement RegisterM 271 "\n Also you should implement RegisterModelFactories()."
296 "\n See visualization/management/includ 272 "\n See visualization/management/include/G4VisExecutive.hh/icc, for example."
297 "\n In your main() you will have someth 273 "\n In your main() you will have something like:"
>> 274 "\n #ifdef G4VIS_USE"
298 "\n G4VisManager* visManager = new G4 275 "\n G4VisManager* visManager = new G4VisExecutive;"
299 "\n visManager -> SetVerboseLevel (Ve 276 "\n visManager -> SetVerboseLevel (Verbose);"
300 "\n visManager -> Initialize ();" 277 "\n visManager -> Initialize ();"
>> 278 "\n #endif"
301 "\n (Don't forget to delete visManager; 279 "\n (Don't forget to delete visManager;)"
302 "\n" 280 "\n"
303 << G4endl; 281 << G4endl;
304 } 282 }
305 283
306 if (fVerbosity >= startup) { 284 if (fVerbosity >= startup) {
307 G4cout << "Registering graphics systems... 285 G4cout << "Registering graphics systems..." << G4endl;
308 } 286 }
309 287
310 RegisterGraphicsSystems (); 288 RegisterGraphicsSystems ();
311 289
312 if (fVerbosity >= startup) { 290 if (fVerbosity >= startup) {
313 G4cout << 291 G4cout <<
314 "\nYou have successfully registered the 292 "\nYou have successfully registered the following graphics systems."
315 << G4endl; 293 << G4endl;
316 PrintAvailableGraphicsSystems (fVerbosity) 294 PrintAvailableGraphicsSystems (fVerbosity);
317 G4cout << G4endl; 295 G4cout << G4endl;
318 } 296 }
319 297
320 // Make command directories for commands ins 298 // Make command directories for commands instantiated in the
321 // modeling subcategory... 299 // modeling subcategory...
322 G4UIcommand* directory; 300 G4UIcommand* directory;
323 directory = new G4UIdirectory ("/vis/modelin 301 directory = new G4UIdirectory ("/vis/modeling/");
324 directory -> SetGuidance ("Modeling commands 302 directory -> SetGuidance ("Modeling commands.");
325 fDirectoryList.push_back (directory); 303 fDirectoryList.push_back (directory);
326 directory = new G4UIdirectory ("/vis/modelin 304 directory = new G4UIdirectory ("/vis/modeling/trajectories/");
327 directory -> SetGuidance ("Trajectory model 305 directory -> SetGuidance ("Trajectory model commands.");
328 fDirectoryList.push_back (directory); 306 fDirectoryList.push_back (directory);
329 directory = new G4UIdirectory ("/vis/modelin 307 directory = new G4UIdirectory ("/vis/modeling/trajectories/create/");
330 directory -> SetGuidance ("Create trajectory 308 directory -> SetGuidance ("Create trajectory models and messengers.");
331 fDirectoryList.push_back (directory); 309 fDirectoryList.push_back (directory);
332 310
333 // Filtering command directory 311 // Filtering command directory
334 directory = new G4UIdirectory ("/vis/filteri 312 directory = new G4UIdirectory ("/vis/filtering/");
335 directory -> SetGuidance ("Filtering command 313 directory -> SetGuidance ("Filtering commands.");
336 fDirectoryList.push_back (directory); 314 fDirectoryList.push_back (directory);
337 directory = new G4UIdirectory ("/vis/filteri 315 directory = new G4UIdirectory ("/vis/filtering/trajectories/");
338 directory -> SetGuidance ("Trajectory filter 316 directory -> SetGuidance ("Trajectory filtering commands.");
339 fDirectoryList.push_back (directory); 317 fDirectoryList.push_back (directory);
340 directory = new G4UIdirectory ("/vis/filteri 318 directory = new G4UIdirectory ("/vis/filtering/trajectories/create/");
341 directory -> SetGuidance ("Create trajectory 319 directory -> SetGuidance ("Create trajectory filters and messengers.");
342 fDirectoryList.push_back (directory); 320 fDirectoryList.push_back (directory);
343 directory = new G4UIdirectory ("/vis/filteri 321 directory = new G4UIdirectory ("/vis/filtering/hits/");
344 directory -> SetGuidance ("Hit filtering com 322 directory -> SetGuidance ("Hit filtering commands.");
345 fDirectoryList.push_back (directory); 323 fDirectoryList.push_back (directory);
346 directory = new G4UIdirectory ("/vis/filteri 324 directory = new G4UIdirectory ("/vis/filtering/hits/create/");
347 directory -> SetGuidance ("Create hit filter 325 directory -> SetGuidance ("Create hit filters and messengers.");
348 fDirectoryList.push_back (directory); 326 fDirectoryList.push_back (directory);
349 directory = new G4UIdirectory ("/vis/filteri 327 directory = new G4UIdirectory ("/vis/filtering/digi/");
350 directory -> SetGuidance ("Digi filtering co 328 directory -> SetGuidance ("Digi filtering commands.");
351 fDirectoryList.push_back (directory); 329 fDirectoryList.push_back (directory);
352 directory = new G4UIdirectory ("/vis/filteri 330 directory = new G4UIdirectory ("/vis/filtering/digi/create/");
353 directory -> SetGuidance ("Create digi filte 331 directory -> SetGuidance ("Create digi filters and messengers.");
354 fDirectoryList.push_back (directory); 332 fDirectoryList.push_back (directory);
355 333
356 RegisterMessengers (); 334 RegisterMessengers ();
357 335
358 if (fVerbosity >= startup) { 336 if (fVerbosity >= startup) {
359 G4cout << "Registering model factories..." 337 G4cout << "Registering model factories..." << G4endl;
360 } 338 }
361 339
362 RegisterModelFactories(); 340 RegisterModelFactories();
363 341
364 if (fVerbosity >= startup) { 342 if (fVerbosity >= startup) {
365 G4cout << 343 G4cout <<
366 "\nYou have successfully registered the 344 "\nYou have successfully registered the following model factories."
367 << G4endl; 345 << G4endl;
368 PrintAvailableModels (fVerbosity); 346 PrintAvailableModels (fVerbosity);
369 G4cout << G4endl; 347 G4cout << G4endl;
370 } 348 }
371 349
372 if (fVerbosity >= startup) { 350 if (fVerbosity >= startup) {
373 PrintAvailableUserVisActions (fVerbosity); 351 PrintAvailableUserVisActions (fVerbosity);
374 G4cout << G4endl; 352 G4cout << G4endl;
375 } 353 }
376 354
377 InitialiseG4ColourMap(); 355 InitialiseG4ColourMap();
378 356
379 if (fVerbosity >= startup) { 357 if (fVerbosity >= startup) {
380 G4cout << 358 G4cout <<
381 "Some /vis commands (optionally) take a st 359 "Some /vis commands (optionally) take a string to specify colour."
382 "\n\"/vis/list\" to see available colours. 360 "\n\"/vis/list\" to see available colours."
383 << G4endl; 361 << G4endl;
384 } 362 }
385 363
386 fInitialised = true; 364 fInitialised = true;
387 } 365 }
388 366
389 void G4VisManager::InitialiseG4ColourMap() con 367 void G4VisManager::InitialiseG4ColourMap() const
390 { 368 {
391 G4Colour::InitialiseColourMap(); // Initial 369 G4Colour::InitialiseColourMap(); // Initialises (if not already initialised)
392 370
393 // our forever 65 named colors taken long ti 371 // our forever 65 named colors taken long time ago from X11.
394 // Extracted from g4tools/include/tools/colo 372 // Extracted from g4tools/include/tools/colors
395 // Copyright (C) 2010, Guy Barrand. All righ 373 // Copyright (C) 2010, Guy Barrand. All rights reserved.
396 // See the file tools.license for terms. 374 // See the file tools.license for terms.
397 375
398 #define TOOLS_COLORS_STAT(name,r,g,b) \ 376 #define TOOLS_COLORS_STAT(name,r,g,b) \
399 G4Colour::AddToMap(#name, G4Colour(r,g,b)); 377 G4Colour::AddToMap(#name, G4Colour(r,g,b));
400 378
401 //0-9 379 //0-9
402 TOOLS_COLORS_STAT(aquamarine,0.496101F,0.996 380 TOOLS_COLORS_STAT(aquamarine,0.496101F,0.996109F,0.828138F)
403 TOOLS_COLORS_STAT(mediumaquamarine,0.398444F 381 TOOLS_COLORS_STAT(mediumaquamarine,0.398444F,0.800793F,0.664073F)
404 // TOOLS_COLORS_STAT(black,0,0,0) (already 382 // TOOLS_COLORS_STAT(black,0,0,0) (already defined)
405 // TOOLS_COLORS_STAT(blue,0,0,1) (already d 383 // TOOLS_COLORS_STAT(blue,0,0,1) (already defined)
406 TOOLS_COLORS_STAT(cadetblue,0.371099F,0.6171 384 TOOLS_COLORS_STAT(cadetblue,0.371099F,0.617197F,0.62501F)
407 TOOLS_COLORS_STAT(cornflowerblue,0.390631F,0 385 TOOLS_COLORS_STAT(cornflowerblue,0.390631F,0.58204F,0.925795F)
408 TOOLS_COLORS_STAT(darkslateblue,0.281254F,0. 386 TOOLS_COLORS_STAT(darkslateblue,0.281254F,0.238285F,0.542977F)
409 TOOLS_COLORS_STAT(lightblue,0.675792F,0.8437 387 TOOLS_COLORS_STAT(lightblue,0.675792F,0.843763F,0.898451F)
410 TOOLS_COLORS_STAT(lightsteelblue,0.68751F,0. 388 TOOLS_COLORS_STAT(lightsteelblue,0.68751F,0.765637F,0.867201F)
411 TOOLS_COLORS_STAT(mediumblue,0,0,0.800793F) 389 TOOLS_COLORS_STAT(mediumblue,0,0,0.800793F)
412 390
413 //10-19 391 //10-19
414 TOOLS_COLORS_STAT(mediumslateblue,0.480476F, 392 TOOLS_COLORS_STAT(mediumslateblue,0.480476F,0.406256F,0.929702F)
415 TOOLS_COLORS_STAT(midnightblue,0.0976577F,0. 393 TOOLS_COLORS_STAT(midnightblue,0.0976577F,0.0976577F,0.437507F)
416 TOOLS_COLORS_STAT(navyblue,0,0,0.500008F) 394 TOOLS_COLORS_STAT(navyblue,0,0,0.500008F)
417 TOOLS_COLORS_STAT(navy,0,0,0.500008F) 395 TOOLS_COLORS_STAT(navy,0,0,0.500008F)
418 TOOLS_COLORS_STAT(skyblue,0.527352F,0.8047F, 396 TOOLS_COLORS_STAT(skyblue,0.527352F,0.8047F,0.917983F)
419 TOOLS_COLORS_STAT(slateblue,0.414069F,0.3515 397 TOOLS_COLORS_STAT(slateblue,0.414069F,0.351568F,0.800793F)
420 TOOLS_COLORS_STAT(steelblue,0.273442F,0.5078 398 TOOLS_COLORS_STAT(steelblue,0.273442F,0.50782F,0.703136F)
421 TOOLS_COLORS_STAT(coral,0.996109F,0.496101F, 399 TOOLS_COLORS_STAT(coral,0.996109F,0.496101F,0.312505F)
422 // TOOLS_COLORS_STAT(cyan,0,1,1) (already d 400 // TOOLS_COLORS_STAT(cyan,0,1,1) (already defined)
423 TOOLS_COLORS_STAT(firebrick,0.695323F,0.1328 401 TOOLS_COLORS_STAT(firebrick,0.695323F,0.132815F,0.132815F)
424 402
425 //20-29 403 //20-29
426 // TOOLS_COLORS_STAT(brown,0.644541F,0.1640 404 // TOOLS_COLORS_STAT(brown,0.644541F,0.164065F,0.164065F) (already defined)
427 TOOLS_COLORS_STAT(gold,0.996109F,0.839857F,0 405 TOOLS_COLORS_STAT(gold,0.996109F,0.839857F,0)
428 TOOLS_COLORS_STAT(goldenrod,0.851575F,0.6445 406 TOOLS_COLORS_STAT(goldenrod,0.851575F,0.644541F,0.125002F)
429 // TOOLS_COLORS_STAT(green,0,1,0) (already 407 // TOOLS_COLORS_STAT(green,0,1,0) (already defined)
430 TOOLS_COLORS_STAT(darkgreen,0,0.390631F,0) 408 TOOLS_COLORS_STAT(darkgreen,0,0.390631F,0)
431 TOOLS_COLORS_STAT(darkolivegreen,0.332036F,0 409 TOOLS_COLORS_STAT(darkolivegreen,0.332036F,0.417975F,0.183597F)
432 TOOLS_COLORS_STAT(forestgreen,0.132815F,0.54 410 TOOLS_COLORS_STAT(forestgreen,0.132815F,0.542977F,0.132815F)
433 TOOLS_COLORS_STAT(limegreen,0.195315F,0.8007 411 TOOLS_COLORS_STAT(limegreen,0.195315F,0.800793F,0.195315F)
434 TOOLS_COLORS_STAT(mediumseagreen,0.234379F,0 412 TOOLS_COLORS_STAT(mediumseagreen,0.234379F,0.699229F,0.441413F)
435 TOOLS_COLORS_STAT(mediumspringgreen,0,0.9765 413 TOOLS_COLORS_STAT(mediumspringgreen,0,0.976577F,0.601572F)
436 414
437 //30-39 415 //30-39
438 TOOLS_COLORS_STAT(palegreen,0.593759F,0.9804 416 TOOLS_COLORS_STAT(palegreen,0.593759F,0.980484F,0.593759F)
439 TOOLS_COLORS_STAT(seagreen,0.17969F,0.542977 417 TOOLS_COLORS_STAT(seagreen,0.17969F,0.542977F,0.339849F)
440 TOOLS_COLORS_STAT(springgreen,0,0.996109F,0. 418 TOOLS_COLORS_STAT(springgreen,0,0.996109F,0.496101F)
441 TOOLS_COLORS_STAT(yellowgreen,0.601572F,0.80 419 TOOLS_COLORS_STAT(yellowgreen,0.601572F,0.800793F,0.195315F)
442 TOOLS_COLORS_STAT(darkslategrey,0.183597F,0. 420 TOOLS_COLORS_STAT(darkslategrey,0.183597F,0.308598F,0.308598F)
443 TOOLS_COLORS_STAT(dimgrey,0.410163F,0.410163 421 TOOLS_COLORS_STAT(dimgrey,0.410163F,0.410163F,0.410163F)
444 TOOLS_COLORS_STAT(lightgrey,0.824231F,0.8242 422 TOOLS_COLORS_STAT(lightgrey,0.824231F,0.824231F,0.824231F)
445 // TOOLS_COLORS_STAT(grey,0.750011F,0.75001 423 // TOOLS_COLORS_STAT(grey,0.750011F,0.750011F,0.750011F) (already defined)
446 TOOLS_COLORS_STAT(khaki,0.937514F,0.898451F, 424 TOOLS_COLORS_STAT(khaki,0.937514F,0.898451F,0.546883F)
447 // TOOLS_COLORS_STAT(magenta,1,0,1) (alread 425 // TOOLS_COLORS_STAT(magenta,1,0,1) (already defined)
448 426
449 //40-49 427 //40-49
450 TOOLS_COLORS_STAT(maroon,0.68751F,0.187503F, 428 TOOLS_COLORS_STAT(maroon,0.68751F,0.187503F,0.375006F)
451 TOOLS_COLORS_STAT(orange,0.996109F,0.644541F 429 TOOLS_COLORS_STAT(orange,0.996109F,0.644541F,0)
452 TOOLS_COLORS_STAT(orchid,0.851575F,0.437507F 430 TOOLS_COLORS_STAT(orchid,0.851575F,0.437507F,0.83595F)
453 TOOLS_COLORS_STAT(darkorchid,0.597665F,0.195 431 TOOLS_COLORS_STAT(darkorchid,0.597665F,0.195315F,0.796887F)
454 TOOLS_COLORS_STAT(mediumorchid,0.726574F,0.3 432 TOOLS_COLORS_STAT(mediumorchid,0.726574F,0.332036F,0.824231F)
455 TOOLS_COLORS_STAT(pink,0.996109F,0.750011F,0 433 TOOLS_COLORS_STAT(pink,0.996109F,0.750011F,0.792981F)
456 TOOLS_COLORS_STAT(plum,0.863294F,0.62501F,0. 434 TOOLS_COLORS_STAT(plum,0.863294F,0.62501F,0.863294F)
457 // TOOLS_COLORS_STAT(red,1,0,0) (already de 435 // TOOLS_COLORS_STAT(red,1,0,0) (already defined)
458 TOOLS_COLORS_STAT(indianred,0.800793F,0.3593 436 TOOLS_COLORS_STAT(indianred,0.800793F,0.35938F,0.35938F)
459 TOOLS_COLORS_STAT(mediumvioletred,0.777356F, 437 TOOLS_COLORS_STAT(mediumvioletred,0.777356F,0.0820325F,0.519539F)
460 438
461 //50-59 439 //50-59
462 TOOLS_COLORS_STAT(orangered,0.996109F,0.2695 440 TOOLS_COLORS_STAT(orangered,0.996109F,0.269535F,0)
463 TOOLS_COLORS_STAT(violetred,0.812512F,0.1250 441 TOOLS_COLORS_STAT(violetred,0.812512F,0.125002F,0.562509F)
464 TOOLS_COLORS_STAT(salmon,0.976577F,0.500008F 442 TOOLS_COLORS_STAT(salmon,0.976577F,0.500008F,0.445319F)
465 TOOLS_COLORS_STAT(sienna,0.62501F,0.320317F, 443 TOOLS_COLORS_STAT(sienna,0.62501F,0.320317F,0.175784F)
466 TOOLS_COLORS_STAT(tan,0.820325F,0.703136F,0. 444 TOOLS_COLORS_STAT(tan,0.820325F,0.703136F,0.546883F)
467 TOOLS_COLORS_STAT(thistle,0.843763F,0.746105 445 TOOLS_COLORS_STAT(thistle,0.843763F,0.746105F,0.843763F)
468 TOOLS_COLORS_STAT(turquoise,0.250004F,0.8750 446 TOOLS_COLORS_STAT(turquoise,0.250004F,0.875013F,0.812512F)
469 TOOLS_COLORS_STAT(darkturquoise,0,0.8047F,0. 447 TOOLS_COLORS_STAT(darkturquoise,0,0.8047F,0.816419F)
470 TOOLS_COLORS_STAT(mediumturquoise,0.281254F, 448 TOOLS_COLORS_STAT(mediumturquoise,0.281254F,0.816419F,0.796887F)
471 TOOLS_COLORS_STAT(violet,0.929702F,0.50782F, 449 TOOLS_COLORS_STAT(violet,0.929702F,0.50782F,0.929702F)
472 450
473 //60-64 451 //60-64
474 TOOLS_COLORS_STAT(blueviolet,0.539071F,0.167 452 TOOLS_COLORS_STAT(blueviolet,0.539071F,0.167971F,0.882826F)
475 TOOLS_COLORS_STAT(wheat,0.957046F,0.867201F, 453 TOOLS_COLORS_STAT(wheat,0.957046F,0.867201F,0.699229F)
476 // TOOLS_COLORS_STAT(white,1,1,1) (already 454 // TOOLS_COLORS_STAT(white,1,1,1) (already defined)
477 // TOOLS_COLORS_STAT(yellow,1,1,0) (already 455 // TOOLS_COLORS_STAT(yellow,1,1,0) (already defined)
478 TOOLS_COLORS_STAT(greenyellow,0.675792F,0.99 456 TOOLS_COLORS_STAT(greenyellow,0.675792F,0.996109F,0.18359F)
479 457
480 #undef TOOLS_COLORS_STAT 458 #undef TOOLS_COLORS_STAT
481 } 459 }
482 460
483 void G4VisManager::RegisterMessengers () { 461 void G4VisManager::RegisterMessengers () {
484 462
485 // Instantiate individual messengers/command 463 // Instantiate individual messengers/commands (often - but not
486 // always - one command per messenger). 464 // always - one command per messenger).
487 465
488 G4UIcommand* directory; 466 G4UIcommand* directory;
489 467
490 directory = new G4UIdirectory ("/vis/geometr 468 directory = new G4UIdirectory ("/vis/geometry/");
491 directory -> SetGuidance("Operations on vis 469 directory -> SetGuidance("Operations on vis attributes of Geant4 geometry.");
492 fDirectoryList.push_back (directory); 470 fDirectoryList.push_back (directory);
493 RegisterMessenger(new G4VisCommandGeometryLi 471 RegisterMessenger(new G4VisCommandGeometryList);
494 RegisterMessenger(new G4VisCommandGeometryRe 472 RegisterMessenger(new G4VisCommandGeometryRestore);
495 473
496 directory = new G4UIdirectory ("/vis/geometr 474 directory = new G4UIdirectory ("/vis/geometry/set/");
497 directory -> SetGuidance("Set vis attributes 475 directory -> SetGuidance("Set vis attributes of Geant4 geometry.");
498 fDirectoryList.push_back (directory); 476 fDirectoryList.push_back (directory);
499 RegisterMessenger(new G4VisCommandGeometrySe 477 RegisterMessenger(new G4VisCommandGeometrySetColour);
500 RegisterMessenger(new G4VisCommandGeometrySe 478 RegisterMessenger(new G4VisCommandGeometrySetDaughtersInvisible);
501 RegisterMessenger(new G4VisCommandGeometrySe 479 RegisterMessenger(new G4VisCommandGeometrySetLineStyle);
502 RegisterMessenger(new G4VisCommandGeometrySe 480 RegisterMessenger(new G4VisCommandGeometrySetLineWidth);
503 RegisterMessenger(new G4VisCommandGeometrySe 481 RegisterMessenger(new G4VisCommandGeometrySetForceAuxEdgeVisible);
504 RegisterMessenger(new G4VisCommandGeometrySe <<
505 RegisterMessenger(new G4VisCommandGeometrySe 482 RegisterMessenger(new G4VisCommandGeometrySetForceLineSegmentsPerCircle);
506 RegisterMessenger(new G4VisCommandGeometrySe 483 RegisterMessenger(new G4VisCommandGeometrySetForceSolid);
507 RegisterMessenger(new G4VisCommandGeometrySe 484 RegisterMessenger(new G4VisCommandGeometrySetForceWireframe);
508 RegisterMessenger(new G4VisCommandGeometrySe 485 RegisterMessenger(new G4VisCommandGeometrySetVisibility);
509 486
>> 487 #ifdef G4MULTITHREADED
510 directory = new G4UIdirectory ("/vis/multith 488 directory = new G4UIdirectory ("/vis/multithreading/");
511 directory -> SetGuidance("Commands unique to 489 directory -> SetGuidance("Commands unique to multithreading mode.");
512 fDirectoryList.push_back (directory); 490 fDirectoryList.push_back (directory);
513 RegisterMessenger(new G4VisCommandMultithrea 491 RegisterMessenger(new G4VisCommandMultithreadingActionOnEventQueueFull);
514 RegisterMessenger(new G4VisCommandMultithrea 492 RegisterMessenger(new G4VisCommandMultithreadingMaxEventQueueSize);
>> 493 #endif
515 494
516 directory = new G4UIdirectory ("/vis/set/"); 495 directory = new G4UIdirectory ("/vis/set/");
517 directory -> SetGuidance 496 directory -> SetGuidance
518 ("Set quantities for use in future command 497 ("Set quantities for use in future commands where appropriate.");
519 fDirectoryList.push_back (directory); 498 fDirectoryList.push_back (directory);
520 RegisterMessenger(new G4VisCommandSetArrow3D 499 RegisterMessenger(new G4VisCommandSetArrow3DLineSegmentsPerCircle);
521 RegisterMessenger(new G4VisCommandSetColour) 500 RegisterMessenger(new G4VisCommandSetColour);
522 RegisterMessenger(new G4VisCommandSetExtentF 501 RegisterMessenger(new G4VisCommandSetExtentForField);
523 RegisterMessenger(new G4VisCommandSetLineWid 502 RegisterMessenger(new G4VisCommandSetLineWidth);
524 RegisterMessenger(new G4VisCommandSetTextCol 503 RegisterMessenger(new G4VisCommandSetTextColour);
525 RegisterMessenger(new G4VisCommandSetTextLay 504 RegisterMessenger(new G4VisCommandSetTextLayout);
526 RegisterMessenger(new G4VisCommandSetTextSiz 505 RegisterMessenger(new G4VisCommandSetTextSize);
527 RegisterMessenger(new G4VisCommandSetTouchab 506 RegisterMessenger(new G4VisCommandSetTouchable);
528 RegisterMessenger(new G4VisCommandSetVolumeF 507 RegisterMessenger(new G4VisCommandSetVolumeForField);
529 508
530 directory = new G4UIdirectory ("/vis/scene/" 509 directory = new G4UIdirectory ("/vis/scene/");
531 directory -> SetGuidance ("Operations on Gea 510 directory -> SetGuidance ("Operations on Geant4 scenes.");
532 fDirectoryList.push_back (directory); 511 fDirectoryList.push_back (directory);
533 RegisterMessenger(new G4VisCommandSceneActiv 512 RegisterMessenger(new G4VisCommandSceneActivateModel);
534 RegisterMessenger(new G4VisCommandSceneCreat 513 RegisterMessenger(new G4VisCommandSceneCreate);
535 RegisterMessenger(new G4VisCommandSceneEndOf 514 RegisterMessenger(new G4VisCommandSceneEndOfEventAction);
536 RegisterMessenger(new G4VisCommandSceneEndOf 515 RegisterMessenger(new G4VisCommandSceneEndOfRunAction);
537 RegisterMessenger(new G4VisCommandSceneList) 516 RegisterMessenger(new G4VisCommandSceneList);
538 RegisterMessenger(new G4VisCommandSceneNotif 517 RegisterMessenger(new G4VisCommandSceneNotifyHandlers);
539 RegisterMessenger(new G4VisCommandSceneRemov <<
540 RegisterMessenger(new G4VisCommandSceneSelec 518 RegisterMessenger(new G4VisCommandSceneSelect);
541 RegisterMessenger(new G4VisCommandSceneShowE 519 RegisterMessenger(new G4VisCommandSceneShowExtents);
542 520
543 directory = new G4UIdirectory ("/vis/scene/a 521 directory = new G4UIdirectory ("/vis/scene/add/");
544 directory -> SetGuidance ("Add model to curr 522 directory -> SetGuidance ("Add model to current scene.");
545 fDirectoryList.push_back (directory); 523 fDirectoryList.push_back (directory);
546 RegisterMessenger(new G4VisCommandSceneAddAr 524 RegisterMessenger(new G4VisCommandSceneAddArrow);
547 RegisterMessenger(new G4VisCommandSceneAddAr 525 RegisterMessenger(new G4VisCommandSceneAddArrow2D);
548 RegisterMessenger(new G4VisCommandSceneAddAx 526 RegisterMessenger(new G4VisCommandSceneAddAxes);
549 RegisterMessenger(new G4VisCommandSceneAddDa 527 RegisterMessenger(new G4VisCommandSceneAddDate);
550 RegisterMessenger(new G4VisCommandSceneAddDi 528 RegisterMessenger(new G4VisCommandSceneAddDigis);
551 RegisterMessenger(new G4VisCommandSceneAddEv 529 RegisterMessenger(new G4VisCommandSceneAddEventID);
552 RegisterMessenger(new G4VisCommandSceneAddEx 530 RegisterMessenger(new G4VisCommandSceneAddExtent);
553 RegisterMessenger(new G4VisCommandSceneAddEl 531 RegisterMessenger(new G4VisCommandSceneAddElectricField);
554 RegisterMessenger(new G4VisCommandSceneAddFr 532 RegisterMessenger(new G4VisCommandSceneAddFrame);
555 RegisterMessenger(new G4VisCommandSceneAddGP 533 RegisterMessenger(new G4VisCommandSceneAddGPS);
556 RegisterMessenger(new G4VisCommandSceneAddHi 534 RegisterMessenger(new G4VisCommandSceneAddHits);
557 RegisterMessenger(new G4VisCommandSceneAddLi 535 RegisterMessenger(new G4VisCommandSceneAddLine);
558 RegisterMessenger(new G4VisCommandSceneAddLi 536 RegisterMessenger(new G4VisCommandSceneAddLine2D);
559 RegisterMessenger(new G4VisCommandSceneAddLo <<
560 RegisterMessenger(new G4VisCommandSceneAddLo 537 RegisterMessenger(new G4VisCommandSceneAddLogicalVolume);
561 RegisterMessenger(new G4VisCommandSceneAddLo 538 RegisterMessenger(new G4VisCommandSceneAddLogo);
562 RegisterMessenger(new G4VisCommandSceneAddLo 539 RegisterMessenger(new G4VisCommandSceneAddLogo2D);
563 RegisterMessenger(new G4VisCommandSceneAddMa 540 RegisterMessenger(new G4VisCommandSceneAddMagneticField);
564 RegisterMessenger(new G4VisCommandSceneAddPl <<
565 RegisterMessenger(new G4VisCommandSceneAddPS 541 RegisterMessenger(new G4VisCommandSceneAddPSHits);
566 RegisterMessenger(new G4VisCommandSceneAddSc 542 RegisterMessenger(new G4VisCommandSceneAddScale);
567 RegisterMessenger(new G4VisCommandSceneAddTe 543 RegisterMessenger(new G4VisCommandSceneAddText);
568 RegisterMessenger(new G4VisCommandSceneAddTe 544 RegisterMessenger(new G4VisCommandSceneAddText2D);
569 RegisterMessenger(new G4VisCommandSceneAddTr 545 RegisterMessenger(new G4VisCommandSceneAddTrajectories);
570 RegisterMessenger(new G4VisCommandSceneAddUs 546 RegisterMessenger(new G4VisCommandSceneAddUserAction);
571 RegisterMessenger(new G4VisCommandSceneAddVo 547 RegisterMessenger(new G4VisCommandSceneAddVolume);
572 548
573 RegisterMessenger(new G4VisCommandPlotterCre <<
574 RegisterMessenger(new G4VisCommandPlotterSet <<
575 RegisterMessenger(new G4VisCommandPlotterAdd <<
576 RegisterMessenger(new G4VisCommandPlotterAdd <<
577 RegisterMessenger(new G4VisCommandPlotterAdd <<
578 RegisterMessenger(new G4VisCommandPlotterCle <<
579 RegisterMessenger(new G4VisCommandPlotterCle <<
580 RegisterMessenger(new G4VisCommandPlotterLis <<
581 RegisterMessenger(new G4VisCommandPlotterAdd <<
582 RegisterMessenger(new G4VisCommandPlotterAdd <<
583 <<
584 directory = new G4UIdirectory ("/vis/sceneHa 549 directory = new G4UIdirectory ("/vis/sceneHandler/");
585 directory -> SetGuidance ("Operations on Gea 550 directory -> SetGuidance ("Operations on Geant4 scene handlers.");
586 fDirectoryList.push_back (directory); 551 fDirectoryList.push_back (directory);
587 RegisterMessenger(new G4VisCommandSceneHandl 552 RegisterMessenger(new G4VisCommandSceneHandlerAttach);
588 RegisterMessenger(new G4VisCommandSceneHandl 553 RegisterMessenger(new G4VisCommandSceneHandlerCreate);
589 RegisterMessenger(new G4VisCommandSceneHandl 554 RegisterMessenger(new G4VisCommandSceneHandlerList);
590 RegisterMessenger(new G4VisCommandSceneHandl 555 RegisterMessenger(new G4VisCommandSceneHandlerSelect);
591 556
592 directory = new G4UIdirectory ("/vis/touchab 557 directory = new G4UIdirectory ("/vis/touchable/");
593 directory -> SetGuidance ("Operations on tou 558 directory -> SetGuidance ("Operations on touchables.");
594 fDirectoryList.push_back (directory); 559 fDirectoryList.push_back (directory);
595 RegisterMessenger(new G4VisCommandsTouchable 560 RegisterMessenger(new G4VisCommandsTouchable);
596 561
597 directory = new G4UIdirectory ("/vis/touchab 562 directory = new G4UIdirectory ("/vis/touchable/set/");
598 directory -> SetGuidance ("Set vis attribute 563 directory -> SetGuidance ("Set vis attributes of current touchable.");
599 fDirectoryList.push_back (directory); 564 fDirectoryList.push_back (directory);
600 RegisterMessenger(new G4VisCommandsTouchable 565 RegisterMessenger(new G4VisCommandsTouchableSet);
601 566
602 directory = new G4UIdirectory ("/vis/viewer/ 567 directory = new G4UIdirectory ("/vis/viewer/");
603 directory -> SetGuidance ("Operations on Gea 568 directory -> SetGuidance ("Operations on Geant4 viewers.");
604 fDirectoryList.push_back (directory); 569 fDirectoryList.push_back (directory);
605 RegisterMessenger(new G4VisCommandViewerAddC 570 RegisterMessenger(new G4VisCommandViewerAddCutawayPlane);
606 RegisterMessenger(new G4VisCommandViewerCent 571 RegisterMessenger(new G4VisCommandViewerCentreOn);
607 RegisterMessenger(new G4VisCommandViewerChan 572 RegisterMessenger(new G4VisCommandViewerChangeCutawayPlane);
608 RegisterMessenger(new G4VisCommandViewerClea 573 RegisterMessenger(new G4VisCommandViewerClear);
609 RegisterMessenger(new G4VisCommandViewerClea 574 RegisterMessenger(new G4VisCommandViewerClearCutawayPlanes);
610 RegisterMessenger(new G4VisCommandViewerClea 575 RegisterMessenger(new G4VisCommandViewerClearTransients);
611 RegisterMessenger(new G4VisCommandViewerClea 576 RegisterMessenger(new G4VisCommandViewerClearVisAttributesModifiers);
612 RegisterMessenger(new G4VisCommandViewerClon 577 RegisterMessenger(new G4VisCommandViewerClone);
613 RegisterMessenger(new G4VisCommandViewerColo 578 RegisterMessenger(new G4VisCommandViewerColourByDensity);
614 RegisterMessenger(new G4VisCommandViewerCopy 579 RegisterMessenger(new G4VisCommandViewerCopyViewFrom);
615 RegisterMessenger(new G4VisCommandViewerCrea 580 RegisterMessenger(new G4VisCommandViewerCreate);
616 RegisterMessenger(new G4VisCommandViewerDoll 581 RegisterMessenger(new G4VisCommandViewerDolly);
617 RegisterMessenger(new G4VisCommandViewerFlus 582 RegisterMessenger(new G4VisCommandViewerFlush);
618 RegisterMessenger(new G4VisCommandViewerInte 583 RegisterMessenger(new G4VisCommandViewerInterpolate);
619 RegisterMessenger(new G4VisCommandViewerList 584 RegisterMessenger(new G4VisCommandViewerList);
620 RegisterMessenger(new G4VisCommandViewerPan) 585 RegisterMessenger(new G4VisCommandViewerPan);
621 RegisterMessenger(new G4VisCommandViewerRebu 586 RegisterMessenger(new G4VisCommandViewerRebuild);
622 RegisterMessenger(new G4VisCommandViewerRefr 587 RegisterMessenger(new G4VisCommandViewerRefresh);
623 RegisterMessenger(new G4VisCommandViewerRese 588 RegisterMessenger(new G4VisCommandViewerReset);
624 RegisterMessenger(new G4VisCommandViewerRese <<
625 RegisterMessenger(new G4VisCommandViewerSave 589 RegisterMessenger(new G4VisCommandViewerSave);
626 RegisterMessenger(new G4VisCommandViewerScal 590 RegisterMessenger(new G4VisCommandViewerScale);
627 RegisterMessenger(new G4VisCommandViewerSele 591 RegisterMessenger(new G4VisCommandViewerSelect);
628 RegisterMessenger(new G4VisCommandViewerUpda 592 RegisterMessenger(new G4VisCommandViewerUpdate);
629 RegisterMessenger(new G4VisCommandViewerZoom 593 RegisterMessenger(new G4VisCommandViewerZoom);
630 594
631 directory = new G4UIdirectory ("/vis/viewer/ 595 directory = new G4UIdirectory ("/vis/viewer/default/");
632 directory -> SetGuidance("Set default values 596 directory -> SetGuidance("Set default values for future viewers.");
633 fDirectoryList.push_back (directory); 597 fDirectoryList.push_back (directory);
634 RegisterMessenger(new G4VisCommandViewerDefa 598 RegisterMessenger(new G4VisCommandViewerDefaultHiddenEdge);
635 RegisterMessenger(new G4VisCommandViewerDefa 599 RegisterMessenger(new G4VisCommandViewerDefaultStyle);
636 600
637 directory = new G4UIdirectory ("/vis/viewer/ 601 directory = new G4UIdirectory ("/vis/viewer/set/");
638 directory -> SetGuidance ("Set view paramete 602 directory -> SetGuidance ("Set view parameters of current viewer.");
639 fDirectoryList.push_back (directory); 603 fDirectoryList.push_back (directory);
640 RegisterMessenger(new G4VisCommandsViewerSet 604 RegisterMessenger(new G4VisCommandsViewerSet);
641 605
642 // *Basic* top level commands were instantia 606 // *Basic* top level commands were instantiated in the constructor
643 // so that they can be used immediately afte 607 // so that they can be used immediately after instantiation of the
644 // vis manager. Other top level commands, i 608 // vis manager. Other top level commands, including "compound commands"
645 // (i.e., commands that invoke other command 609 // (i.e., commands that invoke other commands) are instantiated here.
646 610
647 RegisterMessenger(new G4VisCommandAbortRevie 611 RegisterMessenger(new G4VisCommandAbortReviewKeptEvents);
648 RegisterMessenger(new G4VisCommandAbortRevie <<
649 RegisterMessenger(new G4VisCommandDrawOnlyTo 612 RegisterMessenger(new G4VisCommandDrawOnlyToBeKeptEvents);
650 RegisterMessenger(new G4VisCommandDrawTree); 613 RegisterMessenger(new G4VisCommandDrawTree);
651 RegisterMessenger(new G4VisCommandDrawView); 614 RegisterMessenger(new G4VisCommandDrawView);
652 RegisterMessenger(new G4VisCommandDrawLogica 615 RegisterMessenger(new G4VisCommandDrawLogicalVolume);
653 RegisterMessenger(new G4VisCommandDrawVolume 616 RegisterMessenger(new G4VisCommandDrawVolume);
654 RegisterMessenger(new G4VisCommandEnable); 617 RegisterMessenger(new G4VisCommandEnable);
655 RegisterMessenger(new G4VisCommandList); 618 RegisterMessenger(new G4VisCommandList);
656 RegisterMessenger(new G4VisCommandOpen); 619 RegisterMessenger(new G4VisCommandOpen);
657 RegisterMessenger(new G4VisCommandPlot); <<
658 RegisterMessenger(new G4VisCommandReviewKept 620 RegisterMessenger(new G4VisCommandReviewKeptEvents);
659 RegisterMessenger(new G4VisCommandReviewPlot <<
660 RegisterMessenger(new G4VisCommandSpecify); 621 RegisterMessenger(new G4VisCommandSpecify);
661 622
662 // List manager commands 623 // List manager commands
663 RegisterMessenger(new G4VisCommandListManage 624 RegisterMessenger(new G4VisCommandListManagerList< G4VisModelManager<G4VTrajectoryModel> >
664 (fpTrajDrawModelMgr, fpTrajDrawModelMg 625 (fpTrajDrawModelMgr, fpTrajDrawModelMgr->Placement()));
665 RegisterMessenger(new G4VisCommandListManage 626 RegisterMessenger(new G4VisCommandListManagerSelect< G4VisModelManager<G4VTrajectoryModel> >
666 (fpTrajDrawModelMgr, fpTrajDrawModelMg 627 (fpTrajDrawModelMgr, fpTrajDrawModelMgr->Placement()));
667 628
668 // Trajectory filter manager commands 629 // Trajectory filter manager commands
669 RegisterMessenger(new G4VisCommandListManage 630 RegisterMessenger(new G4VisCommandListManagerList< G4VisFilterManager<G4VTrajectory> >
670 (fpTrajFilterMgr, fpTrajFi 631 (fpTrajFilterMgr, fpTrajFilterMgr->Placement()));
671 RegisterMessenger(new G4VisCommandManagerMod 632 RegisterMessenger(new G4VisCommandManagerMode< G4VisFilterManager<G4VTrajectory> >
672 (fpTrajFilterMgr, fpTrajFi 633 (fpTrajFilterMgr, fpTrajFilterMgr->Placement()));
673 634
674 // Hit filter manager commands 635 // Hit filter manager commands
675 RegisterMessenger(new G4VisCommandListManage 636 RegisterMessenger(new G4VisCommandListManagerList< G4VisFilterManager<G4VHit> >
676 (fpHitFilterMgr, fpHitFilt 637 (fpHitFilterMgr, fpHitFilterMgr->Placement()));
677 RegisterMessenger(new G4VisCommandManagerMod 638 RegisterMessenger(new G4VisCommandManagerMode< G4VisFilterManager<G4VHit> >
678 (fpHitFilterMgr, fpHitFilt 639 (fpHitFilterMgr, fpHitFilterMgr->Placement()));
679 640
680 // Digi filter manager commands 641 // Digi filter manager commands
681 RegisterMessenger(new G4VisCommandListManage 642 RegisterMessenger(new G4VisCommandListManagerList< G4VisFilterManager<G4VDigi> >
682 (fpDigiFilterMgr, fpDigiFi 643 (fpDigiFilterMgr, fpDigiFilterMgr->Placement()));
683 RegisterMessenger(new G4VisCommandManagerMod 644 RegisterMessenger(new G4VisCommandManagerMode< G4VisFilterManager<G4VDigi> >
684 (fpDigiFilterMgr, fpDigiFi 645 (fpDigiFilterMgr, fpDigiFilterMgr->Placement()));
685 } 646 }
686 647
687 #include <tools/histo/h1d> <<
688 #include <tools/histo/h2d> <<
689 <<
690 namespace { <<
691 struct PlotResults { <<
692 std::size_t fNumberOfPlots = 0; <<
693 std::size_t fTotalEntries = 0; <<
694 }; <<
695 template <typename HT> // tools::histo::h1d <<
696 PlotResults ResultsOfHnPlots(const G4String& <<
697 PlotResults plotResults; <<
698 auto ui = G4UImanager::GetUIpointer(); <<
699 auto keepControlVerbose = ui->GetVerboseLe <<
700 ui->SetVerboseLevel(0); <<
701 auto status = ui->ApplyCommand("/analysis/ <<
702 ui->SetVerboseLevel(keepControlVerbose); <<
703 if(status==G4UIcommandStatus::fCommandSucc <<
704 G4String hexString = ui->GetCurrentValue <<
705 if(hexString.size()) { <<
706 void* ptr; std::istringstream is(hexSt <<
707 auto vectorOfPlots = (const std::vecto <<
708 for (std::size_t i = 0; i < vectorOfPl <<
709 auto plot = (*vectorOfPlots)[i]; <<
710 if (plot == nullptr) continue; // I <<
711 ++plotResults.fNumberOfPlots; <<
712 plotResults.fTotalEntries += plot->e <<
713 } <<
714 } <<
715 } <<
716 return plotResults; <<
717 } <<
718 void PrintListOfPlots() { <<
719 std::size_t numberOfPlots = 0; <<
720 std::size_t numberOfEntries = 0; <<
721 PlotResults h1results = ResultsOfHnPlots<t <<
722 numberOfPlots += h1results.fNumberOfPlots; <<
723 numberOfEntries += h1results.fTotalEntries <<
724 PlotResults h2results = ResultsOfHnPlots<t <<
725 numberOfPlots += h2results.fNumberOfPlots; <<
726 numberOfEntries += h2results.fTotalEntries <<
727 if (numberOfPlots > 0) { <<
728 G4warn << "There are histograms that can <<
729 if (h1results.fNumberOfPlots > 0) { <<
730 G4warn << "\n " << h1results.fNumberO <<
731 } <<
732 if (h2results.fNumberOfPlots > 0) { <<
733 G4warn << "\n " << h2results.fNumberO <<
734 } <<
735 G4warn <<
736 << "\n List them with \"/analysis/list\ <<
737 << "\n View them immediately with \"/vi <<
738 << G4endl; <<
739 if (numberOfEntries == 0) { <<
740 G4warn << <<
741 " But...there are no entries. To make <<
742 "\n plotting in this UI session, use <<
743 "\n EndOfRunAction and Reset() in you <<
744 << G4endl; <<
745 } <<
746 } <<
747 } <<
748 } <<
749 <<
750 void G4VisManager::Enable() { 648 void G4VisManager::Enable() {
751 if (IsValidView ()) { 649 if (IsValidView ()) {
752 SetConcreteInstance(this); 650 SetConcreteInstance(this);
753 if (fVerbosity >= confirmations) { 651 if (fVerbosity >= confirmations) {
754 G4cout << "G4VisManager::Enable: visuali 652 G4cout << "G4VisManager::Enable: visualization enabled." << G4endl;
755 } 653 }
756 if (fVerbosity >= warnings) { 654 if (fVerbosity >= warnings) {
757 std::size_t nKeptEvents = 0; << 655 G4int nKeptEvents = 0;
758 const G4Run* run = G4RunManager::GetRunM 656 const G4Run* run = G4RunManager::GetRunManager()->GetCurrentRun();
759 if (run) nKeptEvents = run->GetNumberOfK << 657 if (run) nKeptEvents = run->GetEventVector()->size();
760 G4String isare("are"),plural("s"); <<
761 if (nKeptEvents == 1) {isare = "is"; plu <<
762 G4cout << 658 G4cout <<
763 "There " << isare << ' ' << nKeptEvents << 659 "There are " << nKeptEvents << " kept events."
>> 660 "\n \"/vis/reviewKeptEvents\" to review them one by one."
>> 661 "\n \"/vis/viewer/flush\" or \"/vis/viewer/rebuild\" to see them accumulated."
764 << G4endl; 662 << G4endl;
765 if (nKeptEvents > 0) { <<
766 G4cout << <<
767 " \"/vis/reviewKeptEvents\" to review one b <<
768 "\n To see accumulated, \"/vis/enable\", th <<
769 << G4endl; <<
770 } <<
771 PrintListOfPlots(); <<
772 } 663 }
773 } 664 }
774 else { 665 else {
775 if (fVerbosity >= warnings) { 666 if (fVerbosity >= warnings) {
776 G4warn << << 667 G4cout <<
777 "G4VisManager::Enable: WARNING: visualizatio 668 "G4VisManager::Enable: WARNING: visualization remains disabled for"
778 "\n above reasons. Rectifying with valid v 669 "\n above reasons. Rectifying with valid vis commands will"
779 "\n automatically enable." 670 "\n automatically enable."
780 << G4endl; 671 << G4endl;
781 } 672 }
782 } 673 }
783 } 674 }
784 675
785 void G4VisManager::Disable() { 676 void G4VisManager::Disable() {
786 SetConcreteInstance(0); 677 SetConcreteInstance(0);
787 if (fVerbosity >= confirmations) { 678 if (fVerbosity >= confirmations) {
788 G4cout << 679 G4cout <<
789 "G4VisManager::Disable: visualization disa 680 "G4VisManager::Disable: visualization disabled."
790 "\n The pointer returned by GetConcreteIn 681 "\n The pointer returned by GetConcreteInstance will be zero."
791 "\n Note that it will become enabled afte 682 "\n Note that it will become enabled after some valid vis commands."
792 << G4endl; 683 << G4endl;
793 } 684 }
794 if (fVerbosity >= warnings) { 685 if (fVerbosity >= warnings) {
795 G4int currentTrajectoryType = 686 G4int currentTrajectoryType =
796 G4RunManagerKernel::GetRunManagerKernel()- 687 G4RunManagerKernel::GetRunManagerKernel()->GetTrackingManager()->GetStoreTrajectory();
797 if (currentTrajectoryType > 0) { 688 if (currentTrajectoryType > 0) {
798 G4warn << << 689 G4cout <<
799 "You may wish to disable trajectory prod 690 "You may wish to disable trajectory production too:"
800 "\n \"/tracking/storeTrajectory 0\"" 691 "\n \"/tracking/storeTrajectory 0\""
801 "\nbut don't forget to re-enable with" 692 "\nbut don't forget to re-enable with"
802 "\n \"/vis/enable\"" 693 "\n \"/vis/enable\""
803 "\n \"/tracking/storeTrajectory " << cu << 694 "\n \"/tracking/storeTrajectory " << currentTrajectoryType << '\"'
804 << "\"\n and maybe \"/vis/viewer/rebuil <<
805 << G4endl; 695 << G4endl;
806 } 696 }
807 } 697 }
808 } 698 }
809 699
810 const G4GraphicsSystemList& G4VisManager::GetA 700 const G4GraphicsSystemList& G4VisManager::GetAvailableGraphicsSystems () {
811 std::size_t nSystems = fAvailableGraphicsSys << 701 G4int nSystems = fAvailableGraphicsSystems.size ();
812 if (nSystems == 0) { 702 if (nSystems == 0) {
813 if (fVerbosity >= warnings) { 703 if (fVerbosity >= warnings) {
814 G4warn << "G4VisManager::GetAvailableGra << 704 G4cout << "G4VisManager::GetAvailableGraphicsSystems: WARNING: no"
815 "\n graphics system available!" 705 "\n graphics system available!"
816 "\n 1) Did you have environment variables G 706 "\n 1) Did you have environment variables G4VIS_BUILD_xxxx_DRIVER set"
817 "\n when you compiled/built the visualiz 707 "\n when you compiled/built the visualization code?"
818 "\n 2) Did you instantiate your own Visuali 708 "\n 2) Did you instantiate your own Visualization Manager and forget"
819 "\n to implement RegisterGraphicsSystems 709 "\n to implement RegisterGraphicsSystems correctly?"
820 "\n 3) You can register your own graphics s 710 "\n 3) You can register your own graphics system, e.g.,"
821 "\n visManager->RegisterGraphicsSystem(n 711 "\n visManager->RegisterGraphicsSystem(new MyGraphicsSystem);)"
822 "\n after instantiating your vis manager 712 "\n after instantiating your vis manager and before"
823 "\n visManager->Initialize()." 713 "\n visManager->Initialize()."
824 << G4endl; 714 << G4endl;
825 } 715 }
826 } 716 }
827 return fAvailableGraphicsSystems; 717 return fAvailableGraphicsSystems;
828 } 718 }
829 719
830 G4bool G4VisManager::RegisterGraphicsSystem (G 720 G4bool G4VisManager::RegisterGraphicsSystem (G4VGraphicsSystem* pSystem) {
831 G4bool happy = true; 721 G4bool happy = true;
832 if (pSystem) { 722 if (pSystem) {
833 fAvailableGraphicsSystems.push_back (pSyst 723 fAvailableGraphicsSystems.push_back (pSystem);
834 if (fVerbosity >= confirmations) { 724 if (fVerbosity >= confirmations) {
835 G4cout << "G4VisManager::RegisterGraphic 725 G4cout << "G4VisManager::RegisterGraphicsSystem: "
836 << pSystem -> GetName (); 726 << pSystem -> GetName ();
837 if (pSystem -> GetNickname () != "") { 727 if (pSystem -> GetNickname () != "") {
838 G4cout << " (" << pSystem -> GetNickname () 728 G4cout << " (" << pSystem -> GetNickname () << ")";
839 } 729 }
840 G4cout << " registered." << G4endl; 730 G4cout << " registered." << G4endl;
841 } 731 }
842 } 732 }
843 else { 733 else {
844 if (fVerbosity >= errors) { 734 if (fVerbosity >= errors) {
845 G4warn << "G4VisManager::RegisterGraphic << 735 G4cout << "G4VisManager::RegisterGraphicsSystem: null pointer!"
846 << G4endl; 736 << G4endl;
847 } 737 }
848 happy=false; 738 happy=false;
849 } 739 }
850 return happy; 740 return happy;
851 } 741 }
852 742
853 const G4VTrajectoryModel* 743 const G4VTrajectoryModel*
854 G4VisManager::CurrentTrajDrawModel() const 744 G4VisManager::CurrentTrajDrawModel() const
855 { 745 {
856 assert (0 != fpTrajDrawModelMgr); 746 assert (0 != fpTrajDrawModelMgr);
857 747
858 const G4VTrajectoryModel* model = fpTrajDraw 748 const G4VTrajectoryModel* model = fpTrajDrawModelMgr->Current();
859 749
860 if (0 == model) { 750 if (0 == model) {
861 // No model was registered with the trajec 751 // No model was registered with the trajectory model manager.
862 // Use G4TrajectoryDrawByCharge as a fallb 752 // Use G4TrajectoryDrawByCharge as a fallback.
863 fpTrajDrawModelMgr->Register(new G4Traject 753 fpTrajDrawModelMgr->Register(new G4TrajectoryDrawByCharge("DefaultModel"));
864 if (fVerbosity >= warnings) { 754 if (fVerbosity >= warnings) {
865 G4warn<<"G4VisManager: Using G4Trajector << 755 G4cout<<"G4VisManager: Using G4TrajectoryDrawByCharge as fallback trajectory model."<<G4endl;
866 G4warn<<"See commands in /vis/modeling/t << 756 G4cout<<"See commands in /vis/modeling/trajectories/ for other options."<<G4endl;
867 } 757 }
868 } 758 }
869 759
870 model = fpTrajDrawModelMgr->Current(); 760 model = fpTrajDrawModelMgr->Current();
871 assert (0 != model); // Should definitely ex 761 assert (0 != model); // Should definitely exist now
872 762
873 return model; 763 return model;
874 } 764 }
875 765
876 void G4VisManager::RegisterModel(G4VTrajectory 766 void G4VisManager::RegisterModel(G4VTrajectoryModel* model)
877 { 767 {
878 fpTrajDrawModelMgr->Register(model); 768 fpTrajDrawModelMgr->Register(model);
879 } 769 }
880 770
881 void 771 void
882 G4VisManager::RegisterModelFactory(G4TrajDrawM 772 G4VisManager::RegisterModelFactory(G4TrajDrawModelFactory* factory)
883 { 773 {
884 fpTrajDrawModelMgr->Register(factory); 774 fpTrajDrawModelMgr->Register(factory);
885 } 775 }
886 776
887 void G4VisManager::RegisterModel(G4VFilter<G4V 777 void G4VisManager::RegisterModel(G4VFilter<G4VTrajectory>* model)
888 { 778 {
889 fpTrajFilterMgr->Register(model); 779 fpTrajFilterMgr->Register(model);
890 } 780 }
891 781
892 void 782 void
893 G4VisManager::RegisterModelFactory(G4TrajFilte 783 G4VisManager::RegisterModelFactory(G4TrajFilterFactory* factory)
894 { 784 {
895 fpTrajFilterMgr->Register(factory); 785 fpTrajFilterMgr->Register(factory);
896 } 786 }
897 787
898 void G4VisManager::RegisterModel(G4VFilter<G4V 788 void G4VisManager::RegisterModel(G4VFilter<G4VHit>* model)
899 { 789 {
900 fpHitFilterMgr->Register(model); 790 fpHitFilterMgr->Register(model);
901 } 791 }
902 792
903 void 793 void
904 G4VisManager::RegisterModelFactory(G4HitFilter 794 G4VisManager::RegisterModelFactory(G4HitFilterFactory* factory)
905 { 795 {
906 fpHitFilterMgr->Register(factory); 796 fpHitFilterMgr->Register(factory);
907 } 797 }
908 798
909 void G4VisManager::RegisterModel(G4VFilter<G4V 799 void G4VisManager::RegisterModel(G4VFilter<G4VDigi>* model)
910 { 800 {
911 fpDigiFilterMgr->Register(model); 801 fpDigiFilterMgr->Register(model);
912 } 802 }
913 803
914 void 804 void
915 G4VisManager::RegisterModelFactory(G4DigiFilte 805 G4VisManager::RegisterModelFactory(G4DigiFilterFactory* factory)
916 { 806 {
917 fpDigiFilterMgr->Register(factory); 807 fpDigiFilterMgr->Register(factory);
918 } 808 }
919 809
920 void G4VisManager::SelectTrajectoryModel(const 810 void G4VisManager::SelectTrajectoryModel(const G4String& model)
921 { 811 {
922 fpTrajDrawModelMgr->SetCurrent(model); 812 fpTrajDrawModelMgr->SetCurrent(model);
923 } 813 }
924 814
925 void G4VisManager::BeginDraw (const G4Transfor 815 void G4VisManager::BeginDraw (const G4Transform3D& objectTransform)
926 { 816 {
>> 817 #ifdef G4MULTITHREADED
927 if (G4Threading::IsWorkerThread()) return; 818 if (G4Threading::IsWorkerThread()) return;
928 << 819 #endif
929 fDrawGroupNestingDepth++; 820 fDrawGroupNestingDepth++;
930 if (fDrawGroupNestingDepth > 1) { 821 if (fDrawGroupNestingDepth > 1) {
931 G4Exception 822 G4Exception
932 ("G4VisManager::BeginDraw", 823 ("G4VisManager::BeginDraw",
933 "visman0008", JustWarning, 824 "visman0008", JustWarning,
934 "Nesting detected. It is illegal to nes 825 "Nesting detected. It is illegal to nest Begin/EndDraw."
935 "\n Ignored"); 826 "\n Ignored");
936 return; 827 return;
937 } 828 }
938 if (IsValidView ()) { 829 if (IsValidView ()) {
939 ClearTransientStoreIfMarked(); 830 ClearTransientStoreIfMarked();
940 fpSceneHandler -> BeginPrimitives (objectT 831 fpSceneHandler -> BeginPrimitives (objectTransform);
941 fIsDrawGroup = true; 832 fIsDrawGroup = true;
942 } 833 }
943 } 834 }
944 835
945 void G4VisManager::EndDraw () 836 void G4VisManager::EndDraw ()
946 { 837 {
>> 838 #ifdef G4MULTITHREADED
947 if (G4Threading::IsWorkerThread()) return; 839 if (G4Threading::IsWorkerThread()) return;
948 << 840 #endif
949 fDrawGroupNestingDepth--; 841 fDrawGroupNestingDepth--;
950 if (fDrawGroupNestingDepth != 0) { 842 if (fDrawGroupNestingDepth != 0) {
951 if (fDrawGroupNestingDepth < 0) fDrawGroup 843 if (fDrawGroupNestingDepth < 0) fDrawGroupNestingDepth = 0;
952 return; 844 return;
953 } 845 }
954 if (IsValidView ()) { 846 if (IsValidView ()) {
955 fpSceneHandler -> EndPrimitives (); 847 fpSceneHandler -> EndPrimitives ();
956 } 848 }
957 fIsDrawGroup = false; 849 fIsDrawGroup = false;
958 } 850 }
959 851
960 void G4VisManager::BeginDraw2D (const G4Transf 852 void G4VisManager::BeginDraw2D (const G4Transform3D& objectTransform)
961 { 853 {
>> 854 #ifdef G4MULTITHREADED
962 if (G4Threading::IsWorkerThread()) return; 855 if (G4Threading::IsWorkerThread()) return;
963 << 856 #endif
964 fDrawGroupNestingDepth++; 857 fDrawGroupNestingDepth++;
965 if (fDrawGroupNestingDepth > 1) { 858 if (fDrawGroupNestingDepth > 1) {
966 G4Exception 859 G4Exception
967 ("G4VisManager::BeginDraw2D", 860 ("G4VisManager::BeginDraw2D",
968 "visman0009", JustWarning, 861 "visman0009", JustWarning,
969 "Nesting detected. It is illegal to nes 862 "Nesting detected. It is illegal to nest Begin/EndDraw2D."
970 "\n Ignored"); 863 "\n Ignored");
971 return; 864 return;
972 } 865 }
973 if (IsValidView ()) { 866 if (IsValidView ()) {
974 ClearTransientStoreIfMarked(); 867 ClearTransientStoreIfMarked();
975 fpSceneHandler -> BeginPrimitives2D (objec 868 fpSceneHandler -> BeginPrimitives2D (objectTransform);
976 fIsDrawGroup = true; 869 fIsDrawGroup = true;
977 } 870 }
978 } 871 }
979 872
980 void G4VisManager::EndDraw2D () 873 void G4VisManager::EndDraw2D ()
981 { 874 {
>> 875 #ifdef G4MULTITHREADED
982 if (G4Threading::IsWorkerThread()) return; 876 if (G4Threading::IsWorkerThread()) return;
983 << 877 #endif
984 fDrawGroupNestingDepth--; 878 fDrawGroupNestingDepth--;
985 if (fDrawGroupNestingDepth != 0) { 879 if (fDrawGroupNestingDepth != 0) {
986 if (fDrawGroupNestingDepth < 0) fDrawGroup 880 if (fDrawGroupNestingDepth < 0) fDrawGroupNestingDepth = 0;
987 return; 881 return;
988 } 882 }
989 if (IsValidView ()) { 883 if (IsValidView ()) {
990 fpSceneHandler -> EndPrimitives2D (); 884 fpSceneHandler -> EndPrimitives2D ();
991 } 885 }
992 fIsDrawGroup = false; 886 fIsDrawGroup = false;
993 } 887 }
994 888
995 template <class T> void G4VisManager::DrawT 889 template <class T> void G4VisManager::DrawT
996 (const T& graphics_primitive, const G4Transfor 890 (const T& graphics_primitive, const G4Transform3D& objectTransform) {
>> 891 #ifdef G4MULTITHREADED
997 if (G4Threading::IsWorkerThread()) return; 892 if (G4Threading::IsWorkerThread()) return;
998 << 893 #endif
999 if (fIsDrawGroup) { 894 if (fIsDrawGroup) {
1000 if (objectTransform != fpSceneHandler->Ge 895 if (objectTransform != fpSceneHandler->GetObjectTransformation()) {
1001 G4Exception 896 G4Exception
1002 ("G4VSceneHandler::DrawT", 897 ("G4VSceneHandler::DrawT",
1003 "visman0010", FatalException, 898 "visman0010", FatalException,
1004 "Different transform detected in Begin/End 899 "Different transform detected in Begin/EndDraw group.");
1005 } 900 }
1006 fpSceneHandler -> AddPrimitive (graphics_ 901 fpSceneHandler -> AddPrimitive (graphics_primitive);
1007 } else { 902 } else {
1008 if (IsValidView ()) { 903 if (IsValidView ()) {
1009 ClearTransientStoreIfMarked(); 904 ClearTransientStoreIfMarked();
1010 fpSceneHandler -> BeginPrimitives (obje 905 fpSceneHandler -> BeginPrimitives (objectTransform);
1011 fpSceneHandler -> AddPrimitive (graphic 906 fpSceneHandler -> AddPrimitive (graphics_primitive);
1012 fpSceneHandler -> EndPrimitives (); 907 fpSceneHandler -> EndPrimitives ();
1013 } 908 }
1014 } 909 }
1015 } 910 }
1016 911
1017 template <class T> void G4VisManager::DrawT2D 912 template <class T> void G4VisManager::DrawT2D
1018 (const T& graphics_primitive, const G4Transfo 913 (const T& graphics_primitive, const G4Transform3D& objectTransform) {
>> 914 #ifdef G4MULTITHREADED
1019 if (G4Threading::IsWorkerThread()) return; 915 if (G4Threading::IsWorkerThread()) return;
1020 << 916 #endif
1021 if (fIsDrawGroup) { 917 if (fIsDrawGroup) {
1022 if (objectTransform != fpSceneHandler->Ge 918 if (objectTransform != fpSceneHandler->GetObjectTransformation()) {
1023 G4Exception 919 G4Exception
1024 ("G4VSceneHandler::DrawT", 920 ("G4VSceneHandler::DrawT",
1025 "visman0011", FatalException, 921 "visman0011", FatalException,
1026 "Different transform detected in Begin/End 922 "Different transform detected in Begin/EndDraw2D group.");
1027 } 923 }
1028 fpSceneHandler -> AddPrimitive (graphics_ 924 fpSceneHandler -> AddPrimitive (graphics_primitive);
1029 } else { 925 } else {
1030 if (IsValidView ()) { 926 if (IsValidView ()) {
1031 ClearTransientStoreIfMarked(); 927 ClearTransientStoreIfMarked();
1032 fpSceneHandler -> BeginPrimitives2D (ob 928 fpSceneHandler -> BeginPrimitives2D (objectTransform);
1033 fpSceneHandler -> AddPrimitive (graphic 929 fpSceneHandler -> AddPrimitive (graphics_primitive);
1034 fpSceneHandler -> EndPrimitives2D (); 930 fpSceneHandler -> EndPrimitives2D ();
1035 } 931 }
1036 } 932 }
1037 } 933 }
1038 934
1039 void G4VisManager::Draw (const G4Circle& circ 935 void G4VisManager::Draw (const G4Circle& circle,
1040 const G4Transform3D& objectTransform) 936 const G4Transform3D& objectTransform)
1041 { 937 {
1042 DrawT (circle, objectTransform); 938 DrawT (circle, objectTransform);
1043 } 939 }
1044 940
1045 void G4VisManager::Draw (const G4Polyhedron& 941 void G4VisManager::Draw (const G4Polyhedron& polyhedron,
1046 const G4Transform3D& objectTransform) 942 const G4Transform3D& objectTransform)
1047 { 943 {
1048 DrawT (polyhedron, objectTransform); 944 DrawT (polyhedron, objectTransform);
1049 } 945 }
1050 946
1051 void G4VisManager::Draw (const G4Polyline& li 947 void G4VisManager::Draw (const G4Polyline& line,
1052 const G4Transform3D& objectTransform) 948 const G4Transform3D& objectTransform)
1053 { 949 {
1054 DrawT (line, objectTransform); 950 DrawT (line, objectTransform);
1055 } 951 }
1056 952
1057 void G4VisManager::Draw (const G4Polymarker& 953 void G4VisManager::Draw (const G4Polymarker& polymarker,
1058 const G4Transform3D& objectTransform) 954 const G4Transform3D& objectTransform)
1059 { 955 {
1060 DrawT (polymarker, objectTransform); 956 DrawT (polymarker, objectTransform);
1061 } 957 }
1062 958
>> 959 void G4VisManager::Draw (const G4Scale& scale,
>> 960 const G4Transform3D& objectTransform)
>> 961 {
>> 962 DrawT (scale, objectTransform);
>> 963 }
>> 964
1063 void G4VisManager::Draw (const G4Square& squa 965 void G4VisManager::Draw (const G4Square& square,
1064 const G4Transform3D& objectTransform) 966 const G4Transform3D& objectTransform)
1065 { 967 {
1066 DrawT (square, objectTransform); 968 DrawT (square, objectTransform);
1067 } 969 }
1068 970
1069 void G4VisManager::Draw (const G4Text& text, 971 void G4VisManager::Draw (const G4Text& text,
1070 const G4Transform3D& objectTransform) 972 const G4Transform3D& objectTransform)
1071 { 973 {
1072 DrawT (text, objectTransform); 974 DrawT (text, objectTransform);
1073 } 975 }
1074 976
1075 void G4VisManager::Draw2D (const G4Circle& ci 977 void G4VisManager::Draw2D (const G4Circle& circle,
1076 const G4Transform3D& objectTransform 978 const G4Transform3D& objectTransform)
1077 { 979 {
1078 DrawT2D (circle, objectTransform); 980 DrawT2D (circle, objectTransform);
1079 } 981 }
1080 982
1081 void G4VisManager::Draw2D (const G4Polyhedron 983 void G4VisManager::Draw2D (const G4Polyhedron& polyhedron,
1082 const G4Transform3D& objectTransform 984 const G4Transform3D& objectTransform)
1083 { 985 {
1084 DrawT2D (polyhedron, objectTransform); 986 DrawT2D (polyhedron, objectTransform);
1085 } 987 }
1086 988
1087 void G4VisManager::Draw2D (const G4Polyline& 989 void G4VisManager::Draw2D (const G4Polyline& line,
1088 const G4Transform3D& objectTransform 990 const G4Transform3D& objectTransform)
1089 { 991 {
1090 DrawT2D (line, objectTransform); 992 DrawT2D (line, objectTransform);
1091 } 993 }
1092 994
1093 void G4VisManager::Draw2D (const G4Polymarker 995 void G4VisManager::Draw2D (const G4Polymarker& polymarker,
1094 const G4Transform3D& objectTransform 996 const G4Transform3D& objectTransform)
1095 { 997 {
1096 DrawT2D (polymarker, objectTransform); 998 DrawT2D (polymarker, objectTransform);
1097 } 999 }
1098 1000
1099 void G4VisManager::Draw2D (const G4Square& sq 1001 void G4VisManager::Draw2D (const G4Square& square,
1100 const G4Transform3D& objectTransform 1002 const G4Transform3D& objectTransform)
1101 { 1003 {
1102 DrawT2D (square, objectTransform); 1004 DrawT2D (square, objectTransform);
1103 } 1005 }
1104 1006
1105 void G4VisManager::Draw2D (const G4Text& text 1007 void G4VisManager::Draw2D (const G4Text& text,
1106 const G4Transform3D& objectTransform 1008 const G4Transform3D& objectTransform)
1107 { 1009 {
1108 DrawT2D (text, objectTransform); 1010 DrawT2D (text, objectTransform);
1109 } 1011 }
1110 1012
1111 void G4VisManager::Draw (const G4VHit& hit) { 1013 void G4VisManager::Draw (const G4VHit& hit) {
>> 1014 #ifdef G4MULTITHREADED
1112 if (G4Threading::IsWorkerThread()) return; 1015 if (G4Threading::IsWorkerThread()) return;
1113 << 1016 #endif
1114 if (fIsDrawGroup) { 1017 if (fIsDrawGroup) {
1115 fpSceneHandler -> AddCompound (hit); 1018 fpSceneHandler -> AddCompound (hit);
1116 } else { 1019 } else {
1117 if (IsValidView ()) { 1020 if (IsValidView ()) {
1118 ClearTransientStoreIfMarked(); 1021 ClearTransientStoreIfMarked();
1119 fpSceneHandler -> AddCompound (hit); 1022 fpSceneHandler -> AddCompound (hit);
1120 } 1023 }
1121 } 1024 }
1122 } 1025 }
1123 1026
1124 void G4VisManager::Draw (const G4VDigi& digi) 1027 void G4VisManager::Draw (const G4VDigi& digi) {
>> 1028 #ifdef G4MULTITHREADED
1125 if (G4Threading::IsWorkerThread()) return; 1029 if (G4Threading::IsWorkerThread()) return;
1126 << 1030 #endif
1127 if (fIsDrawGroup) { 1031 if (fIsDrawGroup) {
1128 fpSceneHandler -> AddCompound (digi); 1032 fpSceneHandler -> AddCompound (digi);
1129 } else { 1033 } else {
1130 if (IsValidView ()) { 1034 if (IsValidView ()) {
1131 ClearTransientStoreIfMarked(); 1035 ClearTransientStoreIfMarked();
1132 fpSceneHandler -> AddCompound (digi); 1036 fpSceneHandler -> AddCompound (digi);
1133 } 1037 }
1134 } 1038 }
1135 } 1039 }
1136 1040
1137 void G4VisManager::Draw (const G4VTrajectory& 1041 void G4VisManager::Draw (const G4VTrajectory& traj) {
>> 1042 #ifdef G4MULTITHREADED
1138 if (G4Threading::IsWorkerThread()) return; 1043 if (G4Threading::IsWorkerThread()) return;
1139 << 1044 #endif
1140 // A trajectory needs a trajectories model 1045 // A trajectory needs a trajectories model to provide G4Atts, etc.
1141 static G4TrajectoriesModel trajectoriesMode 1046 static G4TrajectoriesModel trajectoriesModel;
1142 trajectoriesModel.SetCurrentTrajectory(&tra 1047 trajectoriesModel.SetCurrentTrajectory(&traj);
1143 G4RunManager* runManager = G4RunManagerFact << 1048 G4RunManager* runManager = G4RunManager::GetRunManager();
1144 const G4Run* currentRun = runManager->GetC << 1049 #ifdef G4MULTITHREADED
>> 1050 if (G4Threading::IsMultithreadedApplication()) {
>> 1051 runManager = G4MTRunManager::GetMasterRunManager();
>> 1052 }
>> 1053 #endif
>> 1054 const G4Run* currentRun = runManager->GetCurrentRun();
1145 if (currentRun) { 1055 if (currentRun) {
1146 trajectoriesModel.SetRunID(currentRun->Ge 1056 trajectoriesModel.SetRunID(currentRun->GetRunID());
1147 } 1057 }
1148 const G4Event* currentEvent = 1058 const G4Event* currentEvent =
1149 G4EventManager::GetEventManager()->GetConst 1059 G4EventManager::GetEventManager()->GetConstCurrentEvent();
1150 if (currentEvent) { 1060 if (currentEvent) {
1151 trajectoriesModel.SetEventID(currentEvent 1061 trajectoriesModel.SetEventID(currentEvent->GetEventID());
1152 } 1062 }
1153 if (fIsDrawGroup) { 1063 if (fIsDrawGroup) {
1154 fpSceneHandler -> SetModel (&trajectories 1064 fpSceneHandler -> SetModel (&trajectoriesModel);
1155 fpSceneHandler -> AddCompound (traj); 1065 fpSceneHandler -> AddCompound (traj);
1156 fpSceneHandler -> SetModel (0); 1066 fpSceneHandler -> SetModel (0);
1157 } else { 1067 } else {
1158 if (IsValidView ()) { 1068 if (IsValidView ()) {
1159 ClearTransientStoreIfMarked(); 1069 ClearTransientStoreIfMarked();
1160 fpSceneHandler -> SetModel (&trajectori 1070 fpSceneHandler -> SetModel (&trajectoriesModel);
1161 fpSceneHandler -> AddCompound (traj); 1071 fpSceneHandler -> AddCompound (traj);
1162 fpSceneHandler -> SetModel (0); 1072 fpSceneHandler -> SetModel (0);
1163 } 1073 }
1164 } 1074 }
1165 } 1075 }
1166 1076
1167 void G4VisManager::Draw (const G4LogicalVolum 1077 void G4VisManager::Draw (const G4LogicalVolume& logicalVol,
1168 const G4VisAttributes& attribs, 1078 const G4VisAttributes& attribs,
1169 const G4Transform3D& objectTransform) 1079 const G4Transform3D& objectTransform) {
>> 1080 #ifdef G4MULTITHREADED
1170 if (G4Threading::IsWorkerThread()) return; 1081 if (G4Threading::IsWorkerThread()) return;
1171 << 1082 #endif
1172 // Find corresponding solid. 1083 // Find corresponding solid.
1173 G4VSolid* pSol = logicalVol.GetSolid (); 1084 G4VSolid* pSol = logicalVol.GetSolid ();
1174 Draw (*pSol, attribs, objectTransform); 1085 Draw (*pSol, attribs, objectTransform);
1175 } 1086 }
1176 1087
1177 void G4VisManager::Draw (const G4VSolid& soli 1088 void G4VisManager::Draw (const G4VSolid& solid,
1178 const G4VisAttributes& attribs, 1089 const G4VisAttributes& attribs,
1179 const G4Transform3D& objectTransform) 1090 const G4Transform3D& objectTransform) {
>> 1091 #ifdef G4MULTITHREADED
1180 if (G4Threading::IsWorkerThread()) return; 1092 if (G4Threading::IsWorkerThread()) return;
1181 << 1093 #endif
1182 if (fIsDrawGroup) { 1094 if (fIsDrawGroup) {
1183 fpSceneHandler -> PreAddSolid (objectTran 1095 fpSceneHandler -> PreAddSolid (objectTransform, attribs);
1184 solid.DescribeYourselfTo (*fpSceneHandler 1096 solid.DescribeYourselfTo (*fpSceneHandler);
1185 fpSceneHandler -> PostAddSolid (); 1097 fpSceneHandler -> PostAddSolid ();
1186 } else { 1098 } else {
1187 if (IsValidView ()) { 1099 if (IsValidView ()) {
1188 ClearTransientStoreIfMarked(); 1100 ClearTransientStoreIfMarked();
1189 fpSceneHandler -> PreAddSolid (objectTr 1101 fpSceneHandler -> PreAddSolid (objectTransform, attribs);
1190 solid.DescribeYourselfTo (*fpSceneHandl 1102 solid.DescribeYourselfTo (*fpSceneHandler);
1191 fpSceneHandler -> PostAddSolid (); 1103 fpSceneHandler -> PostAddSolid ();
1192 } 1104 }
1193 } 1105 }
1194 } 1106 }
1195 1107
1196 void G4VisManager::Draw (const G4VPhysicalVol 1108 void G4VisManager::Draw (const G4VPhysicalVolume& physicalVol,
1197 const G4VisAttributes& attribs, 1109 const G4VisAttributes& attribs,
1198 const G4Transform3D& objectTransform) 1110 const G4Transform3D& objectTransform) {
>> 1111 #ifdef G4MULTITHREADED
1199 if (G4Threading::IsWorkerThread()) return; 1112 if (G4Threading::IsWorkerThread()) return;
1200 << 1113 #endif
1201 // Note: It is tempting to use a temporary 1114 // Note: It is tempting to use a temporary model here, as for
1202 // trajectories, in order to get at the G4A 1115 // trajectories, in order to get at the G4Atts of the physical
1203 // volume. I tried it (JA). But it's not 1116 // volume. I tried it (JA). But it's not easy to pass the
1204 // vis attributes. Also other aspects of t 1117 // vis attributes. Also other aspects of the model seem not to
1205 // be properly set up. So, the idea has be 1118 // be properly set up. So, the idea has been abandoned for the time
1206 // being. The model pointer will be null. 1119 // being. The model pointer will be null. So when picking there
1207 // will be no G4Atts from this physical vol 1120 // will be no G4Atts from this physical volume.
1208 // 1121 //
1209 // If this is called from DrawHit, for exam 1122 // If this is called from DrawHit, for example, the user may G4Atts to the
1210 // hit and these will be available with "/v 1123 // hit and these will be available with "/vis/scene/add/hits".
1211 // 1124 //
1212 // Find corresponding logical volume and so 1125 // Find corresponding logical volume and solid.
1213 G4LogicalVolume* pLV = physicalVol.GetLogi 1126 G4LogicalVolume* pLV = physicalVol.GetLogicalVolume ();
1214 G4VSolid* pSol = pLV -> GetSolid (); 1127 G4VSolid* pSol = pLV -> GetSolid ();
1215 Draw (*pSol, attribs, objectTransform); 1128 Draw (*pSol, attribs, objectTransform);
1216 } 1129 }
1217 1130
1218 void G4VisManager::DrawGeometry <<
1219 (G4VPhysicalVolume* v, const G4Transform3D& t <<
1220 // Draws a geometry tree starting at the spec <<
1221 { <<
1222 auto modelingParameters = fpSceneHandler->C <<
1223 auto depth = G4PhysicalVolumeModel::UNLIMIT <<
1224 const G4bool useFullExtent = true; <<
1225 G4PhysicalVolumeModel aPVModel(v,depth,t,mo <<
1226 aPVModel.DescribeYourselfTo(*fpSceneHandler <<
1227 delete modelingParameters; <<
1228 } <<
1229 <<
1230 void G4VisManager::CreateSceneHandler (const 1131 void G4VisManager::CreateSceneHandler (const G4String& name) {
1231 if (!fInitialised) Initialise (); 1132 if (!fInitialised) Initialise ();
1232 if (fpGraphicsSystem) { 1133 if (fpGraphicsSystem) {
1233 G4VSceneHandler* pSceneHandler = 1134 G4VSceneHandler* pSceneHandler =
1234 fpGraphicsSystem -> CreateSceneHandler 1135 fpGraphicsSystem -> CreateSceneHandler (name);
1235 if (pSceneHandler) { 1136 if (pSceneHandler) {
1236 fAvailableSceneHandlers.push_back (pSce 1137 fAvailableSceneHandlers.push_back (pSceneHandler);
1237 fpSceneHandler = pSceneHandler; 1138 fpSceneHandler = pSceneHandler; // Make current.
1238 } 1139 }
1239 else { 1140 else {
1240 if (fVerbosity >= errors) { 1141 if (fVerbosity >= errors) {
1241 G4warn << "ERROR in G4VisManager::CreateSce << 1142 G4cout << "ERROR in G4VisManager::CreateSceneHandler during "
1242 << fpGraphicsSystem -> GetName () 1143 << fpGraphicsSystem -> GetName ()
1243 << " scene handler creation.\n No a 1144 << " scene handler creation.\n No action taken."
1244 << G4endl; 1145 << G4endl;
1245 } 1146 }
1246 } 1147 }
1247 } 1148 }
1248 else PrintInvalidPointers (); 1149 else PrintInvalidPointers ();
1249 } 1150 }
1250 1151
1251 void G4VisManager::CreateViewer 1152 void G4VisManager::CreateViewer
1252 (const G4String& name, const G4String& XGeome 1153 (const G4String& name, const G4String& XGeometry)
1253 { 1154 {
1254 1155
1255 if (!fInitialised) Initialise (); 1156 if (!fInitialised) Initialise ();
1256 1157
1257 if (!fpSceneHandler) { 1158 if (!fpSceneHandler) {
1258 PrintInvalidPointers (); 1159 PrintInvalidPointers ();
1259 return; 1160 return;
1260 } 1161 }
1261 1162
1262 G4VViewer* p = fpGraphicsSystem -> CreateVi 1163 G4VViewer* p = fpGraphicsSystem -> CreateViewer (*fpSceneHandler, name);
1263 1164
1264 if (!p) { 1165 if (!p) {
1265 if (fVerbosity >= errors) { 1166 if (fVerbosity >= errors) {
1266 G4warn << "ERROR in G4VisManager::Creat << 1167 G4cerr << "ERROR in G4VisManager::CreateViewer: null pointer during "
1267 << fpGraphicsSystem -> GetName () 1168 << fpGraphicsSystem -> GetName ()
1268 << " viewer creation.\n No action tak 1169 << " viewer creation.\n No action taken."
1269 << G4endl; 1170 << G4endl;
1270 } 1171 }
1271 return; 1172 return;
1272 } 1173 }
1273 1174
1274 if (p -> GetViewId() < 0) { 1175 if (p -> GetViewId() < 0) {
1275 if (fVerbosity >= errors) { 1176 if (fVerbosity >= errors) {
1276 G4warn << "ERROR in G4VisManager::Creat << 1177 G4cerr << "ERROR in G4VisManager::CreateViewer during "
1277 << fpGraphicsSystem -> GetName () 1178 << fpGraphicsSystem -> GetName ()
1278 << " viewer instantiation.\n No actio 1179 << " viewer instantiation.\n No action taken."
1279 << G4endl; 1180 << G4endl;
1280 } 1181 }
1281 return; 1182 return;
1282 } 1183 }
1283 1184
1284 // Viewer is created, now we can set geomet 1185 // Viewer is created, now we can set geometry parameters
1285 // Before 12/2008, it was done in G4VViewer 1186 // Before 12/2008, it was done in G4VViewer.cc but it did not have to be there!
1286 1187
1287 G4ViewParameters initialvp = p -> GetViewPa 1188 G4ViewParameters initialvp = p -> GetViewParameters();
1288 initialvp.SetXGeometryString(XGeometry); // 1189 initialvp.SetXGeometryString(XGeometry); //parse string and store parameters
1289 p -> SetViewParameters(initialvp); 1190 p -> SetViewParameters(initialvp);
1290 p -> Initialise (); // (Viewer itself may 1191 p -> Initialise (); // (Viewer itself may change view parameters further.)
1291 if (p -> GetViewId() < 0) { 1192 if (p -> GetViewId() < 0) {
1292 if (fVerbosity >= errors) { 1193 if (fVerbosity >= errors) {
1293 G4warn << "ERROR in G4VisManager::Creat << 1194 G4cerr << "ERROR in G4VisManager::CreateViewer during "
1294 << fpGraphicsSystem -> GetName () 1195 << fpGraphicsSystem -> GetName ()
1295 << " viewer initialisation.\n No acti 1196 << " viewer initialisation.\n No action taken."
1296 << G4endl; 1197 << G4endl;
1297 } 1198 }
1298 return; 1199 return;
1299 } 1200 }
1300 1201
1301 fpViewer = p; / 1202 fpViewer = p; // Make current.
1302 fpSceneHandler -> AddViewerToList (fpViewer 1203 fpSceneHandler -> AddViewerToList (fpViewer);
1303 fpSceneHandler -> SetCurrentViewer (fpViewe 1204 fpSceneHandler -> SetCurrentViewer (fpViewer);
1304 if (fVerbosity >= confirmations) { 1205 if (fVerbosity >= confirmations) {
1305 G4cout << "G4VisManager::CreateViewer: ne 1206 G4cout << "G4VisManager::CreateViewer: new viewer created."
1306 << G4endl; 1207 << G4endl;
1307 } 1208 }
1308 1209
1309 const G4ViewParameters& vp = fpViewer->GetV 1210 const G4ViewParameters& vp = fpViewer->GetViewParameters();
1310 if (fVerbosity >= parameters) { 1211 if (fVerbosity >= parameters) {
1311 G4cout << " view parameters are:\n " << 1212 G4cout << " view parameters are:\n " << vp << G4endl;
1312 } 1213 }
1313 1214
1314 if (vp.IsCulling () && vp.IsCullingInvisibl 1215 if (vp.IsCulling () && vp.IsCullingInvisible ()) {
1315 static G4bool warned = false; 1216 static G4bool warned = false;
1316 if (fVerbosity >= confirmations) { 1217 if (fVerbosity >= confirmations) {
1317 if (!warned) { 1218 if (!warned) {
1318 G4cout << 1219 G4cout <<
1319 "NOTE: objects with visibility flag set to 1220 "NOTE: objects with visibility flag set to \"false\""
1320 " will not be drawn!" 1221 " will not be drawn!"
1321 "\n \"/vis/viewer/set/culling global false 1222 "\n \"/vis/viewer/set/culling global false\" to Draw such objects."
1322 "\n Also see other \"/vis/viewer/set\" com 1223 "\n Also see other \"/vis/viewer/set\" commands."
1323 << G4endl; 1224 << G4endl;
1324 warned = true; 1225 warned = true;
1325 } 1226 }
1326 } 1227 }
1327 } 1228 }
1328 if (vp.IsCullingCovered ()) { 1229 if (vp.IsCullingCovered ()) {
1329 static G4bool warned = false; 1230 static G4bool warned = false;
1330 if (fVerbosity >= warnings) { 1231 if (fVerbosity >= warnings) {
1331 if (!warned) { 1232 if (!warned) {
1332 G4warn << << 1233 G4cout <<
1333 "WARNING: covered objects in solid mode wil 1234 "WARNING: covered objects in solid mode will not be rendered!"
1334 "\n \"/vis/viewer/set/culling coveredDaugh 1235 "\n \"/vis/viewer/set/culling coveredDaughters false\" to reverse this."
1335 "\n Also see other \"/vis/viewer/set\" com 1236 "\n Also see other \"/vis/viewer/set\" commands."
1336 << G4endl; 1237 << G4endl;
1337 warned = true; 1238 warned = true;
1338 } 1239 }
1339 } 1240 }
1340 } 1241 }
1341 } 1242 }
1342 1243
1343 void G4VisManager::GeometryHasChanged () { 1244 void G4VisManager::GeometryHasChanged () {
1344 if (fVerbosity >= confirmations) { 1245 if (fVerbosity >= confirmations) {
1345 G4cout << "G4VisManager::GeometryHasChang 1246 G4cout << "G4VisManager::GeometryHasChanged() called." << G4endl;
1346 } 1247 }
1347 1248
1348 // Change the world... 1249 // Change the world...
1349 G4VPhysicalVolume* pWorld = 1250 G4VPhysicalVolume* pWorld =
1350 G4TransportationManager::GetTransportatio 1251 G4TransportationManager::GetTransportationManager ()
1351 -> GetNavigatorForTracking () -> GetWorld 1252 -> GetNavigatorForTracking () -> GetWorldVolume ();
1352 if (!pWorld) { 1253 if (!pWorld) {
1353 if (fVerbosity >= warnings) { 1254 if (fVerbosity >= warnings) {
1354 G4warn << "WARNING: There is no world v << 1255 G4cout << "WARNING: There is no world volume!" << G4endl;
1355 } 1256 }
1356 } 1257 }
1357 1258
1358 // Check scenes. 1259 // Check scenes.
1359 G4SceneList& sceneList = fSceneList; 1260 G4SceneList& sceneList = fSceneList;
1360 std::size_t iScene, nScenes = sceneList.siz << 1261 G4int iScene, nScenes = sceneList.size ();
1361 for (iScene = 0; iScene < nScenes; ++iScene << 1262 for (iScene = 0; iScene < nScenes; iScene++) {
1362 G4Scene* pScene = sceneList [iScene]; 1263 G4Scene* pScene = sceneList [iScene];
1363 std::vector<G4Scene::Model>& modelList = 1264 std::vector<G4Scene::Model>& modelList = pScene -> SetRunDurationModelList ();
1364 if (modelList.size ()) { 1265 if (modelList.size ()) {
1365 G4bool modelInvalid; 1266 G4bool modelInvalid;
1366 do { // Remove, if required, one at a 1267 do { // Remove, if required, one at a time.
1367 modelInvalid = false; 1268 modelInvalid = false;
1368 std::vector<G4Scene::Model>::iterator iterM 1269 std::vector<G4Scene::Model>::iterator iterModel;
1369 for (iterModel = modelList.begin(); 1270 for (iterModel = modelList.begin();
1370 iterModel != modelList.end(); 1271 iterModel != modelList.end();
1371 ++iterModel) { 1272 ++iterModel) {
1372 modelInvalid = !(iterModel->fpModel->Vali 1273 modelInvalid = !(iterModel->fpModel->Validate(fVerbosity>=warnings));
1373 if (modelInvalid) { 1274 if (modelInvalid) {
1374 // Model invalid - remove and break. 1275 // Model invalid - remove and break.
1375 if (fVerbosity >= warnings) { 1276 if (fVerbosity >= warnings) {
1376 G4warn << "WARNING: Model \"" << 1277 G4cout << "WARNING: Model \""
1377 << iterModel->fpModel->GetGlobalDesc 1278 << iterModel->fpModel->GetGlobalDescription ()
1378 << 1279 <<
1379 "\" is no longer valid - being removed\n 1280 "\" is no longer valid - being removed\n from scene \""
1380 << pScene -> GetName () << "\"" 1281 << pScene -> GetName () << "\""
1381 << G4endl; 1282 << G4endl;
1382 } 1283 }
1383 modelList.erase (iterModel); 1284 modelList.erase (iterModel);
1384 break; 1285 break;
1385 } 1286 }
1386 } 1287 }
1387 } while (modelInvalid); 1288 } while (modelInvalid);
1388 1289
1389 if (modelList.size () == 0) { 1290 if (modelList.size () == 0) {
1390 if (fVerbosity >= warnings) { 1291 if (fVerbosity >= warnings) {
1391 G4warn << "WARNING: No run-duration model << 1292 G4cout << "WARNING: No models left in this scene \""
1392 << pScene -> GetName () 1293 << pScene -> GetName ()
1393 << "\"." 1294 << "\"."
1394 << G4endl; 1295 << G4endl;
1395 } 1296 }
1396 if (pWorld) { <<
1397 if (fVerbosity >= warnings) { <<
1398 G4warn << " Adding current world <<
1399 << pScene -> GetName () <<
1400 << "\"." <<
1401 << G4endl; <<
1402 } <<
1403 pScene->AddRunDurationModel(new G4P <<
1404 // (The above includes a re-calcula <<
1405 G4UImanager::GetUIpointer () -> <<
1406 ApplyCommand (G4String("/vis/scene/ <<
1407 } <<
1408 } 1297 }
1409 else { 1298 else {
1410 pScene->CalculateExtent(); // Recalculate << 1299 pScene->CalculateExtent();
1411 G4UImanager::GetUIpointer () -> 1300 G4UImanager::GetUIpointer () ->
1412 ApplyCommand (G4String("/vis/scene/notify 1301 ApplyCommand (G4String("/vis/scene/notifyHandlers " + pScene->GetName()));
1413 } 1302 }
1414 } 1303 }
1415 } 1304 }
1416 1305
1417 // Check the manager's current scene... 1306 // Check the manager's current scene...
1418 if (fpScene && fpScene -> GetRunDurationMod 1307 if (fpScene && fpScene -> GetRunDurationModelList ().size () == 0) {
1419 if (fVerbosity >= warnings) { 1308 if (fVerbosity >= warnings) {
1420 G4warn << "WARNING: The current scene \ << 1309 G4cout << "WARNING: The current scene \""
1421 << fpScene -> GetName () 1310 << fpScene -> GetName ()
1422 << "\" has no run duration models." 1311 << "\" has no run duration models."
1423 << "\n Use \"/vis/scene/add/vol 1312 << "\n Use \"/vis/scene/add/volume\" or create a new scene."
1424 << G4endl; 1313 << G4endl;
1425 } 1314 }
1426 // Clean up << 1315 fpSceneHandler->ClearTransientStore();
1427 if (fpSceneHandler) { << 1316 fpSceneHandler->ClearStore();
1428 fpSceneHandler->ClearTransientStore(); << 1317 fpViewer->NeedKernelVisit();
1429 fpSceneHandler->ClearStore(); << 1318 fpViewer->SetView();
1430 if (fpViewer) { << 1319 fpViewer->ClearView();
1431 fpViewer->NeedKernelVisit(); << 1320 fpViewer->FinishView();
1432 fpViewer->SetView(); <<
1433 fpViewer->ClearView(); <<
1434 fpViewer->FinishView(); <<
1435 } <<
1436 } <<
1437 } 1321 }
1438 } 1322 }
1439 1323
1440 void G4VisManager::NotifyHandlers () { 1324 void G4VisManager::NotifyHandlers () {
1441 1325
1442 if (fVerbosity >= confirmations) { 1326 if (fVerbosity >= confirmations) {
1443 G4cout << "G4VisManager::NotifyHandler() 1327 G4cout << "G4VisManager::NotifyHandler() called." << G4endl;
1444 } 1328 }
1445 1329
1446 if (IsValidView()) { << 1330 // Check scenes.
1447 << 1331 G4SceneList& sceneList = fSceneList;
1448 // Check scenes. << 1332 G4int iScene, nScenes = sceneList.size ();
1449 G4SceneList& sceneList = fSceneList; << 1333 for (iScene = 0; iScene < nScenes; iScene++) {
1450 std::size_t iScene, nScenes = sceneList.s << 1334 G4Scene* pScene = sceneList [iScene];
1451 for (iScene = 0; iScene < nScenes; ++iSce << 1335 std::vector<G4Scene::Model>& modelList = pScene -> SetRunDurationModelList ();
1452 G4Scene* pScene = sceneList [iScene]; << 1336
1453 std::vector<G4Scene::Model>& modelList << 1337 if (modelList.size ()) {
1454 << 1338 pScene->CalculateExtent();
1455 if (modelList.size ()) { << 1339 G4UImanager::GetUIpointer () ->
1456 pScene->CalculateExtent(); <<
1457 G4UImanager::GetUIpointer () -> <<
1458 ApplyCommand (G4String("/vis/scene/no 1340 ApplyCommand (G4String("/vis/scene/notifyHandlers " + pScene->GetName()));
1459 } <<
1460 } 1341 }
>> 1342 }
1461 1343
1462 // Check the manager's current scene... << 1344 // Check the manager's current scene...
1463 if (fpScene && fpScene -> GetRunDurationM << 1345 if (fpScene && fpScene -> GetRunDurationModelList ().size () == 0) {
1464 if (fVerbosity >= warnings) { << 1346 if (fVerbosity >= warnings) {
1465 G4warn << "WARNING: The current scene << 1347 G4cout << "WARNING: The current scene \""
1466 << fpScene -> GetName () << 1348 << fpScene -> GetName ()
1467 << "\" has no run duration models." << 1349 << "\" has no run duration models."
1468 << "\n Use \"/vis/scene/add/volume\" << 1350 << "\n Use \"/vis/scene/add/volume\" or create a new scene."
1469 << G4endl; << 1351 << G4endl;
1470 } <<
1471 fpSceneHandler->ClearTransientStore(); <<
1472 fpSceneHandler->ClearStore(); <<
1473 fpViewer->NeedKernelVisit(); <<
1474 fpViewer->SetView(); <<
1475 fpViewer->ClearView(); <<
1476 fpViewer->FinishView(); <<
1477 } 1352 }
>> 1353 fpSceneHandler->ClearTransientStore();
>> 1354 fpSceneHandler->ClearStore();
>> 1355 fpViewer->NeedKernelVisit();
>> 1356 fpViewer->SetView();
>> 1357 fpViewer->ClearView();
>> 1358 fpViewer->FinishView();
1478 } 1359 }
1479 } 1360 }
1480 1361
1481 G4bool G4VisManager::FilterTrajectory(const G 1362 G4bool G4VisManager::FilterTrajectory(const G4VTrajectory& trajectory)
1482 { 1363 {
1483 return fpTrajFilterMgr->Accept(trajectory); 1364 return fpTrajFilterMgr->Accept(trajectory);
1484 } 1365 }
1485 1366
1486 G4bool G4VisManager::FilterHit(const G4VHit& 1367 G4bool G4VisManager::FilterHit(const G4VHit& hit)
1487 { 1368 {
1488 return fpHitFilterMgr->Accept(hit); 1369 return fpHitFilterMgr->Accept(hit);
1489 } 1370 }
1490 1371
1491 G4bool G4VisManager::FilterDigi(const G4VDigi 1372 G4bool G4VisManager::FilterDigi(const G4VDigi& digi)
1492 { 1373 {
1493 return fpDigiFilterMgr->Accept(digi); 1374 return fpDigiFilterMgr->Accept(digi);
1494 } 1375 }
1495 1376
1496 void G4VisManager::DispatchToModel(const G4VT 1377 void G4VisManager::DispatchToModel(const G4VTrajectory& trajectory)
1497 { 1378 {
1498 G4bool visible(true); 1379 G4bool visible(true);
1499 1380
1500 // See if trajectory passes filter 1381 // See if trajectory passes filter
1501 G4bool passed = FilterTrajectory(trajectory 1382 G4bool passed = FilterTrajectory(trajectory);
1502 1383
1503 if (!passed) { 1384 if (!passed) {
1504 // Draw invisible trajectory if trajector 1385 // Draw invisible trajectory if trajectory failed filter and
1505 // are filtering in soft mode 1386 // are filtering in soft mode
1506 if (fpTrajFilterMgr->GetMode() == FilterM 1387 if (fpTrajFilterMgr->GetMode() == FilterMode::Soft) visible = false;
1507 else {return;} 1388 else {return;}
1508 } 1389 }
1509 1390
1510 // Go on to draw trajectory 1391 // Go on to draw trajectory
1511 assert (0 != fpTrajDrawModelMgr); 1392 assert (0 != fpTrajDrawModelMgr);
1512 1393
1513 const G4VTrajectoryModel* trajectoryModel = 1394 const G4VTrajectoryModel* trajectoryModel = CurrentTrajDrawModel();
1514 1395
1515 assert (0 != trajectoryModel); // Should ex 1396 assert (0 != trajectoryModel); // Should exist
1516 1397
1517 if (IsValidView()) { 1398 if (IsValidView()) {
1518 trajectoryModel->Draw(trajectory, visib 1399 trajectoryModel->Draw(trajectory, visible);
1519 } 1400 }
1520 } 1401 }
1521 1402
>> 1403 void G4VisManager::SetUserAction
>> 1404 (G4VUserVisAction* pVisAction,
>> 1405 const G4VisExtent& extent) {
>> 1406 if (fVerbosity >= warnings) {
>> 1407 G4cout <<
>> 1408 "WARNING: SetUserAction is deprecated. Use RegisterRunDurationUserVisAction."
>> 1409 << G4endl;
>> 1410 }
>> 1411 RegisterRunDurationUserVisAction("SetUserAction",pVisAction,extent);
>> 1412 }
>> 1413
1522 void G4VisManager::RegisterRunDurationUserVis 1414 void G4VisManager::RegisterRunDurationUserVisAction
1523 (const G4String& name, 1415 (const G4String& name,
1524 G4VUserVisAction* pVisAction, 1416 G4VUserVisAction* pVisAction,
1525 const G4VisExtent& extent) { 1417 const G4VisExtent& extent) {
1526 fRunDurationUserVisActions.push_back(UserVi 1418 fRunDurationUserVisActions.push_back(UserVisAction(name,pVisAction));
1527 if (extent.GetExtentRadius() > 0.) { 1419 if (extent.GetExtentRadius() > 0.) {
1528 fUserVisActionExtents[pVisAction] = exten 1420 fUserVisActionExtents[pVisAction] = extent;
1529 } else { 1421 } else {
1530 if (fVerbosity >= warnings) { 1422 if (fVerbosity >= warnings) {
1531 G4warn << << 1423 G4cout <<
1532 "WARNING: No extent set for user vis action 1424 "WARNING: No extent set for user vis action \"" << name << "\"."
1533 << G4endl; 1425 << G4endl;
1534 } 1426 }
1535 } 1427 }
1536 if (fVerbosity >= confirmations) { 1428 if (fVerbosity >= confirmations) {
1537 G4cout 1429 G4cout
1538 << "Run duration user vis action \"" << n 1430 << "Run duration user vis action \"" << name << "\" registered"
1539 << G4endl; 1431 << G4endl;
1540 } 1432 }
1541 } 1433 }
1542 1434
1543 void G4VisManager::RegisterEndOfEventUserVisA 1435 void G4VisManager::RegisterEndOfEventUserVisAction
1544 (const G4String& name, 1436 (const G4String& name,
1545 G4VUserVisAction* pVisAction, 1437 G4VUserVisAction* pVisAction,
1546 const G4VisExtent& extent) { 1438 const G4VisExtent& extent) {
1547 fEndOfEventUserVisActions.push_back(UserVis 1439 fEndOfEventUserVisActions.push_back(UserVisAction(name,pVisAction));
1548 if (extent.GetExtentRadius() > 0.) { 1440 if (extent.GetExtentRadius() > 0.) {
1549 fUserVisActionExtents[pVisAction] = exten 1441 fUserVisActionExtents[pVisAction] = extent;
1550 } else { 1442 } else {
1551 if (fVerbosity >= warnings) { 1443 if (fVerbosity >= warnings) {
1552 G4warn << << 1444 G4cout <<
1553 "WARNING: No extent set for user vis action 1445 "WARNING: No extent set for user vis action \"" << name << "\"."
1554 << G4endl; 1446 << G4endl;
1555 } 1447 }
1556 } 1448 }
1557 if (fVerbosity >= confirmations) { 1449 if (fVerbosity >= confirmations) {
1558 G4cout 1450 G4cout
1559 << "End of event user vis action \"" << n 1451 << "End of event user vis action \"" << name << "\" registered"
1560 << G4endl; 1452 << G4endl;
1561 } 1453 }
1562 } 1454 }
1563 1455
1564 void G4VisManager::RegisterEndOfRunUserVisAct 1456 void G4VisManager::RegisterEndOfRunUserVisAction
1565 (const G4String& name, 1457 (const G4String& name,
1566 G4VUserVisAction* pVisAction, 1458 G4VUserVisAction* pVisAction,
1567 const G4VisExtent& extent) { 1459 const G4VisExtent& extent) {
1568 fEndOfRunUserVisActions.push_back(UserVisAc 1460 fEndOfRunUserVisActions.push_back(UserVisAction(name,pVisAction));
1569 if (extent.GetExtentRadius() > 0.) { 1461 if (extent.GetExtentRadius() > 0.) {
1570 fUserVisActionExtents[pVisAction] = exten 1462 fUserVisActionExtents[pVisAction] = extent;
1571 } else { 1463 } else {
1572 if (fVerbosity >= warnings) { 1464 if (fVerbosity >= warnings) {
1573 G4warn << << 1465 G4cout <<
1574 "WARNING: No extent set for user vis action 1466 "WARNING: No extent set for user vis action \"" << name << "\"."
1575 << G4endl; 1467 << G4endl;
1576 } 1468 }
1577 } 1469 }
1578 if (fVerbosity >= confirmations) { 1470 if (fVerbosity >= confirmations) {
1579 G4cout 1471 G4cout
1580 << "End of run user vis action \"" << nam 1472 << "End of run user vis action \"" << name << "\" registered"
1581 << G4endl; 1473 << G4endl;
1582 } 1474 }
1583 } 1475 }
1584 1476
1585 void G4VisManager::SetCurrentScene (G4Scene* 1477 void G4VisManager::SetCurrentScene (G4Scene* pScene) {
1586 if (pScene != fpScene) { 1478 if (pScene != fpScene) {
1587 // A change of scene. Therefore reset tr 1479 // A change of scene. Therefore reset transients drawn flags. All
1588 // memory of previous transient proceessi 1480 // memory of previous transient proceessing thereby erased...
1589 ResetTransientsDrawnFlags(); 1481 ResetTransientsDrawnFlags();
1590 } 1482 }
1591 fpScene = pScene; 1483 fpScene = pScene;
1592 } 1484 }
1593 1485
1594 void G4VisManager::SetCurrentGraphicsSystem ( 1486 void G4VisManager::SetCurrentGraphicsSystem (G4VGraphicsSystem* pSystem) {
1595 fpGraphicsSystem = pSystem; 1487 fpGraphicsSystem = pSystem;
1596 if (fVerbosity >= confirmations) { 1488 if (fVerbosity >= confirmations) {
1597 G4cout << "G4VisManager::SetCurrentGraphi 1489 G4cout << "G4VisManager::SetCurrentGraphicsSystem: system now "
1598 << pSystem -> GetName () << G4endl; 1490 << pSystem -> GetName () << G4endl;
1599 } 1491 }
1600 // If current scene handler is of same grap 1492 // If current scene handler is of same graphics system, leave unchanged.
1601 // Else find the most recent scene handler 1493 // Else find the most recent scene handler of same graphics system.
1602 // Or clear pointers. 1494 // Or clear pointers.
1603 if (!(fpSceneHandler && fpSceneHandler -> G 1495 if (!(fpSceneHandler && fpSceneHandler -> GetGraphicsSystem () == pSystem)) {
1604 const G4SceneHandlerList& sceneHandlerLis 1496 const G4SceneHandlerList& sceneHandlerList = fAvailableSceneHandlers;
1605 G4int nSH = (G4int)sceneHandlerList.size << 1497 G4int nSH = sceneHandlerList.size (); // No. of scene handlers.
1606 G4int iSH; 1498 G4int iSH;
1607 for (iSH = nSH - 1; iSH >= 0; iSH--) { 1499 for (iSH = nSH - 1; iSH >= 0; iSH--) {
1608 if (sceneHandlerList [iSH] -> GetGraphi 1500 if (sceneHandlerList [iSH] -> GetGraphicsSystem () == pSystem) break;
1609 } 1501 }
1610 if (iSH >= 0) { 1502 if (iSH >= 0) {
1611 fpSceneHandler = sceneHandlerList [iSH] 1503 fpSceneHandler = sceneHandlerList [iSH];
1612 if (fVerbosity >= confirmations) { 1504 if (fVerbosity >= confirmations) {
1613 G4cout << " Scene Handler now " 1505 G4cout << " Scene Handler now "
1614 << fpSceneHandler -> GetName () << G 1506 << fpSceneHandler -> GetName () << G4endl;
1615 } 1507 }
1616 if (fpScene != fpSceneHandler -> GetSce 1508 if (fpScene != fpSceneHandler -> GetScene ()) {
1617 fpScene = fpSceneHandler -> GetScene (); 1509 fpScene = fpSceneHandler -> GetScene ();
1618 if (fVerbosity >= confirmations) { 1510 if (fVerbosity >= confirmations) {
1619 G4cout << " Scene now \"" 1511 G4cout << " Scene now \""
1620 << fpScene -> GetName () << "\"" << G4en 1512 << fpScene -> GetName () << "\"" << G4endl;
1621 } 1513 }
1622 } 1514 }
1623 const G4ViewerList& viewerList = fpScen 1515 const G4ViewerList& viewerList = fpSceneHandler -> GetViewerList ();
1624 if (viewerList.size ()) { 1516 if (viewerList.size ()) {
1625 fpViewer = viewerList [0]; 1517 fpViewer = viewerList [0];
1626 if (fVerbosity >= confirmations) { 1518 if (fVerbosity >= confirmations) {
1627 G4cout << " Viewer now " << fpViewer -> 1519 G4cout << " Viewer now " << fpViewer -> GetName () << G4endl;
1628 } 1520 }
1629 } 1521 }
1630 else { 1522 else {
1631 fpViewer = 0; 1523 fpViewer = 0;
1632 } 1524 }
1633 } 1525 }
1634 else { 1526 else {
1635 fpSceneHandler = 0; 1527 fpSceneHandler = 0;
1636 fpViewer = 0; 1528 fpViewer = 0;
1637 } 1529 }
1638 } 1530 }
1639 } 1531 }
1640 1532
1641 void G4VisManager::SetCurrentSceneHandler (G4 1533 void G4VisManager::SetCurrentSceneHandler (G4VSceneHandler* pSceneHandler) {
1642 fpSceneHandler = pSceneHandler; 1534 fpSceneHandler = pSceneHandler;
1643 if (fVerbosity >= confirmations) { 1535 if (fVerbosity >= confirmations) {
1644 G4cout << "G4VisManager::SetCurrentSceneH 1536 G4cout << "G4VisManager::SetCurrentSceneHandler: scene handler now \""
1645 << pSceneHandler -> GetName () << "\"" < 1537 << pSceneHandler -> GetName () << "\"" << G4endl;
1646 } 1538 }
1647 if (fpScene != fpSceneHandler -> GetScene ( 1539 if (fpScene != fpSceneHandler -> GetScene ()) {
1648 fpScene = fpSceneHandler -> GetScene (); 1540 fpScene = fpSceneHandler -> GetScene ();
1649 if (fVerbosity >= confirmations) { 1541 if (fVerbosity >= confirmations) {
1650 G4cout << " Scene now \"" 1542 G4cout << " Scene now \""
1651 << fpScene -> GetName () << "\"" << G4 1543 << fpScene -> GetName () << "\"" << G4endl;
1652 } 1544 }
1653 } 1545 }
1654 if (fpGraphicsSystem != pSceneHandler -> Ge 1546 if (fpGraphicsSystem != pSceneHandler -> GetGraphicsSystem ()) {
1655 fpGraphicsSystem = pSceneHandler -> GetGr 1547 fpGraphicsSystem = pSceneHandler -> GetGraphicsSystem ();
1656 if (fVerbosity >= confirmations) { 1548 if (fVerbosity >= confirmations) {
1657 G4cout << " Graphics system now \"" 1549 G4cout << " Graphics system now \""
1658 << fpGraphicsSystem -> GetName () << " 1550 << fpGraphicsSystem -> GetName () << "\"" << G4endl;
1659 } 1551 }
1660 } 1552 }
1661 const G4ViewerList& viewerList = fpSceneHan 1553 const G4ViewerList& viewerList = fpSceneHandler -> GetViewerList ();
1662 std::size_t nViewers = viewerList.size (); << 1554 G4int nViewers = viewerList.size ();
1663 if (nViewers) { 1555 if (nViewers) {
1664 std::size_t iViewer; << 1556 G4int iViewer;
1665 for (iViewer = 0; iViewer < nViewers; ++i << 1557 for (iViewer = 0; iViewer < nViewers; iViewer++) {
1666 if (fpViewer == viewerList [iViewer]) b 1558 if (fpViewer == viewerList [iViewer]) break;
1667 } 1559 }
1668 if (iViewer >= nViewers) { 1560 if (iViewer >= nViewers) {
1669 fpViewer = viewerList [0]; 1561 fpViewer = viewerList [0];
1670 if (fVerbosity >= confirmations) { 1562 if (fVerbosity >= confirmations) {
1671 G4cout << " Viewer now \"" << fpViewer -> 1563 G4cout << " Viewer now \"" << fpViewer -> GetName () << "\""
1672 << G4endl; 1564 << G4endl;
1673 } 1565 }
1674 } 1566 }
1675 if (!IsValidView ()) { 1567 if (!IsValidView ()) {
1676 if (fVerbosity >= warnings) { 1568 if (fVerbosity >= warnings) {
1677 G4warn << << 1569 G4cout <<
1678 "WARNING: Problem setting scene handler - p 1570 "WARNING: Problem setting scene handler - please report circumstances."
1679 << G4endl; 1571 << G4endl;
1680 } 1572 }
1681 } 1573 }
1682 } 1574 }
1683 else { 1575 else {
1684 fpViewer = 0; 1576 fpViewer = 0;
1685 if (fVerbosity >= warnings) { 1577 if (fVerbosity >= warnings) {
1686 G4warn << << 1578 G4cout <<
1687 "WARNING: No viewers for this scene handler 1579 "WARNING: No viewers for this scene handler - please create one."
1688 << G4endl; 1580 << G4endl;
1689 } 1581 }
1690 } 1582 }
1691 } 1583 }
1692 1584
1693 void G4VisManager::SetCurrentViewer (G4VViewe 1585 void G4VisManager::SetCurrentViewer (G4VViewer* pViewer) {
1694 fpViewer = pViewer; 1586 fpViewer = pViewer;
1695 if (fpViewer == nullptr) { <<
1696 if (fVerbosity >= confirmations) { <<
1697 G4cout << "G4VisManager::SetCurrentView <<
1698 << G4endl; <<
1699 } <<
1700 return; <<
1701 } <<
1702 if (fVerbosity >= confirmations) { 1587 if (fVerbosity >= confirmations) {
1703 G4cout << "G4VisManager::SetCurrentViewer 1588 G4cout << "G4VisManager::SetCurrentViewer: viewer now "
1704 << pViewer -> GetName () 1589 << pViewer -> GetName ()
1705 << G4endl; 1590 << G4endl;
1706 } 1591 }
1707 fpSceneHandler = fpViewer -> GetSceneHandle 1592 fpSceneHandler = fpViewer -> GetSceneHandler ();
1708 if (!fpSceneHandler) { 1593 if (!fpSceneHandler) {
1709 if (fVerbosity >= warnings) { 1594 if (fVerbosity >= warnings) {
1710 G4warn << << 1595 G4cout <<
1711 "WARNING: No scene handler for this vie 1596 "WARNING: No scene handler for this viewer - please create one."
1712 << G4endl; 1597 << G4endl;
1713 } 1598 }
1714 return; 1599 return;
1715 } 1600 }
1716 // JA: I don't think we need this. Setview << 1601 fpViewer->SetView();
1717 // fpViewer->SetView(); <<
1718 fpSceneHandler -> SetCurrentViewer (pViewer 1602 fpSceneHandler -> SetCurrentViewer (pViewer);
1719 fpScene = fpSceneHandler -> GetScene (); 1603 fpScene = fpSceneHandler -> GetScene ();
1720 fpGraphicsSystem = fpSceneHandler -> GetGra 1604 fpGraphicsSystem = fpSceneHandler -> GetGraphicsSystem ();
1721 if (!IsValidView ()) { 1605 if (!IsValidView ()) {
1722 if (fVerbosity >= warnings) { 1606 if (fVerbosity >= warnings) {
1723 G4warn << << 1607 G4cout <<
1724 "WARNING: Problem setting viewer - please r 1608 "WARNING: Problem setting viewer - please report circumstances."
1725 << G4endl; 1609 << G4endl;
1726 } 1610 }
1727 } 1611 }
1728 } 1612 }
1729 1613
1730 void G4VisManager::PrintAvailableGraphicsSyst << 1614 void G4VisManager::PrintAvailableGraphicsSystems (Verbosity verbosity) const
1731 (Verbosity verbosity, std::ostream& out) cons <<
1732 { 1615 {
1733 out << "Registered graphics systems are:\n" << 1616 G4cout << "Current available graphics systems are:\n";
1734 if (fAvailableGraphicsSystems.size ()) { 1617 if (fAvailableGraphicsSystems.size ()) {
1735 for (const auto& gs: fAvailableGraphicsSy 1618 for (const auto& gs: fAvailableGraphicsSystems) {
1736 const G4String& name = gs->GetName(); 1619 const G4String& name = gs->GetName();
1737 const std::vector<G4String>& nicknames 1620 const std::vector<G4String>& nicknames = gs->GetNicknames();
1738 if (verbosity >= warnings) { << 1621 if (verbosity <= warnings) {
1739 // Brief output 1622 // Brief output
1740 out << " " << name << " ("; << 1623 G4cout << name << " (";
1741 for (std::size_t i = 0; i < nicknames << 1624 for (size_t i = 0; i < nicknames.size(); ++i) {
1742 if (i != 0) { 1625 if (i != 0) {
1743 out << ", "; << 1626 G4cout << ", ";
1744 } 1627 }
1745 out << nicknames[i]; << 1628 G4cout << nicknames[i];
1746 } 1629 }
1747 out << ')'; << 1630 G4cout << ')';
1748 } else { 1631 } else {
1749 // Full output 1632 // Full output
1750 out << *gs; << 1633 G4cout << *gs;
1751 } 1634 }
1752 out << std::endl; << 1635 G4cout << G4endl;
1753 } 1636 }
1754 out << <<
1755 "You may choose a graphics system (driver <<
1756 "\nthe command \"/vis/open\" or \"/vis/sc <<
1757 "\nor you may omit the driver parameter a <<
1758 "\n- by argument in the construction of G <<
1759 "\n- by environment variable \"G4VIS_DEFA <<
1760 "\n- by entry in \"~/.g4session\";" <<
1761 "\n- by build flags." <<
1762 "\n- Note: This feature is not allowed in <<
1763 "\nFor further information see \"examples <<
1764 "\nand \"vis.mac\"." <<
1765 << std::endl; <<
1766 } else { 1637 } else {
1767 out << " NONE!!! None registered - yet! << 1638 G4cout << "\n NONE!!! None registered - yet! Mmmmm!" << G4endl;
1768 } 1639 }
1769 } 1640 }
1770 1641
1771 void G4VisManager::PrintAvailableModels (Verb 1642 void G4VisManager::PrintAvailableModels (Verbosity verbosity) const
1772 { 1643 {
1773 { 1644 {
1774 //fpTrajDrawModelMgr->Print(G4cout); 1645 //fpTrajDrawModelMgr->Print(G4cout);
1775 G4cout << "Registered model factories:" < 1646 G4cout << "Registered model factories:" << G4endl;
1776 const std::vector<G4VModelFactory<G4VTraj 1647 const std::vector<G4VModelFactory<G4VTrajectoryModel>*>& factoryList =
1777 fpTrajDrawModelMgr->FactoryList(); 1648 fpTrajDrawModelMgr->FactoryList();
1778 if (factoryList.empty()) G4cout << " Non 1649 if (factoryList.empty()) G4cout << " None" << G4endl;
1779 else { 1650 else {
1780 std::vector<G4VModelFactory<G4VTrajecto 1651 std::vector<G4VModelFactory<G4VTrajectoryModel>*>::const_iterator i;
1781 for (i = factoryList.begin(); i != fact << 1652 for (i = factoryList.begin(); i != factoryList.end(); ++i)
1782 (*i)->Print(G4cout); << 1653 (*i)->Print(G4cout);
1783 } <<
1784 } 1654 }
1785 G4cout << "\nRegistered models:" << G4end <<
1786 const G4VisListManager<G4VTrajectoryModel 1655 const G4VisListManager<G4VTrajectoryModel>* listManager =
1787 fpTrajDrawModelMgr->ListManager(); 1656 fpTrajDrawModelMgr->ListManager();
1788 const std::map<G4String, G4VTrajectoryMod 1657 const std::map<G4String, G4VTrajectoryModel*>& modelMap =
1789 listManager->Map(); 1658 listManager->Map();
1790 if (modelMap.empty()) G4cout << " None" << 1659 if (!modelMap.empty()) {
1791 else { << 1660 G4cout << "\nRegistered models:" << G4endl;
1792 std::map<G4String, G4VTrajectoryModel*> 1661 std::map<G4String, G4VTrajectoryModel*>::const_iterator i;
1793 for (i = modelMap.begin(); i != modelMa 1662 for (i = modelMap.begin(); i != modelMap.end(); ++i) {
1794 G4cout << " " << i->second->Name(); 1663 G4cout << " " << i->second->Name();
1795 if (i->second == listManager->Current()) G4 1664 if (i->second == listManager->Current()) G4cout << " (Current)";
1796 G4cout << G4endl; 1665 G4cout << G4endl;
1797 if (verbosity >= parameters) i->second->Pri 1666 if (verbosity >= parameters) i->second->Print(G4cout);
1798 } 1667 }
1799 } 1668 }
1800 } 1669 }
1801 1670
1802 G4cout << G4endl; 1671 G4cout << G4endl;
1803 1672
1804 { 1673 {
1805 //fpTrajFilterMgr->Print(G4cout); 1674 //fpTrajFilterMgr->Print(G4cout);
1806 G4cout << "Registered filter factories:" 1675 G4cout << "Registered filter factories:" << G4endl;
1807 const std::vector<G4VModelFactory<G4VFilt 1676 const std::vector<G4VModelFactory<G4VFilter<G4VTrajectory> >*>&
1808 factoryList = fpTrajFilterMgr->FactoryL 1677 factoryList = fpTrajFilterMgr->FactoryList();
1809 if (factoryList.empty()) G4cout << " Non 1678 if (factoryList.empty()) G4cout << " None" << G4endl;
1810 else { 1679 else {
1811 std::vector<G4VModelFactory<G4VFilter<G 1680 std::vector<G4VModelFactory<G4VFilter<G4VTrajectory> >*>::const_iterator i;
1812 for (i = factoryList.begin(); i != fact << 1681 for (i = factoryList.begin(); i != factoryList.end(); ++i)
1813 (*i)->Print(G4cout); << 1682 (*i)->Print(G4cout);
1814 } <<
1815 } 1683 }
1816 <<
1817 G4cout << "\nRegistered filters:" << G4en <<
1818 const std::vector<G4VFilter<G4VTrajectory 1684 const std::vector<G4VFilter<G4VTrajectory>*>&
1819 filterList = fpTrajFilterMgr->FilterLis 1685 filterList = fpTrajFilterMgr->FilterList();
1820 if (filterList.empty()) G4cout << " None << 1686 if (!filterList.empty()) {
1821 else { << 1687 G4cout << "\nRegistered filters:" << G4endl;
1822 std::vector<G4VFilter<G4VTrajectory>*>: 1688 std::vector<G4VFilter<G4VTrajectory>*>::const_iterator i;
1823 for (i = filterList.begin(); i != filte 1689 for (i = filterList.begin(); i != filterList.end(); ++i) {
1824 G4cout << " " << (*i)->GetName() << G4endl 1690 G4cout << " " << (*i)->GetName() << G4endl;
1825 if (verbosity >= parameters) (*i)->PrintAll 1691 if (verbosity >= parameters) (*i)->PrintAll(G4cout);
1826 } 1692 }
1827 } 1693 }
1828 } 1694 }
1829 } 1695 }
1830 1696
1831 void G4VisManager::PrintAvailableUserVisActio 1697 void G4VisManager::PrintAvailableUserVisActions (Verbosity) const
1832 { 1698 {
1833 G4cout << 1699 G4cout <<
1834 "You have successfully registered the fol 1700 "You have successfully registered the following user vis actions."
1835 << G4endl; 1701 << G4endl;
1836 G4cout << "Run Duration User Vis Actions:"; 1702 G4cout << "Run Duration User Vis Actions:";
1837 if (fRunDurationUserVisActions.empty()) G4c 1703 if (fRunDurationUserVisActions.empty()) G4cout << " none" << G4endl;
1838 else { 1704 else {
1839 G4cout << G4endl; 1705 G4cout << G4endl;
1840 for (std::size_t i = 0; i < fRunDurationU << 1706 for (size_t i = 0; i < fRunDurationUserVisActions.size(); i++) {
1841 const G4String& name = fRunDurationUser 1707 const G4String& name = fRunDurationUserVisActions[i].fName;
1842 G4cout << " " << name << G4endl; 1708 G4cout << " " << name << G4endl;
1843 } 1709 }
1844 } 1710 }
1845 1711
1846 G4cout << "End of Event User Vis Actions:"; 1712 G4cout << "End of Event User Vis Actions:";
1847 if (fEndOfEventUserVisActions.empty()) G4co 1713 if (fEndOfEventUserVisActions.empty()) G4cout << " none" << G4endl;
1848 else { 1714 else {
1849 G4cout << G4endl; 1715 G4cout << G4endl;
1850 for (std::size_t i = 0; i < fEndOfEventUs << 1716 for (size_t i = 0; i < fEndOfEventUserVisActions.size(); i++) {
1851 const G4String& name = fEndOfEventUserV 1717 const G4String& name = fEndOfEventUserVisActions[i].fName;
1852 G4cout << " " << name << G4endl; 1718 G4cout << " " << name << G4endl;
1853 } 1719 }
1854 } 1720 }
1855 1721
1856 G4cout << "End of Run User Vis Actions:"; 1722 G4cout << "End of Run User Vis Actions:";
1857 if (fEndOfRunUserVisActions.empty()) G4cout 1723 if (fEndOfRunUserVisActions.empty()) G4cout << " none" << G4endl;
1858 else { 1724 else {
1859 G4cout << G4endl; 1725 G4cout << G4endl;
1860 for (std::size_t i = 0; i < fEndOfRunUser << 1726 for (size_t i = 0; i < fEndOfRunUserVisActions.size(); i++) {
1861 const G4String& name = fEndOfRunUserVis 1727 const G4String& name = fEndOfRunUserVisActions[i].fName;
1862 G4cout << " " << name << G4endl; 1728 G4cout << " " << name << G4endl;
1863 } 1729 }
1864 } 1730 }
1865 } 1731 }
1866 1732
1867 void G4VisManager::PrintAvailableColours (Ver 1733 void G4VisManager::PrintAvailableColours (Verbosity) const {
1868 G4cout << 1734 G4cout <<
1869 "Some /vis commands (optionally) take a str << 1735 "Some /vis commands (optionally) take a string to specify colour."
1870 "\nThey are also available in your C++ code << 1736 "\nAvailable colours:\n ";
1871 "\n G4Colour niceColour; // Default - whi << 1737 const std::map<G4String, G4Colour>& map = G4Colour::GetMap();
1872 "\n G4Colour::GetColour(\"pink\", niceColo << 1738 for (std::map<G4String, G4Colour>::const_iterator i = map.begin();
1873 "\n logical->SetVisAttributes(niceColour); << 1739 i != map.end();) {
1874 "\nSee G4Colour.hh." << 1740 G4cout << i->first;
1875 "\nAvailable colours"; << 1741 if (++i != map.end()) G4cout << ", ";
1876 for (const auto& i: G4Colour::GetMap()) { <<
1877 G4cout << ", " << i.first; <<
1878 } 1742 }
1879 G4cout << G4endl; 1743 G4cout << G4endl;
1880 } 1744 }
1881 1745
1882 void G4VisManager::PrintInvalidPointers () co 1746 void G4VisManager::PrintInvalidPointers () const {
1883 if (fVerbosity >= errors) { 1747 if (fVerbosity >= errors) {
1884 G4warn << "ERROR: G4VisManager::PrintInva << 1748 G4cerr << "ERROR: G4VisManager::PrintInvalidPointers:";
1885 if (!fpGraphicsSystem) { 1749 if (!fpGraphicsSystem) {
1886 G4warn << "\n null graphics system poin << 1750 G4cerr << "\n null graphics system pointer.";
1887 } 1751 }
1888 else { 1752 else {
1889 G4warn << "\n Graphics system is " << << 1753 G4cerr << "\n Graphics system is " << fpGraphicsSystem -> GetName ()
1890 << " but:"; 1754 << " but:";
1891 if (!fpScene) 1755 if (!fpScene)
1892 G4warn << << 1756 G4cerr <<
1893 "\n Null scene pointer. Use \"/vis/drawV 1757 "\n Null scene pointer. Use \"/vis/drawVolume\" or"
1894 " \"/vis/scene/create\"."; 1758 " \"/vis/scene/create\".";
1895 if (!fpSceneHandler) 1759 if (!fpSceneHandler)
1896 G4warn << << 1760 G4cerr <<
1897 "\n Null scene handler pointer. Use \"/v 1761 "\n Null scene handler pointer. Use \"/vis/open\" or"
1898 " \"/vis/sceneHandler/create\"."; 1762 " \"/vis/sceneHandler/create\".";
1899 if (!fpViewer ) 1763 if (!fpViewer )
1900 G4warn << << 1764 G4cerr <<
1901 "\n Null viewer pointer. Use \"/vis/view 1765 "\n Null viewer pointer. Use \"/vis/viewer/create\".";
1902 } 1766 }
1903 G4warn << G4endl; << 1767 G4cerr << G4endl;
1904 } 1768 }
1905 } 1769 }
1906 1770
>> 1771 #ifdef G4MULTITHREADED
>> 1772
>> 1773 namespace {
>> 1774 G4bool mtRunInProgress = false;
>> 1775 std::deque<const G4Event*> mtVisEventQueue;
>> 1776 G4Thread* mtVisSubThread = 0;
>> 1777 G4Mutex mtVisSubThreadMutex = G4MUTEX_INITIALIZER;
>> 1778 }
1907 1779
1908 G4ThreadFunReturnType G4VisManager::G4VisSubT 1780 G4ThreadFunReturnType G4VisManager::G4VisSubThread(G4ThreadFunArgType p)
1909 { 1781 {
1910 #ifdef G4MULTITHREADED <<
1911 G4VisManager* pVisManager = (G4VisManager*) 1782 G4VisManager* pVisManager = (G4VisManager*)p;
1912 G4VSceneHandler* pSceneHandler = pVisManage 1783 G4VSceneHandler* pSceneHandler = pVisManager->GetCurrentSceneHandler();
1913 if (!pSceneHandler) return 0; 1784 if (!pSceneHandler) return 0;
1914 G4Scene* pScene = pSceneHandler->GetScene() 1785 G4Scene* pScene = pSceneHandler->GetScene();
1915 if (!pScene) return 0; 1786 if (!pScene) return 0;
1916 G4VViewer* pViewer = pVisManager->GetCurren 1787 G4VViewer* pViewer = pVisManager->GetCurrentViewer();
1917 if (!pViewer) return 0; 1788 if (!pViewer) return 0;
1918 1789
1919 G4UImanager::GetUIpointer()->SetUpForSpecia 1790 G4UImanager::GetUIpointer()->SetUpForSpecialThread("G4VIS");
1920 1791
>> 1792 // G4cout << "G4VisManager::G4VisSubThread: thread: "
>> 1793 // << G4Threading::G4GetThreadId() << std::endl;
>> 1794
1921 // Set up geometry and navigation for a thr 1795 // Set up geometry and navigation for a thread
1922 G4GeometryWorkspace::GetPool()->CreateAndUs 1796 G4GeometryWorkspace::GetPool()->CreateAndUseWorkspace();
1923 G4SolidsWorkspace::GetPool()->CreateAndUseW 1797 G4SolidsWorkspace::GetPool()->CreateAndUseWorkspace();
1924 G4Navigator* navigator = G4TransportationMa << 1798 G4Navigator* navigator =
1925 ->GetNavigatorFo << 1799 G4TransportationManager::GetTransportationManager()->GetNavigatorForTracking();
1926 navigator->SetWorldVolume( << 1800 navigator->SetWorldVolume
1927 G4RunManagerFactory::GetMasterRunManagerK << 1801 (G4MTRunManager::GetMasterRunManagerKernel()->GetCurrentWorld());
1928 1802
1929 pViewer->SwitchToVisSubThread(); 1803 pViewer->SwitchToVisSubThread();
1930 1804
1931 while (true) { 1805 while (true) {
1932 1806
1933 G4MUTEXLOCK(&mtVisSubThreadMutex); 1807 G4MUTEXLOCK(&mtVisSubThreadMutex);
1934 std::size_t eventQueueSize = mtVisEventQu << 1808 G4int eventQueueSize = mtVisEventQueue.size();
1935 G4MUTEXUNLOCK(&mtVisSubThreadMutex); 1809 G4MUTEXUNLOCK(&mtVisSubThreadMutex);
1936 // G4cout << "Event queue size (A): " << << 1810 // G4cout << "Event queue size (A): " << eventQueueSize << G4endl;
1937 1811
1938 while (eventQueueSize) { 1812 while (eventQueueSize) {
1939 1813
1940 G4MUTEXLOCK(&mtVisSubThreadMutex); 1814 G4MUTEXLOCK(&mtVisSubThreadMutex);
1941 const G4Event* event = mtVisEventQueue. 1815 const G4Event* event = mtVisEventQueue.front();
1942 G4MUTEXUNLOCK(&mtVisSubThreadMutex); 1816 G4MUTEXUNLOCK(&mtVisSubThreadMutex);
>> 1817 // G4int eventID = event->GetEventID();
>> 1818 // G4cout <<
>> 1819 // "G4VisManager::G4VisSubThread: Vis sub-thread: Dealing with event: "
>> 1820 // << eventID << G4endl;
1943 1821
1944 // Here comes the event drawing 1822 // Here comes the event drawing
1945 pVisManager->SetTransientsDrawnThisEven 1823 pVisManager->SetTransientsDrawnThisEvent(false);
1946 pSceneHandler->SetTransientsDrawnThisEv 1824 pSceneHandler->SetTransientsDrawnThisEvent(false);
1947 1825
1948 // We are about to draw the event (traj 1826 // We are about to draw the event (trajectories, etc.), but first we
1949 // have to clear the previous event(s) 1827 // have to clear the previous event(s) if necessary. If this event
1950 // needs to be drawn afresh, e.g., the 1828 // needs to be drawn afresh, e.g., the first event or any event when
1951 // "accumulate" is not requested, the o 1829 // "accumulate" is not requested, the old event has to be cleared.
1952 // We have postponed this so that, for 1830 // We have postponed this so that, for normal viewers like OGL, the
1953 // previous event(s) stay on screen unt 1831 // previous event(s) stay on screen until this new event comes
1954 // along. For a file-writing viewer th 1832 // along. For a file-writing viewer the geometry has to be drawn.
1955 // See, for example, G4HepRepFileSceneH 1833 // See, for example, G4HepRepFileSceneHandler::ClearTransientStore.
1956 pVisManager->ClearTransientStoreIfMarke 1834 pVisManager->ClearTransientStoreIfMarked();
1957 1835
1958 // Now draw the event... 1836 // Now draw the event...
1959 pSceneHandler->DrawEvent(event); 1837 pSceneHandler->DrawEvent(event);
1960 ++pVisManager->fNoOfEventsDrawnThisRun; 1838 ++pVisManager->fNoOfEventsDrawnThisRun;
1961 1839
>> 1840 if (pScene->GetRefreshAtEndOfEvent()) {
>> 1841
>> 1842 // ShowView guarantees the view is flushed to the screen. It also
>> 1843 // triggers other features such picking (if enabled) and allows
>> 1844 // file-writing viewers to close the file.
>> 1845 pViewer->ShowView();
>> 1846 pSceneHandler->SetMarkForClearingTransientStore(true);
>> 1847
>> 1848 }
>> 1849
>> 1850 // Testing.
>> 1851 // std::this_thread::sleep_for(std::chrono::seconds(5));
>> 1852
1962 // Then pop and release event 1853 // Then pop and release event
1963 G4MUTEXLOCK(&mtVisSubThreadMutex); 1854 G4MUTEXLOCK(&mtVisSubThreadMutex);
1964 mtVisEventQueue.pop_front(); 1855 mtVisEventQueue.pop_front();
1965 pVisManager->EndOfEventCleanup(event); << 1856 event->PostProcessingFinished();
1966 eventQueueSize = mtVisEventQueue.size() 1857 eventQueueSize = mtVisEventQueue.size();
1967 G4MUTEXUNLOCK(&mtVisSubThreadMutex); 1858 G4MUTEXUNLOCK(&mtVisSubThreadMutex);
>> 1859 // G4cout << "Event queue size (B): " << eventQueueSize << G4endl;
1968 } 1860 }
1969 1861
1970 G4MUTEXLOCK(&mtVisSubThreadMutex); 1862 G4MUTEXLOCK(&mtVisSubThreadMutex);
1971 G4bool runInProgress = mtRunInProgress; << 1863 G4int runInProgress = mtRunInProgress;
1972 G4MUTEXUNLOCK(&mtVisSubThreadMutex); 1864 G4MUTEXUNLOCK(&mtVisSubThreadMutex);
1973 if (!runInProgress) { 1865 if (!runInProgress) {
1974 // EndOfRun on master thread has signal 1866 // EndOfRun on master thread has signalled end of run. There is
1975 // nothing to draw so... 1867 // nothing to draw so...
1976 break; 1868 break;
1977 } 1869 }
1978 1870
1979 // Run still in progress but nothing to d 1871 // Run still in progress but nothing to draw, so wait a while.
>> 1872 #ifdef G4VIS_USE_STD11
1980 std::this_thread::sleep_for(std::chrono:: 1873 std::this_thread::sleep_for(std::chrono::milliseconds(100));
>> 1874 #else
>> 1875 G4THREADSLEEP(1);
>> 1876 #endif
1981 } 1877 }
1982 1878
1983 // Inform viewer that we have finished all 1879 // Inform viewer that we have finished all sub-thread drawing
1984 pViewer->DoneWithVisSubThread(); 1880 pViewer->DoneWithVisSubThread();
1985 pViewer->MovingToMasterThread(); 1881 pViewer->MovingToMasterThread();
1986 #else << 1882 // G4cout << "G4VisManager::G4VisSubThread: Vis sub-thread: ending" << G4endl;
1987 G4ConsumeParameters(p); << 1883 return /*(G4ThreadFunReturnType)*/0;
1988 #endif <<
1989 return nullptr; <<
1990 } 1884 }
1991 1885
>> 1886 namespace {
>> 1887 // G4Mutex visBeginOfRunMutex = G4MUTEX_INITIALIZER;
>> 1888 // G4Mutex visBeginOfEventMutex = G4MUTEX_INITIALIZER;
>> 1889 G4Mutex visEndOfEventMutex = G4MUTEX_INITIALIZER;
>> 1890 // G4Mutex visEndOfRunMutex = G4MUTEX_INITIALIZER;
>> 1891 }
>> 1892
>> 1893 #endif
>> 1894
1992 void G4VisManager::BeginOfRun () 1895 void G4VisManager::BeginOfRun ()
1993 { 1896 {
1994 if (fIgnoreStateChanges) return; 1897 if (fIgnoreStateChanges) return;
>> 1898
>> 1899 #ifdef G4MULTITHREADED
1995 if (G4Threading::IsWorkerThread()) return; 1900 if (G4Threading::IsWorkerThread()) return;
1996 if (!GetConcreteInstance()) return; << 1901 #endif
>> 1902 // G4cout << "G4VisManager::BeginOfRun: thread: "
>> 1903 // << G4Threading::G4GetThreadId() << G4endl;
1997 1904
1998 // Check if view is valid << 1905 G4RunManager* runManager = G4RunManager::GetRunManager();
1999 // Protect IsValidView() with fpSceneHandle << 1906 #ifdef G4MULTITHREADED
2000 isValidViewForRun = fpSceneHandler && IsVal << 1907 if (G4Threading::IsMultithreadedApplication()) {
2001 if (!isValidViewForRun) return; << 1908 runManager = G4MTRunManager::GetMasterRunManager();
>> 1909 }
>> 1910 #endif
2002 1911
2003 // For a fake run... 1912 // For a fake run...
2004 G4RunManager* runManager = G4RunManagerFact <<
2005 G4int nEventsToBeProcessed = runManager->Ge 1913 G4int nEventsToBeProcessed = runManager->GetNumberOfEventsToBeProcessed();
2006 isFakeRun = (nEventsToBeProcessed == 0); << 1914 if (nEventsToBeProcessed == 0) return;
2007 if (isFakeRun) return; <<
2008 <<
2009 // Is the run manager a sub-event type? <<
2010 G4RunManager::RMType rmType = runManager->G <<
2011 isSubEventRunManagerType = <<
2012 (rmType == G4RunManager::subEventMasterRM) <<
2013 (rmType == G4RunManager::subEventWorkerRM); <<
2014 1915
2015 fNKeepForPostProcessingRequests = 0; << 1916 fNKeepRequests = 0;
2016 fNKeepTheEventRequests = 0; << 1917 fKeptLastEvent = false;
2017 fEventKeepingSuspended = false; 1918 fEventKeepingSuspended = false;
2018 fTransientsDrawnThisRun = false; 1919 fTransientsDrawnThisRun = false;
2019 if (fpSceneHandler) fpSceneHandler->SetTran 1920 if (fpSceneHandler) fpSceneHandler->SetTransientsDrawnThisRun(false);
2020 fNoOfEventsDrawnThisRun = 0; 1921 fNoOfEventsDrawnThisRun = 0;
2021 1922
2022 // Check to see if the user has created a t 1923 // Check to see if the user has created a trajectory model. If not, create
2023 // a default one. To avoid code duplication 1924 // a default one. To avoid code duplication the following function is used
2024 // and its result (a const G4VTrajectoryMod 1925 // and its result (a const G4VTrajectoryModel*) is thrown away at this point.
2025 // The function is called again later when 1926 // The function is called again later when needed.
2026 CurrentTrajDrawModel(); 1927 CurrentTrajDrawModel();
2027 1928
2028 // Actions only in MT mode << 1929 #ifdef G4MULTITHREADED
>> 1930 // There is a static method G4Threading::IsMultithreadedApplication()
>> 1931 // that returns true only if G4MTRunManager is instantiated with MT
>> 1932 // installation. Thus method returns false if G4RunManager base class is
>> 1933 // instantiated even with the MT installation, or of course with sequential
>> 1934 // installation.
2029 if (G4Threading::IsMultithreadedApplication 1935 if (G4Threading::IsMultithreadedApplication()) {
2030 1936
2031 // Inform viewer that we have finished al 1937 // Inform viewer that we have finished all master thread drawing for now...
2032 if (fpViewer) fpViewer->DoneWithMasterThr 1938 if (fpViewer) fpViewer->DoneWithMasterThread();
2033 1939
2034 // Start vis sub-thread 1940 // Start vis sub-thread
>> 1941 // G4cout << "G4VisManager::BeginOfRun: Starting vis sub-thread" << G4endl;
2035 G4MUTEXLOCK(&mtVisSubThreadMutex); 1942 G4MUTEXLOCK(&mtVisSubThreadMutex);
2036 mtRunInProgress = true; 1943 mtRunInProgress = true;
2037 G4MUTEXUNLOCK(&mtVisSubThreadMutex); 1944 G4MUTEXUNLOCK(&mtVisSubThreadMutex);
2038 mtVisSubThread = new G4Thread; 1945 mtVisSubThread = new G4Thread;
2039 // Launch vis thread 1946 // Launch vis thread
2040 G4THREADCREATE(mtVisSubThread,G4VisSubThr 1947 G4THREADCREATE(mtVisSubThread,G4VisSubThread,this);
2041 1948
2042 // Tricky things for some viewers (e.g., 1949 // Tricky things for some viewers (e.g., Qt):
2043 // - Launch the vis thread 1950 // - Launch the vis thread
2044 // - Wait for the vis thread to set its Q 1951 // - Wait for the vis thread to set its QThread
2045 // - Then move current QOpenGL context (i 1952 // - Then move current QOpenGL context (if Qt) to this Qthread
2046 // - Go ahead 1953 // - Go ahead
2047 if (fpViewer) fpViewer->MovingToVisSubThr 1954 if (fpViewer) fpViewer->MovingToVisSubThread();
2048 } 1955 }
>> 1956 #endif
2049 } 1957 }
2050 1958
2051 void G4VisManager::BeginOfEvent () 1959 void G4VisManager::BeginOfEvent ()
2052 { 1960 {
2053 if (fIgnoreStateChanges) return; 1961 if (fIgnoreStateChanges) return;
>> 1962
2054 if (!GetConcreteInstance()) return; 1963 if (!GetConcreteInstance()) return;
2055 if (!isValidViewForRun) return; << 1964
2056 if (isFakeRun) return; << 1965 // G4cout << "G4VisManager::BeginOfEvent: thread: "
>> 1966 // << G4Threading::G4GetThreadId() << G4endl;
2057 1967
2058 // Some instructions that should NOT be in 1968 // Some instructions that should NOT be in multithreaded version.
2059 // TODO: protect with G4Threading::IsMultit <<
2060 #ifndef G4MULTITHREADED 1969 #ifndef G4MULTITHREADED
2061 // These instructions are in G4VisSubThread 1970 // These instructions are in G4VisSubThread for multithreading.
2062 fTransientsDrawnThisEvent = false; 1971 fTransientsDrawnThisEvent = false;
2063 if (fpSceneHandler) fpSceneHandler->SetTran 1972 if (fpSceneHandler) fpSceneHandler->SetTransientsDrawnThisEvent(false);
2064 #endif 1973 #endif
2065 } 1974 }
2066 1975
2067 // Here begins a sequence of functions that d <<
2068 // Sequential/Serial mode: <<
2069 // EndOfEvent is invoked by a state change <<
2070 // EndOfEvent pulls the event from the Ev <<
2071 // EndOfEventKernel draws the event and c <<
2072 // (Unless the user him/herself has reque <<
2073 // also sets KeepTheEvent for a certain <<
2074 // of events. The run manager keeps thes <<
2075 // run, so, for example, the vis manager <<
2076 // Multithreading/Tasking: <<
2077 // EndOfEvent is invoked by a state change <<
2078 // EndOfEvent pulls the event from the (w <<
2079 // EndOfEventKernel pushes it to the vis <<
2080 // are marked KeepForPostProcessing so <<
2081 // PostProcessingFinished in EndOfEvent <<
2082 // EndOfEventKernel also sets KeepTheEven <<
2083 // The vis sub thread pulls events from t <<
2084 // calls EndOfEventCleanup, which calls <<
2085 // Sub-event parallelism: <<
2086 // EndOfEvent is invoked by a state change <<
2087 // multithreading, but actually, the even <<
2088 // employed on sub-events, so we ignore s <<
2089 // G4SubEvtRunManager knows when the even <<
2090 // Events are pushed to the Vis Manager by <<
2091 // when the event is ready. EventReadyFo <<
2092 // processsing continues as for Multithr <<
2093 <<
2094 void G4VisManager::EndOfEvent () 1976 void G4VisManager::EndOfEvent ()
2095 { 1977 {
2096 if (fIgnoreStateChanges) return; 1978 if (fIgnoreStateChanges) return;
>> 1979
2097 if (!GetConcreteInstance()) return; 1980 if (!GetConcreteInstance()) return;
2098 if (!isValidViewForRun) return; <<
2099 if (isFakeRun) return; <<
2100 1981
2101 // For sub-event parallelism, this is not t << 1982 // Don't call IsValidView unless there is a scene handler. This
2102 if (isSubEventRunManagerType) return; << 1983 // avoids WARNING message at end of event and run when the user has
>> 1984 // not instantiated a scene handler, e.g., in batch mode.
>> 1985 G4bool valid = fpSceneHandler && IsValidView();
>> 1986 if (!valid) return;
2103 1987
>> 1988 // G4cout << "G4VisManager::EndOfEvent: thread: "
>> 1989 // << G4Threading::G4GetThreadId() << G4endl;
>> 1990
>> 1991 #ifdef G4MULTITHREADED
2104 G4AutoLock al(&visEndOfEventMutex); 1992 G4AutoLock al(&visEndOfEventMutex);
>> 1993 // Testing.
>> 1994 // std::this_thread::sleep_for(std::chrono::seconds(5));
>> 1995 #endif
2105 1996
2106 G4RunManager* runManager = G4RunManagerFact << 1997 G4RunManager* runManager = G4RunManager::GetRunManager();
>> 1998 #ifdef G4MULTITHREADED
>> 1999 if (G4Threading::IsMultithreadedApplication()) {
>> 2000 runManager = G4MTRunManager::GetMasterRunManager();
>> 2001 }
>> 2002 #endif
2107 2003
2108 const G4Run* currentRun = runManager->GetCu 2004 const G4Run* currentRun = runManager->GetCurrentRun();
2109 if (!currentRun) return; 2005 if (!currentRun) return;
2110 2006
2111 // This gets the appropriate event manager << 2007 // This gets the thread-local event manager
2112 G4EventManager* eventManager = G4EventManag 2008 G4EventManager* eventManager = G4EventManager::GetEventManager();
2113 const G4Event* currentEvent = eventManager- 2009 const G4Event* currentEvent = eventManager->GetConstCurrentEvent();
2114 if (!currentEvent) return; 2010 if (!currentEvent) return;
2115 2011
2116 // Call kernel <<
2117 EndOfEventKernel(currentEvent); <<
2118 } <<
2119 <<
2120 void G4VisManager::EventReadyForVis(const G4E <<
2121 // This is invoked by G4SubEvtRunManager. <<
2122 // The event is passed to EndOfEventKernel. <<
2123 { <<
2124 if (fIgnoreStateChanges) return; <<
2125 if (!GetConcreteInstance()) return; <<
2126 if (!isValidViewForRun) return; <<
2127 if (isFakeRun) return; <<
2128 <<
2129 G4AutoLock al(&visEndOfEventMutex); <<
2130 EndOfEventKernel(event); <<
2131 } <<
2132 <<
2133 void G4VisManager::EndOfEventKernel (const G4 <<
2134 { <<
2135 // Note: we are still subject to the mutex <<
2136 <<
2137 // Discard event if fDrawEventOnlyIfToBeKep 2012 // Discard event if fDrawEventOnlyIfToBeKept flag is set unless the
2138 // user has requested the event to be kept. 2013 // user has requested the event to be kept.
2139 if (fDrawEventOnlyIfToBeKept) { 2014 if (fDrawEventOnlyIfToBeKept) {
2140 if (!currentEvent->KeepTheEventFlag()) re << 2015 if (!currentEvent->ToBeKept()) return;
2141 } 2016 }
2142 2017
2143 if (G4Threading::IsMultithreadedApplication 2018 if (G4Threading::IsMultithreadedApplication()) {
2144 2019
>> 2020 #ifdef G4MULTITHREADED
>> 2021
2145 // Wait if too many events in the queue. 2022 // Wait if too many events in the queue.
2146 G4MUTEXLOCK(&mtVisSubThreadMutex); 2023 G4MUTEXLOCK(&mtVisSubThreadMutex);
2147 std::size_t eventQueueSize = mtVisEventQu << 2024 G4int eventQueueSize = mtVisEventQueue.size();
2148 G4MUTEXUNLOCK(&mtVisSubThreadMutex); 2025 G4MUTEXUNLOCK(&mtVisSubThreadMutex);
>> 2026 // G4cout << "Event queue size (1): " << eventQueueSize << G4endl;
2149 2027
2150 G4bool eventQueueFull = false; 2028 G4bool eventQueueFull = false;
2151 while (fMaxEventQueueSize > 0 && (G4int)e << 2029 while (fMaxEventQueueSize > 0 && eventQueueSize >= fMaxEventQueueSize) {
2152 2030
>> 2031 // G4cout << "Event queue size (2): " << eventQueueSize << G4endl;
2153 if (fWaitOnEventQueueFull) { 2032 if (fWaitOnEventQueueFull) {
2154 <<
2155 static G4bool warned = false; 2033 static G4bool warned = false;
2156 if (!warned) { 2034 if (!warned) {
2157 G4warn << << 2035 G4cout <<
2158 "WARNING: The number of events in t 2036 "WARNING: The number of events in the visualisation queue has exceeded"
2159 "\n the maximum, " 2037 "\n the maximum, "
2160 << fMaxEventQueueSize << 2038 << fMaxEventQueueSize <<
2161 ".\n If, during a multithreaded ru 2039 ".\n If, during a multithreaded run, the simulation gets ahead of the"
2162 "\n visualisation by more than thi 2040 "\n visualisation by more than this maximum, the simulation is delayed"
2163 "\n until the vis sub-thread has d 2041 "\n until the vis sub-thread has drawn a few more events and removed them"
2164 "\n from the queue. You may chang 2042 "\n from the queue. You may change this maximum number of events with"
2165 "\n \"/vis/multithreading/maxEvent 2043 "\n \"/vis/multithreading/maxEventQueueSize <N>\", where N is the maximum"
2166 "\n number you wish to allow. N < 2044 "\n number you wish to allow. N <= 0 means \"unlimited\"."
2167 "\n Alternatively you may choose t 2045 "\n Alternatively you may choose to discard events for drawing by setting"
2168 "\n \"/vis/multithreading/actionOn 2046 "\n \"/vis/multithreading/actionOnEventQueueFull discard\"."
2169 "\n To avoid visualisation altoget 2047 "\n To avoid visualisation altogether: \"/vis/disable\"."
2170 "\n And maybe \"/tracking/storeTra 2048 "\n And maybe \"/tracking/storeTrajectories 0\"."
2171 << G4endl; 2049 << G4endl;
2172 warned = true; 2050 warned = true;
2173 } 2051 }
2174 << 2052 // G4cout << "Event queue size (3): " << eventQueueSize << G4endl;
2175 // Wait a while to give event drawing 2053 // Wait a while to give event drawing time to reduce the queue...
>> 2054 #ifdef G4VIS_USE_STD11
2176 std::this_thread::sleep_for(std::chro 2055 std::this_thread::sleep_for(std::chrono::milliseconds(100));
2177 << 2056 #else
>> 2057 G4THREADSLEEP(1);
>> 2058 #endif
>> 2059 // G4cout << "Event queue size (4): " << eventQueueSize << G4endl;
2178 } else { 2060 } else {
2179 <<
2180 static G4bool warned = false; 2061 static G4bool warned = false;
2181 if (!warned) { 2062 if (!warned) {
2182 G4warn << << 2063 G4cout <<
2183 "WARNING: The number of events in t 2064 "WARNING: The number of events in the visualisation queue has exceeded"
2184 "\n the maximum, " 2065 "\n the maximum, "
2185 << fMaxEventQueueSize << 2066 << fMaxEventQueueSize <<
2186 ".\n Some events have been discard 2067 ".\n Some events have been discarded for drawing. You may change this"
2187 "\n behaviour with \"/vis/multithr 2068 "\n behaviour with \"/vis/multithreading/actionOnEventQueueFull wait\"."
2188 "\n To avoid visualisation altoget 2069 "\n To avoid visualisation altogether: \"/vis/disable\"."
2189 "\n And maybe \"/tracking/storeTra 2070 "\n And maybe \"/tracking/storeTrajectories 0\"."
2190 << G4endl; 2071 << G4endl;
2191 warned = true; 2072 warned = true;
2192 } 2073 }
2193 <<
2194 eventQueueFull = true; // Causes eve 2074 eventQueueFull = true; // Causes event to be discarded for drawing.
2195 break; 2075 break;
2196 } 2076 }
2197 2077
2198 G4MUTEXLOCK(&mtVisSubThreadMutex); 2078 G4MUTEXLOCK(&mtVisSubThreadMutex);
2199 eventQueueSize = mtVisEventQueue.size() 2079 eventQueueSize = mtVisEventQueue.size();
2200 G4MUTEXUNLOCK(&mtVisSubThreadMutex); 2080 G4MUTEXUNLOCK(&mtVisSubThreadMutex);
2201 } 2081 }
2202 2082
2203 if (!eventQueueFull) { 2083 if (!eventQueueFull) {
2204 <<
2205 if (RequiredToBeKeptForVis(currentEvent <<
2206 currentEvent->KeepTheEvent(); <<
2207 fNKeepTheEventRequests++; // Counts <<
2208 } <<
2209 <<
2210 G4MUTEXLOCK(&mtVisSubThreadMutex); 2084 G4MUTEXLOCK(&mtVisSubThreadMutex);
2211 << 2085 // Keep event for processing and put event on vis event queue
2212 // Keep while post processing (i.e., dr <<
2213 // Make sure the event is not deleted b <<
2214 currentEvent->KeepForPostProcessing(); 2086 currentEvent->KeepForPostProcessing();
2215 fNKeepForPostProcessingRequests++; <<
2216 <<
2217 // Put event on vis queue <<
2218 mtVisEventQueue.push_back(currentEvent) 2087 mtVisEventQueue.push_back(currentEvent);
2219 <<
2220 G4MUTEXUNLOCK(&mtVisSubThreadMutex); 2088 G4MUTEXUNLOCK(&mtVisSubThreadMutex);
2221 } 2089 }
2222 2090
>> 2091 // G4MUTEXLOCK(&mtVisSubThreadMutex);
>> 2092 // G4int eQS = mtVisEventQueue.size();
>> 2093 // G4MUTEXUNLOCK(&mtVisSubThreadMutex);
>> 2094 // G4cout << "Event queue size (5): " << eQS << G4endl;
>> 2095
>> 2096 #endif
>> 2097
2223 } else { 2098 } else {
2224 2099
2225 // Sequential mode 2100 // Sequential mode
2226 2101
>> 2102 G4int nEventsToBeProcessed = 0;
>> 2103 G4int nKeptEvents = 0;
>> 2104 G4int eventID = -2; // (If no run manager, triggers ShowView as normal.)
>> 2105 if (currentRun) {
>> 2106 nEventsToBeProcessed = runManager->GetNumberOfEventsToBeProcessed();
>> 2107 eventID = currentEvent->GetEventID();
>> 2108 const std::vector<const G4Event*>* events = currentRun->GetEventVector();
>> 2109 if (events) nKeptEvents = events->size();
>> 2110 }
>> 2111
2227 // We are about to draw the event (trajec 2112 // We are about to draw the event (trajectories, etc.), but first we
2228 // have to clear the previous event(s) if 2113 // have to clear the previous event(s) if necessary. If this event
2229 // needs to be drawn afresh, e.g., the fi 2114 // needs to be drawn afresh, e.g., the first event or any event when
2230 // "accumulate" is not requested, the old 2115 // "accumulate" is not requested, the old event has to be cleared.
2231 // We have postponed this so that, for no 2116 // We have postponed this so that, for normal viewers like OGL, the
2232 // previous event(s) stay on screen until 2117 // previous event(s) stay on screen until this new event comes
2233 // along. For a file-writing viewer the 2118 // along. For a file-writing viewer the geometry has to be drawn.
2234 // See, for example, G4HepRepFileSceneHan 2119 // See, for example, G4HepRepFileSceneHandler::ClearTransientStore.
2235 ClearTransientStoreIfMarked(); 2120 ClearTransientStoreIfMarked();
2236 2121
2237 // Keep while post processing (i.e., draw <<
2238 currentEvent->KeepForPostProcessing(); <<
2239 fNKeepForPostProcessingRequests++; <<
2240 <<
2241 if (RequiredToBeKeptForVis(currentEvent-> <<
2242 currentEvent->KeepTheEvent(); <<
2243 fNKeepTheEventRequests++; // Counts nu <<
2244 } <<
2245 <<
2246 // Now draw the event... 2122 // Now draw the event...
2247 fpSceneHandler->DrawEvent(currentEvent); 2123 fpSceneHandler->DrawEvent(currentEvent);
2248 ++fNoOfEventsDrawnThisRun; 2124 ++fNoOfEventsDrawnThisRun;
2249 2125
2250 EndOfEventCleanup(currentEvent); << 2126 if (fpScene->GetRefreshAtEndOfEvent()) {
2251 } <<
2252 } <<
2253 2127
2254 void G4VisManager::EndOfEventCleanup(const G4 << 2128 // Unless last event (in which case wait end of run)...
2255 { << 2129 if (eventID < nEventsToBeProcessed - 1) {
2256 if (fpScene->GetRefreshAtEndOfEvent()) { << 2130 // ShowView guarantees the view is flushed to the screen. It also
2257 << 2131 // triggers other features such picking (if enabled) and allows
2258 fpSceneHandler->SetMarkForClearingTransie << 2132 // file-writing viewers to close the file.
>> 2133 fpViewer->ShowView();
>> 2134 } else { // Last event...
>> 2135 // Keep, but only if user has not kept any...
>> 2136 if (nKeptEvents == 0) {
>> 2137 eventManager->KeepTheCurrentEvent();
>> 2138 fNKeepRequests++;
>> 2139 fKeptLastEvent = true;
>> 2140 }
>> 2141 }
>> 2142 fpSceneHandler->SetMarkForClearingTransientStore(true);
2259 2143
2260 // ShowView guarantees the view is flushe << 2144 }
2261 // triggers other features such as pickin <<
2262 // file-writing viewers to close the file <<
2263 fpViewer->ShowView(); <<
2264 } 2145 }
2265 2146
2266 currentEvent->PostProcessingFinished(); << 2147 // Both modes - sequential and MT
2267 } <<
2268 <<
2269 G4bool G4VisManager::RequiredToBeKeptForVis ( <<
2270 // i.e., kept by the run manager at least to <<
2271 { <<
2272 G4bool requiredToBeKept = false; <<
2273 2148
2274 G4RunManager* runManager = G4RunManagerFact << 2149 if (!(fpScene->GetRefreshAtEndOfEvent())) {
2275 G4int nEventsToBeProcessed = runManager->Ge <<
2276 2150
2277 if (fpScene->GetRefreshAtEndOfEvent()) { / << 2151 // Accumulating events...
2278 <<
2279 // Keep last event only <<
2280 if (eventID == nEventsToBeProcessed - 1) <<
2281 requiredToBeKept = true; <<
2282 } <<
2283 <<
2284 } else { // Accumulating events <<
2285 2152
2286 G4int maxNumberOfKeptEvents = fpScene->Ge 2153 G4int maxNumberOfKeptEvents = fpScene->GetMaxNumberOfKeptEvents();
2287 2154
2288 if (maxNumberOfKeptEvents >= 0) { // Eve << 2155 if (maxNumberOfKeptEvents > 0 &&
2289 << 2156 fNKeepRequests >= maxNumberOfKeptEvents) {
2290 if (fNKeepTheEventRequests < maxNumberO <<
2291 <<
2292 // Not yet reached the limit <<
2293 requiredToBeKept = true; <<
2294 <<
2295 } else { <<
2296 2157
2297 // We have already reached the limit << 2158 fEventKeepingSuspended = true;
2298 fEventKeepingSuspended = true; << 2159 static G4bool warned = false;
2299 static G4bool warned = false; << 2160 if (!warned) {
2300 if (!warned) { << 2161 if (fVerbosity >= warnings) {
2301 if (fVerbosity >= warnings) { << 2162 G4cout <<
2302 G4warn << << 2163 "WARNING: G4VisManager::EndOfEvent: Automatic event keeping suspended."
2303 "WARNING: G4VisManager::EndOfEven << 2164 "\n The number of events exceeds the maximum, "
2304 << G4endl; << 2165 << maxNumberOfKeptEvents <<
2305 if (maxNumberOfKeptEvents > 0) { << 2166 ", that may be kept by\n the vis manager."
2306 G4warn << << 2167 << G4endl;
2307 "\n The number of events excee <<
2308 << maxNumberOfKeptEvents << <<
2309 ", that may be kept by\n the v <<
2310 << G4endl; <<
2311 } <<
2312 } <<
2313 warned = true; <<
2314 } 2168 }
>> 2169 warned = true;
2315 } 2170 }
2316 2171
2317 } else { // Indefinite event keeping (ma << 2172 } else if (maxNumberOfKeptEvents != 0) {
2318 <<
2319 requiredToBeKept = true; <<
2320 2173
>> 2174 // If not disabled nor suspended.
>> 2175 if (GetConcreteInstance() && !fEventKeepingSuspended) {
>> 2176 // G4cout <<
>> 2177 // "Requesting keeping event " << currentEvent->GetEventID()
>> 2178 // << G4endl;
>> 2179 eventManager->KeepTheCurrentEvent();
>> 2180 fNKeepRequests++;
>> 2181 }
>> 2182
2321 } 2183 }
2322 } 2184 }
2323 <<
2324 return requiredToBeKept; <<
2325 } 2185 }
2326 2186
2327 void G4VisManager::EndOfRun () 2187 void G4VisManager::EndOfRun ()
2328 { 2188 {
2329 if (fIgnoreStateChanges) return; 2189 if (fIgnoreStateChanges) return;
>> 2190
>> 2191 #ifdef G4MULTITHREADED
2330 if (G4Threading::IsWorkerThread()) return; 2192 if (G4Threading::IsWorkerThread()) return;
2331 if (!GetConcreteInstance()) return; << 2193 #endif
2332 if (!isValidViewForRun) return; <<
2333 if (isFakeRun) return; <<
2334 2194
2335 G4RunManager* runManager = G4RunManagerFact << 2195 // G4cout << "G4VisManager::EndOfRun: thread: "
>> 2196 // << G4Threading::G4GetThreadId() << G4endl;
>> 2197
>> 2198 G4RunManager* runManager = G4RunManager::GetRunManager();
>> 2199 #ifdef G4MULTITHREADED
>> 2200 if (G4Threading::IsMultithreadedApplication()) {
>> 2201 runManager = G4MTRunManager::GetMasterRunManager();
>> 2202 }
>> 2203 #endif
2336 2204
2337 // For a fake run... 2205 // For a fake run...
2338 G4int nEventsToBeProcessed = runManager->Ge 2206 G4int nEventsToBeProcessed = runManager->GetNumberOfEventsToBeProcessed();
2339 if (nEventsToBeProcessed == 0) return; 2207 if (nEventsToBeProcessed == 0) return;
2340 2208
2341 const G4Run* currentRun = runManager->GetCu 2209 const G4Run* currentRun = runManager->GetCurrentRun();
2342 if (!currentRun) return; 2210 if (!currentRun) return;
2343 2211
>> 2212 #ifdef G4MULTITHREADED
2344 // G4AutoLock al(&visEndOfRunMutex); ??? 2213 // G4AutoLock al(&visEndOfRunMutex); ???
2345 if (G4Threading::IsMultithreadedApplication 2214 if (G4Threading::IsMultithreadedApplication()) {
2346 // Reset flag so that sub-thread exits wh 2215 // Reset flag so that sub-thread exits when it has finished processing.
2347 G4MUTEXLOCK(&mtVisSubThreadMutex); 2216 G4MUTEXLOCK(&mtVisSubThreadMutex);
2348 mtRunInProgress = false; 2217 mtRunInProgress = false;
2349 G4MUTEXUNLOCK(&mtVisSubThreadMutex); 2218 G4MUTEXUNLOCK(&mtVisSubThreadMutex);
2350 // Wait for sub-thread to finish. 2219 // Wait for sub-thread to finish.
2351 G4THREADJOIN(*mtVisSubThread); 2220 G4THREADJOIN(*mtVisSubThread);
2352 delete mtVisSubThread; 2221 delete mtVisSubThread;
2353 fpViewer->SwitchToMasterThread(); << 2222 if (fpViewer) fpViewer->SwitchToMasterThread();
2354 } 2223 }
>> 2224 #endif
2355 2225
2356 if (G4Threading::IsMultithreadedApplication << 2226 #ifdef G4MULTITHREADED
>> 2227 // Print warning about discarded events, if any.
>> 2228 // Don't call IsValidView unless there is a scene handler. This
>> 2229 // avoids WARNING message from IsValidView() when the user has
>> 2230 // not instantiated a scene handler, e.g., in batch mode.
>> 2231 if (fpSceneHandler && IsValidView()) { // Events should have been drawn
2357 G4int noOfEventsRequested = runManager->G 2232 G4int noOfEventsRequested = runManager->GetNumberOfEventsToBeProcessed();
2358 if (fNoOfEventsDrawnThisRun != noOfEvents 2233 if (fNoOfEventsDrawnThisRun != noOfEventsRequested) {
2359 if (!fWaitOnEventQueueFull && fVerbosit 2234 if (!fWaitOnEventQueueFull && fVerbosity >= warnings) {
2360 G4warn << 2235 G4cout
2361 << "WARNING: Number of events drawn t 2236 << "WARNING: Number of events drawn this run, "
2362 << fNoOfEventsDrawnThisRun << ", is d 2237 << fNoOfEventsDrawnThisRun << ", is different to number requested, "
2363 << noOfEventsRequested << 2238 << noOfEventsRequested <<
2364 ".\n (This is because you requested 2239 ".\n (This is because you requested \"/vis/multithreading/actionOnEventQueueFull discard\".)"
2365 << G4endl; 2240 << G4endl;
2366 } 2241 }
2367 } 2242 }
2368 } 2243 }
>> 2244 #endif
2369 2245
2370 G4int nKeptEvents = currentRun->GetNumberOf << 2246 G4int nKeptEvents = 0;
2371 if (fVerbosity >= warnings && nKeptEvents > << 2247 const std::vector<const G4Event*>* events = currentRun->GetEventVector();
2372 G4warn << nKeptEvents; << 2248 if (events) nKeptEvents = events->size();
2373 if (nKeptEvents == 1) G4warn << " event h << 2249 if (nKeptEvents && !fKeptLastEvent) {
2374 else G4warn << " events have"; << 2250 if (fVerbosity >= warnings) {
2375 G4warn << " been kept for refreshing and/ << 2251 G4cout << nKeptEvents;
2376 if (nKeptEvents != fNKeepTheEventRequests << 2252 if (nKeptEvents == 1) G4cout << " event has";
2377 if (fNKeepTheEventRequests == 0) { << 2253 else G4cout << " events have";
2378 G4warn << "No keep requests were"; << 2254 G4cout << " been kept for refreshing and/or reviewing." << G4endl;
2379 } else if (fNKeepTheEventRequests == 1) << 2255 if (nKeptEvents != fNKeepRequests) {
2380 G4warn << "1 keep request was"; << 2256 G4cout << " (Note: ";
2381 } else { << 2257 if (fNKeepRequests == 0) {
2382 G4warn << fNKeepTheEventRequests << " << 2258 G4cout << "No keep requests were";
>> 2259 } else if (fNKeepRequests == 1) {
>> 2260 G4cout << "Only 1 keep request was";
>> 2261 } else {
>> 2262 G4cout << "Only " << fNKeepRequests << " keep requests were";
>> 2263 }
>> 2264 G4cout << " made by the vis manager.)" << G4endl;
2383 } 2265 }
2384 G4warn << " made by the vis manager."; << 2266 G4cout <<
2385 if (fNKeepTheEventRequests == 0) { << 2267 "\n \"/vis/reviewKeptEvents\" to review them one by one."
2386 G4warn << << 2268 "\n \"/vis/enable\", then \"/vis/viewer/flush\" or \"/vis/viewer/rebuild\" to see them accumulated."
2387 "\n The kept events are those you ha << 2269 << G4endl;
2388 } else { << 2270 }
2389 G4warn << << 2271 // static G4bool warned = false;
2390 "\n The same or further events may h << 2272 // if (!valid && fVerbosity >= warnings && !warned) {
2391 "\n To turn off event keeping by the << 2273 // G4cout <<
2392 "\n or use /vis/scene/endOfEventActi << 2274 // " Only useful if before starting the run:"
2393 } << 2275 // "\n a) trajectories are stored (\"/vis/scene/add/trajectories [smooth|rich]\"), or"
2394 G4warn << G4endl; << 2276 // "\n b) the Draw method of any hits or digis is implemented."
2395 } << 2277 // "\n To view trajectories, hits or digis:"
2396 G4warn << << 2278 // "\n open a viewer, draw a volume, \"/vis/scene/add/trajectories\""
2397 " \"/vis/reviewKeptEvents\" to review one << 2279 // "\n \"/vis/scene/add/hits\" or \"/vis/scene/add/digitisations\""
2398 "\n To see accumulated, \"/vis/enable\", t << 2280 // "\n and, possibly, \"/vis/viewer/flush\"."
2399 << G4endl; << 2281 // "\n To see all events: \"/vis/scene/endOfEventAction accumulate\"."
>> 2282 // "\n (You may need \"/vis/viewer/flush\" or even \"/vis/viewer/rebuild\".)"
>> 2283 // "\n To see events individually: \"/vis/reviewKeptEvents\"."
>> 2284 // << G4endl;
>> 2285 // warned = true;
>> 2286 // }
2400 } 2287 }
2401 2288
2402 if (fVerbosity >= warnings) PrintListOfPlot <<
2403 <<
2404 if (fEventKeepingSuspended && fVerbosity >= 2289 if (fEventKeepingSuspended && fVerbosity >= warnings) {
2405 G4warn << << 2290 G4cout <<
2406 "WARNING: G4VisManager::EndOfRun: Automat 2291 "WARNING: G4VisManager::EndOfRun: Automatic event keeping was suspended."
>> 2292 "\n The number of events in the run exceeded the maximum, "
>> 2293 << fpScene->GetMaxNumberOfKeptEvents() <<
>> 2294 ", that may be\n kept by the vis manager." <<
>> 2295 "\n The number of events kept by the vis manager can be changed with"
>> 2296 "\n \"/vis/scene/endOfEventAction accumulate <N>\", where N is the"
>> 2297 "\n maximum number you wish to allow. N < 0 means \"unlimited\"."
2407 << G4endl; 2298 << G4endl;
2408 if (fpScene->GetMaxNumberOfKeptEvents() > <<
2409 G4warn << <<
2410 " The number of events in the run exce <<
2411 << fpScene->GetMaxNumberOfKeptEvents() <<
2412 ", that may be\n kept by the vis manag <<
2413 "\n The number of events kept by the v <<
2414 "\n \"/vis/scene/endOfEventAction accu <<
2415 "\n maximum number you wish to allow. <<
2416 << G4endl; <<
2417 } <<
2418 } 2299 }
2419 2300
>> 2301 // Don't call IsValidView unless there is a scene handler. This
>> 2302 // avoids WARNING message at end of event and run when the user has
>> 2303 // not instantiated a scene handler, e.g., in batch mode.
>> 2304 G4bool valid = fpSceneHandler && IsValidView();
>> 2305 if (GetConcreteInstance() && valid) {
>> 2306 // // ???? I can't remember why
2420 // // if (!fpSceneHandler->GetMarkForClear 2307 // // if (!fpSceneHandler->GetMarkForClearingTransientStore()) {
2421 // // is here. It prevents ShowView at en 2308 // // is here. It prevents ShowView at end of run, which seems to be OK
2422 // // for sequential mode, but MT mode see 2309 // // for sequential mode, but MT mode seems to need it (I have not
2423 // // figured out why). ???? JA ???? 2310 // // figured out why). ???? JA ????
2424 // if (!fpSceneHandler->GetMarkForClearing 2311 // if (!fpSceneHandler->GetMarkForClearingTransientStore()) {
2425 if (fpScene->GetRefreshAtEndOfRun()) { << 2312 if (fpScene->GetRefreshAtEndOfRun()) {
2426 fpSceneHandler->DrawEndOfRunModels(); << 2313 fpSceneHandler->DrawEndOfRunModels();
2427 // An extra refresh for auto-refresh view << 2314 // An extra refresh for auto-refresh viewers.
2428 // ???? I DON'T WHY THIS IS NECESSARY ??? << 2315 // ???? I DON'T WHY THIS IS NECESSARY ???? JA ????
2429 if (fpViewer->GetViewParameters().IsAutoR << 2316 if (fpViewer->GetViewParameters().IsAutoRefresh()) {
2430 fpViewer->RefreshView(); << 2317 fpViewer->RefreshView();
2431 } << 2318 }
2432 // ShowView guarantees the view is flushe << 2319 // ShowView guarantees the view is flushed to the screen. It also
2433 // triggers other features such picking ( << 2320 // triggers other features such picking (if enabled) and allows
2434 // file-writing viewers to close the file << 2321 // file-writing viewers to close the file.
2435 fpViewer->ShowView(); << 2322 fpViewer->ShowView();
2436 fpSceneHandler->SetMarkForClearingTransie << 2323 fpSceneHandler->SetMarkForClearingTransientStore(true);
2437 } else { << 2324 } else {
2438 if (fpGraphicsSystem->GetFunctionality() << 2325 if (fpGraphicsSystem->GetFunctionality() ==
2439 G4VGraphicsSystem::fileWriter) { << 2326 G4VGraphicsSystem::fileWriter) {
2440 if (fVerbosity >= warnings) { << 2327 if (fVerbosity >= warnings) {
2441 G4warn << "\"/vis/viewer/update\" to << 2328 G4cout << "\"/vis/viewer/update\" to close file." << G4endl;
>> 2329 }
>> 2330 }
2442 } 2331 }
2443 } << 2332 // }
2444 } 2333 }
2445 //} <<
2446 fEventRefreshing = false; 2334 fEventRefreshing = false;
2447 } 2335 }
2448 2336
2449 void G4VisManager::ClearTransientStoreIfMarke 2337 void G4VisManager::ClearTransientStoreIfMarked(){
2450 // Assumes valid view. 2338 // Assumes valid view.
2451 if (fpSceneHandler->GetMarkForClearingTrans 2339 if (fpSceneHandler->GetMarkForClearingTransientStore()) {
2452 fpSceneHandler->SetMarkForClearingTransie 2340 fpSceneHandler->SetMarkForClearingTransientStore(false);
2453 fpSceneHandler->ClearTransientStore(); 2341 fpSceneHandler->ClearTransientStore();
2454 } 2342 }
2455 // Record if transients drawn. These local 2343 // Record if transients drawn. These local flags are only set
2456 // *after* ClearTransientStore. In the cod 2344 // *after* ClearTransientStore. In the code in G4VSceneHandler
2457 // triggered by ClearTransientStore, use th 2345 // triggered by ClearTransientStore, use these flags so that
2458 // event refreshing is not done too early. 2346 // event refreshing is not done too early.
2459 fTransientsDrawnThisEvent = fpSceneHandler- 2347 fTransientsDrawnThisEvent = fpSceneHandler->GetTransientsDrawnThisEvent();
2460 fTransientsDrawnThisRun = fpSceneHandler->G 2348 fTransientsDrawnThisRun = fpSceneHandler->GetTransientsDrawnThisRun();
2461 } 2349 }
2462 2350
2463 void G4VisManager::ResetTransientsDrawnFlags( 2351 void G4VisManager::ResetTransientsDrawnFlags()
2464 { 2352 {
2465 fTransientsDrawnThisRun = false; 2353 fTransientsDrawnThisRun = false;
2466 fTransientsDrawnThisEvent = false; 2354 fTransientsDrawnThisEvent = false;
2467 G4SceneHandlerListConstIterator i; 2355 G4SceneHandlerListConstIterator i;
2468 for (i = fAvailableSceneHandlers.begin(); 2356 for (i = fAvailableSceneHandlers.begin();
2469 i != fAvailableSceneHandlers.end(); ++ 2357 i != fAvailableSceneHandlers.end(); ++i) {
2470 (*i)->SetTransientsDrawnThisEvent(false); 2358 (*i)->SetTransientsDrawnThisEvent(false);
2471 (*i)->SetTransientsDrawnThisRun(false); 2359 (*i)->SetTransientsDrawnThisRun(false);
2472 } 2360 }
2473 } 2361 }
2474 2362
2475 G4String G4VisManager::ViewerShortName (const 2363 G4String G4VisManager::ViewerShortName (const G4String& viewerName) const {
2476 const G4String& viewerShortName = viewerNam << 2364 G4String viewerShortName (viewerName);
2477 return G4StrUtil::strip_copy(viewerShortNam << 2365 viewerShortName = viewerShortName (0, viewerShortName.find (' '));
>> 2366 return viewerShortName.strip ();
2478 } 2367 }
2479 2368
2480 G4VViewer* G4VisManager::GetViewer (const G4S 2369 G4VViewer* G4VisManager::GetViewer (const G4String& viewerName) const {
2481 G4String viewerShortName = ViewerShortName 2370 G4String viewerShortName = ViewerShortName (viewerName);
2482 std::size_t nHandlers = fAvailableSceneHand << 2371 size_t nHandlers = fAvailableSceneHandlers.size ();
2483 std::size_t iHandler, iViewer; << 2372 size_t iHandler, iViewer;
2484 G4VViewer* viewer = 0; 2373 G4VViewer* viewer = 0;
2485 G4bool found = false; 2374 G4bool found = false;
2486 for (iHandler = 0; iHandler < nHandlers; iH 2375 for (iHandler = 0; iHandler < nHandlers; iHandler++) {
2487 G4VSceneHandler* sceneHandler = fAvailabl 2376 G4VSceneHandler* sceneHandler = fAvailableSceneHandlers [iHandler];
2488 const G4ViewerList& viewerList = sceneHan 2377 const G4ViewerList& viewerList = sceneHandler -> GetViewerList ();
2489 for (iViewer = 0; iViewer < viewerList.si 2378 for (iViewer = 0; iViewer < viewerList.size (); iViewer++) {
2490 viewer = viewerList [iViewer]; 2379 viewer = viewerList [iViewer];
2491 if (viewerShortName == viewer -> GetSho 2380 if (viewerShortName == viewer -> GetShortName ()) {
2492 found = true; 2381 found = true;
2493 break; 2382 break;
2494 } 2383 }
2495 } 2384 }
2496 if (found) break; 2385 if (found) break;
2497 } 2386 }
2498 if (found) return viewer; 2387 if (found) return viewer;
2499 else return 0; 2388 else return 0;
2500 } 2389 }
2501 2390
2502 std::vector<G4String> G4VisManager::Verbosity 2391 std::vector<G4String> G4VisManager::VerbosityGuidanceStrings;
2503 2392
2504 G4String G4VisManager::VerbosityString(Verbos 2393 G4String G4VisManager::VerbosityString(Verbosity verbosity) {
2505 G4String rs; 2394 G4String rs;
2506 switch (verbosity) { 2395 switch (verbosity) {
2507 case quiet: rs = "quiet (0)"; break 2396 case quiet: rs = "quiet (0)"; break;
2508 case startup: rs = "startup (1)"; bre 2397 case startup: rs = "startup (1)"; break;
2509 case errors: rs = "errors (2)"; brea 2398 case errors: rs = "errors (2)"; break;
2510 case warnings: rs = "warnings (3)"; br 2399 case warnings: rs = "warnings (3)"; break;
2511 case confirmations: rs = "confirmations (4) 2400 case confirmations: rs = "confirmations (4)"; break;
2512 case parameters: rs = "parameters (5)"; 2401 case parameters: rs = "parameters (5)"; break;
2513 case all: rs = "all (6)"; break; 2402 case all: rs = "all (6)"; break;
2514 } 2403 }
2515 return rs; 2404 return rs;
2516 } 2405 }
2517 2406
2518 void G4VisManager::PrintAvailableVerbosity(st <<
2519 { <<
2520 os << "Available verbosity options:"; <<
2521 for (std::size_t i = 0; i < VerbosityGuidan <<
2522 os << '\n' << VerbosityGuidanceStrings[i] <<
2523 } <<
2524 os << "\nCurrent verbosity: " << G4VisManag <<
2525 os << std::endl; <<
2526 } <<
2527 <<
2528 G4VisManager::Verbosity 2407 G4VisManager::Verbosity
2529 G4VisManager::GetVerbosityValue(const G4Strin 2408 G4VisManager::GetVerbosityValue(const G4String& verbosityString) {
2530 G4String ss = G4StrUtil::to_lower_copy(verb << 2409 G4String ss(verbosityString); ss.toLower();
2531 Verbosity verbosity; 2410 Verbosity verbosity;
2532 if (ss[0] == 'q') verbosity = quiet; << 2411 if (ss(0) == 'q') verbosity = quiet;
2533 else if (ss[0] == 's') verbosity = startup; << 2412 else if (ss(0) == 's') verbosity = startup;
2534 else if (ss[0] == 'e') verbosity = errors; << 2413 else if (ss(0) == 'e') verbosity = errors;
2535 else if (ss[0] == 'w') verbosity = warnings << 2414 else if (ss(0) == 'w') verbosity = warnings;
2536 else if (ss[0] == 'c') verbosity = confirma << 2415 else if (ss(0) == 'c') verbosity = confirmations;
2537 else if (ss[0] == 'p') verbosity = paramete << 2416 else if (ss(0) == 'p') verbosity = parameters;
2538 else if (ss[0] == 'a') verbosity = all; << 2417 else if (ss(0) == 'a') verbosity = all;
2539 else { 2418 else {
2540 // Could be an integer <<
2541 G4int intVerbosity; 2419 G4int intVerbosity;
2542 std::istringstream is(ss); 2420 std::istringstream is(ss);
2543 is >> intVerbosity; 2421 is >> intVerbosity;
2544 if (!is) { 2422 if (!is) {
2545 G4warn << "ERROR: G4VisManager::GetVerb << 2423 G4cerr << "ERROR: G4VisManager::GetVerbosityValue: invalid verbosity \""
2546 << verbosityString << "\"\n"; << 2424 << verbosityString << "\"";
2547 PrintAvailableVerbosity(G4warn); << 2425 for (size_t i = 0; i < VerbosityGuidanceStrings.size(); ++i) {
2548 // Return existing verbosity << 2426 G4cerr << '\n' << VerbosityGuidanceStrings[i];
2549 return fVerbosity; << 2427 }
>> 2428 verbosity = warnings;
>> 2429 G4cerr << "\n Returning " << VerbosityString(verbosity)
>> 2430 << G4endl;
2550 } 2431 }
2551 else { 2432 else {
2552 verbosity = GetVerbosityValue(intVerbos 2433 verbosity = GetVerbosityValue(intVerbosity);
2553 } 2434 }
2554 } 2435 }
2555 return verbosity; 2436 return verbosity;
2556 } 2437 }
2557 2438
2558 G4VisManager::Verbosity G4VisManager::GetVerb 2439 G4VisManager::Verbosity G4VisManager::GetVerbosityValue(G4int intVerbosity) {
2559 Verbosity verbosity; 2440 Verbosity verbosity;
2560 if (intVerbosity < quiet) verbosity = 2441 if (intVerbosity < quiet) verbosity = quiet;
2561 else if (intVerbosity > all) verbosity = 2442 else if (intVerbosity > all) verbosity = all;
2562 else verbosity = 2443 else verbosity = Verbosity(intVerbosity);
2563 return verbosity; 2444 return verbosity;
2564 } 2445 }
2565 2446
2566 G4VisManager::Verbosity G4VisManager::GetVerb 2447 G4VisManager::Verbosity G4VisManager::GetVerbosity () {
2567 return fVerbosity; 2448 return fVerbosity;
2568 } 2449 }
2569 2450
2570 void G4VisManager::SetVerboseLevel (G4int int 2451 void G4VisManager::SetVerboseLevel (G4int intVerbosity) {
2571 fVerbosity = GetVerbosityValue(intVerbosity 2452 fVerbosity = GetVerbosityValue(intVerbosity);
2572 } 2453 }
2573 2454
2574 void G4VisManager::SetVerboseLevel (const G4S 2455 void G4VisManager::SetVerboseLevel (const G4String& verbosityString) {
2575 fVerbosity = GetVerbosityValue(verbosityStr 2456 fVerbosity = GetVerbosityValue(verbosityString);
2576 } 2457 }
2577 2458
2578 G4bool G4VisManager::IsValidView () { 2459 G4bool G4VisManager::IsValidView () {
2579 2460
2580 if (!fInitialised) Initialise (); 2461 if (!fInitialised) Initialise ();
2581 2462
2582 static G4bool noGSPrinting = true; 2463 static G4bool noGSPrinting = true;
2583 if (!fpGraphicsSystem) { 2464 if (!fpGraphicsSystem) {
2584 // Limit printing - we do not want printi 2465 // Limit printing - we do not want printing if the user simply does
2585 // not want to use graphics, e.g., in bat 2466 // not want to use graphics, e.g., in batch mode.
2586 if (noGSPrinting) { 2467 if (noGSPrinting) {
2587 noGSPrinting = false; 2468 noGSPrinting = false;
2588 if (fVerbosity >= warnings) { 2469 if (fVerbosity >= warnings) {
2589 G4warn << << 2470 G4cout <<
2590 "WARNING: G4VisManager::IsValidView(): Atte 2471 "WARNING: G4VisManager::IsValidView(): Attempt to draw when no graphics system"
2591 "\n has been instantiated. Use \"/vis/ope 2472 "\n has been instantiated. Use \"/vis/open\" or \"/vis/sceneHandler/create\"."
2592 "\n Alternatively, to avoid this message, 2473 "\n Alternatively, to avoid this message, suppress instantiation of vis"
2593 "\n manager (G4VisExecutive) and ensure dr 2474 "\n manager (G4VisExecutive) and ensure drawing code is executed only if"
2594 "\n G4VVisManager::GetConcreteInstance() i 2475 "\n G4VVisManager::GetConcreteInstance() is non-zero."
2595 << G4endl; 2476 << G4endl;
2596 } 2477 }
2597 } 2478 }
2598 return false; 2479 return false;
2599 } 2480 }
2600 2481
2601 if ((!fpScene) || (!fpSceneHandler) || (!fp 2482 if ((!fpScene) || (!fpSceneHandler) || (!fpViewer)) {
2602 if (fVerbosity >= errors) { 2483 if (fVerbosity >= errors) {
2603 G4warn << << 2484 G4cerr <<
2604 "ERROR: G4VisManager::IsValidView(): Curren 2485 "ERROR: G4VisManager::IsValidView(): Current view is not valid."
2605 << G4endl; 2486 << G4endl;
2606 PrintInvalidPointers (); 2487 PrintInvalidPointers ();
2607 } 2488 }
2608 return false; 2489 return false;
2609 } 2490 }
2610 2491
2611 if (fpScene != fpSceneHandler -> GetScene ( 2492 if (fpScene != fpSceneHandler -> GetScene ()) {
2612 if (fVerbosity >= errors) { 2493 if (fVerbosity >= errors) {
2613 G4warn << "ERROR: G4VisManager::IsValid << 2494 G4cerr << "ERROR: G4VisManager::IsValidView ():";
2614 if (fpSceneHandler -> GetScene ()) { 2495 if (fpSceneHandler -> GetScene ()) {
2615 G4warn << << 2496 G4cout <<
2616 "\n The current scene \"" 2497 "\n The current scene \""
2617 << fpScene -> GetName () 2498 << fpScene -> GetName ()
2618 << "\" is not handled by" 2499 << "\" is not handled by"
2619 "\n the current scene handler \"" 2500 "\n the current scene handler \""
2620 << fpSceneHandler -> GetName () 2501 << fpSceneHandler -> GetName ()
2621 << "\"" 2502 << "\""
2622 "\n (it currently handles scene \"" 2503 "\n (it currently handles scene \""
2623 << fpSceneHandler -> GetScene () -> 2504 << fpSceneHandler -> GetScene () -> GetName ()
2624 << "\")." 2505 << "\")."
2625 "\n Either:" 2506 "\n Either:"
2626 "\n (a) attach it to the scene handler w 2507 "\n (a) attach it to the scene handler with"
2627 "\n /vis/sceneHandler/attach " 2508 "\n /vis/sceneHandler/attach "
2628 << fpScene -> GetName () 2509 << fpScene -> GetName ()
2629 << ", or" 2510 << ", or"
2630 "\n (b) create a new scene handler with 2511 "\n (b) create a new scene handler with "
2631 "\n /vis/sceneHandler/create <graphi 2512 "\n /vis/sceneHandler/create <graphics-system>,"
2632 "\n in which case it should pick up 2513 "\n in which case it should pick up the the new scene."
2633 << G4endl; 2514 << G4endl;
2634 } 2515 }
2635 else { 2516 else {
2636 G4warn << "\n Scene handler \"" << 2517 G4cout << "\n Scene handler \""
2637 << fpSceneHandler -> GetName () 2518 << fpSceneHandler -> GetName ()
2638 << "\" has null scene pointer." 2519 << "\" has null scene pointer."
2639 "\n Attach a scene with /vis/sceneHandle 2520 "\n Attach a scene with /vis/sceneHandler/attach [<scene-name>]"
2640 << G4endl; 2521 << G4endl;
2641 } 2522 }
2642 } 2523 }
2643 return false; 2524 return false;
2644 } 2525 }
2645 2526
2646 const G4ViewerList& viewerList = fpSceneHan 2527 const G4ViewerList& viewerList = fpSceneHandler -> GetViewerList ();
2647 if (viewerList.size () == 0) { 2528 if (viewerList.size () == 0) {
2648 if (fVerbosity >= errors) { 2529 if (fVerbosity >= errors) {
2649 G4warn << << 2530 G4cerr <<
2650 "ERROR: G4VisManager::IsValidView (): the c 2531 "ERROR: G4VisManager::IsValidView (): the current scene handler\n \""
2651 << fpSceneHandler -> GetName () 2532 << fpSceneHandler -> GetName ()
2652 << "\" has no viewers. Do /vis/viewer 2533 << "\" has no viewers. Do /vis/viewer/create."
2653 << G4endl; 2534 << G4endl;
2654 } 2535 }
2655 return false; 2536 return false;
2656 } 2537 }
2657 2538
2658 G4bool isValid = true; 2539 G4bool isValid = true;
2659 if (fpScene -> IsEmpty ()) { // Add world 2540 if (fpScene -> IsEmpty ()) { // Add world by default if possible...
2660 G4bool warn(fVerbosity >= warnings); 2541 G4bool warn(fVerbosity >= warnings);
2661 G4bool successful = fpScene -> AddWorldIf 2542 G4bool successful = fpScene -> AddWorldIfEmpty (warn);
2662 if (!successful || fpScene -> IsEmpty ()) 2543 if (!successful || fpScene -> IsEmpty ()) { // If still empty...
2663 if (fVerbosity >= errors) { 2544 if (fVerbosity >= errors) {
2664 G4warn << "ERROR: G4VisManager::IsValidView << 2545 G4cerr << "ERROR: G4VisManager::IsValidView ():";
2665 G4warn << << 2546 G4cerr <<
2666 "\n Attempt at some drawing operation wh 2547 "\n Attempt at some drawing operation when scene is empty."
2667 "\n Maybe the geometry has not yet been 2548 "\n Maybe the geometry has not yet been defined."
2668 " Try /run/initialize." 2549 " Try /run/initialize."
2669 "\n Or use \"/vis/scene/add/extent 2550 "\n Or use \"/vis/scene/add/extent\"."
2670 << G4endl; 2551 << G4endl;
2671 } 2552 }
2672 isValid = false; 2553 isValid = false;
2673 } 2554 }
2674 else { 2555 else {
2675 G4UImanager::GetUIpointer()->ApplyComma 2556 G4UImanager::GetUIpointer()->ApplyCommand ("/vis/scene/notifyHandlers");
2676 if (fVerbosity >= warnings) { 2557 if (fVerbosity >= warnings) {
2677 G4warn << << 2558 G4cout <<
2678 "WARNING: G4VisManager: the scene was emp 2559 "WARNING: G4VisManager: the scene was empty, \"world\" has been"
2679 "\n added and the scene handlers notifie 2560 "\n added and the scene handlers notified.";
2680 G4warn << G4endl; << 2561 G4cout << G4endl;
2681 } 2562 }
2682 } 2563 }
2683 } 2564 }
2684 return isValid; 2565 return isValid;
2685 } 2566 }
2686 2567
2687 void 2568 void
2688 G4VisManager::RegisterModelFactories() 2569 G4VisManager::RegisterModelFactories()
2689 { 2570 {
2690 if (fVerbosity >= warnings) { 2571 if (fVerbosity >= warnings) {
2691 G4warn<<"G4VisManager: No model factories << 2572 G4cout<<"G4VisManager: No model factories registered with G4VisManager."<<G4endl;
2692 G4warn<<"G4VisManager::RegisterModelFacto << 2573 G4cout<<"G4VisManager::RegisterModelFactories() should be overridden in derived"<<G4endl;
2693 G4warn<<"class. See G4VisExecutive for an << 2574 G4cout<<"class. See G4VisExecutive for an example."<<G4endl;
2694 } 2575 }
2695 } 2576 }
2696 2577
>> 2578 #ifdef G4MULTITHREADED
2697 void G4VisManager::SetUpForAThread() 2579 void G4VisManager::SetUpForAThread()
2698 { 2580 {
2699 // TODO: protect with G4Threading::IsMultit <<
2700 #ifdef G4MULTITHREADED <<
2701 new G4VisStateDependent(this); 2581 new G4VisStateDependent(this);
2702 #endif <<
2703 } 2582 }
>> 2583 #endif
2704 2584
2705 void G4VisManager::IgnoreStateChanges(G4bool 2585 void G4VisManager::IgnoreStateChanges(G4bool val)
2706 { 2586 {
2707 fIgnoreStateChanges = val; 2587 fIgnoreStateChanges = val;
2708 } 2588 }
2709 2589