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

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

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