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

Last change on this file since 612 was 610, checked in by garnier, 17 years ago

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