source: trunk/source/visualization/management/src/G4VisManager.cc@ 1288

Last change on this file since 1288 was 1288, checked in by garnier, 15 years ago

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