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

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

r647@mac-90108: laurentgarnier | 2007-11-15 11:32:46 +0100
Ok en Qt 4.3.0
  • Property svn:mime-type set to text/cpp
File size: 49.1 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  if (!fInitialised) Initialise ();
564  if (fpGraphicsSystem) {
565    G4VSceneHandler* pSceneHandler =
566      fpGraphicsSystem -> CreateSceneHandler (name);
567    if (pSceneHandler) {
568      fAvailableSceneHandlers.push_back (pSceneHandler);
569      fpSceneHandler = pSceneHandler;                         // Make current.
570    }
571    else {
572      if(fVerbosity >= errors) {
573        G4cout << "ERROR in G4VisManager::CreateSceneHandler during "
574               << fpGraphicsSystem -> GetName ()
575               << " scene creation.\n  No action taken."
576               << G4endl;
577      }
578    }
579  }
580  else PrintInvalidPointers ();
581}
582
583void G4VisManager::CreateViewer (G4String name) {
584
585  if (!fInitialised) Initialise ();
586
587  if (fpSceneHandler) {
588    G4VViewer* p = fpGraphicsSystem -> CreateViewer (*fpSceneHandler, name);
589    if (!p) {
590      if (fVerbosity >= errors) {
591        G4cout << "ERROR in G4VisManager::CreateViewer during "
592               << fpGraphicsSystem -> GetName ()
593               << " viewer creation.\n  No action taken."
594               << G4endl;
595      }
596    } else {
597      p -> Initialise ();
598      if (p -> GetViewId() < 0) {
599        if (fVerbosity >= errors) {
600        G4cout << "ERROR in G4VisManager::CreateViewer during "
601               << fpGraphicsSystem -> GetName ()
602               << " viewer initialisation.\n  No action taken."
603               << G4endl;
604        }
605      } else {
606        fpViewer = p;                             // Make current.
607        fpSceneHandler -> AddViewerToList (fpViewer);
608        fpSceneHandler -> SetCurrentViewer (fpViewer);
609
610        if (fVerbosity >= confirmations) {
611          G4cout << "G4VisManager::CreateViewer: new viewer created."
612                 << G4endl;
613        }
614
615        const G4ViewParameters& vp = fpViewer->GetViewParameters();
616        if (fVerbosity >= parameters) {
617          G4cout << " view parameters are:\n  " << vp << G4endl;
618        }
619
620        if (vp.IsCulling () && vp.IsCullingInvisible ()) {
621          static G4bool warned = false;
622          if (fVerbosity >= confirmations) {
623            if (!warned) {
624              G4cout <<
625  "NOTE: objects with visibility flag set to \"false\""
626  " will not be drawn!"
627  "\n  \"/vis/viewer/set/culling global false\" to Draw such objects."
628  "\n  Also see other \"/vis/viewer/set\" commands."
629                     << G4endl;
630              warned = true;
631            }
632          }
633        }
634        if (vp.IsCullingCovered ()) {
635          static G4bool warned = false;
636          if (fVerbosity >= warnings) {
637            if (!warned) {
638              G4cout <<
639  "WARNING: covered objects in solid mode will not be rendered!"
640  "\n  \"/vis/viewer/set/culling coveredDaughters false\" to reverse this."
641  "\n  Also see other \"/vis/viewer/set\" commands."
642                     << G4endl;
643              warned = true;
644            }
645          }
646        }
647      }
648    }
649  }
650  else PrintInvalidPointers ();
651}
652
653void G4VisManager::GeometryHasChanged () {
654  if (fVerbosity >= confirmations) {
655    G4cout << "G4VisManager::GeometryHasChanged() called." << G4endl;
656  }
657
658  // Change the world...
659  G4VPhysicalVolume* pWorld =
660    G4TransportationManager::GetTransportationManager ()
661    -> GetNavigatorForTracking () -> GetWorldVolume ();
662  if (!pWorld) {
663    if (fVerbosity >= warnings) {
664      G4cout << "WARNING: There is no world volume!" << G4endl;
665    }
666  }
667
668  // Check scenes.
669  G4SceneList& sceneList = fSceneList;
670  G4int iScene, nScenes = sceneList.size ();
671  for (iScene = 0; iScene < nScenes; iScene++) {
672    G4Scene* pScene = sceneList [iScene];
673    std::vector<G4VModel*>& modelList = pScene -> SetRunDurationModelList ();
674
675    if (modelList.size ()) {
676      G4bool modelInvalid;
677      do {  // Remove, if required, one at a time.
678        modelInvalid = false;
679        std::vector<G4VModel*>::iterator iterModel;
680        for (iterModel = modelList.begin();
681             iterModel != modelList.end();
682             ++iterModel) {
683          modelInvalid = !((*iterModel) -> Validate (fVerbosity >= warnings));
684          if (modelInvalid) {
685            // Model invalid - remove and break.
686            if (fVerbosity >= warnings) {
687              G4cout << "WARNING: Model \""
688                     << (*iterModel) -> GetGlobalDescription ()
689                     <<
690                "\" is no longer valid - being removed\n  from scene \""
691                     << pScene -> GetName () << "\""
692                     << G4endl;
693            }
694            modelList.erase (iterModel);
695            break;
696          }
697        }
698      } while (modelInvalid);
699
700      if (modelList.size () == 0) {
701        if (fVerbosity >= warnings) {
702          G4cout << "WARNING: No models left in this scene \""
703                 << pScene -> GetName ()
704                 << "\"."
705                 << G4endl;
706        }
707      }
708      else {
709        pScene->CalculateExtent();
710        G4UImanager::GetUIpointer () ->
711          ApplyCommand (G4String("/vis/scene/notifyHandlers " + pScene->GetName()));
712      }
713    }
714  }
715
716  // Check the manager's current scene...
717  if (fpScene && fpScene -> GetRunDurationModelList ().size () == 0) {
718    if (fVerbosity >= warnings) {
719      G4cout << "WARNING: The current scene \""
720             << fpScene -> GetName ()
721             << "\" has no models."
722             << G4endl;
723    }
724  }
725
726}
727
728G4bool G4VisManager::FilterTrajectory(const G4VTrajectory& trajectory)
729{
730  return fpTrajFilterMgr->Accept(trajectory);
731}   
732
733G4bool G4VisManager::FilterHit(const G4VHit& hit)
734{
735  return fpHitFilterMgr->Accept(hit);
736}   
737
738void G4VisManager::DispatchToModel(const G4VTrajectory& trajectory, G4int i_mode)
739{
740  G4bool visible(true);
741
742  // See if trajectory passes filter
743  G4bool passed = FilterTrajectory(trajectory);
744
745  if (!passed) {
746    // Draw invisible trajectory if trajectory failed filter and
747    // are filtering in soft mode
748    if (fpTrajFilterMgr->GetMode() == FilterMode::Soft) visible = false;
749    else {return;}
750  }
751
752  // Go on to draw trajectory
753  assert (0 != fpTrajDrawModelMgr);
754
755  const G4VTrajectoryModel* model = CurrentTrajDrawModel();
756
757  assert (0 != model); // Should exist
758
759  model->Draw(trajectory, i_mode, visible);
760}
761
762void G4VisManager::SetUserAction
763(G4VUserVisAction* pVisAction,
764 const G4VisExtent& extent) {
765  fpUserVisAction = pVisAction;
766  fUserVisActionExtent = extent;
767  if (extent.GetExtentRadius() <= 0.) {
768    if (fVerbosity >= warnings) {
769      G4cout <<
770        "WARNING: No extent set for user vis action.  (You may"
771        "\n  set it later when adding with /vis/scene/add/userAction.)"
772             << G4endl;
773    }
774  }
775}
776
777void G4VisManager::SetCurrentScene (G4Scene* pScene) {
778  if (pScene != fpScene) {
779    // A change of scene.  Therefore reset transients drawn flags.  All
780    // memory of previous transient proceessing thereby erased...
781    ResetTransientsDrawnFlags();
782  }
783  fpScene = pScene;
784}
785
786void G4VisManager::SetCurrentGraphicsSystem (G4VGraphicsSystem* pSystem) {
787  fpGraphicsSystem = pSystem;
788  if (fVerbosity >= confirmations) {
789    G4cout << "G4VisManager::SetCurrentGraphicsSystem: system now "
790           << pSystem -> GetName () << G4endl;
791  }
792  // If current scene handler is of same graphics system, leave unchanged.
793  // Else find the most recent scene handler of same graphics system.
794  // Or clear pointers.
795  if (!(fpSceneHandler && fpSceneHandler -> GetGraphicsSystem () == pSystem)) {
796    const G4SceneHandlerList& sceneHandlerList = fAvailableSceneHandlers;
797    G4int nSH = sceneHandlerList.size ();  // No. of scene handlers.
798    G4int iSH;
799    for (iSH = nSH - 1; iSH >= 0; iSH--) {
800      if (sceneHandlerList [iSH] -> GetGraphicsSystem () == pSystem) break;
801    }
802    if (iSH >= 0) {
803      fpSceneHandler = sceneHandlerList [iSH];
804      if (fVerbosity >= confirmations) {
805        G4cout << "  Scene Handler now "
806               << fpSceneHandler -> GetName () << G4endl;
807      }
808      if (fpScene != fpSceneHandler -> GetScene ()) {
809        fpScene = fpSceneHandler -> GetScene ();
810        if (fVerbosity >= confirmations) {
811          G4cout << "  Scene now \""
812                 << fpScene -> GetName () << "\"" << G4endl;
813        }
814      }
815      const G4ViewerList& viewerList = fpSceneHandler -> GetViewerList ();
816      if (viewerList.size ()) {
817        fpViewer = viewerList [0];
818        if (fVerbosity >= confirmations) {
819          G4cout << "  Viewer now " << fpViewer -> GetName () << G4endl;
820        }
821      }
822      else {
823        fpViewer = 0;
824      }
825    }
826    else {
827      fpSceneHandler = 0;
828      fpViewer = 0;
829    }
830  }
831}
832
833void G4VisManager::SetCurrentSceneHandler (G4VSceneHandler* pSceneHandler) {
834  fpSceneHandler = pSceneHandler;
835  if (fVerbosity >= confirmations) {
836    G4cout << "G4VisManager::SetCurrentSceneHandler: scene handler now \""
837           << pSceneHandler -> GetName () << "\"" << G4endl;
838  }
839  if (fpScene != fpSceneHandler -> GetScene ()) {
840    fpScene = fpSceneHandler -> GetScene ();
841    if (fVerbosity >= confirmations) {
842      G4cout << "  Scene now \""
843             << fpScene -> GetName () << "\"" << G4endl;
844    }
845  }
846  if (fpGraphicsSystem != pSceneHandler -> GetGraphicsSystem ()) {
847    fpGraphicsSystem = pSceneHandler -> GetGraphicsSystem ();
848    if (fVerbosity >= confirmations) {
849      G4cout << "  Graphics system now \""
850             << fpGraphicsSystem -> GetName () << "\"" << G4endl;
851    }
852  }
853  const G4ViewerList& viewerList = fpSceneHandler -> GetViewerList ();
854  G4int nViewers = viewerList.size ();
855  if (nViewers) {
856    G4int iViewer;
857    for (iViewer = 0; iViewer < nViewers; iViewer++) {
858      if (fpViewer == viewerList [iViewer]) break;
859    }
860    if (iViewer >= nViewers) {
861      fpViewer = viewerList [0];
862      if (fVerbosity >= confirmations) {
863        G4cout << "  Viewer now \"" << fpViewer -> GetName () << "\""
864               << G4endl;
865      }
866    }
867    IsValidView ();  // Checks.
868  }
869  else {
870    fpViewer = 0;
871    if (fVerbosity >= warnings) {
872      G4cout <<
873        "WARNING: No viewers for this scene handler - please create one."
874             << G4endl;
875    }
876  }
877}
878
879void G4VisManager::SetCurrentViewer (G4VViewer* pViewer) {
880  fpViewer  = pViewer;
881  if (fVerbosity >= confirmations) {
882    G4cout << "G4VisManager::SetCurrentViewer: viewer now "
883           << pViewer -> GetName ()
884           << G4endl;
885  }
886  fpSceneHandler = fpViewer -> GetSceneHandler ();
887  fpSceneHandler -> SetCurrentViewer (pViewer);
888  fpScene = fpSceneHandler -> GetScene ();
889  fpGraphicsSystem = fpSceneHandler -> GetGraphicsSystem ();
890  IsValidView ();  // Checks.
891}
892
893void G4VisManager::RegisterMessengers () {
894
895  // Instantiate individual messengers/commands (often - but not
896  // always - one command per messenger).
897
898  G4VVisCommand::SetVisManager (this);  // Sets shared pointer to vis manager.
899
900  G4UIcommand* directory;
901
902  // Top level basic commands...
903  RegisterMessenger(new G4VisCommandAbortReviewKeptEvents);
904  RegisterMessenger(new G4VisCommandEnable);
905  RegisterMessenger(new G4VisCommandList);
906  RegisterMessenger(new G4VisCommandVerbose);
907
908  // Other top level commands...
909  RegisterMessenger(new G4VisCommandReviewKeptEvents);
910
911  // Compound commands...
912  RegisterMessenger(new G4VisCommandDrawTree);
913  RegisterMessenger(new G4VisCommandDrawView);
914  RegisterMessenger(new G4VisCommandDrawVolume);
915  RegisterMessenger(new G4VisCommandOpen);
916  RegisterMessenger(new G4VisCommandSpecify);
917
918  directory = new G4UIdirectory ("/vis/geometry/");
919  directory -> SetGuidance("Operations on vis attributes of Geant4 geometry.");
920  fDirectoryList.push_back (directory);
921  RegisterMessenger(new G4VisCommandGeometryList);
922  RegisterMessenger(new G4VisCommandGeometryRestore);
923
924  directory = new G4UIdirectory ("/vis/geometry/set/");
925  directory -> SetGuidance("Set vis attributes of Geant4 geometry.");
926  fDirectoryList.push_back (directory);
927  RegisterMessenger(new G4VisCommandGeometrySetColour);
928  RegisterMessenger(new G4VisCommandGeometrySetDaughtersInvisible);
929  RegisterMessenger(new G4VisCommandGeometrySetLineStyle);
930  RegisterMessenger(new G4VisCommandGeometrySetLineWidth);
931  RegisterMessenger(new G4VisCommandGeometrySetForceAuxEdgeVisible);
932  RegisterMessenger(new G4VisCommandGeometrySetForceLineSegmentsPerCircle);
933  RegisterMessenger(new G4VisCommandGeometrySetForceSolid);
934  RegisterMessenger(new G4VisCommandGeometrySetForceWireframe);
935  RegisterMessenger(new G4VisCommandGeometrySetVisibility);
936
937  directory = new G4UIdirectory ("/vis/scene/");
938  directory -> SetGuidance ("Operations on Geant4 scenes.");
939  fDirectoryList.push_back (directory);
940  RegisterMessenger(new G4VisCommandSceneCreate);
941  RegisterMessenger(new G4VisCommandSceneEndOfEventAction);
942  RegisterMessenger(new G4VisCommandSceneEndOfRunAction);
943  RegisterMessenger(new G4VisCommandSceneList);
944  RegisterMessenger(new G4VisCommandSceneNotifyHandlers);
945  RegisterMessenger(new G4VisCommandSceneSelect);
946
947  directory = new G4UIdirectory ("/vis/scene/add/");
948  directory -> SetGuidance ("Add model to current scene.");
949  fDirectoryList.push_back (directory);
950  RegisterMessenger(new G4VisCommandSceneAddAxes);
951  RegisterMessenger(new G4VisCommandSceneAddEventID);
952  RegisterMessenger(new G4VisCommandSceneAddGhosts);
953  RegisterMessenger(new G4VisCommandSceneAddHits);
954  RegisterMessenger(new G4VisCommandSceneAddLogicalVolume);
955  RegisterMessenger(new G4VisCommandSceneAddLogo);
956  RegisterMessenger(new G4VisCommandSceneAddScale);
957  RegisterMessenger(new G4VisCommandSceneAddText);
958  RegisterMessenger(new G4VisCommandSceneAddTrajectories);
959  RegisterMessenger(new G4VisCommandSceneAddUserAction);
960  RegisterMessenger(new G4VisCommandSceneAddVolume);
961
962  directory = new G4UIdirectory ("/vis/sceneHandler/");
963  directory -> SetGuidance ("Operations on Geant4 scene handlers.");
964  fDirectoryList.push_back (directory);
965  RegisterMessenger(new G4VisCommandSceneHandlerAttach);
966  RegisterMessenger(new G4VisCommandSceneHandlerCreate);
967  RegisterMessenger(new G4VisCommandSceneHandlerList);
968  RegisterMessenger(new G4VisCommandSceneHandlerSelect);
969
970  directory = new G4UIdirectory ("/vis/viewer/");
971  directory -> SetGuidance ("Operations on Geant4 viewers.");
972  fDirectoryList.push_back (directory);
973  RegisterMessenger(new G4VisCommandViewerAddCutawayPlane);
974  RegisterMessenger(new G4VisCommandViewerChangeCutawayPlane);
975  RegisterMessenger(new G4VisCommandViewerClear);
976  RegisterMessenger(new G4VisCommandViewerClearCutawayPlanes);
977  RegisterMessenger(new G4VisCommandViewerClearTransients);
978  RegisterMessenger(new G4VisCommandViewerClone);
979  RegisterMessenger(new G4VisCommandViewerCreate);
980  RegisterMessenger(new G4VisCommandViewerDolly);
981  RegisterMessenger(new G4VisCommandViewerFlush);
982  RegisterMessenger(new G4VisCommandViewerList);
983  RegisterMessenger(new G4VisCommandViewerPan);
984  RegisterMessenger(new G4VisCommandViewerRebuild);
985  RegisterMessenger(new G4VisCommandViewerRefresh);
986  RegisterMessenger(new G4VisCommandViewerReset);
987  RegisterMessenger(new G4VisCommandViewerScale);
988  RegisterMessenger(new G4VisCommandViewerSelect);
989  RegisterMessenger(new G4VisCommandViewerUpdate);
990  RegisterMessenger(new G4VisCommandViewerZoom);
991
992  directory = new G4UIdirectory ("/vis/viewer/set/");
993  directory -> SetGuidance ("Set view parameters of current viewer.");
994  fDirectoryList.push_back (directory);
995  RegisterMessenger(new G4VisCommandsViewerSet);
996
997  // List manager commands
998  RegisterMessenger(new G4VisCommandListManagerList< G4VisModelManager<G4VTrajectoryModel> >
999                    (fpTrajDrawModelMgr, fpTrajDrawModelMgr->Placement()));
1000  RegisterMessenger(new G4VisCommandListManagerSelect< G4VisModelManager<G4VTrajectoryModel> >
1001                    (fpTrajDrawModelMgr, fpTrajDrawModelMgr->Placement())); 
1002
1003  // Trajectory filter manager commands
1004  RegisterMessenger(new G4VisCommandListManagerList< G4VisFilterManager<G4VTrajectory> >
1005                    (fpTrajFilterMgr, fpTrajFilterMgr->Placement()));
1006  RegisterMessenger(new G4VisCommandManagerMode< G4VisFilterManager<G4VTrajectory> >
1007                    (fpTrajFilterMgr, fpTrajFilterMgr->Placement()));
1008
1009  // Hit filter manager commands
1010  RegisterMessenger(new G4VisCommandListManagerList< G4VisFilterManager<G4VHit> >
1011                    (fpHitFilterMgr, fpHitFilterMgr->Placement()));
1012  RegisterMessenger(new G4VisCommandManagerMode< G4VisFilterManager<G4VHit> >
1013                    (fpHitFilterMgr, fpHitFilterMgr->Placement()));
1014}
1015
1016void G4VisManager::PrintAvailableGraphicsSystems () const {
1017  G4int nSystems = fAvailableGraphicsSystems.size ();
1018  G4cout << "Current available graphics systems are:";
1019  if (nSystems) {
1020    for (int i = 0; i < nSystems; i++) {
1021      const G4VGraphicsSystem* pSystem = fAvailableGraphicsSystems [i];
1022      G4cout << "\n  " << pSystem -> GetName ();
1023      if (pSystem -> GetNickname () != "") {
1024        G4cout << " (" << pSystem -> GetNickname () << ")";
1025      }
1026    }
1027  }
1028  else {
1029    G4cout << "\n  NONE!!!  None registered - yet!  Mmmmm!";
1030  }
1031  G4cout << G4endl;
1032}
1033
1034void G4VisManager::PrintAvailableModels (Verbosity verbosity) const
1035{
1036  {
1037    //fpTrajDrawModelMgr->Print(G4cout);
1038    G4cout << "Registered model factories:" << G4endl;
1039    const std::vector<G4VModelFactory<G4VTrajectoryModel>*>& factoryList =
1040      fpTrajDrawModelMgr->FactoryList();
1041    if (factoryList.empty()) G4cout << "  None" << G4endl;
1042    else {
1043      std::vector<G4VModelFactory<G4VTrajectoryModel>*>::const_iterator i;
1044      for (i = factoryList.begin(); i != factoryList.end(); ++i)
1045        (*i)->Print(G4cout);
1046    }
1047    const G4VisListManager<G4VTrajectoryModel>* listManager =
1048      fpTrajDrawModelMgr->ListManager();
1049    const std::map<G4String, G4VTrajectoryModel*>& modelMap =
1050      listManager->Map();
1051    if (!modelMap.empty()) {
1052      G4cout << "\nRegistered models:" << G4endl;
1053      std::map<G4String, G4VTrajectoryModel*>::const_iterator i;
1054      for (i = modelMap.begin(); i != modelMap.end(); ++i) {
1055        G4cout << "  " << i->second->Name();
1056        if (i->second == listManager->Current()) G4cout << " (Current)";
1057        G4cout << G4endl;
1058        if (verbosity >= parameters) i->second->Print(G4cout);
1059      }
1060    }
1061  }
1062
1063  G4cout << G4endl;
1064
1065  {
1066    //fpTrajFilterMgr->Print(G4cout);
1067    G4cout << "Registered filter factories:" << G4endl;
1068    const std::vector<G4VModelFactory<G4VFilter<G4VTrajectory> >*>&
1069      factoryList = fpTrajFilterMgr->FactoryList();
1070    if (factoryList.empty()) G4cout << "  None" << G4endl;
1071    else {
1072      std::vector<G4VModelFactory<G4VFilter<G4VTrajectory> >*>::const_iterator i;
1073      for (i = factoryList.begin(); i != factoryList.end(); ++i)
1074        (*i)->Print(G4cout);
1075    }
1076    const std::vector<G4VFilter<G4VTrajectory>*>&
1077      filterList = fpTrajFilterMgr->FilterList();
1078    if (!filterList.empty()) {
1079      G4cout << "\nRegistered filters:" << G4endl;
1080      std::vector<G4VFilter<G4VTrajectory>*>::const_iterator i;
1081      for (i = filterList.begin(); i != filterList.end(); ++i) {
1082        G4cout << "  " << (*i)->GetName() << G4endl;
1083        if (verbosity >= parameters) (*i)->PrintAll(G4cout);
1084      }
1085    }
1086  }
1087}
1088
1089void G4VisManager::PrintInvalidPointers () const {
1090  if (fVerbosity >= errors) {
1091    G4cout << "ERROR: G4VisManager::PrintInvalidPointers:";
1092    if (!fpGraphicsSystem) {
1093      G4cout << "\n null graphics system pointer.";
1094    }
1095    else {
1096      G4cout << "\n  Graphics system is " << fpGraphicsSystem -> GetName ()
1097             << " but:";
1098      if (!fpScene)
1099        G4cout <<
1100          "\n  Null scene pointer. Use \"/vis/drawVolume\" or"
1101          " \"/vis/scene/create\".";
1102      if (!fpSceneHandler)
1103        G4cout <<
1104          "\n  Null scene handler pointer. Use \"/vis/open\" or"
1105          " \"/vis/sceneHandler/create\".";
1106      if (!fpViewer )
1107        G4cout <<
1108          "\n  Null viewer pointer. Use \"/vis/viewer/create\".";
1109    }
1110    G4cout << G4endl;
1111  }
1112}
1113
1114void G4VisManager::BeginOfRun ()
1115{
1116  //G4cout << "G4VisManager::BeginOfRun" << G4endl;
1117  fKeptLastEvent = false;
1118  fEventKeepingSuspended = false;
1119  fTransientsDrawnThisRun = false;
1120  if (fpSceneHandler) fpSceneHandler->SetTransientsDrawnThisRun(false);
1121}
1122
1123void G4VisManager::BeginOfEvent ()
1124{
1125  //G4cout << "G4VisManager::BeginOfEvent" << G4endl;
1126  fTransientsDrawnThisEvent = false;
1127  if (fpSceneHandler) fpSceneHandler->SetTransientsDrawnThisEvent(false);
1128}
1129
1130void G4VisManager::EndOfEvent ()
1131{
1132  //G4cout << "G4VisManager::EndOfEvent" << G4endl;
1133
1134  // Don't call IsValidView unless there is a scene handler.  This
1135  // avoids WARNING message at end of event and run when the user has
1136  // not instantiated a scene handler, e.g., in batch mode.
1137  G4bool valid = GetConcreteInstance() && fpSceneHandler && IsValidView();
1138  if (!valid) return;
1139
1140  G4RunManager* runManager = G4RunManager::GetRunManager();
1141  const G4Run* currentRun = runManager->GetCurrentRun();
1142
1143  G4EventManager* eventManager = G4EventManager::GetEventManager();
1144  const G4Event* currentEvent = eventManager->GetConstCurrentEvent();
1145  if (!currentEvent) return;
1146
1147  ClearTransientStoreIfMarked();
1148  fpSceneHandler->DrawEvent(currentEvent);
1149
1150  G4int nEventsToBeProcessed = 0;
1151  G4int nKeptEvents = 0;
1152  G4int eventID = -2;  // (If no run manager, triggers ShowView as normal.)
1153  if (currentRun) {
1154    nEventsToBeProcessed = currentRun->GetNumberOfEventToBeProcessed();
1155    eventID = currentEvent->GetEventID();
1156    const std::vector<const G4Event*>* events =
1157      currentRun->GetEventVector();
1158    if (events) nKeptEvents = events->size();
1159  }
1160
1161  if (fpScene->GetRefreshAtEndOfEvent()) {
1162
1163    // Unless last event (in which case wait end of run)...
1164    if (eventID < nEventsToBeProcessed - 1) {
1165      fpViewer->ShowView();
1166      fpSceneHandler->SetMarkForClearingTransientStore(true);
1167    } else {  // Last event...
1168      // Keep, but only if user has not kept any...
1169      if (!nKeptEvents) {
1170        eventManager->KeepTheCurrentEvent();
1171        fKeptLastEvent = true;
1172      }
1173    }
1174
1175  } else {  //  Accumulating events...
1176
1177    G4int maxNumberOfKeptEvents = fpScene->GetMaxNumberOfKeptEvents();
1178    if (maxNumberOfKeptEvents > 0 && nKeptEvents >= maxNumberOfKeptEvents) {
1179      fEventKeepingSuspended = true;
1180      static G4bool warned = false;
1181      if (!warned) {
1182        if (fVerbosity >= warnings) {
1183          G4cout <<
1184            "WARNING: G4VisManager::EndOfEvent: Event keeping suspended."
1185            "\n  The number of events exceeds the maximum that may be kept, "
1186                 << maxNumberOfKeptEvents << '.'
1187                 << G4endl;
1188        }
1189        warned = true;
1190      }
1191    } else if (maxNumberOfKeptEvents != 0) {
1192      eventManager->KeepTheCurrentEvent();
1193    }
1194  }
1195}
1196
1197void G4VisManager::EndOfRun ()
1198{
1199  //G4cout << "G4VisManager::EndOfRun" << G4endl;
1200
1201  // Don't call IsValidView unless there is a scene handler.  This
1202  // avoids WARNING message at end of event and run when the user has
1203  // not instantiated a scene handler, e.g., in batch mode.
1204  G4bool valid = GetConcreteInstance() && fpSceneHandler && IsValidView();
1205  if (valid) {
1206    if (!fpSceneHandler->GetMarkForClearingTransientStore()) {
1207      if (fpScene->GetRefreshAtEndOfRun()) {
1208        fpViewer->ShowView();
1209        fpSceneHandler->SetMarkForClearingTransientStore(true);
1210      }
1211    }
1212
1213    if (fEventKeepingSuspended && fVerbosity >= warnings) {
1214      G4cout <<
1215        "WARNING: G4VisManager::EndOfRun: Event keeping was suspended."
1216        "\n  The number of events in the run exceeded the maximum to be kept, "
1217             << fpScene->GetMaxNumberOfKeptEvents() << '.' <<
1218        "\n  The number of events to be kept can be changed with"
1219        "\n  \"/vis/scene/endOfEventAction accumulate <N>\", where N is the"
1220        "\n  maximum number you wish to allow.  N < 0 means \"unlimited\"."
1221             << G4endl;
1222    }
1223  }
1224  fEventRefreshing = false;
1225
1226  G4RunManager* runManager = G4RunManager::GetRunManager();
1227  const G4Run* currentRun = runManager->GetCurrentRun();
1228 
1229  G4int nKeptEvents = 0;
1230  const std::vector<const G4Event*>* events =
1231    currentRun? currentRun->GetEventVector(): 0;
1232  if (events) nKeptEvents = events->size();
1233
1234  if (nKeptEvents && !fKeptLastEvent) {
1235    if (!valid && fVerbosity >= warnings) G4cout << "WARNING: ";
1236    if (fVerbosity >= warnings) {
1237      G4cout << nKeptEvents;
1238      if (nKeptEvents == 1) G4cout << " event has";
1239      else G4cout << " events have";
1240      G4cout << " been kept for refreshing and/or reviewing." << G4endl;
1241    }
1242    static G4bool warned = false;
1243    if (!valid && fVerbosity >= warnings && !warned) {
1244      G4cout <<
1245        "  Only useful if before starting the run:"
1246        "\n    a) trajectories are stored (\"/vis/scene/add/trajectories [smooth|rich]\"), or"
1247        "\n    b) the Draw method of any hits is implemented."
1248        "\n  To view trajectories and hits:"
1249        "\n    open a viewer, draw a volume, \"/vis/scene/add/trajectories\""
1250        "\n    \"/vis/scene/add/hits\" and, possibly, \"/vis/viewer/flush\"."
1251        "\n  To see all events: \"/vis/scene/endOfEventAction accumulate\"."
1252        "\n  To see events individually: \"/vis/reviewKeptEvents\"."
1253             << G4endl;
1254      warned = true;
1255    }
1256  }
1257}
1258
1259void G4VisManager::ClearTransientStoreIfMarked(){
1260  // Assumes valid view.
1261  if (fpSceneHandler->GetMarkForClearingTransientStore()) {
1262    fpSceneHandler->SetMarkForClearingTransientStore(false);
1263    fpSceneHandler->ClearTransientStore();
1264  }
1265  // Record if transients drawn.  These local flags are only set
1266  // *after* ClearTransientStore.  In the code in G4VSceneHandler
1267  // triggered by ClearTransientStore, use these flags so that
1268  // event refreshing is not done too early.
1269  fTransientsDrawnThisEvent = fpSceneHandler->GetTransientsDrawnThisEvent();
1270  fTransientsDrawnThisRun = fpSceneHandler->GetTransientsDrawnThisRun();
1271}
1272
1273void G4VisManager::ResetTransientsDrawnFlags()
1274{
1275  fTransientsDrawnThisRun = false;
1276  fTransientsDrawnThisEvent = false;
1277  G4SceneHandlerListConstIterator i;
1278  for (i = fAvailableSceneHandlers.begin();
1279       i != fAvailableSceneHandlers.end(); ++i) {
1280    (*i)->SetTransientsDrawnThisEvent(false);
1281    (*i)->SetTransientsDrawnThisRun(false);
1282  }
1283}
1284
1285G4String G4VisManager::ViewerShortName (const G4String& viewerName) const {
1286  G4String viewerShortName (viewerName);
1287  viewerShortName = viewerShortName (0, viewerShortName.find (' '));
1288  return viewerShortName.strip ();
1289}
1290
1291G4VViewer* G4VisManager::GetViewer (const G4String& viewerName) const {
1292  G4String viewerShortName = ViewerShortName (viewerName);
1293  size_t nHandlers = fAvailableSceneHandlers.size ();
1294  size_t iHandler, iViewer;
1295  G4VViewer* viewer = 0;
1296  G4bool found = false;
1297  for (iHandler = 0; iHandler < nHandlers; iHandler++) {
1298    G4VSceneHandler* sceneHandler = fAvailableSceneHandlers [iHandler];
1299    const G4ViewerList& viewerList = sceneHandler -> GetViewerList ();
1300    for (iViewer = 0; iViewer < viewerList.size (); iViewer++) {
1301      viewer = viewerList [iViewer];
1302      if (viewerShortName == viewer -> GetShortName ()) {
1303        found = true;
1304        break;
1305      }
1306    }
1307    if (found) break;
1308  }
1309  if (found) return viewer;
1310  else return 0;
1311}
1312
1313std::vector<G4String> G4VisManager::VerbosityGuidanceStrings;
1314
1315G4String G4VisManager::VerbosityString(Verbosity verbosity) {
1316  G4String s;
1317  switch (verbosity) {
1318  case         quiet: s = "quiet (0)"; break;
1319  case       startup: s = "startup (1)"; break;
1320  case        errors: s = "errors (2)"; break;
1321  case      warnings: s = "warnings (3)"; break;
1322  case confirmations: s = "confirmations (4)"; break;
1323  case    parameters: s = "parameters (5)"; break;
1324  case           all: s = "all (6)"; break;
1325  }
1326  return s;
1327}
1328
1329G4VisManager::Verbosity
1330G4VisManager::GetVerbosityValue(const G4String& verbosityString) {
1331  G4String s(verbosityString); s.toLower();
1332  Verbosity verbosity;
1333  if      (s(0) == 'q') verbosity = quiet;
1334  else if (s(0) == 's') verbosity = startup;
1335  else if (s(0) == 'e') verbosity = errors;
1336  else if (s(0) == 'w') verbosity = warnings;
1337  else if (s(0) == 'c') verbosity = confirmations;
1338  else if (s(0) == 'p') verbosity = parameters;
1339  else if (s(0) == 'a') verbosity = all;
1340  else {
1341    G4int intVerbosity;
1342    std::istringstream is(s);
1343    is >> intVerbosity;
1344    if (!is) {
1345      G4cout << "ERROR: G4VisManager::GetVerbosityValue: invalid verbosity \""
1346             << verbosityString << "\"";
1347      for (size_t i = 0; i < VerbosityGuidanceStrings.size(); ++i) {
1348        G4cout << '\n' << VerbosityGuidanceStrings[i];
1349      }
1350      verbosity = warnings;
1351      G4cout << "\n  Returning " << VerbosityString(verbosity)
1352             << G4endl;
1353    }
1354    else {
1355      verbosity = GetVerbosityValue(intVerbosity);
1356    }
1357  }
1358  return verbosity;
1359}
1360
1361G4VisManager::Verbosity G4VisManager::GetVerbosityValue(G4int intVerbosity) {
1362  Verbosity verbosity;
1363  if      (intVerbosity < quiet) verbosity = quiet;
1364  else if (intVerbosity > all)   verbosity = all;
1365  else                           verbosity = Verbosity(intVerbosity);
1366  return verbosity;
1367}
1368
1369void G4VisManager::SetVerboseLevel (G4int intVerbosity) {
1370  fVerbosity = GetVerbosityValue(intVerbosity);
1371}
1372
1373void G4VisManager::SetVerboseLevel (const G4String& verbosityString) {
1374  fVerbosity = GetVerbosityValue(verbosityString);
1375}
1376
1377G4bool G4VisManager::IsValidView () {
1378
1379  if (!fInitialised) Initialise ();
1380
1381  static G4bool noGSPrinting = true;
1382  if (!fpGraphicsSystem) {
1383    // Limit printing - we do not want printing if the user simply does
1384    // not want to use graphics, e.g., in batch mode.
1385    if (noGSPrinting) {
1386      noGSPrinting = false;
1387      if (fVerbosity >= warnings) {
1388        G4cout <<
1389  "WARNING: G4VisManager::IsValidView(): Attempt to draw when no graphics system"
1390  "\n  has been instantiated.  Use \"/vis/open\" or \"/vis/sceneHandler/create\"."
1391  "\n  Alternatively, to avoid this message, suppress instantiation of vis"
1392  "\n  manager (G4VisExecutive), possibly by setting G4VIS_NONE, and ensure"
1393  "\n  drawing code is executed only if G4VVisManager::GetConcreteInstance()"
1394  "\n  is non-zero."
1395               << G4endl;
1396      }
1397    }
1398    return false;
1399  }
1400
1401  if ((!fpScene) || (!fpSceneHandler) || (!fpViewer)) {
1402    if (fVerbosity >= errors) {
1403      G4cout <<
1404        "ERROR: G4VisManager::IsValidView(): Current view is not valid."
1405             << G4endl;
1406      PrintInvalidPointers ();
1407    }
1408    return false;
1409  }
1410
1411  if (fpScene != fpSceneHandler -> GetScene ()) {
1412    if (fVerbosity >= errors) {
1413      G4cout << "ERROR: G4VisManager::IsValidView ():";
1414      if (fpSceneHandler -> GetScene ()) {
1415        G4cout <<
1416          "\n  The current scene \""
1417               << fpScene -> GetName ()
1418               << "\" is not handled by"
1419          "\n  the current scene handler \""
1420               << fpSceneHandler -> GetName ()
1421               << "\""
1422          "\n  (it currently handles scene \""
1423               << fpSceneHandler -> GetScene () -> GetName ()
1424               << "\")."
1425          "\n  Either:"
1426          "\n  (a) attach it to the scene handler with"
1427          "\n      /vis/sceneHandler/attach "
1428               << fpScene -> GetName ()
1429               <<       ", or"
1430          "\n  (b) create a new scene handler with "
1431          "\n      /vis/sceneHandler/create <graphics-system>,"
1432          "\n      in which case it should pick up the the new scene."
1433               << G4endl;
1434      }
1435      else {
1436        G4cout << "\n  Scene handler \""
1437               << fpSceneHandler -> GetName ()
1438               << "\" has null scene pointer."
1439          "\n  Attach a scene with /vis/sceneHandler/attach [<scene-name>]"
1440               << G4endl;
1441      }
1442    }
1443    return false;
1444  }
1445
1446  const G4ViewerList& viewerList = fpSceneHandler -> GetViewerList ();
1447  if (viewerList.size () == 0) {
1448    if (fVerbosity >= errors) {
1449      G4cout <<
1450        "ERROR: G4VisManager::IsValidView (): the current scene handler\n  \""
1451             << fpSceneHandler -> GetName ()
1452             << "\" has no viewers.  Do /vis/viewer/create."
1453             << G4endl;
1454    }
1455    return false;
1456  }
1457
1458  G4bool isValid = true;
1459  if (fpScene -> IsEmpty ()) {  // Add world by default if possible...
1460    G4bool warn(fVerbosity >= warnings);
1461    G4bool successful = fpScene -> AddWorldIfEmpty (warn);
1462    if (!successful || fpScene -> IsEmpty ()) {        // If still empty...
1463      if (fVerbosity >= errors) {
1464        G4cout << "ERROR: G4VisManager::IsViewValid ():";
1465        G4cout <<
1466          "\n  Attempt at some drawing operation when scene is empty."
1467          "\n  Maybe the geometry has not yet been defined."
1468          "  Try /run/initialize."
1469               << G4endl;
1470      }
1471      isValid = false;
1472    }
1473    else {
1474      G4UImanager::GetUIpointer()->ApplyCommand ("/vis/scene/notifyHandlers");
1475      if (fVerbosity >= warnings) {
1476        G4cout <<
1477          "WARNING: G4VisManager: the scene was empty, \"world\" has been"
1478          "\n  added and the scene handlers notified.";
1479        G4cout << G4endl;
1480      }
1481    }
1482  }
1483  if (isValid) SetConcreteInstance(this);
1484  return isValid;
1485}
1486
1487void
1488G4VisManager::RegisterModelFactories()
1489{
1490  if (fVerbosity >= warnings) {
1491    G4cout<<"G4VisManager: No model factories registered with G4VisManager."<<G4endl;
1492    G4cout<<"G4VisManager::RegisterModelFactories() should be overridden in derived"<<G4endl;
1493    G4cout<<"class. See G4VisExecutive for an example."<<G4endl;
1494  }
1495}
Note: See TracBrowser for help on using the repository browser.