#include <G4VisManager.hh>

Inheritance 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())

void	RegisterEndOfEventUserVisAction (const G4String &name, G4VUserVisAction *, const G4VisExtent &=G4VisExtent())

void	RegisterEndOfRunUserVisAction (const G4String &name, G4VUserVisAction *, const G4VisExtent &=G4VisExtent())

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 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	DrawGeometry (G4VPhysicalVolume *, const G4Transform3D &t=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 &)

virtual void	SetUpForAThread ()

virtual void	EventReadyForVis (const G4Event *)

void	CreateSceneHandler (const G4String &name="")

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

void	Enable ()

void	Disable ()

G4bool	IsEnabled () const

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

G4bool	GetDrawEventOnlyIfToBeKept () const

const G4Event *	GetRequestedEvent () const

G4int	GetNKeepForPostProcessingRequests () const

G4int	GetNKeepTheEventRequests () const

G4int	GetNKeepRequests () const

G4bool	GetReviewingKeptEvents () const

G4bool	GetAbortReviewKeptEvents () const

G4bool	GetReviewingPlots () const

G4bool	GetAbortReviewPlots () const

const G4ViewParameters &	GetDefaultViewParameters () const

G4int	GetMaxEventQueueSize () const

G4bool	GetWaitOnEventQueueFull () const

virtual const G4String &	GetDefaultGraphicsSystemName ()

const G4String &	GetDefaultXGeometryString () const

const G4String &	GetDefaultGraphicsSystemBasis () const

const G4String &	GetDefaultXGeometryStringBasis () const

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	SetDrawEventOnlyIfToBeKept (G4bool)

void	SetRequestedEvent (const G4Event *)

void	SetReviewingKeptEvents (G4bool)

void	SetAbortReviewKeptEvents (G4bool)

void	SetReviewingPlots (G4bool)

void	SetAbortReviewPlots (G4bool)

void	SetDefaultViewParameters (const G4ViewParameters &)

void	SetMaxEventQueueSize (G4int)

void	SetWaitOnEventQueueFull (G4bool)

void	SetDefaultGraphicsSystemName (const G4String &)

void	SetDefaultXGeometryString (const G4String &)

void	SetDefaultGraphicsSystemBasis (const G4String &)

void	SetDefaultXGeometryStringBasis (const G4String &)

G4String	ViewerShortName (const G4String &viewerName) const

G4VViewer *	GetViewer (const G4String &viewerName) const

void	PrintAvailableGraphicsSystems (Verbosity, std::ostream &=G4cout) const

Public Member Functions inherited from G4VVisManager
	G4VVisManager ()

virtual	~G4VVisManager ()

Static Public Member Functions
static G4VisManager *	GetInstance ()

static G4ThreadFunReturnType	G4VisSubThread (G4ThreadFunArgType)

static Verbosity	GetVerbosity ()

static Verbosity	GetVerbosityValue (const G4String &)

static Verbosity	GetVerbosityValue (G4int)

static G4String	VerbosityString (Verbosity)

static void	PrintAvailableVerbosity (std::ostream &os)

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 ()

Protected Attributes
const G4int	fVerbose

G4String	fDefaultGraphicsSystemName

G4String	fDefaultXGeometryString

G4String	fDefaultGraphicsSystemBasis

G4String	fDefaultXGeometryStringBasis

Static Protected Attributes
static Verbosity	fVerbosity = G4VisManager::warnings

Static Protected Attributes inherited from G4VVisManager
static G4VVisManager *	fpConcreteInstance = nullptr

Friends
class	G4VSceneHandler

class	G4VViewer

class	G4VisStateDependent

class	G4VisCommandList

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

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

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

Detailed Description

Definition at line 123 of file G4VisManager.hh.

Member Enumeration Documentation

◆ Verbosity

enum G4VisManager::Verbosity

Enumerator
quiet
startup
errors
warnings
confirmations
parameters
all

Definition at line 137 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()

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

protected

Definition at line 115 of file G4VisManager.cc.

: fVerbose         (1)
, fDefaultGraphicsSystemName("OGL")          // Override in G4VisExecutive
, fDefaultXGeometryString   ("600x600-0+0")  // Override in G4VisExecutive
, fDefaultGraphicsSystemBasis ("G4VisManager initialisation")
, fDefaultXGeometryStringBasis("G4VisManager initialisation")
, fInitialised     (false)
, fpGraphicsSystem (0)
, fpScene          (0)
, fpSceneHandler   (0)
, fpViewer         (0)
, fpStateDependent (0)
, fEventRefreshing          (false)
, fTransientsDrawnThisRun   (false)
, fTransientsDrawnThisEvent (false)
, fNoOfEventsDrawnThisRun   (0)
, fNKeepForPostProcessingRequests (0)
, fNKeepTheEventRequests    (0)
, fEventKeepingSuspended    (false)
, fDrawEventOnlyIfToBeKept  (false)
, fpRequestedEvent          (0)
, fReviewingKeptEvents      (false)
, fAbortReviewKeptEvents    (false)
, fReviewingPlots           (false)
, fAbortReviewPlots         (false)
, fIsDrawGroup              (false)
, fDrawGroupNestingDepth    (0)
, fIgnoreStateChanges       (false)
, fMaxEventQueueSize        (100)
, fWaitOnEventQueueFull     (true)
// 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:
  //   ...
  //   // Instantiate and initialise Visualization Manager.
  //   G4VisManager* visManager = new G4VisExecutive;
  //   visManager -> SetVerboseLevel (Verbose);
  //   visManager -> Initialise ();
  //   // (Don't forget to delete visManager;)
  //   ...
 
  // Make top level command directory...
  // vis commands should *not* be broadcast to workers
  G4bool propagateToWorkers;
  auto directory = new G4UIdirectory ("/vis/",propagateToWorkers=false);
  directory -> SetGuidance ("Visualization commands.");
  // Request commands in name order
  directory -> Sort();  // Ordering propagates to sub-directories
  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);
}

Referenced by G4VisSubThread(), GetInstance(), and operator<<.

◆ ~G4VisManager()

G4VisManager::~G4VisManager ( )

virtual

Definition at line 231 of file G4VisManager.cc.

{
  G4UImanager* UImanager = G4UImanager::GetUIpointer();
  UImanager->SetCoutDestination(nullptr);
  std::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;
  fpInstance = 0;
}

Member Function Documentation

◆ BeginDraw()

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

virtual

Implements G4VVisManager.

Definition at line 925 of file G4VisManager.cc.

{
  if (G4Threading::IsWorkerThread()) return;
  
  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;
  }
}

◆ BeginDraw2D()

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

virtual

Implements G4VVisManager.

Definition at line 960 of file G4VisManager.cc.

{
  if (G4Threading::IsWorkerThread()) return;
  
  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;
  }
}

◆ CreateSceneHandler()

void G4VisManager::CreateSceneHandler ( const G4String & name = "" )

Definition at line 1230 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) {
    G4warn << "ERROR in G4VisManager::CreateSceneHandler during "
           << fpGraphicsSystem -> GetName ()
           << " scene handler creation.\n  No action taken."
           << G4endl;
      }
    }
  }
  else PrintInvalidPointers ();
}

Referenced by CreateSceneHandler().

◆ CreateViewer()

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

Definition at line 1251 of file G4VisManager.cc.

{
 
  if (!fInitialised) Initialise ();
 
  if (!fpSceneHandler) {
    PrintInvalidPointers ();
    return;
  }
 
  G4VViewer* p = fpGraphicsSystem -> CreateViewer (*fpSceneHandler, name);
 
  if (!p) {
    if (fVerbosity >= errors) {
      G4warn << "ERROR in G4VisManager::CreateViewer: null pointer during "
         << fpGraphicsSystem -> GetName ()
         << " viewer creation.\n  No action taken."
         << G4endl;
    }
    return;
  }
 
  if (p -> GetViewId() < 0) {
    if (fVerbosity >= errors) {
      G4warn << "ERROR in G4VisManager::CreateViewer during "
         << fpGraphicsSystem -> GetName ()
         << " viewer instantiation.\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.)
  if (p -> GetViewId() < 0) {
    if (fVerbosity >= errors) {
      G4warn << "ERROR in G4VisManager::CreateViewer during "
         << fpGraphicsSystem -> GetName ()
         << " viewer initialisation.\n  No action taken."
         << G4endl;
    }
    return;
  }
 
  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) {
    G4warn <<
  "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;
      }
    }
  }
}

Referenced by CreateViewer().

◆ CurrentTrajDrawModel()

const G4VTrajectoryModel * G4VisManager::CurrentTrajDrawModel ( ) const

Definition at line 854 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 fallback.
    fpTrajDrawModelMgr->Register(new G4TrajectoryDrawByCharge("DefaultModel"));
    if (fVerbosity >= warnings) {
      G4warn<<"G4VisManager: Using G4TrajectoryDrawByCharge as fallback trajectory model."<<G4endl;
      G4warn<<"See commands in /vis/modeling/trajectories/ for other options."<<G4endl;
    }
  }
 
  model = fpTrajDrawModelMgr->Current();
  assert (0 != model); // Should definitely exist now
 
  return model;
}

Referenced by G4HepRepFileSceneHandler::BeginModeling(), and DispatchToModel().

◆ Disable()

void G4VisManager::Disable ( )

Definition at line 785 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;
  }
  if (fVerbosity >= warnings) {
    G4int currentTrajectoryType =
    G4RunManagerKernel::GetRunManagerKernel()->GetTrackingManager()->GetStoreTrajectory();
    if (currentTrajectoryType > 0) {
    G4warn <<
      "You may wish to disable trajectory production too:"
      "\n  \"/tracking/storeTrajectory 0\""
      "\nbut don't forget to re-enable with"
      "\n  \"/vis/enable\""
      "\n  \"/tracking/storeTrajectory " << currentTrajectoryType
      << "\"\n  and maybe \"/vis/viewer/rebuild\""
      << G4endl;
    }
  }
}

◆ DispatchToModel()

void G4VisManager::DispatchToModel ( const G4VTrajectory & trajectory )

virtual

Implements G4VVisManager.

Definition at line 1496 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);
  }
}

◆ Draw() [1/12]

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

virtual

Implements G4VVisManager.

Definition at line 1039 of file G4VisManager.cc.

{
  DrawT (circle, objectTransform);
}

Referenced by Draw(), and Draw().

◆ Draw() [2/12]

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

virtual

Implements G4VVisManager.

Definition at line 1167 of file G4VisManager.cc.

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

◆ Draw() [3/12]

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

virtual

Implements G4VVisManager.

Definition at line 1045 of file G4VisManager.cc.

{
  DrawT (polyhedron, objectTransform);
}

◆ Draw() [4/12]

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

virtual

Implements G4VVisManager.

Definition at line 1051 of file G4VisManager.cc.

{
  DrawT (line, objectTransform);
}

◆ Draw() [5/12]

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

virtual

Implements G4VVisManager.

Definition at line 1057 of file G4VisManager.cc.

{
  DrawT (polymarker, objectTransform);
}

◆ Draw() [6/12]

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

virtual

Implements G4VVisManager.

Definition at line 1063 of file G4VisManager.cc.

{
  DrawT (square, objectTransform);
}

◆ Draw() [7/12]

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

virtual

Implements G4VVisManager.

Definition at line 1069 of file G4VisManager.cc.

{
  DrawT (text, objectTransform);
}

◆ Draw() [8/12]

void G4VisManager::Draw ( const G4VDigi & digi )

virtual

Implements G4VVisManager.

Definition at line 1124 of file G4VisManager.cc.

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

◆ Draw() [9/12]

void G4VisManager::Draw ( const G4VHit & hit )

virtual

Implements G4VVisManager.

Definition at line 1111 of file G4VisManager.cc.

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

◆ Draw() [10/12]

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

virtual

Implements G4VVisManager.

Definition at line 1196 of file G4VisManager.cc.

                                                   {
  if (G4Threading::IsWorkerThread()) return;
  
  // 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);
}

◆ Draw() [11/12]

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

virtual

Implements G4VVisManager.

Definition at line 1177 of file G4VisManager.cc.

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

◆ Draw() [12/12]

void G4VisManager::Draw ( const G4VTrajectory & traj )

virtual

Implements G4VVisManager.

Definition at line 1137 of file G4VisManager.cc.

                                                  {
  if (G4Threading::IsWorkerThread()) return;
  
  // A trajectory needs a trajectories model to provide G4Atts, etc.
  static G4TrajectoriesModel trajectoriesModel;
  trajectoriesModel.SetCurrentTrajectory(&traj);
  G4RunManager* runManager = G4RunManagerFactory::GetMasterRunManager();
  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);
    }
  }
}

◆ Draw2D() [1/6]

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

virtual

Implements G4VVisManager.

Definition at line 1075 of file G4VisManager.cc.

{
  DrawT2D (circle, objectTransform);
}

◆ Draw2D() [2/6]

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

virtual

Implements G4VVisManager.

Definition at line 1081 of file G4VisManager.cc.

{
  DrawT2D (polyhedron, objectTransform);
}

◆ Draw2D() [3/6]

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

virtual

Implements G4VVisManager.

Definition at line 1087 of file G4VisManager.cc.

{
  DrawT2D (line, objectTransform);
}

◆ Draw2D() [4/6]

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

virtual

Implements G4VVisManager.

Definition at line 1093 of file G4VisManager.cc.

{
  DrawT2D (polymarker, objectTransform);
}

◆ Draw2D() [5/6]

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

virtual

Implements G4VVisManager.

Definition at line 1099 of file G4VisManager.cc.

{
  DrawT2D (square, objectTransform);
}

◆ Draw2D() [6/6]

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

virtual

Implements G4VVisManager.

Definition at line 1105 of file G4VisManager.cc.

{
  DrawT2D (text, objectTransform);
}

◆ DrawGeometry()

void G4VisManager::DrawGeometry	(	G4VPhysicalVolume *	v,
		const G4Transform3D &	t = G4Transform3D() )

virtual

Reimplemented from G4VVisManager.

Definition at line 1218 of file G4VisManager.cc.

{
  auto modelingParameters = fpSceneHandler->CreateModelingParameters();
  auto depth = G4PhysicalVolumeModel::UNLIMITED;
  const G4bool useFullExtent = true;
  G4PhysicalVolumeModel aPVModel(v,depth,t,modelingParameters,useFullExtent);
  aPVModel.DescribeYourselfTo(*fpSceneHandler);
  delete modelingParameters;
}

◆ Enable()

void G4VisManager::Enable ( )

Definition at line 750 of file G4VisManager.cc.

                          {
  if (IsValidView ()) {
    SetConcreteInstance(this);
    if (fVerbosity >= confirmations) {
      G4cout << "G4VisManager::Enable: visualization enabled." << G4endl;
    }
    if (fVerbosity >= warnings) {
      std::size_t nKeptEvents = 0;
      const G4Run* run = G4RunManager::GetRunManager()->GetCurrentRun();
      if (run) nKeptEvents = run->GetNumberOfKeptEvents();
      G4String isare("are"),plural("s");
      if (nKeptEvents == 1) {isare = "is"; plural = "";}
      G4cout <<
      "There " << isare << ' ' << nKeptEvents << " kept event" << plural << '.'
      << G4endl;
      if (nKeptEvents > 0) {
        G4cout <<
  "  \"/vis/reviewKeptEvents\" to review one by one."
  "\n  To see accumulated, \"/vis/enable\", then \"/vis/viewer/flush\" or \"/vis/viewer/rebuild\"."
        << G4endl;
      }
      PrintListOfPlots();
    }
  }
  else {
    if (fVerbosity >= warnings) {
      G4warn <<
    "G4VisManager::Enable: WARNING: visualization remains disabled for"
    "\n  above reasons.  Rectifying with valid vis commands will"
    "\n  automatically enable."
         << G4endl;
    }
  }
}

◆ EndDraw()

void G4VisManager::EndDraw ( )

virtual

Implements G4VVisManager.

Definition at line 945 of file G4VisManager.cc.

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

◆ EndDraw2D()

void G4VisManager::EndDraw2D ( )

virtual

Implements G4VVisManager.

Definition at line 980 of file G4VisManager.cc.

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

◆ EventReadyForVis()

void G4VisManager::EventReadyForVis ( const G4Event * event )

virtual

Reimplemented from G4VVisManager.

Definition at line 2120 of file G4VisManager.cc.

{
  if (fIgnoreStateChanges) return;
  if (!GetConcreteInstance()) return;
  if (!isValidViewForRun) return;
  if (isFakeRun) return;
 
  G4AutoLock al(&visEndOfEventMutex);
  EndOfEventKernel(event);
}

◆ FilterDigi()

G4bool G4VisManager::FilterDigi ( const G4VDigi & digi )

virtual

Implements G4VVisManager.

Definition at line 1491 of file G4VisManager.cc.

{
  return fpDigiFilterMgr->Accept(digi);
}   

◆ FilterHit()

G4bool G4VisManager::FilterHit ( const G4VHit & hit )

virtual

Implements G4VVisManager.

Definition at line 1486 of file G4VisManager.cc.

{
  return fpHitFilterMgr->Accept(hit);
}   

◆ FilterTrajectory()

G4bool G4VisManager::FilterTrajectory ( const G4VTrajectory & trajectory )

virtual

Implements G4VVisManager.

Definition at line 1481 of file G4VisManager.cc.

{
  return fpTrajFilterMgr->Accept(trajectory);
}   

Referenced by DispatchToModel().

◆ G4VisSubThread()

G4ThreadFunReturnType G4VisManager::G4VisSubThread ( G4ThreadFunArgType p )

static

Definition at line 1908 of file G4VisManager.cc.

{
#ifdef G4MULTITHREADED
  G4VisManager* pVisManager = (G4VisManager*)p;
  G4VSceneHandler* pSceneHandler = pVisManager->GetCurrentSceneHandler();
  if (!pSceneHandler) return 0;
  G4Scene* pScene = pSceneHandler->GetScene();
  if (!pScene) return 0;
  G4VViewer* pViewer = pVisManager->GetCurrentViewer();
  if (!pViewer) return 0;
 
  G4UImanager::GetUIpointer()->SetUpForSpecialThread("G4VIS");
 
  // Set up geometry and navigation for a thread
  G4GeometryWorkspace::GetPool()->CreateAndUseWorkspace();
  G4SolidsWorkspace::GetPool()->CreateAndUseWorkspace();
  G4Navigator* navigator = G4TransportationManager::GetTransportationManager()
                             ->GetNavigatorForTracking();
  navigator->SetWorldVolume(
    G4RunManagerFactory::GetMasterRunManagerKernel()->GetCurrentWorld());
 
  pViewer->SwitchToVisSubThread();
 
  while (true) {
 
    G4MUTEXLOCK(&mtVisSubThreadMutex);
    std::size_t eventQueueSize = mtVisEventQueue.size();
    G4MUTEXUNLOCK(&mtVisSubThreadMutex);
    // G4cout << "Event queue size (A): " << eventQueueSize << G4endl;
 
    while (eventQueueSize) {
 
      G4MUTEXLOCK(&mtVisSubThreadMutex);
      const G4Event* event = mtVisEventQueue.front();
      G4MUTEXUNLOCK(&mtVisSubThreadMutex);
 
      // Here comes the event drawing
      pVisManager->SetTransientsDrawnThisEvent(false);
      pSceneHandler->SetTransientsDrawnThisEvent(false);
 
      // 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.
      pVisManager->ClearTransientStoreIfMarked();
 
      // Now draw the event...
      pSceneHandler->DrawEvent(event);
      ++pVisManager->fNoOfEventsDrawnThisRun;
 
      // Then pop and release event
      G4MUTEXLOCK(&mtVisSubThreadMutex);
      mtVisEventQueue.pop_front();
      pVisManager->EndOfEventCleanup(event);
      eventQueueSize = mtVisEventQueue.size();
      G4MUTEXUNLOCK(&mtVisSubThreadMutex);
    }
 
    G4MUTEXLOCK(&mtVisSubThreadMutex);
    G4bool runInProgress = mtRunInProgress;
    G4MUTEXUNLOCK(&mtVisSubThreadMutex);
    if (!runInProgress) {
      // EndOfRun on master thread has signalled end of run.  There is
      // nothing to draw so...
      break;
    }
 
    // Run still in progress but nothing to draw, so wait a while.
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
  }
 
  // Inform viewer that we have finished all sub-thread drawing
  pViewer->DoneWithVisSubThread();
  pViewer->MovingToMasterThread();
#else
  G4ConsumeParameters(p);
#endif
  return nullptr;
}

◆ GeometryHasChanged()

void G4VisManager::GeometryHasChanged ( )

virtual

Implements G4VVisManager.

Definition at line 1343 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) {
      G4warn << "WARNING: There is no world volume!" << G4endl;
    }
  }
 
  // Check scenes.
  G4SceneList& sceneList = fSceneList;
  std::size_t 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) {
          G4warn << "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) {
      G4warn << "WARNING: No run-duration models left in this scene \""
         << pScene -> GetName ()
         << "\"."
         << G4endl;
    }
        if (pWorld) {
          if (fVerbosity >= warnings) {
            G4warn << "  Adding current world to \""
            << pScene -> GetName ()
            << "\"."
            << G4endl;
          }
          pScene->AddRunDurationModel(new G4PhysicalVolumeModel(pWorld),fVerbosity>=warnings);
          // (The above includes a re-calculation of the extent.)
          G4UImanager::GetUIpointer () ->
          ApplyCommand (G4String("/vis/scene/notifyHandlers " + pScene->GetName()));
        }
      }
      else {
    pScene->CalculateExtent();  // Recalculate extent
    G4UImanager::GetUIpointer () ->
      ApplyCommand (G4String("/vis/scene/notifyHandlers " + pScene->GetName()));
      }
    }
  }
 
  // Check the manager's current scene...
  if (fpScene && fpScene -> GetRunDurationModelList ().size () == 0) {
    if (fVerbosity >= warnings) {
      G4warn << "WARNING: The current scene \""
         << fpScene -> GetName ()
         << "\" has no run duration models."
             << "\n  Use \"/vis/scene/add/volume\" or create a new scene."
         << G4endl;
    }
    // Clean up
    if (fpSceneHandler) {
      fpSceneHandler->ClearTransientStore();
      fpSceneHandler->ClearStore();
      if (fpViewer) {
        fpViewer->NeedKernelVisit();
        fpViewer->SetView();
        fpViewer->ClearView();
        fpViewer->FinishView();
      }
    }
  }
}

◆ GetAbortReviewKeptEvents()

G4bool G4VisManager::GetAbortReviewKeptEvents ( ) const

◆ GetAbortReviewPlots()

G4bool G4VisManager::GetAbortReviewPlots ( ) const

◆ GetAvailableGraphicsSystems()

const G4GraphicsSystemList & G4VisManager::GetAvailableGraphicsSystems ( )

Definition at line 810 of file G4VisManager.cc.

                                                                       {
  std::size_t nSystems = fAvailableGraphicsSystems.size ();
  if (nSystems == 0) {
    if (fVerbosity >= warnings) {
      G4warn << "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

Referenced by operator<<.

◆ GetCurrentGraphicsSystem()

G4VGraphicsSystem * G4VisManager::GetCurrentGraphicsSystem ( ) const

◆ GetCurrentScene()

G4Scene * G4VisManager::GetCurrentScene ( ) const

Referenced by G4RayTracerSceneHandler::G4RayTracerSceneHandler().

◆ GetCurrentSceneHandler()

G4VSceneHandler * G4VisManager::GetCurrentSceneHandler ( ) const

Referenced by G4RayTrajectory::AppendStep(), G4VisSubThread(), G4ToolsSGSceneHandler::Messenger::SetNewValue(), and G4RTSteppingAction::UserSteppingAction().

◆ GetCurrentViewer()

G4VViewer * G4VisManager::GetCurrentViewer ( ) const

Referenced by G4VisSubThread(), G4OpenGLViewerMessenger::SetNewValue(), G4OpenGLXmViewerMessenger::SetNewValue(), G4OpenInventorXtExaminerViewerMessenger::SetNewValue(), G4RTMessenger::SetNewValue(), G4ToolsSGOffscreenViewer::Messenger::SetNewValue(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::Messenger::SetNewValue(), and G4VtkMessenger::SetNewValue().

◆ GetDefaultGraphicsSystemBasis()

const G4String & G4VisManager::GetDefaultGraphicsSystemBasis ( ) const

◆ GetDefaultGraphicsSystemName()

virtual const G4String & G4VisManager::GetDefaultGraphicsSystemName ( )

virtual

◆ GetDefaultViewParameters()

const G4ViewParameters & G4VisManager::GetDefaultViewParameters ( ) const

◆ GetDefaultXGeometryString()

const G4String & G4VisManager::GetDefaultXGeometryString ( ) const

◆ GetDefaultXGeometryStringBasis()

const G4String & G4VisManager::GetDefaultXGeometryStringBasis ( ) const

◆ GetDrawEventOnlyIfToBeKept()

G4bool G4VisManager::GetDrawEventOnlyIfToBeKept ( ) const

◆ GetEndOfEventUserVisActions()

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

◆ GetEndOfRunUserVisActions()

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

◆ GetInstance()

G4VisManager * G4VisManager::GetInstance ( )

static

Definition at line 267 of file G4VisManager.cc.

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

Referenced by G4DAWNFILESceneHandler::AddSolid(), G4RayTrajectory::AppendStep(), G4HepRepFileSceneHandler::BeginModeling(), G4RayTracerSceneHandler::BuildVisAttsMap(), G4RayTracerSceneHandler::G4RayTracerSceneHandler(), G4VViewer::G4VViewer(), G4VViewer::InsertModelInSceneTree(), operator<<, G4VSceneHandler::ProcessScene(), G4VSceneHandler::RemoveViewerFromList(), G4OpenGLViewerMessenger::SetNewValue(), G4OpenGLXmViewerMessenger::SetNewValue(), G4OpenInventorXtExaminerViewerMessenger::SetNewValue(), G4RTMessenger::SetNewValue(), G4VtkMessenger::SetNewValue(), and G4RTSteppingAction::UserSteppingAction().

◆ GetMaxEventQueueSize()

G4int G4VisManager::GetMaxEventQueueSize ( ) const

◆ GetNKeepForPostProcessingRequests()

G4int G4VisManager::GetNKeepForPostProcessingRequests ( ) const

◆ GetNKeepRequests()

G4int G4VisManager::GetNKeepRequests ( ) const

◆ GetNKeepTheEventRequests()

G4int G4VisManager::GetNKeepTheEventRequests ( ) const

◆ GetRequestedEvent()

const G4Event * G4VisManager::GetRequestedEvent ( ) const

Referenced by G4VSceneHandler::ProcessScene().

◆ GetReviewingKeptEvents()

G4bool G4VisManager::GetReviewingKeptEvents ( ) const

◆ GetReviewingPlots()

G4bool G4VisManager::GetReviewingPlots ( ) const

◆ GetRunDurationUserVisActions()

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

◆ GetSceneList()

const G4SceneList & G4VisManager::GetSceneList ( ) const

◆ GetTransientsDrawnThisEvent()

G4bool G4VisManager::GetTransientsDrawnThisEvent ( ) const

◆ GetTransientsDrawnThisRun()

G4bool G4VisManager::GetTransientsDrawnThisRun ( ) const

◆ GetUserVisActionExtents()

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

◆ GetVerbosity()

G4VisManager::Verbosity G4VisManager::GetVerbosity ( )

static

Definition at line 2566 of file G4VisManager.cc.

                                                  {
  return fVerbosity;
}

◆ GetVerbosityValue() [1/2]

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

static

Definition at line 2529 of file G4VisManager.cc.

                                                               {
  G4String ss = G4StrUtil::to_lower_copy(verbosityString);
  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 {
    // Could be an integer
    G4int intVerbosity;
    std::istringstream is(ss);
    is >> intVerbosity;
    if (!is) {
      G4warn << "ERROR: G4VisManager::GetVerbosityValue: invalid verbosity \""
         << verbosityString << "\"\n";
      PrintAvailableVerbosity(G4warn);
      // Return existing verbosity
      return fVerbosity;
    }
    else {
      verbosity = GetVerbosityValue(intVerbosity);
    }
  }
  return verbosity;
}

Referenced by G4VisManager(), GetVerbosityValue(), SetVerboseLevel(), and SetVerboseLevel().

◆ GetVerbosityValue() [2/2]

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

static

Definition at line 2558 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 2480 of file G4VisManager.cc.

                                                                    {
  G4String viewerShortName = ViewerShortName (viewerName);
  std::size_t nHandlers = fAvailableSceneHandlers.size ();
  std::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;
}

◆ GetWaitOnEventQueueFull()

G4bool G4VisManager::GetWaitOnEventQueueFull ( ) const

◆ IgnoreStateChanges()

void G4VisManager::IgnoreStateChanges ( G4bool val )

virtual

Reimplemented from G4VVisManager.

Definition at line 2705 of file G4VisManager.cc.

{
  fIgnoreStateChanges = val; 
}

◆ Initialise()

void G4VisManager::Initialise ( )

Definition at line 276 of file G4VisManager.cc.

                               {
 
  if (fInitialised && fVerbosity >= warnings) {
    G4warn << "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/management/include/G4VisExecutive.hh/icc, for example."
      "\n  In your main() you will have something like:"
      "\n    G4VisManager* visManager = new G4VisExecutive;"
      "\n    visManager -> SetVerboseLevel (Verbose);"
      "\n    visManager -> Initialize ();"
      "\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;
  }
 
  InitialiseG4ColourMap();
 
  if (fVerbosity >= startup) {
    G4cout <<
    "Some /vis commands (optionally) take a string to specify colour."
    "\n\"/vis/list\" to see available colours."
    << G4endl;
  }
 
  fInitialised = true;
}

Referenced by CreateSceneHandler(), and CreateViewer().

◆ Initialize()

void G4VisManager::Initialize ( )

◆ IsEnabled()

G4bool G4VisManager::IsEnabled ( ) const

◆ NotifyHandlers()

void G4VisManager::NotifyHandlers ( )

virtual

Reimplemented from G4VVisManager.

Definition at line 1440 of file G4VisManager.cc.

                                   {
 
  if (fVerbosity >= confirmations) {
    G4cout << "G4VisManager::NotifyHandler() called." << G4endl;
  }
 
  if (IsValidView()) {
 
    // Check scenes.
    G4SceneList& sceneList = fSceneList;
    std::size_t 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) {
        G4warn << "WARNING: The current scene \""
        << fpScene -> GetName ()
        << "\" has no run duration models."
        << "\n  Use \"/vis/scene/add/volume\" or create a new scene."
        << G4endl;
      }
      fpSceneHandler->ClearTransientStore();
      fpSceneHandler->ClearStore();
      fpViewer->NeedKernelVisit();
      fpViewer->SetView();
      fpViewer->ClearView();
      fpViewer->FinishView();
    }
  }
}

◆ PrintAvailableGraphicsSystems()

void G4VisManager::PrintAvailableGraphicsSystems	(	Verbosity	verbosity,
		std::ostream &	out = G4cout ) const

Definition at line 1730 of file G4VisManager.cc.

{
  out << "Registered graphics systems are:\n";
  if (fAvailableGraphicsSystems.size ()) {
    for (const auto& gs: fAvailableGraphicsSystems) {
      const G4String& name = gs->GetName();
      const std::vector<G4String>& nicknames = gs->GetNicknames();
      if (verbosity >= warnings) {
        // Brief output
        out << "  " << name << " (";
        for (std::size_t i = 0; i < nicknames.size(); ++i) {
          if (i != 0) {
            out << ", ";
          }
          out << nicknames[i];
        }
        out << ')';
      } else {
        // Full output
        out << *gs;
      }
      out << std::endl;
    }
    out <<
    "You may choose a graphics system (driver) with a parameter of"
    "\nthe command \"/vis/open\" or \"/vis/sceneHandler/create\","
    "\nor you may omit the driver parameter and choose at run time:"
    "\n- by argument in the construction of G4VisExecutive;"
    "\n- by environment variable \"G4VIS_DEFAULT_DRIVER\";"
    "\n- by entry in \"~/.g4session\";"
    "\n- by build flags."
    "\n- Note: This feature is not allowed in batch mode."
    "\nFor further information see \"examples/basic/B1/exampleB1.cc\""
    "\nand \"vis.mac\"."
    << std::endl;
  } else {
    out << "  NONE!!!  None registered - yet!  Mmmmm!" << std::endl;
  }
}

Referenced by Initialise().

◆ PrintAvailableVerbosity()

void G4VisManager::PrintAvailableVerbosity ( std::ostream & os )

static

Definition at line 2518 of file G4VisManager.cc.

{
  os << "Available verbosity options:";
  for (std::size_t i = 0; i < VerbosityGuidanceStrings.size(); ++i) {
    os << '\n' << VerbosityGuidanceStrings[i];
  }
  os << "\nCurrent verbosity: " << G4VisManager::VerbosityString(fVerbosity);
  os << std::endl;
}

Referenced by GetVerbosityValue(), and G4VisCommandList::SetNewValue().

◆ RegisterEndOfEventUserVisAction()

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

Definition at line 1543 of file G4VisManager.cc.

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

◆ RegisterEndOfRunUserVisAction()

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

Definition at line 1564 of file G4VisManager.cc.

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

◆ RegisterGraphicsSystem()

G4bool G4VisManager::RegisterGraphicsSystem ( G4VGraphicsSystem * pSystem )

Definition at line 830 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) {
      G4warn << "G4VisManager::RegisterGraphicsSystem: null pointer!"
         << G4endl;
    }
    happy=false;
  }
  return happy;
}

◆ RegisterGraphicsSystems()

virtual void G4VisManager::RegisterGraphicsSystems ( )

protectedpure virtual

Referenced by Initialise().

◆ RegisterMessenger()

void G4VisManager::RegisterMessenger ( G4UImessenger * messenger )

Referenced by G4VisManager(), and RegisterMessengers().

◆ RegisterMessengers()

void G4VisManager::RegisterMessengers ( )

protected

Definition at line 483 of file G4VisManager.cc.

                                       {
  
  // Instantiate individual messengers/commands (often - but not
  // always - one command per messenger).
  
  G4UIcommand* directory;
  
  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 G4VisCommandGeometrySetForceCloud);
  RegisterMessenger(new G4VisCommandGeometrySetForceLineSegmentsPerCircle);
  RegisterMessenger(new G4VisCommandGeometrySetForceSolid);
  RegisterMessenger(new G4VisCommandGeometrySetForceWireframe);
  RegisterMessenger(new G4VisCommandGeometrySetVisibility);
  
  directory = new G4UIdirectory ("/vis/multithreading/");
  directory -> SetGuidance("Commands unique to multithreading mode.");
  fDirectoryList.push_back (directory);
  RegisterMessenger(new G4VisCommandMultithreadingActionOnEventQueueFull);
  RegisterMessenger(new G4VisCommandMultithreadingMaxEventQueueSize);
 
  directory = new G4UIdirectory ("/vis/set/");
  directory -> SetGuidance
    ("Set quantities for use in future commands where appropriate.");
  fDirectoryList.push_back (directory);
  RegisterMessenger(new G4VisCommandSetArrow3DLineSegmentsPerCircle);
  RegisterMessenger(new G4VisCommandSetColour);
  RegisterMessenger(new G4VisCommandSetExtentForField);
  RegisterMessenger(new G4VisCommandSetLineWidth);
  RegisterMessenger(new G4VisCommandSetTextColour);
  RegisterMessenger(new G4VisCommandSetTextLayout);
  RegisterMessenger(new G4VisCommandSetTextSize);
  RegisterMessenger(new G4VisCommandSetTouchable);
  RegisterMessenger(new G4VisCommandSetVolumeForField);
 
  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 G4VisCommandSceneRemoveModel);
  RegisterMessenger(new G4VisCommandSceneSelect);
  RegisterMessenger(new G4VisCommandSceneShowExtents);
 
  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 G4VisCommandSceneAddElectricField);
  RegisterMessenger(new G4VisCommandSceneAddFrame);
  RegisterMessenger(new G4VisCommandSceneAddGPS);
  RegisterMessenger(new G4VisCommandSceneAddHits);
  RegisterMessenger(new G4VisCommandSceneAddLine);
  RegisterMessenger(new G4VisCommandSceneAddLine2D);
  RegisterMessenger(new G4VisCommandSceneAddLocalAxes);
  RegisterMessenger(new G4VisCommandSceneAddLogicalVolume);
  RegisterMessenger(new G4VisCommandSceneAddLogo);
  RegisterMessenger(new G4VisCommandSceneAddLogo2D);
  RegisterMessenger(new G4VisCommandSceneAddMagneticField);
  RegisterMessenger(new G4VisCommandSceneAddPlotter);
  RegisterMessenger(new G4VisCommandSceneAddPSHits);
  RegisterMessenger(new G4VisCommandSceneAddScale);
  RegisterMessenger(new G4VisCommandSceneAddText);
  RegisterMessenger(new G4VisCommandSceneAddText2D);
  RegisterMessenger(new G4VisCommandSceneAddTrajectories);
  RegisterMessenger(new G4VisCommandSceneAddUserAction);
  RegisterMessenger(new G4VisCommandSceneAddVolume);
  
  RegisterMessenger(new G4VisCommandPlotterCreate);
  RegisterMessenger(new G4VisCommandPlotterSetLayout);
  RegisterMessenger(new G4VisCommandPlotterAddStyle);
  RegisterMessenger(new G4VisCommandPlotterAddRegionStyle);
  RegisterMessenger(new G4VisCommandPlotterAddRegionParameter);
  RegisterMessenger(new G4VisCommandPlotterClear);
  RegisterMessenger(new G4VisCommandPlotterClearRegion);
  RegisterMessenger(new G4VisCommandPlotterList);
  RegisterMessenger(new G4VisCommandPlotterAddRegionH1);
  RegisterMessenger(new G4VisCommandPlotterAddRegionH2);
  
  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 G4VisCommandViewerCentreOn);
  RegisterMessenger(new G4VisCommandViewerChangeCutawayPlane);
  RegisterMessenger(new G4VisCommandViewerClear);
  RegisterMessenger(new G4VisCommandViewerClearCutawayPlanes);
  RegisterMessenger(new G4VisCommandViewerClearTransients);
  RegisterMessenger(new G4VisCommandViewerClearVisAttributesModifiers);
  RegisterMessenger(new G4VisCommandViewerClone);
  RegisterMessenger(new G4VisCommandViewerColourByDensity);
  RegisterMessenger(new G4VisCommandViewerCopyViewFrom);
  RegisterMessenger(new G4VisCommandViewerCreate);
  RegisterMessenger(new G4VisCommandViewerDolly);
  RegisterMessenger(new G4VisCommandViewerFlush);
  RegisterMessenger(new G4VisCommandViewerInterpolate);
  RegisterMessenger(new G4VisCommandViewerList);
  RegisterMessenger(new G4VisCommandViewerPan);
  RegisterMessenger(new G4VisCommandViewerRebuild);
  RegisterMessenger(new G4VisCommandViewerRefresh);
  RegisterMessenger(new G4VisCommandViewerReset);
  RegisterMessenger(new G4VisCommandViewerResetCameraParameters);
  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);
  
  // *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 commands, including "compound commands"
  // (i.e., commands that invoke other commands) are instantiated here.
 
  RegisterMessenger(new G4VisCommandAbortReviewKeptEvents);
  RegisterMessenger(new G4VisCommandAbortReviewPlots);
  RegisterMessenger(new G4VisCommandDrawOnlyToBeKeptEvents);
  RegisterMessenger(new G4VisCommandDrawTree);
  RegisterMessenger(new G4VisCommandDrawView);
  RegisterMessenger(new G4VisCommandDrawLogicalVolume);
  RegisterMessenger(new G4VisCommandDrawVolume);
  RegisterMessenger(new G4VisCommandEnable);
  RegisterMessenger(new G4VisCommandList);
  RegisterMessenger(new G4VisCommandOpen);
  RegisterMessenger(new G4VisCommandPlot);
  RegisterMessenger(new G4VisCommandReviewKeptEvents);
  RegisterMessenger(new G4VisCommandReviewPlots);
  RegisterMessenger(new G4VisCommandSpecify);
 
  // 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()));
}

Referenced by Initialise().

◆ RegisterModel() [1/4]

void G4VisManager::RegisterModel ( G4VFilter< G4VDigi > * filter )

Definition at line 909 of file G4VisManager.cc.

{
  fpDigiFilterMgr->Register(model);
}

◆ RegisterModel() [2/4]

void G4VisManager::RegisterModel ( G4VFilter< G4VHit > * filter )

Definition at line 898 of file G4VisManager.cc.

{
  fpHitFilterMgr->Register(model);
}

◆ RegisterModel() [3/4]

void G4VisManager::RegisterModel ( G4VFilter< G4VTrajectory > * filter )

Definition at line 887 of file G4VisManager.cc.

{
  fpTrajFilterMgr->Register(model);
}

◆ RegisterModel() [4/4]

void G4VisManager::RegisterModel ( G4VTrajectoryModel * model )

Definition at line 876 of file G4VisManager.cc.

{
  fpTrajDrawModelMgr->Register(model);
}

◆ RegisterModelFactories()

void G4VisManager::RegisterModelFactories ( )

protectedvirtual

Definition at line 2688 of file G4VisManager.cc.

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

Referenced by Initialise().

◆ RegisterModelFactory() [1/4]

void G4VisManager::RegisterModelFactory ( G4DigiFilterFactory * factory )

Definition at line 915 of file G4VisManager.cc.

{
  fpDigiFilterMgr->Register(factory);
}

◆ RegisterModelFactory() [2/4]

void G4VisManager::RegisterModelFactory ( G4HitFilterFactory * factory )

Definition at line 904 of file G4VisManager.cc.

{
  fpHitFilterMgr->Register(factory);
}

◆ RegisterModelFactory() [3/4]

void G4VisManager::RegisterModelFactory ( G4TrajDrawModelFactory * factory )

Definition at line 882 of file G4VisManager.cc.

{
  fpTrajDrawModelMgr->Register(factory);
}

◆ RegisterModelFactory() [4/4]

void G4VisManager::RegisterModelFactory ( G4TrajFilterFactory * factory )

Definition at line 893 of file G4VisManager.cc.

{
  fpTrajFilterMgr->Register(factory);
}

◆ RegisterRunDurationUserVisAction()

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

Definition at line 1522 of file G4VisManager.cc.

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

◆ ResetTransientsDrawnFlags()

void G4VisManager::ResetTransientsDrawnFlags ( )

Definition at line 2463 of file G4VisManager.cc.

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

Referenced by SetCurrentScene().

◆ SelectTrajectoryModel()

void G4VisManager::SelectTrajectoryModel ( const G4String & model )

Definition at line 920 of file G4VisManager.cc.

{
   fpTrajDrawModelMgr->SetCurrent(model);
}

◆ SetAbortReviewKeptEvents()

void G4VisManager::SetAbortReviewKeptEvents ( G4bool )

◆ SetAbortReviewPlots()

void G4VisManager::SetAbortReviewPlots ( G4bool )

◆ SetAvailableSceneHandlers()

G4SceneHandlerList & G4VisManager::SetAvailableSceneHandlers ( )

◆ SetCurrentGraphicsSystem()

void G4VisManager::SetCurrentGraphicsSystem ( G4VGraphicsSystem * pSystem )

Definition at line 1594 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 = (G4int)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;
    }
  }
}

◆ SetCurrentScene()

void G4VisManager::SetCurrentScene ( G4Scene * pScene )

Definition at line 1585 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;
}

Referenced by G4RayTracerSceneHandler::G4RayTracerSceneHandler().

◆ SetCurrentSceneHandler()

void G4VisManager::SetCurrentSceneHandler ( G4VSceneHandler * pSceneHandler )

Definition at line 1641 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 ();
  std::size_t nViewers = viewerList.size ();
  if (nViewers) {
    std::size_t 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) {
    G4warn <<
  "WARNING: Problem setting scene handler - please report circumstances."
           << G4endl;
      }
    }
  }
  else {
    fpViewer = 0;
    if (fVerbosity >= warnings) {
      G4warn <<
    "WARNING: No viewers for this scene handler - please create one."
         << G4endl;
    }
  }
}

◆ SetCurrentViewer()

void G4VisManager::SetCurrentViewer ( G4VViewer * pViewer )

Definition at line 1693 of file G4VisManager.cc.

                                                       {
  fpViewer  = pViewer;
  if (fpViewer == nullptr) {
    if (fVerbosity >= confirmations) {
      G4cout << "G4VisManager::SetCurrentViewer: current viewer pointer zeroed "
      << G4endl;
    }
    return;
  }
  if (fVerbosity >= confirmations) {
    G4cout << "G4VisManager::SetCurrentViewer: viewer now "
       << pViewer -> GetName ()
       << G4endl;
  }
  fpSceneHandler = fpViewer -> GetSceneHandler ();
  if (!fpSceneHandler) {
    if (fVerbosity >= warnings) {
      G4warn <<
      "WARNING: No scene handler for this viewer - please create one."
      << G4endl;
    }
    return;
  }
  // JA: I don't think we need this. Setview will be called when needed.
  // fpViewer->SetView();
  fpSceneHandler -> SetCurrentViewer (pViewer);
  fpScene = fpSceneHandler -> GetScene ();
  fpGraphicsSystem = fpSceneHandler -> GetGraphicsSystem ();
  if (!IsValidView ()) {
    if (fVerbosity >= warnings) {
      G4warn <<
    "WARNING: Problem setting viewer - please report circumstances."
         << G4endl;
    }
  }
}

Referenced by CreateViewer(), and SetCurrentViewer().

◆ SetDefaultGraphicsSystemBasis()

void G4VisManager::SetDefaultGraphicsSystemBasis ( const G4String & )

◆ SetDefaultGraphicsSystemName()

void G4VisManager::SetDefaultGraphicsSystemName ( const G4String & )

◆ SetDefaultViewParameters()

void G4VisManager::SetDefaultViewParameters ( const G4ViewParameters & )

◆ SetDefaultXGeometryString()

void G4VisManager::SetDefaultXGeometryString ( const G4String & )

◆ SetDefaultXGeometryStringBasis()

void G4VisManager::SetDefaultXGeometryStringBasis ( const G4String & )

◆ SetDrawEventOnlyIfToBeKept()

void G4VisManager::SetDrawEventOnlyIfToBeKept ( G4bool )

◆ SetEventRefreshing()

void G4VisManager::SetEventRefreshing ( G4bool )

Referenced by G4VSceneHandler::ProcessScene().

◆ SetMaxEventQueueSize()

void G4VisManager::SetMaxEventQueueSize ( G4int )

◆ SetRequestedEvent()

void G4VisManager::SetRequestedEvent ( const G4Event * )

◆ SetReviewingKeptEvents()

void G4VisManager::SetReviewingKeptEvents ( G4bool )

◆ SetReviewingPlots()

void G4VisManager::SetReviewingPlots ( G4bool )

◆ SetSceneList()

G4SceneList & G4VisManager::SetSceneList ( )

Referenced by G4RayTracerSceneHandler::G4RayTracerSceneHandler().

◆ SetTransientsDrawnThisEvent()

void G4VisManager::SetTransientsDrawnThisEvent ( G4bool )

Referenced by G4VisSubThread().

◆ SetTransientsDrawnThisRun()

void G4VisManager::SetTransientsDrawnThisRun ( G4bool )

◆ SetUpForAThread()

void G4VisManager::SetUpForAThread ( )

virtual

Reimplemented from G4VVisManager.

Definition at line 2697 of file G4VisManager.cc.

{
  // TODO: protect with G4Threading::IsMultithreadedApplication() instead?
#ifdef G4MULTITHREADED
  new G4VisStateDependent(this); 
#endif
}

◆ SetVerboseLevel() [1/3]

void G4VisManager::SetVerboseLevel ( const G4String & verbosityString )

Definition at line 2574 of file G4VisManager.cc.

                                                                   {
  fVerbosity = GetVerbosityValue(verbosityString);
}

◆ SetVerboseLevel() [2/3]

void G4VisManager::SetVerboseLevel ( G4int intVerbosity )

Definition at line 2570 of file G4VisManager.cc.

                                                      {
  fVerbosity = GetVerbosityValue(intVerbosity);
}

◆ SetVerboseLevel() [3/3]

void G4VisManager::SetVerboseLevel ( Verbosity )

◆ SetWaitOnEventQueueFull()

void G4VisManager::SetWaitOnEventQueueFull ( G4bool )

◆ VerbosityString()

G4String G4VisManager::VerbosityString ( Verbosity verbosity )

static

Definition at line 2504 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;
}

Referenced by G4VisManager(), PrintAvailableVerbosity(), and G4VisCommandVerbose::SetNewValue().

◆ ViewerShortName()

G4String G4VisManager::ViewerShortName ( const G4String & viewerName ) const

Definition at line 2475 of file G4VisManager.cc.

                                                                        {
  const G4String& viewerShortName = viewerName.substr(0, viewerName.find (' '));
  return G4StrUtil::strip_copy(viewerShortName);
}

Definition at line 127 of file G4VisManager.hh.

Referenced by CreateViewer(), G4VisSubThread(), G4VViewer, GetCurrentViewer(), GetDefaultXGeometryStringBasis(), GetViewer(), SetCurrentViewer(), and SetDefaultXGeometryStringBasis().

◆ operator<< [1/2]

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

friend

Definition at line 73 of file G4VGraphicsSystem.cc.

{
  os << "Graphics System: " << gs.GetName ();
  os << ", nicknames:"; for (const 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 mouse control and \"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 1307 of file G4VSceneHandler.cc.

                                                                    {
 
  os << "Scene handler " << sh.fName << " has "
     << sh.fViewerList.size () << " viewer(s):";
  for (std::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;
}

Referenced by G4VisManager().

◆ fVerbosity

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

staticprotected

◆ VerbosityGuidanceStrings

std::vector< G4String > G4VisManager::VerbosityGuidanceStrings

static

Definition at line 474 of file G4VisManager.hh.

Referenced by G4VisCommandVerbose::G4VisCommandVerbose(), G4VisManager(), and PrintAvailableVerbosity().

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

Classes

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Static Protected Attributes

Friends

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ Verbosity

Constructor & Destructor Documentation

◆ G4VisManager()

◆ ~G4VisManager()

Member Function Documentation

◆ BeginDraw()

◆ BeginDraw2D()

◆ CreateSceneHandler()

◆ CreateViewer()

◆ CurrentTrajDrawModel()

◆ Disable()

◆ DispatchToModel()

◆ Draw() [1/12]

◆ Draw() [2/12]

◆ Draw() [3/12]

◆ Draw() [4/12]

◆ Draw() [5/12]

◆ Draw() [6/12]

◆ Draw() [7/12]

◆ Draw() [8/12]

◆ Draw() [9/12]

◆ Draw() [10/12]

◆ Draw() [11/12]

◆ Draw() [12/12]

◆ Draw2D() [1/6]

◆ Draw2D() [2/6]

◆ Draw2D() [3/6]

◆ Draw2D() [4/6]

◆ Draw2D() [5/6]

◆ Draw2D() [6/6]

◆ DrawGeometry()

◆ Enable()

◆ EndDraw()

◆ EndDraw2D()

◆ EventReadyForVis()

◆ FilterDigi()

◆ FilterHit()

◆ FilterTrajectory()

◆ G4VisSubThread()

◆ GeometryHasChanged()

◆ GetAbortReviewKeptEvents()

◆ GetAbortReviewPlots()

◆ GetAvailableGraphicsSystems()

◆ GetAvailableSceneHandlers()

◆ GetCurrentGraphicsSystem()

◆ GetCurrentScene()

◆ GetCurrentSceneHandler()

◆ GetCurrentViewer()

◆ GetDefaultGraphicsSystemBasis()

◆ GetDefaultGraphicsSystemName()

◆ GetDefaultViewParameters()

◆ GetDefaultXGeometryString()

◆ GetDefaultXGeometryStringBasis()

◆ GetDrawEventOnlyIfToBeKept()

◆ GetEndOfEventUserVisActions()

◆ GetEndOfRunUserVisActions()

◆ GetInstance()

◆ GetMaxEventQueueSize()

◆ GetNKeepForPostProcessingRequests()

◆ GetNKeepRequests()

◆ GetNKeepTheEventRequests()

◆ GetRequestedEvent()

◆ GetReviewingKeptEvents()

◆ GetReviewingPlots()

◆ GetRunDurationUserVisActions()

◆ GetSceneList()

◆ GetTransientsDrawnThisEvent()

◆ GetTransientsDrawnThisRun()