#include <G4HepRepFileSceneHandler.hh>

Inheritance diagram for G4HepRepFileSceneHandler:

Collaboration diagram for G4HepRepFileSceneHandler:

Public Member Functions
	G4HepRepFileSceneHandler (G4VGraphicsSystem &system, const G4String &name)

virtual	~G4HepRepFileSceneHandler ()

void	AddSolid (const G4Box &)

void	AddSolid (const G4Cons &)

void	AddSolid (const G4Tubs &)

void	AddSolid (const G4Trd &)

void	AddSolid (const G4Trap &)

void	AddSolid (const G4Sphere &)

void	AddSolid (const G4Para &)

void	AddSolid (const G4Torus &)

void	AddSolid (const G4Polycone &)

void	AddSolid (const G4Polyhedra &)

void	AddSolid (const G4VSolid &)

void	AddCompound (const G4VTrajectory &)

void	InitTrajectory ()

void	AddCompound (const G4VHit &)

void	InitHit ()

void	AddCompound (const G4THitsMap< G4double > &hits)

void	AddCompound (const G4VDigi &digi)

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

void	EndModeling ()

void	BeginPrimitives2D (const G4Transform3D &objectTransformation)

void	EndPrimitives2D ()

void	ClearTransientStore ()

G4HepRepFileXMLWriter *	GetHepRepXMLWriter ()

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

virtual	~G4VSceneHandler ()

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

virtual void	PostAddSolid ()

virtual void	BeginPrimitives (const G4Transform3D &objectTransformation)

virtual void	EndPrimitives ()

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 G4Visible &)

const G4Colour &	GetColor (const G4Visible &)

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

G4int	IncrementViewCount ()

virtual void	ClearStore ()

void	AddViewerToList (G4VViewer *pView)

void	RemoveViewerFromList (G4VViewer *pView)

Public Member Functions inherited from G4VGraphicsScene
	G4VGraphicsScene ()

virtual	~G4VGraphicsScene ()

Static Protected Attributes
static G4int	fSceneIdCount = 0

Private Member Functions
void	AddHepRepInstance (const char *primName, const G4Visible visible)

void	CheckFileOpen ()

Private Attributes
G4HepRepFileXMLWriter *	hepRepXMLWriter

int	fileCounter

G4bool	haveVisible

G4bool	inPrimitives2D

G4bool	warnedAbout3DText

G4bool	warnedAbout2DMarkers

G4bool	drawingTraj

G4bool	doneInitTraj

G4bool	drawingHit

G4bool	doneInitHit

const G4VisTrajContext *	trajContext

std::vector< G4AttValue > *	trajAttValues

std::map< G4String, G4AttDef > *	trajAttDefs

std::vector< G4AttValue > *	hitAttValues

std::map< G4String, G4AttDef > *	hitAttDefs

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

Definition at line 59 of file G4HepRepFileSceneHandler.hh.

Constructor & Destructor Documentation

◆ G4HepRepFileSceneHandler()

G4HepRepFileSceneHandler::G4HepRepFileSceneHandler	(	G4VGraphicsSystem &	system,
		const G4String &	name
	)

Definition at line 70 of file G4HepRepFileSceneHandler.cc.

                                                                         :
 G4VSceneHandler(system, fSceneIdCount++, name)
 {
     hepRepXMLWriter = ((G4HepRepFile*)(&system))->GetHepRepXMLWriter();
     fileCounter = 0;
     
     inPrimitives2D = false;
     warnedAbout3DText = false;
     warnedAbout2DMarkers = false;
     haveVisible = false;
     drawingTraj = false;
     doneInitTraj = false;
     drawingHit = false;
     doneInitHit = false;
         trajContext = 0;
         trajAttValues = 0;
         trajAttDefs = 0;
         hitAttValues = 0;
         hitAttDefs = 0;
 }

Here is the call graph for this function:

◆ ~G4HepRepFileSceneHandler()

G4HepRepFileSceneHandler::~G4HepRepFileSceneHandler ( )

virtual

Definition at line 93 of file G4HepRepFileSceneHandler.cc.

93 {}

Member Function Documentation

◆ AddCompound() [1/4]

void G4HepRepFileSceneHandler::AddCompound ( const G4VTrajectory & traj )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 485 of file G4HepRepFileSceneHandler.cc.

                                                                      {
 #ifdef G4HEPREPFILEDEBUG
     G4cout << "G4HepRepFileSceneHandler::AddCompound(const G4VTrajectory&) " << G4endl;
 #endif
     
     G4TrajectoriesModel* pTrModel =
         dynamic_cast<G4TrajectoriesModel*>(fpModel);
     if (!pTrModel) G4Exception
       ("G4HepRepFileSceneHandler::AddCompound(const G4VTrajectory&)",
        "vis-HepRep0001", FatalException, "Not a G4TrajectoriesModel.");
     
     // Pointers to hold trajectory attribute values and definitions.
     std::vector<G4AttValue>* rawTrajAttValues = traj.CreateAttValues();
     trajAttValues =
         new std::vector<G4AttValue>;
     trajAttDefs =
         new std::map<G4String,G4AttDef>;
     
     // Iterators to use with attribute values and definitions.
     std::vector<G4AttValue>::iterator iAttVal;
     std::map<G4String,G4AttDef>::const_iterator iAttDef;
     G4int i;
     
     // Get trajectory attributes and definitions in standard HepRep style
     // (uniform units, 3Vectors decomposed).
     if (rawTrajAttValues) {
         G4bool error = G4AttCheck(rawTrajAttValues,
                                   traj.GetAttDefs()).Standard(trajAttValues,trajAttDefs);
         if (error) {
             G4cout << "G4HepRepFileSceneHandler::AddCompound(traj):"
             "\nERROR found during conversion to standard trajectory attributes."
             << G4endl;
         }
 #ifdef G4HEPREPFILEDEBUG 
         G4cout <<
             "G4HepRepFileSceneHandler::AddCompound(traj): standardised attributes:\n"
             << G4AttCheck(trajAttValues,trajAttDefs) << G4endl;
 #endif
         delete rawTrajAttValues;
     }
     
     // Open the HepRep output file if it is not already open.
     CheckFileOpen();
     
     // Add the Event Data Type if it hasn't already been added.
     if (strcmp("Event Data",hepRepXMLWriter->prevTypeName[0])!=0) {
         hepRepXMLWriter->addType("Event Data",0);
         hepRepXMLWriter->addInstance();
     }
     
     // Add the Trajectories Type.
     G4String previousName = hepRepXMLWriter->prevTypeName[1];
     hepRepXMLWriter->addType("Trajectories",1);
     
     // If this is the first trajectory of this event,
     // specify attribute values common to all trajectories.
     if (strcmp("Trajectories",previousName)!=0) {
         hepRepXMLWriter->addAttValue("Layer",100);
         
         // Take all Trajectory attDefs from first trajectory.
         // Would rather be able to get these attDefs without needing a reference from any
         // particular trajectory, but don't know how to do that.
         // Write out trajectory attribute definitions.
         if (trajAttValues && trajAttDefs) {
             for (iAttVal = trajAttValues->begin();
                  iAttVal != trajAttValues->end(); ++iAttVal) {
                 iAttDef = trajAttDefs->find(iAttVal->GetName());
                 if (iAttDef != trajAttDefs->end()) {
                     // Protect against incorrect use of Category.  Anything value other than the
                     // standard ones will be considered to be in the physics category.
                     G4String category = iAttDef->second.GetCategory();
                     if (strcmp(category,"Draw")!=0 &&
                         strcmp(category,"Physics")!=0 &&
                         strcmp(category,"Association")!=0 &&
                         strcmp(category,"PickAction")!=0)
                         category = "Physics";
                     hepRepXMLWriter->addAttDef(iAttVal->GetName(), iAttDef->second.GetDesc(),
                                                category, iAttDef->second.GetExtra());
                 }
             } 
         }
         
         // Take all TrajectoryPoint attDefs from first point of first trajectory.
         // Would rather be able to get these attDefs without needing a reference from any
         // particular point, but don't know how to do that.
         if ((trajContext->GetDrawStepPts() || trajContext->GetDrawAuxPts())
             && traj.GetPointEntries()>0) {
             G4VTrajectoryPoint* aTrajectoryPoint = traj.GetPoint(0);
             
             // Pointers to hold trajectory point attribute values and definitions.
             std::vector<G4AttValue>* rawPointAttValues = aTrajectoryPoint->CreateAttValues();
             std::vector<G4AttValue>* pointAttValues =
             new std::vector<G4AttValue>;
             std::map<G4String,G4AttDef>* pointAttDefs =
             new std::map<G4String,G4AttDef>;
             
             // Get first trajectory point's attributes and definitions in standard HepRep style
             // (uniform units, 3Vectors decomposed).
             if (rawPointAttValues) {
                 G4bool error = G4AttCheck(rawPointAttValues,
                                           aTrajectoryPoint->GetAttDefs()).Standard(pointAttValues,pointAttDefs);
                 if (error) {
                     G4cout << "G4HepRepFileSceneHandler::AddCompound(traj):"
                     "\nERROR found during conversion to standard first point attributes." << G4endl;
                 }
                 
                 // Write out point attribute definitions.
                 if (pointAttValues && pointAttDefs) {
                     for (iAttVal = pointAttValues->begin();
                          iAttVal != pointAttValues->end(); ++iAttVal) {
                         iAttDef =
                         pointAttDefs->find(iAttVal->GetName());
                         if (iAttDef != pointAttDefs->end()) {
                             // Protect against incorrect use of Category.  Anything value other than the
                             // standard ones will be considered to be in the physics category.
                             G4String category = iAttDef->second.GetCategory();
                             if (strcmp(category,"Draw")!=0 &&
                                 strcmp(category,"Physics")!=0 &&
                                 strcmp(category,"Association")!=0 &&
                                 strcmp(category,"PickAction")!=0)
                                 category = "Physics";
                             // Do not write out the Aux or Pos attribute.  Aux does not conform to the HepRep rule
                             // that each object can have only one instance of a given AttValue.
                             // Both of these attributes are redundant to actual position information of the point.
                             if (strcmp(iAttVal->GetName(),"Aux-X")!=0 &&
                                 strcmp(iAttVal->GetName(),"Aux-Y")!=0 &&
                                 strcmp(iAttVal->GetName(),"Aux-Z")!=0 &&
                                 strcmp(iAttVal->GetName(),"Pos-X")!=0 &&
                                 strcmp(iAttVal->GetName(),"Pos-Y")!=0 &&
                                 strcmp(iAttVal->GetName(),"Pos-Z")!=0)
                                 hepRepXMLWriter->addAttDef(iAttVal->GetName(), iAttDef->second.GetDesc(),
                                                         category, iAttDef->second.GetExtra());
                         }
                     }
                 }
                 delete rawPointAttValues;
             }
             
             // Clean up point attributes.
             if (pointAttValues)
                 delete pointAttValues;
             if (pointAttDefs)
                 delete pointAttDefs;
         }
     } // end of special treatment for when this is the first trajectory.
     
     // Now that we have written out all of the attributes that are based on the
     // trajectory's particulars, call base class to deconstruct trajectory into polyline and/or points
     // (or nothing if trajectory is to be filtered out).
     // If base class calls for drawing points, no points will actually be drawn there since we
     // instead need to do point drawing from here (in order to obtain the points attributes,
     // not available from AddPrimitive(...point).  Instead, such a call will just serve to set the
     // flag that tells us that point drawing was requested for this trajectory (depends on several
     // factors including trajContext and filtering).
     drawingTraj = true;
     doneInitTraj = false;
     G4VSceneHandler::AddCompound(traj);
     drawingTraj = false;
     
     // Draw step points.
     if (trajContext->GetDrawStepPts()) {
         if (!doneInitTraj)
             InitTrajectory();
         // Create Trajectory Points as a subType of Trajectories.
         // Note that we should create this heprep type even if there are no actual points.
         // This allows the user to tell that points don't exist (admittedly odd) rather
         // than that they were omitted by the drawing mode.
         previousName = hepRepXMLWriter->prevTypeName[2];
         hepRepXMLWriter->addType("Trajectory Step Points",2);
 
         float redness;
         float greenness;
         float blueness;         
         G4int markSize;
         G4bool visible;
         G4bool square;
         G4Colour colour = trajContext->GetStepPtsColour();
         redness = colour.GetRed();
         greenness = colour.GetGreen();
         blueness = colour.GetBlue();
         markSize = (G4int) trajContext->GetStepPtsSize();
         visible = (G4int) trajContext->GetStepPtsVisible();
         square = (trajContext->GetStepPtsType()==G4Polymarker::squares);
 
         // Avoiding drawing anything black on black.  
         if (redness==0. && greenness==0. && blueness==0.) {
             redness = 1.;
             greenness = 1.;
             blueness = 1.;
         }
         
         // Specify attributes common to all trajectory points.
         if (strcmp("Trajectory Step Points",previousName)!=0) {
             hepRepXMLWriter->addAttValue("DrawAs","Point");
             hepRepXMLWriter->addAttValue("MarkColor", redness, greenness, blueness);
             hepRepXMLWriter->addAttValue("MarkSize",markSize);
             hepRepXMLWriter->addAttValue("Layer",110);
             hepRepXMLWriter->addAttValue("Visibility",visible);
             if (square)
                 hepRepXMLWriter->addAttValue("MarkName","square");
             else
                 hepRepXMLWriter->addAttValue("MarkName","dot");
         }
         
         // Loop over all points on this trajectory.
         for (i = 0; i < traj.GetPointEntries(); i++) {
             G4VTrajectoryPoint* aTrajectoryPoint = traj.GetPoint(i);
             
             // Each point is a separate instance of the type Trajectory Points.
             hepRepXMLWriter->addInstance();
             
             // Pointers to hold trajectory point attribute values and definitions.
             std::vector<G4AttValue>* rawPointAttValues = aTrajectoryPoint->CreateAttValues();
             std::vector<G4AttValue>* pointAttValues =
                 new std::vector<G4AttValue>;
             std::map<G4String,G4AttDef>* pointAttDefs =
                 new std::map<G4String,G4AttDef>;
             
             // Get trajectory point attributes and definitions in standard HepRep style
             // (uniform units, 3Vectors decomposed).
             if (rawPointAttValues) {
                 G4bool error = G4AttCheck(rawPointAttValues,
                                           aTrajectoryPoint->GetAttDefs()).Standard(pointAttValues,pointAttDefs);
                 if (error) {
                     G4cout << "G4HepRepFileSceneHandler::AddCompound(traj):"
                     "\nERROR found during conversion to standard point attributes." << G4endl;
                 }
                 
                 // Write out point attribute values.
                 if (pointAttValues) {
                     for (iAttVal = pointAttValues->begin();
                          iAttVal != pointAttValues->end(); ++iAttVal)
                         // Do not write out the Aux or Pos attribute.  Aux does not conform to the HepRep rule
                         // that each object can have only one instance of a given AttValue.
                         // Both of these attributes are redundant to actual position information of the point.
                         if (strcmp(iAttVal->GetName(),"Aux-X")!=0 &&
                             strcmp(iAttVal->GetName(),"Aux-Y")!=0 &&
                             strcmp(iAttVal->GetName(),"Aux-Z")!=0 &&
                             strcmp(iAttVal->GetName(),"Pos-X")!=0 &&
                             strcmp(iAttVal->GetName(),"Pos-Y")!=0 &&
                             strcmp(iAttVal->GetName(),"Pos-Z")!=0)
                             hepRepXMLWriter->addAttValue(iAttVal->GetName(), iAttVal->GetValue());
                 }
             }
             
             // Clean up point attributes.
                         delete pointAttDefs;
                         delete pointAttValues;
                         delete rawPointAttValues;
 
             // Each trajectory point is made of a single primitive, a point.
             hepRepXMLWriter->addPrimitive();
             G4Point3D vertex = aTrajectoryPoint->GetPosition();
             hepRepXMLWriter->addPoint(vertex.x(), vertex.y(), vertex.z());
         }
     }
     
     // Draw Auxiliary Points
     if (trajContext->GetDrawAuxPts()) {
         if (!doneInitTraj)
             InitTrajectory();
         // Create Trajectory Points as a subType of Trajectories.
         // Note that we should create this heprep type even if there are no actual points.
         // This allows the user to tell that points don't exist (admittedly odd) rather
         // than that they were omitted by the drawing mode.
         previousName = hepRepXMLWriter->prevTypeName[2];
         hepRepXMLWriter->addType("Trajectory Auxiliary Points",2);
 
         float redness;
         float greenness;
         float blueness;         
         G4int markSize;
         G4bool visible;
         G4bool square;
         G4Colour colour = trajContext->GetAuxPtsColour();
         redness = colour.GetRed();
         greenness = colour.GetGreen();
         blueness = colour.GetBlue();
         markSize = (G4int) trajContext->GetAuxPtsSize();
         visible = (G4int) trajContext->GetAuxPtsVisible();
         square = (trajContext->GetAuxPtsType()==G4Polymarker::squares);
 
         // Avoiding drawing anything black on black.  
         if (redness==0. && greenness==0. && blueness==0.) {
             redness = 1.;
             greenness = 1.;
             blueness = 1.;
         }
         
         // Specify attributes common to all trajectory points.
         if (strcmp("Trajectory Auxiliary Points",previousName)!=0) {
             hepRepXMLWriter->addAttValue("DrawAs","Point");
             hepRepXMLWriter->addAttValue("MarkColor", redness, greenness, blueness);
             hepRepXMLWriter->addAttValue("MarkSize",markSize);
             hepRepXMLWriter->addAttValue("Layer",110);
             hepRepXMLWriter->addAttValue("Visibility",visible);
             if (square)
                 hepRepXMLWriter->addAttValue("MarkName","Square");
             else
                 hepRepXMLWriter->addAttValue("MarkName","Dot");
         }
         
         // Loop over all points on this trajectory.
         for (i = 0; i < traj.GetPointEntries(); i++) {
             G4VTrajectoryPoint* aTrajectoryPoint = traj.GetPoint(i);
             
             // Each point is a separate instance of the type Trajectory Points.
             hepRepXMLWriter->addInstance();
             
             // Pointers to hold trajectory point attribute values and definitions.
             std::vector<G4AttValue>* rawPointAttValues = aTrajectoryPoint->CreateAttValues();
             std::vector<G4AttValue>* pointAttValues =
                 new std::vector<G4AttValue>;
             std::map<G4String,G4AttDef>* pointAttDefs =
                 new std::map<G4String,G4AttDef>;
             
             // Get trajectory point attributes and definitions in standard HepRep style
             // (uniform units, 3Vectors decomposed).
             if (rawPointAttValues) {
                 G4bool error = G4AttCheck(rawPointAttValues,
                                           aTrajectoryPoint->GetAttDefs()).Standard(pointAttValues,pointAttDefs);
                 if (error) {
                     G4cout << "G4HepRepFileSceneHandler::AddCompound(traj):"
                     "\nERROR found during conversion to standard point attributes." << G4endl;
                 }
                 
                 // Write out point attribute values.
                 if (pointAttValues) {
                     for (iAttVal = pointAttValues->begin();
                          iAttVal != pointAttValues->end(); ++iAttVal)
                         // Do not write out the Aux or Pos attribute.  Aux does not conform to the HepRep rule
                         // that each object can have only one instance of a given AttValue.
                         // Both of these attributes are redundant to actual position information of the point.
                         if (strcmp(iAttVal->GetName(),"Aux-X")!=0 &&
                             strcmp(iAttVal->GetName(),"Aux-Y")!=0 &&
                             strcmp(iAttVal->GetName(),"Aux-Z")!=0 &&
                             strcmp(iAttVal->GetName(),"Pos-X")!=0 &&
                             strcmp(iAttVal->GetName(),"Pos-Y")!=0 &&
                             strcmp(iAttVal->GetName(),"Pos-Z")!=0)
                             hepRepXMLWriter->addAttValue(iAttVal->GetName(), iAttVal->GetValue());
                 }
             }
             
             // Clean up point attributes.
             delete pointAttDefs;
                         delete pointAttValues;
                         delete rawPointAttValues;
 
             // Each trajectory point is made of a single primitive, a point.
             G4Point3D vertex = aTrajectoryPoint->GetPosition();
             
             // Loop over auxiliary points associated with this Trajectory Point.
             const std::vector<G4ThreeVector>* auxiliaries = aTrajectoryPoint->GetAuxiliaryPoints();
             if (0 != auxiliaries) {
                 for (size_t iAux=0; iAux<auxiliaries->size(); ++iAux) {
                     const G4ThreeVector auxPos((*auxiliaries)[iAux]);
                     hepRepXMLWriter->addPrimitive();
                     hepRepXMLWriter->addPoint(auxPos.x(), auxPos.y(), auxPos.z());
                 }
             }
         }
     }
 }

Here is the call graph for this function:

◆ AddCompound() [2/4]

void G4HepRepFileSceneHandler::AddCompound ( const G4VHit & hit )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 850 of file G4HepRepFileSceneHandler.cc.

                                                              {
 #ifdef G4HEPREPFILEDEBUG
     G4cout << "G4HepRepFileSceneHandler::AddCompound(G4VHit&) " << G4endl;
 #endif
     
     // Pointers to hold hit attribute values and definitions.
     std::vector<G4AttValue>* rawHitAttValues = hit.CreateAttValues();
     hitAttValues =
         new std::vector<G4AttValue>;
     hitAttDefs =
         new std::map<G4String,G4AttDef>;
     
     // Iterators to use with attribute values and definitions.
     std::vector<G4AttValue>::iterator iAttVal;
     std::map<G4String,G4AttDef>::const_iterator iAttDef;
     
     // Get hit attributes and definitions in standard HepRep style
     // (uniform units, 3Vectors decomposed).
     if (rawHitAttValues) {
         G4bool error = G4AttCheck(rawHitAttValues,
                                   hit.GetAttDefs()).Standard(hitAttValues,hitAttDefs);
         if (error) {
             G4cout << "G4HepRepFileSceneHandler::AddCompound(hit):"
             "\nERROR found during conversion to standard hit attributes."
             << G4endl;
         }
 #ifdef G4HEPREPFILEDEBUG 
         G4cout <<
             "G4HepRepFileSceneHandler::AddCompound(hit): standardised attributes:\n"
             << G4AttCheck(hitAttValues,hitAttDefs) << G4endl;
 #endif
         delete rawHitAttValues;
     }
     
     // Open the HepRep output file if it is not already open.
     CheckFileOpen();
     
     // Add the Event Data Type if it hasn't already been added.
     if (strcmp("Event Data",hepRepXMLWriter->prevTypeName[0])!=0) {
         hepRepXMLWriter->addType("Event Data",0);
         hepRepXMLWriter->addInstance();
     }
     
     // Find out the current HitType.
     G4String hitType = "Hits";
     if (hitAttValues) {
         G4bool found = false;
         for (iAttVal = hitAttValues->begin();
              iAttVal != hitAttValues->end() && !found; ++iAttVal) {
             if (strcmp(iAttVal->GetName(),"HitType")==0) {
                 hitType = iAttVal->GetValue();
                 found = true;
             }
         }
     }
     
     // Add the Hits Type.
     G4String previousName = hepRepXMLWriter->prevTypeName[1];
     hepRepXMLWriter->addType(hitType,1);
     
     // If this is the first hit of this event,
     // specify attribute values common to all hits.
     if (strcmp(hitType,previousName)!=0) {
         hepRepXMLWriter->addAttValue("Layer",130);
         
         // Take all Hit attDefs from first hit.
         // Would rather be able to get these attDefs without needing a reference from any
         // particular hit, but don't know how to do that.
         // Write out hit attribute definitions.
         if (hitAttValues && hitAttDefs) {
             for (iAttVal = hitAttValues->begin();
                  iAttVal != hitAttValues->end(); ++iAttVal) {
                 iAttDef = hitAttDefs->find(iAttVal->GetName());
                 if (iAttDef != hitAttDefs->end()) {
                     // Protect against incorrect use of Category.  Anything value other than the
                     // standard ones will be considered to be in the physics category.
                     G4String category = iAttDef->second.GetCategory();
                     if (strcmp(category,"Draw")!=0 &&
                         strcmp(category,"Physics")!=0 &&
                         strcmp(category,"Association")!=0 &&
                         strcmp(category,"PickAction")!=0)
                         category = "Physics";
                     hepRepXMLWriter->addAttDef(iAttVal->GetName(), iAttDef->second.GetDesc(),
                                                category, iAttDef->second.GetExtra());
                 }
             }
         }
     } // end of special treatment for when this is the first hit.
     
     // Now that we have written out all of the attributes that are based on the
     // hit's particulars, call base class to deconstruct hit into a primitives.
     drawingHit = true;
     doneInitHit = false;
     G4VSceneHandler::AddCompound(hit);  // Invoke default action.
     drawingHit = false;
 }

Here is the call graph for this function:

◆ AddCompound() [3/4]

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

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 83 of file G4HepRepFileSceneHandler.hh.

                                                       {
     G4VSceneHandler::AddCompound(hits);
   }

Here is the call graph for this function:

◆ AddCompound() [4/4]

void G4HepRepFileSceneHandler::AddCompound ( const G4VDigi & digi )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 86 of file G4HepRepFileSceneHandler.hh.

                                          {
     G4VSceneHandler::AddCompound(digi);
   }

Here is the call graph for this function:

◆ AddHepRepInstance()

void G4HepRepFileSceneHandler::AddHepRepInstance	(	const char *	primName,
		const G4Visible	visible
	)

private

Definition at line 1278 of file G4HepRepFileSceneHandler.cc.

                                                                           {
 #ifdef G4HEPREPFILEDEBUG
     G4cout <<
     "G4HepRepFileSceneHandler::AddHepRepInstance called."
     << G4endl;
 #endif
     
     // Open the HepRep output file if it is not already open.
     CheckFileOpen();
     
     G4VPhysicalVolume* pCurrentPV = 0;
     G4LogicalVolume* pCurrentLV = 0;
     G4int currentDepth = 0;
     G4PhysicalVolumeModel* pPVModel = dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
     if (pPVModel) {
         pCurrentPV = pPVModel->GetCurrentPV();
         pCurrentLV = pPVModel->GetCurrentLV();
         currentDepth = pPVModel->GetCurrentDepth();
     }
     
 #ifdef G4HEPREPFILEDEBUG
     G4cout <<
         "pCurrentPV:" << pCurrentPV << ", readyForTransients:" << fReadyForTransients
         << G4endl;
 #endif
     
     if (drawingTraj || drawingHit) {
         // In this case, HepRep type, layer and instance were already created
         // in the AddCompound method.
     }
     else if (fReadyForTransients) {
         if (strcmp("Event Data",hepRepXMLWriter->prevTypeName[0])!=0) {
             hepRepXMLWriter->addType("Event Data",0);
             hepRepXMLWriter->addInstance();
         }
         
         // Applications have the option of either calling AddSolid(G4VTrajectory&) and
         // AddSolid(G4VHits&), or of just decomposing these into simpler primitives.
         // In the former case, drawing will be handled above and will include setting of
         // physics attributes.
         // In the latter case, which is an older style of working, we end up drawing the
         // trajectories and hits here, where we have no access to physics attributes. 
         // We receive primitives here.  We can figure out that these are transients, but we
         // have to guess exactly what these transients represent.
         // We assume the primitives are being used as in G4VTrajectory, hence we assume:
         // Lines are Trajectories
         // Squares that come after we've seen trajectories are Auxiliary Points
         // Circles that come after we've seen trajectories are Step Points
         // Other primitives are Hits
         
         int layer;
         
         if (strcmp("Text",primName)==0) {
             hepRepXMLWriter->addType("EventID",1);
         } else {
             if (strcmp("Line",primName)==0) {
                 hepRepXMLWriter->addType("TransientPolylines",1);
                 layer = 100;
             } else {
                 if (strcmp(hepRepXMLWriter->prevTypeName[1],"TransientPolylines")==0 &&
                     strcmp("Square",primName)==0)
                 {
                     hepRepXMLWriter->addType("AuxiliaryPoints",2);
                     layer = 110;
                 } else {
                     if (strcmp(hepRepXMLWriter->prevTypeName[1],"TransientPolylines")==0 &&
                         strcmp("Circle",primName)==0)
                     {
                         hepRepXMLWriter->addType("StepPoints",2);
                         layer = 120;
                     } else {
                         hepRepXMLWriter->addType("Hits",1);
                         layer = 130;
                     }
                 }
             }
             hepRepXMLWriter->addAttValue("Layer",layer);
         }
         
         hepRepXMLWriter->addInstance();
         
         // Handle Type declaration for Axes, Ruler, etc.
     } else if (pCurrentPV==0) {
         if (strcmp("AxesEtc",hepRepXMLWriter->prevTypeName[0])!=0) {
             hepRepXMLWriter->addType("AxesEtc",0);
             hepRepXMLWriter->addInstance();
         }
         
         int layer;
         
         if (strcmp("Text",primName)==0) {
             hepRepXMLWriter->addType("Text",1);
         } else {
             if (strcmp("Line",primName)==0) {
                 hepRepXMLWriter->addType("Polylines",1);
                 layer = 100;
             } else {
                 hepRepXMLWriter->addType("Points",1);
                 layer = 130;
             }
             hepRepXMLWriter->addAttValue("Layer",layer);
         }
         
         hepRepXMLWriter->addInstance();
         
         // Handle Type declaration for Detector Geometry,
         // replacing G4's top geometry level name "worldPhysical" with the
         // name "Detector Geometry".
     } else {
         //G4cout << "CurrentDepth" << currentDepth << G4endl;
         //G4cout << "currentName" << pCurrentPV->GetName() << G4endl;
         if (strcmp("Detector Geometry",hepRepXMLWriter->prevTypeName[0])!=0) {
             //G4cout << "Adding Det Geom type" << G4endl;
             hepRepXMLWriter->addType("Detector Geometry",0);
             hepRepXMLWriter->addInstance();
         }
         
         // Re-insert any layers of the hierarchy that were removed by G4's culling process.
         // Don't bother checking if same type name as last instance.
         if(strcmp(hepRepXMLWriter->prevTypeName[currentDepth+1],pCurrentPV->GetName())!=0) {
             //G4cout << "Looking for mother of:" << pCurrentLV->GetName() << G4endl;
             typedef G4PhysicalVolumeModel::G4PhysicalVolumeNodeID PVNodeID;
             typedef std::vector<PVNodeID> PVPath;
             const PVPath& drawnPVPath = pPVModel->GetDrawnPVPath();
             PVPath::const_reverse_iterator ri = ++drawnPVPath.rbegin();
             G4int drawnMotherDepth;
             if (ri != drawnPVPath.rend()) {
                 // This volume has a mother.
                 drawnMotherDepth = ri->GetNonCulledDepth();
                 //G4cout << "drawnMotherDepth" << drawnMotherDepth << G4endl;
             } else {
                 // This volume has no mother.  Must be a top level volume.
                 drawnMotherDepth = -1;
                 //G4cout << "Mother must be very top" << G4endl;
             }
             
             while (drawnMotherDepth < (currentDepth-1)) {
                 G4String culledParentName = "Culled parent of " + pCurrentPV->GetName();
                 //G4cout << "Inserting culled layer " << culledParentName << " at depth:" << drawnMotherDepth+2 << G4endl;
                 hepRepXMLWriter->addType(culledParentName, drawnMotherDepth+2);
                 hepRepXMLWriter->addInstance();
                 drawnMotherDepth ++;
             }
         }
         
         // Add the HepRepType for the current volume.
         hepRepXMLWriter->addType(pCurrentPV->GetName(),currentDepth+1);
         hepRepXMLWriter->addInstance();
         
         G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
         
         if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && messenger->getCullInvisibles())
             return;
         
         // Additional attributes.
         hepRepXMLWriter->addAttValue("Layer",hepRepXMLWriter->typeDepth);
         hepRepXMLWriter->addAttValue("LVol", pCurrentLV->GetName());
         G4Region* region = pCurrentLV->GetRegion();
         G4String regionName = region? region->GetName(): G4String("No region");
         hepRepXMLWriter->addAttValue("Region", regionName);
         hepRepXMLWriter->addAttValue("RootRegion", pCurrentLV->IsRootRegion());
         hepRepXMLWriter->addAttValue("Solid", pCurrentLV->GetSolid()->GetName());
         hepRepXMLWriter->addAttValue("EType", pCurrentLV->GetSolid()->GetEntityType());
         G4Material * material = pPVModel->GetCurrentMaterial();
         G4String matName = material? material->GetName(): G4String("No material");
         hepRepXMLWriter->addAttValue("Material", matName);
         G4double matDensity = material? material->GetDensity(): 0.;
         hepRepXMLWriter->addAttValue("Density", matDensity*m3/kg);
         G4State matState = material? material->GetState(): kStateUndefined;
         hepRepXMLWriter->addAttValue("State", matState);
         G4double matRadlen = material? material->GetRadlen(): 0.;
         hepRepXMLWriter->addAttValue("Radlen", matRadlen/m);
     }
     
     hepRepXMLWriter->addAttValue("DrawAs",primName);
     
     // Handle color and visibility attributes.
     float redness;
     float greenness;
     float blueness;
     G4bool isVisible; 
     
     if (fpVisAttribs || haveVisible) {
         G4Colour colour;
         
         if (fpVisAttribs) {
             colour = fpVisAttribs->GetColour();
             isVisible = fpVisAttribs->IsVisible();
         } else {
             colour = GetColour(visible);
             isVisible = fpViewer->
                 GetApplicableVisAttributes(visible.GetVisAttributes())->IsVisible();
         }
         
         redness = colour.GetRed();
         greenness = colour.GetGreen();
         blueness = colour.GetBlue();
         
         // Avoiding drawing anything black on black.  
         if (redness==0. && greenness==0. && blueness==0.) {
             redness = 1.;
             greenness = 1.;
             blueness = 1.;
         }
     } else {
 #ifdef G4HEPREPFILEDEBUG
         G4cout <<
         "G4HepRepFileSceneHandler::AddHepRepInstance using default colour."
         << G4endl;
 #endif
         redness = 1.;
         greenness = 1.;
         blueness = 1.;
         isVisible = true;
     }
     
     if (strcmp(primName,"Point")==0)
         hepRepXMLWriter->addAttValue("MarkColor",redness,greenness,blueness);
     else
         hepRepXMLWriter->addAttValue("LineColor",redness,greenness,blueness);
     
     hepRepXMLWriter->addAttValue("Visibility",isVisible);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddPrimitive() [1/7]

void G4HepRepFileSceneHandler::AddPrimitive ( const G4Polyline & polyline )

virtual

Implements G4VSceneHandler.

Definition at line 994 of file G4HepRepFileSceneHandler.cc.

                                                                       {
 #ifdef G4HEPREPFILEDEBUG
     G4cout <<
     "G4HepRepFileSceneHandler::AddPrimitive(const G4Polyline& polyline) called:"
     "\n  polyline: " << polyline
     << G4endl;
     PrintThings();
 #endif
     
     G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
     
     if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && messenger->getCullInvisibles())
         return;
     
     if (inPrimitives2D) {
         if (!warnedAbout2DMarkers) {
             G4cout << "HepRepFile does not currently support 2D lines." << G4endl;
             warnedAbout2DMarkers = true;
         }
         return;
     }
     
     if (drawingTraj)
         InitTrajectory();
         
     if (drawingHit)
         InitHit();
     
     haveVisible = true;
     AddHepRepInstance("Line", polyline);
     
     hepRepXMLWriter->addPrimitive();
     
     for (size_t i=0; i < polyline.size(); i++) {
         G4Point3D vertex = (fObjectTransformation) * polyline[i];
         hepRepXMLWriter->addPoint(vertex.x(), vertex.y(), vertex.z());
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddPrimitive() [2/7]

void G4HepRepFileSceneHandler::AddPrimitive ( const G4Text & text )

virtual

Implements G4VSceneHandler.

Definition at line 1082 of file G4HepRepFileSceneHandler.cc.

                                                               {
 #ifdef G4HEPREPFILEDEBUG
     G4cout <<
     "G4HepRepFileSceneHandler::AddPrimitive(const G4Text& text) called:"
     "\n  text: " << text.GetText()
     << G4endl;
     PrintThings();
 #endif
     
     if (!inPrimitives2D) {
         if (!warnedAbout3DText) {
             G4cout << "HepRepFile does not currently support 3D text." << G4endl;
             G4cout << "HepRep browsers can directly display text attributes on request." << G4endl;
             G4cout << "See Application Developers Guide for how to attach attributes to viewable objects." << G4endl;
             warnedAbout3DText = true;
         }
         return;
     }
     
     MarkerSizeType sizeType;
     G4double size = GetMarkerSize (text, sizeType);
     if (sizeType==world)
         size = 12.;
     
     haveVisible = true;
     AddHepRepInstance("Text", text);
     
     hepRepXMLWriter->addAttValue("VAlign", "Top");
     hepRepXMLWriter->addAttValue("HAlign", "Left");
     hepRepXMLWriter->addAttValue("FontName", "Arial");
     hepRepXMLWriter->addAttValue("FontStyle", "Plain");
     hepRepXMLWriter->addAttValue("FontSize", (G4int) size);
     hepRepXMLWriter->addAttValue("FontHasBanner", "TRUE");
     hepRepXMLWriter->addAttValue("FontBannerColor", "0,0,0");
     
     const G4Colour& colour = GetTextColour(text);
     float redness = colour.GetRed();
     float greenness = colour.GetGreen();
     float blueness = colour.GetBlue();
     
     // Avoiding drawing anything black on black.  
     if (redness==0. && greenness==0. && blueness==0.) {
         redness = 1.;
         greenness = 1.;
         blueness = 1.;
     }
     hepRepXMLWriter->addAttValue("FontColor",redness,greenness,blueness);
     
     hepRepXMLWriter->addPrimitive();
     
     hepRepXMLWriter->addAttValue("Text", text.GetText());
     hepRepXMLWriter->addAttValue("VPos", .99-text.GetYOffset());
     hepRepXMLWriter->addAttValue("HPos", text.GetXOffset());
 }

Here is the call graph for this function:

◆ AddPrimitive() [3/7]

void G4HepRepFileSceneHandler::AddPrimitive ( const G4Circle & circle )

virtual

Implements G4VSceneHandler.

Definition at line 1138 of file G4HepRepFileSceneHandler.cc.

                                                                   {
 #ifdef G4HEPREPFILEDEBUG
     G4cout <<
     "G4HepRepFileSceneHandler::AddPrimitive(const G4Circle& circle) called:"
     "\n  radius: " << circle.GetWorldRadius()
     << G4endl;
     PrintThings();
 #endif
     
     G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
     
     if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && messenger->getCullInvisibles())
         return;
     
     if (inPrimitives2D) {
         if (!warnedAbout2DMarkers) {
             G4cout << "HepRepFile does not currently support 2D circles." << G4endl;
             warnedAbout2DMarkers = true;
         }
         return;
     }
     
     MarkerSizeType sizeType;
     G4double size = GetMarkerSize (circle, sizeType);
     if (sizeType==world)
         size = 4.;
     
     if (drawingTraj)
         return;
     
     if (drawingHit)
         InitHit();
     
     haveVisible = true;
     AddHepRepInstance("Point", circle);
     
     hepRepXMLWriter->addAttValue("MarkName", "Dot");
     hepRepXMLWriter->addAttValue("MarkSize", (G4int) size);
     
     hepRepXMLWriter->addPrimitive();
     
     G4Point3D center = (fObjectTransformation) * circle.GetPosition();
     hepRepXMLWriter->addPoint(center.x(), center.y(), center.z());
 }

Here is the call graph for this function:

◆ AddPrimitive() [4/7]

void G4HepRepFileSceneHandler::AddPrimitive ( const G4Square & square )

virtual

Implements G4VSceneHandler.

Definition at line 1184 of file G4HepRepFileSceneHandler.cc.

                                                                   {
 #ifdef G4HEPREPFILEDEBUG
     G4cout <<
     "G4HepRepFileSceneHandler::AddPrimitive(const G4Square& square) called:"
     "\n  side: " << square.GetWorldRadius()
     << G4endl;
     PrintThings();
 #endif
     
     G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
     
     if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && messenger->getCullInvisibles())
         return;
     
     if (inPrimitives2D) {
         if (!warnedAbout2DMarkers) {
             G4cout << "HepRepFile does not currently support 2D squares." << G4endl;
             warnedAbout2DMarkers = true;
         }
         return;
     }
     
     MarkerSizeType sizeType;
     G4double size = GetMarkerSize (square, sizeType);
     if (sizeType==world)
         size = 4.;
     
     if (drawingTraj)
         return;
     
     if (drawingHit)
         InitHit();
     
     haveVisible = true;
     AddHepRepInstance("Point", square);
     
     hepRepXMLWriter->addAttValue("MarkName", "Square");
     hepRepXMLWriter->addAttValue("MarkSize", (G4int) size);
     
     hepRepXMLWriter->addPrimitive();
     
     G4Point3D center = (fObjectTransformation) * square.GetPosition();
     hepRepXMLWriter->addPoint(center.x(), center.y(), center.z());
 }

Here is the call graph for this function:

◆ AddPrimitive() [5/7]

void G4HepRepFileSceneHandler::AddPrimitive ( const G4Polyhedron & polyhedron )

virtual

Implements G4VSceneHandler.

Definition at line 1230 of file G4HepRepFileSceneHandler.cc.

                                                                           {
 #ifdef G4HEPREPFILEDEBUG
     G4cout <<
     "G4HepRepFileSceneHandler::AddPrimitive(const G4Polyhedron& polyhedron) called."
     << G4endl;
     PrintThings();
 #endif
     
     G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
     
     if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && messenger->getCullInvisibles())
         return;
     
     if(polyhedron.GetNoFacets()==0)return;
     
     if (drawingTraj)
         return;
     
     if (drawingHit)
         InitHit();
     
     haveVisible = true;
     AddHepRepInstance("Polygon", polyhedron);
     
     G4Normal3D surfaceNormal;
     G4Point3D vertex;
     
     G4bool notLastFace;
     do {
         hepRepXMLWriter->addPrimitive();
         notLastFace = polyhedron.GetNextNormal (surfaceNormal);
         
         G4int edgeFlag = 1;
         G4bool notLastEdge;
         do {
             notLastEdge = polyhedron.GetNextVertex (vertex, edgeFlag);
             vertex = (fObjectTransformation) * vertex;
             hepRepXMLWriter->addPoint(vertex.x(), vertex.y(), vertex.z());
         } while (notLastEdge);
     } while (notLastFace);
 }

Here is the call graph for this function:

◆ AddPrimitive() [6/7]

void G4HepRepFileSceneHandler::AddPrimitive ( const G4Polymarker & line )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1035 of file G4HepRepFileSceneHandler.cc.

                                                                      {
 #ifdef G4HEPREPFILEDEBUG
     G4cout <<
     "G4HepRepFileSceneHandler::AddPrimitive(const G4Polymarker& line) called"
     << G4endl;
     PrintThings();
 #endif
     
     G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
     
     if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && messenger->getCullInvisibles())
         return;
     
     if (inPrimitives2D) {
         if (!warnedAbout2DMarkers) {
             G4cout << "HepRepFile does not currently support 2D lines." << G4endl;
             warnedAbout2DMarkers = true;
         }
         return;
     }
     
     MarkerSizeType sizeType;
     G4double size = GetMarkerSize (line, sizeType);
     if (sizeType==world)
         size = 4.;
     
     if (drawingTraj)
         return;
     
     if (drawingHit)
         InitHit();
     
     haveVisible = true;
     AddHepRepInstance("Point", line);
     
     hepRepXMLWriter->addAttValue("MarkName", "Dot");
     hepRepXMLWriter->addAttValue("MarkSize", (G4int) size);
     
     hepRepXMLWriter->addPrimitive();
     
     for (size_t i=0; i < line.size(); i++) {
         G4Point3D vertex = (fObjectTransformation) * line[i];
         hepRepXMLWriter->addPoint(vertex.x(), vertex.y(), vertex.z());
     }
 }

Here is the call graph for this function:

◆ AddPrimitive() [7/7]

void G4HepRepFileSceneHandler::AddPrimitive ( const G4Scale & scale )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 108 of file G4HepRepFileSceneHandler.hh.

                                           {
     G4VSceneHandler::AddPrimitive (scale);
   }

Here is the call graph for this function:

◆ AddSolid() [1/11]

void G4HepRepFileSceneHandler::AddSolid ( const G4Box & box )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 151 of file G4HepRepFileSceneHandler.cc.

                                                         {
 #ifdef G4HEPREPFILEDEBUG
     G4cout <<
     "G4HepRepFileSceneHandler::AddSolid(const G4Box& box) called for "
     << box.GetName()
     << G4endl;
     PrintThings();
 #endif
     
     if (drawingTraj)
         return;
     
     if (drawingHit)
         InitHit();
     
     haveVisible = false;
     AddHepRepInstance("Prism", NULL);
     
     G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
     
     if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && messenger->getCullInvisibles())
         return;
     
     hepRepXMLWriter->addPrimitive();
     
     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 = (fObjectTransformation) * vertex1;
     vertex2 = (fObjectTransformation) * vertex2;
     vertex3 = (fObjectTransformation) * vertex3;
     vertex4 = (fObjectTransformation) * vertex4;
     vertex5 = (fObjectTransformation) * vertex5;
     vertex6 = (fObjectTransformation) * vertex6;
     vertex7 = (fObjectTransformation) * vertex7;
     vertex8 = (fObjectTransformation) * vertex8;
     
     hepRepXMLWriter->addPoint(vertex1.x(), vertex1.y(), vertex1.z());
     hepRepXMLWriter->addPoint(vertex2.x(), vertex2.y(), vertex2.z());
     hepRepXMLWriter->addPoint(vertex3.x(), vertex3.y(), vertex3.z());
     hepRepXMLWriter->addPoint(vertex4.x(), vertex4.y(), vertex4.z());
     hepRepXMLWriter->addPoint(vertex5.x(), vertex5.y(), vertex5.z());
     hepRepXMLWriter->addPoint(vertex6.x(), vertex6.y(), vertex6.z());
     hepRepXMLWriter->addPoint(vertex7.x(), vertex7.y(), vertex7.z());
     hepRepXMLWriter->addPoint(vertex8.x(), vertex8.y(), vertex8.z());
 }

Here is the call graph for this function:

◆ AddSolid() [2/11]

void G4HepRepFileSceneHandler::AddSolid ( const G4Cons & cons )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 209 of file G4HepRepFileSceneHandler.cc.

                                                           {
 #ifdef G4HEPREPFILEDEBUG
     G4cout <<
     "G4HepRepFileSceneHandler::AddSolid(const G4Cons& cons) called for "
     << cons.GetName()
     << G4endl;
     PrintThings();
 #endif
     
     // HepRApp does not correctly represent the end faces of cones at
     // non-standard angles, let the base class convert these solids to polygons.    
     G4RotationMatrix r = fObjectTransformation.getRotation();   
     G4bool linedUpWithAnAxis = (std::fabs(r.phiX())<=.001 ||  
                                 std::fabs(r.phiY())<=.001 || 
                                 std::fabs(r.phiZ())<=.001 ||
                                 std::fabs(r.phiX()-pi)<=.001 ||
                                 std::fabs(r.phiY()-pi)<=.001 ||
                                 std::fabs(r.phiZ()-pi)<=.001);  
     //G4cout << "Angle X:" << r.phiX() << ", Angle Y:" << r.phiY() << ", Angle Z:" << r.phiZ() << G4endl;
     //G4cout << "linedUpWithAnAxis:" << linedUpWithAnAxis << G4endl;
     
     // HepRep does not have a primitive for a cut cone,
     // so if this cone is cut, let the base class convert this
     // solid to polygons.
     G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
     if (cons.GetDeltaPhiAngle() < twopi || !linedUpWithAnAxis || messenger->renderCylAsPolygons())
     {
         G4VSceneHandler::AddSolid(cons);  // Invoke default action.
     } else {
     
         if (drawingTraj)
             return;
         
         if (drawingHit)
             InitHit();
 
         haveVisible = false;
         AddHepRepInstance("Cylinder", NULL);
         
         if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && messenger->getCullInvisibles())
             return;
         
         G4Point3D vertex1(G4Point3D( 0., 0., -cons.GetZHalfLength()));
         G4Point3D vertex2(G4Point3D( 0., 0.,  cons.GetZHalfLength()));
         
         vertex1 = (fObjectTransformation) * vertex1;
         vertex2 = (fObjectTransformation) * vertex2;
                 
         // Outer cylinder.
         hepRepXMLWriter->addPrimitive();
         hepRepXMLWriter->addAttValue("Radius1",messenger->getScale() * cons.GetOuterRadiusMinusZ());
         hepRepXMLWriter->addAttValue("Radius2",messenger->getScale() * cons.GetOuterRadiusPlusZ());
         hepRepXMLWriter->addPoint(vertex1.x(), vertex1.y(), vertex1.z());
         hepRepXMLWriter->addPoint(vertex2.x(), vertex2.y(), vertex2.z());
         
         // Inner cylinder.
         hepRepXMLWriter->addPrimitive();
         hepRepXMLWriter->addAttValue("Radius1",messenger->getScale() * cons.GetInnerRadiusMinusZ());
         hepRepXMLWriter->addAttValue("Radius2",messenger->getScale() * cons.GetInnerRadiusPlusZ());
         hepRepXMLWriter->addPoint(vertex1.x(), vertex1.y(), vertex1.z());
         hepRepXMLWriter->addPoint(vertex2.x(), vertex2.y(), vertex2.z());
     }
 }

Here is the call graph for this function:

◆ AddSolid() [3/11]

void G4HepRepFileSceneHandler::AddSolid ( const G4Tubs & tubs )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 274 of file G4HepRepFileSceneHandler.cc.

                                                           {
 #ifdef G4HEPREPFILEDEBUG
     G4cout <<
     "G4HepRepFileSceneHandler::AddSolid(const G4Tubs& tubs) called for "
     << tubs.GetName()
     << G4endl;
     PrintThings();
 #endif
     
     // HepRApp does not correctly represent the end faces of cylinders at
     // non-standard angles, let the base class convert these solids to polygons.    
     G4RotationMatrix r = fObjectTransformation.getRotation();   
     G4bool linedUpWithAnAxis = (std::fabs(r.phiX())<=.001 ||  
                                 std::fabs(r.phiY())<=.001 || 
                                 std::fabs(r.phiZ())<=.001 ||
                                 std::fabs(r.phiX()-pi)<=.001 ||
                                 std::fabs(r.phiY()-pi)<=.001 ||
                                 std::fabs(r.phiZ()-pi)<=.001);  
     //G4cout << "Angle X:" << r.phiX() << ", Angle Y:" << r.phiY() << ", Angle Z:" << r.phiZ() << G4endl;
     //G4cout << "linedUpWithAnAxis:" << linedUpWithAnAxis << G4endl;
     
     // HepRep does not have a primitive for a cut cylinder,
     // so if this cylinder is cut, let the base class convert this
     // solid to polygons.
     G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
     if (tubs.GetDeltaPhiAngle() < twopi || !linedUpWithAnAxis || messenger->renderCylAsPolygons())
     {
         G4VSceneHandler::AddSolid(tubs);  // Invoke default action.
     } else {
     
         if (drawingTraj)
             return;
         
         if (drawingHit)
             InitHit();
 
         haveVisible = false;
         AddHepRepInstance("Cylinder", NULL);
         
         if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && messenger->getCullInvisibles())
             return;
         
         G4Point3D vertex1(G4Point3D( 0., 0., -tubs.GetZHalfLength()));
         G4Point3D vertex2(G4Point3D( 0., 0.,  tubs.GetZHalfLength()));
         
         vertex1 = (fObjectTransformation) * vertex1;
         vertex2 = (fObjectTransformation) * vertex2;
         
         // Outer cylinder.
         hepRepXMLWriter->addPrimitive();
         hepRepXMLWriter->addAttValue("Radius1", messenger->getScale() * tubs.GetOuterRadius());
         hepRepXMLWriter->addAttValue("Radius2", messenger->getScale() * tubs.GetOuterRadius());
         hepRepXMLWriter->addPoint(vertex1.x(), vertex1.y(), vertex1.z());
         hepRepXMLWriter->addPoint(vertex2.x(), vertex2.y(), vertex2.z());
         
         // Inner cylinder.
         if (tubs.GetInnerRadius() != 0.) {
             hepRepXMLWriter->addPrimitive();
             hepRepXMLWriter->addAttValue("Radius1", messenger->getScale() * tubs.GetInnerRadius());
             hepRepXMLWriter->addAttValue("Radius2", messenger->getScale() * tubs.GetInnerRadius());
             hepRepXMLWriter->addPoint(vertex1.x(), vertex1.y(), vertex1.z());
             hepRepXMLWriter->addPoint(vertex2.x(), vertex2.y(), vertex2.z());
         }
     }
 }

Here is the call graph for this function:

◆ AddSolid() [4/11]

void G4HepRepFileSceneHandler::AddSolid ( const G4Trd & trd )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 341 of file G4HepRepFileSceneHandler.cc.

                                                         {
 #ifdef G4HEPREPFILEDEBUG
     G4cout <<
     "G4HepRepFileSceneHandler::AddSolid(const G4Trd& trd) called for "
     << trd.GetName()
     << G4endl;
     PrintThings();
 #endif
     
     if (drawingTraj)
         return;
     
     if (drawingHit)
         InitHit();
     
     haveVisible = false;
     AddHepRepInstance("Prism", NULL);
     
     G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
     
     if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && messenger->getCullInvisibles())
         return;
     
     hepRepXMLWriter->addPrimitive();
     
     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 = (fObjectTransformation) * vertex1;
     vertex2 = (fObjectTransformation) * vertex2;
     vertex3 = (fObjectTransformation) * vertex3;
     vertex4 = (fObjectTransformation) * vertex4;
     vertex5 = (fObjectTransformation) * vertex5;
     vertex6 = (fObjectTransformation) * vertex6;
     vertex7 = (fObjectTransformation) * vertex7;
     vertex8 = (fObjectTransformation) * vertex8;
     
     hepRepXMLWriter->addPoint(vertex1.x(), vertex1.y(), vertex1.z());
     hepRepXMLWriter->addPoint(vertex2.x(), vertex2.y(), vertex2.z());
     hepRepXMLWriter->addPoint(vertex3.x(), vertex3.y(), vertex3.z());
     hepRepXMLWriter->addPoint(vertex4.x(), vertex4.y(), vertex4.z());
     hepRepXMLWriter->addPoint(vertex5.x(), vertex5.y(), vertex5.z());
     hepRepXMLWriter->addPoint(vertex6.x(), vertex6.y(), vertex6.z());
     hepRepXMLWriter->addPoint(vertex7.x(), vertex7.y(), vertex7.z());
     hepRepXMLWriter->addPoint(vertex8.x(), vertex8.y(), vertex8.z());
 }

Here is the call graph for this function:

◆ AddSolid() [5/11]

void G4HepRepFileSceneHandler::AddSolid ( const G4Trap & trap )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 401 of file G4HepRepFileSceneHandler.cc.

                                                           {
 #ifdef G4HEPREPFILEDEBUG
     G4cout <<
     "G4HepRepFileSceneHandler::AddSolid(const G4Trap& trap) called for "
     << trap.GetName()
     << G4endl;
     PrintThings();
 #endif
     G4VSceneHandler::AddSolid(trap);  // Invoke default action.
 }

Here is the call graph for this function:

◆ AddSolid() [6/11]

void G4HepRepFileSceneHandler::AddSolid ( const G4Sphere & sphere )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 413 of file G4HepRepFileSceneHandler.cc.

                                                               {
 #ifdef G4HEPREPFILEDEBUG
     G4cout <<
     "G4HepRepFileSceneHandler::AddSolid(const G4Sphere& sphere) called for "
     << sphere.GetName()
     << G4endl;
     PrintThings();
 #endif
     G4VSceneHandler::AddSolid(sphere);  // Invoke default action.
 }

Here is the call graph for this function:

◆ AddSolid() [7/11]

void G4HepRepFileSceneHandler::AddSolid ( const G4Para & para )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 425 of file G4HepRepFileSceneHandler.cc.

                                                           {
 #ifdef G4HEPREPFILEDEBUG
     G4cout <<
     "G4HepRepFileSceneHandler::AddSolid(const G4Para& para) called for "
     << para.GetName()
     << G4endl;
     PrintThings();
 #endif
     G4VSceneHandler::AddSolid(para);  // Invoke default action.
 }

Here is the call graph for this function:

◆ AddSolid() [8/11]

void G4HepRepFileSceneHandler::AddSolid ( const G4Torus & torus )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 437 of file G4HepRepFileSceneHandler.cc.

                                                             {
 #ifdef G4HEPREPFILEDEBUG
     G4cout <<
     "G4HepRepFileSceneHandler::AddSolid(const G4Torus& torus) called for "
     << torus.GetName()
     << G4endl;
     PrintThings();
 #endif
     G4VSceneHandler::AddSolid(torus);  // Invoke default action.
 }

Here is the call graph for this function:

◆ AddSolid() [9/11]

void G4HepRepFileSceneHandler::AddSolid ( const G4Polycone & polycone )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 449 of file G4HepRepFileSceneHandler.cc.

                                                                   {
 #ifdef G4HEPREPFILEDEBUG
     G4cout <<
     "G4HepRepFileSceneHandler::AddSolid(const G4Polycone& polycone) called for "
     << polycone.GetName()
     << G4endl;
     PrintThings();
 #endif
     G4VSceneHandler::AddSolid(polycone);  // Invoke default action.
 }

Here is the call graph for this function:

◆ AddSolid() [10/11]

void G4HepRepFileSceneHandler::AddSolid ( const G4Polyhedra & polyhedra )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 461 of file G4HepRepFileSceneHandler.cc.

                                                                     {
 #ifdef G4HEPREPFILEDEBUG
     G4cout <<
     "G4HepRepFileSceneHandler::AddSolid(const G4Polyhedra& polyhedra) called for "
     << polyhedra.GetName()
     << G4endl;
     PrintThings();
 #endif
     G4VSceneHandler::AddSolid(polyhedra);  // Invoke default action.
 }

Here is the call graph for this function:

◆ AddSolid() [11/11]

void G4HepRepFileSceneHandler::AddSolid ( const G4VSolid & solid )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 473 of file G4HepRepFileSceneHandler.cc.

                                                              {
 #ifdef G4HEPREPFILEDEBUG
     G4cout <<
     "G4HepRepFileSceneHandler::AddSolid(const G4Solid& solid) called for "
     << solid.GetName()
     << G4endl;
     PrintThings();
 #endif
     G4VSceneHandler::AddSolid(solid);  // Invoke default action.
 }

Here is the call graph for this function:

◆ BeginModeling()

void G4HepRepFileSceneHandler::BeginModeling ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 96 of file G4HepRepFileSceneHandler.cc.

                                              {
     G4VisManager* visManager = G4VisManager::GetInstance();
     const G4VTrajectoryModel* model = visManager->CurrentTrajDrawModel();
     trajContext = & model->GetContext();
     
     G4VSceneHandler::BeginModeling();  // Required: see G4VSceneHandler.hh.
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BeginPrimitives2D()

void G4HepRepFileSceneHandler::BeginPrimitives2D ( const G4Transform3D & objectTransformation )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 110 of file G4HepRepFileSceneHandler.cc.

                                             {
 #ifdef G4HEPREPFILEDEBUG
     G4cout << "G4HepRepFileSceneHandler::BeginPrimitives2D() " << G4endl;
 #endif
     inPrimitives2D = true;
     G4VSceneHandler::BeginPrimitives2D(objectTransformation);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CheckFileOpen()

void G4HepRepFileSceneHandler::CheckFileOpen ( )

private

Definition at line 1504 of file G4HepRepFileSceneHandler.cc.

                                              {
 #ifdef G4HEPREPFILEDEBUG
     G4cout <<
     "G4HepRepFileSceneHandler::CheckFileOpen called."
     << G4endl;
 #endif
     
     if (!hepRepXMLWriter->isOpen) {
         G4String newFileSpec;
 
         G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
         
         if (messenger->getOverwrite()) {
             newFileSpec = messenger->getFileDir()+messenger->getFileName()+".heprep";
         } else {
             newFileSpec = messenger->getFileDir()+messenger->getFileName()+G4UIcommand::ConvertToString(fileCounter)+".heprep";
         }
         
         G4cout << "HepRepFile writing to " << newFileSpec << G4endl;
         
         hepRepXMLWriter->open(newFileSpec);
         
         if (!messenger->getOverwrite())
             fileCounter++;
         
         hepRepXMLWriter->addAttDef("Generator", "HepRep Data Generator", "Physics","");
         G4String versionString = G4Version;
         versionString = versionString.substr(1,versionString.size()-2);
         versionString = " Geant4 version " + versionString + "   " + G4Date;
         hepRepXMLWriter->addAttValue("Generator", versionString);
         
         hepRepXMLWriter->addAttDef("LVol", "Logical Volume", "Physics","");
         hepRepXMLWriter->addAttDef("Region", "Cuts Region", "Physics","");
         hepRepXMLWriter->addAttDef("RootRegion", "Root Region", "Physics","");
         hepRepXMLWriter->addAttDef("Solid", "Solid Name", "Physics","");
         hepRepXMLWriter->addAttDef("EType", "Entity Type", "Physics","");
         hepRepXMLWriter->addAttDef("Material", "Material Name", "Physics","");
         hepRepXMLWriter->addAttDef("Density", "Material Density", "Physics","kg/m3");
         hepRepXMLWriter->addAttDef("State", "Material State", "Physics","");
         hepRepXMLWriter->addAttDef("Radlen", "Material Radiation Length", "Physics","m");
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ClearTransientStore()

void G4HepRepFileSceneHandler::ClearTransientStore ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1548 of file G4HepRepFileSceneHandler.cc.

                                                    {
     // This is typically called after an update and before drawing hits
     // of the next event.  To simulate the clearing of "transients"
     // (hits, etc.) the detector is redrawn...
     if (fpViewer) {
         fpViewer -> SetView();
         fpViewer -> ClearView();
         fpViewer -> DrawView();
     }
 }

Here is the caller graph for this function:

◆ EndModeling()

void G4HepRepFileSceneHandler::EndModeling ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 105 of file G4HepRepFileSceneHandler.cc.

                                            {
     G4VSceneHandler::EndModeling();  // Required: see G4VSceneHandler.hh.
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EndPrimitives2D()

void G4HepRepFileSceneHandler::EndPrimitives2D ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 118 of file G4HepRepFileSceneHandler.cc.

                                                 {
 #ifdef G4HEPREPFILEDEBUG
     G4cout << "G4HepRepFileSceneHandler::EndPrimitives2D() " << G4endl;
 #endif
     G4VSceneHandler::EndPrimitives2D();
     inPrimitives2D = false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetHepRepXMLWriter()

G4HepRepFileXMLWriter * G4HepRepFileSceneHandler::GetHepRepXMLWriter ( )

Definition at line 1273 of file G4HepRepFileSceneHandler.cc.

                                                                     {
     return hepRepXMLWriter;
 }

Here is the caller graph for this function:

◆ InitHit()

void G4HepRepFileSceneHandler::InitHit ( )

Definition at line 971 of file G4HepRepFileSceneHandler.cc.

                                        {
     if (!doneInitHit) {
         // For every hit, add an instance of Type Hit.
         hepRepXMLWriter->addInstance();
         
         // Write out the hit's attribute values.
         if (hitAttValues) {
             std::vector<G4AttValue>::iterator iAttVal;
             for (iAttVal = hitAttValues->begin();
                  iAttVal != hitAttValues->end(); ++iAttVal)
                 hepRepXMLWriter->addAttValue(iAttVal->GetName(), iAttVal->GetValue());
             delete hitAttValues;
         }
         
         // Clean up hit attributes.
         if (hitAttDefs)
             delete hitAttDefs;
         
         doneInitHit = true;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InitTrajectory()

void G4HepRepFileSceneHandler::InitTrajectory ( )

Definition at line 948 of file G4HepRepFileSceneHandler.cc.

                                               {
     if (!doneInitTraj) {
         // For every trajectory, add an instance of Type Trajectory.
         hepRepXMLWriter->addInstance();
         
         // Write out the trajectory's attribute values.
         if (trajAttValues) {
             std::vector<G4AttValue>::iterator iAttVal;
             for (iAttVal = trajAttValues->begin();
                  iAttVal != trajAttValues->end(); ++iAttVal)
                 hepRepXMLWriter->addAttValue(iAttVal->GetName(), iAttVal->GetValue());
             delete trajAttValues; 
         }
         
         // Clean up trajectory attributes.
         if (trajAttDefs)
             delete trajAttDefs;
         
         doneInitTraj = true;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ doneInitHit

G4bool G4HepRepFileSceneHandler::doneInitHit

private

Definition at line 151 of file G4HepRepFileSceneHandler.hh.

◆ doneInitTraj

G4bool G4HepRepFileSceneHandler::doneInitTraj

private

Definition at line 149 of file G4HepRepFileSceneHandler.hh.

◆ drawingHit

G4bool G4HepRepFileSceneHandler::drawingHit

private

Definition at line 150 of file G4HepRepFileSceneHandler.hh.

◆ drawingTraj

G4bool G4HepRepFileSceneHandler::drawingTraj

private

Definition at line 148 of file G4HepRepFileSceneHandler.hh.

◆ fileCounter

int G4HepRepFileSceneHandler::fileCounter

private

Definition at line 143 of file G4HepRepFileSceneHandler.hh.

◆ fSceneIdCount

G4int G4HepRepFileSceneHandler::fSceneIdCount = 0

staticprotected

Definition at line 136 of file G4HepRepFileSceneHandler.hh.

◆ haveVisible

G4bool G4HepRepFileSceneHandler::haveVisible

private

Definition at line 144 of file G4HepRepFileSceneHandler.hh.

◆ hepRepXMLWriter

G4HepRepFileXMLWriter* G4HepRepFileSceneHandler::hepRepXMLWriter

private

Definition at line 139 of file G4HepRepFileSceneHandler.hh.

◆ hitAttDefs

std::map<G4String,G4AttDef>* G4HepRepFileSceneHandler::hitAttDefs

private

Definition at line 158 of file G4HepRepFileSceneHandler.hh.

◆ hitAttValues

std::vector<G4AttValue>* G4HepRepFileSceneHandler::hitAttValues

private

Definition at line 157 of file G4HepRepFileSceneHandler.hh.

◆ inPrimitives2D

G4bool G4HepRepFileSceneHandler::inPrimitives2D

private

Definition at line 145 of file G4HepRepFileSceneHandler.hh.

◆ trajAttDefs

std::map<G4String,G4AttDef>* G4HepRepFileSceneHandler::trajAttDefs

private

Definition at line 156 of file G4HepRepFileSceneHandler.hh.

◆ trajAttValues

std::vector<G4AttValue>* G4HepRepFileSceneHandler::trajAttValues

private

Definition at line 155 of file G4HepRepFileSceneHandler.hh.

◆ trajContext

const G4VisTrajContext* G4HepRepFileSceneHandler::trajContext

private

Definition at line 153 of file G4HepRepFileSceneHandler.hh.

◆ warnedAbout2DMarkers

G4bool G4HepRepFileSceneHandler::warnedAbout2DMarkers

private

Definition at line 147 of file G4HepRepFileSceneHandler.hh.

◆ warnedAbout3DText

G4bool G4HepRepFileSceneHandler::warnedAbout3DText

private

Definition at line 146 of file G4HepRepFileSceneHandler.hh.

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

Public Member Functions

Static Protected Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4HepRepFileSceneHandler()

◆ ~G4HepRepFileSceneHandler()

Member Function Documentation

◆ AddCompound() [1/4]

◆ AddCompound() [2/4]

◆ AddCompound() [3/4]

◆ AddCompound() [4/4]

◆ AddHepRepInstance()

◆ AddPrimitive() [1/7]

◆ AddPrimitive() [2/7]

◆ AddPrimitive() [3/7]

◆ AddPrimitive() [4/7]

◆ AddPrimitive() [5/7]

◆ AddPrimitive() [6/7]

◆ AddPrimitive() [7/7]

◆ AddSolid() [1/11]

◆ AddSolid() [2/11]

◆ AddSolid() [3/11]

◆ AddSolid() [4/11]

◆ AddSolid() [5/11]

◆ AddSolid() [6/11]

◆ AddSolid() [7/11]

◆ AddSolid() [8/11]

◆ AddSolid() [9/11]

◆ AddSolid() [10/11]

◆ AddSolid() [11/11]

◆ BeginModeling()

◆ BeginPrimitives2D()

◆ CheckFileOpen()

◆ ClearTransientStore()

◆ EndModeling()

◆ EndPrimitives2D()

◆ GetHepRepXMLWriter()

◆ InitHit()

◆ InitTrajectory()

Member Data Documentation

◆ doneInitHit

◆ doneInitTraj

◆ drawingHit

◆ drawingTraj

◆ fileCounter

◆ fSceneIdCount

◆ haveVisible

◆ hepRepXMLWriter

◆ hitAttDefs

◆ hitAttValues

◆ inPrimitives2D

◆ trajAttDefs

◆ trajAttValues

◆ trajContext

◆ warnedAbout2DMarkers

◆ warnedAbout3DText