source: trunk/geant4/visualization/management/src/G4VisManager.cc@ 772

Last change on this file since 772 was 688, checked in by garnier, 18 years ago

mise a jour par rapport au commit sur cvs de geant4
  • Property svn:mime-type set to text/cpp
File size: 51.0 KB
Line 
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26// $Id: G4VisManager.cc,v 1.115 2008/01/04 22:03:46 allison Exp $
27// GEANT4 tag $Name: $
28//
29//
30// GEANT4 Visualization Manager - John Allison 02/Jan/1996.
31
32#include "G4VisManager.hh"
33
34#include "G4VisCommands.hh"
35#include "G4VisCommandsCompound.hh"
36#include "G4VisCommandsGeometry.hh"
37#include "G4VisCommandsGeometrySet.hh"
38#include "G4VisCommandsScene.hh"
39#include "G4VisCommandsSceneAdd.hh"
40#include "G4VisCommandsSceneHandler.hh"
41#include "G4VisCommandsViewer.hh"
42#include "G4VisCommandsViewerSet.hh"
43#include "G4UImanager.hh"
44#include "G4VisStateDependent.hh"
45#include "G4UIdirectory.hh"
46#include "G4VisFeaturesOfFukuiRenderer.hh"
47#include "G4VisFeaturesOfDAWNFILE.hh"
48#include "G4VisFeaturesOfOpenGL.hh"
49#include "G4VisFeaturesOfOpenInventor.hh"
50#include "G4VGraphicsSystem.hh"
51#include "G4VSceneHandler.hh"
52#include "G4VViewer.hh"
53#include "G4VPhysicalVolume.hh"
54#include "G4LogicalVolume.hh"
55#include "G4VSolid.hh"
56#include "G4Vector3D.hh"
57#include "G4Point3D.hh"
58#include "G4RotationMatrix.hh"
59#include "G4Polyline.hh"
60#include "G4Polyhedron.hh"
61#include "G4NURBS.hh"
62#include "G4NullModel.hh"
63#include "G4ModelingParameters.hh"
64#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 "G4EventManager.hh"
75#include "G4Run.hh"
76#include "G4Event.hh"
77#include <sstream>
78
79G4VisManager* G4VisManager::fpInstance = 0;
80
81G4VisManager::G4VisManager ():
82 fVerbose (1),
83 fInitialised (false),
84 fpUserVisAction (0),
85 fpGraphicsSystem (0),
86 fpScene (0),
87 fpSceneHandler (0),
88 fpViewer (0),
89 fVerbosity (warnings),
90 fpStateDependent (0),
91 fEventRefreshing (false),
92 fTransientsDrawnThisRun (false),
93 fTransientsDrawnThisEvent (false),
94 fEventKeepingSuspended (false),
95 fKeptLastEvent (false),
96 fpRequestedEvent (0),
97 fAbortReviewKeptEvents (false)
98 // All other objects use default constructors.
99{
100 fpTrajDrawModelMgr = new G4VisModelManager<G4VTrajectoryModel>("/vis/modeling/trajectories");
101 fpTrajFilterMgr = new G4VisFilterManager<G4VTrajectory>("/vis/filtering/trajectories");
102 fpHitFilterMgr = new G4VisFilterManager<G4VHit>("/vis/filtering/hits");
103
104 VerbosityGuidanceStrings.push_back
105 ("Simple graded message scheme - digit or string (1st character defines):");
106 VerbosityGuidanceStrings.push_back
107 (" 0) quiet, // Nothing is printed.");
108 VerbosityGuidanceStrings.push_back
109 (" 1) startup, // Startup and endup messages are printed...");
110 VerbosityGuidanceStrings.push_back
111 (" 2) errors, // ...and errors...");
112 VerbosityGuidanceStrings.push_back
113 (" 3) warnings, // ...and warnings...");
114 VerbosityGuidanceStrings.push_back
115 (" 4) confirmations, // ...and confirming messages...");
116 VerbosityGuidanceStrings.push_back
117 (" 5) parameters, // ...and parameters of scenes and views...");
118 VerbosityGuidanceStrings.push_back
119 (" 6) all // ...and everything available.");
120
121 if (fpInstance) {
122 G4Exception
123 ("G4VisManager: attempt to Construct more than one VisManager.");
124 }
125 else {
126
127 fpInstance = this;
128 SetConcreteInstance(this);
129
130 fpStateDependent = new G4VisStateDependent (this);
131 // No need to delete this; G4StateManager does this.
132
133 if (fVerbosity >= startup) {
134 G4cout << "Visualization Manager instantiating..." << G4endl;
135 }
136
137 // Note: The specific graphics systems must be instantiated in a
138 // higher level library to avoid circular dependencies. Also,
139 // some specifically need additional external libararies that the
140 // user must supply. Therefore we ask the user to implement
141 // RegisterGraphicsSystems() and RegisterModelFactories()
142 // in a subclass. We have to wait for the subclass to instantiate
143 // so RegisterGraphicsSystems() cannot be called from this
144 // constructor; it is called from Initialise(). So we ask the
145 // user:
146 // (a) to write a subclass and implement RegisterGraphicsSystems()
147 // and RegisterModelFactories(). See
148 // visualization/include/G4VisExecutive.hh/icc as an example.
149 // (b) instantiate the subclass.
150 // (c) invoke the Initialise() method of the subclass.
151 // For example:
152 // ...
153 // #ifdef G4VIS_USE
154 // // Instantiate and initialise Visualization Manager.
155 // G4VisManager* visManager = new G4VisExecutive;
156 // visManager -> SetVerboseLevel (Verbose);
157 // visManager -> Initialise ();
158 // #endif
159 // // (Don't forget to delete visManager;)
160 // ...
161 }
162}
163
164G4VisManager::~G4VisManager () {
165 fpInstance = 0;
166 size_t i;
167 for (i = 0; i < fSceneList.size (); ++i) {
168 delete fSceneList[i];
169 }
170 for (i = 0; i < fAvailableSceneHandlers.size (); ++i) {
171 delete fAvailableSceneHandlers[i];
172 }
173 for (i = 0; i < fAvailableGraphicsSystems.size (); ++i) {
174 delete fAvailableGraphicsSystems[i];
175 }
176 if (fVerbosity >= startup) {
177 G4cout << "Graphics systems deleted." << G4endl;
178 G4cout << "Visualization Manager deleting..." << G4endl;
179 }
180 for (i = 0; i < fMessengerList.size (); ++i) {
181 delete fMessengerList[i];
182 }
183 for (i = 0; i < fDirectoryList.size (); ++i) {
184 delete fDirectoryList[i];
185 }
186
187 delete fpTrajDrawModelMgr;
188 delete fpTrajFilterMgr;
189 delete fpHitFilterMgr;
190}
191
192G4VisManager* G4VisManager::GetInstance () {
193 if (!fpInstance) {
194 G4Exception
195 ("G4VisManager::GetInstance: VisManager not yet instantiated!");
196 }
197 return fpInstance;
198}
199
200void G4VisManager::Initialise () {
201
202 if (fVerbosity >= startup) {
203 G4cout << "Visualization Manager initialising..." << G4endl;
204 }
205
206 if (fVerbosity >= parameters) {
207 G4cout <<
208 "\nYou have instantiated your own Visualization Manager, inheriting"
209 "\n G4VisManager and implementing RegisterGraphicsSystems(), in which"
210 "\n you should, normally, instantiate drivers which do not need"
211 "\n external packages or libraries, and, optionally, drivers under"
212 "\n control of environment variables."
213 "\n Also you should implement RegisterModelFactories()."
214 "\n See visualization/include/G4VisExecutive.hh/icc, for example."
215 "\n In your main() you will have something like:"
216 "\n #ifdef G4VIS_USE"
217 "\n G4VisManager* visManager = new G4VisExecutive;"
218 "\n visManager -> SetVerboseLevel (Verbose);"
219 "\n visManager -> Initialize ();"
220 "\n #endif"
221 "\n (Don't forget to delete visManager;)"
222 "\n"
223 << G4endl;
224 }
225
226 if (fVerbosity >= startup) {
227 G4cout << "Registering graphics systems..." << G4endl;
228 }
229
230 RegisterGraphicsSystems ();
231
232 if (fVerbosity >= startup) {
233 G4cout <<
234 "\nYou have successfully registered the following graphics systems."
235 << G4endl;
236 PrintAvailableGraphicsSystems ();
237 G4cout << G4endl;
238 }
239
240 // Make top level directory...
241 G4UIcommand* directory;
242 directory = new G4UIdirectory ("/vis/");
243 directory -> SetGuidance ("Visualization commands.");
244 fDirectoryList.push_back (directory);
245
246 // ... and make command directory for commands instantiated in the
247 // modeling subcategory...
248 directory = new G4UIdirectory ("/vis/modeling/");
249 directory -> SetGuidance ("Modeling commands.");
250 fDirectoryList.push_back (directory);
251 directory = new G4UIdirectory ("/vis/modeling/trajectories/");
252 directory -> SetGuidance ("Trajectory model commands.");
253 fDirectoryList.push_back (directory);
254 directory = new G4UIdirectory ("/vis/modeling/trajectories/create/");
255 directory -> SetGuidance ("Create trajectory models and messengers.");
256 fDirectoryList.push_back (directory);
257
258 // Filtering command directory
259 directory = new G4UIdirectory ("/vis/filtering/");
260 directory -> SetGuidance ("Filtering commands.");
261 fDirectoryList.push_back (directory);
262 directory = new G4UIdirectory ("/vis/filtering/trajectories/");
263 directory -> SetGuidance ("Trajectory filtering commands.");
264 fDirectoryList.push_back (directory);
265 directory = new G4UIdirectory ("/vis/filtering/trajectories/create/");
266 directory -> SetGuidance ("Create trajectory filters and messengers.");
267 fDirectoryList.push_back (directory);
268 directory = new G4UIdirectory ("/vis/filtering/hits/");
269 directory -> SetGuidance ("Hit filtering commands.");
270 fDirectoryList.push_back (directory);
271 directory = new G4UIdirectory ("/vis/filtering/hits/create/");
272 directory -> SetGuidance ("Create hit filters and messengers.");
273 fDirectoryList.push_back (directory);
274
275 RegisterMessengers ();
276
277 if (fVerbosity >= startup) {
278 G4cout << "Registering model factories..." << G4endl;
279 }
280
281 RegisterModelFactories();
282
283 if (fVerbosity >= startup) {
284 G4cout <<
285 "\nYou have successfully registered the following model factories."
286 << G4endl;
287 PrintAvailableModels (fVerbosity);
288 G4cout << G4endl;
289 }
290
291 fInitialised = true;
292}
293
294void G4VisManager::Enable() {
295 if (IsValidView ()) {
296 if (fVerbosity >= confirmations) {
297 G4cout << "G4VisManager::Enable: visualization enabled." << G4endl;
298 }
299 }
300 else {
301 if (fVerbosity >= warnings) {
302 G4cout <<
303 "G4VisManager::Enable: WARNING: visualization remains disabled for"
304 "\n above reasons. Rectifying with valid vis commands will"
305 "\n automatically enable."
306 << G4endl;
307 }
308 }
309}
310
311void G4VisManager::Disable() {
312 SetConcreteInstance(0);
313 if (fVerbosity >= confirmations) {
314 G4cout <<
315 "G4VisManager::Disable: visualization disabled."
316 "\n The pointer returned by GetConcreteInstance will be zero."
317 "\n Note that it will become enabled after some valid vis commands."
318 << G4endl;
319 }
320}
321
322const G4GraphicsSystemList& G4VisManager::GetAvailableGraphicsSystems () {
323 G4int nSystems = fAvailableGraphicsSystems.size ();
324 if (nSystems == 0) {
325 if (fVerbosity >= warnings) {
326 G4cout << "G4VisManager::GetAvailableGraphicsSystems: WARNING: no"
327 "\n graphics system available!"
328 "\n 1) Did you have environment variables G4VIS_BUILD_xxxx_DRIVER set"
329 "\n when you compiled/built the visualization code?"
330 "\n 2) Did you instantiate your own Visualization Manager and forget"
331 "\n to implement RegisterGraphicsSystems correctly?"
332 "\n 3) You can register your own graphics system, e.g.,"
333 "\n visManager->RegisterGraphicsSystem(new MyGraphicsSystem);)"
334 "\n after instantiating your vis manager and before"
335 "\n visManager->Initialize()."
336 << G4endl;
337 }
338 }
339 return fAvailableGraphicsSystems;
340}
341
342G4bool G4VisManager::RegisterGraphicsSystem (G4VGraphicsSystem* pSystem) {
343 G4bool happy = true;
344 if (pSystem) {
345 fAvailableGraphicsSystems.push_back (pSystem);
346 if (fVerbosity >= confirmations) {
347 G4cout << "G4VisManager::RegisterGraphicsSystem: "
348 << pSystem -> GetName ();
349 if (pSystem -> GetNickname () != "") {
350 G4cout << " (" << pSystem -> GetNickname () << ")";
351 }
352 G4cout << " registered." << G4endl;
353 }
354 }
355 else {
356 if (fVerbosity >= errors) {
357 G4cout << "G4VisManager::RegisterGraphicsSystem: null pointer!"
358 << G4endl;
359 }
360 happy=false;
361 }
362 return happy;
363}
364
365const G4VTrajectoryModel*
366G4VisManager::CurrentTrajDrawModel() const
367{
368 assert (0 != fpTrajDrawModelMgr);
369
370 const G4VTrajectoryModel* model = fpTrajDrawModelMgr->Current();
371
372 if (0 == model) {
373 // No model was registered with the trajectory model manager.
374 // Use G4TrajectoryDrawByCharge as a default.
375 fpTrajDrawModelMgr->Register(new G4TrajectoryDrawByCharge("AutoGenerated"));
376
377 if (fVerbosity >= warnings) {
378 G4cout<<"G4VisManager: Using G4TrajectoryDrawByCharge as default trajectory model."<<G4endl;
379 G4cout<<"See commands in /vis/modeling/trajectories/ for other options."<<G4endl;
380 }
381 }
382
383 model = fpTrajDrawModelMgr->Current();
384 assert (0 != model); // Should definitely exist now
385
386 return model;
387}
388
389void G4VisManager::RegisterModel(G4VTrajectoryModel* model)
390{
391 fpTrajDrawModelMgr->Register(model);
392}
393
394void
395G4VisManager::RegisterModelFactory(G4TrajDrawModelFactory* factory)
396{
397 fpTrajDrawModelMgr->Register(factory);
398}
399
400void G4VisManager::RegisterModel(G4VFilter<G4VTrajectory>* model)
401{
402 fpTrajFilterMgr->Register(model);
403}
404
405void
406G4VisManager::RegisterModelFactory(G4TrajFilterFactory* factory)
407{
408 fpTrajFilterMgr->Register(factory);
409}
410
411void G4VisManager::RegisterModel(G4VFilter<G4VHit>* model)
412{
413 fpHitFilterMgr->Register(model);
414}
415
416void
417G4VisManager::RegisterModelFactory(G4HitFilterFactory* factory)
418{
419 fpHitFilterMgr->Register(factory);
420}
421
422void G4VisManager::SelectTrajectoryModel(const G4String& model)
423{
424 fpTrajDrawModelMgr->SetCurrent(model);
425}
426
427void G4VisManager::Draw (const G4Circle& circle,
428 const G4Transform3D& objectTransform) {
429 if (IsValidView ()) {
430 ClearTransientStoreIfMarked();
431 fpSceneHandler -> BeginPrimitives (objectTransform);
432 fpSceneHandler -> AddPrimitive (circle);
433 fpSceneHandler -> EndPrimitives ();
434 }
435}
436
437void G4VisManager::Draw (const G4NURBS& nurbs,
438 const G4Transform3D& objectTransform) {
439 if (IsValidView ()) {
440 ClearTransientStoreIfMarked();
441 fpSceneHandler -> BeginPrimitives (objectTransform);
442 fpSceneHandler -> AddPrimitive (nurbs);
443 fpSceneHandler -> EndPrimitives ();
444 }
445}
446
447void G4VisManager::Draw (const G4Polyhedron& polyhedron,
448 const G4Transform3D& objectTransform) {
449 if (IsValidView ()) {
450 ClearTransientStoreIfMarked();
451 fpSceneHandler -> BeginPrimitives (objectTransform);
452 fpSceneHandler -> AddPrimitive (polyhedron);
453 fpSceneHandler -> EndPrimitives ();
454 }
455}
456
457void G4VisManager::Draw (const G4Polyline& line,
458 const G4Transform3D& objectTransform) {
459 if (IsValidView ()) {
460 ClearTransientStoreIfMarked();
461 fpSceneHandler -> BeginPrimitives (objectTransform);
462 fpSceneHandler -> AddPrimitive (line);
463 fpSceneHandler -> EndPrimitives ();
464 }
465}
466
467void G4VisManager::Draw (const G4Polymarker& polymarker,
468 const G4Transform3D& objectTransform) {
469 if (IsValidView ()) {
470 ClearTransientStoreIfMarked();
471 fpSceneHandler -> BeginPrimitives (objectTransform);
472 fpSceneHandler -> AddPrimitive (polymarker);
473 fpSceneHandler -> EndPrimitives ();
474 }
475}
476
477void G4VisManager::Draw (const G4Scale& scale,
478 const G4Transform3D& objectTransform) {
479 if (IsValidView ()) {
480 ClearTransientStoreIfMarked();
481 fpSceneHandler -> BeginPrimitives (objectTransform);
482 fpSceneHandler -> AddPrimitive (scale);
483 fpSceneHandler -> EndPrimitives ();
484 }
485}
486
487void G4VisManager::Draw (const G4Square& square,
488 const G4Transform3D& objectTransform) {
489 if (IsValidView ()) {
490 ClearTransientStoreIfMarked();
491 fpSceneHandler -> BeginPrimitives (objectTransform);
492 fpSceneHandler -> AddPrimitive (square);
493 fpSceneHandler -> EndPrimitives ();
494 }
495}
496
497void G4VisManager::Draw (const G4Text& text,
498 const G4Transform3D& objectTransform) {
499 if (IsValidView ()) {
500 ClearTransientStoreIfMarked();
501 fpSceneHandler -> BeginPrimitives (objectTransform);
502 fpSceneHandler -> AddPrimitive (text);
503 fpSceneHandler -> EndPrimitives ();
504 }
505}
506
507void G4VisManager::Draw2D (const G4Circle& circle,
508 const G4Transform3D& objectTransform)
509{
510 if (IsValidView()) {
511 ClearTransientStoreIfMarked();
512 fpSceneHandler -> BeginPrimitives2D(objectTransform);
513 fpSceneHandler -> AddPrimitive(circle);
514 fpSceneHandler -> EndPrimitives2D();
515 }
516}
517
518void G4VisManager::Draw2D (const G4NURBS& nurbs,
519 const G4Transform3D& objectTransform)
520{
521 if (IsValidView()) {
522 ClearTransientStoreIfMarked();
523 fpSceneHandler -> BeginPrimitives2D(objectTransform);
524 fpSceneHandler -> AddPrimitive(nurbs);
525 fpSceneHandler -> EndPrimitives2D();
526 }
527}
528
529void G4VisManager::Draw2D (const G4Polyhedron& polyhedron,
530 const G4Transform3D& objectTransform)
531{
532 if (IsValidView()) {
533 ClearTransientStoreIfMarked();
534 fpSceneHandler -> BeginPrimitives2D(objectTransform);
535 fpSceneHandler -> AddPrimitive(polyhedron);
536 fpSceneHandler -> EndPrimitives2D();
537 }
538}
539
540void G4VisManager::Draw2D (const G4Polyline& line,
541 const G4Transform3D& objectTransform)
542{
543 if (IsValidView()) {
544 ClearTransientStoreIfMarked();
545 fpSceneHandler -> BeginPrimitives2D(objectTransform);
546 fpSceneHandler -> AddPrimitive(line);
547 fpSceneHandler -> EndPrimitives2D();
548 }
549}
550
551void G4VisManager::Draw2D (const G4Polymarker& polymarker,
552 const G4Transform3D& objectTransform)
553{
554 if (IsValidView()) {
555 ClearTransientStoreIfMarked();
556 fpSceneHandler -> BeginPrimitives2D(objectTransform);
557 fpSceneHandler -> AddPrimitive(polymarker);
558 fpSceneHandler -> EndPrimitives2D();
559 }
560}
561
562void G4VisManager::Draw2D (const G4Square& square,
563 const G4Transform3D& objectTransform)
564{
565 if (IsValidView()) {
566 ClearTransientStoreIfMarked();
567 fpSceneHandler -> BeginPrimitives2D(objectTransform);
568 fpSceneHandler -> AddPrimitive(square);
569 fpSceneHandler -> EndPrimitives2D();
570 }
571}
572
573void G4VisManager::Draw2D (const G4Text& text,
574 const G4Transform3D& objectTransform)
575{
576 if (IsValidView()) {
577 ClearTransientStoreIfMarked();
578 fpSceneHandler -> BeginPrimitives2D(objectTransform);
579 fpSceneHandler -> AddPrimitive(text);
580 fpSceneHandler -> EndPrimitives2D();
581 }
582}
583
584void G4VisManager::Draw (const G4VHit& hit) {
585 if (IsValidView ()) {
586 ClearTransientStoreIfMarked();
587 fpSceneHandler -> AddCompound (hit);
588 }
589}
590
591void G4VisManager::Draw (const G4VTrajectory& traj,
592 G4int i_mode) {
593 if (IsValidView ()) {
594 ClearTransientStoreIfMarked();
595 fpSceneHandler -> SetModel (&dummyTrajectoriesModel);
596 dummyTrajectoriesModel.SetDrawingMode(i_mode);
597 fpSceneHandler -> AddCompound (traj);
598 }
599}
600
601void G4VisManager::Draw (const G4LogicalVolume& logicalVol,
602 const G4VisAttributes& attribs,
603 const G4Transform3D& objectTransform) {
604 // Find corresponding solid.
605 G4VSolid* pSol = logicalVol.GetSolid ();
606 Draw (*pSol, attribs, objectTransform);
607}
608
609void G4VisManager::Draw (const G4VSolid& solid,
610 const G4VisAttributes& attribs,
611 const G4Transform3D& objectTransform) {
612 if (IsValidView ()) {
613 ClearTransientStoreIfMarked();
614 fpSceneHandler -> PreAddSolid (objectTransform, attribs);
615 solid.DescribeYourselfTo (*fpSceneHandler);
616 fpSceneHandler -> PostAddSolid ();
617 }
618}
619
620void G4VisManager::Draw (const G4VPhysicalVolume& physicalVol,
621 const G4VisAttributes& attribs,
622 const G4Transform3D& objectTransform) {
623 // Find corresponding logical volume and solid.
624 G4LogicalVolume* pLV = physicalVol.GetLogicalVolume ();
625 G4VSolid* pSol = pLV -> GetSolid ();
626 Draw (*pSol, attribs, objectTransform);
627}
628
629void G4VisManager::CreateSceneHandler (G4String name) {
630 if (!fInitialised) Initialise ();
631 if (fpGraphicsSystem) {
632 G4VSceneHandler* pSceneHandler =
633 fpGraphicsSystem -> CreateSceneHandler (name);
634 if (pSceneHandler) {
635 fAvailableSceneHandlers.push_back (pSceneHandler);
636 fpSceneHandler = pSceneHandler; // Make current.
637 }
638 else {
639 if(fVerbosity >= errors) {
640 G4cout << "ERROR in G4VisManager::CreateSceneHandler during "
641 << fpGraphicsSystem -> GetName ()
642 << " scene creation.\n No action taken."
643 << G4endl;
644 }
645 }
646 }
647 else PrintInvalidPointers ();
648}
649
650void G4VisManager::CreateViewer (G4String name) {
651
652 if (!fInitialised) Initialise ();
653
654 if (fpSceneHandler) {
655 G4VViewer* p = fpGraphicsSystem -> CreateViewer (*fpSceneHandler, name);
656 if (!p) {
657 if (fVerbosity >= errors) {
658 G4cout << "ERROR in G4VisManager::CreateViewer during "
659 << fpGraphicsSystem -> GetName ()
660 << " viewer creation.\n No action taken."
661 << G4endl;
662 }
663 } else {
664 p -> Initialise ();
665 if (p -> GetViewId() < 0) {
666 if (fVerbosity >= errors) {
667 G4cout << "ERROR in G4VisManager::CreateViewer during "
668 << fpGraphicsSystem -> GetName ()
669 << " viewer initialisation.\n No action taken."
670 << G4endl;
671 }
672 } else {
673 fpViewer = p; // Make current.
674 fpSceneHandler -> AddViewerToList (fpViewer);
675 fpSceneHandler -> SetCurrentViewer (fpViewer);
676
677 if (fVerbosity >= confirmations) {
678 G4cout << "G4VisManager::CreateViewer: new viewer created."
679 << G4endl;
680 }
681
682 const G4ViewParameters& vp = fpViewer->GetViewParameters();
683 if (fVerbosity >= parameters) {
684 G4cout << " view parameters are:\n " << vp << G4endl;
685 }
686
687 if (vp.IsCulling () && vp.IsCullingInvisible ()) {
688 static G4bool warned = false;
689 if (fVerbosity >= confirmations) {
690 if (!warned) {
691 G4cout <<
692 "NOTE: objects with visibility flag set to \"false\""
693 " will not be drawn!"
694 "\n \"/vis/viewer/set/culling global false\" to Draw such objects."
695 "\n Also see other \"/vis/viewer/set\" commands."
696 << G4endl;
697 warned = true;
698 }
699 }
700 }
701 if (vp.IsCullingCovered ()) {
702 static G4bool warned = false;
703 if (fVerbosity >= warnings) {
704 if (!warned) {
705 G4cout <<
706 "WARNING: covered objects in solid mode will not be rendered!"
707 "\n \"/vis/viewer/set/culling coveredDaughters false\" to reverse this."
708 "\n Also see other \"/vis/viewer/set\" commands."
709 << G4endl;
710 warned = true;
711 }
712 }
713 }
714 }
715 }
716 }
717 else PrintInvalidPointers ();
718}
719
720void G4VisManager::GeometryHasChanged () {
721 if (fVerbosity >= confirmations) {
722 G4cout << "G4VisManager::GeometryHasChanged() called." << G4endl;
723 }
724
725 // Change the world...
726 G4VPhysicalVolume* pWorld =
727 G4TransportationManager::GetTransportationManager ()
728 -> GetNavigatorForTracking () -> GetWorldVolume ();
729 if (!pWorld) {
730 if (fVerbosity >= warnings) {
731 G4cout << "WARNING: There is no world volume!" << G4endl;
732 }
733 }
734
735 // Check scenes.
736 G4SceneList& sceneList = fSceneList;
737 G4int iScene, nScenes = sceneList.size ();
738 for (iScene = 0; iScene < nScenes; iScene++) {
739 G4Scene* pScene = sceneList [iScene];
740 std::vector<G4VModel*>& modelList = pScene -> SetRunDurationModelList ();
741
742 if (modelList.size ()) {
743 G4bool modelInvalid;
744 do { // Remove, if required, one at a time.
745 modelInvalid = false;
746 std::vector<G4VModel*>::iterator iterModel;
747 for (iterModel = modelList.begin();
748 iterModel != modelList.end();
749 ++iterModel) {
750 modelInvalid = !((*iterModel) -> Validate (fVerbosity >= warnings));
751 if (modelInvalid) {
752 // Model invalid - remove and break.
753 if (fVerbosity >= warnings) {
754 G4cout << "WARNING: Model \""
755 << (*iterModel) -> GetGlobalDescription ()
756 <<
757 "\" is no longer valid - being removed\n from scene \""
758 << pScene -> GetName () << "\""
759 << G4endl;
760 }
761 modelList.erase (iterModel);
762 break;
763 }
764 }
765 } while (modelInvalid);
766
767 if (modelList.size () == 0) {
768 if (fVerbosity >= warnings) {
769 G4cout << "WARNING: No models left in this scene \""
770 << pScene -> GetName ()
771 << "\"."
772 << G4endl;
773 }
774 }
775 else {
776 pScene->CalculateExtent();
777 G4UImanager::GetUIpointer () ->
778 ApplyCommand (G4String("/vis/scene/notifyHandlers " + pScene->GetName()));
779 }
780 }
781 }
782
783 // Check the manager's current scene...
784 if (fpScene && fpScene -> GetRunDurationModelList ().size () == 0) {
785 if (fVerbosity >= warnings) {
786 G4cout << "WARNING: The current scene \""
787 << fpScene -> GetName ()
788 << "\" has no models."
789 << G4endl;
790 }
791 }
792
793}
794
795G4bool G4VisManager::FilterTrajectory(const G4VTrajectory& trajectory)
796{
797 return fpTrajFilterMgr->Accept(trajectory);
798}
799
800G4bool G4VisManager::FilterHit(const G4VHit& hit)
801{
802 return fpHitFilterMgr->Accept(hit);
803}
804
805void G4VisManager::DispatchToModel(const G4VTrajectory& trajectory, G4int i_mode)
806{
807 G4bool visible(true);
808
809 // See if trajectory passes filter
810 G4bool passed = FilterTrajectory(trajectory);
811
812 if (!passed) {
813 // Draw invisible trajectory if trajectory failed filter and
814 // are filtering in soft mode
815 if (fpTrajFilterMgr->GetMode() == FilterMode::Soft) visible = false;
816 else {return;}
817 }
818
819 // Go on to draw trajectory
820 assert (0 != fpTrajDrawModelMgr);
821
822 const G4VTrajectoryModel* model = CurrentTrajDrawModel();
823
824 assert (0 != model); // Should exist
825
826 model->Draw(trajectory, i_mode, visible);
827}
828
829void G4VisManager::SetUserAction
830(G4VUserVisAction* pVisAction,
831 const G4VisExtent& extent) {
832 fpUserVisAction = pVisAction;
833 fUserVisActionExtent = extent;
834 if (extent.GetExtentRadius() <= 0.) {
835 if (fVerbosity >= warnings) {
836 G4cout <<
837 "WARNING: No extent set for user vis action. (You may"
838 "\n set it later when adding with /vis/scene/add/userAction.)"
839 << G4endl;
840 }
841 }
842}
843
844void G4VisManager::SetCurrentScene (G4Scene* pScene) {
845 if (pScene != fpScene) {
846 // A change of scene. Therefore reset transients drawn flags. All
847 // memory of previous transient proceessing thereby erased...
848 ResetTransientsDrawnFlags();
849 }
850 fpScene = pScene;
851}
852
853void G4VisManager::SetCurrentGraphicsSystem (G4VGraphicsSystem* pSystem) {
854 fpGraphicsSystem = pSystem;
855 if (fVerbosity >= confirmations) {
856 G4cout << "G4VisManager::SetCurrentGraphicsSystem: system now "
857 << pSystem -> GetName () << G4endl;
858 }
859 // If current scene handler is of same graphics system, leave unchanged.
860 // Else find the most recent scene handler of same graphics system.
861 // Or clear pointers.
862 if (!(fpSceneHandler && fpSceneHandler -> GetGraphicsSystem () == pSystem)) {
863 const G4SceneHandlerList& sceneHandlerList = fAvailableSceneHandlers;
864 G4int nSH = sceneHandlerList.size (); // No. of scene handlers.
865 G4int iSH;
866 for (iSH = nSH - 1; iSH >= 0; iSH--) {
867 if (sceneHandlerList [iSH] -> GetGraphicsSystem () == pSystem) break;
868 }
869 if (iSH >= 0) {
870 fpSceneHandler = sceneHandlerList [iSH];
871 if (fVerbosity >= confirmations) {
872 G4cout << " Scene Handler now "
873 << fpSceneHandler -> GetName () << G4endl;
874 }
875 if (fpScene != fpSceneHandler -> GetScene ()) {
876 fpScene = fpSceneHandler -> GetScene ();
877 if (fVerbosity >= confirmations) {
878 G4cout << " Scene now \""
879 << fpScene -> GetName () << "\"" << G4endl;
880 }
881 }
882 const G4ViewerList& viewerList = fpSceneHandler -> GetViewerList ();
883 if (viewerList.size ()) {
884 fpViewer = viewerList [0];
885 if (fVerbosity >= confirmations) {
886 G4cout << " Viewer now " << fpViewer -> GetName () << G4endl;
887 }
888 }
889 else {
890 fpViewer = 0;
891 }
892 }
893 else {
894 fpSceneHandler = 0;
895 fpViewer = 0;
896 }
897 }
898}
899
900void G4VisManager::SetCurrentSceneHandler (G4VSceneHandler* pSceneHandler) {
901 fpSceneHandler = pSceneHandler;
902 if (fVerbosity >= confirmations) {
903 G4cout << "G4VisManager::SetCurrentSceneHandler: scene handler now \""
904 << pSceneHandler -> GetName () << "\"" << G4endl;
905 }
906 if (fpScene != fpSceneHandler -> GetScene ()) {
907 fpScene = fpSceneHandler -> GetScene ();
908 if (fVerbosity >= confirmations) {
909 G4cout << " Scene now \""
910 << fpScene -> GetName () << "\"" << G4endl;
911 }
912 }
913 if (fpGraphicsSystem != pSceneHandler -> GetGraphicsSystem ()) {
914 fpGraphicsSystem = pSceneHandler -> GetGraphicsSystem ();
915 if (fVerbosity >= confirmations) {
916 G4cout << " Graphics system now \""
917 << fpGraphicsSystem -> GetName () << "\"" << G4endl;
918 }
919 }
920 const G4ViewerList& viewerList = fpSceneHandler -> GetViewerList ();
921 G4int nViewers = viewerList.size ();
922 if (nViewers) {
923 G4int iViewer;
924 for (iViewer = 0; iViewer < nViewers; iViewer++) {
925 if (fpViewer == viewerList [iViewer]) break;
926 }
927 if (iViewer >= nViewers) {
928 fpViewer = viewerList [0];
929 if (fVerbosity >= confirmations) {
930 G4cout << " Viewer now \"" << fpViewer -> GetName () << "\""
931 << G4endl;
932 }
933 }
934 IsValidView (); // Checks.
935 }
936 else {
937 fpViewer = 0;
938 if (fVerbosity >= warnings) {
939 G4cout <<
940 "WARNING: No viewers for this scene handler - please create one."
941 << G4endl;
942 }
943 }
944}
945
946void G4VisManager::SetCurrentViewer (G4VViewer* pViewer) {
947 fpViewer = pViewer;
948 if (fVerbosity >= confirmations) {
949 G4cout << "G4VisManager::SetCurrentViewer: viewer now "
950 << pViewer -> GetName ()
951 << G4endl;
952 }
953 fpSceneHandler = fpViewer -> GetSceneHandler ();
954 fpSceneHandler -> SetCurrentViewer (pViewer);
955 fpScene = fpSceneHandler -> GetScene ();
956 fpGraphicsSystem = fpSceneHandler -> GetGraphicsSystem ();
957 IsValidView (); // Checks.
958}
959
960void G4VisManager::RegisterMessengers () {
961
962 // Instantiate individual messengers/commands (often - but not
963 // always - one command per messenger).
964
965 G4VVisCommand::SetVisManager (this); // Sets shared pointer to vis manager.
966
967 G4UIcommand* directory;
968
969 // Top level basic commands...
970 RegisterMessenger(new G4VisCommandAbortReviewKeptEvents);
971 RegisterMessenger(new G4VisCommandEnable);
972 RegisterMessenger(new G4VisCommandList);
973 RegisterMessenger(new G4VisCommandVerbose);
974
975 // Other top level commands...
976 RegisterMessenger(new G4VisCommandReviewKeptEvents);
977
978 // Compound commands...
979 RegisterMessenger(new G4VisCommandDrawTree);
980 RegisterMessenger(new G4VisCommandDrawView);
981 RegisterMessenger(new G4VisCommandDrawVolume);
982 RegisterMessenger(new G4VisCommandOpen);
983 RegisterMessenger(new G4VisCommandSpecify);
984
985 directory = new G4UIdirectory ("/vis/geometry/");
986 directory -> SetGuidance("Operations on vis attributes of Geant4 geometry.");
987 fDirectoryList.push_back (directory);
988 RegisterMessenger(new G4VisCommandGeometryList);
989 RegisterMessenger(new G4VisCommandGeometryRestore);
990
991 directory = new G4UIdirectory ("/vis/geometry/set/");
992 directory -> SetGuidance("Set vis attributes of Geant4 geometry.");
993 fDirectoryList.push_back (directory);
994 RegisterMessenger(new G4VisCommandGeometrySetColour);
995 RegisterMessenger(new G4VisCommandGeometrySetDaughtersInvisible);
996 RegisterMessenger(new G4VisCommandGeometrySetLineStyle);
997 RegisterMessenger(new G4VisCommandGeometrySetLineWidth);
998 RegisterMessenger(new G4VisCommandGeometrySetForceAuxEdgeVisible);
999 RegisterMessenger(new G4VisCommandGeometrySetForceLineSegmentsPerCircle);
1000 RegisterMessenger(new G4VisCommandGeometrySetForceSolid);
1001 RegisterMessenger(new G4VisCommandGeometrySetForceWireframe);
1002 RegisterMessenger(new G4VisCommandGeometrySetVisibility);
1003
1004 directory = new G4UIdirectory ("/vis/scene/");
1005 directory -> SetGuidance ("Operations on Geant4 scenes.");
1006 fDirectoryList.push_back (directory);
1007 RegisterMessenger(new G4VisCommandSceneCreate);
1008 RegisterMessenger(new G4VisCommandSceneEndOfEventAction);
1009 RegisterMessenger(new G4VisCommandSceneEndOfRunAction);
1010 RegisterMessenger(new G4VisCommandSceneList);
1011 RegisterMessenger(new G4VisCommandSceneNotifyHandlers);
1012 RegisterMessenger(new G4VisCommandSceneSelect);
1013
1014 directory = new G4UIdirectory ("/vis/scene/add/");
1015 directory -> SetGuidance ("Add model to current scene.");
1016 fDirectoryList.push_back (directory);
1017 RegisterMessenger(new G4VisCommandSceneAddAxes);
1018 RegisterMessenger(new G4VisCommandSceneAddEventID);
1019 RegisterMessenger(new G4VisCommandSceneAddGhosts);
1020 RegisterMessenger(new G4VisCommandSceneAddHits);
1021 RegisterMessenger(new G4VisCommandSceneAddLogicalVolume);
1022 RegisterMessenger(new G4VisCommandSceneAddLogo);
1023 RegisterMessenger(new G4VisCommandSceneAddScale);
1024 RegisterMessenger(new G4VisCommandSceneAddText);
1025 RegisterMessenger(new G4VisCommandSceneAddTrajectories);
1026 RegisterMessenger(new G4VisCommandSceneAddUserAction);
1027 RegisterMessenger(new G4VisCommandSceneAddVolume);
1028
1029 directory = new G4UIdirectory ("/vis/sceneHandler/");
1030 directory -> SetGuidance ("Operations on Geant4 scene handlers.");
1031 fDirectoryList.push_back (directory);
1032 RegisterMessenger(new G4VisCommandSceneHandlerAttach);
1033 RegisterMessenger(new G4VisCommandSceneHandlerCreate);
1034 RegisterMessenger(new G4VisCommandSceneHandlerList);
1035 RegisterMessenger(new G4VisCommandSceneHandlerSelect);
1036
1037 directory = new G4UIdirectory ("/vis/viewer/");
1038 directory -> SetGuidance ("Operations on Geant4 viewers.");
1039 fDirectoryList.push_back (directory);
1040 RegisterMessenger(new G4VisCommandViewerAddCutawayPlane);
1041 RegisterMessenger(new G4VisCommandViewerChangeCutawayPlane);
1042 RegisterMessenger(new G4VisCommandViewerClear);
1043 RegisterMessenger(new G4VisCommandViewerClearCutawayPlanes);
1044 RegisterMessenger(new G4VisCommandViewerClearTransients);
1045 RegisterMessenger(new G4VisCommandViewerClone);
1046 RegisterMessenger(new G4VisCommandViewerCreate);
1047 RegisterMessenger(new G4VisCommandViewerDolly);
1048 RegisterMessenger(new G4VisCommandViewerFlush);
1049 RegisterMessenger(new G4VisCommandViewerList);
1050 RegisterMessenger(new G4VisCommandViewerPan);
1051 RegisterMessenger(new G4VisCommandViewerRebuild);
1052 RegisterMessenger(new G4VisCommandViewerRefresh);
1053 RegisterMessenger(new G4VisCommandViewerReset);
1054 RegisterMessenger(new G4VisCommandViewerScale);
1055 RegisterMessenger(new G4VisCommandViewerSelect);
1056 RegisterMessenger(new G4VisCommandViewerUpdate);
1057 RegisterMessenger(new G4VisCommandViewerZoom);
1058
1059 directory = new G4UIdirectory ("/vis/viewer/set/");
1060 directory -> SetGuidance ("Set view parameters of current viewer.");
1061 fDirectoryList.push_back (directory);
1062 RegisterMessenger(new G4VisCommandsViewerSet);
1063
1064 // List manager commands
1065 RegisterMessenger(new G4VisCommandListManagerList< G4VisModelManager<G4VTrajectoryModel> >
1066 (fpTrajDrawModelMgr, fpTrajDrawModelMgr->Placement()));
1067 RegisterMessenger(new G4VisCommandListManagerSelect< G4VisModelManager<G4VTrajectoryModel> >
1068 (fpTrajDrawModelMgr, fpTrajDrawModelMgr->Placement()));
1069
1070 // Trajectory filter manager commands
1071 RegisterMessenger(new G4VisCommandListManagerList< G4VisFilterManager<G4VTrajectory> >
1072 (fpTrajFilterMgr, fpTrajFilterMgr->Placement()));
1073 RegisterMessenger(new G4VisCommandManagerMode< G4VisFilterManager<G4VTrajectory> >
1074 (fpTrajFilterMgr, fpTrajFilterMgr->Placement()));
1075
1076 // Hit filter manager commands
1077 RegisterMessenger(new G4VisCommandListManagerList< G4VisFilterManager<G4VHit> >
1078 (fpHitFilterMgr, fpHitFilterMgr->Placement()));
1079 RegisterMessenger(new G4VisCommandManagerMode< G4VisFilterManager<G4VHit> >
1080 (fpHitFilterMgr, fpHitFilterMgr->Placement()));
1081}
1082
1083void G4VisManager::PrintAvailableGraphicsSystems () const {
1084 G4int nSystems = fAvailableGraphicsSystems.size ();
1085 G4cout << "Current available graphics systems are:";
1086 if (nSystems) {
1087 for (int i = 0; i < nSystems; i++) {
1088 const G4VGraphicsSystem* pSystem = fAvailableGraphicsSystems [i];
1089 G4cout << "\n " << pSystem -> GetName ();
1090 if (pSystem -> GetNickname () != "") {
1091 G4cout << " (" << pSystem -> GetNickname () << ")";
1092 }
1093 }
1094 }
1095 else {
1096 G4cout << "\n NONE!!! None registered - yet! Mmmmm!";
1097 }
1098 G4cout << G4endl;
1099}
1100
1101void G4VisManager::PrintAvailableModels (Verbosity verbosity) const
1102{
1103 {
1104 //fpTrajDrawModelMgr->Print(G4cout);
1105 G4cout << "Registered model factories:" << G4endl;
1106 const std::vector<G4VModelFactory<G4VTrajectoryModel>*>& factoryList =
1107 fpTrajDrawModelMgr->FactoryList();
1108 if (factoryList.empty()) G4cout << " None" << G4endl;
1109 else {
1110 std::vector<G4VModelFactory<G4VTrajectoryModel>*>::const_iterator i;
1111 for (i = factoryList.begin(); i != factoryList.end(); ++i)
1112 (*i)->Print(G4cout);
1113 }
1114 const G4VisListManager<G4VTrajectoryModel>* listManager =
1115 fpTrajDrawModelMgr->ListManager();
1116 const std::map<G4String, G4VTrajectoryModel*>& modelMap =
1117 listManager->Map();
1118 if (!modelMap.empty()) {
1119 G4cout << "\nRegistered models:" << G4endl;
1120 std::map<G4String, G4VTrajectoryModel*>::const_iterator i;
1121 for (i = modelMap.begin(); i != modelMap.end(); ++i) {
1122 G4cout << " " << i->second->Name();
1123 if (i->second == listManager->Current()) G4cout << " (Current)";
1124 G4cout << G4endl;
1125 if (verbosity >= parameters) i->second->Print(G4cout);
1126 }
1127 }
1128 }
1129
1130 G4cout << G4endl;
1131
1132 {
1133 //fpTrajFilterMgr->Print(G4cout);
1134 G4cout << "Registered filter factories:" << G4endl;
1135 const std::vector<G4VModelFactory<G4VFilter<G4VTrajectory> >*>&
1136 factoryList = fpTrajFilterMgr->FactoryList();
1137 if (factoryList.empty()) G4cout << " None" << G4endl;
1138 else {
1139 std::vector<G4VModelFactory<G4VFilter<G4VTrajectory> >*>::const_iterator i;
1140 for (i = factoryList.begin(); i != factoryList.end(); ++i)
1141 (*i)->Print(G4cout);
1142 }
1143 const std::vector<G4VFilter<G4VTrajectory>*>&
1144 filterList = fpTrajFilterMgr->FilterList();
1145 if (!filterList.empty()) {
1146 G4cout << "\nRegistered filters:" << G4endl;
1147 std::vector<G4VFilter<G4VTrajectory>*>::const_iterator i;
1148 for (i = filterList.begin(); i != filterList.end(); ++i) {
1149 G4cout << " " << (*i)->GetName() << G4endl;
1150 if (verbosity >= parameters) (*i)->PrintAll(G4cout);
1151 }
1152 }
1153 }
1154}
1155
1156void G4VisManager::PrintInvalidPointers () const {
1157 if (fVerbosity >= errors) {
1158 G4cout << "ERROR: G4VisManager::PrintInvalidPointers:";
1159 if (!fpGraphicsSystem) {
1160 G4cout << "\n null graphics system pointer.";
1161 }
1162 else {
1163 G4cout << "\n Graphics system is " << fpGraphicsSystem -> GetName ()
1164 << " but:";
1165 if (!fpScene)
1166 G4cout <<
1167 "\n Null scene pointer. Use \"/vis/drawVolume\" or"
1168 " \"/vis/scene/create\".";
1169 if (!fpSceneHandler)
1170 G4cout <<
1171 "\n Null scene handler pointer. Use \"/vis/open\" or"
1172 " \"/vis/sceneHandler/create\".";
1173 if (!fpViewer )
1174 G4cout <<
1175 "\n Null viewer pointer. Use \"/vis/viewer/create\".";
1176 }
1177 G4cout << G4endl;
1178 }
1179}
1180
1181void G4VisManager::BeginOfRun ()
1182{
1183 //G4cout << "G4VisManager::BeginOfRun" << G4endl;
1184 fKeptLastEvent = false;
1185 fEventKeepingSuspended = false;
1186 fTransientsDrawnThisRun = false;
1187 if (fpSceneHandler) fpSceneHandler->SetTransientsDrawnThisRun(false);
1188}
1189
1190void G4VisManager::BeginOfEvent ()
1191{
1192 //G4cout << "G4VisManager::BeginOfEvent" << G4endl;
1193 fTransientsDrawnThisEvent = false;
1194 if (fpSceneHandler) fpSceneHandler->SetTransientsDrawnThisEvent(false);
1195}
1196
1197void G4VisManager::EndOfEvent ()
1198{
1199 //G4cout << "G4VisManager::EndOfEvent" << G4endl;
1200
1201 // Don't call IsValidView unless there is a scene handler. This
1202 // avoids WARNING message at end of event and run when the user has
1203 // not instantiated a scene handler, e.g., in batch mode.
1204 G4bool valid = GetConcreteInstance() && fpSceneHandler && IsValidView();
1205 if (!valid) return;
1206
1207 G4RunManager* runManager = G4RunManager::GetRunManager();
1208 const G4Run* currentRun = runManager->GetCurrentRun();
1209
1210 G4EventManager* eventManager = G4EventManager::GetEventManager();
1211 const G4Event* currentEvent = eventManager->GetConstCurrentEvent();
1212 if (!currentEvent) return;
1213
1214 ClearTransientStoreIfMarked();
1215 fpSceneHandler->DrawEvent(currentEvent);
1216
1217 G4int nEventsToBeProcessed = 0;
1218 G4int nKeptEvents = 0;
1219 G4int eventID = -2; // (If no run manager, triggers ShowView as normal.)
1220 if (currentRun) {
1221 nEventsToBeProcessed = currentRun->GetNumberOfEventToBeProcessed();
1222 eventID = currentEvent->GetEventID();
1223 const std::vector<const G4Event*>* events =
1224 currentRun->GetEventVector();
1225 if (events) nKeptEvents = events->size();
1226 }
1227
1228 if (fpScene->GetRefreshAtEndOfEvent()) {
1229
1230 // Unless last event (in which case wait end of run)...
1231 if (eventID < nEventsToBeProcessed - 1) {
1232 fpViewer->ShowView();
1233 fpSceneHandler->SetMarkForClearingTransientStore(true);
1234 } else { // Last event...
1235 // Keep, but only if user has not kept any...
1236 if (!nKeptEvents) {
1237 eventManager->KeepTheCurrentEvent();
1238 fKeptLastEvent = true;
1239 }
1240 }
1241
1242 } else { // Accumulating events...
1243
1244 G4int maxNumberOfKeptEvents = fpScene->GetMaxNumberOfKeptEvents();
1245 if (maxNumberOfKeptEvents > 0 && nKeptEvents >= maxNumberOfKeptEvents) {
1246 fEventKeepingSuspended = true;
1247 static G4bool warned = false;
1248 if (!warned) {
1249 if (fVerbosity >= warnings) {
1250 G4cout <<
1251 "WARNING: G4VisManager::EndOfEvent: Event keeping suspended."
1252 "\n The number of events exceeds the maximum that may be kept, "
1253 << maxNumberOfKeptEvents << '.'
1254 << G4endl;
1255 }
1256 warned = true;
1257 }
1258 } else if (maxNumberOfKeptEvents != 0) {
1259 eventManager->KeepTheCurrentEvent();
1260 }
1261 }
1262}
1263
1264void G4VisManager::EndOfRun ()
1265{
1266 //G4cout << "G4VisManager::EndOfRun" << G4endl;
1267
1268 // Don't call IsValidView unless there is a scene handler. This
1269 // avoids WARNING message at end of event and run when the user has
1270 // not instantiated a scene handler, e.g., in batch mode.
1271 G4bool valid = GetConcreteInstance() && fpSceneHandler && IsValidView();
1272 if (valid) {
1273 if (!fpSceneHandler->GetMarkForClearingTransientStore()) {
1274 if (fpScene->GetRefreshAtEndOfRun()) {
1275 fpViewer->ShowView();
1276 fpSceneHandler->SetMarkForClearingTransientStore(true);
1277 }
1278 }
1279
1280 if (fEventKeepingSuspended && fVerbosity >= warnings) {
1281 G4cout <<
1282 "WARNING: G4VisManager::EndOfRun: Event keeping was suspended."
1283 "\n The number of events in the run exceeded the maximum to be kept, "
1284 << fpScene->GetMaxNumberOfKeptEvents() << '.' <<
1285 "\n The number of events to be kept can be changed with"
1286 "\n \"/vis/scene/endOfEventAction accumulate <N>\", where N is the"
1287 "\n maximum number you wish to allow. N < 0 means \"unlimited\"."
1288 << G4endl;
1289 }
1290 }
1291 fEventRefreshing = false;
1292
1293 G4RunManager* runManager = G4RunManager::GetRunManager();
1294 const G4Run* currentRun = runManager->GetCurrentRun();
1295
1296 G4int nKeptEvents = 0;
1297 const std::vector<const G4Event*>* events =
1298 currentRun? currentRun->GetEventVector(): 0;
1299 if (events) nKeptEvents = events->size();
1300
1301 if (nKeptEvents && !fKeptLastEvent) {
1302 if (!valid && fVerbosity >= warnings) G4cout << "WARNING: ";
1303 if (fVerbosity >= warnings) {
1304 G4cout << nKeptEvents;
1305 if (nKeptEvents == 1) G4cout << " event has";
1306 else G4cout << " events have";
1307 G4cout << " been kept for refreshing and/or reviewing." << G4endl;
1308 }
1309 static G4bool warned = false;
1310 if (!valid && fVerbosity >= warnings && !warned) {
1311 G4cout <<
1312 " Only useful if before starting the run:"
1313 "\n a) trajectories are stored (\"/vis/scene/add/trajectories [smooth|rich]\"), or"
1314 "\n b) the Draw method of any hits is implemented."
1315 "\n To view trajectories and hits:"
1316 "\n open a viewer, draw a volume, \"/vis/scene/add/trajectories\""
1317 "\n \"/vis/scene/add/hits\" and, possibly, \"/vis/viewer/flush\"."
1318 "\n To see all events: \"/vis/scene/endOfEventAction accumulate\"."
1319 "\n To see events individually: \"/vis/reviewKeptEvents\"."
1320 << G4endl;
1321 warned = true;
1322 }
1323 }
1324}
1325
1326void G4VisManager::ClearTransientStoreIfMarked(){
1327 // Assumes valid view.
1328 if (fpSceneHandler->GetMarkForClearingTransientStore()) {
1329 fpSceneHandler->SetMarkForClearingTransientStore(false);
1330 fpSceneHandler->ClearTransientStore();
1331 }
1332 // Record if transients drawn. These local flags are only set
1333 // *after* ClearTransientStore. In the code in G4VSceneHandler
1334 // triggered by ClearTransientStore, use these flags so that
1335 // event refreshing is not done too early.
1336 fTransientsDrawnThisEvent = fpSceneHandler->GetTransientsDrawnThisEvent();
1337 fTransientsDrawnThisRun = fpSceneHandler->GetTransientsDrawnThisRun();
1338}
1339
1340void G4VisManager::ResetTransientsDrawnFlags()
1341{
1342 fTransientsDrawnThisRun = false;
1343 fTransientsDrawnThisEvent = false;
1344 G4SceneHandlerListConstIterator i;
1345 for (i = fAvailableSceneHandlers.begin();
1346 i != fAvailableSceneHandlers.end(); ++i) {
1347 (*i)->SetTransientsDrawnThisEvent(false);
1348 (*i)->SetTransientsDrawnThisRun(false);
1349 }
1350}
1351
1352G4String G4VisManager::ViewerShortName (const G4String& viewerName) const {
1353 G4String viewerShortName (viewerName);
1354 viewerShortName = viewerShortName (0, viewerShortName.find (' '));
1355 return viewerShortName.strip ();
1356}
1357
1358G4VViewer* G4VisManager::GetViewer (const G4String& viewerName) const {
1359 G4String viewerShortName = ViewerShortName (viewerName);
1360 size_t nHandlers = fAvailableSceneHandlers.size ();
1361 size_t iHandler, iViewer;
1362 G4VViewer* viewer = 0;
1363 G4bool found = false;
1364 for (iHandler = 0; iHandler < nHandlers; iHandler++) {
1365 G4VSceneHandler* sceneHandler = fAvailableSceneHandlers [iHandler];
1366 const G4ViewerList& viewerList = sceneHandler -> GetViewerList ();
1367 for (iViewer = 0; iViewer < viewerList.size (); iViewer++) {
1368 viewer = viewerList [iViewer];
1369 if (viewerShortName == viewer -> GetShortName ()) {
1370 found = true;
1371 break;
1372 }
1373 }
1374 if (found) break;
1375 }
1376 if (found) return viewer;
1377 else return 0;
1378}
1379
1380std::vector<G4String> G4VisManager::VerbosityGuidanceStrings;
1381
1382G4String G4VisManager::VerbosityString(Verbosity verbosity) {
1383 G4String s;
1384 switch (verbosity) {
1385 case quiet: s = "quiet (0)"; break;
1386 case startup: s = "startup (1)"; break;
1387 case errors: s = "errors (2)"; break;
1388 case warnings: s = "warnings (3)"; break;
1389 case confirmations: s = "confirmations (4)"; break;
1390 case parameters: s = "parameters (5)"; break;
1391 case all: s = "all (6)"; break;
1392 }
1393 return s;
1394}
1395
1396G4VisManager::Verbosity
1397G4VisManager::GetVerbosityValue(const G4String& verbosityString) {
1398 G4String s(verbosityString); s.toLower();
1399 Verbosity verbosity;
1400 if (s(0) == 'q') verbosity = quiet;
1401 else if (s(0) == 's') verbosity = startup;
1402 else if (s(0) == 'e') verbosity = errors;
1403 else if (s(0) == 'w') verbosity = warnings;
1404 else if (s(0) == 'c') verbosity = confirmations;
1405 else if (s(0) == 'p') verbosity = parameters;
1406 else if (s(0) == 'a') verbosity = all;
1407 else {
1408 G4int intVerbosity;
1409 std::istringstream is(s);
1410 is >> intVerbosity;
1411 if (!is) {
1412 G4cout << "ERROR: G4VisManager::GetVerbosityValue: invalid verbosity \""
1413 << verbosityString << "\"";
1414 for (size_t i = 0; i < VerbosityGuidanceStrings.size(); ++i) {
1415 G4cout << '\n' << VerbosityGuidanceStrings[i];
1416 }
1417 verbosity = warnings;
1418 G4cout << "\n Returning " << VerbosityString(verbosity)
1419 << G4endl;
1420 }
1421 else {
1422 verbosity = GetVerbosityValue(intVerbosity);
1423 }
1424 }
1425 return verbosity;
1426}
1427
1428G4VisManager::Verbosity G4VisManager::GetVerbosityValue(G4int intVerbosity) {
1429 Verbosity verbosity;
1430 if (intVerbosity < quiet) verbosity = quiet;
1431 else if (intVerbosity > all) verbosity = all;
1432 else verbosity = Verbosity(intVerbosity);
1433 return verbosity;
1434}
1435
1436void G4VisManager::SetVerboseLevel (G4int intVerbosity) {
1437 fVerbosity = GetVerbosityValue(intVerbosity);
1438}
1439
1440void G4VisManager::SetVerboseLevel (const G4String& verbosityString) {
1441 fVerbosity = GetVerbosityValue(verbosityString);
1442}
1443
1444G4bool G4VisManager::IsValidView () {
1445
1446 if (!fInitialised) Initialise ();
1447
1448 static G4bool noGSPrinting = true;
1449 if (!fpGraphicsSystem) {
1450 // Limit printing - we do not want printing if the user simply does
1451 // not want to use graphics, e.g., in batch mode.
1452 if (noGSPrinting) {
1453 noGSPrinting = false;
1454 if (fVerbosity >= warnings) {
1455 G4cout <<
1456 "WARNING: G4VisManager::IsValidView(): Attempt to draw when no graphics system"
1457 "\n has been instantiated. Use \"/vis/open\" or \"/vis/sceneHandler/create\"."
1458 "\n Alternatively, to avoid this message, suppress instantiation of vis"
1459 "\n manager (G4VisExecutive), possibly by setting G4VIS_NONE, and ensure"
1460 "\n drawing code is executed only if G4VVisManager::GetConcreteInstance()"
1461 "\n is non-zero."
1462 << G4endl;
1463 }
1464 }
1465 return false;
1466 }
1467
1468 if ((!fpScene) || (!fpSceneHandler) || (!fpViewer)) {
1469 if (fVerbosity >= errors) {
1470 G4cout <<
1471 "ERROR: G4VisManager::IsValidView(): Current view is not valid."
1472 << G4endl;
1473 PrintInvalidPointers ();
1474 }
1475 return false;
1476 }
1477
1478 if (fpScene != fpSceneHandler -> GetScene ()) {
1479 if (fVerbosity >= errors) {
1480 G4cout << "ERROR: G4VisManager::IsValidView ():";
1481 if (fpSceneHandler -> GetScene ()) {
1482 G4cout <<
1483 "\n The current scene \""
1484 << fpScene -> GetName ()
1485 << "\" is not handled by"
1486 "\n the current scene handler \""
1487 << fpSceneHandler -> GetName ()
1488 << "\""
1489 "\n (it currently handles scene \""
1490 << fpSceneHandler -> GetScene () -> GetName ()
1491 << "\")."
1492 "\n Either:"
1493 "\n (a) attach it to the scene handler with"
1494 "\n /vis/sceneHandler/attach "
1495 << fpScene -> GetName ()
1496 << ", or"
1497 "\n (b) create a new scene handler with "
1498 "\n /vis/sceneHandler/create <graphics-system>,"
1499 "\n in which case it should pick up the the new scene."
1500 << G4endl;
1501 }
1502 else {
1503 G4cout << "\n Scene handler \""
1504 << fpSceneHandler -> GetName ()
1505 << "\" has null scene pointer."
1506 "\n Attach a scene with /vis/sceneHandler/attach [<scene-name>]"
1507 << G4endl;
1508 }
1509 }
1510 return false;
1511 }
1512
1513 const G4ViewerList& viewerList = fpSceneHandler -> GetViewerList ();
1514 if (viewerList.size () == 0) {
1515 if (fVerbosity >= errors) {
1516 G4cout <<
1517 "ERROR: G4VisManager::IsValidView (): the current scene handler\n \""
1518 << fpSceneHandler -> GetName ()
1519 << "\" has no viewers. Do /vis/viewer/create."
1520 << G4endl;
1521 }
1522 return false;
1523 }
1524
1525 G4bool isValid = true;
1526 if (fpScene -> IsEmpty ()) { // Add world by default if possible...
1527 G4bool warn(fVerbosity >= warnings);
1528 G4bool successful = fpScene -> AddWorldIfEmpty (warn);
1529 if (!successful || fpScene -> IsEmpty ()) { // If still empty...
1530 if (fVerbosity >= errors) {
1531 G4cout << "ERROR: G4VisManager::IsViewValid ():";
1532 G4cout <<
1533 "\n Attempt at some drawing operation when scene is empty."
1534 "\n Maybe the geometry has not yet been defined."
1535 " Try /run/initialize."
1536 << G4endl;
1537 }
1538 isValid = false;
1539 }
1540 else {
1541 G4UImanager::GetUIpointer()->ApplyCommand ("/vis/scene/notifyHandlers");
1542 if (fVerbosity >= warnings) {
1543 G4cout <<
1544 "WARNING: G4VisManager: the scene was empty, \"world\" has been"
1545 "\n added and the scene handlers notified.";
1546 G4cout << G4endl;
1547 }
1548 }
1549 }
1550 if (isValid) SetConcreteInstance(this);
1551 return isValid;
1552}
1553
1554void
1555G4VisManager::RegisterModelFactories()
1556{
1557 if (fVerbosity >= warnings) {
1558 G4cout<<"G4VisManager: No model factories registered with G4VisManager."<<G4endl;
1559 G4cout<<"G4VisManager::RegisterModelFactories() should be overridden in derived"<<G4endl;
1560 G4cout<<"class. See G4VisExecutive for an example."<<G4endl;
1561 }
1562}
Note: See TracBrowser for help on using the repository browser.