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

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

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