Inheritance diagram for PyG4VisManager:

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

Public Member Functions
void	BeginDraw (const G4Transform3D &objectTransformation=G4Transform3D())

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

void	CreateSceneHandler (const G4String &name="")

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

const G4VTrajectoryModel *	CurrentTrajDrawModel () const

void	Disable ()

void	DispatchToModel (const G4VTrajectory &)

void	Draw (const G4Circle &, const G4Transform3D &objectTransformation=G4Transform3D())

void	Draw (const G4LogicalVolume &, const G4VisAttributes &, 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	Draw (const G4VDigi &)

void	Draw (const G4VHit &)

void	Draw (const G4VPhysicalVolume &, const G4VisAttributes &, const G4Transform3D &objectTransformation=G4Transform3D())

void	Draw (const G4VSolid &, const G4VisAttributes &, const G4Transform3D &objectTransformation=G4Transform3D())

void	Draw (const G4VTrajectory &)

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

void	EndDraw ()

void	EndDraw2D ()

G4bool	FilterDigi (const G4VDigi &)

G4bool	FilterHit (const G4VHit &)

G4bool	FilterTrajectory (const G4VTrajectory &)

void	GeometryHasChanged ()

G4bool	GetAbortReviewKeptEvents () const

const G4GraphicsSystemList &	GetAvailableGraphicsSystems ()

const G4SceneHandlerList &	GetAvailableSceneHandlers () const

G4VGraphicsSystem *	GetCurrentGraphicsSystem () const

G4Scene *	GetCurrentScene () const

G4VSceneHandler *	GetCurrentSceneHandler () const

G4VViewer *	GetCurrentViewer () const

const G4ViewParameters &	GetDefaultViewParameters () const

G4bool	GetDrawEventOnlyIfToBeKept () const

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

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

G4int	GetNKeepRequests () const

const G4Event *	GetRequestedEvent () const

G4bool	GetReviewingKeptEvents () const

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

const G4SceneList &	GetSceneList () const

G4bool	GetTransientsDrawnThisEvent () const

G4bool	GetTransientsDrawnThisRun () const

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

G4VViewer *	GetViewer (const G4String &viewerName) const

void	IgnoreStateChanges (G4bool)

void	Initialise ()

void	Initialize ()

void	NotifyHandlers ()

	PyG4VisManager ()

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

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

G4bool	RegisterGraphicsSystem (G4VGraphicsSystem *)

virtual void	RegisterGraphicsSystems ()

void	RegisterMessenger (G4UImessenger *messenger)

void	RegisterModel (G4VFilter< G4VDigi > *filter)

void	RegisterModel (G4VFilter< G4VHit > *filter)

void	RegisterModel (G4VFilter< G4VTrajectory > *filter)

void	RegisterModel (G4VTrajectoryModel *model)

virtual void	RegisterModelFactories ()

void	RegisterModelFactory (G4DigiFilterFactory *factory)

void	RegisterModelFactory (G4HitFilterFactory *factory)

void	RegisterModelFactory (G4TrajDrawModelFactory *factory)

void	RegisterModelFactory (G4TrajFilterFactory *factory)

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

void	ResetTransientsDrawnFlags ()

void	SelectTrajectoryModel (const G4String &model)

void	SetAbortReviewKeptEvents (G4bool)

G4SceneHandlerList &	SetAvailableSceneHandlers ()

void	SetCurrentGraphicsSystem (G4VGraphicsSystem *)

void	SetCurrentScene (G4Scene *)

void	SetCurrentSceneHandler (G4VSceneHandler *)

void	SetCurrentViewer (G4VViewer *)

void	SetDefaultViewParameters (const G4ViewParameters &)

void	SetDrawEventOnlyIfToBeKept (G4bool)

void	SetEventRefreshing (G4bool)

void	SetRequestedEvent (const G4Event *)

void	SetReviewingKeptEvents (G4bool)

G4SceneList &	SetSceneList ()

void	SetTransientsDrawnThisEvent (G4bool)

void	SetTransientsDrawnThisRun (G4bool)

void	SetVerboseLevel (const G4String &)

void	SetVerboseLevel (G4int)

void	SetVerboseLevel (Verbosity)

G4String	ViewerShortName (const G4String &viewerName) const

	~PyG4VisManager ()

Static Public Member Functions
static PyG4VisManager *	_get_concrete_instance ()

static G4VVisManager *	GetConcreteInstance ()

static G4VisManager *	GetInstance ()

static Verbosity	GetVerbosity ()

static Verbosity	GetVerbosityValue (const G4String &)

static Verbosity	GetVerbosityValue (G4int)

static G4String	VerbosityString (Verbosity)

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

Protected Member Functions
void	PrintAvailableGraphicsSystems (Verbosity) const

void	RegisterMessengers ()

Static Protected Member Functions
static void	SetConcreteInstance (G4VVisManager *)

Protected Attributes
const G4int	fVerbose

Static Protected Attributes
static G4VVisManager *	fpConcreteInstance = 0

Private Member Functions
void	BeginOfEvent ()

void	BeginOfRun ()

void	ClearTransientStoreIfMarked ()

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

void	EndOfRun ()

void	InitialiseG4ColourMap () const

G4bool	IsValidView ()

void	PrintAvailableColours (Verbosity) const

void	PrintAvailableModels (Verbosity) const

void	PrintAvailableUserVisActions (Verbosity) const

void	PrintInvalidPointers () const

Private Attributes
G4bool	fAbortReviewKeptEvents

G4GraphicsSystemList	fAvailableGraphicsSystems

G4SceneHandlerList	fAvailableSceneHandlers

G4ViewParameters	fDefaultViewParameters

std::vector< G4UIcommand * >	fDirectoryList

G4bool	fDrawEventOnlyIfToBeKept

G4int	fDrawGroupNestingDepth

std::vector< UserVisAction >	fEndOfEventUserVisActions

std::vector< UserVisAction >	fEndOfRunUserVisActions

G4bool	fEventKeepingSuspended

G4bool	fEventRefreshing

G4bool	fIgnoreStateChanges

G4bool	fInitialised

G4bool	fIsDrawGroup

std::vector< G4UImessenger * >	fMessengerList

G4int	fNKeepRequests

G4int	fNoOfEventsDrawnThisRun

G4VisFilterManager< G4VDigi > *	fpDigiFilterMgr

G4VGraphicsSystem *	fpGraphicsSystem

G4VisFilterManager< G4VHit > *	fpHitFilterMgr

const G4Event *	fpRequestedEvent

G4Scene *	fpScene

G4VSceneHandler *	fpSceneHandler

G4VisStateDependent *	fpStateDependent

G4VisModelManager< G4VTrajectoryModel > *	fpTrajDrawModelMgr

G4VisFilterManager< G4VTrajectory > *	fpTrajFilterMgr

G4VViewer *	fpViewer

G4bool	fReviewingKeptEvents

std::vector< UserVisAction >	fRunDurationUserVisActions

G4SceneList	fSceneList

G4bool	fTransientsDrawnThisEvent

G4bool	fTransientsDrawnThisRun

std::map< G4VUserVisAction *, G4VisExtent >	fUserVisActionExtents

Static Private Attributes
static G4VisManager *	fpInstance = 0

static Verbosity	fVerbosity = G4VisManager::warnings

Detailed Description

Definition at line 40 of file pyG4VisManager.cc.

Member Enumeration Documentation

◆ Verbosity

enum G4VisManager::Verbosity

inherited

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

◆ PyG4VisManager()

PyG4VisManager::PyG4VisManager ( )

inline

Definition at line 42 of file pyG4VisManager.cc.

42{ SetVerboseLevel(quiet); }

G4VisManager::SetVerboseLevel

void SetVerboseLevel(G4int)

Definition: G4VisManager.cc:2454

References G4VisManager::quiet, and G4VisManager::SetVerboseLevel().

◆ ~PyG4VisManager()

PyG4VisManager::~PyG4VisManager ( )

inline

Definition at line 43 of file pyG4VisManager.cc.

43{ }

Member Function Documentation

◆ _get_concrete_instance()

static PyG4VisManager * PyG4VisManager::_get_concrete_instance ( )

inlinestatic

Definition at line 45 of file pyG4VisManager.cc.

                                                  { 
    return dynamic_cast<PyG4VisManager*>(fpConcreteInstance);
  }

References G4VVisManager::fpConcreteInstance.

Referenced by export_G4VisManager().

◆ BeginDraw()

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

virtualinherited

Implements G4VVisManager.

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

References G4VisManager::ClearTransientStoreIfMarked(), G4VisManager::fDrawGroupNestingDepth, G4VisManager::fIsDrawGroup, G4VisManager::fpSceneHandler, G4Exception(), G4VisManager::IsValidView(), G4Threading::IsWorkerThread(), and JustWarning.

◆ BeginDraw2D()

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

virtualinherited

Implements G4VVisManager.

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

References G4VisManager::ClearTransientStoreIfMarked(), G4VisManager::fDrawGroupNestingDepth, G4VisManager::fIsDrawGroup, G4VisManager::fpSceneHandler, G4Exception(), G4VisManager::IsValidView(), G4Threading::IsWorkerThread(), and JustWarning.

◆ BeginOfEvent()

void G4VisManager::BeginOfEvent ( )

privateinherited

Definition at line 1964 of file G4VisManager.cc.

{
  if (fIgnoreStateChanges) return;
 
  if (!GetConcreteInstance()) 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
}

References G4VisManager::fIgnoreStateChanges, G4VisManager::fpSceneHandler, G4VisManager::fTransientsDrawnThisEvent, G4VVisManager::GetConcreteInstance(), and G4VSceneHandler::SetTransientsDrawnThisEvent().

◆ BeginOfRun()

void G4VisManager::BeginOfRun ( )

privateinherited

Definition at line 1906 of file G4VisManager.cc.

{
  if (fIgnoreStateChanges) return;
 
#ifdef G4MULTITHREADED
  if (G4Threading::IsWorkerThread()) return;
#endif
  //  G4cout << "G4VisManager::BeginOfRun: thread: "
  //  << G4Threading::G4GetThreadId() << G4endl;
 
  G4RunManager* runManager = G4RunManagerFactory::GetMasterRunManager();
 
  // For a fake run...
  G4int nEventsToBeProcessed = runManager->GetNumberOfEventsToBeProcessed();
  if (nEventsToBeProcessed == 0) return;
 
  fNKeepRequests = 0;
  fEventKeepingSuspended = false;
  fTransientsDrawnThisRun = false;
  if (fpSceneHandler) fpSceneHandler->SetTransientsDrawnThisRun(false);
  fNoOfEventsDrawnThisRun = 0;
 
  // Check to see if the user has created a trajectory model. If not, create
  // a default one. To avoid code duplication the following function is used
  // and its result (a const G4VTrajectoryModel*) is thrown away at this point.
  // The function is called again later when needed.
  CurrentTrajDrawModel();
 
#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
}

References G4VisManager::CurrentTrajDrawModel(), G4VisManager::fEventKeepingSuspended, G4VisManager::fIgnoreStateChanges, G4VisManager::fNKeepRequests, G4VisManager::fNoOfEventsDrawnThisRun, G4VisManager::fpSceneHandler, G4VisManager::fpViewer, G4VisManager::fTransientsDrawnThisRun, G4MUTEXLOCK, G4MUTEXUNLOCK, G4THREADCREATE(), G4RunManagerFactory::GetMasterRunManager(), G4RunManager::GetNumberOfEventsToBeProcessed(), G4Threading::IsMultithreadedApplication(), G4Threading::IsWorkerThread(), and G4VSceneHandler::SetTransientsDrawnThisRun().

◆ ClearTransientStoreIfMarked()

void G4VisManager::ClearTransientStoreIfMarked ( )

privateinherited

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

References G4VSceneHandler::ClearTransientStore(), G4VisManager::fpSceneHandler, G4VisManager::fTransientsDrawnThisEvent, G4VisManager::fTransientsDrawnThisRun, G4VSceneHandler::GetMarkForClearingTransientStore(), G4VSceneHandler::GetTransientsDrawnThisEvent(), G4VSceneHandler::GetTransientsDrawnThisRun(), and G4VSceneHandler::SetMarkForClearingTransientStore().

Referenced by G4VisManager::BeginDraw(), G4VisManager::BeginDraw2D(), G4VisManager::Draw(), G4VisManager::DrawT(), G4VisManager::DrawT2D(), and G4VisManager::EndOfEvent().

◆ CreateSceneHandler()

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

inherited

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

References G4VisManager::CreateSceneHandler(), G4VisManager::errors, G4VisManager::fAvailableSceneHandlers, G4VisManager::fInitialised, G4VisManager::fpGraphicsSystem, G4VisManager::fpSceneHandler, G4VisManager::fVerbosity, G4cout, G4endl, G4VisManager::Initialise(), G4InuclParticleNames::name(), and G4VisManager::PrintInvalidPointers().

Referenced by G4VisManager::CreateSceneHandler().

◆ CreateViewer()

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

inherited

Definition at line 1156 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: null pointer 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 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) {
      G4cerr << "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) {
    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;
      }
    }
  }
}

References G4VisManager::confirmations, G4VisManager::CreateViewer(), G4VisManager::errors, G4VisManager::fInitialised, G4VisManager::fpGraphicsSystem, G4VisManager::fpSceneHandler, G4VisManager::fpViewer, G4VisManager::fVerbosity, G4cerr, G4cout, G4endl, G4VViewer::GetViewParameters(), G4VisManager::Initialise(), G4ViewParameters::IsCulling(), G4ViewParameters::IsCullingCovered(), G4ViewParameters::IsCullingInvisible(), G4InuclParticleNames::name(), G4VisManager::parameters, G4VisManager::PrintInvalidPointers(), G4VisManager::SetCurrentViewer(), G4ViewParameters::SetXGeometryString(), and G4VisManager::warnings.

Referenced by G4VisManager::CreateViewer().

◆ CurrentTrajDrawModel()

const G4VTrajectoryModel * G4VisManager::CurrentTrajDrawModel ( ) const

inherited

Definition at line 759 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) {
      G4cout<<"G4VisManager: Using G4TrajectoryDrawByCharge as fallback 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;
}

References G4VisModelManager< Model >::Current(), G4VisManager::fpTrajDrawModelMgr, G4VisManager::fVerbosity, G4cout, G4endl, G4VisModelManager< Model >::Register(), and G4VisManager::warnings.

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

◆ Disable()

void G4VisManager::Disable ( )

inherited

Definition at line 690 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) {
    G4cout <<
      "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;
    }
  }
}

References G4VisManager::confirmations, G4VisManager::fVerbosity, G4cout, G4endl, G4RunManagerKernel::GetRunManagerKernel(), G4TrackingManager::GetStoreTrajectory(), G4RunManagerKernel::GetTrackingManager(), G4VVisManager::SetConcreteInstance(), and G4VisManager::warnings.

Referenced by G4VisCommandEnable::SetNewValue(), and G4VisCommandReviewKeptEvents::SetNewValue().

◆ DispatchToModel()

void G4VisManager::DispatchToModel ( const G4VTrajectory & trajectory )

virtualinherited

Implements G4VVisManager.

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

References G4VisManager::CurrentTrajDrawModel(), G4VTrajectoryModel::Draw(), G4VisManager::FilterTrajectory(), G4VisManager::fpTrajDrawModelMgr, G4VisManager::fpTrajFilterMgr, G4VisFilterManager< T >::GetMode(), G4VisManager::IsValidView(), and FilterMode::Soft.

◆ Draw() [1/12]

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

virtualinherited

Implements G4VVisManager.

Definition at line 950 of file G4VisManager.cc.

{
  DrawT (circle, objectTransform);
}

References G4VisManager::DrawT().

Referenced by G4VisManager::Draw(), and G4VVisCommand::DrawExtent().

◆ Draw() [2/12]

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

virtualinherited

Implements G4VVisManager.

Definition at line 1081 of file G4VisManager.cc.

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

References G4VisManager::Draw(), G4LogicalVolume::GetSolid(), and G4Threading::IsWorkerThread().

◆ Draw() [3/12]

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

virtualinherited

Implements G4VVisManager.

Definition at line 956 of file G4VisManager.cc.

{
  DrawT (polyhedron, objectTransform);
}

References G4VisManager::DrawT().

◆ Draw() [4/12]

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

virtualinherited

Implements G4VVisManager.

Definition at line 962 of file G4VisManager.cc.

{
  DrawT (line, objectTransform);
}

References G4VisManager::DrawT().

◆ Draw() [5/12]

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

virtualinherited

Implements G4VVisManager.

Definition at line 968 of file G4VisManager.cc.

{
  DrawT (polymarker, objectTransform);
}

References G4VisManager::DrawT().

◆ Draw() [6/12]

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

virtualinherited

Implements G4VVisManager.

Definition at line 974 of file G4VisManager.cc.

{
  DrawT (square, objectTransform);
}

References G4VisManager::DrawT().

◆ Draw() [7/12]

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

virtualinherited

Implements G4VVisManager.

Definition at line 980 of file G4VisManager.cc.

{
  DrawT (text, objectTransform);
}

References G4VisManager::DrawT().

◆ Draw() [8/12]

void G4VisManager::Draw ( const G4VDigi & digi )

virtualinherited

Implements G4VVisManager.

Definition at line 1036 of file G4VisManager.cc.

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

References G4VisManager::ClearTransientStoreIfMarked(), G4VisManager::fIsDrawGroup, G4VisManager::fpSceneHandler, G4VisManager::IsValidView(), and G4Threading::IsWorkerThread().

◆ Draw() [9/12]

void G4VisManager::Draw ( const G4VHit & hit )

virtualinherited

Implements G4VVisManager.

Definition at line 1022 of file G4VisManager.cc.

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

References G4VisManager::ClearTransientStoreIfMarked(), G4VisManager::fIsDrawGroup, G4VisManager::fpSceneHandler, G4VisManager::IsValidView(), and G4Threading::IsWorkerThread().

◆ Draw() [10/12]

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

virtualinherited

Implements G4VVisManager.

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

References G4VisManager::Draw(), G4VPhysicalVolume::GetLogicalVolume(), and G4Threading::IsWorkerThread().

◆ Draw() [11/12]

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

virtualinherited

Implements G4VVisManager.

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

References G4VisManager::ClearTransientStoreIfMarked(), G4VSolid::DescribeYourselfTo(), G4VisManager::fIsDrawGroup, G4VisManager::fpSceneHandler, G4VisManager::IsValidView(), and G4Threading::IsWorkerThread().

◆ Draw() [12/12]

void G4VisManager::Draw ( const G4VTrajectory & traj )

virtualinherited

Implements G4VVisManager.

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

References G4VisManager::ClearTransientStoreIfMarked(), G4VisManager::fIsDrawGroup, G4VisManager::fpSceneHandler, G4EventManager::GetConstCurrentEvent(), G4RunManager::GetCurrentRun(), G4Event::GetEventID(), G4EventManager::GetEventManager(), G4RunManagerFactory::GetMasterRunManager(), G4Run::GetRunID(), G4VisManager::IsValidView(), G4Threading::IsWorkerThread(), G4TrajectoriesModel::SetCurrentTrajectory(), G4TrajectoriesModel::SetEventID(), and G4TrajectoriesModel::SetRunID().

◆ Draw2D() [1/6]

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

virtualinherited

Implements G4VVisManager.

Definition at line 986 of file G4VisManager.cc.

{
  DrawT2D (circle, objectTransform);
}

References G4VisManager::DrawT2D().

◆ Draw2D() [2/6]

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

virtualinherited

Implements G4VVisManager.

Definition at line 992 of file G4VisManager.cc.

{
  DrawT2D (polyhedron, objectTransform);
}

References G4VisManager::DrawT2D().

◆ Draw2D() [3/6]

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

virtualinherited

Implements G4VVisManager.

Definition at line 998 of file G4VisManager.cc.

{
  DrawT2D (line, objectTransform);
}

References G4VisManager::DrawT2D().

◆ Draw2D() [4/6]

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

virtualinherited

Implements G4VVisManager.

Definition at line 1004 of file G4VisManager.cc.

{
  DrawT2D (polymarker, objectTransform);
}

References G4VisManager::DrawT2D().

◆ Draw2D() [5/6]

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

virtualinherited

Implements G4VVisManager.

Definition at line 1010 of file G4VisManager.cc.

{
  DrawT2D (square, objectTransform);
}

References G4VisManager::DrawT2D().

◆ Draw2D() [6/6]

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

virtualinherited

Implements G4VVisManager.

Definition at line 1016 of file G4VisManager.cc.

{
  DrawT2D (text, objectTransform);
}

References G4VisManager::DrawT2D().

◆ DrawT()

template<class T >

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

privateinherited

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

References G4VisManager::ClearTransientStoreIfMarked(), FatalException, G4VisManager::fIsDrawGroup, G4VisManager::fpSceneHandler, G4Exception(), G4VSceneHandler::GetObjectTransformation(), G4VisManager::IsValidView(), and G4Threading::IsWorkerThread().

Referenced by G4VisManager::Draw().

◆ DrawT2D()

template<class T >

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

privateinherited

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

References G4VisManager::ClearTransientStoreIfMarked(), FatalException, G4VisManager::fIsDrawGroup, G4VisManager::fpSceneHandler, G4Exception(), G4VSceneHandler::GetObjectTransformation(), G4VisManager::IsValidView(), and G4Threading::IsWorkerThread().

Referenced by G4VisManager::Draw2D().

◆ Enable()

void G4VisManager::Enable ( )

inherited

Definition at line 662 of file G4VisManager.cc.

                          {
  if (IsValidView ()) {
    SetConcreteInstance(this);
    if (fVerbosity >= confirmations) {
      G4cout << "G4VisManager::Enable: visualization enabled." << G4endl;
    }
    if (fVerbosity >= warnings) {
      G4int nKeptEvents = 0;
      const G4Run* run = G4RunManager::GetRunManager()->GetCurrentRun();
      if (run) nKeptEvents = run->GetEventVector()->size();
      G4cout <<
  "There are " << nKeptEvents << " kept events."
  "\n  \"/vis/reviewKeptEvents\" to review them one by one."
  "\n  \"/vis/viewer/flush\" or \"/vis/viewer/rebuild\" to see them accumulated."
      << 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;
    }
  }
}

References G4VisManager::confirmations, G4VisManager::fVerbosity, G4cout, G4endl, G4RunManager::GetCurrentRun(), G4RunManager::GetRunManager(), G4VisManager::IsValidView(), G4VVisManager::SetConcreteInstance(), and G4VisManager::warnings.

Referenced by G4VisCommandEnable::SetNewValue(), and G4VisCommandReviewKeptEvents::SetNewValue().

◆ EndDraw()

void G4VisManager::EndDraw ( )

virtualinherited

Implements G4VVisManager.

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

References G4VisManager::fDrawGroupNestingDepth, G4VisManager::fIsDrawGroup, G4VisManager::fpSceneHandler, G4VisManager::IsValidView(), and G4Threading::IsWorkerThread().

◆ EndDraw2D()

void G4VisManager::EndDraw2D ( )

virtualinherited

Implements G4VVisManager.

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

References G4VisManager::fDrawGroupNestingDepth, G4VisManager::fIsDrawGroup, G4VisManager::fpSceneHandler, G4VisManager::IsValidView(), and G4Threading::IsWorkerThread().

◆ EndOfEvent()

void G4VisManager::EndOfEvent ( )

privateinherited

Definition at line 1981 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 = G4RunManagerFactory::GetMasterRunManager();
 
  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;
 
  // Discard event if fDrawEventOnlyIfToBeKept flag is set unless the
  // user has requested the event to be kept.
  if (fDrawEventOnlyIfToBeKept) {
    if (!currentEvent->ToBeKept()) 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...
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        //      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();
      if (fpScene->GetRefreshAtEndOfEvent()) {
        // Keep one event (cannot know which is last so any will do)
        if (fNKeepRequests == 0) {
          eventManager->KeepTheCurrentEvent();
          fNKeepRequests++;
        }
      }
      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 is flushed to the screen.  It also
        // triggers other features such picking (if enabled) 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++;
        }
      }
      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++;
      }
      
    }
  }
}

References G4INCL::DeuteronDensity::anonymous_namespace{G4INCLDeuteronDensity.cc}::al, G4VisManager::ClearTransientStoreIfMarked(), G4VSceneHandler::DrawEvent(), G4VisManager::fDrawEventOnlyIfToBeKept, G4VisManager::fEventKeepingSuspended, G4VisManager::fIgnoreStateChanges, G4VisManager::fNKeepRequests, G4VisManager::fNoOfEventsDrawnThisRun, G4VisManager::fpScene, G4VisManager::fpSceneHandler, G4VisManager::fpViewer, G4VisManager::fVerbosity, G4cout, G4endl, G4MUTEXLOCK, G4MUTEXUNLOCK, G4VVisManager::GetConcreteInstance(), G4EventManager::GetConstCurrentEvent(), G4RunManager::GetCurrentRun(), G4Event::GetEventID(), G4EventManager::GetEventManager(), G4Run::GetEventVector(), G4RunManagerFactory::GetMasterRunManager(), G4Scene::GetMaxNumberOfKeptEvents(), G4RunManager::GetNumberOfEventsToBeProcessed(), G4Scene::GetRefreshAtEndOfEvent(), G4Threading::IsMultithreadedApplication(), G4VisManager::IsValidView(), G4Event::KeepForPostProcessing(), G4EventManager::KeepTheCurrentEvent(), G4VSceneHandler::SetMarkForClearingTransientStore(), G4VViewer::ShowView(), G4Event::ToBeKept(), and G4VisManager::warnings.

◆ EndOfRun()

void G4VisManager::EndOfRun ( )

privateinherited

Definition at line 2189 of file G4VisManager.cc.

{
  if (fIgnoreStateChanges) return;
 
#ifdef G4MULTITHREADED
  if (G4Threading::IsWorkerThread()) return;
#endif
 
  //  G4cout << "G4VisManager::EndOfRun: thread: "
  //  << G4Threading::G4GetThreadId() << G4endl;
 
  G4RunManager* runManager = G4RunManagerFactory::GetMasterRunManager();
 
  // 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
  // Print warning about discarded events, if any.
  // Don't call IsValidView unless there is a scene handler.  This
  // avoids WARNING message from IsValidView() when the user has
  // not instantiated a scene handler, e.g., in batch mode.
  if (fpSceneHandler && IsValidView()) {  // 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 (fVerbosity >= warnings) {
    G4cout << 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 << "1 keep request was";
      } else {
        G4cout << fNKeepRequests << " keep requests were";
      }
      G4cout << " made by the vis manager.";
      if (fNKeepRequests == 0) {
        G4cout <<
        "\n  The kept events are those you have asked to be kept in your user action(s).)";
      } else {
        G4cout <<
        "\n  The same or further events may have been kept by you in your user action(s).)";
      }
      G4cout << G4endl;
    }
    G4cout <<
    "  \"/vis/reviewKeptEvents\" to review them one by one."
    "\n  \"/vis/enable\", then \"/vis/viewer/flush\" or \"/vis/viewer/rebuild\" to see them accumulated."
    << 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  (You may need \"/vis/viewer/flush\" or even \"/vis/viewer/rebuild\".)"
    //  "\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();
        // An extra refresh for auto-refresh viewers.
        // ???? I DON'T WHY THIS IS NECESSARY ???? JA ????
        if (fpViewer->GetViewParameters().IsAutoRefresh()) {
          fpViewer->RefreshView();
        }
        // ShowView guarantees the view is flushed to the screen.  It also
        // triggers other features such picking (if enabled) and allows
        // file-writing viewers to close the file.
        fpViewer->ShowView();
    fpSceneHandler->SetMarkForClearingTransientStore(true);
      } else {
        if (fpGraphicsSystem->GetFunctionality() ==
            G4VGraphicsSystem::fileWriter) {
          if (fVerbosity >= warnings) {
            G4cout << "\"/vis/viewer/update\" to close file." << G4endl;
          }
        }
      }
//    }
  }
  fEventRefreshing = false;
}

References G4VSceneHandler::DrawEndOfRunModels(), G4VisManager::fEventKeepingSuspended, G4VisManager::fEventRefreshing, G4VisManager::fIgnoreStateChanges, G4VGraphicsSystem::fileWriter, G4VisManager::fNKeepRequests, G4VisManager::fNoOfEventsDrawnThisRun, G4VisManager::fpGraphicsSystem, G4VisManager::fpScene, G4VisManager::fpSceneHandler, G4VisManager::fpViewer, G4VisManager::fVerbosity, G4cout, G4endl, G4MUTEXLOCK, G4MUTEXUNLOCK, G4THREADJOIN, G4VVisManager::GetConcreteInstance(), G4RunManager::GetCurrentRun(), G4Run::GetEventVector(), G4VGraphicsSystem::GetFunctionality(), G4RunManagerFactory::GetMasterRunManager(), G4Scene::GetMaxNumberOfKeptEvents(), G4RunManager::GetNumberOfEventsToBeProcessed(), G4Scene::GetRefreshAtEndOfRun(), G4VViewer::GetViewParameters(), G4ViewParameters::IsAutoRefresh(), G4Threading::IsMultithreadedApplication(), G4VisManager::IsValidView(), G4Threading::IsWorkerThread(), G4VViewer::RefreshView(), G4VSceneHandler::SetMarkForClearingTransientStore(), G4VViewer::ShowView(), and G4VisManager::warnings.

◆ FilterDigi()

G4bool G4VisManager::FilterDigi ( const G4VDigi & digi )

virtualinherited

Implements G4VVisManager.

Definition at line 1384 of file G4VisManager.cc.

{
  return fpDigiFilterMgr->Accept(digi);
}   

References G4VisFilterManager< T >::Accept(), and G4VisManager::fpDigiFilterMgr.

◆ FilterHit()

G4bool G4VisManager::FilterHit ( const G4VHit & hit )

virtualinherited

Implements G4VVisManager.

Definition at line 1379 of file G4VisManager.cc.

{
  return fpHitFilterMgr->Accept(hit);
}   

References G4VisFilterManager< T >::Accept(), and G4VisManager::fpHitFilterMgr.

◆ FilterTrajectory()

G4bool G4VisManager::FilterTrajectory ( const G4VTrajectory & trajectory )

virtualinherited

Implements G4VVisManager.

Definition at line 1374 of file G4VisManager.cc.

{
  return fpTrajFilterMgr->Accept(trajectory);
}   

References G4VisFilterManager< T >::Accept(), and G4VisManager::fpTrajFilterMgr.

Referenced by G4VisManager::DispatchToModel().

◆ GeometryHasChanged()

void G4VisManager::GeometryHasChanged ( )

virtualinherited

Implements G4VVisManager.

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

References G4Scene::CalculateExtent(), G4VSceneHandler::ClearStore(), G4VSceneHandler::ClearTransientStore(), G4VViewer::ClearView(), G4VisManager::confirmations, G4VViewer::FinishView(), G4VisManager::fpScene, G4VisManager::fpSceneHandler, G4VisManager::fpViewer, G4VisManager::fSceneList, G4VisManager::fVerbosity, G4cout, G4endl, G4Scene::GetName(), G4TransportationManager::GetTransportationManager(), G4UImanager::GetUIpointer(), G4VViewer::NeedKernelVisit(), G4VViewer::SetView(), and G4VisManager::warnings.

◆ GetAbortReviewKeptEvents()

G4bool G4VisManager::GetAbortReviewKeptEvents ( ) const

inherited

Referenced by G4VisCommandReviewKeptEvents::SetNewValue().

◆ GetAvailableGraphicsSystems()

const G4GraphicsSystemList & G4VisManager::GetAvailableGraphicsSystems ( )

inherited

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

References G4VisManager::fAvailableGraphicsSystems, G4VisManager::fVerbosity, G4cout, G4endl, and G4VisManager::warnings.

◆ GetAvailableSceneHandlers()

const G4SceneHandlerList & G4VisManager::GetAvailableSceneHandlers ( ) const

inherited

◆ GetConcreteInstance()

G4VVisManager * G4VVisManager::GetConcreteInstance ( )

staticinherited

Definition at line 41 of file G4VVisManager.cc.

{
  return fpConcreteInstance;
}

References G4VVisManager::fpConcreteInstance.

◆ GetCurrentGraphicsSystem()

G4VGraphicsSystem * G4VisManager::GetCurrentGraphicsSystem ( ) const

inherited

Referenced by G4VisCommandDrawTree::SetNewValue().

◆ GetCurrentScene()

G4Scene * G4VisManager::GetCurrentScene ( ) const

inherited

◆ GetCurrentSceneHandler()

G4VSceneHandler * G4VisManager::GetCurrentSceneHandler ( ) const

inherited

Referenced by G4RayTrajectory::AppendStep(), G4ToolsSGSceneHandler::Messenger::SetNewValue(), G4VisCommandDrawTree::SetNewValue(), G4VisCommandSceneActivateModel::SetNewValue(), G4VisCommandSceneEndOfEventAction::SetNewValue(), G4VisCommandSceneEndOfRunAction::SetNewValue(), G4VisCommandSceneRemoveModel::SetNewValue(), G4VisCommandsTouchable::SetNewValue(), and G4RTSteppingAction::UserSteppingAction().

◆ GetCurrentViewer()

G4VViewer * G4VisManager::GetCurrentViewer ( ) const

inherited

◆ GetDefaultViewParameters()

const G4ViewParameters & G4VisManager::GetDefaultViewParameters ( ) const

inherited

Referenced by G4VViewer::G4VViewer(), G4VisCommandViewerDefaultHiddenEdge::SetNewValue(), and G4VisCommandViewerDefaultStyle::SetNewValue().

◆ GetDrawEventOnlyIfToBeKept()

G4bool G4VisManager::GetDrawEventOnlyIfToBeKept ( ) const

inherited

Referenced by G4VisCommandDrawOnlyToBeKeptEvents::SetNewValue().

◆ GetEndOfEventUserVisActions()

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

inherited

Referenced by G4VisCommandSceneAddUserAction::SetNewValue().

◆ GetEndOfRunUserVisActions()

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

inherited

Referenced by G4VisCommandSceneAddUserAction::SetNewValue().

◆ GetInstance()

G4VisManager * G4VisManager::GetInstance ( )

staticinherited

Definition at line 244 of file G4VisManager.cc.

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

References FatalException, G4VisManager::fpInstance, and G4Exception().

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

◆ GetNKeepRequests()

G4int G4VisManager::GetNKeepRequests ( ) const

inherited

◆ GetRequestedEvent()

const G4Event * G4VisManager::GetRequestedEvent ( ) const

inherited

Referenced by G4VSceneHandler::ProcessScene().

◆ GetReviewingKeptEvents()

G4bool G4VisManager::GetReviewingKeptEvents ( ) const

inherited

Referenced by G4VisCommandSceneAddEventID::EventID::operator()(), and G4VisCommandReviewKeptEvents::SetNewValue().

◆ GetRunDurationUserVisActions()

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

inherited

Referenced by G4VisCommandSceneAddUserAction::SetNewValue().

◆ GetSceneList()

const G4SceneList & G4VisManager::GetSceneList ( ) const

inherited

Referenced by G4VVisCommandGeometrySet::Set().

◆ GetTransientsDrawnThisEvent()

G4bool G4VisManager::GetTransientsDrawnThisEvent ( ) const

inherited

◆ GetTransientsDrawnThisRun()

G4bool G4VisManager::GetTransientsDrawnThisRun ( ) const

inherited

◆ GetUserVisActionExtents()

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

inherited

Referenced by G4VisCommandSceneAddUserAction::AddVisAction().

◆ GetVerbosity()

G4VisManager::Verbosity G4VisManager::GetVerbosity ( )

staticinherited

Definition at line 2450 of file G4VisManager.cc.

                                                  {
  return fVerbosity;
}

References G4VisManager::fVerbosity.

◆ GetVerbosityValue() [1/2]

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

staticinherited

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

References G4VisManager::all, G4VisManager::confirmations, G4VisManager::errors, G4cerr, G4endl, G4VisManager::GetVerbosityValue(), G4VisManager::parameters, G4VisManager::quiet, G4VisManager::startup, G4StrUtil::to_lower_copy(), G4VisManager::VerbosityGuidanceStrings, G4VisManager::VerbosityString(), and G4VisManager::warnings.

Referenced by G4VisManager::G4VisManager(), G4VisManager::GetVerbosityValue(), G4VisCommandList::SetNewValue(), G4VisCommandVerbose::SetNewValue(), G4VisCommandSceneList::SetNewValue(), G4VisCommandSceneHandlerList::SetNewValue(), G4VisCommandViewerList::SetNewValue(), and G4VisManager::SetVerboseLevel().

◆ GetVerbosityValue() [2/2]

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

staticinherited

Definition at line 2442 of file G4VisManager.cc.

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

References G4VisManager::all, and G4VisManager::quiet.

◆ GetViewer()

G4VViewer * G4VisManager::GetViewer ( const G4String & viewerName ) const

inherited

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

References G4VisManager::fAvailableSceneHandlers, and G4VisManager::ViewerShortName().

Referenced by G4VisCommandsViewerSet::SetNewValue().

◆ IgnoreStateChanges()

void G4VisManager::IgnoreStateChanges ( G4bool val )

virtualinherited

Reimplemented from G4VVisManager.

Definition at line 2588 of file G4VisManager.cc.

{
  fIgnoreStateChanges = val; 
}

References G4VisManager::fIgnoreStateChanges.

◆ Initialise()

void G4VisManager::Initialise ( )

inherited

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

References G4VisManager::fDirectoryList, G4VisManager::fInitialised, G4VisManager::fVerbosity, G4cout, G4endl, G4VisManager::InitialiseG4ColourMap(), G4VisManager::parameters, G4VisManager::PrintAvailableGraphicsSystems(), G4VisManager::PrintAvailableModels(), G4VisManager::PrintAvailableUserVisActions(), G4VisManager::RegisterGraphicsSystems(), G4VisManager::RegisterMessengers(), G4VisManager::RegisterModelFactories(), G4VisManager::startup, and G4VisManager::warnings.

Referenced by G4VisManager::CreateSceneHandler(), G4VisManager::CreateViewer(), and G4VisManager::IsValidView().

◆ InitialiseG4ColourMap()

void G4VisManager::InitialiseG4ColourMap ( ) const

privateinherited

Definition at line 366 of file G4VisManager.cc.

{
  G4Colour::InitialiseColourMap();  // Initialises (if not already initialised)
 
  // our forever 65 named colors taken long time ago from X11.
  // Extracted from g4tools/include/tools/colors
  // Copyright (C) 2010, Guy Barrand. All rights reserved.
  // See the file tools.license for terms.
 
#define TOOLS_COLORS_STAT(name,r,g,b) \
G4Colour::AddToMap(#name, G4Colour(r,g,b));
 
  //0-9
  TOOLS_COLORS_STAT(aquamarine,0.496101F,0.996109F,0.828138F)
  TOOLS_COLORS_STAT(mediumaquamarine,0.398444F,0.800793F,0.664073F)
  //  TOOLS_COLORS_STAT(black,0,0,0) (already defined)
  //  TOOLS_COLORS_STAT(blue,0,0,1) (already defined)
  TOOLS_COLORS_STAT(cadetblue,0.371099F,0.617197F,0.62501F)
  TOOLS_COLORS_STAT(cornflowerblue,0.390631F,0.58204F,0.925795F)
  TOOLS_COLORS_STAT(darkslateblue,0.281254F,0.238285F,0.542977F)
  TOOLS_COLORS_STAT(lightblue,0.675792F,0.843763F,0.898451F)
  TOOLS_COLORS_STAT(lightsteelblue,0.68751F,0.765637F,0.867201F)
  TOOLS_COLORS_STAT(mediumblue,0,0,0.800793F)
 
  //10-19
  TOOLS_COLORS_STAT(mediumslateblue,0.480476F,0.406256F,0.929702F)
  TOOLS_COLORS_STAT(midnightblue,0.0976577F,0.0976577F,0.437507F)
  TOOLS_COLORS_STAT(navyblue,0,0,0.500008F)
  TOOLS_COLORS_STAT(navy,0,0,0.500008F)
  TOOLS_COLORS_STAT(skyblue,0.527352F,0.8047F,0.917983F)
  TOOLS_COLORS_STAT(slateblue,0.414069F,0.351568F,0.800793F)
  TOOLS_COLORS_STAT(steelblue,0.273442F,0.50782F,0.703136F)
  TOOLS_COLORS_STAT(coral,0.996109F,0.496101F,0.312505F)
  //  TOOLS_COLORS_STAT(cyan,0,1,1) (already defined)
  TOOLS_COLORS_STAT(firebrick,0.695323F,0.132815F,0.132815F)
 
  //20-29
  //  TOOLS_COLORS_STAT(brown,0.644541F,0.164065F,0.164065F) (already defined)
  TOOLS_COLORS_STAT(gold,0.996109F,0.839857F,0)
  TOOLS_COLORS_STAT(goldenrod,0.851575F,0.644541F,0.125002F)
  //  TOOLS_COLORS_STAT(green,0,1,0) (already defined)
  TOOLS_COLORS_STAT(darkgreen,0,0.390631F,0)
  TOOLS_COLORS_STAT(darkolivegreen,0.332036F,0.417975F,0.183597F)
  TOOLS_COLORS_STAT(forestgreen,0.132815F,0.542977F,0.132815F)
  TOOLS_COLORS_STAT(limegreen,0.195315F,0.800793F,0.195315F)
  TOOLS_COLORS_STAT(mediumseagreen,0.234379F,0.699229F,0.441413F)
  TOOLS_COLORS_STAT(mediumspringgreen,0,0.976577F,0.601572F)
 
  //30-39
  TOOLS_COLORS_STAT(palegreen,0.593759F,0.980484F,0.593759F)
  TOOLS_COLORS_STAT(seagreen,0.17969F,0.542977F,0.339849F)
  TOOLS_COLORS_STAT(springgreen,0,0.996109F,0.496101F)
  TOOLS_COLORS_STAT(yellowgreen,0.601572F,0.800793F,0.195315F)
  TOOLS_COLORS_STAT(darkslategrey,0.183597F,0.308598F,0.308598F)
  TOOLS_COLORS_STAT(dimgrey,0.410163F,0.410163F,0.410163F)
  TOOLS_COLORS_STAT(lightgrey,0.824231F,0.824231F,0.824231F)
  //  TOOLS_COLORS_STAT(grey,0.750011F,0.750011F,0.750011F) (already defined)
  TOOLS_COLORS_STAT(khaki,0.937514F,0.898451F,0.546883F)
  //  TOOLS_COLORS_STAT(magenta,1,0,1) (already defined)
 
  //40-49
  TOOLS_COLORS_STAT(maroon,0.68751F,0.187503F,0.375006F)
  TOOLS_COLORS_STAT(orange,0.996109F,0.644541F,0)
  TOOLS_COLORS_STAT(orchid,0.851575F,0.437507F,0.83595F)
  TOOLS_COLORS_STAT(darkorchid,0.597665F,0.195315F,0.796887F)
  TOOLS_COLORS_STAT(mediumorchid,0.726574F,0.332036F,0.824231F)
  TOOLS_COLORS_STAT(pink,0.996109F,0.750011F,0.792981F)
  TOOLS_COLORS_STAT(plum,0.863294F,0.62501F,0.863294F)
  //  TOOLS_COLORS_STAT(red,1,0,0) (already defined)
  TOOLS_COLORS_STAT(indianred,0.800793F,0.35938F,0.35938F)
  TOOLS_COLORS_STAT(mediumvioletred,0.777356F,0.0820325F,0.519539F)
 
  //50-59
  TOOLS_COLORS_STAT(orangered,0.996109F,0.269535F,0)
  TOOLS_COLORS_STAT(violetred,0.812512F,0.125002F,0.562509F)
  TOOLS_COLORS_STAT(salmon,0.976577F,0.500008F,0.445319F)
  TOOLS_COLORS_STAT(sienna,0.62501F,0.320317F,0.175784F)
  TOOLS_COLORS_STAT(tan,0.820325F,0.703136F,0.546883F)
  TOOLS_COLORS_STAT(thistle,0.843763F,0.746105F,0.843763F)
  TOOLS_COLORS_STAT(turquoise,0.250004F,0.875013F,0.812512F)
  TOOLS_COLORS_STAT(darkturquoise,0,0.8047F,0.816419F)
  TOOLS_COLORS_STAT(mediumturquoise,0.281254F,0.816419F,0.796887F)
  TOOLS_COLORS_STAT(violet,0.929702F,0.50782F,0.929702F)
 
  //60-64
  TOOLS_COLORS_STAT(blueviolet,0.539071F,0.167971F,0.882826F)
  TOOLS_COLORS_STAT(wheat,0.957046F,0.867201F,0.699229F)
  //  TOOLS_COLORS_STAT(white,1,1,1) (already defined)
  //  TOOLS_COLORS_STAT(yellow,1,1,0) (already defined)
  TOOLS_COLORS_STAT(greenyellow,0.675792F,0.996109F,0.18359F)
 
#undef TOOLS_COLORS_STAT
}

References G4Colour::InitialiseColourMap(), and TOOLS_COLORS_STAT.

Referenced by G4VisManager::Initialise().

◆ Initialize()

void G4VisManager::Initialize ( )

inherited

Referenced by export_G4VisManager(), and G4VisCommandInitialize::SetNewValue().

◆ IsValidView()

G4bool G4VisManager::IsValidView ( )

privateinherited

Definition at line 2462 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) and ensure drawing code is executed only if"
  "\n  G4VVisManager::GetConcreteInstance() 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;
}

References G4UImanager::ApplyCommand(), G4VisManager::errors, G4VisManager::fInitialised, G4VisManager::fpGraphicsSystem, G4VisManager::fpScene, G4VisManager::fpSceneHandler, G4VisManager::fpViewer, G4VisManager::fVerbosity, G4cerr, G4cout, G4endl, G4UImanager::GetUIpointer(), G4VisManager::Initialise(), G4VisManager::PrintInvalidPointers(), and G4VisManager::warnings.

Referenced by G4VisManager::BeginDraw(), G4VisManager::BeginDraw2D(), G4VisManager::DispatchToModel(), G4VisManager::Draw(), G4VisManager::DrawT(), G4VisManager::DrawT2D(), G4VisManager::Enable(), G4VisManager::EndDraw(), G4VisManager::EndDraw2D(), G4VisManager::EndOfEvent(), G4VisManager::EndOfRun(), G4VisManager::NotifyHandlers(), G4VisManager::SetCurrentSceneHandler(), and G4VisManager::SetCurrentViewer().

◆ NotifyHandlers()

void G4VisManager::NotifyHandlers ( )

virtualinherited

Reimplemented from G4VVisManager.

Definition at line 1333 of file G4VisManager.cc.

                                   {
 
  if (fVerbosity >= confirmations) {
    G4cout << "G4VisManager::NotifyHandler() called." << G4endl;
  }
 
  if (IsValidView()) {
 
    // 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 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();
    }
  }
}

References G4Scene::CalculateExtent(), G4VSceneHandler::ClearStore(), G4VSceneHandler::ClearTransientStore(), G4VViewer::ClearView(), G4VisManager::confirmations, G4VViewer::FinishView(), G4VisManager::fpScene, G4VisManager::fpSceneHandler, G4VisManager::fpViewer, G4VisManager::fSceneList, G4VisManager::fVerbosity, G4cout, G4endl, G4Scene::GetName(), G4UImanager::GetUIpointer(), G4VisManager::IsValidView(), G4VViewer::NeedKernelVisit(), G4VViewer::SetView(), and G4VisManager::warnings.

◆ PrintAvailableColours()

void G4VisManager::PrintAvailableColours ( Verbosity ) const

privateinherited

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

References G4cout, G4endl, G4Colour::GetMap(), and anonymous_namespace{G4QuasiElRatios.cc}::map.

Referenced by G4VisCommandList::SetNewValue().

◆ PrintAvailableGraphicsSystems()

void G4VisManager::PrintAvailableGraphicsSystems ( Verbosity verbosity ) const

protectedinherited

Definition at line 1623 of file G4VisManager.cc.

{
  G4cout << "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
        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 << "  NONE!!!  None registered - yet!  Mmmmm!" << G4endl;
  }
}

References G4VisManager::fAvailableGraphicsSystems, G4cout, G4endl, G4InuclParticleNames::name(), and G4VisManager::warnings.

Referenced by G4VisManager::Initialise(), and G4VisCommandList::SetNewValue().

◆ PrintAvailableModels()

void G4VisManager::PrintAvailableModels ( Verbosity verbosity ) const

privateinherited

Definition at line 1651 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);
      }
    }
    G4cout << "\nRegistered models:" << G4endl;
    const G4VisListManager<G4VTrajectoryModel>* listManager =
      fpTrajDrawModelMgr->ListManager();
    const std::map<G4String, G4VTrajectoryModel*>& modelMap =
      listManager->Map();
    if (modelMap.empty()) G4cout << "  None" << G4endl;
    else {
      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);
      }
    }
 
    G4cout << "\nRegistered filters:" << G4endl;
    const std::vector<G4VFilter<G4VTrajectory>*>&
      filterList = fpTrajFilterMgr->FilterList();
    if (filterList.empty()) G4cout << "  None" << G4endl;
    else {
      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);
      }
    }
  }
}

References G4VisListManager< T >::Current(), G4VisFilterManager< T >::FactoryList(), G4VisModelManager< Model >::FactoryList(), G4VisFilterManager< T >::FilterList(), G4VisManager::fpTrajDrawModelMgr, G4VisManager::fpTrajFilterMgr, G4cout, G4endl, G4VisModelManager< Model >::ListManager(), G4VisListManager< T >::Map(), and G4VisManager::parameters.

Referenced by G4VisManager::Initialise(), and G4VisCommandList::SetNewValue().

◆ PrintAvailableUserVisActions()

void G4VisManager::PrintAvailableUserVisActions ( Verbosity ) const

privateinherited

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

References G4VisManager::fEndOfEventUserVisActions, G4VisManager::fEndOfRunUserVisActions, G4VisManager::fRunDurationUserVisActions, G4cout, G4endl, and G4InuclParticleNames::name().

Referenced by G4VisManager::Initialise(), and G4VisCommandList::SetNewValue().

◆ PrintInvalidPointers()

void G4VisManager::PrintInvalidPointers ( ) const

privateinherited

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

References G4VisManager::errors, G4VisManager::fpGraphicsSystem, G4VisManager::fpScene, G4VisManager::fpSceneHandler, G4VisManager::fpViewer, G4VisManager::fVerbosity, G4cerr, and G4endl.

Referenced by G4VisManager::CreateSceneHandler(), G4VisManager::CreateViewer(), and G4VisManager::IsValidView().

◆ RegisterEndOfEventUserVisAction()

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

inherited

Definition at line 1436 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;
    }
  }
  if (fVerbosity >= confirmations) {
    G4cout
    << "End of event user vis action \"" << name << "\" registered"
    << G4endl;
  }
}

References G4VisManager::confirmations, G4VisManager::fEndOfEventUserVisActions, G4VisManager::fUserVisActionExtents, G4VisManager::fVerbosity, G4cout, G4endl, G4VisExtent::GetExtentRadius(), G4InuclParticleNames::name(), and G4VisManager::warnings.

◆ RegisterEndOfRunUserVisAction()

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

inherited

Definition at line 1457 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;
    }
  }
  if (fVerbosity >= confirmations) {
    G4cout
    << "End of run user vis action \"" << name << "\" registered"
    << G4endl;
  }
}

References G4VisManager::confirmations, G4VisManager::fEndOfRunUserVisActions, G4VisManager::fUserVisActionExtents, G4VisManager::fVerbosity, G4cout, G4endl, G4VisExtent::GetExtentRadius(), G4InuclParticleNames::name(), and G4VisManager::warnings.

◆ RegisterGraphicsSystem()

G4bool G4VisManager::RegisterGraphicsSystem ( G4VGraphicsSystem * pSystem )

inherited

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

References G4VisManager::confirmations, G4VisManager::errors, G4VisManager::fAvailableGraphicsSystems, G4VisManager::fVerbosity, G4cout, and G4endl.

Referenced by export_G4VisManager().

◆ RegisterGraphicsSystems()

virtual void PyG4VisManager::RegisterGraphicsSystems ( )

inlinevirtual

Implements G4VisManager.

Definition at line 49 of file pyG4VisManager.cc.

49{ }

◆ RegisterMessenger()

void G4VisManager::RegisterMessenger ( G4UImessenger * messenger )

inherited

Referenced by G4VisManager::G4VisManager(), and G4VisManager::RegisterMessengers().

◆ RegisterMessengers()

void G4VisManager::RegisterMessengers ( )

protectedinherited

Definition at line 460 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);
  
#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 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 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 G4VisCommandDrawOnlyToBeKeptEvents);
  RegisterMessenger(new G4VisCommandDrawTree);
  RegisterMessenger(new G4VisCommandDrawView);
  RegisterMessenger(new G4VisCommandDrawLogicalVolume);
  RegisterMessenger(new G4VisCommandDrawVolume);
  RegisterMessenger(new G4VisCommandEnable);
  RegisterMessenger(new G4VisCommandList);
  RegisterMessenger(new G4VisCommandOpen);
  RegisterMessenger(new G4VisCommandReviewKeptEvents);
  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()));
}

References G4VisManager::fDirectoryList, G4VisManager::fpDigiFilterMgr, G4VisManager::fpHitFilterMgr, G4VisManager::fpTrajDrawModelMgr, G4VisManager::fpTrajFilterMgr, G4VisFilterManager< T >::Placement(), G4VisModelManager< Model >::Placement(), and G4VisManager::RegisterMessenger().

Referenced by G4VisManager::Initialise().

◆ RegisterModel() [1/4]

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

inherited

Definition at line 814 of file G4VisManager.cc.

{
  fpDigiFilterMgr->Register(model);
}

References G4VisManager::fpDigiFilterMgr, and G4VisFilterManager< T >::Register().

◆ RegisterModel() [2/4]

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

inherited

Definition at line 803 of file G4VisManager.cc.

{
  fpHitFilterMgr->Register(model);
}

References G4VisManager::fpHitFilterMgr, and G4VisFilterManager< T >::Register().

◆ RegisterModel() [3/4]

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

inherited

Definition at line 792 of file G4VisManager.cc.

{
  fpTrajFilterMgr->Register(model);
}

References G4VisManager::fpTrajFilterMgr, and G4VisFilterManager< T >::Register().

◆ RegisterModel() [4/4]

void G4VisManager::RegisterModel ( G4VTrajectoryModel * model )

inherited

Definition at line 781 of file G4VisManager.cc.

{
  fpTrajDrawModelMgr->Register(model);
}

References G4VisManager::fpTrajDrawModelMgr, and G4VisModelManager< Model >::Register().

◆ RegisterModelFactories()

virtual void PyG4VisManager::RegisterModelFactories ( )

inlinevirtual

Reimplemented from G4VisManager.

Definition at line 51 of file pyG4VisManager.cc.

                                        {
    RegisterModelFactory(new G4TrajectoryDrawByChargeFactory());
    RegisterModelFactory(new G4TrajectoryDrawByParticleIDFactory());
  }

References G4VisManager::RegisterModelFactory().

◆ RegisterModelFactory() [1/4]

void G4VisManager::RegisterModelFactory ( G4DigiFilterFactory * factory )

inherited

Definition at line 820 of file G4VisManager.cc.

{
  fpDigiFilterMgr->Register(factory);
}

References test::factory, G4VisManager::fpDigiFilterMgr, and G4VisFilterManager< T >::Register().

◆ RegisterModelFactory() [2/4]

void G4VisManager::RegisterModelFactory ( G4HitFilterFactory * factory )

inherited

Definition at line 809 of file G4VisManager.cc.

{
  fpHitFilterMgr->Register(factory);
}

References test::factory, G4VisManager::fpHitFilterMgr, and G4VisFilterManager< T >::Register().

◆ RegisterModelFactory() [3/4]

void G4VisManager::RegisterModelFactory ( G4TrajDrawModelFactory * factory )

inherited

Definition at line 787 of file G4VisManager.cc.

{
  fpTrajDrawModelMgr->Register(factory);
}

References test::factory, G4VisManager::fpTrajDrawModelMgr, and G4VisModelManager< Model >::Register().

Referenced by RegisterModelFactories().

◆ RegisterModelFactory() [4/4]

void G4VisManager::RegisterModelFactory ( G4TrajFilterFactory * factory )

inherited

Definition at line 798 of file G4VisManager.cc.

{
  fpTrajFilterMgr->Register(factory);
}

References test::factory, G4VisManager::fpTrajFilterMgr, and G4VisFilterManager< T >::Register().

◆ RegisterRunDurationUserVisAction()

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

inherited

Definition at line 1415 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;
    }
  }
  if (fVerbosity >= confirmations) {
    G4cout
    << "Run duration user vis action \"" << name << "\" registered"
    << G4endl;
  }
}

References G4VisManager::confirmations, G4VisManager::fRunDurationUserVisActions, G4VisManager::fUserVisActionExtents, G4VisManager::fVerbosity, G4cout, G4endl, G4VisExtent::GetExtentRadius(), G4InuclParticleNames::name(), and G4VisManager::warnings.

◆ ResetTransientsDrawnFlags()

void G4VisManager::ResetTransientsDrawnFlags ( )

inherited

Definition at line 2355 of file G4VisManager.cc.

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

References G4VisManager::fAvailableSceneHandlers, G4VisManager::fTransientsDrawnThisEvent, and G4VisManager::fTransientsDrawnThisRun.

Referenced by G4VisManager::SetCurrentScene(), G4VisCommandSceneEndOfEventAction::SetNewValue(), G4VisCommandSceneEndOfRunAction::SetNewValue(), and G4VisCommandViewerClearTransients::SetNewValue().

◆ SelectTrajectoryModel()

void G4VisManager::SelectTrajectoryModel ( const G4String & model )

inherited

Definition at line 825 of file G4VisManager.cc.

{
   fpTrajDrawModelMgr->SetCurrent(model);
}

References G4VisManager::fpTrajDrawModelMgr, and G4VisModelManager< Model >::SetCurrent().

◆ SetAbortReviewKeptEvents()

void G4VisManager::SetAbortReviewKeptEvents ( G4bool )

inherited

Referenced by G4VisCommandAbortReviewKeptEvents::SetNewValue(), and G4VisCommandReviewKeptEvents::SetNewValue().

◆ SetAvailableSceneHandlers()

G4SceneHandlerList & G4VisManager::SetAvailableSceneHandlers ( )

inherited

◆ SetConcreteInstance()

void G4VVisManager::SetConcreteInstance ( G4VVisManager * man )

staticprotectedinherited

Definition at line 46 of file G4VVisManager.cc.

{
  fpConcreteInstance = man;
}

References G4VVisManager::fpConcreteInstance.

Referenced by G4VisManager::Disable(), G4VisManager::Enable(), and G4VisManager::G4VisManager().

◆ SetCurrentGraphicsSystem()

void G4VisManager::SetCurrentGraphicsSystem ( G4VGraphicsSystem * pSystem )

inherited

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

References G4VisManager::confirmations, G4VisManager::fAvailableSceneHandlers, G4VisManager::fpGraphicsSystem, G4VisManager::fpScene, G4VisManager::fpSceneHandler, G4VisManager::fpViewer, G4VisManager::fVerbosity, G4cout, and G4endl.

Referenced by G4VisCommandDrawTree::SetNewValue().

◆ SetCurrentScene()

void G4VisManager::SetCurrentScene ( G4Scene * pScene )

inherited

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

References G4VisManager::fpScene, and G4VisManager::ResetTransientsDrawnFlags().

Referenced by G4RayTracerSceneHandler::G4RayTracerSceneHandler(), and G4VisCommandDrawTree::SetNewValue().

◆ SetCurrentSceneHandler()

void G4VisManager::SetCurrentSceneHandler ( G4VSceneHandler * pSceneHandler )

inherited

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

References G4VisManager::confirmations, G4VisManager::fpGraphicsSystem, G4VisManager::fpScene, G4VisManager::fpSceneHandler, G4VisManager::fpViewer, G4VisManager::fVerbosity, G4cout, G4endl, G4VisManager::IsValidView(), and G4VisManager::warnings.

Referenced by G4VisCommandDrawTree::SetNewValue().

◆ SetCurrentViewer()

void G4VisManager::SetCurrentViewer ( G4VViewer * pViewer )

inherited

Definition at line 1586 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) {
      G4cout <<
      "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) {
      G4cout <<
    "WARNING: Problem setting viewer - please report circumstances."
         << G4endl;
    }
  }
}

References G4VisManager::confirmations, G4VisManager::fpGraphicsSystem, G4VisManager::fpScene, G4VisManager::fpSceneHandler, G4VisManager::fpViewer, G4VisManager::fVerbosity, G4cout, G4endl, G4VisManager::IsValidView(), G4VisManager::SetCurrentViewer(), and G4VisManager::warnings.

Referenced by G4VisManager::CreateViewer(), G4VisManager::SetCurrentViewer(), and G4VisCommandDrawTree::SetNewValue().

◆ SetDefaultViewParameters()

void G4VisManager::SetDefaultViewParameters ( const G4ViewParameters & )

inherited

Referenced by G4VisCommandViewerDefaultHiddenEdge::SetNewValue(), and G4VisCommandViewerDefaultStyle::SetNewValue().

◆ SetDrawEventOnlyIfToBeKept()

void G4VisManager::SetDrawEventOnlyIfToBeKept ( G4bool )

inherited

Referenced by G4VisCommandDrawOnlyToBeKeptEvents::SetNewValue().

◆ SetEventRefreshing()

void G4VisManager::SetEventRefreshing ( G4bool )

inherited

Referenced by G4VSceneHandler::ProcessScene().

◆ SetRequestedEvent()

void G4VisManager::SetRequestedEvent ( const G4Event * )

inherited

Referenced by G4VisCommandReviewKeptEvents::SetNewValue().

◆ SetReviewingKeptEvents()

void G4VisManager::SetReviewingKeptEvents ( G4bool )

inherited

Referenced by G4VisCommandReviewKeptEvents::SetNewValue().

◆ SetSceneList()

G4SceneList & G4VisManager::SetSceneList ( )

inherited

Referenced by G4RayTracerSceneHandler::G4RayTracerSceneHandler().

◆ SetTransientsDrawnThisEvent()

void G4VisManager::SetTransientsDrawnThisEvent ( G4bool )

inherited

◆ SetTransientsDrawnThisRun()

void G4VisManager::SetTransientsDrawnThisRun ( G4bool )

inherited

◆ SetVerboseLevel() [1/3]

void G4VisManager::SetVerboseLevel ( const G4String & verbosityString )

inherited

Definition at line 2458 of file G4VisManager.cc.

                                                                   {
  fVerbosity = GetVerbosityValue(verbosityString);
}

References G4VisManager::fVerbosity, and G4VisManager::GetVerbosityValue().

◆ SetVerboseLevel() [2/3]

void G4VisManager::SetVerboseLevel ( G4int intVerbosity )

inherited

Definition at line 2454 of file G4VisManager.cc.

                                                      {
  fVerbosity = GetVerbosityValue(intVerbosity);
}

References G4VisManager::fVerbosity, and G4VisManager::GetVerbosityValue().

Referenced by PyG4VisManager(), G4VisCommandVerbose::SetNewValue(), G4VisCommandDrawTree::SetNewValue(), and G4VisCommandViewerInterpolate::SetNewValue().

◆ SetVerboseLevel() [3/3]

void G4VisManager::SetVerboseLevel ( Verbosity )

inherited

◆ VerbosityString()

G4String G4VisManager::VerbosityString ( Verbosity verbosity )

staticinherited

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

References G4VisManager::all, G4VisManager::confirmations, G4VisManager::errors, G4VisManager::parameters, G4VisManager::quiet, G4VisManager::startup, and G4VisManager::warnings.

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

◆ ViewerShortName()

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

inherited

Definition at line 2367 of file G4VisManager.cc.

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

References G4StrUtil::strip_copy().

Referenced by G4VisManager::GetViewer().

Field Documentation

◆ fAbortReviewKeptEvents

G4bool G4VisManager::fAbortReviewKeptEvents

privateinherited

Definition at line 522 of file G4VisManager.hh.

◆ fAvailableGraphicsSystems

G4GraphicsSystemList G4VisManager::fAvailableGraphicsSystems

privateinherited

Definition at line 506 of file G4VisManager.hh.

Referenced by G4VisManager::GetAvailableGraphicsSystems(), G4VisManager::PrintAvailableGraphicsSystems(), G4VisManager::RegisterGraphicsSystem(), and G4VisManager::~G4VisManager().

◆ fAvailableSceneHandlers

G4SceneHandlerList G4VisManager::fAvailableSceneHandlers

privateinherited

Definition at line 508 of file G4VisManager.hh.

Referenced by G4VisManager::CreateSceneHandler(), G4VisManager::GetViewer(), G4VisManager::ResetTransientsDrawnFlags(), G4VisManager::SetCurrentGraphicsSystem(), and G4VisManager::~G4VisManager().

◆ fDefaultViewParameters

G4ViewParameters G4VisManager::fDefaultViewParameters

privateinherited

Definition at line 523 of file G4VisManager.hh.

◆ fDirectoryList

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

privateinherited

Definition at line 511 of file G4VisManager.hh.

Referenced by G4VisManager::G4VisManager(), G4VisManager::Initialise(), G4VisManager::RegisterMessengers(), and G4VisManager::~G4VisManager().

◆ fDrawEventOnlyIfToBeKept

G4bool G4VisManager::fDrawEventOnlyIfToBeKept

privateinherited

Definition at line 519 of file G4VisManager.hh.

Referenced by G4VisManager::EndOfEvent().

◆ fDrawGroupNestingDepth

G4int G4VisManager::fDrawGroupNestingDepth

privateinherited

Definition at line 525 of file G4VisManager.hh.

Referenced by G4VisManager::BeginDraw(), G4VisManager::BeginDraw2D(), G4VisManager::EndDraw(), and G4VisManager::EndDraw2D().

◆ fEndOfEventUserVisActions

std::vector<UserVisAction> G4VisManager::fEndOfEventUserVisActions

privateinherited

Definition at line 499 of file G4VisManager.hh.

Referenced by G4VisManager::PrintAvailableUserVisActions(), and G4VisManager::RegisterEndOfEventUserVisAction().

◆ fEndOfRunUserVisActions

std::vector<UserVisAction> G4VisManager::fEndOfRunUserVisActions

privateinherited

Definition at line 500 of file G4VisManager.hh.

Referenced by G4VisManager::PrintAvailableUserVisActions(), and G4VisManager::RegisterEndOfRunUserVisAction().

◆ fEventKeepingSuspended

G4bool G4VisManager::fEventKeepingSuspended

privateinherited

Definition at line 518 of file G4VisManager.hh.

Referenced by G4VisManager::BeginOfRun(), G4VisManager::EndOfEvent(), and G4VisManager::EndOfRun().

◆ fEventRefreshing

G4bool G4VisManager::fEventRefreshing

privateinherited

Definition at line 513 of file G4VisManager.hh.

Referenced by G4VisManager::EndOfRun().

◆ fIgnoreStateChanges

G4bool G4VisManager::fIgnoreStateChanges

privateinherited

Definition at line 526 of file G4VisManager.hh.

Referenced by G4VisManager::BeginOfEvent(), G4VisManager::BeginOfRun(), G4VisManager::EndOfEvent(), G4VisManager::EndOfRun(), and G4VisManager::IgnoreStateChanges().

◆ fInitialised

G4bool G4VisManager::fInitialised

privateinherited

Definition at line 497 of file G4VisManager.hh.

Referenced by G4VisManager::CreateSceneHandler(), G4VisManager::CreateViewer(), G4VisManager::Initialise(), and G4VisManager::IsValidView().

◆ fIsDrawGroup

G4bool G4VisManager::fIsDrawGroup

privateinherited

Definition at line 524 of file G4VisManager.hh.

Referenced by G4VisManager::BeginDraw(), G4VisManager::BeginDraw2D(), G4VisManager::Draw(), G4VisManager::DrawT(), G4VisManager::DrawT2D(), G4VisManager::EndDraw(), and G4VisManager::EndDraw2D().

◆ fMessengerList

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

privateinherited

Definition at line 510 of file G4VisManager.hh.

Referenced by G4VisManager::~G4VisManager().

◆ fNKeepRequests

G4int G4VisManager::fNKeepRequests

privateinherited

Definition at line 517 of file G4VisManager.hh.

Referenced by G4VisManager::BeginOfRun(), G4VisManager::EndOfEvent(), and G4VisManager::EndOfRun().

◆ fNoOfEventsDrawnThisRun

G4int G4VisManager::fNoOfEventsDrawnThisRun

privateinherited

Definition at line 516 of file G4VisManager.hh.

Referenced by G4VisManager::BeginOfRun(), G4VisManager::EndOfEvent(), and G4VisManager::EndOfRun().

◆ fpConcreteInstance

G4VVisManager * G4VVisManager::fpConcreteInstance = 0

staticprotectedinherited

Definition at line 231 of file G4VVisManager.hh.

Referenced by _get_concrete_instance(), G4VVisManager::GetConcreteInstance(), and G4VVisManager::SetConcreteInstance().

◆ fpDigiFilterMgr

G4VisFilterManager<G4VDigi>* G4VisManager::fpDigiFilterMgr

privateinherited

Definition at line 542 of file G4VisManager.hh.

Referenced by G4VisManager::FilterDigi(), G4VisManager::G4VisManager(), G4VisManager::RegisterMessengers(), G4VisManager::RegisterModel(), G4VisManager::RegisterModelFactory(), and G4VisManager::~G4VisManager().

◆ fpGraphicsSystem

G4VGraphicsSystem* G4VisManager::fpGraphicsSystem

privateinherited

Definition at line 502 of file G4VisManager.hh.

Referenced by G4VisManager::CreateSceneHandler(), G4VisManager::CreateViewer(), G4VisManager::EndOfRun(), G4VisManager::IsValidView(), G4VisManager::PrintInvalidPointers(), G4VisManager::SetCurrentGraphicsSystem(), G4VisManager::SetCurrentSceneHandler(), and G4VisManager::SetCurrentViewer().

◆ fpHitFilterMgr

G4VisFilterManager<G4VHit>* G4VisManager::fpHitFilterMgr

privateinherited

Definition at line 539 of file G4VisManager.hh.

Referenced by G4VisManager::FilterHit(), G4VisManager::G4VisManager(), G4VisManager::RegisterMessengers(), G4VisManager::RegisterModel(), G4VisManager::RegisterModelFactory(), and G4VisManager::~G4VisManager().

◆ fpInstance

G4VisManager * G4VisManager::fpInstance = 0

staticprivateinherited

Definition at line 496 of file G4VisManager.hh.

Referenced by G4VisManager::G4VisManager(), G4VisManager::GetInstance(), and G4VisManager::~G4VisManager().

◆ fpRequestedEvent

const G4Event* G4VisManager::fpRequestedEvent

privateinherited

Definition at line 520 of file G4VisManager.hh.

◆ fpScene

G4Scene* G4VisManager::fpScene

privateinherited

Definition at line 503 of file G4VisManager.hh.

Referenced by G4VisManager::EndOfEvent(), G4VisManager::EndOfRun(), G4VisManager::GeometryHasChanged(), G4VisManager::IsValidView(), G4VisManager::NotifyHandlers(), G4VisManager::PrintInvalidPointers(), G4VisManager::SetCurrentGraphicsSystem(), G4VisManager::SetCurrentScene(), G4VisManager::SetCurrentSceneHandler(), and G4VisManager::SetCurrentViewer().

◆ fpSceneHandler

G4VSceneHandler* G4VisManager::fpSceneHandler

privateinherited

◆ fpStateDependent

G4VisStateDependent* G4VisManager::fpStateDependent

privateinherited

Definition at line 512 of file G4VisManager.hh.

Referenced by G4VisManager::G4VisManager().

◆ fpTrajDrawModelMgr

G4VisModelManager<G4VTrajectoryModel>* G4VisManager::fpTrajDrawModelMgr

privateinherited

Definition at line 533 of file G4VisManager.hh.

Referenced by G4VisManager::CurrentTrajDrawModel(), G4VisManager::DispatchToModel(), G4VisManager::G4VisManager(), G4VisManager::PrintAvailableModels(), G4VisManager::RegisterMessengers(), G4VisManager::RegisterModel(), G4VisManager::RegisterModelFactory(), G4VisManager::SelectTrajectoryModel(), and G4VisManager::~G4VisManager().

◆ fpTrajFilterMgr

G4VisFilterManager<G4VTrajectory>* G4VisManager::fpTrajFilterMgr

privateinherited

Definition at line 536 of file G4VisManager.hh.

Referenced by G4VisManager::DispatchToModel(), G4VisManager::FilterTrajectory(), G4VisManager::G4VisManager(), G4VisManager::PrintAvailableModels(), G4VisManager::RegisterMessengers(), G4VisManager::RegisterModel(), G4VisManager::RegisterModelFactory(), and G4VisManager::~G4VisManager().

◆ fpViewer

G4VViewer* G4VisManager::fpViewer

privateinherited

Definition at line 505 of file G4VisManager.hh.

Referenced by G4VisManager::BeginOfRun(), G4VisManager::CreateViewer(), G4VisManager::EndOfEvent(), G4VisManager::EndOfRun(), G4VisManager::GeometryHasChanged(), G4VisManager::IsValidView(), G4VisManager::NotifyHandlers(), G4VisManager::PrintInvalidPointers(), G4VisManager::SetCurrentGraphicsSystem(), G4VisManager::SetCurrentSceneHandler(), and G4VisManager::SetCurrentViewer().

◆ fReviewingKeptEvents

G4bool G4VisManager::fReviewingKeptEvents

privateinherited

Definition at line 521 of file G4VisManager.hh.

◆ fRunDurationUserVisActions

std::vector<UserVisAction> G4VisManager::fRunDurationUserVisActions

privateinherited

Definition at line 498 of file G4VisManager.hh.

Referenced by G4VisManager::PrintAvailableUserVisActions(), and G4VisManager::RegisterRunDurationUserVisAction().

◆ fSceneList

G4SceneList G4VisManager::fSceneList

privateinherited

Definition at line 507 of file G4VisManager.hh.

Referenced by G4VisManager::GeometryHasChanged(), G4VisManager::NotifyHandlers(), and G4VisManager::~G4VisManager().

◆ fTransientsDrawnThisEvent

G4bool G4VisManager::fTransientsDrawnThisEvent

privateinherited

Definition at line 515 of file G4VisManager.hh.

Referenced by G4VisManager::BeginOfEvent(), G4VisManager::ClearTransientStoreIfMarked(), and G4VisManager::ResetTransientsDrawnFlags().

◆ fTransientsDrawnThisRun

G4bool G4VisManager::fTransientsDrawnThisRun

privateinherited

Definition at line 514 of file G4VisManager.hh.

Referenced by G4VisManager::BeginOfRun(), G4VisManager::ClearTransientStoreIfMarked(), and G4VisManager::ResetTransientsDrawnFlags().

◆ fUserVisActionExtents

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

privateinherited

Definition at line 501 of file G4VisManager.hh.

Referenced by G4VisManager::RegisterEndOfEventUserVisAction(), G4VisManager::RegisterEndOfRunUserVisAction(), and G4VisManager::RegisterRunDurationUserVisAction().

◆ fVerbose

const G4int G4VisManager::fVerbose

protectedinherited

Definition at line 468 of file G4VisManager.hh.

◆ fVerbosity

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

staticprivateinherited

Definition at line 509 of file G4VisManager.hh.

Referenced by G4VisManager::CreateSceneHandler(), G4VisManager::CreateViewer(), G4VisManager::CurrentTrajDrawModel(), G4VisManager::Disable(), G4VisManager::Enable(), G4VisManager::EndOfEvent(), G4VisManager::EndOfRun(), G4VisManager::G4VisManager(), G4VisManager::GeometryHasChanged(), G4VisManager::GetAvailableGraphicsSystems(), G4VisManager::GetVerbosity(), G4VisManager::Initialise(), G4VisManager::IsValidView(), G4VisManager::NotifyHandlers(), G4VisManager::PrintInvalidPointers(), G4VisManager::RegisterEndOfEventUserVisAction(), G4VisManager::RegisterEndOfRunUserVisAction(), G4VisManager::RegisterGraphicsSystem(), G4VisManager::RegisterModelFactories(), G4VisManager::RegisterRunDurationUserVisAction(), G4VisManager::SetCurrentGraphicsSystem(), G4VisManager::SetCurrentSceneHandler(), G4VisManager::SetCurrentViewer(), G4VisManager::SetVerboseLevel(), and G4VisManager::~G4VisManager().

◆ VerbosityGuidanceStrings

std::vector< G4String > G4VisManager::VerbosityGuidanceStrings

staticinherited

Definition at line 454 of file G4VisManager.hh.

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

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

environments/g4py/source/visualization/pyG4VisManager.cc

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Enumeration Documentation

◆ Verbosity

Constructor & Destructor Documentation

◆ PyG4VisManager()

◆ ~PyG4VisManager()

Member Function Documentation

◆ _get_concrete_instance()

◆ BeginDraw()

◆ BeginDraw2D()

◆ BeginOfEvent()

◆ BeginOfRun()

◆ ClearTransientStoreIfMarked()

◆ 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]

◆ DrawT()

◆ DrawT2D()

◆ Enable()

◆ EndDraw()

◆ EndDraw2D()

◆ EndOfEvent()

◆ EndOfRun()

◆ FilterDigi()

◆ FilterHit()

◆ FilterTrajectory()

◆ GeometryHasChanged()

◆ GetAbortReviewKeptEvents()

◆ GetAvailableGraphicsSystems()

◆ GetAvailableSceneHandlers()

◆ GetConcreteInstance()

◆ GetCurrentGraphicsSystem()

◆ GetCurrentScene()

◆ GetCurrentSceneHandler()

◆ GetCurrentViewer()

◆ GetDefaultViewParameters()

◆ GetDrawEventOnlyIfToBeKept()

◆ GetEndOfEventUserVisActions()

◆ GetEndOfRunUserVisActions()

◆ GetInstance()

◆ GetNKeepRequests()

◆ GetRequestedEvent()

◆ GetReviewingKeptEvents()

◆ GetRunDurationUserVisActions()

◆ GetSceneList()

◆ GetTransientsDrawnThisEvent()

◆ GetTransientsDrawnThisRun()

◆ GetUserVisActionExtents()

◆ GetVerbosity()