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

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

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