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

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

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