#include <G4HepRepSceneHandler.hh>

Inheritance diagram for G4HepRepSceneHandler:

Collaboration diagram for G4HepRepSceneHandler:

Public Member Functions
	G4HepRepSceneHandler (G4VGraphicsSystem &system, const G4String &name="")

virtual	~G4HepRepSceneHandler ()

void	AddSolid (const G4Box &box)

void	AddSolid (const G4Cons &cons)

void	AddSolid (const G4Tubs &tubs)

void	AddSolid (const G4Trd &trd)

void	AddSolid (const G4Trap &trap)

void	AddSolid (const G4Sphere &sphere)

void	AddSolid (const G4Para &para)

void	AddSolid (const G4Torus &torus)

void	AddSolid (const G4Polycone &polycone)

void	AddSolid (const G4Polyhedra &polyhedra)

void	AddSolid (const G4Orb &orb)

void	AddSolid (const G4Ellipsoid &ellipsoid)

void	AddSolid (const G4VSolid &solid)

void	AddCompound (const G4VTrajectory &)

void	AddCompound (const G4VHit &hit)

void	AddCompound (const G4VDigi &digi)

void	AddCompound (const G4THitsMap< G4double > &hits)

void	AddCompound (const G4THitsMap< G4StatDouble > &hits)

void	PreAddSolid (const G4Transform3D &objectTransformation, const G4VisAttributes &visAttribs)

void	PostAddSolid ()

void	AddPrimitive (const G4Polyline &)

void	AddPrimitive (const G4Text &)

void	AddPrimitive (const G4Circle &)

void	AddPrimitive (const G4Square &)

void	AddPrimitive (const G4Polyhedron &)

void	AddPrimitive (const G4Polymarker &)

void	AddPrimitive (const G4Scale &scale)

void	BeginPrimitives (const G4Transform3D &objectTransformation)

void	EndPrimitives ()

void	BeginModeling ()

void	EndModeling ()

void	openHepRep ()

bool	closeHepRep (bool final=false)

void	openFile (G4String name)

void	closeFile ()

Public Member Functions inherited from G4VSceneHandler
	G4VSceneHandler (G4VGraphicsSystem &system, G4int id, const G4String &name="")

virtual	~G4VSceneHandler ()

virtual void	BeginPrimitives2D (const G4Transform3D &objectTransformation)

virtual void	EndPrimitives2D ()

virtual const G4VisExtent &	GetExtent () const

const G4String &	GetName () const

G4int	GetSceneHandlerId () const

G4int	GetViewCount () const

G4VGraphicsSystem *	GetGraphicsSystem () const

G4Scene *	GetScene () const

const G4ViewerList &	GetViewerList () const

G4VModel *	GetModel () const

G4VViewer *	GetCurrentViewer () const

G4bool	GetMarkForClearingTransientStore () const

G4bool	IsReadyForTransients () const

G4bool	GetTransientsDrawnThisEvent () const

G4bool	GetTransientsDrawnThisRun () const

const G4Transform3D &	GetObjectTransformation () const

void	SetName (const G4String &)

void	SetCurrentViewer (G4VViewer *)

virtual void	SetScene (G4Scene *)

G4ViewerList &	SetViewerList ()

void	SetModel (G4VModel *)

void	SetMarkForClearingTransientStore (G4bool)

void	SetTransientsDrawnThisEvent (G4bool)

void	SetTransientsDrawnThisRun (G4bool)

void	SetObjectTransformation (const G4Transform3D &)

const G4Colour &	GetColour ()

const G4Colour &	GetColor ()

const G4Colour &	GetTextColour (const G4Text &)

const G4Colour &	GetTextColor (const G4Text &)

G4double	GetLineWidth (const G4VisAttributes *)

G4ViewParameters::DrawingStyle	GetDrawingStyle (const G4VisAttributes *)

G4bool	GetAuxEdgeVisible (const G4VisAttributes *)

G4int	GetNoOfSides (const G4VisAttributes *)

G4double	GetMarkerSize (const G4VMarker &, MarkerSizeType &)

G4double	GetMarkerDiameter (const G4VMarker &, MarkerSizeType &)

G4double	GetMarkerRadius (const G4VMarker &, MarkerSizeType &)

G4ModelingParameters *	CreateModelingParameters ()

void	DrawEvent (const G4Event *)

void	DrawEndOfRunModels ()

template<class T >
void	AddSolidT (const T &solid)

template<class T >
void	AddSolidWithAuxiliaryEdges (const T &solid)

G4int	IncrementViewCount ()

virtual void	ClearStore ()

virtual void	ClearTransientStore ()

void	AddViewerToList (G4VViewer *pView)

void	RemoveViewerFromList (G4VViewer *pView)

Public Member Functions inherited from G4VGraphicsScene
	G4VGraphicsScene ()

virtual	~G4VGraphicsScene ()

Additional Inherited Members
Public Types inherited from G4VSceneHandler
enum	MarkerSizeType { world, screen }

Protected Member Functions inherited from G4VSceneHandler
virtual void	ProcessScene ()

virtual void	RequestPrimitives (const G4VSolid &solid)

virtual G4VSolid *	CreateSectionSolid ()

virtual G4VSolid *	CreateCutawaySolid ()

void	LoadAtts (const G4Visible &, G4AttHolder *)

Protected Attributes inherited from G4VSceneHandler
G4VGraphicsSystem &	fSystem

const G4int	fSceneHandlerId

G4String	fName

G4int	fViewCount

G4ViewerList	fViewerList

G4VViewer *	fpViewer

G4Scene *	fpScene

G4bool	fMarkForClearingTransientStore

G4bool	fReadyForTransients

G4bool	fTransientsDrawnThisEvent

G4bool	fTransientsDrawnThisRun

G4bool	fProcessingSolid

G4bool	fProcessing2D

G4VModel *	fpModel

G4Transform3D	fObjectTransformation

G4int	fNestingDepth

const G4VisAttributes *	fpVisAttribs

const G4Transform3D	fIdentityTransformation

Detailed Description

Author: Mark Donszelmann

Definition at line 64 of file G4HepRepSceneHandler.hh.

Constructor & Destructor Documentation

G4HepRepSceneHandler::G4HepRepSceneHandler	(	G4VGraphicsSystem &	system,
		const G4String &	name = `""`
	)

Definition at line 93 of file G4HepRepSceneHandler.cc.

         : G4VSceneHandler (system, sceneIdCount++, name),
           out                   (0),
           geometryLayer         ("Geometry"),
           eventLayer            ("Event"),
           calHitLayer           ("CalHit"),
           trajectoryLayer       ("Trajectory"),
           hitLayer              ("Hit"),
           rootVolumeName        ("Geometry"),
           baseName              (""),
           eventNumberPrefix     (""),
           eventNumberSuffix     (""),
           eventNumber           (1),
           eventNumberWidth      (-1),
           extension             (""),
           writeBinary           (false),
           writeZip              (false),
           writeGZ               (false),
           writeMultipleFiles    (false),
           currentHit            (NULL),
           currentTrack          (NULL),
           _heprep               (NULL),
           _heprepGeometry       (NULL)
 {
 
 #ifdef LDEBUG
     cout << "G4HepRepSceneHandler::G4HepRepSceneHandler: " << system << endl;
 #endif
 
     materialState[kStateSolid]      = G4String("Solid");
     materialState[kStateLiquid]     = G4String("Liquid");
     materialState[kStateGas]        = G4String("Gas");
     materialState[kStateUndefined]  = G4String("Undefined");    
 
     factory = new XMLHepRepFactory();
     writer = NULL;
     
     // opening of file deferred to closeHepRep();
     openHepRep();
 }

Here is the call graph for this function:

G4HepRepSceneHandler::~G4HepRepSceneHandler ( )

virtual

Definition at line 135 of file G4HepRepSceneHandler.cc.

                                              {
 #ifdef LDEBUG
     cout << "G4HepRepSceneHandler::~G4HepRepSceneHandler() " << endl;
 #endif
     close();
 
     delete factory;
     factory = NULL;
 
     G4HepRep* pHepRepSystem = dynamic_cast<G4HepRep*>(GetGraphicsSystem());
     if (pHepRepSystem) pHepRepSystem->removeSceneHandler();
 }

Here is the call graph for this function:

Member Function Documentation

void G4HepRepSceneHandler::AddCompound ( const G4VTrajectory & trajectory )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1001 of file G4HepRepSceneHandler.cc.

                                                                        {
 #ifdef PDEBUG
     cout << "G4HepRepSceneHandler::AddCompound(G4VTrajectory&) " << endl;
 #endif
     if (dontWrite()) return;
     
     currentTrack = &trajectory;
     G4VSceneHandler::AddCompound(trajectory); 
     currentTrack = NULL;    
 }

Here is the call graph for this function:

void G4HepRepSceneHandler::AddCompound ( const G4VHit & hit )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1013 of file G4HepRepSceneHandler.cc.

                                                          { 
 #ifdef PDEBUG
     cout << "G4HepRepSceneHandler::AddCompound(G4VHit&) " << endl;
 #endif
     if (dontWrite()) return;
     
     currentHit = &hit;
     G4VSceneHandler::AddCompound(hit); 
     currentHit = NULL;
 }

Here is the call graph for this function:

void G4HepRepSceneHandler::AddCompound ( const G4VDigi & digi )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 86 of file G4HepRepSceneHandler.hh.

                                                {
       G4VSceneHandler::AddCompound(digi);
     }

Here is the call graph for this function:

void G4HepRepSceneHandler::AddCompound ( const G4THitsMap< G4double > & hits )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 89 of file G4HepRepSceneHandler.hh.

                                                             {
       G4VSceneHandler::AddCompound(hits);
     }

Here is the call graph for this function:

void G4HepRepSceneHandler::AddCompound ( const G4THitsMap< G4StatDouble > & hits )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 92 of file G4HepRepSceneHandler.hh.

                                                                 {
       G4VSceneHandler::AddCompound(hits);
     }

Here is the call graph for this function:

void G4HepRepSceneHandler::AddPrimitive ( const G4Polyline & line )

virtual

Implements G4VSceneHandler.

Definition at line 751 of file G4HepRepSceneHandler.cc.

                                                                {
 
 #ifdef PDEBUG
     cout << "G4HepRepSceneHandler::AddPrimitive(G4Polyline&) " << line.size() << endl;
 #endif
     if (dontWrite()) return;
 
     if (fProcessing2D) {
       static G4bool warned = false;
       if (!warned) {
     warned = true;
     G4Exception
       ("G4HepRepSceneHandler::AddPrimitive (const G4Polyline&)",
        "vis-HepRep1001", JustWarning,
        "2D polylines not implemented.  Ignored.");
       }
       return;
     }
 
     HepRepInstance* instance = factory->createHepRepInstance(getEventInstance(), getTrajectoryType());
 
     addAttributes(instance, getTrajectoryType());
 
     fpVisAttribs = line.GetVisAttributes();
     setColor(instance, GetColor());
 
     setVisibility(instance, line);
 
     setLine(instance, line);
 
     for (size_t i=0; i < line.size(); i++) {
         G4Point3D vertex = transform * line[i];
         factory->createHepRepPoint(instance, vertex.x(), vertex.y(), vertex.z());
     }
 }

Here is the call graph for this function:

void G4HepRepSceneHandler::AddPrimitive ( const G4Text & )

virtual

Implements G4VSceneHandler.

Definition at line 939 of file G4HepRepSceneHandler.cc.

                                                       {
 #ifdef PDEBUG
     cout << "G4HepRepSceneHandler::AddPrimitive(G4Text&) " << endl;
 #endif
     if (dontWrite()) return;
 
     /*** You may need this
     if (fProcessing2D) {
       static G4bool warned = false;
       if (!warned) {
     warned = true;
     G4Exception
       ("G4HepRepSceneHandler::AddPrimitive (const G4Text&)",
        "vis-HepRep1005", JustWarning,
        "2D text not implemented.  Ignored.");
       }
       return;
     }
     ***/
 
     cout << "G4HepRepSceneHandler::AddPrimitive G4Text : not yet implemented. " << endl;
 }

void G4HepRepSceneHandler::AddPrimitive ( const G4Circle & circle )

virtual

Implements G4VSceneHandler.

Definition at line 840 of file G4HepRepSceneHandler.cc.

                                                                {
 #ifdef PDEBUG
     cout << "G4HepRepSceneHandler::AddPrimitive(G4Circle&) " << endl;
 #endif
     if (dontWrite()) return;
 
     if (fProcessing2D) {
       static G4bool warned = false;
       if (!warned) {
     warned = true;
     G4Exception
       ("G4HepRepSceneHandler::AddPrimitive (const G4Circle&)",
        "vis-HepRep1003", JustWarning,
        "2D circles not implemented.  Ignored.");
       }
       return;
     }
 
     HepRepInstance* instance = factory->createHepRepInstance(getEventInstance(), getHitType());
 
     addAttributes(instance, getHitType());
 
     G4Point3D center = transform * circle.GetPosition();
 
     fpVisAttribs = circle.GetVisAttributes();
     setColor (instance, GetColor());
 
     setVisibility(instance, circle);
 
     setMarker(instance, circle);
 
     factory->createHepRepPoint(instance, center.x(), center.y(), center.z());
 }

Here is the call graph for this function:

void G4HepRepSceneHandler::AddPrimitive ( const G4Square & square )

virtual

Implements G4VSceneHandler.

Definition at line 963 of file G4HepRepSceneHandler.cc.

                                                                {
 #ifdef PDEBUG
     cout << "G4HepRepSceneHandler::AddPrimitive(G4Square&) " << endl;
 #endif
     if (dontWrite()) return;
 
     if (fProcessing2D) {
       static G4bool warned = false;
       if (!warned) {
     warned = true;
     G4Exception
       ("G4HepRepSceneHandler::AddPrimitive (const G4Square&)",
        "vis-HepRep1006", JustWarning,
        "2D squares not implemented.  Ignored.");
       }
       return;
     }
 
     HepRepInstance* instance = factory->createHepRepInstance(getEventInstance(), getHitType());
 
     addAttributes(instance, getHitType());
 
     G4Point3D center = transform * square.GetPosition();
 
     setColor (instance, getColorFor(square));
 
     setVisibility(instance, square);
 
     setMarker(instance, square);
 
     factory->createHepRepPoint(instance, center.x(), center.y(), center.z());
 }

Here is the call graph for this function:

void G4HepRepSceneHandler::AddPrimitive ( const G4Polyhedron & polyhedron )

virtual

Implements G4VSceneHandler.

Definition at line 875 of file G4HepRepSceneHandler.cc.

                                                                        {
 
 #ifdef PDEBUG
     cout << "G4HepRepSceneHandler::AddPrimitive(G4Polyhedron&) " << endl;
 #endif
     if (dontWrite()) return;
 
     if (fProcessing2D) {
       static G4bool warned = false;
       if (!warned) {
     warned = true;
     G4Exception
       ("G4HepRepSceneHandler::AddPrimitive (const G4Polyhedron&)",
        "vis-HepRep1004", JustWarning,
        "2D polyhedra not implemented.  Ignored.");
       }
       return;
     }
 
     G4Normal3D surfaceNormal;
     G4Point3D vertex;
 
     if (polyhedron.GetNoFacets()==0) return;
 
     HepRepInstance* instance = getGeometryOrEventInstance(getCalHitType());
         
     addAttributes(instance, getCalHitType());
 
     setVisibility(instance, polyhedron);
     
     G4int currentDepth = 0;
     G4PhysicalVolumeModel* pPVModel =
       dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
     if (pPVModel) currentDepth = pPVModel->GetCurrentDepth();
 
     G4bool notLastFace;
     do {
         HepRepInstance* face;
         if (isEventData()) {
             face = factory->createHepRepInstance(instance, getCalHitFaceType());
         } else {
             face = getGeometryInstance("*Face", currentDepth+1);
             setAttribute(face, "PickParent", true);
             setAttribute(face, "DrawAs", G4String("Polygon"));
         }
         
         setLine(face, polyhedron);
         fpVisAttribs = polyhedron.GetVisAttributes();
         setColor(face, GetColor());
         if (isEventData()) setColor(face, GetColor(), G4String("FillColor"));
 
         notLastFace = polyhedron.GetNextNormal (surfaceNormal);
 
         G4int edgeFlag = 1;
         G4bool notLastEdge;
         do {
             notLastEdge = polyhedron.GetNextVertex (vertex, edgeFlag);
             vertex = transform * vertex;
             factory->createHepRepPoint(face, vertex.x(), vertex.y(), vertex.z());
         } while (notLastEdge);
     } while (notLastFace);
 }

Here is the call graph for this function:

void G4HepRepSceneHandler::AddPrimitive ( const G4Polymarker & line )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 788 of file G4HepRepSceneHandler.cc.

                                                                  {
 
 #ifdef PDEBUG
     cout << "G4HepRepSceneHandler::AddPrimitive(G4Polymarker&) " << line.size() << endl;
 #endif
     if (dontWrite()) return;
 
     if (fProcessing2D) {
       static G4bool warned = false;
       if (!warned) {
     warned = true;
     G4Exception
       ("G4HepRepSceneHandler::AddPrimitive (const G4Polymarker&)",
        "vis-HepRep1002", JustWarning,
        "2D polymarkers not implemented.  Ignored.");
       }
       return;
     }
 
     HepRepInstance* instance = factory->createHepRepInstance(getEventInstance(), getHitType());
 
     addAttributes(instance, getHitType());
 
     fpVisAttribs = line.GetVisAttributes();
     setColor(instance, GetColor());
 
     setVisibility(instance, line);
 
     setMarker(instance, line);
 
     // Default MarkName is set to Circle for this Type.
     int mtype = line.GetMarkerType();
     
     // Cannot be case statement since line.xxx is not a constant
     if (mtype == line.dots) {
         setAttribute(instance, "Fill", true);
         setColor(instance, GetColor(), G4String("FillColor"));
     } else if (mtype == line.circles) {
     } else if (mtype == line.squares) {
         setAttribute(instance, "MarkName", G4String("Box"));
     } else {
         // line.line + default
         setAttribute(instance, "MarkName", G4String("Plus"));
     }
 
     for (size_t i=0; i < line.size(); i++) {
         G4Point3D vertex = transform * line[i];
         factory->createHepRepPoint(instance, vertex.x(), vertex.y(), vertex.z());
     }
 }

Here is the call graph for this function:

void G4HepRepSceneHandler::AddPrimitive ( const G4Scale & scale )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 996 of file G4HepRepSceneHandler.cc.

                                                              { 
     if (dontWrite()) return;
     G4VSceneHandler::AddPrimitive(scale); 
 }

Here is the call graph for this function:

void G4HepRepSceneHandler::AddSolid ( const G4Box & box )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 468 of file G4HepRepSceneHandler.cc.

                                                     {
 #ifdef SDEBUG
     cout << "G4HepRepSceneHandler::AddSolid(const G4Box& box)" << endl;
 #endif
 
     if (dontWrite()) return;
     
     G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
 
     if (! messenger->useSolids()) {
         G4VSceneHandler::AddSolid(box);
         return;
     }
     
     G4double dx = box.GetXHalfLength();
     G4double dy = box.GetYHalfLength();
     G4double dz = box.GetZHalfLength();
     
     G4Point3D vertex1(G4Point3D( dx, dy,-dz));
     G4Point3D vertex2(G4Point3D( dx,-dy,-dz));
     G4Point3D vertex3(G4Point3D(-dx,-dy,-dz));
     G4Point3D vertex4(G4Point3D(-dx, dy,-dz));
     G4Point3D vertex5(G4Point3D( dx, dy, dz));
     G4Point3D vertex6(G4Point3D( dx,-dy, dz));
     G4Point3D vertex7(G4Point3D(-dx,-dy, dz));
     G4Point3D vertex8(G4Point3D(-dx, dy, dz));
     
     vertex1 = (transform) * vertex1;
     vertex2 = (transform) * vertex2;
     vertex3 = (transform) * vertex3;
     vertex4 = (transform) * vertex4;
     vertex5 = (transform) * vertex5;
     vertex6 = (transform) * vertex6;
     vertex7 = (transform) * vertex7;
     vertex8 = (transform) * vertex8;
 
     HepRepInstance* instance = getGeometryOrEventInstance(getCalHitType());
     addAttributes(instance, getCalHitType());
 
     setAttribute(instance, "DrawAs", G4String("Prism"));
         
     setVisibility(instance, box);
     setLine(instance, box);
     setColor(instance, getColorFor(box));
 
     factory->createHepRepPoint(instance, vertex1.x(), vertex1.y(), vertex1.z());
     factory->createHepRepPoint(instance, vertex2.x(), vertex2.y(), vertex2.z());
     factory->createHepRepPoint(instance, vertex3.x(), vertex3.y(), vertex3.z());
     factory->createHepRepPoint(instance, vertex4.x(), vertex4.y(), vertex4.z());
     factory->createHepRepPoint(instance, vertex5.x(), vertex5.y(), vertex5.z());
     factory->createHepRepPoint(instance, vertex6.x(), vertex6.y(), vertex6.z());
     factory->createHepRepPoint(instance, vertex7.x(), vertex7.y(), vertex7.z());
     factory->createHepRepPoint(instance, vertex8.x(), vertex8.y(), vertex8.z());
 }

Here is the call graph for this function:

void G4HepRepSceneHandler::AddSolid ( const G4Cons & cons )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 524 of file G4HepRepSceneHandler.cc.

                                                       {
 #ifdef SDEBUG
     cout << "G4HepRepSceneHandler::AddSolid(const G4Cons& cons)" << endl;
 #endif
 
     if (dontWrite()) return;
     
     G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
 
     if (! messenger->useSolids() || (cons.GetDeltaPhiAngle() < twopi)) {
         G4VSceneHandler::AddSolid(cons);
         return;
     }
 
     G4PhysicalVolumeModel* pPVModel =
       dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
     if (!pPVModel) {
       G4VSceneHandler::AddSolid(cons);
         return;
     }
 
     G4LogicalVolume* pCurrentLV = pPVModel->GetCurrentLV();
     G4int currentDepth = pPVModel->GetCurrentDepth();
     G4Material* pCurrentMaterial = pPVModel->GetCurrentMaterial();
 
     G4Point3D vertex1(G4Point3D( 0., 0., cons.GetZHalfLength()));
     G4Point3D vertex2(G4Point3D( 0., 0.,-cons.GetZHalfLength()));
 
     vertex1 = (transform) * vertex1;
     vertex2 = (transform) * vertex2;
 
     HepRepInstance* instance = getGeometryInstance(pCurrentLV, pCurrentMaterial, currentDepth);
     setAttribute(instance, "DrawAs", G4String("Cylinder"));
         
     setVisibility(instance, cons);
     setLine(instance, cons);
     setColor(instance, getColorFor(cons));
 
     HepRepType* type = getGeometryType(pCurrentLV->GetName(), currentDepth);
 
     // Outer cylinder.
     HepRepInstance* outer = factory->createHepRepInstance(instance, type);
     outer->addAttValue("pickParent",true);
     outer->addAttValue("showParentAttributes",true);
     
     HepRepPoint* op1 = factory->createHepRepPoint(outer, vertex1.x(), vertex1.y(), vertex1.z());
     op1->addAttValue("Radius",cons.GetOuterRadiusPlusZ());
     
     HepRepPoint* op2 = factory->createHepRepPoint(outer, vertex2.x(), vertex2.y(), vertex2.z());
     op2->addAttValue("Radius",cons.GetOuterRadiusMinusZ());
 
     // Inner cylinder.
     HepRepInstance* inner = factory->createHepRepInstance(instance, type);
     inner->addAttValue("pickParent",true);
     inner->addAttValue("showParentAttributes",true);
     
     HepRepPoint* ip1 = factory->createHepRepPoint(inner, vertex1.x(), vertex1.y(), vertex1.z());
     ip1->addAttValue("Radius",cons.GetInnerRadiusPlusZ());
     
     HepRepPoint* ip2 = factory->createHepRepPoint(inner, vertex2.x(), vertex2.y(), vertex2.z());
     ip2->addAttValue("Radius",cons.GetInnerRadiusMinusZ());
 }

Here is the call graph for this function:

void G4HepRepSceneHandler::AddSolid ( const G4Tubs & tubs )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 588 of file G4HepRepSceneHandler.cc.

                                                       {
 #ifdef SDEBUG
     cout << "G4HepRepSceneHandler::AddSolid(const G4Tubs& tubs)" << endl;
 #endif
 
     if (dontWrite()) return;
     
     G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
 
     if (! messenger->useSolids() || (tubs.GetDeltaPhiAngle() < twopi)) {
         G4VSceneHandler::AddSolid(tubs);
         return;
     }
     
     G4PhysicalVolumeModel* pPVModel =
       dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
     if (!pPVModel) {
       G4VSceneHandler::AddSolid(tubs);
         return;
     }
 
     G4LogicalVolume* pCurrentLV = pPVModel->GetCurrentLV();
     G4int currentDepth = pPVModel->GetCurrentDepth();
     G4Material* pCurrentMaterial = pPVModel->GetCurrentMaterial();
 
     G4Point3D vertex1(G4Point3D( 0., 0., tubs.GetZHalfLength()));
     G4Point3D vertex2(G4Point3D( 0., 0.,-tubs.GetZHalfLength()));
 
     vertex1 = (transform) * vertex1;
     vertex2 = (transform) * vertex2;
 
     HepRepInstance* instance = getGeometryInstance(pCurrentLV, pCurrentMaterial, currentDepth);
     setAttribute(instance, "DrawAs", G4String("Cylinder"));
         
     setVisibility(instance, tubs);
     setLine(instance, tubs);
     setColor(instance, getColorFor(tubs));
 
     HepRepType* type = getGeometryType(pCurrentLV->GetName(), currentDepth);
 
     // Outer cylinder.
     HepRepInstance* outer = factory->createHepRepInstance(instance, type);
     outer->addAttValue("Radius",tubs.GetOuterRadius());
     outer->addAttValue("pickParent",true);
     outer->addAttValue("showParentAttributes",true);
     factory->createHepRepPoint(outer, vertex1.x(), vertex1.y(), vertex1.z());
     factory->createHepRepPoint(outer, vertex2.x(), vertex2.y(), vertex2.z());
 
     // Inner cylinder.
     if (tubs.GetInnerRadius() > 0.) {
         HepRepInstance* inner = factory->createHepRepInstance(instance, type);
         inner->addAttValue("Radius",tubs.GetInnerRadius());
         inner->addAttValue("pickParent",true);
         inner->addAttValue("showParentAttributes",true);
         factory->createHepRepPoint(inner, vertex1.x(), vertex1.y(), vertex1.z());
         factory->createHepRepPoint(inner, vertex2.x(), vertex2.y(), vertex2.z());
     }
 }

Here is the call graph for this function:

void G4HepRepSceneHandler::AddSolid ( const G4Trd & trd )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 648 of file G4HepRepSceneHandler.cc.

                                                     {
 #ifdef SDEBUG
     cout << "G4HepRepSceneHandler::AddSolid(const G4Trd& trd)" << endl;
 #endif
     if (dontWrite()) return;
     
     G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
 
     if (! messenger->useSolids()) {
         G4VSceneHandler::AddSolid(trd);
         return;
     }
     
     G4double dx1 = trd.GetXHalfLength1();
     G4double dy1 = trd.GetYHalfLength1();
     G4double dx2 = trd.GetXHalfLength2();
     G4double dy2 = trd.GetYHalfLength2();
     G4double dz = trd.GetZHalfLength();
     
     G4Point3D vertex1(G4Point3D( dx1, dy1,-dz));
     G4Point3D vertex2(G4Point3D( dx1,-dy1,-dz));
     G4Point3D vertex3(G4Point3D(-dx1,-dy1,-dz));
     G4Point3D vertex4(G4Point3D(-dx1, dy1,-dz));
     G4Point3D vertex5(G4Point3D( dx2, dy2, dz));
     G4Point3D vertex6(G4Point3D( dx2,-dy2, dz));
     G4Point3D vertex7(G4Point3D(-dx2,-dy2, dz));
     G4Point3D vertex8(G4Point3D(-dx2, dy2, dz));
     
     vertex1 = (transform) * vertex1;
     vertex2 = (transform) * vertex2;
     vertex3 = (transform) * vertex3;
     vertex4 = (transform) * vertex4;
     vertex5 = (transform) * vertex5;
     vertex6 = (transform) * vertex6;
     vertex7 = (transform) * vertex7;
     vertex8 = (transform) * vertex8;
 
     HepRepInstance* instance = getGeometryOrEventInstance(getCalHitType());
 
     addAttributes(instance, getCalHitType());
 
     setAttribute(instance, "DrawAs", G4String("Prism"));
         
     setVisibility(instance, trd);
     setLine(instance, trd);
     setColor(instance, getColorFor(trd));
 
     factory->createHepRepPoint(instance, vertex1.x(), vertex1.y(), vertex1.z());
     factory->createHepRepPoint(instance, vertex2.x(), vertex2.y(), vertex2.z());
     factory->createHepRepPoint(instance, vertex3.x(), vertex3.y(), vertex3.z());
     factory->createHepRepPoint(instance, vertex4.x(), vertex4.y(), vertex4.z());
     factory->createHepRepPoint(instance, vertex5.x(), vertex5.y(), vertex5.z());
     factory->createHepRepPoint(instance, vertex6.x(), vertex6.y(), vertex6.z());
     factory->createHepRepPoint(instance, vertex7.x(), vertex7.y(), vertex7.z());
     factory->createHepRepPoint(instance, vertex8.x(), vertex8.y(), vertex8.z());
 }

Here is the call graph for this function:

void G4HepRepSceneHandler::AddSolid ( const G4Trap & trap )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 705 of file G4HepRepSceneHandler.cc.

                                                        { 
     if (dontWrite()) return;
     G4VSceneHandler::AddSolid (trap); 
 }

Here is the call graph for this function:

void G4HepRepSceneHandler::AddSolid ( const G4Sphere & sphere )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 710 of file G4HepRepSceneHandler.cc.

                                                            { 
     if (dontWrite()) return;
     G4VSceneHandler::AddSolid (sphere); 
 }

Here is the call graph for this function:

void G4HepRepSceneHandler::AddSolid ( const G4Para & para )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 715 of file G4HepRepSceneHandler.cc.

                                                        { 
     if (dontWrite()) return;
     G4VSceneHandler::AddSolid (para); 
 }

Here is the call graph for this function:

void G4HepRepSceneHandler::AddSolid ( const G4Torus & torus )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 720 of file G4HepRepSceneHandler.cc.

                                                          { 
     if (dontWrite()) return;
     G4VSceneHandler::AddSolid (torus); 
 }

Here is the call graph for this function:

void G4HepRepSceneHandler::AddSolid ( const G4Polycone & polycone )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 725 of file G4HepRepSceneHandler.cc.

                                                                {
   if (dontWrite()) return;
   G4VSceneHandler::AddSolid (polycone);
 }

Here is the call graph for this function:

void G4HepRepSceneHandler::AddSolid ( const G4Polyhedra & polyhedra )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 730 of file G4HepRepSceneHandler.cc.

                                                                  {
   if (dontWrite()) return;
   G4VSceneHandler::AddSolid (polyhedra);
 }

Here is the call graph for this function:

void G4HepRepSceneHandler::AddSolid ( const G4Orb & orb )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 735 of file G4HepRepSceneHandler.cc.

                                                      {
   if (dontWrite()) return;
   G4VSceneHandler::AddSolid (orb);
 }

Here is the call graph for this function:

void G4HepRepSceneHandler::AddSolid ( const G4Ellipsoid & ellipsoid )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 740 of file G4HepRepSceneHandler.cc.

                                                                  {
   if (dontWrite()) return;
   G4VSceneHandler::AddSolid (ellipsoid);
 }

Here is the call graph for this function:

void G4HepRepSceneHandler::AddSolid ( const G4VSolid & solid )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 745 of file G4HepRepSceneHandler.cc.

                                                           {
     if (dontWrite()) return;
     G4VSceneHandler::AddSolid(solid); 
 }

Here is the call graph for this function:

void G4HepRepSceneHandler::BeginModeling ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 453 of file G4HepRepSceneHandler.cc.

                                          {
 #ifdef SDEBUG
     cout << "G4HepRepSceneHandler::BeginModeling() " << endl;
 #endif
     G4VSceneHandler::BeginModeling();
 }

Here is the call graph for this function:

void G4HepRepSceneHandler::BeginPrimitives ( const G4Transform3D & objectTransformation )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1044 of file G4HepRepSceneHandler.cc.

                                                                                      {
 #ifdef SDEBUG
     cout << "G4HepRepSceneHandler::BeginPrimitives(G4Transform3D&)" << endl;
 #endif
 
     G4VSceneHandler::BeginPrimitives (objectTransformation);
     transform = objectTransformation;
 }

Here is the call graph for this function:

void G4HepRepSceneHandler::closeFile ( )

Definition at line 435 of file G4HepRepSceneHandler.cc.

                                      {
     writer->close();
     delete writer;
     writer = NULL;
 
     delete out;
     out = NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool G4HepRepSceneHandler::closeHepRep ( bool final = false )

Returns true if the HepRep was (already) closed, false if the HepRep is still open

Definition at line 295 of file G4HepRepSceneHandler.cc.

                                                  {
     if (_heprep == NULL) return true;
 
 #ifdef LDEBUG
     cout << "G4HepRepSceneHandler::CloseHepRep() start" << endl;
 #endif
 
     // if this is the final close, then there should not be any event pending to be written.
     if (final) {
         if (_eventInstanceTree != NULL) {
             cerr << "WARNING: you probably used '/vis/viewer/endOfEventAction accumulate' and "
                  << "forgot to call /vis/viewer/update before exit. No event written." << endl;
         }
     } else {
         
         G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
 
         // add geometry to the heprep if there is an event (separate geometries are written
         // using DrawView() called from /vis/viewer/flush)
         if (_eventInstanceTree != NULL) {
             GetCurrentViewer()->DrawView();
         
             // couple geometry
 
             if ( messenger->appendGeometry()) {
                 // couple geometry to event if geometry was written
                 if ((_geometryInstanceTree != NULL)) {
                     getEventInstanceTree()->addInstanceTree(getGeometryInstanceTree());
                 }
             } else {
                 char name[128];
                 if (writeMultipleFiles) {
                     sprintf(name, "%s%s%s#%s", baseName.c_str(), "-geometry", extension.c_str(), "G4GeometryData");
                 } else {
                     sprintf(name, "%s%s#%s", "geometry", (writeBinary ? ".bheprep" : ".heprep"), "G4GeometryData");
                 }   
                 getEventInstanceTree()->addInstanceTree(factory->createHepRepTreeID(name, "1.0"));
             }
         }
     
         // force inclusion of all subtypes of event
         if (_eventInstanceTree != NULL) {
             getEventType();
             getTrajectoryType();
             getHitType();
             getCalHitType();
             getCalHitFaceType();
         }
     
         // Give this HepRep all of the layer order info for both geometry and event,
         // since these will both end up in a single HepRep.
         writeLayers(_heprepGeometry);
         writeLayers(_heprep);
 
         // open heprep file
         if (writer == NULL) {
             open((GetScene() == NULL) ? G4String("G4HepRepOutput.heprep.zip") : GetScene()->GetName());
         }
 
         // write out separate geometry
         if (! messenger->appendGeometry() && (_heprepGeometry != NULL)) {
             if (writeMultipleFiles) {
                 char fileName[128];
                 sprintf(fileName, "%s%s%s", baseName.c_str(), "-geometry", extension.c_str());
                 openFile(G4String(fileName));
             }
 
             char name[128];
             sprintf(name, "%s%s", "geometry", (writeBinary ? ".bheprep" : ".heprep"));
             if (!writeMultipleFiles) {
                 writer->addProperty("RecordLoop.ignore", name);
             }
 
             writer->write(_heprepGeometry, G4String(name));
             
             delete _heprepGeometry;
             _heprepGeometry = NULL;
             
             if (writeMultipleFiles) closeFile();
         }
     
         if (writeMultipleFiles) {
 // NOTE: does not work on Solaris 5.2 and Linux 2.95.2
 //            stringstream fileName;
 //            fileName << baseName << eventNumberPrefix << setw(eventNumberWidth) << setfill('0') << eventNumber << eventNumberSuffix << extension;
 //            openFile(fileName.str());
 // Use instead:
             char fileName[128];
             char fileFormat[128];
             sprintf(fileFormat, "%s%d%s", "%s%s%0", eventNumberWidth, "d%s%s");
             sprintf(fileName, fileFormat, baseName.c_str(), eventNumberPrefix.c_str(), eventNumber, eventNumberSuffix.c_str(), extension.c_str());
             openFile(G4String(fileName));
         }
             
         // write out the heprep
 // NOTE: does not work on Solaris 5.2 and Linux 2.95.2
 //        stringstream eventName;
 //        eventName << "event-" << setw(eventNumberWidth) << setfill('0') << eventNumber << (writeBinary ? ".bheprep" : ".heprep");
 //        writer->write(_heprep, eventName.str());
 // Use instead:
         char eventName[128];
         char eventFormat[128];
         sprintf(eventFormat, "%s%d%s%s", "event-%0", eventNumberWidth, "d", (writeBinary ? ".bheprep" : ".heprep"));
         sprintf(eventName, eventFormat, eventNumber);
         if (writer) writer->write(_heprep, G4String(eventName));
 
         eventNumber++;
     }
     
     delete _heprep;
     _heprep = NULL;
 
     if (writeMultipleFiles) closeFile();
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4HepRepSceneHandler::EndModeling ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 461 of file G4HepRepSceneHandler.cc.

                                        {
 #ifdef SDEBUG
     cout << "G4HepRepSceneHandler::EndModeling() " << endl;
 #endif
     G4VSceneHandler::EndModeling();
 }

Here is the call graph for this function:

void G4HepRepSceneHandler::EndPrimitives ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1054 of file G4HepRepSceneHandler.cc.

                                           {
 #ifdef SDEBUG
     cout << "G4HepRepSceneHandler::EndPrimitives" << endl;
 #endif
     G4VSceneHandler::EndPrimitives ();
 }

Here is the call graph for this function:

void G4HepRepSceneHandler::openFile ( G4String name )

Definition at line 430 of file G4HepRepSceneHandler.cc.

                                                  {
     out = new ofstream(name.c_str(), std::ios::out | std::ios::binary );
     writer = factory->createHepRepWriter(out, writeZip, writeZip || writeGZ);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4HepRepSceneHandler::openHepRep ( )

Definition at line 265 of file G4HepRepSceneHandler.cc.

                                       {
 #ifdef LDEBUG
     cout << "G4HepRepSceneHandler::OpenHepRep() " << endl;
 #endif
 
     if (_heprep != NULL) return;
 
     // all done on demand, once pointers are set to NULL
     _heprepGeometry       = NULL;
     _geometryInstanceTree = NULL;
     _geometryRootInstance = NULL;
     _geometryInstance.clear();
     _geometryTypeTree     = NULL;
     _geometryRootType     = NULL;
     _geometryTypeName.clear();
     _geometryType.clear();
     _eventInstanceTree    = NULL;
     _eventInstance        = NULL;
     _eventTypeTree        = NULL;
     _eventType            = NULL;
     _trajectoryType       = NULL;
     _hitType              = NULL;
     _calHitType           = NULL;
     _calHitFaceType       = NULL;     
 }

Here is the caller graph for this function:

void G4HepRepSceneHandler::PostAddSolid ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1036 of file G4HepRepSceneHandler.cc.

                                          {
 #ifdef SDEBUG
     cout << "G4HepRepSceneHandler::PostAddSolid()" << endl;
 #endif
     G4VSceneHandler::PostAddSolid();
 }

Here is the call graph for this function:

void G4HepRepSceneHandler::PreAddSolid	(	const G4Transform3D &	objectTransformation,
		const G4VisAttributes &	visAttribs
	)

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1024 of file G4HepRepSceneHandler.cc.

                                                      {
 
     G4VSceneHandler::PreAddSolid (objectTransformation, visAttribs);
 
     transform = objectTransformation;
 #ifdef SDEBUG
     cout << "G4HepRepSceneHandler::PreAddSolid(G4Transform3D&, G4VisAttributes&)" << endl;
 #endif
 }

Here is the call graph for this function:

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

source/geant4.10.03.p02/source/visualization/HepRep/include/G4HepRepSceneHandler.hh
source/geant4.10.03.p02/source/visualization/HepRep/src/G4HepRepSceneHandler.cc

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation