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