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

Last change on this file since 1347 was 1347, checked in by garnier, 14 years ago

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