G4VisManager Class Reference

#include <G4VisManager.hh>

Inheritance diagram for G4VisManager:

Data Structures
struct	UserVisAction

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

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

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

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

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

Protected Attributes
const G4int	fVerbose
G4bool	fIgnoreStateChanges

Friends
class	G4RTSteppingAction
class	G4RayTrajectory
class	G4RayTracerSceneHandler
class	G4RTMessenger
class	G4OpenGLViewerMessenger
class	G4OpenGLXmViewerMessenger
class	G4HepRepFileSceneHandler
class	G4VSceneHandler
class	G4VViewer
class	G4VisStateDependent
class	G4VisCommandList
std::ostream &	operator<< (std::ostream &, const G4VGraphicsSystem &)
std::ostream &	operator<< (std::ostream &, const G4VSceneHandler &)

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

Detailed Description

Definition at line 119 of file G4VisManager.hh.

Member Enumeration Documentation

enum G4VisManager::Verbosity

Enumerator
quiet
startup
errors
warnings
confirmations
parameters
all

Definition at line 149 of file G4VisManager.hh.

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

Constructor & Destructor Documentation

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

protected

Definition at line 88 of file G4VisManager.cc.

References FatalException, G4cout, G4endl, G4Exception(), G4VisStateDependent, GetVerbosityValue(), RegisterMessenger(), G4VVisManager::SetConcreteInstance(), G4VVisCommand::SetVisManager(), startup, VerbosityGuidanceStrings, and VerbosityString().

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

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

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

  fpInstance = this;
  SetConcreteInstance(this);

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

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

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

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

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

G4VisManager::~G4VisManager ( )

virtual

Definition at line 192 of file G4VisManager.cc.

References G4cout, G4endl, and startup.

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

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

Member Function Documentation

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

virtual

Implements G4VVisManager.

Definition at line 656 of file G4VisManager.cc.

References G4Exception(), G4Threading::IsWorkerThread(), and JustWarning.

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

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

virtual

Implements G4VVisManager.

Definition at line 693 of file G4VisManager.cc.

References G4Exception(), G4Threading::IsWorkerThread(), and JustWarning.

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

void G4VisManager::CreateSceneHandler

(

const G4String &

name = ""

)

Definition at line 941 of file G4VisManager.cc.

References errors, G4cout, G4endl, and Initialise().

                                                           {
  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 ();
}

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

Definition at line 963 of file G4VisManager.cc.

References G4cout, G4endl, G4ViewParameters::IsCulling(), G4ViewParameters::IsCullingCovered(), G4ViewParameters::IsCullingInvisible(), and G4ViewParameters::SetXGeometryString().

{

  if (!fInitialised) Initialise ();

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

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

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

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

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

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

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

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

const G4VTrajectoryModel * G4VisManager::CurrentTrajDrawModel

(

)

const

Definition at line 584 of file G4VisManager.cc.

References assert, G4VisModelManager< typename >::Current(), G4cout, G4endl, G4VisModelManager< typename >::Register(), and warnings.

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

{
  assert (0 != fpTrajDrawModelMgr);

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

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

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

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

  return model;
}

void G4VisManager::Disable

(

)

Definition at line 529 of file G4VisManager.cc.

References confirmations, G4cout, G4endl, and G4VVisManager::SetConcreteInstance().

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

                           {
  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;
  }
}

void G4VisManager::DispatchToModel ( const G4VTrajectory &  trajectory )

virtual

Implements G4VVisManager.

Definition at line 1164 of file G4VisManager.cc.

References assert, CurrentTrajDrawModel(), G4VTrajectoryModel::Draw(), FilterTrajectory(), G4VisFilterManager< T >::GetMode(), and FilterMode::Soft.

{
  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);
  }
}

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

virtual

Implements G4VVisManager.

Definition at line 776 of file G4VisManager.cc.

Referenced by Draw().

{
  DrawT (circle, objectTransform);
}

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

virtual

Implements G4VVisManager.

Definition at line 782 of file G4VisManager.cc.

{
  DrawT (polyhedron, objectTransform);
}

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

virtual

Implements G4VVisManager.

Definition at line 788 of file G4VisManager.cc.

{
  DrawT (line, objectTransform);
}

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

virtual

Implements G4VVisManager.

Definition at line 794 of file G4VisManager.cc.

{
  DrawT (polymarker, objectTransform);
}

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

virtual

Implements G4VVisManager.

Definition at line 800 of file G4VisManager.cc.

{
  DrawT (scale, objectTransform);
}

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

virtual

Implements G4VVisManager.

Definition at line 806 of file G4VisManager.cc.

{
  DrawT (square, objectTransform);
}

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

virtual

Implements G4VVisManager.

Definition at line 812 of file G4VisManager.cc.

{
  DrawT (text, objectTransform);
}

void G4VisManager::Draw ( const G4VTrajectory &  traj )

virtual

Implements G4VVisManager.

Definition at line 882 of file G4VisManager.cc.

References G4Threading::IsWorkerThread().

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

void G4VisManager::Draw ( const G4VHit &  hit )

virtual

Implements G4VVisManager.

Definition at line 854 of file G4VisManager.cc.

References G4Threading::IsWorkerThread().

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

void G4VisManager::Draw ( const G4VDigi &  digi )

virtual

Implements G4VVisManager.

Definition at line 868 of file G4VisManager.cc.

References G4Threading::IsWorkerThread().

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

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

virtual

Implements G4VVisManager.

Definition at line 898 of file G4VisManager.cc.

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

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

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

virtual

Implements G4VVisManager.

Definition at line 929 of file G4VisManager.cc.

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

                                                   {
  // Find corresponding logical volume and solid.
#ifdef G4MULTITHREADED
  if (G4Threading::IsWorkerThread()) return;
#endif
  G4LogicalVolume* pLV  = physicalVol.GetLogicalVolume ();
  G4VSolid*        pSol = pLV -> GetSolid ();
  Draw (*pSol, attribs, objectTransform);
}

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

virtual

Implements G4VVisManager.

Definition at line 909 of file G4VisManager.cc.

References G4VSolid::DescribeYourselfTo(), and G4Threading::IsWorkerThread().

                                                   {
#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 ();
    }
  }
}

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

virtual

Implements G4VVisManager.

Definition at line 818 of file G4VisManager.cc.

{
  DrawT2D (circle, objectTransform);
}

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

virtual

Implements G4VVisManager.

Definition at line 824 of file G4VisManager.cc.

{
  DrawT2D (polyhedron, objectTransform);
}

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

virtual

Implements G4VVisManager.

Definition at line 830 of file G4VisManager.cc.

{
  DrawT2D (line, objectTransform);
}

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

virtual

Implements G4VVisManager.

Definition at line 836 of file G4VisManager.cc.

{
  DrawT2D (polymarker, objectTransform);
}

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

virtual

Implements G4VVisManager.

Definition at line 842 of file G4VisManager.cc.

{
  DrawT2D (square, objectTransform);
}

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

virtual

Implements G4VVisManager.

Definition at line 848 of file G4VisManager.cc.

{
  DrawT2D (text, objectTransform);
}

void G4VisManager::Enable

(

)

Definition at line 511 of file G4VisManager.cc.

References confirmations, G4cout, G4endl, G4VVisManager::SetConcreteInstance(), and warnings.

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

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

void G4VisManager::EndDraw ( )

virtual

Implements G4VVisManager.

Definition at line 677 of file G4VisManager.cc.

References G4Threading::IsWorkerThread().

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

void G4VisManager::EndDraw2D ( )

virtual

Implements G4VVisManager.

Definition at line 714 of file G4VisManager.cc.

References G4Threading::IsWorkerThread().

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

G4bool G4VisManager::FilterDigi ( const G4VDigi &  digi )

virtual

Implements G4VVisManager.

Definition at line 1159 of file G4VisManager.cc.

References G4VisFilterManager< T >::Accept().

{
  return fpDigiFilterMgr->Accept(digi);
}   

G4bool G4VisManager::FilterHit ( const G4VHit &  hit )

virtual

Implements G4VVisManager.

Definition at line 1154 of file G4VisManager.cc.

References G4VisFilterManager< T >::Accept().

{
  return fpHitFilterMgr->Accept(hit);
}   

G4bool G4VisManager::FilterTrajectory ( const G4VTrajectory &  trajectory )

virtual

Implements G4VVisManager.

Definition at line 1149 of file G4VisManager.cc.

References G4VisFilterManager< T >::Accept().

Referenced by DispatchToModel().

{
  return fpTrajFilterMgr->Accept(trajectory);
}   

void G4VisManager::GeometryHasChanged ( )

virtual

Implements G4VVisManager.

Definition at line 1045 of file G4VisManager.cc.

References G4Scene::CalculateExtent(), confirmations, G4cout, G4endl, G4Scene::GetName(), G4TransportationManager::GetTransportationManager(), G4UImanager::GetUIpointer(), and warnings.

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

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

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

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

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

G4bool G4VisManager::GetAbortReviewKeptEvents

(

)

const

Referenced by G4VisCommandReviewKeptEvents::SetNewValue().

const G4GraphicsSystemList & G4VisManager::GetAvailableGraphicsSystems

(

)

Definition at line 540 of file G4VisManager.cc.

References G4cout, G4endl, and warnings.

Referenced by G4VisCommandOpen::G4VisCommandOpen().

                                                                       {
  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;
}

const G4SceneHandlerList& G4VisManager::GetAvailableSceneHandlers

(

)

const

G4VGraphicsSystem* G4VisManager::GetCurrentGraphicsSystem

(

)

const

Referenced by G4VisCommandDrawTree::SetNewValue().

G4Scene* G4VisManager::GetCurrentScene

(

)

const

Referenced by G4RayTracerSceneHandler::G4RayTracerSceneHandler(), CexmcRunManager::RegisterScenePrimitives(), G4VisCommandDrawTree::SetNewValue(), G4VisCommandSceneAddArrow::SetNewValue(), G4VisCommandSceneActivateModel::SetNewValue(), G4VisCommandSceneAddArrow2D::SetNewValue(), G4VisCommandSceneEndOfEventAction::SetNewValue(), G4VisCommandSceneAddAxes::SetNewValue(), G4VisCommandReviewKeptEvents::SetNewValue(), G4VisCommandSceneEndOfRunAction::SetNewValue(), G4VisCommandSceneAddDate::SetNewValue(), G4VisCommandSceneAddDigis::SetNewValue(), G4VisCommandSceneAddEventID::SetNewValue(), G4VisCommandSceneAddFrame::SetNewValue(), G4VisCommandSceneAddHits::SetNewValue(), G4VisCommandSceneAddLine::SetNewValue(), G4VisCommandSceneAddLine2D::SetNewValue(), G4VisCommandSceneAddLogicalVolume::SetNewValue(), G4VisCommandSceneAddLogo::SetNewValue(), G4VisCommandSceneAddLogo2D::SetNewValue(), G4VisCommandSceneAddScale::SetNewValue(), G4VisCommandSceneAddText::SetNewValue(), G4VisCommandSceneAddText2D::SetNewValue(), G4VisCommandSceneAddTrajectories::SetNewValue(), and G4VisCommandSceneAddVolume::SetNewValue().

G4VSceneHandler* G4VisManager::GetCurrentSceneHandler

(

)

const

Referenced by G4VisCommandDrawTree::SetNewValue(), G4VisCommandSceneActivateModel::SetNewValue(), G4VisCommandSceneEndOfEventAction::SetNewValue(), and G4VisCommandSceneEndOfRunAction::SetNewValue().

G4VViewer* G4VisManager::GetCurrentViewer

(

)

const

Referenced by G4RayTrajectory::AppendStep(), G4VisCommandDrawTree::SetNewValue(), G4VisCommandDrawView::SetNewValue(), G4RTMessenger::SetNewValue(), G4VisCommandGeometryRestore::SetNewValue(), G4VisCommandReviewKeptEvents::SetNewValue(), G4VisCommandViewerCopyViewFrom::SetNewValue(), G4VisCommandViewerDolly::SetNewValue(), G4VisCommandViewerPan::SetNewValue(), G4VisCommandViewerSave::SetNewValue(), G4VisCommandSceneAddLogo::SetNewValue(), G4VisCommandViewerScale::SetNewValue(), G4VisCommandViewerZoom::SetNewValue(), G4VisCommandSceneAddScale::SetNewValue(), and G4RTSteppingAction::UserSteppingAction().

const G4ViewParameters& G4VisManager::GetDefaultViewParameters

(

)

const

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

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

(

)

const

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

(

)

const

const G4Event* G4VisManager::GetRequestedEvent

(

)

const

Referenced by G4VSceneHandler::ProcessScene().

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

(

)

const

const G4SceneList& G4VisManager::GetSceneList

(

)

const

G4bool G4VisManager::GetTransientsDrawnThisEvent

(

)

const

Referenced by G4VSceneHandler::G4VSceneHandler().

G4bool G4VisManager::GetTransientsDrawnThisRun

(

)

const

Referenced by G4VSceneHandler::G4VSceneHandler().

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

(

)

const

G4VisManager::Verbosity G4VisManager::GetVerbosity ( )

static

Definition at line 2077 of file G4VisManager.cc.

Referenced by G4GMocrenFileSceneHandler::AddPrimitive(), G4GMocrenFileSceneHandler::AddSolid(), G4GMocrenFileSceneHandler::BeginPrimitives(), G4DAWNFILESceneHandler::BeginSavingG4Prim(), G4GMocrenFileSceneHandler::BeginSavingGdd(), G4VRML1FileViewer::ClearView(), G4VRML2FileViewer::ClearView(), G4DAWNFILEViewer::ClearView(), G4GMocrenFileViewer::ClearView(), G4VRML1FileSceneHandler::closePort(), G4VRML2FileSceneHandler::closePort(), G4VRML1FileSceneHandler::connectPort(), G4VRML2FileSceneHandler::connectPort(), G4VSceneHandler::CreateModelingParameters(), G4VRML1FileViewer::DrawView(), G4VRML2FileViewer::DrawView(), G4DAWNFILEViewer::DrawView(), G4GMocrenFileViewer::DrawView(), G4GMocrenFileSceneHandler::EndPrimitives(), G4DAWNFILESceneHandler::EndSavingG4Prim(), G4GMocrenFileSceneHandler::EndSavingGdd(), export_G4VisManager(), G4VRML1FileViewer::FinishView(), G4VRML2FileViewer::FinishView(), G4DAWNFILESceneHandler::FRBeginModeling(), G4GMocrenIO::getDetector(), GMocrenDetector::getEdge(), G4GMocrenIO::getShortDoseDist(), GMocrenTrack::getStep(), G4GMocrenIO::getTrack(), G4GMocrenFileSceneHandler::GFBeginModeling(), G4GMocrenFileSceneHandler::GFEndModeling(), G4GMocrenIO::mergeDoseDist(), GMocrenDataPrimitive< T >::operator+(), GMocrenDataPrimitive< T >::operator+=(), G4VSceneHandler::ProcessScene(), G4VVisCommandViewer::RefreshIfRequired(), G4VSceneHandler::RequestPrimitives(), G4GMocrenIO::retrieveData(), G4GMocrenIO::retrieveData2(), G4GMocrenIO::retrieveData3(), G4GMocrenIO::retrieveData4(), G4DAWNFILEViewer::SendViewParameters(), G4DAWNFILESceneHandler::SetG4PrimFileName(), G4GMocrenFileSceneHandler::SetGddFileName(), G4VisCommandDrawTree::SetNewValue(), G4VisCommandViewerDefaultHiddenEdge::SetNewValue(), G4VisCommandSceneHandlerAttach::SetNewValue(), G4VisCommandSetColour::SetNewValue(), G4VisCommandDrawView::SetNewValue(), G4VisCommandSceneAddArrow::SetNewValue(), G4VisCommandSceneHandlerCreate::SetNewValue(), G4VisCommandSceneActivateModel::SetNewValue(), G4VisCommandViewerDefaultStyle::SetNewValue(), G4VisCommandGeometryList::SetNewValue(), G4VisCommandSetTextColour::SetNewValue(), G4VisCommandViewerAddCutawayPlane::SetNewValue(), G4VisCommandDrawVolume::SetNewValue(), G4VisCommandSceneAddArrow2D::SetNewValue(), G4VisCommandGeometryRestore::SetNewValue(), G4VisCommandSceneCreate::SetNewValue(), G4VisCommandSetLineWidth::SetNewValue(), G4VisCommandOpen::SetNewValue(), G4VisCommandViewerChangeCutawayPlane::SetNewValue(), G4VisCommandSceneHandlerSelect::SetNewValue(), G4VisCommandSetTextLayout::SetNewValue(), G4VisCommandSceneEndOfEventAction::SetNewValue(), G4VisCommandSpecify::SetNewValue(), G4VisCommandSceneAddAxes::SetNewValue(), G4VisCommandViewerClear::SetNewValue(), G4VisCommandReviewKeptEvents::SetNewValue(), G4VisCommandSetTouchable::SetNewValue(), G4VisCommandSceneEndOfRunAction::SetNewValue(), G4VisCommandSceneAddDate::SetNewValue(), G4VisCommandViewerClearCutawayPlanes::SetNewValue(), G4VisCommandViewerClearTransients::SetNewValue(), G4VisCommandSceneNotifyHandlers::SetNewValue(), G4VisCommandViewerClone::SetNewValue(), G4VisCommandSceneAddDigis::SetNewValue(), G4VisCommandSceneSelect::SetNewValue(), G4VisCommandSceneAddEventID::SetNewValue(), G4VisCommandViewerCopyViewFrom::SetNewValue(), G4VisCommandViewerCreate::SetNewValue(), G4VisCommandSceneAddFrame::SetNewValue(), G4VisCommandViewerDolly::SetNewValue(), G4VisCommandViewerFlush::SetNewValue(), G4VisCommandSceneAddHits::SetNewValue(), G4VisCommandViewerPan::SetNewValue(), G4VisCommandSceneAddLine::SetNewValue(), G4VisCommandViewerReset::SetNewValue(), G4VisCommandSceneAddLine2D::SetNewValue(), G4VisCommandViewerRefresh::SetNewValue(), G4VisCommandViewerRebuild::SetNewValue(), G4VisCommandSceneAddLogicalVolume::SetNewValue(), G4VisCommandViewerSave::SetNewValue(), G4VisCommandSceneAddLogo::SetNewValue(), G4VisCommandViewerScale::SetNewValue(), G4VisCommandViewerSelect::SetNewValue(), G4VisCommandSceneAddLogo2D::SetNewValue(), G4VisCommandViewerUpdate::SetNewValue(), G4VisCommandViewerZoom::SetNewValue(), G4VisCommandSceneAddScale::SetNewValue(), G4VisCommandSceneAddText::SetNewValue(), G4VisCommandSceneAddText2D::SetNewValue(), G4VisCommandSceneAddTrajectories::SetNewValue(), G4VisCommandSceneAddVolume::SetNewValue(), G4DAWNFILEViewer::SetView(), G4GMocrenFileViewer::SetView(), G4VRML1FileViewer::ShowView(), G4VRML2FileViewer::ShowView(), G4DAWNFILEViewer::ShowView(), G4GMocrenFileViewer::ShowView(), G4GMocrenIO::storeData3(), G4DAWNFILESceneHandler::~G4DAWNFILESceneHandler(), G4GMocrenFileSceneHandler::~G4GMocrenFileSceneHandler(), G4VRML1FileSceneHandler::~G4VRML1FileSceneHandler(), and G4VRML2FileSceneHandler::~G4VRML2FileSceneHandler().

                                                  {
  return fVerbosity;
}

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

static

Definition at line 2038 of file G4VisManager.cc.

References all, confirmations, errors, G4cout, G4endl, parameters, quiet, startup, G4String::toLower(), VerbosityGuidanceStrings, VerbosityString(), and warnings.

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

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

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

static

Definition at line 2069 of file G4VisManager.cc.

References all, and quiet.

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

G4VViewer * G4VisManager::GetViewer

(

const G4String &

viewerName

)

const

Definition at line 1999 of file G4VisManager.cc.

References ViewerShortName().

                                                                    {
  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;
}

void G4VisManager::Initialise

(

)

Definition at line 234 of file G4VisManager.cc.

References G4cout, G4endl, parameters, PrintAvailableGraphicsSystems(), RegisterGraphicsSystems(), RegisterMessengers(), RegisterModelFactories(), startup, and warnings.

Referenced by CreateSceneHandler(), and main().

                               {

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

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

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

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

  RegisterGraphicsSystems ();

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

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

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

  RegisterMessengers ();

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

  RegisterModelFactories();

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

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

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

  fInitialised = true;
}

void G4VisManager::Initialize

(

)

Referenced by export_G4VisManager(), main(), XrayFluoSimulation::RunSimulation(), and G4VisCommandInitialize::SetNewValue().

void G4VisManager::NotifyHandlers ( )

virtual

Reimplemented from G4VVisManager.

Definition at line 1118 of file G4VisManager.cc.

References G4Scene::CalculateExtent(), confirmations, G4cout, G4endl, G4Scene::GetName(), G4UImanager::GetUIpointer(), and warnings.

                                   {

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

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

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

void G4VisManager::PrintAvailableGraphicsSystems ( ) const

protected

Definition at line 1373 of file G4VisManager.cc.

References G4cout, G4endl, G4VGraphicsSystem::GetName(), and G4VGraphicsSystem::GetNickname().

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

                                                        {
  G4int nSystems = fAvailableGraphicsSystems.size ();
  G4cout << "Current available graphics systems are:";
  if (nSystems) {
    // Make a map of graphics systems names (there may be repeated systems)
    // and for each name a set of nicknames.  The nicknames are ordered
    // by length - see struct NicknameComparison above.
    std::map<G4String,std::set<G4String,NicknameComparison> > systemMap;
    for (G4int i = 0; i < nSystems; i++) {
      const G4VGraphicsSystem* pSystem = fAvailableGraphicsSystems[i];
      systemMap[pSystem->GetName()].insert(pSystem->GetNickname());
    }
    // Print the map.
    std::map<G4String,std::set<G4String,NicknameComparison> >::const_iterator i;
    for (i = systemMap.begin(); i != systemMap.end(); ++i) {
      G4cout << "\n  " << i->first << " (";
      const std::set<G4String,NicknameComparison>& nicknames = i->second;
      std::set<G4String,NicknameComparison>::const_iterator j;
      for (j = nicknames.begin(); j != nicknames.end(); ++j) {
        if (j != nicknames.begin()) G4cout << ", ";
        G4cout << *j;
      }
      G4cout << ')';
    }
  }
  else {
    G4cout << "\n  NONE!!!  None registered - yet!  Mmmmm!";
  }
  G4cout << G4endl;
}

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

Definition at line 1207 of file G4VisManager.cc.

References G4cout, G4endl, and G4VisExtent::GetExtentRadius().

                            {
  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;
    }
  }
}

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

Definition at line 1223 of file G4VisManager.cc.

References G4cout, G4endl, and G4VisExtent::GetExtentRadius().

                            {
  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;
    }
  }
}

G4bool G4VisManager::RegisterGraphicsSystem

(

G4VGraphicsSystem *

pSystem

)

Definition at line 560 of file G4VisManager.cc.

References confirmations, errors, G4cout, and G4endl.

Referenced by export_G4VisManager().

                                                                       {
  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;
}

virtual void G4VisManager::RegisterGraphicsSystems ( )

protectedpure virtual

Implemented in PyG4VisManager.

Referenced by Initialise().

void G4VisManager::RegisterMessenger

(

G4UImessenger *

messenger

)

Referenced by G4VisManager(), and RegisterMessengers().

void G4VisManager::RegisterMessengers ( )

protected

Definition at line 345 of file G4VisManager.cc.

References G4VisModelManager< typename >::Placement(), G4VisFilterManager< T >::Placement(), and RegisterMessenger().

Referenced by Initialise().

                                       {
  
  // Instantiate individual messengers/commands (often - but not
  // always - one command per messenger).
  
  G4UIcommand* directory;
  
  // *Basic* top level commands were instantiated in the constructor
  // so that they can be used immediately after instantiation of the
  // vis manager.  Other top level and lower level commands are
  // instantiated here.
  
  // Other top level commands...
  RegisterMessenger(new G4VisCommandAbortReviewKeptEvents);
  RegisterMessenger(new G4VisCommandEnable);
  RegisterMessenger(new G4VisCommandList);
  RegisterMessenger(new G4VisCommandReviewKeptEvents);
  
  // Compound commands...
  RegisterMessenger(new G4VisCommandDrawTree);
  RegisterMessenger(new G4VisCommandDrawView);
  RegisterMessenger(new G4VisCommandDrawVolume);
  RegisterMessenger(new G4VisCommandOpen);
  RegisterMessenger(new G4VisCommandSpecify);
  
  directory = new G4UIdirectory ("/vis/geometry/");
  directory -> SetGuidance("Operations on vis attributes of Geant4 geometry.");
  fDirectoryList.push_back (directory);
  RegisterMessenger(new G4VisCommandGeometryList);
  RegisterMessenger(new G4VisCommandGeometryRestore);
  
  directory = new G4UIdirectory ("/vis/geometry/set/");
  directory -> SetGuidance("Set vis attributes of Geant4 geometry.");
  fDirectoryList.push_back (directory);
  RegisterMessenger(new G4VisCommandGeometrySetColour);
  RegisterMessenger(new G4VisCommandGeometrySetDaughtersInvisible);
  RegisterMessenger(new G4VisCommandGeometrySetLineStyle);
  RegisterMessenger(new G4VisCommandGeometrySetLineWidth);
  RegisterMessenger(new G4VisCommandGeometrySetForceAuxEdgeVisible);
  RegisterMessenger(new G4VisCommandGeometrySetForceLineSegmentsPerCircle);
  RegisterMessenger(new G4VisCommandGeometrySetForceSolid);
  RegisterMessenger(new G4VisCommandGeometrySetForceWireframe);
  RegisterMessenger(new G4VisCommandGeometrySetVisibility);
  
  directory = new G4UIdirectory ("/vis/set/");
  directory -> SetGuidance
    ("Set quantities for use in future commands where appropriate.");
  fDirectoryList.push_back (directory);
  RegisterMessenger(new G4VisCommandSetColour);
  RegisterMessenger(new G4VisCommandSetLineWidth);
  RegisterMessenger(new G4VisCommandSetTextColour);
  RegisterMessenger(new G4VisCommandSetTextLayout);
  RegisterMessenger(new G4VisCommandSetTouchable);
  
  directory = new G4UIdirectory ("/vis/scene/");
  directory -> SetGuidance ("Operations on Geant4 scenes.");
  fDirectoryList.push_back (directory);
  RegisterMessenger(new G4VisCommandSceneActivateModel);
  RegisterMessenger(new G4VisCommandSceneCreate);
  RegisterMessenger(new G4VisCommandSceneEndOfEventAction);
  RegisterMessenger(new G4VisCommandSceneEndOfRunAction);
  RegisterMessenger(new G4VisCommandSceneList);
  RegisterMessenger(new G4VisCommandSceneNotifyHandlers);
  RegisterMessenger(new G4VisCommandSceneSelect);
  
  directory = new G4UIdirectory ("/vis/scene/add/");
  directory -> SetGuidance ("Add model to current scene.");
  fDirectoryList.push_back (directory);
  RegisterMessenger(new G4VisCommandSceneAddArrow);
  RegisterMessenger(new G4VisCommandSceneAddArrow2D);
  RegisterMessenger(new G4VisCommandSceneAddAxes);
  RegisterMessenger(new G4VisCommandSceneAddDate);
  RegisterMessenger(new G4VisCommandSceneAddDigis);
  RegisterMessenger(new G4VisCommandSceneAddEventID);
  RegisterMessenger(new G4VisCommandSceneAddFrame);
  RegisterMessenger(new G4VisCommandSceneAddHits);
  RegisterMessenger(new G4VisCommandSceneAddLine);
  RegisterMessenger(new G4VisCommandSceneAddLine2D);
  RegisterMessenger(new G4VisCommandSceneAddLogicalVolume);
  RegisterMessenger(new G4VisCommandSceneAddLogo);
  RegisterMessenger(new G4VisCommandSceneAddLogo2D);
  RegisterMessenger(new G4VisCommandSceneAddMagneticField);
  RegisterMessenger(new G4VisCommandSceneAddPSHits);
  RegisterMessenger(new G4VisCommandSceneAddScale);
  RegisterMessenger(new G4VisCommandSceneAddText);
  RegisterMessenger(new G4VisCommandSceneAddText2D);
  RegisterMessenger(new G4VisCommandSceneAddTrajectories);
  RegisterMessenger(new G4VisCommandSceneAddUserAction);
  RegisterMessenger(new G4VisCommandSceneAddVolume);
  
  directory = new G4UIdirectory ("/vis/sceneHandler/");
  directory -> SetGuidance ("Operations on Geant4 scene handlers.");
  fDirectoryList.push_back (directory);
  RegisterMessenger(new G4VisCommandSceneHandlerAttach);
  RegisterMessenger(new G4VisCommandSceneHandlerCreate);
  RegisterMessenger(new G4VisCommandSceneHandlerList);
  RegisterMessenger(new G4VisCommandSceneHandlerSelect);
  
  directory = new G4UIdirectory ("/vis/touchable/");
  directory -> SetGuidance ("Operations on touchables.");
  fDirectoryList.push_back (directory);
  directory = new G4UIdirectory ("/vis/touchable/set/");
  directory -> SetGuidance ("Set vis attributes of current touchable.");
  fDirectoryList.push_back (directory);
  RegisterMessenger(new G4VisCommandsTouchableSet);

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

void G4VisManager::RegisterModel

(

G4VTrajectoryModel *

model

)

Definition at line 607 of file G4VisManager.cc.

References G4VisModelManager< typename >::Register().

{
  fpTrajDrawModelMgr->Register(model);
}

void G4VisManager::RegisterModel

(

G4VFilter< G4VTrajectory > *

filter

)

Definition at line 618 of file G4VisManager.cc.

References G4VisFilterManager< T >::Register().

{
  fpTrajFilterMgr->Register(model);
}

void G4VisManager::RegisterModel

(

G4VFilter< G4VHit > *

filter

)

Definition at line 629 of file G4VisManager.cc.

References G4VisFilterManager< T >::Register().

{
  fpHitFilterMgr->Register(model);
}

void G4VisManager::RegisterModel

(

G4VFilter< G4VDigi > *

filter

)

Definition at line 640 of file G4VisManager.cc.

References G4VisFilterManager< T >::Register().

{
  fpDigiFilterMgr->Register(model);
}

void G4VisManager::RegisterModelFactories ( )

protectedvirtual

Reimplemented in PyG4VisManager.

Definition at line 2199 of file G4VisManager.cc.

References G4cout, G4endl, and warnings.

Referenced by Initialise().

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

void G4VisManager::RegisterModelFactory

(

G4TrajDrawModelFactory *

factory

)

Definition at line 613 of file G4VisManager.cc.

References G4VisModelManager< typename >::Register().

{
  fpTrajDrawModelMgr->Register(factory);
}

void G4VisManager::RegisterModelFactory

(

G4TrajFilterFactory *

factory

)

Definition at line 624 of file G4VisManager.cc.

References G4VisFilterManager< T >::Register().

{
  fpTrajFilterMgr->Register(factory);
}

void G4VisManager::RegisterModelFactory

(

G4HitFilterFactory *

factory

)

Definition at line 635 of file G4VisManager.cc.

References G4VisFilterManager< T >::Register().

{
  fpHitFilterMgr->Register(factory);
}

void G4VisManager::RegisterModelFactory

(

G4DigiFilterFactory *

factory

)

Definition at line 646 of file G4VisManager.cc.

References G4VisFilterManager< T >::Register().

{
  fpDigiFilterMgr->Register(factory);
}

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

Definition at line 1191 of file G4VisManager.cc.

References G4cout, G4endl, and G4VisExtent::GetExtentRadius().

Referenced by main().

                            {
  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;
    }
  }
}

void G4VisManager::ResetTransientsDrawnFlags

(

)

Definition at line 1981 of file G4VisManager.cc.

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

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

void G4VisManager::SelectTrajectoryModel

(

const G4String &

model

)

Definition at line 651 of file G4VisManager.cc.

References G4VisModelManager< typename >::SetCurrent().

{
   fpTrajDrawModelMgr->SetCurrent(model);
}

void G4VisManager::SetAbortReviewKeptEvents

(

G4bool

)

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

G4SceneHandlerList& G4VisManager::SetAvailableSceneHandlers

(

)

void G4VisManager::SetCurrentGraphicsSystem

(

G4VGraphicsSystem *

pSystem

)

Definition at line 1247 of file G4VisManager.cc.

References confirmations, G4cout, and G4endl.

Referenced by G4VisCommandDrawTree::SetNewValue().

                                                                       {
  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;
    }
  }
}

void G4VisManager::SetCurrentScene

(

G4Scene *

pScene

)

Definition at line 1238 of file G4VisManager.cc.

References ResetTransientsDrawnFlags().

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

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

void G4VisManager::SetCurrentSceneHandler

(

G4VSceneHandler *

pSceneHandler

)

Definition at line 1294 of file G4VisManager.cc.

References confirmations, G4cout, G4endl, and warnings.

Referenced by G4VisCommandDrawTree::SetNewValue().

                                                                         {
  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;
    }
  }
}

void G4VisManager::SetCurrentViewer

(

G4VViewer *

pViewer

)

Definition at line 1346 of file G4VisManager.cc.

References confirmations, G4cout, G4endl, and warnings.

Referenced by G4VisCommandDrawTree::SetNewValue().

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

void G4VisManager::SetDefaultViewParameters

(

const G4ViewParameters &

)

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

void G4VisManager::SetEventRefreshing

(

G4bool

)

Referenced by G4VSceneHandler::ProcessScene().

void G4VisManager::SetRequestedEvent

(

const G4Event *

)

Referenced by G4VisCommandReviewKeptEvents::SetNewValue().

G4SceneList& G4VisManager::SetSceneList

(

)

Referenced by G4RayTracerSceneHandler::G4RayTracerSceneHandler().

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

Referenced by main().

void G4VisManager::SetUserActionExtent

(

const G4VisExtent &

)

void G4VisManager::SetVerboseLevel

(

G4int

intVerbosity

)

Definition at line 2081 of file G4VisManager.cc.

References GetVerbosityValue().

Referenced by main(), and G4VisCommandVerbose::SetNewValue().

                                                      {
  fVerbosity = GetVerbosityValue(intVerbosity);
}

void G4VisManager::SetVerboseLevel

(

const G4String &

verbosityString

)

Definition at line 2085 of file G4VisManager.cc.

References GetVerbosityValue().

                                                                   {
  fVerbosity = GetVerbosityValue(verbosityString);
}

void G4VisManager::SetVerboseLevel

(

Verbosity

)

G4String G4VisManager::VerbosityString ( Verbosity  verbosity )

static

Definition at line 2023 of file G4VisManager.cc.

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

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

                                                          {
  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;
}

G4String G4VisManager::ViewerShortName

(

const G4String &

viewerName

)

const

Definition at line 1993 of file G4VisManager.cc.

References G4String::strip().

Referenced by GetViewer().

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

Friends And Related Function Documentation

friend class G4HepRepFileSceneHandler

friend

Definition at line 135 of file G4VisManager.hh.

friend class G4OpenGLViewerMessenger

friend

Definition at line 133 of file G4VisManager.hh.

friend class G4OpenGLXmViewerMessenger

friend

Definition at line 134 of file G4VisManager.hh.

friend class G4RayTracerSceneHandler

friend

Definition at line 131 of file G4VisManager.hh.

friend class G4RayTrajectory

friend

Definition at line 130 of file G4VisManager.hh.

friend class G4RTMessenger

friend

Definition at line 132 of file G4VisManager.hh.

friend class G4RTSteppingAction

friend

Definition at line 129 of file G4VisManager.hh.

friend class G4VisCommandList

friend

Definition at line 141 of file G4VisManager.hh.

friend class G4VisStateDependent

friend

Definition at line 140 of file G4VisManager.hh.

Referenced by G4VisManager().

friend class G4VSceneHandler

friend

Definition at line 138 of file G4VisManager.hh.

friend class G4VViewer

friend

Definition at line 139 of file G4VisManager.hh.

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

friend

Definition at line 68 of file G4VGraphicsSystem.cc.

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

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

friend

Definition at line 933 of file G4VSceneHandler.cc.

                                                                    {

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

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

  return os;
}

Field Documentation

G4bool G4VisManager::fIgnoreStateChanges

protected

Definition at line 530 of file G4VisManager.hh.

const G4int G4VisManager::fVerbose

protected

Definition at line 453 of file G4VisManager.hh.

std::vector< G4String > G4VisManager::VerbosityGuidanceStrings

static

Definition at line 439 of file G4VisManager.hh.

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

---

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

• G4VisManager.hh
• G4VisManager.cc