G4VisManager Class Reference

#include <G4VisManager.hh>

Inheritance diagram for G4VisManager:

Collaboration diagram for G4VisManager:

Classes
struct	UserVisAction

Public Types
enum	Verbosity {   quiet, startup, errors, warnings,   confirmations, parameters, all }

Public Member Functions
virtual	~G4VisManager ()
void	Initialise ()
void	Initialize ()
void	RegisterRunDurationUserVisAction (const G4String &name, G4VUserVisAction *, const G4VisExtent &=G4VisExtent::NullExtent)
void	RegisterEndOfEventUserVisAction (const G4String &name, G4VUserVisAction *, const G4VisExtent &=G4VisExtent::NullExtent)
void	RegisterEndOfRunUserVisAction (const G4String &name, G4VUserVisAction *, const G4VisExtent &=G4VisExtent::NullExtent)
G4bool	RegisterGraphicsSystem (G4VGraphicsSystem *)
void	RegisterModelFactory (G4TrajDrawModelFactory *factory)
void	RegisterModel (G4VTrajectoryModel *model)
void	RegisterModelFactory (G4TrajFilterFactory *factory)
void	RegisterModel (G4VFilter< G4VTrajectory > *filter)
void	RegisterModelFactory (G4HitFilterFactory *factory)
void	RegisterModel (G4VFilter< G4VHit > *filter)
void	RegisterModelFactory (G4DigiFilterFactory *factory)
void	RegisterModel (G4VFilter< G4VDigi > *filter)
void	SelectTrajectoryModel (const G4String &model)
void	RegisterMessenger (G4UImessenger *messenger)
void	Draw (const G4Circle &, const G4Transform3D &objectTransformation=G4Transform3D())
void	Draw (const G4Polyhedron &, const G4Transform3D &objectTransformation=G4Transform3D())
void	Draw (const G4Polyline &, const G4Transform3D &objectTransformation=G4Transform3D())
void	Draw (const G4Polymarker &, const G4Transform3D &objectTransformation=G4Transform3D())
void	Draw (const G4Scale &, const G4Transform3D &objectTransformation=G4Transform3D())
void	Draw (const G4Square &, const G4Transform3D &objectTransformation=G4Transform3D())
void	Draw (const G4Text &, const G4Transform3D &objectTransformation=G4Transform3D())
void	Draw2D (const G4Circle &, const G4Transform3D &objectTransformation=G4Transform3D())
void	Draw2D (const G4Polyhedron &, const G4Transform3D &objectTransformation=G4Transform3D())
void	Draw2D (const G4Polyline &, const G4Transform3D &objectTransformation=G4Transform3D())
void	Draw2D (const G4Polymarker &, const G4Transform3D &objectTransformation=G4Transform3D())
void	Draw2D (const G4Square &, const G4Transform3D &objectTransformation=G4Transform3D())
void	Draw2D (const G4Text &, const G4Transform3D &objectTransformation=G4Transform3D())
void	Draw (const G4VTrajectory &)
void	Draw (const G4VHit &)
void	Draw (const G4VDigi &)
void	Draw (const G4LogicalVolume &, const G4VisAttributes &, const G4Transform3D &objectTransformation=G4Transform3D())
void	Draw (const G4VPhysicalVolume &, const G4VisAttributes &, const G4Transform3D &objectTransformation=G4Transform3D())
void	Draw (const G4VSolid &, const G4VisAttributes &, const G4Transform3D &objectTransformation=G4Transform3D())
void	BeginDraw (const G4Transform3D &objectTransformation=G4Transform3D())
void	EndDraw ()
void	BeginDraw2D (const G4Transform3D &objectTransformation=G4Transform3D())
void	EndDraw2D ()
void	GeometryHasChanged ()
void	IgnoreStateChanges (G4bool)
void	NotifyHandlers ()
void	DispatchToModel (const G4VTrajectory &)
G4bool	FilterTrajectory (const G4VTrajectory &)
G4bool	FilterHit (const G4VHit &)
G4bool	FilterDigi (const G4VDigi &)
void	CreateSceneHandler (const G4String &name="")
void	CreateViewer (const G4String &name="", const G4String &XGeometry="")
void	Enable ()
void	Disable ()
const G4VTrajectoryModel *	CurrentTrajDrawModel () const
const std::vector< UserVisAction > &	GetRunDurationUserVisActions () const
const std::vector< UserVisAction > &	GetEndOfEventUserVisActions () const
const std::vector< UserVisAction > &	GetEndOfRunUserVisActions () const
const std::map< G4VUserVisAction *, G4VisExtent > &	GetUserVisActionExtents () const
G4VGraphicsSystem *	GetCurrentGraphicsSystem () const
G4Scene *	GetCurrentScene () const
G4VSceneHandler *	GetCurrentSceneHandler () const
G4VViewer *	GetCurrentViewer () const
const G4GraphicsSystemList &	GetAvailableGraphicsSystems ()
const G4SceneHandlerList &	GetAvailableSceneHandlers () const
const G4SceneList &	GetSceneList () const
G4bool	GetTransientsDrawnThisRun () const
G4bool	GetTransientsDrawnThisEvent () const
const G4Event *	GetRequestedEvent () const
G4bool	GetAbortReviewKeptEvents () const
const G4ViewParameters &	GetDefaultViewParameters () const
void	SetUserAction (G4VUserVisAction *pVisAction, const G4VisExtent &=G4VisExtent::NullExtent)
void	SetUserActionExtent (const G4VisExtent &)
void	SetCurrentGraphicsSystem (G4VGraphicsSystem *)
void	SetCurrentScene (G4Scene *)
void	SetCurrentSceneHandler (G4VSceneHandler *)
void	SetCurrentViewer (G4VViewer *)
G4SceneHandlerList &	SetAvailableSceneHandlers ()
G4SceneList &	SetSceneList ()
void	SetVerboseLevel (G4int)
void	SetVerboseLevel (const G4String &)
void	SetVerboseLevel (Verbosity)
void	SetEventRefreshing (G4bool)
void	ResetTransientsDrawnFlags ()
void	SetTransientsDrawnThisRun (G4bool)
void	SetTransientsDrawnThisEvent (G4bool)
void	SetRequestedEvent (const G4Event *)
void	SetAbortReviewKeptEvents (G4bool)
void	SetDefaultViewParameters (const G4ViewParameters &)
G4String	ViewerShortName (const G4String &viewerName) const
G4VViewer *	GetViewer (const G4String &viewerName) const
Public Member Functions inherited from G4VVisManager
virtual	~G4VVisManager ()

Static Public Member Functions
static G4VisManager *	GetInstance ()
static Verbosity	GetVerbosity ()
static Verbosity	GetVerbosityValue (const G4String &)
static Verbosity	GetVerbosityValue (G4int)
static G4String	VerbosityString (Verbosity)
Static Public Member Functions inherited from G4VVisManager
static G4VVisManager *	GetConcreteInstance ()

Static Public Attributes
static std::vector< G4String >	VerbosityGuidanceStrings

Protected Member Functions
	G4VisManager (const G4String &verbosityString="warnings")
virtual void	RegisterGraphicsSystems ()=0
virtual void	RegisterModelFactories ()
void	RegisterMessengers ()
void	PrintAvailableGraphicsSystems (Verbosity) const

Protected Attributes
const G4int	fVerbose

Private Member Functions
	G4VisManager (const G4VisManager &)
G4VisManager &	operator= (const G4VisManager &)
void	BeginOfRun ()
void	BeginOfEvent ()
void	EndOfEvent ()
void	EndOfRun ()
template<class T >
void	DrawT (const T &graphics_primitive, const G4Transform3D &objectTransform)
template<class T >
void	DrawT2D (const T &graphics_primitive, const G4Transform3D &objectTransform)
void	PrintAvailableModels (Verbosity) const
void	PrintAvailableColours (Verbosity) const
void	PrintAvailableUserVisActions (Verbosity) const
void	PrintInvalidPointers () const
G4bool	IsValidView ()
void	ClearTransientStoreIfMarked ()

Private Attributes
G4bool	fInitialised
std::vector< UserVisAction >	fRunDurationUserVisActions
std::vector< UserVisAction >	fEndOfEventUserVisActions
std::vector< UserVisAction >	fEndOfRunUserVisActions
std::map< G4VUserVisAction *, G4VisExtent >	fUserVisActionExtents
G4VGraphicsSystem *	fpGraphicsSystem
G4Scene *	fpScene
G4VSceneHandler *	fpSceneHandler
G4VViewer *	fpViewer
G4GraphicsSystemList	fAvailableGraphicsSystems
G4SceneList	fSceneList
G4SceneHandlerList	fAvailableSceneHandlers
std::vector< G4UImessenger * >	fMessengerList
std::vector< G4UIcommand * >	fDirectoryList
G4VisStateDependent *	fpStateDependent
G4bool	fEventRefreshing
G4bool	fTransientsDrawnThisRun
G4bool	fTransientsDrawnThisEvent
G4int	fNoOfEventsDrawnThisRun
G4int	fNKeepRequests
G4bool	fEventKeepingSuspended
G4bool	fKeptLastEvent
const G4Event *	fpRequestedEvent
G4bool	fAbortReviewKeptEvents
G4ViewParameters	fDefaultViewParameters
G4bool	fIsDrawGroup
G4int	fDrawGroupNestingDepth
G4bool	fIgnoreStateChanges
G4VisModelManager< G4VTrajectoryModel > *	fpTrajDrawModelMgr
G4VisFilterManager< G4VTrajectory > *	fpTrajFilterMgr
G4VisFilterManager< G4VHit > *	fpHitFilterMgr
G4VisFilterManager< G4VDigi > *	fpDigiFilterMgr

Static Private Attributes
static G4VisManager *	fpInstance = 0
static Verbosity	fVerbosity = G4VisManager::warnings

Friends
class	G4VSceneHandler
class	G4VViewer
class	G4VisStateDependent
class	G4VisCommandList
std::ostream &	operator<< (std::ostream &, const G4VGraphicsSystem &)
std::ostream &	operator<< (std::ostream &, const G4VSceneHandler &)

Additional Inherited Members
Static Protected Member Functions inherited from G4VVisManager
static void	SetConcreteInstance (G4VVisManager *)
Static Protected Attributes inherited from G4VVisManager
static G4VVisManager *	fpConcreteInstance = 0

Detailed Description

Definition at line 119 of file G4VisManager.hh.

Member Enumeration Documentation

Verbosity

enum G4VisManager::Verbosity

Enumerator
quiet
startup
errors
warnings
confirmations
parameters
all

Definition at line 133 of file G4VisManager.hh.

                 {
    quiet,         // Nothing is printed.
    startup,       // Startup and endup messages are printed...
    errors,        // ...and errors...
    warnings,      // ...and warnings...
    confirmations, // ...and confirming messages...
    parameters,    // ...and parameters of scenes and views...
    all            // ...and everything available.
  };

Constructor & Destructor Documentation

G4VisManager() [1/2]

G4VisManager::G4VisManager ( const G4String &  verbosityString = "warnings" )

protected

Definition at line 103 of file G4VisManager.cc.

                                                          :
  fVerbose         (1),
  fInitialised     (false),
  fpGraphicsSystem (0),
  fpScene          (0),
  fpSceneHandler   (0),
  fpViewer         (0),
  fpStateDependent (0),
  fEventRefreshing          (false),
  fTransientsDrawnThisRun   (false),
  fTransientsDrawnThisEvent (false),
  fNoOfEventsDrawnThisRun   (0),
  fNKeepRequests            (0),
  fEventKeepingSuspended    (false),
  fKeptLastEvent            (false),
  fpRequestedEvent          (0),
  fAbortReviewKeptEvents    (false),
  fIsDrawGroup              (false),
  fDrawGroupNestingDepth    (0),
  fIgnoreStateChanges       (false)
#ifdef G4MULTITHREADED
, fMaxEventQueueSize        (100)
, fWaitOnEventQueueFull     (true)
#endif
  // All other objects use default constructors.
{
  fpTrajDrawModelMgr = new G4VisModelManager<G4VTrajectoryModel>("/vis/modeling/trajectories");
  fpTrajFilterMgr = new G4VisFilterManager<G4VTrajectory>("/vis/filtering/trajectories");
  fpHitFilterMgr = new G4VisFilterManager<G4VHit>("/vis/filtering/hits");
  fpDigiFilterMgr = new G4VisFilterManager<G4VDigi>("/vis/filtering/digi");

  VerbosityGuidanceStrings.push_back
    ("Simple graded message scheme - digit or string (1st character defines):");
  VerbosityGuidanceStrings.push_back
    ("  0) quiet,         // Nothing is printed.");
  VerbosityGuidanceStrings.push_back
    ("  1) startup,       // Startup and endup messages are printed...");
  VerbosityGuidanceStrings.push_back
    ("  2) errors,        // ...and errors...");
  VerbosityGuidanceStrings.push_back
    ("  3) warnings,      // ...and warnings...");
  VerbosityGuidanceStrings.push_back
    ("  4) confirmations, // ...and confirming messages...");
  VerbosityGuidanceStrings.push_back
    ("  5) parameters,    // ...and parameters of scenes and views...");
  VerbosityGuidanceStrings.push_back
    ("  6) all            // ...and everything available.");

  if (fpInstance) {
    G4Exception
      ("G4VisManager::G4VisManager",
       "visman0001", FatalException,
       "Attempt to Construct more than one VisManager");
  }

  fpInstance = this;
  SetConcreteInstance(this);

  fpStateDependent = new G4VisStateDependent (this);
  // No need to delete this; G4StateManager does this.

  fVerbosity = GetVerbosityValue(verbosityString);
  if (fVerbosity >= startup) {
      G4cout
    << "Visualization Manager instantiating with verbosity \""
    << VerbosityString(fVerbosity)
    << "\"..." << G4endl;
  }

  // Note: The specific graphics systems must be instantiated in a
  // higher level library to avoid circular dependencies.  Also,
  // some specifically need additional external libararies that the
  // user must supply.  Therefore we ask the user to implement
  // RegisterGraphicsSystems() and RegisterModelFactories()
  // in a subclass.  We have to wait for the subclass to instantiate
  // so RegisterGraphicsSystems() cannot be called from this
  // constructor; it is called from Initialise().  So we ask the
  // user:
  //   (a) to write a subclass and implement  RegisterGraphicsSystems()
  //       and RegisterModelFactories().  See
  //       visualization/include/G4VisExecutive.hh/icc as an example.
  //   (b) instantiate the subclass.
  //   (c) invoke the Initialise() method of the subclass.
  // For example:
  //   ...
  // #ifdef G4VIS_USE
  //   // Instantiate and initialise Visualization Manager.
  //   G4VisManager* visManager = new G4VisExecutive;
  //   visManager -> SetVerboseLevel (Verbose);
  //   visManager -> Initialise ();
  // #endif
  //   // (Don't forget to delete visManager;)
  //   ...

  // Make top level command directory...
  // Vis commands should *not* be broadcast to threads (2nd argument).
  G4UIcommand* directory = new G4UIdirectory ("/vis/",false);
  directory -> SetGuidance ("Visualization commands.");
  fDirectoryList.push_back (directory);

  // Instantiate *basic* top level commands so that they can be used
  // immediately after instantiation of the vis manager.  Other top
  // level and lower level commands are instantiated later in
  // RegisterMessengers.
  G4VVisCommand::SetVisManager (this);  // Sets shared pointer
  RegisterMessenger(new G4VisCommandVerbose);
  RegisterMessenger(new G4VisCommandInitialize);
}

Here is the call graph for this function:

~G4VisManager()

G4VisManager::~G4VisManager ( )

virtual

Definition at line 212 of file G4VisManager.cc.

                             {
  fpInstance = 0;
  size_t i;
  for (i = 0; i < fSceneList.size (); ++i) {
    delete fSceneList[i];
  }
  for (i = 0; i < fAvailableSceneHandlers.size (); ++i) {
  if (fAvailableSceneHandlers[i] != NULL) {
    delete fAvailableSceneHandlers[i];
  }
  }
  for (i = 0; i < fAvailableGraphicsSystems.size (); ++i) {
    if (fAvailableGraphicsSystems[i]) {
      delete fAvailableGraphicsSystems[i];
    }
  }
  if (fVerbosity >= startup) {
    G4cout << "Graphics systems deleted." << G4endl;
    G4cout << "Visualization Manager deleting..." << G4endl;
  }
  for (i = 0; i < fMessengerList.size (); ++i) {
    delete fMessengerList[i];
  }
  for (i = 0; i < fDirectoryList.size (); ++i) {
    delete fDirectoryList[i];
  }

  delete fpDigiFilterMgr;
  delete fpHitFilterMgr;
  delete fpTrajFilterMgr;
  delete fpTrajDrawModelMgr;
}

G4VisManager() [2/2]

G4VisManager::G4VisManager ( const G4VisManager &  )

private

Member Function Documentation

BeginDraw()

void G4VisManager::BeginDraw ( const G4Transform3D &  objectTransformation = G4Transform3D() )

virtual

Implements G4VVisManager.

Definition at line 688 of file G4VisManager.cc.

{
#ifdef G4MULTITHREADED
  if (G4Threading::IsWorkerThread()) return;
#endif
  fDrawGroupNestingDepth++;
  if (fDrawGroupNestingDepth > 1) {
    G4Exception
      ("G4VisManager::BeginDraw",
       "visman0008", JustWarning,
       "Nesting detected. It is illegal to nest Begin/EndDraw."
       "\n Ignored");
    return;
  }
  if (IsValidView ()) {
    ClearTransientStoreIfMarked();
    fpSceneHandler -> BeginPrimitives (objectTransform);
    fIsDrawGroup = true;
  }
}

Here is the call graph for this function:

BeginDraw2D()

void G4VisManager::BeginDraw2D ( const G4Transform3D &  objectTransformation = G4Transform3D() )

virtual

Implements G4VVisManager.

Definition at line 725 of file G4VisManager.cc.

{
#ifdef G4MULTITHREADED
  if (G4Threading::IsWorkerThread()) return;
#endif
  fDrawGroupNestingDepth++;
  if (fDrawGroupNestingDepth > 1) {
    G4Exception
      ("G4VisManager::BeginDraw2D",
       "visman0009", JustWarning,
       "Nesting detected. It is illegal to nest Begin/EndDraw2D."
       "\n Ignored");
    return;
  }
  if (IsValidView ()) {
    ClearTransientStoreIfMarked();
    fpSceneHandler -> BeginPrimitives2D (objectTransform);
    fIsDrawGroup = true;
  }
}

Here is the call graph for this function:

BeginOfEvent()

void G4VisManager::BeginOfEvent ( )

private

Definition at line 1768 of file G4VisManager.cc.

{
  if (fIgnoreStateChanges) return;
//  G4cout << "G4VisManager::BeginOfEvent: thread: "
//  << G4Threading::G4GetThreadId() << G4endl;

  // Some instructions that should NOT be in multithreaded version.
#ifndef G4MULTITHREADED
  // These instructions are in G4VisSubThread for multithreading.
  fTransientsDrawnThisEvent = false;
  if (fpSceneHandler) fpSceneHandler->SetTransientsDrawnThisEvent(false);
#endif
}

Here is the call graph for this function:

BeginOfRun()

void G4VisManager::BeginOfRun ( )

private

Definition at line 1711 of file G4VisManager.cc.

{
  if (fIgnoreStateChanges) return;
#ifdef G4MULTITHREADED
  if (G4Threading::IsWorkerThread()) return;
#endif
//  G4cout << "G4VisManager::BeginOfRun: thread: "
//  << G4Threading::G4GetThreadId() << G4endl;

  G4RunManager* runManager = G4RunManager::GetRunManager();
#ifdef G4MULTITHREADED
  if (G4Threading::IsMultithreadedApplication()) {
    runManager = G4MTRunManager::GetMasterRunManager();
  }
#endif

  // For a fake run...
  G4int nEventsToBeProcessed = runManager->GetNumberOfEventsToBeProcessed();
  if (nEventsToBeProcessed == 0) return;

  fNKeepRequests = 0;
  fKeptLastEvent = false;
  fEventKeepingSuspended = false;
  fTransientsDrawnThisRun = false;
  if (fpSceneHandler) fpSceneHandler->SetTransientsDrawnThisRun(false);
  fNoOfEventsDrawnThisRun = 0;

#ifdef G4MULTITHREADED
//   There is a static method G4Threading::IsMultithreadedApplication()
//   that returns true only if G4MTRunManager is instantiated with MT
//   installation. Thus method returns false if G4RunManager base class is
//   instantiated even with the MT installation, or of course with sequential
//   installation.
  if (G4Threading::IsMultithreadedApplication()) {

    // Inform viewer that we have finished all master thread drawing for now...
    if (fpViewer) fpViewer->DoneWithMasterThread();

    // Start vis sub-thread
//    G4cout << "G4VisManager::BeginOfRun: Starting vis sub-thread" << G4endl;
    G4MUTEXLOCK(&mtVisSubThreadMutex);
    mtRunInProgress = true;
    G4MUTEXUNLOCK(&mtVisSubThreadMutex);
    mtVisSubThread = new G4Thread;
    // Launch vis thread
    G4THREADCREATE(mtVisSubThread,G4VisSubThread,this);

    // Tricky things for some viewers (e.g., Qt):
    // - Launch the vis thread
    // - Wait for the vis thread to set its QThread
    // - Then move current QOpenGL context (if Qt) to this Qthread
    // - Go ahead
    if (fpViewer) fpViewer->MovingToVisSubThread();
  }
#endif
}

Here is the call graph for this function:

ClearTransientStoreIfMarked()

void G4VisManager::ClearTransientStoreIfMarked ( )

private

Definition at line 2132 of file G4VisManager.cc.

                                              {
  // Assumes valid view.
  if (fpSceneHandler->GetMarkForClearingTransientStore()) {
    fpSceneHandler->SetMarkForClearingTransientStore(false);
    fpSceneHandler->ClearTransientStore();
  }
  // Record if transients drawn.  These local flags are only set
  // *after* ClearTransientStore.  In the code in G4VSceneHandler
  // triggered by ClearTransientStore, use these flags so that
  // event refreshing is not done too early.
  fTransientsDrawnThisEvent = fpSceneHandler->GetTransientsDrawnThisEvent();
  fTransientsDrawnThisRun = fpSceneHandler->GetTransientsDrawnThisRun();
}

Here is the call graph for this function:

Here is the caller graph for this function:

CreateSceneHandler()

void G4VisManager::CreateSceneHandler

(

const G4String &

name = ""

)

Definition at line 1004 of file G4VisManager.cc.

                                                           {
  if (!fInitialised) Initialise ();
  if (fpGraphicsSystem) {
    G4VSceneHandler* pSceneHandler =
      fpGraphicsSystem -> CreateSceneHandler (name);
    if (pSceneHandler) {
      fAvailableSceneHandlers.push_back (pSceneHandler);
      fpSceneHandler = pSceneHandler;                         // Make current.
    }
    else {
      if (fVerbosity >= errors) {
    G4cout << "ERROR in G4VisManager::CreateSceneHandler during "
           << fpGraphicsSystem -> GetName ()
           << " scene handler creation.\n  No action taken."
           << G4endl;
      }
    }
  }
  else PrintInvalidPointers ();
}

Here is the call graph for this function:

CreateViewer()

void G4VisManager::CreateViewer	(	const G4String &	name = "",
		const G4String &	XGeometry = ""
	)

Definition at line 1026 of file G4VisManager.cc.

{

  if (!fInitialised) Initialise ();

  if (!fpSceneHandler) {
    PrintInvalidPointers ();
    return;
  }

  G4VViewer* p = fpGraphicsSystem -> CreateViewer (*fpSceneHandler, name);

  if (!p) {
    if (fVerbosity >= errors) {
      G4cerr << "ERROR in G4VisManager::CreateViewer during "
         << fpGraphicsSystem -> GetName ()
         << " viewer creation.\n  No action taken."
         << G4endl;
    }
    return;
  }

  if (p -> GetViewId() < 0) {
    if (fVerbosity >= errors) {
      G4cerr << "ERROR in G4VisManager::CreateViewer during "
         << fpGraphicsSystem -> GetName ()
         << " viewer initialisation.\n  No action taken."
         << G4endl;
    }
    return;
  }

  // Viewer is created, now we can set geometry parameters
  // Before 12/2008, it was done in G4VViewer.cc but it did not have to be there!
    
  G4ViewParameters initialvp = p -> GetViewParameters();
  initialvp.SetXGeometryString(XGeometry); //parse string and store parameters
  p -> SetViewParameters(initialvp);
  p -> Initialise ();  // (Viewer itself may change view parameters further.)

  fpViewer = p;                             // Make current.
  fpSceneHandler -> AddViewerToList (fpViewer);
  fpSceneHandler -> SetCurrentViewer (fpViewer);
  if (fVerbosity >= confirmations) {
    G4cout << "G4VisManager::CreateViewer: new viewer created."
       << G4endl;
  }

  const G4ViewParameters& vp = fpViewer->GetViewParameters();
  if (fVerbosity >= parameters) {
    G4cout << " view parameters are:\n  " << vp << G4endl;
  }

  if (vp.IsCulling () && vp.IsCullingInvisible ()) {
    static G4bool warned = false;
    if (fVerbosity >= confirmations) {
      if (!warned) {
    G4cout <<
  "NOTE: objects with visibility flag set to \"false\""
  " will not be drawn!"
  "\n  \"/vis/viewer/set/culling global false\" to Draw such objects."
  "\n  Also see other \"/vis/viewer/set\" commands."
           << G4endl;
    warned = true;
      }
    }
  }
  if (vp.IsCullingCovered ()) {
    static G4bool warned = false;
    if (fVerbosity >= warnings) {
      if (!warned) {
    G4cout <<
  "WARNING: covered objects in solid mode will not be rendered!"
  "\n  \"/vis/viewer/set/culling coveredDaughters false\" to reverse this."
  "\n  Also see other \"/vis/viewer/set\" commands."
           << G4endl;
    warned = true;
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

CurrentTrajDrawModel()

const G4VTrajectoryModel * G4VisManager::CurrentTrajDrawModel

(

)

const

Definition at line 616 of file G4VisManager.cc.

{
  assert (0 != fpTrajDrawModelMgr);

  const G4VTrajectoryModel* model = fpTrajDrawModelMgr->Current();

  if (0 == model) {
    // No model was registered with the trajectory model manager.
    // Use G4TrajectoryDrawByCharge as a default.
    fpTrajDrawModelMgr->Register(new G4TrajectoryDrawByCharge("AutoGenerated"));

    if (fVerbosity >= warnings) {
      G4cout<<"G4VisManager: Using G4TrajectoryDrawByCharge as default trajectory model."<<G4endl;
      G4cout<<"See commands in /vis/modeling/trajectories/ for other options."<<G4endl;
    }
  }

  model = fpTrajDrawModelMgr->Current();
  assert (0 != model); // Should definitely exist now

  return model;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Disable()

void G4VisManager::Disable

(

)

Definition at line 561 of file G4VisManager.cc.

                           {
  SetConcreteInstance(0);
  if (fVerbosity >= confirmations) {
    G4cout <<
      "G4VisManager::Disable: visualization disabled."
      "\n  The pointer returned by GetConcreteInstance will be zero."
      "\n  Note that it will become enabled after some valid vis commands."
       << G4endl;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

DispatchToModel()

void G4VisManager::DispatchToModel ( const G4VTrajectory &  trajectory )

virtual

Implements G4VVisManager.

Definition at line 1227 of file G4VisManager.cc.

{
  G4bool visible(true);

  // See if trajectory passes filter
  G4bool passed = FilterTrajectory(trajectory);

  if (!passed) {
    // Draw invisible trajectory if trajectory failed filter and
    // are filtering in soft mode
    if (fpTrajFilterMgr->GetMode() == FilterMode::Soft) visible = false;
    else {return;}
  }

  // Go on to draw trajectory
  assert (0 != fpTrajDrawModelMgr);

  const G4VTrajectoryModel* trajectoryModel = CurrentTrajDrawModel();

  assert (0 != trajectoryModel); // Should exist

  if (IsValidView()) {
      trajectoryModel->Draw(trajectory, visible);
  }
}

Here is the call graph for this function:

Draw() [1/13]

void G4VisManager::Draw ( const G4Circle &  circle, const G4Transform3D &  objectTransformation = G4Transform3D()  )

virtual

Implements G4VVisManager.

Definition at line 808 of file G4VisManager.cc.

{
  DrawT (circle, objectTransform);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Draw() [2/13]

void G4VisManager::Draw ( const G4Polyhedron &  polyhedron, const G4Transform3D &  objectTransformation = G4Transform3D()  )

virtual

Implements G4VVisManager.

Definition at line 814 of file G4VisManager.cc.

{
  DrawT (polyhedron, objectTransform);
}

Here is the call graph for this function:

Draw() [3/13]

void G4VisManager::Draw ( const G4Polyline &  line, const G4Transform3D &  objectTransformation = G4Transform3D()  )

virtual

Implements G4VVisManager.

Definition at line 820 of file G4VisManager.cc.

{
  DrawT (line, objectTransform);
}

Here is the call graph for this function:

Draw() [4/13]

void G4VisManager::Draw ( const G4Polymarker &  polymarker, const G4Transform3D &  objectTransformation = G4Transform3D()  )

virtual

Implements G4VVisManager.

Definition at line 826 of file G4VisManager.cc.

{
  DrawT (polymarker, objectTransform);
}

Here is the call graph for this function:

Draw() [5/13]

void G4VisManager::Draw ( const G4Scale &  scale, const G4Transform3D &  objectTransformation = G4Transform3D()  )

virtual

Implements G4VVisManager.

Definition at line 832 of file G4VisManager.cc.

{
  DrawT (scale, objectTransform);
}

Here is the call graph for this function:

Draw() [6/13]

void G4VisManager::Draw ( const G4Square &  square, const G4Transform3D &  objectTransformation = G4Transform3D()  )

virtual

Implements G4VVisManager.

Definition at line 838 of file G4VisManager.cc.

{
  DrawT (square, objectTransform);
}

Here is the call graph for this function:

Draw() [7/13]

void G4VisManager::Draw ( const G4Text &  text, const G4Transform3D &  objectTransformation = G4Transform3D()  )

virtual

Implements G4VVisManager.

Definition at line 844 of file G4VisManager.cc.

{
  DrawT (text, objectTransform);
}

Here is the call graph for this function:

Draw() [8/13]

void G4VisManager::Draw ( const G4VTrajectory &  traj )

virtual

Implements G4VVisManager.

Definition at line 914 of file G4VisManager.cc.

                                                  {
#ifdef G4MULTITHREADED
  if (G4Threading::IsWorkerThread()) return;
#endif
  // A trajectory needs a trajectories model to provide G4Atts, etc.
  static G4TrajectoriesModel trajectoriesModel;
  trajectoriesModel.SetCurrentTrajectory(&traj);
  G4RunManager* runManager = G4RunManager::GetRunManager();
#ifdef G4MULTITHREADED
  if (G4Threading::IsMultithreadedApplication()) {
    runManager = G4MTRunManager::GetMasterRunManager();
  }
#endif
  const G4Run* currentRun = runManager->GetCurrentRun();
  if (currentRun) {
    trajectoriesModel.SetRunID(currentRun->GetRunID());
  }
  const G4Event* currentEvent =
  G4EventManager::GetEventManager()->GetConstCurrentEvent();
  if (currentEvent) {
    trajectoriesModel.SetEventID(currentEvent->GetEventID());
  }
  if (fIsDrawGroup) {
    fpSceneHandler -> SetModel (&trajectoriesModel);
    fpSceneHandler -> AddCompound (traj);
    fpSceneHandler -> SetModel (0);
  } else {
    if (IsValidView ()) {
      ClearTransientStoreIfMarked();
      fpSceneHandler -> SetModel (&trajectoriesModel);
      fpSceneHandler -> AddCompound (traj);
      fpSceneHandler -> SetModel (0);
    }
  }
}

Here is the call graph for this function:

Draw() [9/13]

void G4VisManager::Draw ( const G4VHit &  hit )

virtual

Implements G4VVisManager.

Definition at line 886 of file G4VisManager.cc.

                                          {
#ifdef G4MULTITHREADED
  if (G4Threading::IsWorkerThread()) return;
#endif
  if (fIsDrawGroup) {
    fpSceneHandler -> AddCompound (hit);
  } else {
    if (IsValidView ()) {
      ClearTransientStoreIfMarked();
      fpSceneHandler -> AddCompound (hit);
    }
  }
}

Here is the call graph for this function:

Draw() [10/13]

void G4VisManager::Draw ( const G4VDigi &  digi )

virtual

Implements G4VVisManager.

Definition at line 900 of file G4VisManager.cc.

                                            {
#ifdef G4MULTITHREADED
  if (G4Threading::IsWorkerThread()) return;
#endif
  if (fIsDrawGroup) {
    fpSceneHandler -> AddCompound (digi);
  } else {
    if (IsValidView ()) {
      ClearTransientStoreIfMarked();
      fpSceneHandler -> AddCompound (digi);
    }
  }
}

Here is the call graph for this function:

Draw() [11/13]

void G4VisManager::Draw ( const G4LogicalVolume &  logicalVol, const G4VisAttributes &  attribs, const G4Transform3D &  objectTransformation = G4Transform3D()  )

virtual

Implements G4VVisManager.

Definition at line 950 of file G4VisManager.cc.

                                                   {
#ifdef G4MULTITHREADED
  if (G4Threading::IsWorkerThread()) return;
#endif
  // Find corresponding solid.
  G4VSolid* pSol = logicalVol.GetSolid ();
  Draw (*pSol, attribs, objectTransform);
}

Here is the call graph for this function:

Draw() [12/13]

void G4VisManager::Draw ( const G4VPhysicalVolume &  physicalVol, const G4VisAttributes &  attribs, const G4Transform3D &  objectTransformation = G4Transform3D()  )

virtual

Implements G4VVisManager.

Definition at line 981 of file G4VisManager.cc.

                                                   {
#ifdef G4MULTITHREADED
  if (G4Threading::IsWorkerThread()) return;
#endif
  // Note: It is tempting to use a temporary model here, as for
  // trajectories, in order to get at the G4Atts of the physical
  // volume.  I tried it (JA).  But it's not easy to pass the
  // vis attributes.  Also other aspects of the model seem not to
  // be properly set up.  So, the idea has been abandoned for the time
  // being.  The model pointer will be null.  So when picking there
  // will be no G4Atts from this physical volume.
  //
  // If this is called from DrawHit, for example, the user may G4Atts to the
  // hit and these will be available with "/vis/scene/add/hits".
  //
  // Find corresponding logical volume and solid.
  G4LogicalVolume* pLV  = physicalVol.GetLogicalVolume ();
  G4VSolid*        pSol = pLV -> GetSolid ();
  Draw (*pSol, attribs, objectTransform);
}

Here is the call graph for this function:

Draw() [13/13]

void G4VisManager::Draw ( const G4VSolid &  solid, const G4VisAttributes &  attribs, const G4Transform3D &  objectTransformation = G4Transform3D()  )

virtual

Implements G4VVisManager.

Definition at line 961 of file G4VisManager.cc.

                                                   {
#ifdef G4MULTITHREADED
  if (G4Threading::IsWorkerThread()) return;
#endif
  if (fIsDrawGroup) {
    fpSceneHandler -> PreAddSolid (objectTransform, attribs);
    solid.DescribeYourselfTo (*fpSceneHandler);
    fpSceneHandler -> PostAddSolid ();
  } else {
    if (IsValidView ()) {
      ClearTransientStoreIfMarked();
      fpSceneHandler -> PreAddSolid (objectTransform, attribs);
      solid.DescribeYourselfTo (*fpSceneHandler);
      fpSceneHandler -> PostAddSolid ();
    }
  }
}

Here is the call graph for this function:

Draw2D() [1/6]

void G4VisManager::Draw2D ( const G4Circle &  circle, const G4Transform3D &  objectTransformation = G4Transform3D()  )

virtual

Implements G4VVisManager.

Definition at line 850 of file G4VisManager.cc.

{
  DrawT2D (circle, objectTransform);
}

Here is the call graph for this function:

Draw2D() [2/6]

void G4VisManager::Draw2D ( const G4Polyhedron &  polyhedron, const G4Transform3D &  objectTransformation = G4Transform3D()  )

virtual

Implements G4VVisManager.

Definition at line 856 of file G4VisManager.cc.

{
  DrawT2D (polyhedron, objectTransform);
}

Here is the call graph for this function:

Draw2D() [3/6]

void G4VisManager::Draw2D ( const G4Polyline &  line, const G4Transform3D &  objectTransformation = G4Transform3D()  )

virtual

Implements G4VVisManager.

Definition at line 862 of file G4VisManager.cc.

{
  DrawT2D (line, objectTransform);
}

Here is the call graph for this function:

Draw2D() [4/6]

void G4VisManager::Draw2D ( const G4Polymarker &  polymarker, const G4Transform3D &  objectTransformation = G4Transform3D()  )

virtual

Implements G4VVisManager.

Definition at line 868 of file G4VisManager.cc.

{
  DrawT2D (polymarker, objectTransform);
}

Here is the call graph for this function:

Draw2D() [5/6]

void G4VisManager::Draw2D ( const G4Square &  square, const G4Transform3D &  objectTransformation = G4Transform3D()  )

virtual

Implements G4VVisManager.

Definition at line 874 of file G4VisManager.cc.

{
  DrawT2D (square, objectTransform);
}

Here is the call graph for this function:

Draw2D() [6/6]

void G4VisManager::Draw2D ( const G4Text &  text, const G4Transform3D &  objectTransformation = G4Transform3D()  )

virtual

Implements G4VVisManager.

Definition at line 880 of file G4VisManager.cc.

{
  DrawT2D (text, objectTransform);
}

Here is the call graph for this function:

DrawT()

template<class T >

void G4VisManager::DrawT ( const T &  graphics_primitive, const G4Transform3D &  objectTransform  )

private

Definition at line 763 of file G4VisManager.cc.

                                                                    {
#ifdef G4MULTITHREADED
  if (G4Threading::IsWorkerThread()) return;
#endif
  if (fIsDrawGroup) {
    if (objectTransform != fpSceneHandler->GetObjectTransformation()) {
      G4Exception
    ("G4VSceneHandler::DrawT",
     "visman0010", FatalException,
     "Different transform detected in Begin/EndDraw group.");
    }
    fpSceneHandler -> AddPrimitive (graphics_primitive);
  } else {
    if (IsValidView ()) {
      ClearTransientStoreIfMarked();
      fpSceneHandler -> BeginPrimitives (objectTransform);
      fpSceneHandler -> AddPrimitive (graphics_primitive);
      fpSceneHandler -> EndPrimitives ();
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

DrawT2D()

template<class T >

void G4VisManager::DrawT2D ( const T &  graphics_primitive, const G4Transform3D &  objectTransform  )

private

Definition at line 786 of file G4VisManager.cc.

                                                                    {
#ifdef G4MULTITHREADED
  if (G4Threading::IsWorkerThread()) return;
#endif
  if (fIsDrawGroup) {
    if (objectTransform != fpSceneHandler->GetObjectTransformation()) {
      G4Exception
    ("G4VSceneHandler::DrawT",
     "visman0011", FatalException,
     "Different transform detected in Begin/EndDraw2D group.");
    }
    fpSceneHandler -> AddPrimitive (graphics_primitive);
  } else {
    if (IsValidView ()) {
      ClearTransientStoreIfMarked();
      fpSceneHandler -> BeginPrimitives2D (objectTransform);
      fpSceneHandler -> AddPrimitive (graphics_primitive);
      fpSceneHandler -> EndPrimitives2D ();
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Enable()

void G4VisManager::Enable

(

)

Definition at line 543 of file G4VisManager.cc.

                          {
  if (IsValidView ()) {
    SetConcreteInstance(this);
    if (fVerbosity >= confirmations) {
      G4cout << "G4VisManager::Enable: visualization enabled." << G4endl;
    }
  }
  else {
    if (fVerbosity >= warnings) {
      G4cout <<
    "G4VisManager::Enable: WARNING: visualization remains disabled for"
    "\n  above reasons.  Rectifying with valid vis commands will"
    "\n  automatically enable."
         << G4endl;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

EndDraw()

void G4VisManager::EndDraw ( )

virtual

Implements G4VVisManager.

Definition at line 709 of file G4VisManager.cc.

{
#ifdef G4MULTITHREADED
  if (G4Threading::IsWorkerThread()) return;
#endif
  fDrawGroupNestingDepth--;
  if (fDrawGroupNestingDepth != 0) {
    if (fDrawGroupNestingDepth < 0) fDrawGroupNestingDepth = 0;
    return;
  }
  if (IsValidView ()) {
    fpSceneHandler -> EndPrimitives ();
  }
  fIsDrawGroup = false;
}

Here is the call graph for this function:

EndDraw2D()

void G4VisManager::EndDraw2D ( )

virtual

Implements G4VVisManager.

Definition at line 746 of file G4VisManager.cc.

{
#ifdef G4MULTITHREADED
  if (G4Threading::IsWorkerThread()) return;
#endif
  fDrawGroupNestingDepth--;
  if (fDrawGroupNestingDepth != 0) {
    if (fDrawGroupNestingDepth < 0) fDrawGroupNestingDepth = 0;
    return;
  }
  if (IsValidView ()) {
    fpSceneHandler -> EndPrimitives2D ();
  }
  fIsDrawGroup = false;
}

Here is the call graph for this function:

EndOfEvent()

void G4VisManager::EndOfEvent ( )

private

Definition at line 1782 of file G4VisManager.cc.

{
  if (fIgnoreStateChanges) return;

  if (!GetConcreteInstance()) return;

  // Don't call IsValidView unless there is a scene handler.  This
  // avoids WARNING message at end of event and run when the user has
  // not instantiated a scene handler, e.g., in batch mode.
  G4bool valid = fpSceneHandler && IsValidView();
  if (!valid) return;

//  G4cout << "G4VisManager::EndOfEvent: thread: "
//  << G4Threading::G4GetThreadId() << G4endl;

#ifdef G4MULTITHREADED
  G4AutoLock al(&visEndOfEventMutex);
  // Testing.
//  std::this_thread::sleep_for(std::chrono::seconds(5));
#endif

  G4RunManager* runManager = G4RunManager::GetRunManager();
#ifdef G4MULTITHREADED
  if (G4Threading::IsMultithreadedApplication()) {
    runManager = G4MTRunManager::GetMasterRunManager();
  }
#endif

  const G4Run* currentRun = runManager->GetCurrentRun();
  if (!currentRun) return;

  // This gets the thread-local event manager
  G4EventManager* eventManager = G4EventManager::GetEventManager();
  const G4Event* currentEvent = eventManager->GetConstCurrentEvent();
  if (!currentEvent) return;

  if (G4Threading::IsMultithreadedApplication()) {

#ifdef G4MULTITHREADED

    // Wait if too many events in the queue.
    G4MUTEXLOCK(&mtVisSubThreadMutex);
    G4int eventQueueSize = mtVisEventQueue.size();
    G4MUTEXUNLOCK(&mtVisSubThreadMutex);
//    G4cout << "Event queue size (1): " << eventQueueSize << G4endl;

    G4bool eventQueueFull = false;
    while (fMaxEventQueueSize > 0 && eventQueueSize >= fMaxEventQueueSize) {

//      G4cout << "Event queue size (2): " << eventQueueSize << G4endl;
      if (fWaitOnEventQueueFull) {
        static G4bool warned = false;
        if (!warned) {
          G4cout <<
          "WARNING: The number of events in the visualisation queue has exceeded"
          "\n  the maximum, "
          << fMaxEventQueueSize <<
          ".\n  If, during a multithreaded run, the simulation gets ahead of the"
          "\n  visualisation by more than this maximum, the simulation is delayed"
          "\n  until the vis sub-thread has drawn a few more events and removed them"
          "\n  from the queue.  You may change this maximum number of events with"
          "\n  \"/vis/multithreading/maxEventQueueSize <N>\", where N is the maximum"
          "\n  number you wish to allow.  N <= 0 means \"unlimited\"."
          "\n  Alternatively you may choose to discard events for drawing by setting"
          "\n  \"/vis/multithreading/actionOnEventQueueFull discard\"."
          "\n  To avoid visualisation altogether: \"/vis/disable\"."
          "\n  And maybe \"/tracking/storeTrajectories 0\"."
          << G4endl;
          warned = true;
        }
        //      G4cout << "Event queue size (3): " << eventQueueSize << G4endl;
        // Wait a while to give event drawing time to reduce the queue...
#ifdef G4VIS_USE_STD11
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
#else
        G4THREADSLEEP(1);
#endif
        //      G4cout << "Event queue size (4): " << eventQueueSize << G4endl;
      } else {
        static G4bool warned = false;
        if (!warned) {
          G4cout <<
          "WARNING: The number of events in the visualisation queue has exceeded"
          "\n  the maximum, "
          << fMaxEventQueueSize <<
          ".\n  Some events have been discarded for drawing.  You may change this"
          "\n  behaviour with \"/vis/multithreading/actionOnEventQueueFull wait\"."
          "\n  To avoid visualisation altogether: \"/vis/disable\"."
          "\n  And maybe \"/tracking/storeTrajectories 0\"."
          << G4endl;
          warned = true;
        }
        eventQueueFull = true;  // Causes event to be discarded for drawing.
        break;
      }

      G4MUTEXLOCK(&mtVisSubThreadMutex);
      eventQueueSize = mtVisEventQueue.size();
      G4MUTEXUNLOCK(&mtVisSubThreadMutex);
    }

    if (!eventQueueFull) {
      G4MUTEXLOCK(&mtVisSubThreadMutex);
      // Keep event for processing and put event on vis event queue
      currentEvent->KeepForPostProcessing();
      mtVisEventQueue.push_back(currentEvent);
      G4MUTEXUNLOCK(&mtVisSubThreadMutex);
    }

//    G4MUTEXLOCK(&mtVisSubThreadMutex);
//    G4int eQS = mtVisEventQueue.size();
//    G4MUTEXUNLOCK(&mtVisSubThreadMutex);
//    G4cout << "Event queue size (5): " << eQS << G4endl;

#endif

  } else {

    // Sequential mode

    G4int nEventsToBeProcessed = 0;
    G4int nKeptEvents = 0;
    G4int eventID = -2;  // (If no run manager, triggers ShowView as normal.)
    if (currentRun) {
      nEventsToBeProcessed = runManager->GetNumberOfEventsToBeProcessed();
      eventID = currentEvent->GetEventID();
      const std::vector<const G4Event*>* events = currentRun->GetEventVector();
      if (events) nKeptEvents = events->size();
    }

    // We are about to draw the event (trajectories, etc.), but first we
    // have to clear the previous event(s) if necessary.  If this event
    // needs to be drawn afresh, e.g., the first event or any event when
    // "accumulate" is not requested, the old event has to be cleared.
    // We have postponed this so that, for normal viewers like OGL, the
    // previous event(s) stay on screen until this new event comes
    // along.  For a file-writing viewer the geometry has to be drawn.
    // See, for example, G4HepRepFileSceneHandler::ClearTransientStore.
    ClearTransientStoreIfMarked();

    // Now draw the event...
    fpSceneHandler->DrawEvent(currentEvent);
    ++fNoOfEventsDrawnThisRun;

    if (fpScene->GetRefreshAtEndOfEvent()) {

      // Unless last event (in which case wait end of run)...
      if (eventID < nEventsToBeProcessed - 1) {
        // ShowView guarantees the view comes to the screen.  No action
        // is taken for passive viewers like OGL*X (without picking enabled),
        // but it passes control to interactive viewers, such as OGL*X (with
        // picking enabled) or OGL*Xm, and allows file-writing viewers to
        // close the file.
        fpViewer->ShowView();
      } else {  // Last event...
                // Keep, but only if user has not kept any...
        if (nKeptEvents == 0) {
          eventManager->KeepTheCurrentEvent();
          fNKeepRequests++;
          fKeptLastEvent = true;
        }
      }
      fpSceneHandler->SetMarkForClearingTransientStore(true);

    }
  }

  // Both modes - sequential and MT

  if (!(fpScene->GetRefreshAtEndOfEvent())) {

    //  Accumulating events...

    G4int maxNumberOfKeptEvents = fpScene->GetMaxNumberOfKeptEvents();

    if (maxNumberOfKeptEvents > 0 &&
        fNKeepRequests >= maxNumberOfKeptEvents) {

      fEventKeepingSuspended = true;
      static G4bool warned = false;
      if (!warned) {
        if (fVerbosity >= warnings) {
          G4cout <<
          "WARNING: G4VisManager::EndOfEvent: Automatic event keeping suspended."
          "\n  The number of events exceeds the maximum, "
          << maxNumberOfKeptEvents <<
          ", that may be kept by\n  the vis manager."
          << G4endl;
        }
        warned = true;
      }

    } else if (maxNumberOfKeptEvents != 0) {

      // If not disabled nor suspended.
      if (GetConcreteInstance() && !fEventKeepingSuspended) {
//        G4cout <<
//        "Requesting keeping event " << currentEvent->GetEventID()
//        << G4endl;
        eventManager->KeepTheCurrentEvent();
        fNKeepRequests++;
      }
      
    }
  }
}

Here is the call graph for this function:

EndOfRun()

void G4VisManager::EndOfRun ( )

private

Definition at line 1989 of file G4VisManager.cc.

{
  if (fIgnoreStateChanges) return;
#ifdef G4MULTITHREADED
  if (G4Threading::IsWorkerThread()) return;
#endif

//  G4cout << "G4VisManager::EndOfRun: thread: "
//  << G4Threading::G4GetThreadId() << G4endl;

  G4RunManager* runManager = G4RunManager::GetRunManager();
#ifdef G4MULTITHREADED
  if (G4Threading::IsMultithreadedApplication()) {
    runManager = G4MTRunManager::GetMasterRunManager();
  }
#endif

  // For a fake run...
  G4int nEventsToBeProcessed = runManager->GetNumberOfEventsToBeProcessed();
  if (nEventsToBeProcessed == 0) return;

  const G4Run* currentRun = runManager->GetCurrentRun();
  if (!currentRun) return;

#ifdef G4MULTITHREADED
  //  G4AutoLock al(&visEndOfRunMutex);  ???
  if (G4Threading::IsMultithreadedApplication()) {
    // Reset flag so that sub-thread exits when it has finished processing.
    G4MUTEXLOCK(&mtVisSubThreadMutex);
    mtRunInProgress = false;
    G4MUTEXUNLOCK(&mtVisSubThreadMutex);
    // Wait for sub-thread to finish.
    G4THREADJOIN(*mtVisSubThread);
    delete mtVisSubThread;
    if (fpViewer) fpViewer->SwitchToMasterThread();
  }
#endif

#ifdef G4MULTITHREADED
  if (IsValidView()) {  // I.e., events should have been drawn.
    G4int noOfEventsRequested = runManager->GetNumberOfEventsToBeProcessed();
    if (fNoOfEventsDrawnThisRun != noOfEventsRequested) {
      if (!fWaitOnEventQueueFull && fVerbosity >= warnings) {
        G4cout
        << "WARNING: Number of events drawn this run, "
        << fNoOfEventsDrawnThisRun << ", is different to number requested, "
        << noOfEventsRequested <<
        ".\n  (This is because you requested \"/vis/multithreading/actionOnEventQueueFull discard\".)"
        << G4endl;
      }
    }
  }
#endif

  G4int nKeptEvents = 0;
  const std::vector<const G4Event*>* events = currentRun->GetEventVector();
  if (events) nKeptEvents = events->size();
  if (nKeptEvents && !fKeptLastEvent) {
    if (fVerbosity >= warnings) {
      G4cout << "WARNING: " << nKeptEvents;
      if (nKeptEvents == 1) G4cout << " event has";
      else G4cout << " events have";
      G4cout << " been kept for refreshing and/or reviewing." << G4endl;
      if (nKeptEvents != fNKeepRequests) {
        G4cout << "  (Note: ";
        if (fNKeepRequests == 0) {
          G4cout << "No keep requests were";
        } else if (fNKeepRequests == 1) {
          G4cout << "Only 1 keep request was";
        } else {
          G4cout << "Only " << fNKeepRequests << " keep requests were";
        }
        G4cout << " made by the vis manager.)" << G4endl;
      }
      G4cout << "  \"/vis/reviewKeptEvents\" to review them." << G4endl;
    }
    //    static G4bool warned = false;
    //    if (!valid && fVerbosity >= warnings && !warned) {
    //      G4cout <<
    //  "  Only useful if before starting the run:"
    //  "\n    a) trajectories are stored (\"/vis/scene/add/trajectories [smooth|rich]\"), or"
    //  "\n    b) the Draw method of any hits or digis is implemented."
    //  "\n  To view trajectories, hits or digis:"
    //  "\n    open a viewer, draw a volume, \"/vis/scene/add/trajectories\""
    //  "\n    \"/vis/scene/add/hits\" or \"/vis/scene/add/digitisations\""
    //  "\n    and, possibly, \"/vis/viewer/flush\"."
    //  "\n  To see all events: \"/vis/scene/endOfEventAction accumulate\"."
    //  "\n  To see events individually: \"/vis/reviewKeptEvents\"."
    //       << G4endl;
    //      warned = true;
    //    }
  }

  if (fEventKeepingSuspended && fVerbosity >= warnings) {
    G4cout <<
    "WARNING: G4VisManager::EndOfRun: Automatic event keeping was suspended."
    "\n  The number of events in the run exceeded the maximum, "
    << fpScene->GetMaxNumberOfKeptEvents() <<
    ", that may be\n  kept by the vis manager." <<
    "\n  The number of events kept by the vis manager can be changed with"
    "\n  \"/vis/scene/endOfEventAction accumulate <N>\", where N is the"
    "\n  maximum number you wish to allow.  N < 0 means \"unlimited\"."
    << G4endl;
  }

  // Don't call IsValidView unless there is a scene handler.  This
  // avoids WARNING message at end of event and run when the user has
  // not instantiated a scene handler, e.g., in batch mode.
  G4bool valid = fpSceneHandler && IsValidView();
  if (GetConcreteInstance() && valid) {
//    // ???? I can't remember why
//    // if (!fpSceneHandler->GetMarkForClearingTransientStore()) {
//    // is here.  It prevents ShowView at end of run, which seems to be OK
//    // for sequential mode, but MT mode seems to need it (I have not
//    // figured out why). ???? JA ????
//    if (!fpSceneHandler->GetMarkForClearingTransientStore()) {
      if (fpScene->GetRefreshAtEndOfRun()) {
    fpSceneHandler->DrawEndOfRunModels();
        // ShowView guarantees the view comes to the screen.  No action
        // is taken for passive viewers like OGL*X (without picking enabled),
        // but it passes control to interactive viewers, such as OGL*X (with
        // picking enabled) or OGL*Xm, and allows file-writing viewers to
        // close the file.
        fpViewer->ShowView();
//        // An extra refresh for auto-refresh viewers.
//        // ???? I DON'T THINK THIS IS NECESSARY ???? JA ????
//        if (fpViewer->GetViewParameters().IsAutoRefresh()) {
//          fpViewer->RefreshView();
//        }
    fpSceneHandler->SetMarkForClearingTransientStore(true);
      } else {
        if (fpGraphicsSystem->GetFunctionality() ==
            G4VGraphicsSystem::fileWriter) {
          if (fVerbosity >= warnings) {
            G4cout << "\"/vis/viewer/update\" to close file." << G4endl;
          }
        }
      }
//    }
  }
  fEventRefreshing = false;
}

Here is the call graph for this function:

FilterDigi()

G4bool G4VisManager::FilterDigi ( const G4VDigi &  digi )

virtual

Implements G4VVisManager.

Definition at line 1222 of file G4VisManager.cc.

{
  return fpDigiFilterMgr->Accept(digi);
}   

Here is the call graph for this function:

FilterHit()

G4bool G4VisManager::FilterHit ( const G4VHit &  hit )

virtual

Implements G4VVisManager.

Definition at line 1217 of file G4VisManager.cc.

{
  return fpHitFilterMgr->Accept(hit);
}   

Here is the call graph for this function:

FilterTrajectory()

G4bool G4VisManager::FilterTrajectory ( const G4VTrajectory &  trajectory )

virtual

Implements G4VVisManager.

Definition at line 1212 of file G4VisManager.cc.

{
  return fpTrajFilterMgr->Accept(trajectory);
}   

Here is the call graph for this function:

Here is the caller graph for this function:

GeometryHasChanged()

void G4VisManager::GeometryHasChanged ( )

virtual

Implements G4VVisManager.

Definition at line 1108 of file G4VisManager.cc.

                                       {
  if (fVerbosity >= confirmations) {
    G4cout << "G4VisManager::GeometryHasChanged() called." << G4endl;
  }

  // Change the world...
  G4VPhysicalVolume* pWorld =
    G4TransportationManager::GetTransportationManager ()
    -> GetNavigatorForTracking () -> GetWorldVolume ();
  if (!pWorld) {
    if (fVerbosity >= warnings) {
      G4cout << "WARNING: There is no world volume!" << G4endl;
    }
  }

  // Check scenes.
  G4SceneList& sceneList = fSceneList;
  G4int iScene, nScenes = sceneList.size ();
  for (iScene = 0; iScene < nScenes; iScene++) {
    G4Scene* pScene = sceneList [iScene];
    std::vector<G4Scene::Model>& modelList = pScene -> SetRunDurationModelList ();
    if (modelList.size ()) {
      G4bool modelInvalid;
      do {  // Remove, if required, one at a time.
    modelInvalid = false;
    std::vector<G4Scene::Model>::iterator iterModel;
    for (iterModel = modelList.begin();
         iterModel != modelList.end();
         ++iterModel) {
      modelInvalid = !(iterModel->fpModel->Validate(fVerbosity>=warnings));
      if (modelInvalid) {
        // Model invalid - remove and break.
        if (fVerbosity >= warnings) {
          G4cout << "WARNING: Model \""
             << iterModel->fpModel->GetGlobalDescription ()
             <<
        "\" is no longer valid - being removed\n  from scene \""
             << pScene -> GetName () << "\""
             << G4endl;
        }
        modelList.erase (iterModel);
        break;
      }
    }
      } while (modelInvalid);

      if (modelList.size () == 0) {
    if (fVerbosity >= warnings) {
      G4cout << "WARNING: No models left in this scene \""
         << pScene -> GetName ()
         << "\"."
         << G4endl;
    }
      }
      else {
    pScene->CalculateExtent();
    G4UImanager::GetUIpointer () ->
      ApplyCommand (G4String("/vis/scene/notifyHandlers " + pScene->GetName()));
      }
    }
  }

  // Check the manager's current scene...
  if (fpScene && fpScene -> GetRunDurationModelList ().size () == 0) {
    if (fVerbosity >= warnings) {
      G4cout << "WARNING: The current scene \""
         << fpScene -> GetName ()
         << "\" has no models."
         << G4endl;
    }
  }
}

Here is the call graph for this function:

GetAbortReviewKeptEvents()

G4bool G4VisManager::GetAbortReviewKeptEvents

(

)

const

Here is the caller graph for this function:

GetAvailableGraphicsSystems()

const G4GraphicsSystemList & G4VisManager::GetAvailableGraphicsSystems

(

)

Definition at line 572 of file G4VisManager.cc.

                                                                       {
  G4int nSystems = fAvailableGraphicsSystems.size ();
  if (nSystems == 0) {
    if (fVerbosity >= warnings) {
      G4cout << "G4VisManager::GetAvailableGraphicsSystems: WARNING: no"
    "\n graphics system available!"
    "\n  1) Did you have environment variables G4VIS_BUILD_xxxx_DRIVER set"
    "\n     when you compiled/built the visualization code?"
    "\n  2) Did you instantiate your own Visualization Manager and forget"
    "\n     to implement RegisterGraphicsSystems correctly?"
    "\n  3) You can register your own graphics system, e.g.,"
    "\n     visManager->RegisterGraphicsSystem(new MyGraphicsSystem);)"
    "\n     after instantiating your vis manager and before"
    "\n     visManager->Initialize()."
         << G4endl;
    }
  }
  return fAvailableGraphicsSystems;
}

GetAvailableSceneHandlers()

const G4SceneHandlerList& G4VisManager::GetAvailableSceneHandlers

(

)

const

GetCurrentGraphicsSystem()

G4VGraphicsSystem* G4VisManager::GetCurrentGraphicsSystem

(

)

const

Here is the caller graph for this function:

GetCurrentScene()

G4Scene* G4VisManager::GetCurrentScene

(

)

const

Here is the caller graph for this function:

GetCurrentSceneHandler()

G4VSceneHandler* G4VisManager::GetCurrentSceneHandler

(

)

const

Here is the caller graph for this function:

GetCurrentViewer()

G4VViewer* G4VisManager::GetCurrentViewer

(

)

const

Here is the caller graph for this function:

GetDefaultViewParameters()

const G4ViewParameters& G4VisManager::GetDefaultViewParameters

(

)

const

Here is the caller graph for this function:

GetEndOfEventUserVisActions()

const std::vector<UserVisAction>& G4VisManager::GetEndOfEventUserVisActions

(

)

const

Here is the caller graph for this function:

GetEndOfRunUserVisActions()

const std::vector<UserVisAction>& G4VisManager::GetEndOfRunUserVisActions

(

)

const

Here is the caller graph for this function:

GetInstance()

G4VisManager * G4VisManager::GetInstance ( void  )

static

Definition at line 245 of file G4VisManager.cc.

                                         {
  if (!fpInstance) {
    G4Exception
      ("G4VisManager::GetInstance",
       "visman0002", FatalException, "VisManager not yet instantiated");
  }
  return fpInstance;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetRequestedEvent()

const G4Event* G4VisManager::GetRequestedEvent

(

)

const

Here is the caller graph for this function:

GetRunDurationUserVisActions()

const std::vector<UserVisAction>& G4VisManager::GetRunDurationUserVisActions

(

)

const

Here is the caller graph for this function:

GetSceneList()

const G4SceneList& G4VisManager::GetSceneList

(

)

const

GetTransientsDrawnThisEvent()

G4bool G4VisManager::GetTransientsDrawnThisEvent

(

)

const

Here is the caller graph for this function:

GetTransientsDrawnThisRun()

G4bool G4VisManager::GetTransientsDrawnThisRun

(

)

const

Here is the caller graph for this function:

GetUserVisActionExtents()

const std::map<G4VUserVisAction*,G4VisExtent>& G4VisManager::GetUserVisActionExtents

(

)

const

Here is the caller graph for this function:

GetVerbosity()

G4VisManager::Verbosity G4VisManager::GetVerbosity ( )

static

Definition at line 2242 of file G4VisManager.cc.

                                                  {
  return fVerbosity;
}

GetVerbosityValue() [1/2]

G4VisManager::Verbosity G4VisManager::GetVerbosityValue ( const G4String &  verbosityString )

static

Definition at line 2203 of file G4VisManager.cc.

                                                               {
  G4String ss(verbosityString); ss.toLower();
  Verbosity verbosity;
  if      (ss(0) == 'q') verbosity = quiet;
  else if (ss(0) == 's') verbosity = startup;
  else if (ss(0) == 'e') verbosity = errors;
  else if (ss(0) == 'w') verbosity = warnings;
  else if (ss(0) == 'c') verbosity = confirmations;
  else if (ss(0) == 'p') verbosity = parameters;
  else if (ss(0) == 'a') verbosity = all;
  else {
    G4int intVerbosity;
    std::istringstream is(ss);
    is >> intVerbosity;
    if (!is) {
      G4cerr << "ERROR: G4VisManager::GetVerbosityValue: invalid verbosity \""
         << verbosityString << "\"";
      for (size_t i = 0; i < VerbosityGuidanceStrings.size(); ++i) {
    G4cerr << '\n' << VerbosityGuidanceStrings[i];
      }
      verbosity = warnings;
      G4cerr << "\n  Returning " << VerbosityString(verbosity)
         << G4endl;
    }
    else {
      verbosity = GetVerbosityValue(intVerbosity);
    }
  }
  return verbosity;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetVerbosityValue() [2/2]

G4VisManager::Verbosity G4VisManager::GetVerbosityValue ( G4int  intVerbosity )

static

Definition at line 2234 of file G4VisManager.cc.

                                                                        {
  Verbosity verbosity;
  if      (intVerbosity < quiet) verbosity = quiet;
  else if (intVerbosity > all)   verbosity = all;
  else                           verbosity = Verbosity(intVerbosity);
  return verbosity;
}

GetViewer()

G4VViewer * G4VisManager::GetViewer

(

const G4String &

viewerName

)

const

Definition at line 2164 of file G4VisManager.cc.

                                                                    {
  G4String viewerShortName = ViewerShortName (viewerName);
  size_t nHandlers = fAvailableSceneHandlers.size ();
  size_t iHandler, iViewer;
  G4VViewer* viewer = 0;
  G4bool found = false;
  for (iHandler = 0; iHandler < nHandlers; iHandler++) {
    G4VSceneHandler* sceneHandler = fAvailableSceneHandlers [iHandler];
    const G4ViewerList& viewerList = sceneHandler -> GetViewerList ();
    for (iViewer = 0; iViewer < viewerList.size (); iViewer++) {
      viewer = viewerList [iViewer];
      if (viewerShortName == viewer -> GetShortName ()) {
    found = true;
    break;
      }
    }
    if (found) break;
  }
  if (found) return viewer;
  else return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

IgnoreStateChanges()

void G4VisManager::IgnoreStateChanges ( G4bool  val )

virtual

Reimplemented from G4VVisManager.

Definition at line 2381 of file G4VisManager.cc.

{
  fIgnoreStateChanges = val; 
}

Initialise()

void G4VisManager::Initialise

(

)

Definition at line 254 of file G4VisManager.cc.

                               {

  if (fInitialised && fVerbosity >= warnings) {
    G4cout << "WARNING: G4VisManager::Initialise: already initialised."
       << G4endl;
    return;
  }

  if (fVerbosity >= startup) {
    G4cout << "Visualization Manager initialising..." << G4endl;
  }

  if (fVerbosity >= parameters) {
    G4cout <<
      "\nYou have instantiated your own Visualization Manager, inheriting"
      "\n  G4VisManager and implementing RegisterGraphicsSystems(), in which"
      "\n  you should, normally, instantiate drivers which do not need"
      "\n  external packages or libraries, and, optionally, drivers under"
      "\n  control of environment variables."
      "\n  Also you should implement RegisterModelFactories()."
      "\n  See visualization/include/G4VisExecutive.hh/icc, for example."
      "\n  In your main() you will have something like:"
      "\n  #ifdef G4VIS_USE"
      "\n    G4VisManager* visManager = new G4VisExecutive;"
      "\n    visManager -> SetVerboseLevel (Verbose);"
      "\n    visManager -> Initialize ();"
      "\n  #endif"
      "\n  (Don't forget to delete visManager;)"
      "\n"
     << G4endl;
  }

  if (fVerbosity >= startup) {
    G4cout << "Registering graphics systems..." << G4endl;
  }

  RegisterGraphicsSystems ();

  if (fVerbosity >= startup) {
    G4cout <<
      "\nYou have successfully registered the following graphics systems."
     << G4endl;
    PrintAvailableGraphicsSystems (fVerbosity);
    G4cout << G4endl;
  }

  // Make command directories for commands instantiated in the
  // modeling subcategory...
  G4UIcommand* directory;
  directory = new G4UIdirectory ("/vis/modeling/");
  directory -> SetGuidance ("Modeling commands.");
  fDirectoryList.push_back (directory);
  directory = new G4UIdirectory ("/vis/modeling/trajectories/");
  directory -> SetGuidance ("Trajectory model commands.");
  fDirectoryList.push_back (directory);
  directory = new G4UIdirectory ("/vis/modeling/trajectories/create/");
  directory -> SetGuidance ("Create trajectory models and messengers.");
  fDirectoryList.push_back (directory);

  // Filtering command directory
  directory = new G4UIdirectory ("/vis/filtering/");
  directory -> SetGuidance ("Filtering commands.");
  fDirectoryList.push_back (directory);
  directory = new G4UIdirectory ("/vis/filtering/trajectories/");
  directory -> SetGuidance ("Trajectory filtering commands.");
  fDirectoryList.push_back (directory);
  directory = new G4UIdirectory ("/vis/filtering/trajectories/create/");
  directory -> SetGuidance ("Create trajectory filters and messengers.");
  fDirectoryList.push_back (directory);
  directory = new G4UIdirectory ("/vis/filtering/hits/");
  directory -> SetGuidance ("Hit filtering commands.");
  fDirectoryList.push_back (directory);
  directory = new G4UIdirectory ("/vis/filtering/hits/create/");
  directory -> SetGuidance ("Create hit filters and messengers.");
  fDirectoryList.push_back (directory);
  directory = new G4UIdirectory ("/vis/filtering/digi/");
  directory -> SetGuidance ("Digi filtering commands.");
  fDirectoryList.push_back (directory);
  directory = new G4UIdirectory ("/vis/filtering/digi/create/");
  directory -> SetGuidance ("Create digi filters and messengers.");
  fDirectoryList.push_back (directory);

  RegisterMessengers ();

  if (fVerbosity >= startup) {
    G4cout << "Registering model factories..." << G4endl;
  }

  RegisterModelFactories();

  if (fVerbosity >= startup) {
    G4cout <<
      "\nYou have successfully registered the following model factories."
       << G4endl;
    PrintAvailableModels (fVerbosity);
    G4cout << G4endl;
  }

  if (fVerbosity >= startup) {
    PrintAvailableUserVisActions (fVerbosity);
    G4cout << G4endl;
  }

  if (fVerbosity >= startup) {
    PrintAvailableColours (fVerbosity);
    G4cout << G4endl;
  }

  fInitialised = true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Initialize()

void G4VisManager::Initialize

(

)

Here is the caller graph for this function:

IsValidView()

G4bool G4VisManager::IsValidView ( )

private

Definition at line 2254 of file G4VisManager.cc.

                                  {

  if (!fInitialised) Initialise ();

  static G4bool noGSPrinting = true;
  if (!fpGraphicsSystem) {
    // Limit printing - we do not want printing if the user simply does
    // not want to use graphics, e.g., in batch mode.
    if (noGSPrinting) {
      noGSPrinting = false;
      if (fVerbosity >= warnings) {
    G4cout <<
  "WARNING: G4VisManager::IsValidView(): Attempt to draw when no graphics system"
  "\n  has been instantiated.  Use \"/vis/open\" or \"/vis/sceneHandler/create\"."
  "\n  Alternatively, to avoid this message, suppress instantiation of vis"
  "\n  manager (G4VisExecutive), possibly by setting G4VIS_NONE, and ensure"
  "\n  drawing code is executed only if G4VVisManager::GetConcreteInstance()"
  "\n  is non-zero."
           << G4endl;
      }
    }
    return false;
  }

  if ((!fpScene) || (!fpSceneHandler) || (!fpViewer)) {
    if (fVerbosity >= errors) {
      G4cerr <<
    "ERROR: G4VisManager::IsValidView(): Current view is not valid."
         << G4endl;
      PrintInvalidPointers ();
    }
    return false;
  }

  if (fpScene != fpSceneHandler -> GetScene ()) {
    if (fVerbosity >= errors) {
      G4cerr << "ERROR: G4VisManager::IsValidView ():";
      if (fpSceneHandler -> GetScene ()) {
    G4cout <<
      "\n  The current scene \""
           << fpScene -> GetName ()
           << "\" is not handled by"
      "\n  the current scene handler \""
           << fpSceneHandler -> GetName ()
           << "\""
      "\n  (it currently handles scene \""
           << fpSceneHandler -> GetScene () -> GetName ()
           << "\")."
      "\n  Either:"
      "\n  (a) attach it to the scene handler with"
      "\n      /vis/sceneHandler/attach "
           << fpScene -> GetName ()
           <<   ", or"
      "\n  (b) create a new scene handler with "
      "\n      /vis/sceneHandler/create <graphics-system>,"
      "\n      in which case it should pick up the the new scene."
           << G4endl;
      }
      else {
    G4cout << "\n  Scene handler \""
           << fpSceneHandler -> GetName ()
           << "\" has null scene pointer."
      "\n  Attach a scene with /vis/sceneHandler/attach [<scene-name>]"
           << G4endl;
      }
    }
    return false;
  }

  const G4ViewerList& viewerList = fpSceneHandler -> GetViewerList ();
  if (viewerList.size () == 0) {
    if (fVerbosity >= errors) {
      G4cerr <<
    "ERROR: G4VisManager::IsValidView (): the current scene handler\n  \""
         << fpSceneHandler -> GetName ()
         << "\" has no viewers.  Do /vis/viewer/create."
         << G4endl;
    }
    return false;
  }

  G4bool isValid = true;
  if (fpScene -> IsEmpty ()) {  // Add world by default if possible...
    G4bool warn(fVerbosity >= warnings);
    G4bool successful = fpScene -> AddWorldIfEmpty (warn);
    if (!successful || fpScene -> IsEmpty ()) {        // If still empty...
      if (fVerbosity >= errors) {
    G4cerr << "ERROR: G4VisManager::IsValidView ():";
    G4cerr <<
      "\n  Attempt at some drawing operation when scene is empty."
      "\n  Maybe the geometry has not yet been defined."
      "  Try /run/initialize."
          "\n  Or use \"/vis/scene/add/extent\"."
           << G4endl;
      }
      isValid = false;
    }
    else {
      G4UImanager::GetUIpointer()->ApplyCommand ("/vis/scene/notifyHandlers");
      if (fVerbosity >= warnings) {
    G4cout <<
      "WARNING: G4VisManager: the scene was empty, \"world\" has been"
      "\n  added and the scene handlers notified.";
    G4cout << G4endl;
      }
    }
  }
  return isValid;
}

Here is the call graph for this function:

Here is the caller graph for this function:

NotifyHandlers()

void G4VisManager::NotifyHandlers ( )

virtual

Reimplemented from G4VVisManager.

Definition at line 1181 of file G4VisManager.cc.

                                   {

  if (fVerbosity >= confirmations) {
    G4cout << "G4VisManager::NotifyHandler() called." << G4endl;
  }

  // Check scenes.
  G4SceneList& sceneList = fSceneList;
  G4int iScene, nScenes = sceneList.size ();
  for (iScene = 0; iScene < nScenes; iScene++) {
    G4Scene* pScene = sceneList [iScene];
    std::vector<G4Scene::Model>& modelList = pScene -> SetRunDurationModelList ();
    
    if (modelList.size ()) {
      pScene->CalculateExtent();
      G4UImanager::GetUIpointer () ->
        ApplyCommand (G4String("/vis/scene/notifyHandlers " + pScene->GetName()));
    }
  }

  // Check the manager's current scene...
  if (fpScene && fpScene -> GetRunDurationModelList ().size () == 0) {
    if (fVerbosity >= warnings) {
      G4cout << "WARNING: The current scene \""
         << fpScene -> GetName ()
         << "\" has no models."
         << G4endl;
    }
  }
}

Here is the call graph for this function:

operator=()

G4VisManager& G4VisManager::operator= ( const G4VisManager &  )

private

PrintAvailableColours()

void G4VisManager::PrintAvailableColours ( Verbosity  ) const

private

Definition at line 1556 of file G4VisManager.cc.

                                                         {
  G4cout <<
    "Some /vis commands (optionally) take a string to specify colour."
    "\nAvailable colours:\n  ";
  const std::map<G4String, G4Colour>& map = G4Colour::GetMap();
  for (std::map<G4String, G4Colour>::const_iterator i = map.begin();
       i != map.end();) {
    G4cout << i->first;
    if (++i != map.end()) G4cout << ", ";
  }
  G4cout << G4endl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PrintAvailableGraphicsSystems()

void G4VisManager::PrintAvailableGraphicsSystems ( Verbosity  verbosity ) const

protected

Definition at line 1437 of file G4VisManager.cc.

{
  G4cout << "Current available graphics systems are:\n";
  if (fAvailableGraphicsSystems.size ()) {
    for (auto&& gs: fAvailableGraphicsSystems) {
      const G4String& name = gs->GetName();
      const std::vector<G4String>& nicknames = gs->GetNicknames();
      if (verbosity <= warnings) {
        // Brief output
        G4cout << name << " (";
        for (size_t i = 0; i < nicknames.size(); ++i) {
          if (i != 0) {
            G4cout << ", ";
          }
          G4cout << nicknames[i];
        }
        G4cout << ')';
      } else {
        // Full output
        G4cout << *gs;
      }
      G4cout << G4endl;
    }
  } else {
    G4cout << "\n  NONE!!!  None registered - yet!  Mmmmm!" << G4endl;
  }
}

Here is the caller graph for this function:

PrintAvailableModels()

void G4VisManager::PrintAvailableModels ( Verbosity  verbosity ) const

private

Definition at line 1465 of file G4VisManager.cc.

{
  {
    //fpTrajDrawModelMgr->Print(G4cout);
    G4cout << "Registered model factories:" << G4endl;
    const std::vector<G4VModelFactory<G4VTrajectoryModel>*>& factoryList =
      fpTrajDrawModelMgr->FactoryList();
    if (factoryList.empty()) G4cout << "  None" << G4endl;
    else {
      std::vector<G4VModelFactory<G4VTrajectoryModel>*>::const_iterator i;
      for (i = factoryList.begin(); i != factoryList.end(); ++i)
    (*i)->Print(G4cout);
    }
    const G4VisListManager<G4VTrajectoryModel>* listManager =
      fpTrajDrawModelMgr->ListManager();
    const std::map<G4String, G4VTrajectoryModel*>& modelMap =
      listManager->Map();
    if (!modelMap.empty()) {
      G4cout << "\nRegistered models:" << G4endl;
      std::map<G4String, G4VTrajectoryModel*>::const_iterator i;
      for (i = modelMap.begin(); i != modelMap.end(); ++i) {
    G4cout << "  " << i->second->Name();
    if (i->second == listManager->Current()) G4cout << " (Current)";
    G4cout << G4endl;
    if (verbosity >= parameters) i->second->Print(G4cout);
      }
    }
  }

  G4cout << G4endl;

  {
    //fpTrajFilterMgr->Print(G4cout);
    G4cout << "Registered filter factories:" << G4endl;
    const std::vector<G4VModelFactory<G4VFilter<G4VTrajectory> >*>&
      factoryList = fpTrajFilterMgr->FactoryList();
    if (factoryList.empty()) G4cout << "  None" << G4endl;
    else {
      std::vector<G4VModelFactory<G4VFilter<G4VTrajectory> >*>::const_iterator i;
      for (i = factoryList.begin(); i != factoryList.end(); ++i)
    (*i)->Print(G4cout);
    }
    const std::vector<G4VFilter<G4VTrajectory>*>&
      filterList = fpTrajFilterMgr->FilterList();
    if (!filterList.empty()) {
      G4cout << "\nRegistered filters:" << G4endl;
      std::vector<G4VFilter<G4VTrajectory>*>::const_iterator i;
      for (i = filterList.begin(); i != filterList.end(); ++i) {
    G4cout << "  " << (*i)->GetName() << G4endl;
    if (verbosity >= parameters) (*i)->PrintAll(G4cout);
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

PrintAvailableUserVisActions()

void G4VisManager::PrintAvailableUserVisActions ( Verbosity  ) const

private

Definition at line 1520 of file G4VisManager.cc.

{
  G4cout <<
    "You have successfully registered the following user vis actions."
     << G4endl;
  G4cout << "Run Duration User Vis Actions:";
  if (fRunDurationUserVisActions.empty()) G4cout << " none" << G4endl;
  else {
    G4cout << G4endl;
    for (size_t i = 0; i < fRunDurationUserVisActions.size(); i++) {
      const G4String& name = fRunDurationUserVisActions[i].fName;
      G4cout << "  " << name << G4endl;
    }
  }

  G4cout << "End of Event User Vis Actions:";
  if (fEndOfEventUserVisActions.empty()) G4cout << " none" << G4endl;
  else {
    G4cout << G4endl;
    for (size_t i = 0; i < fEndOfEventUserVisActions.size(); i++) {
      const G4String& name = fEndOfEventUserVisActions[i].fName;
      G4cout << "  " << name << G4endl;
    }
  }

  G4cout << "End of Run User Vis Actions:";
  if (fEndOfRunUserVisActions.empty()) G4cout << " none" << G4endl;
  else {
    G4cout << G4endl;
    for (size_t i = 0; i < fEndOfRunUserVisActions.size(); i++) {
      const G4String& name = fEndOfRunUserVisActions[i].fName;
      G4cout << "  " << name << G4endl;
    }
  }
}

Here is the caller graph for this function:

PrintInvalidPointers()

void G4VisManager::PrintInvalidPointers ( ) const

private

Definition at line 1569 of file G4VisManager.cc.

                                               {
  if (fVerbosity >= errors) {
    G4cerr << "ERROR: G4VisManager::PrintInvalidPointers:";
    if (!fpGraphicsSystem) {
      G4cerr << "\n null graphics system pointer.";
    }
    else {
      G4cerr << "\n  Graphics system is " << fpGraphicsSystem -> GetName ()
         << " but:";
      if (!fpScene)
    G4cerr <<
      "\n  Null scene pointer. Use \"/vis/drawVolume\" or"
      " \"/vis/scene/create\".";
      if (!fpSceneHandler)
    G4cerr <<
      "\n  Null scene handler pointer. Use \"/vis/open\" or"
      " \"/vis/sceneHandler/create\".";
      if (!fpViewer )
    G4cerr <<
      "\n  Null viewer pointer. Use \"/vis/viewer/create\".";
    }
    G4cerr << G4endl;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

RegisterEndOfEventUserVisAction()

void G4VisManager::RegisterEndOfEventUserVisAction	(	const G4String &	name,
		G4VUserVisAction *	pVisAction,
		const G4VisExtent &	extent = G4VisExtent::NullExtent
	)

Definition at line 1270 of file G4VisManager.cc.

                            {
  fEndOfEventUserVisActions.push_back(UserVisAction(name,pVisAction));
  if (extent.GetExtentRadius() > 0.) {
    fUserVisActionExtents[pVisAction] = extent;
  } else {
    if (fVerbosity >= warnings) {
      G4cout << 
    "WARNING: No extent set for user vis action \"" << name << "\"."
         << G4endl;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

RegisterEndOfRunUserVisAction()

void G4VisManager::RegisterEndOfRunUserVisAction	(	const G4String &	name,
		G4VUserVisAction *	pVisAction,
		const G4VisExtent &	extent = G4VisExtent::NullExtent
	)

Definition at line 1286 of file G4VisManager.cc.

                            {
  fEndOfRunUserVisActions.push_back(UserVisAction(name,pVisAction));
  if (extent.GetExtentRadius() > 0.) {
    fUserVisActionExtents[pVisAction] = extent;
  } else {
    if (fVerbosity >= warnings) {
      G4cout << 
    "WARNING: No extent set for user vis action \"" << name << "\"."
         << G4endl;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

RegisterGraphicsSystem()

G4bool G4VisManager::RegisterGraphicsSystem

(

G4VGraphicsSystem *

pSystem

)

Definition at line 592 of file G4VisManager.cc.

                                                                       {
  G4bool happy = true;
  if (pSystem) {
    fAvailableGraphicsSystems.push_back (pSystem);
    if (fVerbosity >= confirmations) {
      G4cout << "G4VisManager::RegisterGraphicsSystem: "
         << pSystem -> GetName ();
      if (pSystem -> GetNickname () != "") {
    G4cout << " (" << pSystem -> GetNickname () << ")";
      }
      G4cout << " registered." << G4endl;
    }
  }
  else {
    if (fVerbosity >= errors) {
      G4cout << "G4VisManager::RegisterGraphicsSystem: null pointer!"
         << G4endl;
    }
    happy=false;
  }
  return happy;
}

Here is the caller graph for this function:

RegisterGraphicsSystems()

virtual void G4VisManager::RegisterGraphicsSystems ( )

protectedpure virtual

Implemented in G4VisExecutive, and PyG4VisManager.

Here is the caller graph for this function:

RegisterMessenger()

void G4VisManager::RegisterMessenger

(

G4UImessenger *

messenger

)

Here is the caller graph for this function:

RegisterMessengers()

void G4VisManager::RegisterMessengers ( )

protected

Definition at line 365 of file G4VisManager.cc.

                                       {
  
  // Instantiate individual messengers/commands (often - but not
  // always - one command per messenger).
  
  G4UIcommand* directory;
  
  // *Basic* top level commands were instantiated in the constructor
  // so that they can be used immediately after instantiation of the
  // vis manager.  Other top level and lower level commands are
  // instantiated here.
  
  // Other top level commands...
  RegisterMessenger(new G4VisCommandAbortReviewKeptEvents);
  RegisterMessenger(new G4VisCommandEnable);
  RegisterMessenger(new G4VisCommandList);
  RegisterMessenger(new G4VisCommandReviewKeptEvents);
  
  // Compound commands...
  RegisterMessenger(new G4VisCommandDrawTree);
  RegisterMessenger(new G4VisCommandDrawView);
  RegisterMessenger(new G4VisCommandDrawVolume);
  RegisterMessenger(new G4VisCommandOpen);
  RegisterMessenger(new G4VisCommandSpecify);
  
  directory = new G4UIdirectory ("/vis/geometry/");
  directory -> SetGuidance("Operations on vis attributes of Geant4 geometry.");
  fDirectoryList.push_back (directory);
  RegisterMessenger(new G4VisCommandGeometryList);
  RegisterMessenger(new G4VisCommandGeometryRestore);
  
  directory = new G4UIdirectory ("/vis/geometry/set/");
  directory -> SetGuidance("Set vis attributes of Geant4 geometry.");
  fDirectoryList.push_back (directory);
  RegisterMessenger(new G4VisCommandGeometrySetColour);
  RegisterMessenger(new G4VisCommandGeometrySetDaughtersInvisible);
  RegisterMessenger(new G4VisCommandGeometrySetLineStyle);
  RegisterMessenger(new G4VisCommandGeometrySetLineWidth);
  RegisterMessenger(new G4VisCommandGeometrySetForceAuxEdgeVisible);
  RegisterMessenger(new G4VisCommandGeometrySetForceLineSegmentsPerCircle);
  RegisterMessenger(new G4VisCommandGeometrySetForceSolid);
  RegisterMessenger(new G4VisCommandGeometrySetForceWireframe);
  RegisterMessenger(new G4VisCommandGeometrySetVisibility);
  
#ifdef G4MULTITHREADED
  directory = new G4UIdirectory ("/vis/multithreading/");
  directory -> SetGuidance("Commands unique to multithreading mode.");
  fDirectoryList.push_back (directory);
  RegisterMessenger(new G4VisCommandMultithreadingActionOnEventQueueFull);
  RegisterMessenger(new G4VisCommandMultithreadingMaxEventQueueSize);
#endif

  directory = new G4UIdirectory ("/vis/set/");
  directory -> SetGuidance
    ("Set quantities for use in future commands where appropriate.");
  fDirectoryList.push_back (directory);
  RegisterMessenger(new G4VisCommandSetColour);
  RegisterMessenger(new G4VisCommandSetLineWidth);
  RegisterMessenger(new G4VisCommandSetTextColour);
  RegisterMessenger(new G4VisCommandSetTextLayout);
  RegisterMessenger(new G4VisCommandSetTextSize);
  RegisterMessenger(new G4VisCommandSetTouchable);
  
  directory = new G4UIdirectory ("/vis/scene/");
  directory -> SetGuidance ("Operations on Geant4 scenes.");
  fDirectoryList.push_back (directory);
  RegisterMessenger(new G4VisCommandSceneActivateModel);
  RegisterMessenger(new G4VisCommandSceneCreate);
  RegisterMessenger(new G4VisCommandSceneEndOfEventAction);
  RegisterMessenger(new G4VisCommandSceneEndOfRunAction);
  RegisterMessenger(new G4VisCommandSceneList);
  RegisterMessenger(new G4VisCommandSceneNotifyHandlers);
  RegisterMessenger(new G4VisCommandSceneSelect);
  
  directory = new G4UIdirectory ("/vis/scene/add/");
  directory -> SetGuidance ("Add model to current scene.");
  fDirectoryList.push_back (directory);
  RegisterMessenger(new G4VisCommandSceneAddArrow);
  RegisterMessenger(new G4VisCommandSceneAddArrow2D);
  RegisterMessenger(new G4VisCommandSceneAddAxes);
  RegisterMessenger(new G4VisCommandSceneAddDate);
  RegisterMessenger(new G4VisCommandSceneAddDigis);
  RegisterMessenger(new G4VisCommandSceneAddEventID);
  RegisterMessenger(new G4VisCommandSceneAddExtent);
  RegisterMessenger(new G4VisCommandSceneAddFrame);
  RegisterMessenger(new G4VisCommandSceneAddHits);
  RegisterMessenger(new G4VisCommandSceneAddLine);
  RegisterMessenger(new G4VisCommandSceneAddLine2D);
  RegisterMessenger(new G4VisCommandSceneAddLogicalVolume);
  RegisterMessenger(new G4VisCommandSceneAddLogo);
  RegisterMessenger(new G4VisCommandSceneAddLogo2D);
  RegisterMessenger(new G4VisCommandSceneAddMagneticField);
  RegisterMessenger(new G4VisCommandSceneAddPSHits);
  RegisterMessenger(new G4VisCommandSceneAddScale);
  RegisterMessenger(new G4VisCommandSceneAddText);
  RegisterMessenger(new G4VisCommandSceneAddText2D);
  RegisterMessenger(new G4VisCommandSceneAddTrajectories);
  RegisterMessenger(new G4VisCommandSceneAddUserAction);
  RegisterMessenger(new G4VisCommandSceneAddVolume);
  
  directory = new G4UIdirectory ("/vis/sceneHandler/");
  directory -> SetGuidance ("Operations on Geant4 scene handlers.");
  fDirectoryList.push_back (directory);
  RegisterMessenger(new G4VisCommandSceneHandlerAttach);
  RegisterMessenger(new G4VisCommandSceneHandlerCreate);
  RegisterMessenger(new G4VisCommandSceneHandlerList);
  RegisterMessenger(new G4VisCommandSceneHandlerSelect);
  
  directory = new G4UIdirectory ("/vis/touchable/");
  directory -> SetGuidance ("Operations on touchables.");
  fDirectoryList.push_back (directory);
  RegisterMessenger(new G4VisCommandsTouchable);
  
  directory = new G4UIdirectory ("/vis/touchable/set/");
  directory -> SetGuidance ("Set vis attributes of current touchable.");
  fDirectoryList.push_back (directory);
  RegisterMessenger(new G4VisCommandsTouchableSet);

  directory = new G4UIdirectory ("/vis/viewer/");
  directory -> SetGuidance ("Operations on Geant4 viewers.");
  fDirectoryList.push_back (directory);
  RegisterMessenger(new G4VisCommandViewerAddCutawayPlane);
  RegisterMessenger(new G4VisCommandViewerChangeCutawayPlane);
  RegisterMessenger(new G4VisCommandViewerClear);
  RegisterMessenger(new G4VisCommandViewerClearCutawayPlanes);
  RegisterMessenger(new G4VisCommandViewerClearTransients);
  RegisterMessenger(new G4VisCommandViewerClone);
  RegisterMessenger(new G4VisCommandViewerCopyViewFrom);
  RegisterMessenger(new G4VisCommandViewerCreate);
  RegisterMessenger(new G4VisCommandViewerDolly);
  RegisterMessenger(new G4VisCommandViewerFlush);
  RegisterMessenger(new G4VisCommandViewerList);
  RegisterMessenger(new G4VisCommandViewerPan);
  RegisterMessenger(new G4VisCommandViewerRebuild);
  RegisterMessenger(new G4VisCommandViewerRefresh);
  RegisterMessenger(new G4VisCommandViewerReset);
  RegisterMessenger(new G4VisCommandViewerSave);
  RegisterMessenger(new G4VisCommandViewerScale);
  RegisterMessenger(new G4VisCommandViewerSelect);
  RegisterMessenger(new G4VisCommandViewerUpdate);
  RegisterMessenger(new G4VisCommandViewerZoom);
  
  directory = new G4UIdirectory ("/vis/viewer/default/");
  directory -> SetGuidance("Set default values for future viewers.");
  fDirectoryList.push_back (directory);
  RegisterMessenger(new G4VisCommandViewerDefaultHiddenEdge);
  RegisterMessenger(new G4VisCommandViewerDefaultStyle);
  
  directory = new G4UIdirectory ("/vis/viewer/set/");
  directory -> SetGuidance ("Set view parameters of current viewer.");
  fDirectoryList.push_back (directory);
  RegisterMessenger(new G4VisCommandsViewerSet);
  
  // List manager commands
  RegisterMessenger(new G4VisCommandListManagerList< G4VisModelManager<G4VTrajectoryModel> >
            (fpTrajDrawModelMgr, fpTrajDrawModelMgr->Placement()));
  RegisterMessenger(new G4VisCommandListManagerSelect< G4VisModelManager<G4VTrajectoryModel> >
            (fpTrajDrawModelMgr, fpTrajDrawModelMgr->Placement()));
  
  // Trajectory filter manager commands
  RegisterMessenger(new G4VisCommandListManagerList< G4VisFilterManager<G4VTrajectory> >
                    (fpTrajFilterMgr, fpTrajFilterMgr->Placement()));
  RegisterMessenger(new G4VisCommandManagerMode< G4VisFilterManager<G4VTrajectory> >
                    (fpTrajFilterMgr, fpTrajFilterMgr->Placement()));
  
  // Hit filter manager commands
  RegisterMessenger(new G4VisCommandListManagerList< G4VisFilterManager<G4VHit> >
                    (fpHitFilterMgr, fpHitFilterMgr->Placement()));
  RegisterMessenger(new G4VisCommandManagerMode< G4VisFilterManager<G4VHit> >
                    (fpHitFilterMgr, fpHitFilterMgr->Placement()));
  
  // Digi filter manager commands
  RegisterMessenger(new G4VisCommandListManagerList< G4VisFilterManager<G4VDigi> >
                    (fpDigiFilterMgr, fpDigiFilterMgr->Placement()));
  RegisterMessenger(new G4VisCommandManagerMode< G4VisFilterManager<G4VDigi> >
                    (fpDigiFilterMgr, fpDigiFilterMgr->Placement()));
}

Here is the call graph for this function:

Here is the caller graph for this function:

RegisterModel() [1/4]

void G4VisManager::RegisterModel

(

G4VTrajectoryModel *

model

)

Definition at line 639 of file G4VisManager.cc.

{
  fpTrajDrawModelMgr->Register(model);
}

Here is the call graph for this function:

Here is the caller graph for this function:

RegisterModel() [2/4]

void G4VisManager::RegisterModel

(

G4VFilter< G4VTrajectory > *

filter

)

Definition at line 650 of file G4VisManager.cc.

{
  fpTrajFilterMgr->Register(model);
}

Here is the call graph for this function:

RegisterModel() [3/4]

void G4VisManager::RegisterModel

(

G4VFilter< G4VHit > *

filter

)

Definition at line 661 of file G4VisManager.cc.

{
  fpHitFilterMgr->Register(model);
}

Here is the call graph for this function:

RegisterModel() [4/4]

void G4VisManager::RegisterModel

(

G4VFilter< G4VDigi > *

filter

)

Definition at line 672 of file G4VisManager.cc.

{
  fpDigiFilterMgr->Register(model);
}

Here is the call graph for this function:

RegisterModelFactories()

void G4VisManager::RegisterModelFactories ( )

protectedvirtual

Reimplemented in G4VisExecutive, and PyG4VisManager.

Definition at line 2365 of file G4VisManager.cc.

{
  if (fVerbosity >= warnings) {
    G4cout<<"G4VisManager: No model factories registered with G4VisManager."<<G4endl;
    G4cout<<"G4VisManager::RegisterModelFactories() should be overridden in derived"<<G4endl;
    G4cout<<"class. See G4VisExecutive for an example."<<G4endl;
  }
}

Here is the caller graph for this function:

RegisterModelFactory() [1/4]

void G4VisManager::RegisterModelFactory

(

G4TrajDrawModelFactory *

factory

)

Definition at line 645 of file G4VisManager.cc.

{
  fpTrajDrawModelMgr->Register(factory);
}

Here is the call graph for this function:

RegisterModelFactory() [2/4]

void G4VisManager::RegisterModelFactory

(

G4TrajFilterFactory *

factory

)

Definition at line 656 of file G4VisManager.cc.

{
  fpTrajFilterMgr->Register(factory);
}

Here is the call graph for this function:

RegisterModelFactory() [3/4]

void G4VisManager::RegisterModelFactory

(

G4HitFilterFactory *

factory

)

Definition at line 667 of file G4VisManager.cc.

{
  fpHitFilterMgr->Register(factory);
}

Here is the call graph for this function:

RegisterModelFactory() [4/4]

void G4VisManager::RegisterModelFactory

(

G4DigiFilterFactory *

factory

)

Definition at line 678 of file G4VisManager.cc.

{
  fpDigiFilterMgr->Register(factory);
}

Here is the call graph for this function:

RegisterRunDurationUserVisAction()

void G4VisManager::RegisterRunDurationUserVisAction	(	const G4String &	name,
		G4VUserVisAction *	pVisAction,
		const G4VisExtent &	extent = G4VisExtent::NullExtent
	)

Definition at line 1254 of file G4VisManager.cc.

                            {
  fRunDurationUserVisActions.push_back(UserVisAction(name,pVisAction));
  if (extent.GetExtentRadius() > 0.) {
    fUserVisActionExtents[pVisAction] = extent;
  } else {
    if (fVerbosity >= warnings) {
      G4cout << 
    "WARNING: No extent set for user vis action \"" << name << "\"."
         << G4endl;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ResetTransientsDrawnFlags()

void G4VisManager::ResetTransientsDrawnFlags

(

)

Definition at line 2146 of file G4VisManager.cc.

{
  fTransientsDrawnThisRun = false;
  fTransientsDrawnThisEvent = false;
  G4SceneHandlerListConstIterator i;
  for (i = fAvailableSceneHandlers.begin();
       i != fAvailableSceneHandlers.end(); ++i) {
    (*i)->SetTransientsDrawnThisEvent(false);
    (*i)->SetTransientsDrawnThisRun(false);
  }
}

Here is the caller graph for this function:

SelectTrajectoryModel()

void G4VisManager::SelectTrajectoryModel

(

const G4String &

model

)

Definition at line 683 of file G4VisManager.cc.

{
   fpTrajDrawModelMgr->SetCurrent(model);
}

Here is the call graph for this function:

SetAbortReviewKeptEvents()

void G4VisManager::SetAbortReviewKeptEvents

(

G4bool

)

Here is the caller graph for this function:

SetAvailableSceneHandlers()

G4SceneHandlerList& G4VisManager::SetAvailableSceneHandlers

(

)

SetCurrentGraphicsSystem()

void G4VisManager::SetCurrentGraphicsSystem

(

G4VGraphicsSystem *

pSystem

)

Definition at line 1310 of file G4VisManager.cc.

                                                                       {
  fpGraphicsSystem = pSystem;
  if (fVerbosity >= confirmations) {
    G4cout << "G4VisManager::SetCurrentGraphicsSystem: system now "
       << pSystem -> GetName () << G4endl;
  }
  // If current scene handler is of same graphics system, leave unchanged.
  // Else find the most recent scene handler of same graphics system.
  // Or clear pointers.
  if (!(fpSceneHandler && fpSceneHandler -> GetGraphicsSystem () == pSystem)) {
    const G4SceneHandlerList& sceneHandlerList = fAvailableSceneHandlers;
    G4int nSH = sceneHandlerList.size ();  // No. of scene handlers.
    G4int iSH;
    for (iSH = nSH - 1; iSH >= 0; iSH--) {
      if (sceneHandlerList [iSH] -> GetGraphicsSystem () == pSystem) break;
    }
    if (iSH >= 0) {
      fpSceneHandler = sceneHandlerList [iSH];
      if (fVerbosity >= confirmations) {
    G4cout << "  Scene Handler now "
           << fpSceneHandler -> GetName () << G4endl;
      }
      if (fpScene != fpSceneHandler -> GetScene ()) {
    fpScene = fpSceneHandler -> GetScene ();
    if (fVerbosity >= confirmations) {
      G4cout << "  Scene now \""
         << fpScene -> GetName () << "\"" << G4endl;
    }
      }
      const G4ViewerList& viewerList = fpSceneHandler -> GetViewerList ();
      if (viewerList.size ()) {
    fpViewer = viewerList [0];
    if (fVerbosity >= confirmations) {
      G4cout << "  Viewer now " << fpViewer -> GetName () << G4endl;
    }
      }
      else {
    fpViewer = 0;
      }
    }
    else {
      fpSceneHandler = 0;
      fpViewer = 0;
    }
  }
}

Here is the caller graph for this function:

SetCurrentScene()

void G4VisManager::SetCurrentScene

(

G4Scene *

pScene

)

Definition at line 1301 of file G4VisManager.cc.

                                                   {
  if (pScene != fpScene) {
    // A change of scene.  Therefore reset transients drawn flags.  All
    // memory of previous transient proceessing thereby erased...
    ResetTransientsDrawnFlags();
  }
  fpScene = pScene;
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetCurrentSceneHandler()

void G4VisManager::SetCurrentSceneHandler

(

G4VSceneHandler *

pSceneHandler

)

Definition at line 1357 of file G4VisManager.cc.

                                                                         {
  fpSceneHandler = pSceneHandler;
  if (fVerbosity >= confirmations) {
    G4cout << "G4VisManager::SetCurrentSceneHandler: scene handler now \""
       << pSceneHandler -> GetName () << "\"" << G4endl;
  }
  if (fpScene != fpSceneHandler -> GetScene ()) {
    fpScene = fpSceneHandler -> GetScene ();
    if (fVerbosity >= confirmations) {
      G4cout << "  Scene now \""
         << fpScene -> GetName () << "\"" << G4endl;
    }
  }
  if (fpGraphicsSystem != pSceneHandler -> GetGraphicsSystem ()) {
    fpGraphicsSystem = pSceneHandler -> GetGraphicsSystem ();
    if (fVerbosity >= confirmations) {
      G4cout << "  Graphics system now \""
         << fpGraphicsSystem -> GetName () << "\"" << G4endl;
    }
  }
  const G4ViewerList& viewerList = fpSceneHandler -> GetViewerList ();
  G4int nViewers = viewerList.size ();
  if (nViewers) {
    G4int iViewer;
    for (iViewer = 0; iViewer < nViewers; iViewer++) {
      if (fpViewer == viewerList [iViewer]) break;
    }
    if (iViewer >= nViewers) {
      fpViewer = viewerList [0];
      if (fVerbosity >= confirmations) {
    G4cout << "  Viewer now \"" << fpViewer -> GetName () << "\""
           << G4endl;
      }
    }
    if (!IsValidView ()) {
      if (fVerbosity >= warnings) {
    G4cout <<
  "WARNING: Problem setting scene handler - please report circumstances."
           << G4endl;
      }
    }
  }
  else {
    fpViewer = 0;
    if (fVerbosity >= warnings) {
      G4cout <<
    "WARNING: No viewers for this scene handler - please create one."
         << G4endl;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetCurrentViewer()

void G4VisManager::SetCurrentViewer

(

G4VViewer *

pViewer

)

Definition at line 1409 of file G4VisManager.cc.

                                                       {
  fpViewer  = pViewer;
  if (fVerbosity >= confirmations) {
    G4cout << "G4VisManager::SetCurrentViewer: viewer now "
       << pViewer -> GetName ()
       << G4endl;
  }
  fpSceneHandler = fpViewer -> GetSceneHandler ();
  if (!fpSceneHandler) {
    if (fVerbosity >= warnings) {
      G4cout <<
      "WARNING: No scene handler for this viewer - please create one."
      << G4endl;
    }
    return;
  }
  fpSceneHandler -> SetCurrentViewer (pViewer);
  fpScene = fpSceneHandler -> GetScene ();
  fpGraphicsSystem = fpSceneHandler -> GetGraphicsSystem ();
  if (!IsValidView ()) {
    if (fVerbosity >= warnings) {
      G4cout <<
    "WARNING: Problem setting viewer - please report circumstances."
         << G4endl;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetDefaultViewParameters()

void G4VisManager::SetDefaultViewParameters

(

const G4ViewParameters &

)

Here is the caller graph for this function:

SetEventRefreshing()

void G4VisManager::SetEventRefreshing

(

G4bool

)

Here is the caller graph for this function:

SetRequestedEvent()

void G4VisManager::SetRequestedEvent

(

const G4Event *

)

Here is the caller graph for this function:

SetSceneList()

G4SceneList& G4VisManager::SetSceneList

(

)

Here is the caller graph for this function:

SetTransientsDrawnThisEvent()

void G4VisManager::SetTransientsDrawnThisEvent

(

G4bool

)

Here is the caller graph for this function:

SetTransientsDrawnThisRun()

void G4VisManager::SetTransientsDrawnThisRun

(

G4bool

)

SetUserAction()

void G4VisManager::SetUserAction	(	G4VUserVisAction *	pVisAction,
		const G4VisExtent &	= G4VisExtent::NullExtent
	)

Here is the caller graph for this function:

SetUserActionExtent()

void G4VisManager::SetUserActionExtent

(

const G4VisExtent &

)

SetVerboseLevel() [1/3]

void G4VisManager::SetVerboseLevel

(

G4int

intVerbosity

)

Definition at line 2246 of file G4VisManager.cc.

                                                      {
  fVerbosity = GetVerbosityValue(intVerbosity);
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetVerboseLevel() [2/3]

void G4VisManager::SetVerboseLevel

(

const G4String &

verbosityString

)

Definition at line 2250 of file G4VisManager.cc.

                                                                   {
  fVerbosity = GetVerbosityValue(verbosityString);
}

Here is the call graph for this function:

SetVerboseLevel() [3/3]

void G4VisManager::SetVerboseLevel

(

Verbosity

)

VerbosityString()

G4String G4VisManager::VerbosityString ( Verbosity  verbosity )

static

Definition at line 2188 of file G4VisManager.cc.

                                                          {
  G4String rs;
  switch (verbosity) {
  case         quiet: rs = "quiet (0)"; break;
  case       startup: rs = "startup (1)"; break;
  case        errors: rs = "errors (2)"; break;
  case      warnings: rs = "warnings (3)"; break;
  case confirmations: rs = "confirmations (4)"; break;
  case    parameters: rs = "parameters (5)"; break;
  case           all: rs = "all (6)"; break;
  }
  return rs;
}

Here is the caller graph for this function:

ViewerShortName()

G4String G4VisManager::ViewerShortName

(

const G4String &

viewerName

)

const

Definition at line 2158 of file G4VisManager.cc.

                                                                        {
  G4String viewerShortName (viewerName);
  viewerShortName = viewerShortName (0, viewerShortName.find (' '));
  return viewerShortName.strip ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

G4VisCommandList

friend class G4VisCommandList

friend

Definition at line 125 of file G4VisManager.hh.

G4VisStateDependent

friend class G4VisStateDependent

friend

Definition at line 124 of file G4VisManager.hh.

G4VSceneHandler

friend class G4VSceneHandler

friend

Definition at line 122 of file G4VisManager.hh.

G4VViewer

friend class G4VViewer

friend

Definition at line 123 of file G4VisManager.hh.

operator<< [1/2]

std::ostream& operator<< ( std::ostream &  os, const G4VGraphicsSystem &  gs  )

friend

Definition at line 74 of file G4VGraphicsSystem.cc.

{
  os << "Graphics System: " << gs.GetName ();
  os << ", nicknames:"; for (auto&& nickname: gs.GetNicknames())
  {os << ' ' << nickname;}
  os << "\n  Description: " << gs.GetDescription ();
  os << "\n  Functionality: ";
  switch (gs.GetFunctionality()) {
    case G4VGraphicsSystem::noFunctionality:
      os << "None";
      break;
    case G4VGraphicsSystem::nonEuclidian:
      os << "nonEuclidian, e.g., tree representation of geometry hierarchy.";
      break;
    case G4VGraphicsSystem::twoD:
      os << "twoD: Simple 2D, e.g., X (no stored structures).";
      break;
    case G4VGraphicsSystem::twoDStore:
      os << "twoDStore: 2D with stored structures.";
      break;
    case G4VGraphicsSystem::threeD:
      os << "threeD: Passive 3D (with stored structures)";
      break;
    case G4VGraphicsSystem::threeDInteractive:
      os << "threeDInteractive: 3D with \"pick\" functionality.";
      break;
    case G4VGraphicsSystem::virtualReality:
      os << "virtualReality";
      break;
    case G4VGraphicsSystem::fileWriter:
      os << "fileWriter";
      break;
    default:
      os << "unknown";
      break;
  }

  G4VisManager* pVMan = G4VisManager::GetInstance ();
  const G4SceneHandlerList& scenes = pVMan -> GetAvailableSceneHandlers ();
  if (pVMan -> GetVerbosity() >= G4VisManager::parameters) {
    size_t nScenes = scenes.size ();
    if (nScenes) {
      G4int nScenesOfThisSystem = 0;
      for (size_t i = 0; i < nScenes; i++) {
        if (scenes [i] -> GetGraphicsSystem () == &gs) {
          nScenesOfThisSystem++;
        }
      }
      if (nScenesOfThisSystem) {
        os << "\n  Its scenes are: ";
        for (size_t i = 0; i < nScenes; i++) {
          if (scenes [i] -> GetGraphicsSystem () == &gs) {
            os << "\n  " << *(scenes [i]);
          }
        }
      }
      else {
        os << "\n  It has no scenes at present.";
      }
    }
    else {
      os << "\n  There are no scenes instantiated at present.";
    }
  }

  return os;
}

operator<< [2/2]

std::ostream& operator<< ( std::ostream &  os, const G4VSceneHandler &  sh  )

friend

Definition at line 945 of file G4VSceneHandler.cc.

                                                                    {

  os << "Scene handler " << sh.fName << " has "
     << sh.fViewerList.size () << " viewer(s):";
  for (size_t i = 0; i < sh.fViewerList.size (); i++) {
    os << "\n  " << *(sh.fViewerList [i]);
  }

  if (sh.fpScene) {
    os << "\n  " << *sh.fpScene;
  }
  else {
    os << "\n  This scene handler currently has no scene.";
  }

  return os;
}

Member Data Documentation

fAbortReviewKeptEvents

G4bool G4VisManager::fAbortReviewKeptEvents

private

Definition at line 518 of file G4VisManager.hh.

fAvailableGraphicsSystems

G4GraphicsSystemList G4VisManager::fAvailableGraphicsSystems

private

Definition at line 503 of file G4VisManager.hh.

fAvailableSceneHandlers

G4SceneHandlerList G4VisManager::fAvailableSceneHandlers

private

Definition at line 505 of file G4VisManager.hh.

fDefaultViewParameters

G4ViewParameters G4VisManager::fDefaultViewParameters

private

Definition at line 519 of file G4VisManager.hh.

fDirectoryList

std::vector<G4UIcommand*> G4VisManager::fDirectoryList

private

Definition at line 508 of file G4VisManager.hh.

fDrawGroupNestingDepth

G4int G4VisManager::fDrawGroupNestingDepth

private

Definition at line 521 of file G4VisManager.hh.

fEndOfEventUserVisActions

std::vector<UserVisAction> G4VisManager::fEndOfEventUserVisActions

private

Definition at line 496 of file G4VisManager.hh.

fEndOfRunUserVisActions

std::vector<UserVisAction> G4VisManager::fEndOfRunUserVisActions

private

Definition at line 497 of file G4VisManager.hh.

fEventKeepingSuspended

G4bool G4VisManager::fEventKeepingSuspended

private

Definition at line 515 of file G4VisManager.hh.

fEventRefreshing

G4bool G4VisManager::fEventRefreshing

private

Definition at line 510 of file G4VisManager.hh.

fIgnoreStateChanges

G4bool G4VisManager::fIgnoreStateChanges

private

Definition at line 522 of file G4VisManager.hh.

fInitialised

G4bool G4VisManager::fInitialised

private

Definition at line 494 of file G4VisManager.hh.

fIsDrawGroup

G4bool G4VisManager::fIsDrawGroup

private

Definition at line 520 of file G4VisManager.hh.

fKeptLastEvent

G4bool G4VisManager::fKeptLastEvent

private

Definition at line 516 of file G4VisManager.hh.

fMessengerList

std::vector<G4UImessenger*> G4VisManager::fMessengerList

private

Definition at line 507 of file G4VisManager.hh.

fNKeepRequests

G4int G4VisManager::fNKeepRequests

private

Definition at line 514 of file G4VisManager.hh.

fNoOfEventsDrawnThisRun

G4int G4VisManager::fNoOfEventsDrawnThisRun

private

Definition at line 513 of file G4VisManager.hh.

fpDigiFilterMgr

G4VisFilterManager<G4VDigi>* G4VisManager::fpDigiFilterMgr

private

Definition at line 538 of file G4VisManager.hh.

fpGraphicsSystem

G4VGraphicsSystem* G4VisManager::fpGraphicsSystem

private

Definition at line 499 of file G4VisManager.hh.

fpHitFilterMgr

G4VisFilterManager<G4VHit>* G4VisManager::fpHitFilterMgr

private

Definition at line 535 of file G4VisManager.hh.

fpInstance

G4VisManager * G4VisManager::fpInstance = 0

staticprivate

Definition at line 493 of file G4VisManager.hh.

fpRequestedEvent

const G4Event* G4VisManager::fpRequestedEvent

private

Definition at line 517 of file G4VisManager.hh.

fpScene

G4Scene* G4VisManager::fpScene

private

Definition at line 500 of file G4VisManager.hh.

fpSceneHandler

G4VSceneHandler* G4VisManager::fpSceneHandler

private

Definition at line 501 of file G4VisManager.hh.

fpStateDependent

G4VisStateDependent* G4VisManager::fpStateDependent

private

Definition at line 509 of file G4VisManager.hh.

fpTrajDrawModelMgr

G4VisModelManager<G4VTrajectoryModel>* G4VisManager::fpTrajDrawModelMgr

private

Definition at line 529 of file G4VisManager.hh.

fpTrajFilterMgr

G4VisFilterManager<G4VTrajectory>* G4VisManager::fpTrajFilterMgr

private

Definition at line 532 of file G4VisManager.hh.

fpViewer

G4VViewer* G4VisManager::fpViewer

private

Definition at line 502 of file G4VisManager.hh.

fRunDurationUserVisActions

std::vector<UserVisAction> G4VisManager::fRunDurationUserVisActions

private

Definition at line 495 of file G4VisManager.hh.

fSceneList

G4SceneList G4VisManager::fSceneList

private

Definition at line 504 of file G4VisManager.hh.

fTransientsDrawnThisEvent

G4bool G4VisManager::fTransientsDrawnThisEvent

private

Definition at line 512 of file G4VisManager.hh.

fTransientsDrawnThisRun

G4bool G4VisManager::fTransientsDrawnThisRun

private

Definition at line 511 of file G4VisManager.hh.

fUserVisActionExtents

std::map<G4VUserVisAction*,G4VisExtent> G4VisManager::fUserVisActionExtents

private

Definition at line 498 of file G4VisManager.hh.

fVerbose

const G4int G4VisManager::fVerbose

protected

Definition at line 466 of file G4VisManager.hh.

fVerbosity

G4VisManager::Verbosity G4VisManager::fVerbosity = G4VisManager::warnings

staticprivate

Definition at line 506 of file G4VisManager.hh.

VerbosityGuidanceStrings

std::vector< G4String > G4VisManager::VerbosityGuidanceStrings

static

Definition at line 452 of file G4VisManager.hh.

---

The documentation for this class was generated from the following files:

• G4VisManager.hh
• G4VisManager.cc