| Geant4 Cross Reference |
>> 1 // This code implementation is the intellectual property of
>> 2 // the GEANT4 collaboration.
1 // 3 //
2 // ******************************************* << 4 // By copying, distributing or modifying the Program (or any work
3 // * License and Disclaimer << 5 // based on the Program) you indicate your acceptance of this statement,
4 // * << 6 // and all its terms.
5 // * The Geant4 software is copyright of th <<
6 // * the Geant4 Collaboration. It is provided <<
7 // * conditions of the Geant4 Software License <<
8 // * LICENSE and available at http://cern.ch/ <<
9 // * include a list of copyright holders. <<
10 // * <<
11 // * Neither the authors of this software syst <<
12 // * institutes,nor the agencies providing fin <<
13 // * work make any representation or warran <<
14 // * regarding this software system or assum <<
15 // * use. Please see the license in the file <<
16 // * for the full disclaimer and the limitatio <<
17 // * <<
18 // * This code implementation is the result <<
19 // * technical work of the GEANT4 collaboratio <<
20 // * By using, copying, modifying or distri <<
21 // * any work based on the software) you ag <<
22 // * use in resulting scientific publicati <<
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* <<
25 // 7 //
>> 8 // $Id: G4VisManager.cc,v 1.21 2001/02/23 15:43:32 johna Exp $
>> 9 // GEANT4 tag $Name: geant4-03-01 $
26 // 10 //
27 // 11 //
28 // GEANT4 Visualization Manager - John Allison 12 // GEANT4 Visualization Manager - John Allison 02/Jan/1996.
29 // Michael Kelsey 31 Jan 2019 -- Add new comm <<
30 13
31 #include "G4VisManager.hh" 14 #include "G4VisManager.hh"
32 15
33 #include "G4VisCommands.hh" <<
34 #include "G4VisCommandsCompound.hh" <<
35 #include "G4VisCommandsGeometry.hh" <<
36 #include "G4VisCommandsGeometrySet.hh" <<
37 #include "G4VisCommandsMultithreading.hh" <<
38 #include "G4VisCommandsSet.hh" <<
39 #include "G4VisCommandsScene.hh" <<
40 #include "G4VisCommandsSceneAdd.hh" <<
41 #include "G4VisCommandsPlotter.hh" <<
42 #include "G4VisCommandsSceneHandler.hh" <<
43 #include "G4VisCommandsTouchable.hh" <<
44 #include "G4VisCommandsTouchableSet.hh" <<
45 #include "G4VisCommandsViewer.hh" <<
46 #include "G4VisCommandsViewerDefault.hh" <<
47 #include "G4VisCommandsViewerSet.hh" <<
48 #include "G4UImanager.hh" 16 #include "G4UImanager.hh"
49 #include "G4VisStateDependent.hh" 17 #include "G4VisStateDependent.hh"
50 #include "G4UIdirectory.hh" 18 #include "G4UIdirectory.hh"
>> 19 #include "G4VisFeaturesOfFukuiRenderer.hh"
>> 20 #include "G4VisFeaturesOfDAWNFILE.hh"
>> 21 #include "G4VisFeaturesOfOpenGL.hh"
>> 22 #include "G4VisFeaturesOfOpenInventor.hh"
51 #include "G4VGraphicsSystem.hh" 23 #include "G4VGraphicsSystem.hh"
52 #include "G4VSceneHandler.hh" 24 #include "G4VSceneHandler.hh"
53 #include "G4VViewer.hh" 25 #include "G4VViewer.hh"
54 #include "G4VPhysicalVolume.hh" 26 #include "G4VPhysicalVolume.hh"
55 #include "G4LogicalVolume.hh" 27 #include "G4LogicalVolume.hh"
56 #include "G4VSolid.hh" 28 #include "G4VSolid.hh"
57 #include "G4Vector3D.hh" 29 #include "G4Vector3D.hh"
58 #include "G4Point3D.hh" 30 #include "G4Point3D.hh"
59 #include "G4RotationMatrix.hh" 31 #include "G4RotationMatrix.hh"
60 #include "G4Polyline.hh" 32 #include "G4Polyline.hh"
61 #include "G4Polyhedron.hh" 33 #include "G4Polyhedron.hh"
>> 34 #include "G4NURBS.hh"
62 #include "G4NullModel.hh" 35 #include "G4NullModel.hh"
63 #include "G4ModelingParameters.hh" 36 #include "G4ModelingParameters.hh"
64 #include "G4TransportationManager.hh" 37 #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 38
110 // Class statics << 39 #include "G4VisManMessenger.hh"
111 G4VisManager* G4VisManager::fpInstance = 0; << 40 // TEMPORARY /vis/ -> /vis~/ equivalence.
>> 41 #include "G4VisToOldVisCommands.hh"
112 42
113 G4VisManager::Verbosity G4VisManager::fVerbosi << 43 #include "G4ios.hh"
114 44
115 G4VisManager::G4VisManager (const G4String& ve << 45 G4VisManager* G4VisManager::fpInstance = 0;
116 : fVerbose (1) <<
117 , fDefaultGraphicsSystemName("OGL") / <<
118 , fDefaultXGeometryString ("600x600-0+0") / <<
119 , fDefaultGraphicsSystemBasis ("G4VisManager i <<
120 , fDefaultXGeometryStringBasis("G4VisManager i <<
121 , fInitialised (false) <<
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 { <<
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 46
>> 47 G4VisManager::G4VisManager ():
>> 48 fInitialised (false),
>> 49 fpGraphicsSystem (0),
>> 50 fpScene (0),
>> 51 fpSceneHandler (0),
>> 52 fpViewer (0),
>> 53 fVerbose (0) // All other objects use default constructors.
>> 54 {
169 if (fpInstance) { 55 if (fpInstance) {
170 G4Exception 56 G4Exception
171 ("G4VisManager::G4VisManager", << 57 ("G4VisManager: attempt to Construct more than one VisManager.");
172 "visman0001", FatalException, << 58 }
173 "Attempt to Construct more than one Vis << 59 else {
174 } << 60
175 << 61 fpInstance = this;
176 fpInstance = this; << 62
177 SetConcreteInstance(this); << 63 fpStateDependent = new G4VisStateDependent (this);
178 << 64 // No need to delete this; G4StateManager does this.
179 fpStateDependent = new G4VisStateDependent ( << 65
180 // No need to delete this; G4StateManager do << 66 G4cout << "Constructing Visualization Manager...." << G4endl;
181 << 67 // Note: You might think that we could register graphics systems
182 fVerbosity = GetVerbosityValue(verbosityStri << 68 // and messengers here but we have to give the subclass time to
183 if (fVerbosity >= startup) { << 69 // instantiate. So the user has to invoke Initialise().
184 G4cout << 70 }
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 <<
222 // Instantiate *basic* top level commands so <<
223 // immediately after instantiation of the vi <<
224 // level and lower level commands are instan <<
225 // RegisterMessengers. <<
226 G4VVisCommand::SetVisManager (this); // Set <<
227 RegisterMessenger(new G4VisCommandVerbose); <<
228 RegisterMessenger(new G4VisCommandInitialize <<
229 } 71 }
230 72
231 G4VisManager::~G4VisManager() << 73 G4VisManager::~G4VisManager () {
232 { << 74 fpInstance = 0;
233 G4UImanager* UImanager = G4UImanager::GetUIp << 75 int i;
234 UImanager->SetCoutDestination(nullptr); <<
235 std::size_t i; <<
236 for (i = 0; i < fSceneList.size (); ++i) { 76 for (i = 0; i < fSceneList.size (); ++i) {
237 delete fSceneList[i]; 77 delete fSceneList[i];
238 } 78 }
239 for (i = 0; i < fAvailableSceneHandlers.size 79 for (i = 0; i < fAvailableSceneHandlers.size (); ++i) {
240 if (fAvailableSceneHandlers[i] != NULL) { <<
241 delete fAvailableSceneHandlers[i]; 80 delete fAvailableSceneHandlers[i];
242 } 81 }
243 } <<
244 for (i = 0; i < fAvailableGraphicsSystems.si 82 for (i = 0; i < fAvailableGraphicsSystems.size (); ++i) {
245 if (fAvailableGraphicsSystems[i]) { << 83 delete fAvailableGraphicsSystems[i];
246 delete fAvailableGraphicsSystems[i]; <<
247 } <<
248 } <<
249 if (fVerbosity >= startup) { <<
250 G4cout << "Graphics systems deleted." << G <<
251 G4cout << "Visualization Manager deleting. <<
252 } 84 }
>> 85 G4cout << "Graphics systems deleted." << G4endl;
>> 86 G4cout << "VisManager deleting." << G4endl;
253 for (i = 0; i < fMessengerList.size (); ++i) 87 for (i = 0; i < fMessengerList.size (); ++i) {
254 delete fMessengerList[i]; 88 delete fMessengerList[i];
255 } 89 }
256 for (i = 0; i < fDirectoryList.size (); ++i) << 90 delete fpMessenger;
257 delete fDirectoryList[i]; <<
258 } <<
259 <<
260 delete fpDigiFilterMgr; <<
261 delete fpHitFilterMgr; <<
262 delete fpTrajFilterMgr; <<
263 delete fpTrajDrawModelMgr; <<
264 fpInstance = 0; <<
265 } 91 }
266 92
267 G4VisManager* G4VisManager::GetInstance () { 93 G4VisManager* G4VisManager::GetInstance () {
268 if (!fpInstance) { 94 if (!fpInstance) {
269 G4Exception 95 G4Exception
270 ("G4VisManager::GetInstance", << 96 ("G4VisManager::GetInstance: VisManager not yet instantiated!");
271 "visman0002", FatalException, "VisManag <<
272 } 97 }
273 return fpInstance; 98 return fpInstance;
274 } 99 }
275 100
276 void G4VisManager::Initialise () { 101 void G4VisManager::Initialise () {
277 102
278 if (fInitialised && fVerbosity >= warnings) << 103 G4cout << "Initialising Visualization Manager...." << G4endl;
279 G4warn << "WARNING: G4VisManager::Initiali <<
280 << G4endl; <<
281 return; <<
282 } <<
283 <<
284 if (fVerbosity >= startup) { <<
285 G4cout << "Visualization Manager initialis <<
286 } <<
287 104
288 if (fVerbosity >= parameters) { << 105 if (fVerbose > 0) {
>> 106 PrintAllGraphicsSystems ();
>> 107 PrintInstalledGraphicsSystems ();
289 G4cout << 108 G4cout <<
290 "\nYou have instantiated your own Visual 109 "\nYou have instantiated your own Visualization Manager, inheriting"
291 "\n G4VisManager and implementing Regis << 110 "\n G4VisManager and implementing RegisterGraphicsSystems. An example"
292 "\n you should, normally, instantiate d << 111 "\n class MyVisManager is provided which is controlled by the"
293 "\n external packages or libraries, and << 112 "\n following environment variables:"
294 "\n control of environment variables." << 113 #ifdef G4VIS_BUILD_DAWN_DRIVER
295 "\n Also you should implement RegisterM << 114 "\n G4VIS_USE_DAWN"
296 "\n See visualization/management/includ << 115 #endif
297 "\n In your main() you will have someth << 116 #ifdef G4VIS_BUILD_DAWNFILE_DRIVER
298 "\n G4VisManager* visManager = new G4 << 117 "\n G4VIS_USE_DAWNFILE"
299 "\n visManager -> SetVerboseLevel (Ve << 118 #endif
>> 119 #ifdef G4VIS_BUILD_OPACS_DRIVER
>> 120 "\n G4VIS_USE_OPACS"
>> 121 #endif
>> 122 #ifdef G4VIS_BUILD_OPENGLX_DRIVER
>> 123 "\n G4VIS_USE_OPENGLX"
>> 124 #endif
>> 125 #ifdef G4VIS_BUILD_OPENGLXM_DRIVER
>> 126 "\n G4VIS_USE_OPENGLXM"
>> 127 #endif
>> 128 #ifdef G4VIS_BUILD_OIX_DRIVER
>> 129 "\n G4VIS_USE_OIX"
>> 130 #endif
>> 131 #ifdef G4VIS_BUILD_OIWIN32_DRIVER
>> 132 "\n G4VIS_USE_OIWIN32"
>> 133 #endif
>> 134 #ifdef G4VIS_BUILD_VRML_DRIVER
>> 135 "\n G4VIS_USE_VRML"
>> 136 #endif
>> 137 #ifdef G4VIS_BUILD_VRMLFILE_DRIVER
>> 138 "\n G4VIS_USE_VRMLFILE"
>> 139 #endif
>> 140 #ifdef G4VIS_BUILD_RAYTRACER_DRIVER
>> 141 "\n G4VIS_USE_RAYTRACER"
>> 142 #endif
>> 143 "\n Thus, in your main() you have something like:"
>> 144 "\n G4VisManager* visManager = new MyVisManager;"
300 "\n visManager -> Initialize ();" 145 "\n visManager -> Initialize ();"
301 "\n (Don't forget to delete visManager; 146 "\n (Don't forget to delete visManager;)"
302 "\n" <<
303 << G4endl; 147 << G4endl;
304 } 148 }
305 << 149
306 if (fVerbosity >= startup) { << 150 G4cout << "Registering graphics systems...." << G4endl;
307 G4cout << "Registering graphics systems... <<
308 } <<
309 151
310 RegisterGraphicsSystems (); 152 RegisterGraphicsSystems ();
311 153
312 if (fVerbosity >= startup) { <<
313 G4cout << <<
314 "\nYou have successfully registered the <<
315 << G4endl; <<
316 PrintAvailableGraphicsSystems (fVerbosity) <<
317 G4cout << G4endl; <<
318 } <<
319 <<
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 (); 154 RegisterMessengers ();
357 155
358 if (fVerbosity >= startup) { << 156 // Remaining commands - not yet template-ised.
359 G4cout << "Registering model factories..." << 157 fpMessenger = new G4VisManMessenger (this);
360 } <<
361 158
362 RegisterModelFactories(); << 159 // TEMPORARY /vis/ -> /vis~/ equivalence.
363 << 160 fMessengerList.push_back (new G4VisToOldVisCommands);
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 161
386 fInitialised = true; 162 fInitialised = true;
387 } 163 }
388 164
389 void G4VisManager::InitialiseG4ColourMap() con << 165 // void G4VisManager::RegisterMessengers () - see separate file,
390 { << 166 // 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 167
750 void G4VisManager::Enable() { 168 void G4VisManager::Enable() {
751 if (IsValidView ()) { 169 if (IsValidView ()) {
752 SetConcreteInstance(this); << 170 G4cout << "G4VisManager::Enable: visualization enabled." << G4endl;
753 if (fVerbosity >= confirmations) { <<
754 G4cout << "G4VisManager::Enable: visuali <<
755 } <<
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 } 171 }
774 else { 172 else {
775 if (fVerbosity >= warnings) { << 173 G4cout <<
776 G4warn << << 174 "G4VisManager::Enable: visualization remains disabled for above reasons."
777 "G4VisManager::Enable: WARNING: visualizatio << 175 "\n Rectifying with valid vis commands will automatically enable."
778 "\n above reasons. Rectifying with valid v << 176 << G4endl;
779 "\n automatically enable." <<
780 << G4endl; <<
781 } <<
782 } 177 }
783 } 178 }
784 179
785 void G4VisManager::Disable() { 180 void G4VisManager::Disable() {
786 SetConcreteInstance(0); << 181 fpConcreteInstance = 0;
787 if (fVerbosity >= confirmations) { << 182 G4cout <<
788 G4cout << <<
789 "G4VisManager::Disable: visualization disa 183 "G4VisManager::Disable: visualization disabled."
790 "\n The pointer returned by GetConcreteIn <<
791 "\n Note that it will become enabled afte 184 "\n Note that it will become enabled after some valid vis commands."
792 << G4endl; << 185 << G4endl;
793 } <<
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 } 186 }
809 187
810 const G4GraphicsSystemList& G4VisManager::GetA 188 const G4GraphicsSystemList& G4VisManager::GetAvailableGraphicsSystems () {
811 std::size_t nSystems = fAvailableGraphicsSys << 189 G4int nSystems = fAvailableGraphicsSystems.size ();
812 if (nSystems == 0) { 190 if (nSystems == 0) {
813 if (fVerbosity >= warnings) { << 191 G4cout << "G4VisManager::GetAvailableGraphicsSystems: WARNING: no graphics"
814 G4warn << "G4VisManager::GetAvailableGra << 192 " system available!"
815 "\n graphics system available!" << 193 "\n 1) Did you have environment variables G4VIS_BUILD_xxxx_DRIVER set"
816 "\n 1) Did you have environment variables G << 194 "\n when you compiled/built the visualization code?"
817 "\n when you compiled/built the visualiz << 195 "\n 2) Did you instantiate your own Visualization Manager and forget"
818 "\n 2) Did you instantiate your own Visuali << 196 "\n to implement RegisterGraphicsSystems correctly?"
819 "\n to implement RegisterGraphicsSystems << 197 "\n 3) You can register your own graphics system, e.g.,"
820 "\n 3) You can register your own graphics s << 198 "\n G4VisManager::GetInstance () ->"
821 "\n visManager->RegisterGraphicsSystem(n << 199 "\n RegisterGraphicsSystem (new MyGraphicsSystem);)"
822 "\n after instantiating your vis manager << 200 << G4endl;
823 "\n visManager->Initialize()." <<
824 << G4endl; <<
825 } <<
826 } 201 }
827 return fAvailableGraphicsSystems; 202 return fAvailableGraphicsSystems;
828 } 203 }
829 204
830 G4bool G4VisManager::RegisterGraphicsSystem (G 205 G4bool G4VisManager::RegisterGraphicsSystem (G4VGraphicsSystem* pSystem) {
831 G4bool happy = true; << 206 if (pSystem -> GetFunctionality () == G4VGraphicsSystem::noFunctionality) {
832 if (pSystem) { << 207 G4cout << "G4VisManager::RegisterGraphicsSystem: WARNING: attempt to"
>> 208 "\n register a \"no functionality\" graphics system, probably an"
>> 209 "\n unbuilt system, i.e., a system not available locally. Please"
>> 210 "\n consult your computer manager. System was "
>> 211 << pSystem -> GetName ();
>> 212 if (pSystem -> GetNickname () != "") {
>> 213 G4cout << " (" << pSystem -> GetNickname () << ")";
>> 214 }
>> 215 G4cout << G4endl;
>> 216 return false;
>> 217 }
>> 218 else {
833 fAvailableGraphicsSystems.push_back (pSyst 219 fAvailableGraphicsSystems.push_back (pSystem);
834 if (fVerbosity >= confirmations) { << 220 if (fVerbose > 0) {
835 G4cout << "G4VisManager::RegisterGraphic 221 G4cout << "G4VisManager::RegisterGraphicsSystem: "
836 << pSystem -> GetName (); << 222 << pSystem -> GetName ();
837 if (pSystem -> GetNickname () != "") { 223 if (pSystem -> GetNickname () != "") {
838 G4cout << " (" << pSystem -> GetNickname () 224 G4cout << " (" << pSystem -> GetNickname () << ")";
839 } 225 }
840 G4cout << " registered." << G4endl; 226 G4cout << " registered." << G4endl;
841 } 227 }
>> 228 return true;
842 } 229 }
843 else { << 230 }
844 if (fVerbosity >= errors) { << 231
845 G4warn << "G4VisManager::RegisterGraphic << 232 void G4VisManager::CopyViewParameters () {
846 << G4endl; << 233 if (IsValidView ()) {
847 } << 234 fVP = fpViewer -> GetViewParameters ();
848 happy=false; <<
849 } 235 }
850 return happy; <<
851 } 236 }
852 237
853 const G4VTrajectoryModel* << 238 /***********
854 G4VisManager::CurrentTrajDrawModel() const << 239 void G4VisManager::Clear () {
855 { <<
856 assert (0 != fpTrajDrawModelMgr); <<
857 240
858 const G4VTrajectoryModel* model = fpTrajDraw << 241 // Clear current scene and current view, marking all its views as
>> 242 // needing refreshing. This is a comprehensive clear which clears
>> 243 // both framebuffers of a double buffered system and clears the
>> 244 // scene's graphics databse (display lists, etc.) and clears the
>> 245 // current scene data.
859 246
860 if (0 == model) { << 247 if (IsValidView ()) {
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 248
870 model = fpTrajDrawModelMgr->Current(); << 249 fpViewer -> ClearView ();
871 assert (0 != model); // Should definitely ex << 250 // Clears current buffer, i.e., back buffer in case of double
>> 251 // buffered system.
872 252
873 return model; << 253 fpViewer -> FinishView ();
874 } << 254 // Swaps buffers of double buffered systems.
875 255
876 void G4VisManager::RegisterModel(G4VTrajectory << 256 fpViewer -> ClearView ();
877 { << 257 // Clears the swapped buffer.
878 fpTrajDrawModelMgr->Register(model); <<
879 } <<
880 258
881 void << 259 fpViewer -> NeedKernelVisit ();
882 G4VisManager::RegisterModelFactory(G4TrajDrawM << 260 // Informs all views of need to revisit kernel.
883 { <<
884 fpTrajDrawModelMgr->Register(factory); <<
885 } <<
886 261
887 void G4VisManager::RegisterModel(G4VFilter<G4V << 262 fpSceneHandler -> ClearStore ();
888 { << 263 // Clears the graphics database (display lists) if any.
889 fpTrajFilterMgr->Register(model); <<
890 } <<
891 264
892 void << 265 fSD.Clear ();
893 G4VisManager::RegisterModelFactory(G4TrajFilte << 266 fpSceneHandler -> SetSceneData (fSD);
894 { << 267 // Clears current scene data - then updates scene.
895 fpTrajFilterMgr->Register(factory); << 268 }
896 } 269 }
>> 270 *****************/
897 271
898 void G4VisManager::RegisterModel(G4VFilter<G4V << 272 /****************
899 { << 273 void G4VisManager::ClearScene () {
900 fpHitFilterMgr->Register(model); <<
901 } <<
902 274
903 void << 275 // Clear current scene, marking all its views as needing refreshing.
904 G4VisManager::RegisterModelFactory(G4HitFilter << 276 // Clears the scene handler's graphics database (display lists, etc.)
905 { <<
906 fpHitFilterMgr->Register(factory); <<
907 } <<
908 277
909 void G4VisManager::RegisterModel(G4VFilter<G4V << 278 if (IsValidView ()) {
910 { <<
911 fpDigiFilterMgr->Register(model); <<
912 } <<
913 279
914 void << 280 fpViewer -> NeedKernelVisit ();
915 G4VisManager::RegisterModelFactory(G4DigiFilte << 281 // Informs all views of need to revisit kernel.
916 { <<
917 fpDigiFilterMgr->Register(factory); <<
918 } <<
919 282
920 void G4VisManager::SelectTrajectoryModel(const << 283 fpSceneHandler -> ClearStore ();
921 { << 284 // Clears the graphics database (display lists) if any.
922 fpTrajDrawModelMgr->SetCurrent(model); <<
923 } <<
924 285
925 void G4VisManager::BeginDraw (const G4Transfor << 286 fSD.Clear ();
926 { << 287 fpSceneHandler -> SetSceneData (fSD);
927 if (G4Threading::IsWorkerThread()) return; << 288 // Clears current scene data - then updates scene.
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 ()) { <<
939 ClearTransientStoreIfMarked(); <<
940 fpSceneHandler -> BeginPrimitives (objectT <<
941 fIsDrawGroup = true; <<
942 } 289 }
943 } 290 }
>> 291 ********************/
>> 292
>> 293 void G4VisManager::ClearView () {
>> 294
>> 295 // Clear visible window of current view (both buffers of a double
>> 296 // buffered system).
944 297
945 void G4VisManager::EndDraw () <<
946 { <<
947 if (G4Threading::IsWorkerThread()) return; <<
948 <<
949 fDrawGroupNestingDepth--; <<
950 if (fDrawGroupNestingDepth != 0) { <<
951 if (fDrawGroupNestingDepth < 0) fDrawGroup <<
952 return; <<
953 } <<
954 if (IsValidView ()) { 298 if (IsValidView ()) {
955 fpSceneHandler -> EndPrimitives (); << 299
>> 300 fpViewer -> ClearView ();
>> 301 // Clears current buffer, i.e., back buffer in case of double
>> 302 // buffered system.
>> 303
>> 304 fpViewer -> FinishView ();
>> 305 // Swaps buffers of double buffered systems.
>> 306
>> 307 fpViewer -> ClearView ();
>> 308 // Clears the swapped buffer.
956 } 309 }
957 fIsDrawGroup = false; <<
958 } 310 }
959 311
960 void G4VisManager::BeginDraw2D (const G4Transf << 312 void G4VisManager::Draw () {
961 { <<
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 ()) { 313 if (IsValidView ()) {
974 ClearTransientStoreIfMarked(); << 314 fpViewer -> SetViewParameters (fVP);
975 fpSceneHandler -> BeginPrimitives2D (objec << 315 fpViewer -> DrawView ();
976 fIsDrawGroup = true; <<
977 } 316 }
978 } 317 }
979 318
980 void G4VisManager::EndDraw2D () << 319 void G4VisManager::Show () {
981 { <<
982 if (G4Threading::IsWorkerThread()) return; <<
983 <<
984 fDrawGroupNestingDepth--; <<
985 if (fDrawGroupNestingDepth != 0) { <<
986 if (fDrawGroupNestingDepth < 0) fDrawGroup <<
987 return; <<
988 } <<
989 if (IsValidView ()) { 320 if (IsValidView ()) {
990 fpSceneHandler -> EndPrimitives2D (); << 321 fpViewer -> ShowView ();
991 } 322 }
992 fIsDrawGroup = false; <<
993 } 323 }
994 324
995 template <class T> void G4VisManager::DrawT << 325 void G4VisManager::Draw (const G4Polyline& line,
996 (const T& graphics_primitive, const G4Transfor << 326 const G4Transform3D& objectTransform) {
997 if (G4Threading::IsWorkerThread()) return; << 327 if (IsValidView ()) {
998 << 328 G4ModelingParameters* pMP = fpSceneHandler -> CreateModelingParameters ();
999 if (fIsDrawGroup) { << 329 G4VModel* pModel = new G4NullModel (pMP);
1000 if (objectTransform != fpSceneHandler->Ge << 330 fpSceneHandler -> SetModel (pModel);
1001 G4Exception << 331 fpSceneHandler -> BeginPrimitives (objectTransform);
1002 ("G4VSceneHandler::DrawT", << 332 fpSceneHandler -> AddPrimitive (line);
1003 "visman0010", FatalException, << 333 fpSceneHandler -> EndPrimitives ();
1004 "Different transform detected in Begin/End << 334 fpSceneHandler -> SetModel (0);
1005 } << 335 delete pModel;
1006 fpSceneHandler -> AddPrimitive (graphics_ << 336 delete pMP;
1007 } else { <<
1008 if (IsValidView ()) { <<
1009 ClearTransientStoreIfMarked(); <<
1010 fpSceneHandler -> BeginPrimitives (obje <<
1011 fpSceneHandler -> AddPrimitive (graphic <<
1012 fpSceneHandler -> EndPrimitives (); <<
1013 } <<
1014 } 337 }
1015 } 338 }
1016 339
1017 template <class T> void G4VisManager::DrawT2D << 340 void G4VisManager::Draw (const G4Text& text,
1018 (const T& graphics_primitive, const G4Transfo << 341 const G4Transform3D& objectTransform) {
1019 if (G4Threading::IsWorkerThread()) return; << 342 if (IsValidView ()) {
1020 << 343 G4ModelingParameters* pMP = fpSceneHandler -> CreateModelingParameters ();
1021 if (fIsDrawGroup) { << 344 G4VModel* pModel = new G4NullModel (pMP);
1022 if (objectTransform != fpSceneHandler->Ge << 345 fpSceneHandler -> SetModel (pModel);
1023 G4Exception << 346 fpSceneHandler -> BeginPrimitives (objectTransform);
1024 ("G4VSceneHandler::DrawT", << 347 fpSceneHandler -> AddPrimitive (text);
1025 "visman0011", FatalException, << 348 fpSceneHandler -> EndPrimitives ();
1026 "Different transform detected in Begin/End << 349 fpSceneHandler -> SetModel (0);
1027 } << 350 delete pModel;
1028 fpSceneHandler -> AddPrimitive (graphics_ << 351 delete pMP;
1029 } else { <<
1030 if (IsValidView ()) { <<
1031 ClearTransientStoreIfMarked(); <<
1032 fpSceneHandler -> BeginPrimitives2D (ob <<
1033 fpSceneHandler -> AddPrimitive (graphic <<
1034 fpSceneHandler -> EndPrimitives2D (); <<
1035 } <<
1036 } 352 }
1037 } 353 }
1038 354
1039 void G4VisManager::Draw (const G4Circle& circ 355 void G4VisManager::Draw (const G4Circle& circle,
1040 const G4Transform3D& objectTransform) << 356 const G4Transform3D& objectTransform) {
1041 { << 357 if (IsValidView ()) {
1042 DrawT (circle, objectTransform); << 358 G4ModelingParameters* pMP = fpSceneHandler -> CreateModelingParameters ();
1043 } << 359 G4VModel* pModel = new G4NullModel (pMP);
1044 << 360 fpSceneHandler -> SetModel (pModel);
1045 void G4VisManager::Draw (const G4Polyhedron& << 361 fpSceneHandler -> BeginPrimitives (objectTransform);
1046 const G4Transform3D& objectTransform) << 362 fpSceneHandler -> AddPrimitive (circle);
1047 { << 363 fpSceneHandler -> EndPrimitives ();
1048 DrawT (polyhedron, objectTransform); << 364 fpSceneHandler -> SetModel (0);
>> 365 delete pModel;
>> 366 delete pMP;
>> 367 }
1049 } 368 }
1050 369
1051 void G4VisManager::Draw (const G4Polyline& li << 370 void G4VisManager::Draw (const G4Square& Square,
1052 const G4Transform3D& objectTransform) << 371 const G4Transform3D& objectTransform) {
1053 { << 372 if (IsValidView ()) {
1054 DrawT (line, objectTransform); << 373 G4ModelingParameters* pMP = fpSceneHandler -> CreateModelingParameters ();
>> 374 G4VModel* pModel = new G4NullModel (pMP);
>> 375 fpSceneHandler -> SetModel (pModel);
>> 376 fpSceneHandler -> BeginPrimitives (objectTransform);
>> 377 fpSceneHandler -> AddPrimitive (Square);
>> 378 fpSceneHandler -> EndPrimitives ();
>> 379 fpSceneHandler -> SetModel (0);
>> 380 delete pModel;
>> 381 delete pMP;
>> 382 }
1055 } 383 }
1056 384
1057 void G4VisManager::Draw (const G4Polymarker& 385 void G4VisManager::Draw (const G4Polymarker& polymarker,
1058 const G4Transform3D& objectTransform) << 386 const G4Transform3D& objectTransform) {
1059 { << 387 if (IsValidView ()) {
1060 DrawT (polymarker, objectTransform); << 388 G4ModelingParameters* pMP = fpSceneHandler -> CreateModelingParameters ();
1061 } << 389 G4VModel* pModel = new G4NullModel (pMP);
1062 << 390 fpSceneHandler -> SetModel (pModel);
1063 void G4VisManager::Draw (const G4Square& squa << 391 fpSceneHandler -> BeginPrimitives (objectTransform);
1064 const G4Transform3D& objectTransform) << 392 fpSceneHandler -> AddPrimitive (polymarker);
1065 { << 393 fpSceneHandler -> EndPrimitives ();
1066 DrawT (square, objectTransform); << 394 fpSceneHandler -> SetModel (0);
1067 } << 395 delete pModel;
1068 << 396 delete pMP;
1069 void G4VisManager::Draw (const G4Text& text, << 397 }
1070 const G4Transform3D& objectTransform) <<
1071 { <<
1072 DrawT (text, objectTransform); <<
1073 } <<
1074 <<
1075 void G4VisManager::Draw2D (const G4Circle& ci <<
1076 const G4Transform3D& objectTransform <<
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 } 398 }
1110 399
1111 void G4VisManager::Draw (const G4VHit& hit) { << 400 void G4VisManager::Draw (const G4Polyhedron& polyhedron,
1112 if (G4Threading::IsWorkerThread()) return; << 401 const G4Transform3D& objectTransform) {
1113 << 402 if (IsValidView ()) {
1114 if (fIsDrawGroup) { << 403 G4ModelingParameters* pMP = fpSceneHandler -> CreateModelingParameters ();
1115 fpSceneHandler -> AddCompound (hit); << 404 G4VModel* pModel = new G4NullModel (pMP);
1116 } else { << 405 fpSceneHandler -> SetModel (pModel);
1117 if (IsValidView ()) { << 406 fpSceneHandler -> BeginPrimitives (objectTransform);
1118 ClearTransientStoreIfMarked(); << 407 fpSceneHandler -> AddPrimitive (polyhedron);
1119 fpSceneHandler -> AddCompound (hit); << 408 fpSceneHandler -> EndPrimitives ();
1120 } << 409 fpSceneHandler -> SetModel (0);
>> 410 delete pModel;
>> 411 delete pMP;
1121 } 412 }
1122 } 413 }
1123 414
1124 void G4VisManager::Draw (const G4VDigi& digi) << 415 void G4VisManager::Draw (const G4NURBS& nurbs,
1125 if (G4Threading::IsWorkerThread()) return; << 416 const G4Transform3D& objectTransform) {
1126 << 417 if (IsValidView ()) {
1127 if (fIsDrawGroup) { << 418 G4ModelingParameters* pMP = fpSceneHandler -> CreateModelingParameters ();
1128 fpSceneHandler -> AddCompound (digi); << 419 G4VModel* pModel = new G4NullModel (pMP);
1129 } else { << 420 fpSceneHandler -> SetModel (pModel);
1130 if (IsValidView ()) { << 421 fpSceneHandler -> BeginPrimitives (objectTransform);
1131 ClearTransientStoreIfMarked(); << 422 fpSceneHandler -> AddPrimitive (nurbs);
1132 fpSceneHandler -> AddCompound (digi); << 423 fpSceneHandler -> EndPrimitives ();
1133 } << 424 fpSceneHandler -> SetModel (0);
>> 425 delete pModel;
>> 426 delete pMP;
1134 } 427 }
1135 } 428 }
1136 429
1137 void G4VisManager::Draw (const G4VTrajectory& << 430 void G4VisManager::Draw (const G4VSolid& solid,
1138 if (G4Threading::IsWorkerThread()) return; << 431 const G4VisAttributes& attribs,
1139 << 432 const G4Transform3D& objectTransform) {
1140 // A trajectory needs a trajectories model << 433 if (IsValidView ()) {
1141 static G4TrajectoriesModel trajectoriesMode << 434 G4ModelingParameters* pMP = fpSceneHandler -> CreateModelingParameters ();
1142 trajectoriesModel.SetCurrentTrajectory(&tra << 435 G4VModel* pModel = new G4NullModel (pMP);
1143 G4RunManager* runManager = G4RunManagerFact << 436 fpSceneHandler -> SetModel (pModel);
1144 const G4Run* currentRun = runManager->GetC << 437 fpSceneHandler -> PreAddThis (objectTransform, attribs);
1145 if (currentRun) { << 438 solid.DescribeYourselfTo (*fpSceneHandler);
1146 trajectoriesModel.SetRunID(currentRun->Ge << 439 fpSceneHandler -> PostAddThis ();
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); 440 fpSceneHandler -> SetModel (0);
1157 } else { << 441 delete pModel;
1158 if (IsValidView ()) { << 442 delete pMP;
1159 ClearTransientStoreIfMarked(); <<
1160 fpSceneHandler -> SetModel (&trajectori <<
1161 fpSceneHandler -> AddCompound (traj); <<
1162 fpSceneHandler -> SetModel (0); <<
1163 } <<
1164 } 443 }
1165 } 444 }
1166 445
1167 void G4VisManager::Draw (const G4LogicalVolum 446 void G4VisManager::Draw (const G4LogicalVolume& logicalVol,
1168 const G4VisAttributes& attribs, 447 const G4VisAttributes& attribs,
1169 const G4Transform3D& objectTransform) 448 const G4Transform3D& objectTransform) {
1170 if (G4Threading::IsWorkerThread()) return; <<
1171 <<
1172 // Find corresponding solid. 449 // Find corresponding solid.
1173 G4VSolid* pSol = logicalVol.GetSolid (); 450 G4VSolid* pSol = logicalVol.GetSolid ();
1174 Draw (*pSol, attribs, objectTransform); 451 Draw (*pSol, attribs, objectTransform);
1175 } 452 }
1176 453
1177 void G4VisManager::Draw (const G4VSolid& soli <<
1178 const G4VisAttributes& attribs, <<
1179 const G4Transform3D& objectTransform) <<
1180 if (G4Threading::IsWorkerThread()) return; <<
1181 <<
1182 if (fIsDrawGroup) { <<
1183 fpSceneHandler -> PreAddSolid (objectTran <<
1184 solid.DescribeYourselfTo (*fpSceneHandler <<
1185 fpSceneHandler -> PostAddSolid (); <<
1186 } else { <<
1187 if (IsValidView ()) { <<
1188 ClearTransientStoreIfMarked(); <<
1189 fpSceneHandler -> PreAddSolid (objectTr <<
1190 solid.DescribeYourselfTo (*fpSceneHandl <<
1191 fpSceneHandler -> PostAddSolid (); <<
1192 } <<
1193 } <<
1194 } <<
1195 <<
1196 void G4VisManager::Draw (const G4VPhysicalVol 454 void G4VisManager::Draw (const G4VPhysicalVolume& physicalVol,
1197 const G4VisAttributes& attribs, 455 const G4VisAttributes& attribs,
1198 const G4Transform3D& objectTransform) 456 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 457 // Find corresponding logical volume and solid.
1213 G4LogicalVolume* pLV = physicalVol.GetLogi 458 G4LogicalVolume* pLV = physicalVol.GetLogicalVolume ();
1214 G4VSolid* pSol = pLV -> GetSolid (); 459 G4VSolid* pSol = pLV -> GetSolid ();
1215 Draw (*pSol, attribs, objectTransform); 460 Draw (*pSol, attribs, objectTransform);
1216 } 461 }
1217 462
1218 void G4VisManager::DrawGeometry << 463 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 (); 464 if (!fInitialised) Initialise ();
1232 if (fpGraphicsSystem) { 465 if (fpGraphicsSystem) {
1233 G4VSceneHandler* pSceneHandler = 466 G4VSceneHandler* pSceneHandler =
1234 fpGraphicsSystem -> CreateSceneHandler 467 fpGraphicsSystem -> CreateSceneHandler (name);
>> 468 G4VViewer* pViewer;
1235 if (pSceneHandler) { 469 if (pSceneHandler) {
1236 fAvailableSceneHandlers.push_back (pSce 470 fAvailableSceneHandlers.push_back (pSceneHandler);
1237 fpSceneHandler = pSceneHandler; 471 fpSceneHandler = pSceneHandler; // Make current.
1238 } 472 }
1239 else { 473 else {
1240 if (fVerbosity >= errors) { << 474 G4cout << "Error in G4VisManager::CreateSceneHandler during "
1241 G4warn << "ERROR in G4VisManager::CreateSce << 475 << fpGraphicsSystem -> GetName ()
1242 << fpGraphicsSystem -> GetName () << 476 << " scene creation.\n No action taken."
1243 << " scene handler creation.\n No a << 477 << G4endl;
1244 << G4endl; <<
1245 } <<
1246 } 478 }
1247 } 479 }
1248 else PrintInvalidPointers (); 480 else PrintInvalidPointers ();
1249 } 481 }
1250 482
1251 void G4VisManager::CreateViewer << 483 void G4VisManager::CreateViewer (G4String name) {
1252 (const G4String& name, const G4String& XGeome <<
1253 { <<
1254 484
1255 if (!fInitialised) Initialise (); 485 if (!fInitialised) Initialise ();
1256 486
1257 if (!fpSceneHandler) { << 487 if (fpSceneHandler) {
1258 PrintInvalidPointers (); << 488 G4VViewer* p = fpGraphicsSystem -> CreateViewer (*fpSceneHandler, name);
1259 return; << 489 if (p) {
1260 } << 490 fpViewer = p; // Make current.
1261 << 491 fpSceneHandler -> AddViewerToList (fpViewer);
1262 G4VViewer* p = fpGraphicsSystem -> CreateVi << 492 fpSceneHandler -> SetCurrentViewer (fpViewer);
1263 << 493 // Make it possible for user action code to Draw.
1264 if (!p) { << 494 fpConcreteInstance = this;
1265 if (fVerbosity >= errors) { << 495
1266 G4warn << "ERROR in G4VisManager::Creat << 496 G4bool warnings = false;
1267 << fpGraphicsSystem -> GetName () << 497 if (fVP.IsCulling () && fVP.IsCullingInvisible ()) {
1268 << " viewer creation.\n No action tak << 498 warnings = true;
>> 499 G4cout << "G4VisManager::CreateViewer: new viewer created:";
>> 500 if (fVerbose > 0) {
>> 501 G4cout << " view parameters are:\n " << fVP;
>> 502 }
>> 503 G4cout <<
>> 504 "\n NOTE: objects with visibility flag set to \"false\""
>> 505 " will not be drawn!"
>> 506 "\n \"/vis/set/culling off\" to Draw such objects.";
>> 507 }
>> 508 if (fVP.IsCullingCovered ()) {
>> 509 if (!warnings) {
>> 510 G4cout << "G4VisManager::CreateViewer: new viewer created:";
>> 511 }
>> 512 warnings = true;
>> 513 G4cout <<
>> 514 "\n ALSO: covered objects in solid mode will not be part of"
>> 515 " the scene!"
>> 516 "\n \"/vis/set/cull_covered_daughters off\" to reverse this.";
>> 517 }
>> 518 if (warnings) {
>> 519 G4cout << "\n Also see other \"/vis/set\" commands."
1269 << G4endl; 520 << G4endl;
>> 521 }
1270 } 522 }
1271 return; << 523 else {
1272 } << 524 G4cout << "Error in G4VisManager::CreateViewer during "
1273 <<
1274 if (p -> GetViewId() < 0) { <<
1275 if (fVerbosity >= errors) { <<
1276 G4warn << "ERROR in G4VisManager::Creat <<
1277 << fpGraphicsSystem -> GetName () 525 << fpGraphicsSystem -> GetName ()
1278 << " viewer instantiation.\n No actio << 526 << " viewer creation.\n No action taken."
1279 << G4endl; 527 << G4endl;
1280 } 528 }
1281 return; <<
1282 } 529 }
>> 530 else PrintInvalidPointers ();
>> 531 }
1283 532
1284 // Viewer is created, now we can set geomet << 533 void G4VisManager::DeleteCurrentSceneHandler () {
1285 // Before 12/2008, it was done in G4VViewer << 534 G4cout << "G4VisManager::DeleteCurrentSceneHandler: scene handler \""
1286 << 535 << fpSceneHandler -> GetName ()
1287 G4ViewParameters initialvp = p -> GetViewPa << 536 << "\"\n and its viewer(s) are being deleted.";
1288 initialvp.SetXGeometryString(XGeometry); // << 537 if(fpSceneHandler) {
1289 p -> SetViewParameters(initialvp); << 538 fAvailableSceneHandlers.remove (fpSceneHandler);
1290 p -> Initialise (); // (Viewer itself may << 539 delete fpSceneHandler;
1291 if (p -> GetViewId() < 0) { << 540 }
1292 if (fVerbosity >= errors) { << 541 const G4SceneHandlerList& sceneHandlerList = fAvailableSceneHandlers;
1293 G4warn << "ERROR in G4VisManager::Creat << 542 G4int nSH = sceneHandlerList.size ();
1294 << fpGraphicsSystem -> GetName () << 543 G4int iSH;
1295 << " viewer initialisation.\n No acti << 544 for (iSH = 0; iSH < nSH; iSH++) {
1296 << G4endl; << 545 if (sceneHandlerList [iSH] -> GetViewerList ().size ()) break;
1297 } << 546 }
1298 return; << 547 if (iSH < nSH) {
>> 548 fpSceneHandler = sceneHandlerList [iSH];
>> 549 G4cout << "\n scene handler is now \""
>> 550 << fpSceneHandler -> GetName ();
>> 551 fpViewer = fpSceneHandler -> GetViewerList () [0];
>> 552 G4cout << "\"\n and viewer now \""
>> 553 << fpViewer -> GetName ()
>> 554 << ".";
>> 555 IsValidView (); // Check.
>> 556 }
>> 557 else if (nSH) {
>> 558 fpSceneHandler = fAvailableSceneHandlers [0];
>> 559 G4cout << "\n scene handler is now \""
>> 560 << fpSceneHandler -> GetName ();
>> 561 fpViewer = 0;
>> 562 // Make it impossible for user action code to Draw.
>> 563 fpConcreteInstance = 0;
>> 564 G4cout << "\" but it has no viewers -\n please create one.";
1299 } 565 }
1300 << 566 else {
1301 fpViewer = p; / << 567 fpSceneHandler = 0;
1302 fpSceneHandler -> AddViewerToList (fpViewer << 568 fpViewer = 0;
1303 fpSceneHandler -> SetCurrentViewer (fpViewe << 569 // Make it impossible for user action code to Draw.
1304 if (fVerbosity >= confirmations) { << 570 fpConcreteInstance = 0;
1305 G4cout << "G4VisManager::CreateViewer: ne << 571 G4cout <<
1306 << G4endl; << 572 "\n There are now no scene handlers left. /vis/sceneHandler/select"
>> 573 "\n to select a scene handler and /vis/viewer/select to select"
>> 574 "\n a viewer, or maybe you will have to create some.";
1307 } 575 }
>> 576 G4cout << G4endl;
>> 577 }
1308 578
1309 const G4ViewParameters& vp = fpViewer->GetV << 579 void G4VisManager::DeleteCurrentViewer () {
1310 if (fVerbosity >= parameters) { << 580 G4cout << "G4VisManager::DeleteCurrentViewer: viewer \""
1311 G4cout << " view parameters are:\n " << << 581 << fpViewer -> GetName ()
>> 582 << "\" being deleted.";
>> 583 if (fpViewer ) {
>> 584 fpViewer -> GetSceneHandler () -> RemoveViewerFromList (fpViewer);
>> 585 delete fpViewer;
1312 } 586 }
1313 << 587 const G4ViewerList& viewerList = fpSceneHandler -> GetViewerList ();
1314 if (vp.IsCulling () && vp.IsCullingInvisibl << 588 if (viewerList.size () > 0) {
1315 static G4bool warned = false; << 589 fpViewer = viewerList [0];
1316 if (fVerbosity >= confirmations) { << 590 fpSceneHandler -> SetCurrentViewer (fpViewer);
1317 if (!warned) { << 591 if (IsValidView ()) {
1318 G4cout << << 592 G4cout << "\n viewer is now \""
1319 "NOTE: objects with visibility flag set to << 593 << fpViewer -> GetName ()
1320 " will not be drawn!" << 594 << "\".";
1321 "\n \"/vis/viewer/set/culling global false <<
1322 "\n Also see other \"/vis/viewer/set\" com <<
1323 << G4endl; <<
1324 warned = true; <<
1325 } <<
1326 } 595 }
1327 } 596 }
1328 if (vp.IsCullingCovered ()) { << 597 else {
1329 static G4bool warned = false; << 598 fpViewer = 0;
1330 if (fVerbosity >= warnings) { << 599 fpSceneHandler -> SetCurrentViewer (0);
1331 if (!warned) { << 600 // Make it impossible for user action code to Draw.
1332 G4warn << << 601 fpConcreteInstance = 0;
1333 "WARNING: covered objects in solid mode wil << 602 G4cout <<
1334 "\n \"/vis/viewer/set/culling coveredDaugh << 603 "\n There are now no viewers left for this scene handler."
1335 "\n Also see other \"/vis/viewer/set\" com << 604 "\n /vis/sceneHandler/select to select a different scene handler"
1336 << G4endl; << 605 "\n and /vis/viewer/select to select a viewer, or maybe you will"
1337 warned = true; << 606 "\n have to create some.";
1338 } <<
1339 } <<
1340 } 607 }
>> 608 G4cout << G4endl;
1341 } 609 }
1342 610
1343 void G4VisManager::GeometryHasChanged () { 611 void G4VisManager::GeometryHasChanged () {
1344 if (fVerbosity >= confirmations) { << 612 G4cout << "G4VisManager::GeometryHasChanged() called." << G4endl;
1345 G4cout << "G4VisManager::GeometryHasChang <<
1346 } <<
1347 613
1348 // Change the world... 614 // Change the world...
1349 G4VPhysicalVolume* pWorld = 615 G4VPhysicalVolume* pWorld =
1350 G4TransportationManager::GetTransportatio 616 G4TransportationManager::GetTransportationManager ()
1351 -> GetNavigatorForTracking () -> GetWorld 617 -> GetNavigatorForTracking () -> GetWorldVolume ();
1352 if (!pWorld) { 618 if (!pWorld) {
1353 if (fVerbosity >= warnings) { << 619 G4cout << " The world has ended!!! (Is this serious?)" << G4endl;
1354 G4warn << "WARNING: There is no world v <<
1355 } <<
1356 } 620 }
1357 621
1358 // Check scenes. 622 // Check scenes.
1359 G4SceneList& sceneList = fSceneList; 623 G4SceneList& sceneList = fSceneList;
1360 std::size_t iScene, nScenes = sceneList.siz << 624 G4int iScene, nScenes = sceneList.size ();
1361 for (iScene = 0; iScene < nScenes; ++iScene << 625 for (iScene = 0; iScene < nScenes; iScene++) {
1362 G4Scene* pScene = sceneList [iScene]; 626 G4Scene* pScene = sceneList [iScene];
1363 std::vector<G4Scene::Model>& modelList = << 627 G4std::vector<G4VModel*>& modelList = pScene -> SetRunDurationModelList ();
1364 if (modelList.size ()) { <<
1365 G4bool modelInvalid; <<
1366 do { // Remove, if required, one at a <<
1367 modelInvalid = false; <<
1368 std::vector<G4Scene::Model>::iterator iterM <<
1369 for (iterModel = modelList.begin(); <<
1370 iterModel != modelList.end(); <<
1371 ++iterModel) { <<
1372 modelInvalid = !(iterModel->fpModel->Vali <<
1373 if (modelInvalid) { <<
1374 // Model invalid - remove and break. <<
1375 if (fVerbosity >= warnings) { <<
1376 G4warn << "WARNING: Model \"" <<
1377 << iterModel->fpModel->GetGlobalDesc <<
1378 << <<
1379 "\" is no longer valid - being removed\n <<
1380 << pScene -> GetName () << "\"" <<
1381 << G4endl; <<
1382 } <<
1383 modelList.erase (iterModel); <<
1384 break; <<
1385 } <<
1386 } <<
1387 } while (modelInvalid); <<
1388 628
1389 if (modelList.size () == 0) { << 629 G4bool modelInvalid;
1390 if (fVerbosity >= warnings) { << 630 do { // Remove, if required, one at a time.
1391 G4warn << "WARNING: No run-duration model << 631 modelInvalid = false;
1392 << pScene -> GetName () << 632 G4std::vector<G4VModel*>::iterator iterModel;
1393 << "\"." << 633 for (iterModel = modelList.begin();
>> 634 iterModel != modelList.end();
>> 635 ++iterModel) {
>> 636 if (modelInvalid = !((*iterModel) -> Validate ())) {
>> 637 // Model invalid - remove and break.
>> 638 G4cout << " Model \""
>> 639 << (*iterModel) -> GetGlobalDescription ()
>> 640 <<
>> 641 "\" is no longer valid - being removed\n from scene \""
>> 642 << pScene -> GetName () << "\""
1394 << G4endl; 643 << G4endl;
>> 644 modelList.erase (iterModel);
>> 645 break;
1395 } 646 }
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 } <<
1409 else { <<
1410 pScene->CalculateExtent(); // Recalculate <<
1411 G4UImanager::GetUIpointer () -> <<
1412 ApplyCommand (G4String("/vis/scene/notify <<
1413 } <<
1414 } <<
1415 } <<
1416 <<
1417 // Check the manager's current scene... <<
1418 if (fpScene && fpScene -> GetRunDurationMod <<
1419 if (fVerbosity >= warnings) { <<
1420 G4warn << "WARNING: The current scene \ <<
1421 << fpScene -> GetName () <<
1422 << "\" has no run duration 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 } 647 }
1460 } << 648 } while (modelInvalid);
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 649
1517 if (IsValidView()) { << 650 if (modelList.size () == 0) {
1518 trajectoryModel->Draw(trajectory, visib << 651 G4cout << " No models left in this scene \""
1519 } << 652 << pScene -> GetName ()
1520 } << 653 << "\"."
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; 654 << G4endl;
1534 } 655 }
1535 } 656 }
1536 if (fVerbosity >= confirmations) { <<
1537 G4cout <<
1538 << "Run duration user vis action \"" << n <<
1539 << G4endl; <<
1540 } <<
1541 } <<
1542 657
1543 void G4VisManager::RegisterEndOfEventUserVisA << 658 // Check the manager's current scene...
1544 (const G4String& name, << 659 if (fpScene && fpScene -> GetRunDurationModelList ().size () == 0) {
1545 G4VUserVisAction* pVisAction, << 660 G4cout << " The current scene \""
1546 const G4VisExtent& extent) { << 661 << fpScene -> GetName ()
1547 fEndOfEventUserVisActions.push_back(UserVis << 662 << "\" has no models left."
1548 if (extent.GetExtentRadius() > 0.) { << 663 << G4endl;
1549 fUserVisActionExtents[pVisAction] = exten << 664 }
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 } <<
1563 <<
1564 void G4VisManager::RegisterEndOfRunUserVisAct <<
1565 (const G4String& name, <<
1566 G4VUserVisAction* pVisAction, <<
1567 const G4VisExtent& extent) { <<
1568 fEndOfRunUserVisActions.push_back(UserVisAc <<
1569 if (extent.GetExtentRadius() > 0.) { <<
1570 fUserVisActionExtents[pVisAction] = exten <<
1571 } else { <<
1572 if (fVerbosity >= warnings) { <<
1573 G4warn << <<
1574 "WARNING: No extent set for user vis action <<
1575 << G4endl; <<
1576 } <<
1577 } <<
1578 if (fVerbosity >= confirmations) { <<
1579 G4cout <<
1580 << "End of run user vis action \"" << nam <<
1581 << G4endl; <<
1582 } <<
1583 } 665 }
1584 666
1585 void G4VisManager::SetCurrentScene (G4Scene* << 667 void G4VisManager::SetCurrentGraphicsSystemAndCreateViewer
1586 if (pScene != fpScene) { << 668 (G4VGraphicsSystem* pSystem) {
1587 // A change of scene. Therefore reset tr << 669 // This is used only by the deprecated
1588 // memory of previous transient proceessi << 670 // /vis~/create_view/new_graphics_system command. Hence the ad hoc
1589 ResetTransientsDrawnFlags(); << 671 // creation of "scene-vis~" below as a working solution while these
>> 672 // old commands exist.
>> 673 fpGraphicsSystem = pSystem;
>> 674 if (!fpScene) {
>> 675 fpScene = new G4Scene ("scene-vis~");
>> 676 fSceneList.push_back (fpScene);
>> 677 G4cout << "G4VisManager::SetCurrentGraphicsSystemAndCreateViewer:"
>> 678 "\n Empty scene \"scene-vis~\" created."
>> 679 << G4endl;
1590 } 680 }
1591 fpScene = pScene; << 681 CreateSceneHandler ();
>> 682 CreateViewer ();
1592 } 683 }
1593 684
1594 void G4VisManager::SetCurrentGraphicsSystem ( 685 void G4VisManager::SetCurrentGraphicsSystem (G4VGraphicsSystem* pSystem) {
1595 fpGraphicsSystem = pSystem; 686 fpGraphicsSystem = pSystem;
1596 if (fVerbosity >= confirmations) { << 687 G4cout << "G4VisManager::SetCurrentGraphicsSystem: system now "
1597 G4cout << "G4VisManager::SetCurrentGraphi << 688 << pSystem -> GetName ();
1598 << pSystem -> GetName () << G4endl; <<
1599 } <<
1600 // If current scene handler is of same grap 689 // If current scene handler is of same graphics system, leave unchanged.
1601 // Else find the most recent scene handler 690 // Else find the most recent scene handler of same graphics system.
1602 // Or clear pointers. 691 // Or clear pointers.
1603 if (!(fpSceneHandler && fpSceneHandler -> G 692 if (!(fpSceneHandler && fpSceneHandler -> GetGraphicsSystem () == pSystem)) {
1604 const G4SceneHandlerList& sceneHandlerLis 693 const G4SceneHandlerList& sceneHandlerList = fAvailableSceneHandlers;
1605 G4int nSH = (G4int)sceneHandlerList.size << 694 G4int nSH = sceneHandlerList.size (); // No. of scene handlers.
1606 G4int iSH; 695 G4int iSH;
1607 for (iSH = nSH - 1; iSH >= 0; iSH--) { 696 for (iSH = nSH - 1; iSH >= 0; iSH--) {
1608 if (sceneHandlerList [iSH] -> GetGraphi 697 if (sceneHandlerList [iSH] -> GetGraphicsSystem () == pSystem) break;
1609 } 698 }
1610 if (iSH >= 0) { 699 if (iSH >= 0) {
1611 fpSceneHandler = sceneHandlerList [iSH] 700 fpSceneHandler = sceneHandlerList [iSH];
1612 if (fVerbosity >= confirmations) { << 701 G4cout << "\n Scene Handler now "
1613 G4cout << " Scene Handler now " << 702 << fpSceneHandler -> GetName ();
1614 << fpSceneHandler -> GetName () << G <<
1615 } <<
1616 if (fpScene != fpSceneHandler -> GetSce <<
1617 fpScene = fpSceneHandler -> GetScene (); <<
1618 if (fVerbosity >= confirmations) { <<
1619 G4cout << " Scene now \"" <<
1620 << fpScene -> GetName () << "\"" << G4en <<
1621 } <<
1622 } <<
1623 const G4ViewerList& viewerList = fpScen 703 const G4ViewerList& viewerList = fpSceneHandler -> GetViewerList ();
1624 if (viewerList.size ()) { 704 if (viewerList.size ()) {
1625 fpViewer = viewerList [0]; 705 fpViewer = viewerList [0];
1626 if (fVerbosity >= confirmations) { << 706 G4cout << "\n Viewer now " << fpViewer -> GetName ();
1627 G4cout << " Viewer now " << fpViewer -> <<
1628 } <<
1629 } 707 }
1630 else { 708 else {
1631 fpViewer = 0; 709 fpViewer = 0;
>> 710 // Make it impossible for user action code to Draw.
>> 711 fpConcreteInstance = 0;
1632 } 712 }
1633 } 713 }
1634 else { 714 else {
1635 fpSceneHandler = 0; 715 fpSceneHandler = 0;
1636 fpViewer = 0; 716 fpViewer = 0;
>> 717 // Make it impossible for user action code to Draw.
>> 718 fpConcreteInstance = 0;
1637 } 719 }
1638 } 720 }
>> 721 G4cout << G4endl;
1639 } 722 }
1640 723
1641 void G4VisManager::SetCurrentSceneHandler (G4 724 void G4VisManager::SetCurrentSceneHandler (G4VSceneHandler* pSceneHandler) {
1642 fpSceneHandler = pSceneHandler; 725 fpSceneHandler = pSceneHandler;
1643 if (fVerbosity >= confirmations) { << 726 G4cout << "G4VisManager::SetCurrentSceneHandler: scene handler now \""
1644 G4cout << "G4VisManager::SetCurrentSceneH << 727 << pSceneHandler -> GetName () << "\"";
1645 << pSceneHandler -> GetName () << "\"" < <<
1646 } <<
1647 if (fpScene != fpSceneHandler -> GetScene ( <<
1648 fpScene = fpSceneHandler -> GetScene (); <<
1649 if (fVerbosity >= confirmations) { <<
1650 G4cout << " Scene now \"" <<
1651 << fpScene -> GetName () << "\"" << G4 <<
1652 } <<
1653 } <<
1654 if (fpGraphicsSystem != pSceneHandler -> Ge 728 if (fpGraphicsSystem != pSceneHandler -> GetGraphicsSystem ()) {
1655 fpGraphicsSystem = pSceneHandler -> GetGr 729 fpGraphicsSystem = pSceneHandler -> GetGraphicsSystem ();
1656 if (fVerbosity >= confirmations) { << 730 G4cout << "\n graphics system now \""
1657 G4cout << " Graphics system now \"" << 731 << fpGraphicsSystem -> GetName () << "\"";
1658 << fpGraphicsSystem -> GetName () << " <<
1659 } <<
1660 } 732 }
1661 const G4ViewerList& viewerList = fpSceneHan 733 const G4ViewerList& viewerList = fpSceneHandler -> GetViewerList ();
1662 std::size_t nViewers = viewerList.size (); << 734 G4int nViewers = viewerList.size ();
1663 if (nViewers) { 735 if (nViewers) {
1664 std::size_t iViewer; << 736 G4int iViewer;
1665 for (iViewer = 0; iViewer < nViewers; ++i << 737 for (iViewer = 0; iViewer < nViewers; iViewer++) {
1666 if (fpViewer == viewerList [iViewer]) b 738 if (fpViewer == viewerList [iViewer]) break;
1667 } 739 }
1668 if (iViewer >= nViewers) { 740 if (iViewer >= nViewers) {
1669 fpViewer = viewerList [0]; 741 fpViewer = viewerList [0];
1670 if (fVerbosity >= confirmations) { << 742 G4cout << "\n Viewer now \"" << fpViewer -> GetName () << "\"";
1671 G4cout << " Viewer now \"" << fpViewer -> <<
1672 << G4endl; <<
1673 } <<
1674 } <<
1675 if (!IsValidView ()) { <<
1676 if (fVerbosity >= warnings) { <<
1677 G4warn << <<
1678 "WARNING: Problem setting scene handler - p <<
1679 << G4endl; <<
1680 } <<
1681 } 743 }
>> 744 IsValidView (); // Checks.
1682 } 745 }
1683 else { 746 else {
1684 fpViewer = 0; 747 fpViewer = 0;
1685 if (fVerbosity >= warnings) { << 748 // Make it impossible for user action code to Draw.
1686 G4warn << << 749 fpConcreteInstance = 0;
1687 "WARNING: No viewers for this scene handler << 750 G4cout << "\n No viewers for this scene handler - please create one.";
1688 << G4endl; <<
1689 } <<
1690 } 751 }
>> 752 G4cout << G4endl;
1691 } 753 }
1692 754
1693 void G4VisManager::SetCurrentViewer (G4VViewe 755 void G4VisManager::SetCurrentViewer (G4VViewer* pViewer) {
1694 fpViewer = pViewer; 756 fpViewer = pViewer;
1695 if (fpViewer == nullptr) { << 757 G4cout << "G4VisManager::SetCurrentViewer: viewer now "
1696 if (fVerbosity >= confirmations) { << 758 << pViewer -> GetName ()
1697 G4cout << "G4VisManager::SetCurrentView << 759 << G4endl;
1698 << G4endl; <<
1699 } <<
1700 return; <<
1701 } <<
1702 if (fVerbosity >= confirmations) { <<
1703 G4cout << "G4VisManager::SetCurrentViewer <<
1704 << pViewer -> GetName () <<
1705 << G4endl; <<
1706 } <<
1707 fpSceneHandler = fpViewer -> GetSceneHandle 760 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 761 fpSceneHandler -> SetCurrentViewer (pViewer);
1719 fpScene = fpSceneHandler -> GetScene (); <<
1720 fpGraphicsSystem = fpSceneHandler -> GetGra 762 fpGraphicsSystem = fpSceneHandler -> GetGraphicsSystem ();
1721 if (!IsValidView ()) { << 763 IsValidView (); // Checks.
1722 if (fVerbosity >= warnings) { <<
1723 G4warn << <<
1724 "WARNING: Problem setting viewer - please r <<
1725 << G4endl; <<
1726 } <<
1727 } <<
1728 } 764 }
1729 765
1730 void G4VisManager::PrintAvailableGraphicsSyst << 766 void G4VisManager::PrintCurrentSystems () const {
1731 (Verbosity verbosity, std::ostream& out) cons << 767 if (fpGraphicsSystem && fpSceneHandler && fpViewer) {
1732 { << 768 G4int nSystems = fAvailableGraphicsSystems.size ();
1733 out << "Registered graphics systems are:\n" << 769 if (nSystems <= 0) {
1734 if (fAvailableGraphicsSystems.size ()) { << 770 G4cout << "No graphics systems available yet." << G4endl;
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 } 771 }
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 <<
1771 void G4VisManager::PrintAvailableModels (Verb <<
1772 { <<
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 { 772 else {
1780 std::vector<G4VModelFactory<G4VTrajecto << 773 PrintAvailableGraphicsSystems ();
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 <<
1802 G4cout << G4endl; <<
1803 <<
1804 { <<
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 <<
1817 G4cout << "\nRegistered filters:" << G4en <<
1818 const std::vector<G4VFilter<G4VTrajectory <<
1819 filterList = fpTrajFilterMgr->FilterLis <<
1820 if (filterList.empty()) G4cout << " None <<
1821 else { <<
1822 std::vector<G4VFilter<G4VTrajectory>*>: <<
1823 for (i = filterList.begin(); i != filte <<
1824 G4cout << " " << (*i)->GetName() << G4endl <<
1825 if (verbosity >= parameters) (*i)->PrintAll <<
1826 } <<
1827 } 774 }
1828 } 775 }
>> 776 else PrintInvalidPointers ();
1829 } 777 }
1830 778
1831 void G4VisManager::PrintAvailableUserVisActio << 779 void G4VisManager::PrintCurrentSystem () const {
1832 { << 780 if (fpGraphicsSystem && fpSceneHandler && fpViewer) {
1833 G4cout << << 781 G4cout << "Current graphics system is: " << *fpGraphicsSystem;
1834 "You have successfully registered the fol <<
1835 << G4endl; <<
1836 G4cout << "Run Duration User Vis Actions:"; <<
1837 if (fRunDurationUserVisActions.empty()) G4c <<
1838 else { <<
1839 G4cout << G4endl; <<
1840 for (std::size_t i = 0; i < fRunDurationU <<
1841 const G4String& name = fRunDurationUser <<
1842 G4cout << " " << name << G4endl; <<
1843 } <<
1844 } <<
1845 <<
1846 G4cout << "End of Event User Vis Actions:"; <<
1847 if (fEndOfEventUserVisActions.empty()) G4co <<
1848 else { <<
1849 G4cout << G4endl; <<
1850 for (std::size_t i = 0; i < fEndOfEventUs <<
1851 const G4String& name = fEndOfEventUserV <<
1852 G4cout << " " << name << G4endl; <<
1853 } <<
1854 } <<
1855 <<
1856 G4cout << "End of Run User Vis Actions:"; <<
1857 if (fEndOfRunUserVisActions.empty()) G4cout <<
1858 else { <<
1859 G4cout << G4endl; 782 G4cout << G4endl;
1860 for (std::size_t i = 0; i < fEndOfRunUser <<
1861 const G4String& name = fEndOfRunUserVis <<
1862 G4cout << " " << name << G4endl; <<
1863 } <<
1864 } 783 }
>> 784 else PrintInvalidPointers ();
1865 } 785 }
1866 786
1867 void G4VisManager::PrintAvailableColours (Ver << 787 void G4VisManager::PrintCurrentScene () const {
1868 G4cout << << 788 if (fpGraphicsSystem && fpSceneHandler && fpViewer) {
1869 "Some /vis commands (optionally) take a str << 789 G4cout << "Current Scene is: " << fpSceneHandler -> GetName ();
1870 "\nThey are also available in your C++ code << 790 G4cout << '\n' << *fpSceneHandler;
1871 "\n G4Colour niceColour; // Default - whi << 791 G4cout << G4endl;
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 } 792 }
1879 G4cout << G4endl; << 793 else PrintInvalidPointers ();
1880 } 794 }
1881 795
1882 void G4VisManager::PrintInvalidPointers () co << 796 void G4VisManager::PrintCurrentView () const {
1883 if (fVerbosity >= errors) { << 797 if (fpGraphicsSystem && fpSceneHandler && fpViewer) {
1884 G4warn << "ERROR: G4VisManager::PrintInva << 798 G4cout << "Current View is: ";
1885 if (!fpGraphicsSystem) { << 799 G4cout << fpGraphicsSystem -> GetName () << '-'
1886 G4warn << "\n null graphics system poin << 800 << fpSceneHandler -> GetSceneHandlerId () << '-'
>> 801 << fpViewer -> GetViewId ()
>> 802 << " selected (check: " << fpViewer -> GetName () << ").";
>> 803 G4cout << '\n' << *fpViewer;
>> 804 G4cout << "\nCurrent view parameters";
>> 805 if (fVP != fpViewer -> GetViewParameters ()) {
>> 806 G4cout << " differ in the following respect:\n";
>> 807 fVP.PrintDifferences (fpViewer -> GetViewParameters ());
1887 } 808 }
1888 else { 809 else {
1889 G4warn << "\n Graphics system is " << << 810 G4cout << " are same."
1890 << " but:"; << 811 << G4endl;
1891 if (!fpScene) <<
1892 G4warn << <<
1893 "\n Null scene pointer. Use \"/vis/drawV <<
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 } 812 }
1903 G4warn << G4endl; <<
1904 } 813 }
>> 814 else PrintInvalidPointers ();
1905 } 815 }
1906 816
1907 << 817 void G4VisManager::PrintAllGraphicsSystems () const {
1908 G4ThreadFunReturnType G4VisManager::G4VisSubT << 818 G4cout << "\nThe following graphics systems drivers are supported in the"
1909 { << 819 " GEANT4 distribution:"
1910 #ifdef G4MULTITHREADED << 820 << "\n\n DAWN (socket connection to the Fukui Renderer DAWN) " << G4VisFeaturesOfFukuiRenderer ()
1911 G4VisManager* pVisManager = (G4VisManager*) << 821 << "\n\n DAWNFILE (file connection to the Fukui Renderer DAWN ) " << G4VisFeaturesOfDAWNFILE ()
1912 G4VSceneHandler* pSceneHandler = pVisManage << 822 << "\n\n OPACS (the Orsay Package) "
1913 if (!pSceneHandler) return 0; << 823 << "\n\n OpenGLIX (direct/immediate drawing on X Windows)\n"
1914 G4Scene* pScene = pSceneHandler->GetScene() << 824 << G4VisFeaturesOfOpenGLIX ()
1915 if (!pScene) return 0; << 825 << "\n\n OpenGLSX (display List/stored drawing on X Windows)\n"
1916 G4VViewer* pViewer = pVisManager->GetCurren << 826 << G4VisFeaturesOfOpenGLSX ()
1917 if (!pViewer) return 0; << 827 << "\n\n OpenGLIXm (with Motif widgets)\n"
1918 << 828 << G4VisFeaturesOfOpenGLIXm ()
1919 G4UImanager::GetUIpointer()->SetUpForSpecia << 829 << "\n\n OpenGLSXm (with Motif widgets)\n"
1920 << 830 << G4VisFeaturesOfOpenGLSXm ()
1921 // Set up geometry and navigation for a thr << 831 << "\n\n Open Inventor"
1922 G4GeometryWorkspace::GetPool()->CreateAndUs << 832 << G4VisFeaturesOfOpenInventor ()
1923 G4SolidsWorkspace::GetPool()->CreateAndUseW << 833 << "\n\n VRML1 (produces VRML 1 file over network)"
1924 G4Navigator* navigator = G4TransportationMa << 834 << "\n\n VRML1FILE (produces VRML 1 file locally )"
1925 ->GetNavigatorFo << 835 << "\n\n VRML2 (produces VRML 2 file over network)"
1926 navigator->SetWorldVolume( << 836 << "\n\n VRML2FILE (produces VRML 2 file locally )"
1927 G4RunManagerFactory::GetMasterRunManagerK << 837 << "\n\n RayTracer (produces JPEG file)"
1928 << 838 << G4endl;
1929 pViewer->SwitchToVisSubThread(); << 839 }
1930 << 840
1931 while (true) { << 841 void G4VisManager::PrintInstalledGraphicsSystems () const {
1932 << 842 G4cout << "\nThe following graphics systems drivers are installed on your"
1933 G4MUTEXLOCK(&mtVisSubThreadMutex); << 843 " system:"
1934 std::size_t eventQueueSize = mtVisEventQu << 844 #ifdef G4VIS_BUILD_DAWN_DRIVER
1935 G4MUTEXUNLOCK(&mtVisSubThreadMutex); << 845 << "\n DAWN (socket connection to the Fukui Renderer DAWN)"
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 846 #endif
1989 return nullptr; << 847 #ifdef G4VIS_BUILD_DAWNFILE_DRIVER
1990 } << 848 << "\n DAWNFILE (file connection to the Fukui Renderer DAWN)"
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 } <<
2049 } <<
2050 <<
2051 void G4VisManager::BeginOfEvent () <<
2052 { <<
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 849 #endif
>> 850 #ifdef G4VIS_BUILD_OPACS_DRIVER
>> 851 << "\n OPACS (the Orsay Package)"
>> 852 #endif
>> 853 #ifdef G4VIS_BUILD_OPENGLX_DRIVER
>> 854 << "\n OpenGLIX (direct/immediate drawing on X Windows)"
>> 855 << "\n OpenGLSX (display List/stored drawing on X Windows)"
>> 856 #endif
>> 857 #ifdef G4VIS_BUILD_OPENGLXM_DRIVER
>> 858 << "\n OpenGLIXm (with Motif widgets)"
>> 859 << "\n OpenGLSXm (with Motif widgets)"
>> 860 #endif
>> 861 #ifdef G4VIS_BUILD_OIX_DRIVER
>> 862 << "\n Open Inventor X11"
>> 863 #endif
>> 864 #ifdef G4VIS_BUILD_OIWIN32_DRIVER
>> 865 << "\n Open Inventor Win32"
>> 866 #endif
>> 867 #ifdef G4VIS_BUILD_VRML_DRIVER
>> 868 << "\n VRML1 (produces VRML 1 file over network)"
>> 869 << "\n VRML2 (produces VRML 2 file over network)"
>> 870 #endif
>> 871 #ifdef G4VIS_BUILD_VRMLFILE_DRIVER
>> 872 << "\n VRML1FILE (produces VRML 1 file locally)"
>> 873 << "\n VRML2FILE (produces VRML 2 file locally)"
>> 874 #endif
>> 875 #ifdef G4VIS_BUILD_RAYTRACER_DRIVER
>> 876 << "\n RayTracer (produces JPEG file)"
>> 877 #endif
>> 878 << G4endl;
2065 } 879 }
2066 880
2067 // Here begins a sequence of functions that d << 881 void G4VisManager::PrintAvailableGraphicsSystems () const {
2068 // Sequential/Serial mode: << 882 G4int nSystems = fAvailableGraphicsSystems.size ();
2069 // EndOfEvent is invoked by a state change << 883 G4cout << "Current available graphics systems are:";
2070 // EndOfEvent pulls the event from the Ev << 884 if (nSystems) {
2071 // EndOfEventKernel draws the event and c << 885 for (int i = 0; i < nSystems; i++) {
2072 // (Unless the user him/herself has reque << 886 const G4VGraphicsSystem* pSystem = fAvailableGraphicsSystems [i];
2073 // also sets KeepTheEvent for a certain << 887 G4cout << "\n " << pSystem -> GetName ();
2074 // of events. The run manager keeps thes << 888 if (pSystem -> GetNickname () != "") {
2075 // run, so, for example, the vis manager << 889 G4cout << " (" << pSystem -> GetNickname () << ")";
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 } <<
2119 <<
2120 void G4VisManager::EventReadyForVis(const G4E <<
2121 // This is invoked by G4SubEvtRunManager. <<
2122 // The event is passed to EndOfEventKernel. <<
2123 { <<
2124 if (fIgnoreStateChanges) return; <<
2125 if (!GetConcreteInstance()) return; <<
2126 if (!isValidViewForRun) return; <<
2127 if (isFakeRun) return; <<
2128 <<
2129 G4AutoLock al(&visEndOfEventMutex); <<
2130 EndOfEventKernel(event); <<
2131 } <<
2132 <<
2133 void G4VisManager::EndOfEventKernel (const G4 <<
2134 { <<
2135 // Note: we are still subject to the mutex <<
2136 <<
2137 // Discard event if fDrawEventOnlyIfToBeKep <<
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 } 890 }
2197 <<
2198 G4MUTEXLOCK(&mtVisSubThreadMutex); <<
2199 eventQueueSize = mtVisEventQueue.size() <<
2200 G4MUTEXUNLOCK(&mtVisSubThreadMutex); <<
2201 } 891 }
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(); <<
2236 <<
2237 // Keep while post processing (i.e., draw <<
2238 currentEvent->KeepForPostProcessing(); <<
2239 fNKeepForPostProcessingRequests++; <<
2240 <<
2241 if (RequiredToBeKeptForVis(currentEvent-> <<
2242 currentEvent->KeepTheEvent(); <<
2243 fNKeepTheEventRequests++; // Counts nu <<
2244 } <<
2245 <<
2246 // Now draw the event... <<
2247 fpSceneHandler->DrawEvent(currentEvent); <<
2248 ++fNoOfEventsDrawnThisRun; <<
2249 <<
2250 EndOfEventCleanup(currentEvent); <<
2251 } 892 }
2252 } << 893 else {
2253 << 894 G4cout << "\n NONE!!! None registered - yet! Mmmmm!";
2254 void G4VisManager::EndOfEventCleanup(const G4 <<
2255 { <<
2256 if (fpScene->GetRefreshAtEndOfEvent()) { <<
2257 <<
2258 fpSceneHandler->SetMarkForClearingTransie <<
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 } <<
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 } 895 }
2323 << 896 G4cout << G4endl;
2324 return requiredToBeKept; <<
2325 } 897 }
2326 898
2327 void G4VisManager::EndOfRun () << 899 void G4VisManager::PrintInvalidPointers () const {
2328 { << 900 G4cout << "Error in G4VisManager::PrintInvalidPointers:";
2329 if (fIgnoreStateChanges) return; << 901 if (!fpGraphicsSystem) {
2330 if (G4Threading::IsWorkerThread()) return; << 902 G4cout << "\n null graphics system pointer.";
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 } 903 }
2419 << 904 else {
2420 // // if (!fpSceneHandler->GetMarkForClear << 905 G4cout << "\n graphics system is " << fpGraphicsSystem -> GetName ()
2421 // // is here. It prevents ShowView at en << 906 << " but:";
2422 // // for sequential mode, but MT mode see << 907 if (!fpScene) G4cout << "\nNull scene pointer. ";
2423 // // figured out why). ???? JA ???? << 908 if (!fpSceneHandler) G4cout << "\nNull scene handler pointer. ";
2424 // if (!fpSceneHandler->GetMarkForClearing << 909 if (!fpViewer ) G4cout << "\nNull viewer pointer. ";
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 } 910 }
2445 //} << 911 G4cout << G4endl;
2446 fEventRefreshing = false; <<
2447 } 912 }
2448 913
2449 void G4VisManager::ClearTransientStoreIfMarke << 914 void G4VisManager::RefreshCurrentView () { // Soft clear, then redraw.
2450 // Assumes valid view. << 915 if (IsValidView ()) {
2451 if (fpSceneHandler->GetMarkForClearingTrans << 916 fpViewer -> ClearView (); // Soft clear, i.e., clears buffer only.
2452 fpSceneHandler->SetMarkForClearingTransie << 917 Draw ();
2453 fpSceneHandler->ClearTransientStore(); << 918 Show ();
2454 } 919 }
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 } 920 }
2462 921
2463 void G4VisManager::ResetTransientsDrawnFlags( << 922 void G4VisManager::EndOfEvent () {
2464 { << 923 if (fpConcreteInstance && IsValidView ()) {
2465 fTransientsDrawnThisRun = false; << 924 G4ModelingParameters* pMP =
2466 fTransientsDrawnThisEvent = false; << 925 fpSceneHandler -> CreateModelingParameters ();
2467 G4SceneHandlerListConstIterator i; << 926 const G4std::vector<G4VModel*>& EOEModelList =
2468 for (i = fAvailableSceneHandlers.begin(); << 927 fpScene -> GetEndOfEventModelList ();
2469 i != fAvailableSceneHandlers.end(); ++ << 928 fpSceneHandler->ClearTransientStore(); //GB
2470 (*i)->SetTransientsDrawnThisEvent(false); << 929 for (int i = 0; i < EOEModelList.size (); i++) {
2471 (*i)->SetTransientsDrawnThisRun(false); << 930 G4VModel* pModel = EOEModelList [i];
>> 931 pModel -> SetModelingParameters (pMP);
>> 932 pModel -> DescribeYourselfTo (*fpSceneHandler);
>> 933 pModel -> SetModelingParameters (0);
>> 934 }
>> 935 delete pMP;
2472 } 936 }
2473 } 937 }
2474 938
2475 G4String G4VisManager::ViewerShortName (const 939 G4String G4VisManager::ViewerShortName (const G4String& viewerName) const {
2476 const G4String& viewerShortName = viewerNam << 940 G4String viewerShortName (viewerName);
2477 return G4StrUtil::strip_copy(viewerShortNam << 941 viewerShortName = viewerShortName (0, viewerShortName.find (' '));
>> 942 return viewerShortName.strip ();
2478 } 943 }
2479 944
2480 G4VViewer* G4VisManager::GetViewer (const G4S 945 G4VViewer* G4VisManager::GetViewer (const G4String& viewerName) const {
2481 G4String viewerShortName = ViewerShortName 946 G4String viewerShortName = ViewerShortName (viewerName);
2482 std::size_t nHandlers = fAvailableSceneHand << 947 G4int nHandlers = fAvailableSceneHandlers.size ();
2483 std::size_t iHandler, iViewer; << 948 G4int iHandler, iViewer;
2484 G4VViewer* viewer = 0; << 949 G4VSceneHandler* sceneHandler;
>> 950 G4VViewer* viewer;
2485 G4bool found = false; 951 G4bool found = false;
2486 for (iHandler = 0; iHandler < nHandlers; iH 952 for (iHandler = 0; iHandler < nHandlers; iHandler++) {
2487 G4VSceneHandler* sceneHandler = fAvailabl << 953 sceneHandler = fAvailableSceneHandlers [iHandler];
2488 const G4ViewerList& viewerList = sceneHan 954 const G4ViewerList& viewerList = sceneHandler -> GetViewerList ();
2489 for (iViewer = 0; iViewer < viewerList.si 955 for (iViewer = 0; iViewer < viewerList.size (); iViewer++) {
2490 viewer = viewerList [iViewer]; 956 viewer = viewerList [iViewer];
2491 if (viewerShortName == viewer -> GetSho 957 if (viewerShortName == viewer -> GetShortName ()) {
2492 found = true; 958 found = true;
2493 break; 959 break;
2494 } 960 }
2495 } 961 }
2496 if (found) break; 962 if (found) break;
2497 } 963 }
2498 if (found) return viewer; 964 if (found) return viewer;
2499 else return 0; 965 else return 0;
2500 } 966 }
2501 967
2502 std::vector<G4String> G4VisManager::Verbosity <<
2503 <<
2504 G4String G4VisManager::VerbosityString(Verbos <<
2505 G4String rs; <<
2506 switch (verbosity) { <<
2507 case quiet: rs = "quiet (0)"; break <<
2508 case startup: rs = "startup (1)"; bre <<
2509 case errors: rs = "errors (2)"; brea <<
2510 case warnings: rs = "warnings (3)"; br <<
2511 case confirmations: rs = "confirmations (4) <<
2512 case parameters: rs = "parameters (5)"; <<
2513 case all: rs = "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 } <<
2524 os << "\nCurrent verbosity: " << G4VisManag <<
2525 os << std::endl; <<
2526 } <<
2527 <<
2528 G4VisManager::Verbosity <<
2529 G4VisManager::GetVerbosityValue(const G4Strin <<
2530 G4String ss = G4StrUtil::to_lower_copy(verb <<
2531 Verbosity verbosity; <<
2532 if (ss[0] == 'q') verbosity = quiet; <<
2533 else if (ss[0] == 's') verbosity = startup; <<
2534 else if (ss[0] == 'e') verbosity = errors; <<
2535 else if (ss[0] == 'w') verbosity = warnings <<
2536 else if (ss[0] == 'c') verbosity = confirma <<
2537 else if (ss[0] == 'p') verbosity = paramete <<
2538 else if (ss[0] == 'a') verbosity = all; <<
2539 else { <<
2540 // Could be an integer <<
2541 G4int intVerbosity; <<
2542 std::istringstream is(ss); <<
2543 is >> intVerbosity; <<
2544 if (!is) { <<
2545 G4warn << "ERROR: G4VisManager::GetVerb <<
2546 << verbosityString << "\"\n"; <<
2547 PrintAvailableVerbosity(G4warn); <<
2548 // Return existing verbosity <<
2549 return fVerbosity; <<
2550 } <<
2551 else { <<
2552 verbosity = GetVerbosityValue(intVerbos <<
2553 } <<
2554 } <<
2555 return verbosity; <<
2556 } <<
2557 <<
2558 G4VisManager::Verbosity G4VisManager::GetVerb <<
2559 Verbosity verbosity; <<
2560 if (intVerbosity < quiet) verbosity = <<
2561 else if (intVerbosity > all) verbosity = <<
2562 else verbosity = <<
2563 return verbosity; <<
2564 } <<
2565 <<
2566 G4VisManager::Verbosity G4VisManager::GetVerb <<
2567 return fVerbosity; <<
2568 } <<
2569 <<
2570 void G4VisManager::SetVerboseLevel (G4int int <<
2571 fVerbosity = GetVerbosityValue(intVerbosity <<
2572 } <<
2573 <<
2574 void G4VisManager::SetVerboseLevel (const G4S <<
2575 fVerbosity = GetVerbosityValue(verbosityStr <<
2576 } <<
2577 <<
2578 G4bool G4VisManager::IsValidView () { 968 G4bool G4VisManager::IsValidView () {
2579 969
2580 if (!fInitialised) Initialise (); 970 if (!fInitialised) Initialise ();
2581 971
2582 static G4bool noGSPrinting = true; << 972 fpConcreteInstance = 0;
2583 if (!fpGraphicsSystem) { << 973 // Unless we survive a few preliminary tests, users must not use.
2584 // Limit printing - we do not want printi << 974
2585 // not want to use graphics, e.g., in bat << 975 if (!fpGraphicsSystem) return false;
2586 if (noGSPrinting) { << 976 // Simply return without printing - we do not want printing if the
2587 noGSPrinting = false; << 977 // 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 978
2601 if ((!fpScene) || (!fpSceneHandler) || (!fp 979 if ((!fpScene) || (!fpSceneHandler) || (!fpViewer)) {
2602 if (fVerbosity >= errors) { << 980 G4cout << "G4VisManager::IsValidView ():"
2603 G4warn << << 981 "\n Current view is not valid.";
2604 "ERROR: G4VisManager::IsValidView(): Curren << 982 G4cout << G4endl;
2605 << G4endl; << 983 PrintInvalidPointers ();
2606 PrintInvalidPointers (); <<
2607 } <<
2608 return false; 984 return false;
2609 } 985 }
2610 986
2611 if (fpScene != fpSceneHandler -> GetScene ( 987 if (fpScene != fpSceneHandler -> GetScene ()) {
2612 if (fVerbosity >= errors) { << 988 G4cout << "G4VisManager::IsValidView ():";
2613 G4warn << "ERROR: G4VisManager::IsValid << 989 if (fpSceneHandler -> GetScene ()) {
2614 if (fpSceneHandler -> GetScene ()) { << 990 G4cout <<
2615 G4warn << << 991 "\n The current scene \""
2616 "\n The current scene \"" << 992 << fpScene -> GetName ()
2617 << fpScene -> GetName () << 993 << "\" is not handled by"
2618 << "\" is not handled by" << 994 "\n the current scene handler \""
2619 "\n the current scene handler \"" << 995 << fpSceneHandler -> GetName ()
2620 << fpSceneHandler -> GetName () << 996 << "\""
2621 << "\"" << 997 "\n (it currently handles scene \""
2622 "\n (it currently handles scene \"" << 998 << fpSceneHandler -> GetScene () -> GetName ()
2623 << fpSceneHandler -> GetScene () -> << 999 << "\")."
2624 << "\")." << 1000 "\n Either:"
2625 "\n Either:" << 1001 "\n (a) attach it to the scene handler with"
2626 "\n (a) attach it to the scene handler w << 1002 "\n /vis/sceneHandler/attach "
2627 "\n /vis/sceneHandler/attach " << 1003 << fpScene -> GetName ()
2628 << fpScene -> GetName () << 1004 << ", or"
2629 << ", or" << 1005 "\n (b) create a new scene handler with "
2630 "\n (b) create a new scene handler with << 1006 "\n /vis/sceneHandler/create <graphics-system>,"
2631 "\n /vis/sceneHandler/create <graphi << 1007 "\n in which case it should pick up the the new scene."
2632 "\n in which case it should pick up << 1008 << G4endl;
2633 << G4endl; << 1009 }
2634 } << 1010 else {
2635 else { << 1011 G4cout << "\n Scene handler \""
2636 G4warn << "\n Scene handler \"" << 1012 << fpSceneHandler -> GetName ()
2637 << fpSceneHandler -> GetName () << 1013 << "\" has null scene pointer."
2638 << "\" has null scene pointer." << 1014 "\n Attach a scene with /vis/sceneHandler/attach [<scene-name>]"
2639 "\n Attach a scene with /vis/sceneHandle << 1015 << G4endl;
2640 << G4endl; <<
2641 } <<
2642 } 1016 }
2643 return false; 1017 return false;
2644 } 1018 }
2645 1019
2646 const G4ViewerList& viewerList = fpSceneHan 1020 const G4ViewerList& viewerList = fpSceneHandler -> GetViewerList ();
2647 if (viewerList.size () == 0) { 1021 if (viewerList.size () == 0) {
2648 if (fVerbosity >= errors) { << 1022 G4cout << "G4VisManager::IsValidView (): the current scene handler\n \""
2649 G4warn << << 1023 << fpSceneHandler -> GetName ()
2650 "ERROR: G4VisManager::IsValidView (): the c << 1024 << "\" has no viewers. Do /vis/viewer/create."
2651 << fpSceneHandler -> GetName () << 1025 << G4endl;
2652 << "\" has no viewers. Do /vis/viewer <<
2653 << G4endl; <<
2654 } <<
2655 return false; 1026 return false;
2656 } 1027 }
2657 1028
>> 1029 fpConcreteInstance = this; // Unless we find another problem, users can use!
2658 G4bool isValid = true; 1030 G4bool isValid = true;
2659 if (fpScene -> IsEmpty ()) { // Add world << 1031 if (fpScene -> IsEmpty ()) {
2660 G4bool warn(fVerbosity >= warnings); << 1032 fpScene -> AddWorldIfEmpty (); // Add world by default if possible.
2661 G4bool successful = fpScene -> AddWorldIf << 1033 if (fpScene -> IsEmpty ()) { // If still empty...
2662 if (!successful || fpScene -> IsEmpty ()) << 1034 G4cout << "G4VisManager::IsViewValid ():";
2663 if (fVerbosity >= errors) { << 1035 G4cout <<
2664 G4warn << "ERROR: G4VisManager::IsValidView << 1036 "\n Attempt at some drawing operation when scene is empty."
2665 G4warn << << 1037 "\n Maybe the geometry has not yet been defined."
2666 "\n Attempt at some drawing operation wh << 1038 " Try /run/initialize."
2667 "\n Maybe the geometry has not yet been << 1039 << G4endl;
2668 " Try /run/initialize." <<
2669 "\n Or use \"/vis/scene/add/extent <<
2670 << G4endl; <<
2671 } <<
2672 isValid = false; 1040 isValid = false;
>> 1041 fpConcreteInstance = 0; // Users must not use!
2673 } 1042 }
2674 else { 1043 else {
2675 G4UImanager::GetUIpointer()->ApplyComma << 1044 G4UImanager::GetUIpointer () -> ApplyCommand ("/vis/camera/reset");
2676 if (fVerbosity >= warnings) { << 1045 G4cout <<
2677 G4warn << << 1046 "G4VisManager: the scene was empty, \"world\" has been added"
2678 "WARNING: G4VisManager: the scene was emp << 1047 "\n and the view parameters have been reset.";
2679 "\n added and the scene handlers notifie << 1048 G4cout << G4endl;
2680 G4warn << G4endl; <<
2681 } <<
2682 } 1049 }
2683 } 1050 }
2684 return isValid; 1051 return isValid;
2685 } 1052 }
2686 1053
2687 void << 1054 void G4VisManager::PrintCommandDeprecation(const G4String& message) {
2688 G4VisManager::RegisterModelFactories() << 1055 G4cout <<
2689 { << 1056 "**** DEPRECATED COMMAND ***"
2690 if (fVerbosity >= warnings) { << 1057 "\n**** Will be discontinued as a \"/vis/\" command after Geant4 3.0."
2691 G4warn<<"G4VisManager: No model factories << 1058 "\n**** Will still be available as a \"/vis~/\" command for a while."
2692 G4warn<<"G4VisManager::RegisterModelFacto << 1059 "\n**** " << message << G4endl;
2693 G4warn<<"class. See G4VisExecutive for an << 1060 }
2694 } << 1061
2695 } << 1062 // "No functionality" graphics systems to trap accidental attempt to
>> 1063 // use unbuilt systems.
>> 1064
>> 1065 #ifndef G4VIS_BUILD_DAWN_DRIVER
>> 1066
>> 1067 class G4FukuiRenderer: public G4VGraphicsSystem {
>> 1068 public:
>> 1069 G4FukuiRenderer ();
>> 1070 };
>> 1071 G4FukuiRenderer::G4FukuiRenderer ():
>> 1072 G4VGraphicsSystem ("FukuiRenderer",
>> 1073 "DAWN",
>> 1074 G4VGraphicsSystem::noFunctionality) {}
2696 1075
2697 void G4VisManager::SetUpForAThread() <<
2698 { <<
2699 // TODO: protect with G4Threading::IsMultit <<
2700 #ifdef G4MULTITHREADED <<
2701 new G4VisStateDependent(this); <<
2702 #endif 1076 #endif
2703 } <<
2704 1077
2705 void G4VisManager::IgnoreStateChanges(G4bool << 1078 #ifndef G4VIS_BUILD_DAWNFILE_DRIVER
2706 { << 1079
2707 fIgnoreStateChanges = val; << 1080 class G4DAWNFILE: public G4VGraphicsSystem {
2708 } << 1081 public:
>> 1082 G4DAWNFILE ();
>> 1083 };
>> 1084 G4DAWNFILE::G4DAWNFILE ():
>> 1085 G4VGraphicsSystem ("FukuiRendererFile",
>> 1086 "DAWNFILE",
>> 1087 G4VGraphicsSystem::noFunctionality) {}
>> 1088
>> 1089 #endif
>> 1090
>> 1091 #ifndef G4VIS_BUILD_RAYTRACER_DRIVER
>> 1092
>> 1093 class G4RayTracer: public G4VGraphicsSystem {
>> 1094 public:
>> 1095 G4RayTracer ();
>> 1096 };
>> 1097 G4RayTracer::G4RayTracer ():
>> 1098 G4VGraphicsSystem ("RayTracer",
>> 1099 "RayTracer",
>> 1100 G4VGraphicsSystem::noFunctionality) {}
>> 1101
>> 1102 #endif
>> 1103
>> 1104 #ifndef G4VIS_BUILD_OPACS_DRIVER
>> 1105
>> 1106 class G4Wo: public G4VGraphicsSystem {
>> 1107 public:
>> 1108 G4Wo ();
>> 1109 };
>> 1110 G4Wo::G4Wo ():
>> 1111 G4VGraphicsSystem ("Wo",
>> 1112 G4VGraphicsSystem::noFunctionality) {}
>> 1113
>> 1114 class G4Xo: public G4VGraphicsSystem {
>> 1115 public:
>> 1116 G4Xo ();
>> 1117 };
>> 1118 G4Xo::G4Xo ():
>> 1119 G4VGraphicsSystem ("Xo",
>> 1120 G4VGraphicsSystem::noFunctionality) {}
>> 1121
>> 1122 #endif
>> 1123
>> 1124 #ifndef G4VIS_BUILD_OPENGLX_DRIVER
>> 1125
>> 1126 class G4OpenGLImmediateX: public G4VGraphicsSystem {
>> 1127 public:
>> 1128 G4OpenGLImmediateX ();
>> 1129 };
>> 1130 G4OpenGLImmediateX::G4OpenGLImmediateX ():
>> 1131 G4VGraphicsSystem ("OpenGLImmediateX",
>> 1132 "OGLIX",
>> 1133 G4VGraphicsSystem::noFunctionality) {}
>> 1134
>> 1135 class G4OpenGLStoredX: public G4VGraphicsSystem {
>> 1136 public:
>> 1137 G4OpenGLStoredX ();
>> 1138 };
>> 1139 G4OpenGLStoredX::G4OpenGLStoredX ():
>> 1140 G4VGraphicsSystem ("OpenGLStoredX",
>> 1141 "OGLSX",
>> 1142 G4VGraphicsSystem::noFunctionality) {}
>> 1143
>> 1144 #endif
>> 1145
>> 1146 #ifndef G4VIS_BUILD_OPENGLXM_DRIVER
>> 1147
>> 1148 class G4OpenGLImmediateXm: public G4VGraphicsSystem {
>> 1149 public:
>> 1150 G4OpenGLImmediateXm ();
>> 1151 };
>> 1152 G4OpenGLImmediateXm::G4OpenGLImmediateXm ():
>> 1153 G4VGraphicsSystem ("OpenGLImmediateXm",
>> 1154 "OGLIXm",
>> 1155 G4VGraphicsSystem::noFunctionality) {}
>> 1156
>> 1157 class G4OpenGLStoredXm: public G4VGraphicsSystem {
>> 1158 public:
>> 1159 G4OpenGLStoredXm ();
>> 1160 };
>> 1161 G4OpenGLStoredXm::G4OpenGLStoredXm ():
>> 1162 G4VGraphicsSystem ("OpenGLStoredXm",
>> 1163 "OGLSXm",
>> 1164 G4VGraphicsSystem::noFunctionality) {}
>> 1165
>> 1166 #endif
>> 1167
>> 1168 #ifndef G4VIS_BUILD_OIX_DRIVER
>> 1169
>> 1170 class G4OpenInventorX: public G4VGraphicsSystem {
>> 1171 public:
>> 1172 G4OpenInventorX ();
>> 1173 };
>> 1174 G4OpenInventorX::G4OpenInventorX ():
>> 1175 G4VGraphicsSystem ("OpenInventorX",
>> 1176 "OIX",
>> 1177 G4VGraphicsSystem::noFunctionality) {}
>> 1178
>> 1179 #endif
>> 1180
>> 1181 #ifndef G4VIS_BUILD_OIWIN32_DRIVER
>> 1182
>> 1183 class G4OpenInventorWin32: public G4VGraphicsSystem {
>> 1184 public:
>> 1185 G4OpenInventorWin32 ();
>> 1186 };
>> 1187 G4OpenInventorWin32::G4OpenInventorWin32 ():
>> 1188 G4VGraphicsSystem ("OpenInventorWin32",
>> 1189 "OIWIN32",
>> 1190 G4VGraphicsSystem::noFunctionality) {}
>> 1191
>> 1192 #endif
>> 1193
>> 1194 #ifndef G4VIS_BUILD_VRML_DRIVER
>> 1195
>> 1196 class G4VRML1: public G4VGraphicsSystem {
>> 1197 public:
>> 1198 G4VRML1 ();
>> 1199 };
>> 1200 G4VRML1::G4VRML1 ():
>> 1201 G4VGraphicsSystem ("VRML1.0",
>> 1202 "VRML1",
>> 1203 G4VGraphicsSystem::noFunctionality) {}
>> 1204
>> 1205 class G4VRML2: public G4VGraphicsSystem {
>> 1206 public:
>> 1207 G4VRML2 ();
>> 1208 };
>> 1209 G4VRML2::G4VRML2 ():
>> 1210 G4VGraphicsSystem ("VRML2.0",
>> 1211 "VRML2",
>> 1212 G4VGraphicsSystem::noFunctionality) {}
>> 1213
>> 1214 #endif
>> 1215
>> 1216 #ifndef G4VIS_BUILD_VRMLFILE_DRIVER
>> 1217
>> 1218 class G4VRML1File: public G4VGraphicsSystem {
>> 1219 public:
>> 1220 G4VRML1File ();
>> 1221 };
>> 1222 G4VRML1File::G4VRML1File ():
>> 1223 G4VGraphicsSystem ("VRML1.0File",
>> 1224 "VRML1File",
>> 1225 G4VGraphicsSystem::noFunctionality) {}
>> 1226
>> 1227 class G4VRML2File: public G4VGraphicsSystem {
>> 1228 public:
>> 1229 G4VRML2File ();
>> 1230 };
>> 1231 G4VRML2File::G4VRML2File ():
>> 1232 G4VGraphicsSystem ("VRML2.0File",
>> 1233 "VRML2File",
>> 1234 G4VGraphicsSystem::noFunctionality) {}
>> 1235
>> 1236 #endif
2709 1237