G4VVisManager: All user code writes to the graphics systems through this pure abstract interface. It contains Draw methods for all the graphics primitives in the graphics_reps category (G4Polyline, G4Circle, etc.), geometry objects (through their base classes, G4VSolid, G4PhysicalVolume and G4LogicalVolume) and hits and trajectories (through their base classes, G4VHit and G4VTrajectory).

Since this is an abstract interface, all user code must check that there exists a concrete instantiation of it. A static method is provided, so a typical user code fragment is:

  G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
  if(pVVisManager) {
    pVVisManager->Draw(G4Circle...
    ...
    

Note that this allows the building an application without a concrete implementation, for example for a batch job, even if some code, like the above, is still included. Most of the novice examples can be built this way if G4VIS_NONE is specified.

The concrete implementation of this interface is hereafter referred to as the visualisation manager.

G4VGraphicsScene: The visualisation manager must also provide a concrete implementation of the subsidiary interface, G4VGraphicsScene. It is only for use by the kernel and the modeling category. It offers direct access to a ``scene handler'' through a reference provided by the visualisation manager. It is described in more detail in the section on extending the toolkit functionality.

G4VisManager: An implementation of the G4VVisManager interface. It manages multiple graphics systems and defines three more concepts -- the scene (G4Scene), the scene handler (base class G4VSceneHandler, itself a sub-class of G4VGraphicsScene) and the viewer (base class G4VViewer) -- see below. G4VisManager is a singleton and an abstract class, requiring the user to derive from it a concrete visualisation manager (G4VisExecutive is provided -- see below). Roles and structure of the visualisation manager are described in Chapter 8 of the User's Guide for Application Developers.

G4VisExecutive: A concrete visualisation manager that implements the virtual functions RegisterGraphicsSystems and RegisterModelFactories. These functions must be in the users' domain, since the graphics systems and models that are instantiated by them are, in many cases, provided by the user (graphics libraries, etc.). It is therefore implemented as a .hh-.icc combination that is designed to be included in the users' code. Of course, the user may write his or her own.

G4Scene The scene is a list if models for physical volumes, axes, hits, trajectories, etc. - see Section Section 2.12.4. They are distinguished according to their lifetime -- ``run-duration'' for physical volumes, etc., ``end-of-event'' for hits and trajectories, etc. The end-of-event models are only to be used when the Geant4 state indicates the end of event has been reached. The scene has an extent (G4VisExtent), which is updated by the scene when a new model is added (each model itself has an extent), and a ``standard'' target point; these are used to define the standard view -- see below. In addition, the scene keeps flags which indicate whether end-of-event objects should be accumulated or refreshed for each event or run.

G4VGraphicsSystem: This is an abstract base class for scene handler and viewer factories. It is used by the visualisation manager to create scene handlers and viewers on request.

G4VSceneHandler: A sub-class of G4VGraphicsScene, itself an abstract base class for specific scene handlers, whose job is to convert the scene into graphics-system-specific code for the viewer. For example, the scene handler may create a graphical database, taking care to separate run-duration (persistent) and end-of-event (transient) information (this is described further in Section 3.7.1.6.

G4VViewer: An abstract base class for specific viewers. Its job is to create windows or files and identify where and how the final view should be rendered. It has view parameters (G4ViewParameters) which specify viewpoint direction, type of rendering (wireframe or surface), etc. It is the view's responsibility, noting the scene's extent and target point, to choose a camera position and magnification that ensures that the scene is automatically and comfortably rendered in the viewing window. This is then the standard view, and any further operations requested by the user - zoom, pan, etc. - are relative to this standard view. The class G4ViewParameters has utility routines to assist this procedure; it is strongly advised that toolkit developers writing a viewer should study the G4ViewParameters class, whose header file contains much useful information (also preserved in the Software Reference Manual).

The viewer is messaged by the vis manager when the user issues commands, such as /vis/viewer/refresh. This invokes methods such as SetView, ClearView and DrawView. A detailed description of the call sequences is given in Section 3.7.1.2- Section 3.7.1.5.

G4VModel - a base class for visualisation models. A model is a graphics-system-independent description of a Geant4 component.

The sub-category visualisation/modeling defines how to model a 3D scene for visualisation. The term "3D scene" indicates a set of visualisable component objects put in a 3D world. A concrete class inheriting from the abstract base class G4VModel defines a "model", which describes how to visualise the corresponding component object belonging to a 3D scene. G4ModelingParameters defines various associated parameters.

For example, G4PhysicalVolumeModel knows how to visualise a physical volume. It describes a physical volume and its daughters to any desired depth. G4HitsModel knows how to visualise hits. G4TrajectoriesModel knows how to visualise trajectories.

The main task of a model is to describe itself to a 3D scene by giving a concrete implementation of the following virtual method of G4VModel:

    virtual void DescribeYourselfTo (G4VGraphicsScene&) = 0;
    

The argument class G4VGraphicsScene is a minimal abstract interface of a 3D scene for the Geant4 kernel defined in the graphics_reps category. Since G4VSceneHandler and its concrete descendants inherit from G4VGraphicsScene, the method DescribeYourselfTo() can pass information of a 3D scene to a visualisation driver.

It is easy for a toolkit developer of Geant4 to add a new kind of visualisable component object. It is done by implementing a new class inheriting from G4VModel.

G4VTrajectoryModel - an abstract base class for trajectory drawing models.

A trajectory model governs how an individual trajectory is drawn. Concrete models inheriting from G4VTrajectoryModel must implement two pure virtual functions:

    virtual void Draw(const G4VTrajectory&, G4int i_mode = 0) const = 0;
    virtual void Print(std::ostream& ostr) const = 0;
    

See for example G4TrajectoryDrawByParticleID.

G4VModelFactory - an abstract base class for factories creating models and associated messengers.

It is not necessary to generate messengers for a trajectory model that will be constructed and configured directly in compiled code. If the user requires model creation and configuration features through interactive commands, however, there must be a mechanism to generate both models and their associated messengers. This is the role of G4VModelFactory. Concrete factories inheriting from G4VModelFactory are responsible for creating a concrete model and concrete messengers. To help ensure a type safe messenger to model interaction on the command line, the messengers should inherit from G4VModelCommand.

Concrete factories must implement one pure virtual function:

    virtual ModelAndMessengers 
    Create(const G4String& placement, const G4String& modelName) = 0;
    

where placement indicates which directory space the commands should occupy. See for example G4TrajectoryDrawByParticleIDFactory.