G4HepRepFileSceneHandler Class Reference

#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 G4Orb &)
void	AddSolid (const G4Ellipsoid &)
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 G4THitsMap< G4StatDouble > &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 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 ()
void	AddViewerToList (G4VViewer *pView)
void	RemoveViewerFromList (G4VViewer *pView)
Public Member Functions inherited from G4VGraphicsScene
	G4VGraphicsScene ()
virtual	~G4VGraphicsScene ()

Static Protected Attributes
static G4int	fSceneIdCount = 0

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

virtual

Definition at line 93 of file G4HepRepFileSceneHandler.cc.

{}

Member Function Documentation

void G4HepRepFileSceneHandler::AddCompound ( const G4VTrajectory &  traj )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 517 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:

void G4HepRepFileSceneHandler::AddCompound ( const G4VHit &  hit )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 882 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:

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

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 85 of file G4HepRepFileSceneHandler.hh.

                                                      {
    G4VSceneHandler::AddCompound(hits);
  }

Here is the call graph for this function:

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

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 88 of file G4HepRepFileSceneHandler.hh.

                                                          {
    G4VSceneHandler::AddCompound(hits);
  }

Here is the call graph for this function:

void G4HepRepFileSceneHandler::AddCompound ( const G4VDigi &  digi )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 91 of file G4HepRepFileSceneHandler.hh.

                                         {
    G4VSceneHandler::AddCompound(digi);
  }

Here is the call graph for this function:

void G4HepRepFileSceneHandler::AddPrimitive ( const G4Polyline &  polyline )

virtual

Implements G4VSceneHandler.

Definition at line 1026 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:

void G4HepRepFileSceneHandler::AddPrimitive ( const G4Text &  text )

virtual

Implements G4VSceneHandler.

Definition at line 1114 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:

void G4HepRepFileSceneHandler::AddPrimitive ( const G4Circle &  circle )

virtual

Implements G4VSceneHandler.

Definition at line 1170 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:

void G4HepRepFileSceneHandler::AddPrimitive ( const G4Square &  square )

virtual

Implements G4VSceneHandler.

Definition at line 1216 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:

void G4HepRepFileSceneHandler::AddPrimitive ( const G4Polyhedron &  polyhedron )

virtual

Implements G4VSceneHandler.

Definition at line 1262 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:

void G4HepRepFileSceneHandler::AddPrimitive ( const G4Polymarker &  line )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1067 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:

void G4HepRepFileSceneHandler::AddPrimitive ( const G4Scale &  scale )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 113 of file G4HepRepFileSceneHandler.hh.

                                          {
    G4VSceneHandler::AddPrimitive (scale);
  }

Here is the call graph for this function:

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();
    
    // Get and check applicable vis attributes.
    fpVisAttribs = fpViewer->GetApplicableVisAttributes(fpVisAttribs);
    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:

void G4HepRepFileSceneHandler::AddSolid ( const G4Cons &  cons )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 211 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);
        
        // Get and check applicable vis attributes.
        fpVisAttribs = fpViewer->GetApplicableVisAttributes(fpVisAttribs);
        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:

void G4HepRepFileSceneHandler::AddSolid ( const G4Tubs &  tubs )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 278 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);
        
        // Get and check applicable vis attributes.
        fpVisAttribs = fpViewer->GetApplicableVisAttributes(fpVisAttribs);
        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:

void G4HepRepFileSceneHandler::AddSolid ( const G4Trd &  trd )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 347 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();
    
    // Get and check applicable vis attributes.
    fpVisAttribs = fpViewer->GetApplicableVisAttributes(fpVisAttribs);
    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:

void G4HepRepFileSceneHandler::AddSolid ( const G4Trap &  trap )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 409 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:

void G4HepRepFileSceneHandler::AddSolid ( const G4Sphere &  sphere )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 421 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:

void G4HepRepFileSceneHandler::AddSolid ( const G4Para &  para )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 433 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:

void G4HepRepFileSceneHandler::AddSolid ( const G4Torus &  torus )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 445 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:

void G4HepRepFileSceneHandler::AddSolid ( const G4Polycone &  polycone )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 457 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:

void G4HepRepFileSceneHandler::AddSolid ( const G4Polyhedra &  polyhedra )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 469 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:

void G4HepRepFileSceneHandler::AddSolid ( const G4Orb &  orb )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 481 of file G4HepRepFileSceneHandler.cc.

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

Here is the call graph for this function:

void G4HepRepFileSceneHandler::AddSolid ( const G4Ellipsoid &  ellipsoid )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 493 of file G4HepRepFileSceneHandler.cc.

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

Here is the call graph for this function:

void G4HepRepFileSceneHandler::AddSolid ( const G4VSolid &  solid )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 505 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:

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:

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:

void G4HepRepFileSceneHandler::ClearTransientStore ( )

virtual

Reimplemented from G4VSceneHandler.

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

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:

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:

G4HepRepFileXMLWriter * G4HepRepFileSceneHandler::GetHepRepXMLWriter

(

)

Definition at line 1305 of file G4HepRepFileSceneHandler.cc.

                                                                    {
    return hepRepXMLWriter;
}

Here is the caller graph for this function:

void G4HepRepFileSceneHandler::InitHit

(

)

Definition at line 1003 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:

void G4HepRepFileSceneHandler::InitTrajectory

(

)

Definition at line 980 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

G4int G4HepRepFileSceneHandler::fSceneIdCount = 0

staticprotected

Definition at line 141 of file G4HepRepFileSceneHandler.hh.

---

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

• geant4.10.03.p01/source/visualization/HepRep/include/G4HepRepFileSceneHandler.hh
• geant4.10.03.p01/source/visualization/HepRep/src/G4HepRepFileSceneHandler.cc