G4HepRepSceneHandler Class Reference

#include <G4HepRepSceneHandler.hh>

Inheritance diagram for G4HepRepSceneHandler:

Collaboration diagram for G4HepRepSceneHandler:

Public Member Functions
	G4HepRepSceneHandler (G4VGraphicsSystem &system, const G4String &name="")
virtual	~G4HepRepSceneHandler ()
void	AddSolid (const G4Box &box)
void	AddSolid (const G4Cons &cons)
void	AddSolid (const G4Tubs &tubs)
void	AddSolid (const G4Trd &trd)
void	AddSolid (const G4Trap &trap)
void	AddSolid (const G4Sphere &sphere)
void	AddSolid (const G4Para &para)
void	AddSolid (const G4Torus &torus)
void	AddSolid (const G4Polycone &polycone)
void	AddSolid (const G4Polyhedra &polyhedra)
void	AddSolid (const G4VSolid &solid)
void	AddCompound (const G4VTrajectory &)
void	AddCompound (const G4VHit &hit)
void	AddCompound (const G4VDigi &digi)
void	AddCompound (const G4THitsMap< G4double > &hits)
void	PreAddSolid (const G4Transform3D &objectTransformation, const G4VisAttributes &visAttribs)
void	PostAddSolid ()
void	AddPrimitive (const G4Polyline &)
void	AddPrimitive (const G4Text &)
void	AddPrimitive (const G4Circle &)
void	AddPrimitive (const G4Square &)
void	AddPrimitive (const G4Polyhedron &)
void	AddPrimitive (const G4Polymarker &)
void	AddPrimitive (const G4Scale &scale)
void	BeginPrimitives (const G4Transform3D &objectTransformation)
void	EndPrimitives ()
void	BeginModeling ()
void	EndModeling ()
void	openHepRep ()
bool	closeHepRep (bool final=false)
void	openFile (G4String name)
void	closeFile ()
Public Member Functions inherited from G4VSceneHandler
	G4VSceneHandler (G4VGraphicsSystem &system, G4int id, const G4String &name="")
virtual	~G4VSceneHandler ()
virtual void	BeginPrimitives2D (const G4Transform3D &objectTransformation)
virtual void	EndPrimitives2D ()
virtual const G4VisExtent &	GetExtent () const
const G4String &	GetName () const
G4int	GetSceneHandlerId () const
G4int	GetViewCount () const
G4VGraphicsSystem *	GetGraphicsSystem () const
G4Scene *	GetScene () const
const G4ViewerList &	GetViewerList () const
G4VModel *	GetModel () const
G4VViewer *	GetCurrentViewer () const
G4bool	GetMarkForClearingTransientStore () const
G4bool	IsReadyForTransients () const
G4bool	GetTransientsDrawnThisEvent () const
G4bool	GetTransientsDrawnThisRun () const
const G4Transform3D &	GetObjectTransformation () const
void	SetName (const G4String &)
void	SetCurrentViewer (G4VViewer *)
virtual void	SetScene (G4Scene *)
G4ViewerList &	SetViewerList ()
void	SetModel (G4VModel *)
void	SetMarkForClearingTransientStore (G4bool)
void	SetTransientsDrawnThisEvent (G4bool)
void	SetTransientsDrawnThisRun (G4bool)
void	SetObjectTransformation (const G4Transform3D &)
const G4Colour &	GetColour (const 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 ()
virtual void	ClearTransientStore ()
void	AddViewerToList (G4VViewer *pView)
void	RemoveViewerFromList (G4VViewer *pView)
Public Member Functions inherited from G4VGraphicsScene
	G4VGraphicsScene ()
virtual	~G4VGraphicsScene ()

Private Member Functions
	G4HepRepSceneHandler (const G4HepRepSceneHandler &)
G4HepRepSceneHandler &	operator= (const G4HepRepSceneHandler &)
G4bool	dontWrite ()
void	setColor (HEPREP::HepRepAttribute *attribute, const G4Color &color, const G4String &key=G4String("Color"))
G4Color	getColorFor (const G4Visible &visible)
G4Color	getColorFor (const G4VSolid &solid)
void	setVisibility (HEPREP::HepRepAttribute *attribute, const G4VSolid &solid)
void	setLine (HEPREP::HepRepAttribute *attribute, const G4VSolid &solid)
void	setVisibility (HEPREP::HepRepAttribute *attribute, const G4Visible &visible)
void	setLine (HEPREP::HepRepAttribute *attribute, const G4Visible &visible)
void	setMarker (HEPREP::HepRepAttribute *attribute, const G4VMarker &marker)
void	setAttribute (HEPREP::HepRepAttribute *attribute, G4String name, char *value)
void	setAttribute (HEPREP::HepRepAttribute *attribute, G4String name, G4String value)
void	setAttribute (HEPREP::HepRepAttribute *attribute, G4String name, bool value)
void	setAttribute (HEPREP::HepRepAttribute *attribute, G4String name, double value)
void	setAttribute (HEPREP::HepRepAttribute *attribute, G4String name, int value)
void	setAttribute (HEPREP::HepRepAttribute *attribute, G4String name, double red, double green, double blue, double alpha)
bool	isEventData ()
void	open (G4String name)
void	close ()
void	writeLayers (HEPREP::HepRep *heprep)
void	addAttributes (HEPREP::HepRepInstance *instance, HEPREP::HepRepType *type)
void	addAttDefs (HEPREP::HepRepDefinition *definition, const std::map< G4String, G4AttDef > *attDefs)
void	addAttVals (HEPREP::HepRepAttribute *attribute, const std::map< G4String, G4AttDef > *attDefs, std::vector< G4AttValue > *attValues)
void	addTopLevelAttributes (HEPREP::HepRepType *type)
HEPREP::HepRepInstance *	getGeometryOrEventInstance (HEPREP::HepRepType *type)
HEPREP::HepRep *	getHepRep ()
HEPREP::HepRep *	getHepRepGeometry ()
HEPREP::HepRepInstanceTree *	getGeometryInstanceTree ()
HEPREP::HepRepInstance *	getGeometryInstance (G4LogicalVolume *volume, G4Material *material, int depth)
HEPREP::HepRepInstance *	getGeometryInstance (G4String volumeName, int depth)
HEPREP::HepRepInstance *	getGeometryRootInstance ()
HEPREP::HepRepTypeTree *	getGeometryTypeTree ()
HEPREP::HepRepType *	getGeometryType (G4String volumeName, int depth)
HEPREP::HepRepType *	getGeometryRootType ()
HEPREP::HepRepInstanceTree *	getEventInstanceTree ()
HEPREP::HepRepInstance *	getEventInstance ()
HEPREP::HepRepTypeTree *	getEventTypeTree ()
HEPREP::HepRepType *	getEventType ()
HEPREP::HepRepType *	getTrajectoryType ()
HEPREP::HepRepType *	getHitType ()
HEPREP::HepRepType *	getCalHitType ()
HEPREP::HepRepType *	getCalHitFaceType ()
G4String	getFullTypeName (G4String volumeName, int depth)
G4String	getParentTypeName (int currentDepth)

Private Attributes
G4Transform3D	transform
std::ostream *	out
HEPREP::HepRepFactory *	factory
HEPREP::HepRepWriter *	writer
G4String	geometryLayer
G4String	eventLayer
G4String	calHitLayer
G4String	trajectoryLayer
G4String	hitLayer
G4String	rootVolumeName
G4String	baseName
G4String	eventNumberPrefix
G4String	eventNumberSuffix
G4int	eventNumber
G4int	eventNumberWidth
G4String	extension
G4bool	writeBinary
G4bool	writeZip
G4bool	writeGZ
G4bool	writeMultipleFiles
const G4VHit *	currentHit
const G4VTrajectory *	currentTrack
HEPREP::HepRep *	_heprep
HEPREP::HepRep *	_heprepGeometry
HEPREP::HepRepInstanceTree *	_geometryInstanceTree
std::vector< HEPREP::HepRepInstance * >	_geometryInstance
HEPREP::HepRepInstance *	_geometryRootInstance
HEPREP::HepRepTypeTree *	_geometryTypeTree
std::vector< G4String >	_geometryTypeName
std::map< G4String, HEPREP::HepRepType * >	_geometryType
HEPREP::HepRepType *	_geometryRootType
HEPREP::HepRepInstanceTree *	_eventInstanceTree
HEPREP::HepRepInstance *	_eventInstance
HEPREP::HepRepTypeTree *	_eventTypeTree
HEPREP::HepRepType *	_eventType
HEPREP::HepRepType *	_trajectoryType
HEPREP::HepRepType *	_hitType
HEPREP::HepRepType *	_calHitType
HEPREP::HepRepType *	_calHitFaceType
std::map< int, G4String >	materialState

Static Private Attributes
static G4int	sceneIdCount = 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

Author

Mark Donszelmann

Definition at line 64 of file G4HepRepSceneHandler.hh.

Constructor & Destructor Documentation

G4HepRepSceneHandler() [1/2]

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

Definition at line 93 of file G4HepRepSceneHandler.cc.

        : G4VSceneHandler (system, sceneIdCount++, name),
          out                   (0),
          geometryLayer         ("Geometry"),
          eventLayer            ("Event"),
          calHitLayer           ("CalHit"),
          trajectoryLayer       ("Trajectory"),
          hitLayer              ("Hit"),
          rootVolumeName        ("Geometry"),
          baseName              (""),
          eventNumberPrefix     (""),
          eventNumberSuffix     (""),
          eventNumber           (1),
          eventNumberWidth      (-1),
          extension             (""),
          writeBinary           (false),
          writeZip              (false),
          writeGZ               (false),
          writeMultipleFiles    (false),
          currentHit            (NULL),
          currentTrack          (NULL),
          _heprep               (NULL),
          _heprepGeometry       (NULL)
{

#ifdef LDEBUG
    cout << "G4HepRepSceneHandler::G4HepRepSceneHandler: " << system << endl;
#endif

    materialState[kStateSolid]      = G4String("Solid");
    materialState[kStateLiquid]     = G4String("Liquid");
    materialState[kStateGas]        = G4String("Gas");
    materialState[kStateUndefined]  = G4String("Undefined");    

    factory = new XMLHepRepFactory();
    writer = NULL;
    
    // opening of file deferred to closeHepRep();
    openHepRep();
}

Here is the call graph for this function:

Here is the caller graph for this function:

~G4HepRepSceneHandler()

G4HepRepSceneHandler::~G4HepRepSceneHandler ( )

virtual

Definition at line 135 of file G4HepRepSceneHandler.cc.

                                             {
#ifdef LDEBUG
    cout << "G4HepRepSceneHandler::~G4HepRepSceneHandler() " << endl;
#endif
    close();

    delete factory;
    factory = NULL;

    G4HepRep* pHepRepSystem = dynamic_cast<G4HepRep*>(GetGraphicsSystem());
    if (pHepRepSystem) pHepRepSystem->removeSceneHandler();
}

Here is the call graph for this function:

G4HepRepSceneHandler() [2/2]

G4HepRepSceneHandler::G4HepRepSceneHandler ( const G4HepRepSceneHandler &  )

private

Member Function Documentation

addAttDefs()

void G4HepRepSceneHandler::addAttDefs ( HEPREP::HepRepDefinition *  definition, const std::map< G4String, G4AttDef > *  attDefs  )

private

Definition at line 1281 of file G4HepRepSceneHandler.cc.

                                                                                                         {
    if (attDefs == NULL) return;

    // Specify additional attribute definitions.
    map<G4String,G4AttDef>::const_iterator attDefIterator = attDefs->begin();
    while (attDefIterator != attDefs->end()) {
        definition->addAttDef(attDefIterator->first, attDefIterator->second.GetDesc(),
                        attDefIterator->second.GetCategory(), attDefIterator->second.GetExtra());
        attDefIterator++;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

addAttributes()

void G4HepRepSceneHandler::addAttributes ( HEPREP::HepRepInstance *  instance, HEPREP::HepRepType *  type  )

private

Definition at line 1121 of file G4HepRepSceneHandler.cc.

                                                                                   {
    if (currentHit) {
        vector<G4AttValue>* hitAttValues = currentHit->CreateAttValues();
        const map<G4String,G4AttDef>* hitAttDefs = currentHit->GetAttDefs();

        addAttDefs(getHitType(), hitAttDefs);

        // these attValues are non-standard, so can only be added when we have the attDef.
        type->addAttValue("LVol", G4String(""));
        type->addAttValue("HitType", G4String(""));
        type->addAttValue("ID", -1);
        type->addAttValue("Column", -1);
        type->addAttValue("Row", -1);
        type->addAttValue("Energy", 0.0);
        type->addAttValue("Pos", G4String(""));

        addAttVals(instance, hitAttDefs, hitAttValues);
    
        delete hitAttValues;
    
    } else if (currentTrack) {
        vector<G4AttValue>* trajectoryAttValues = currentTrack->CreateAttValues();
        const map<G4String,G4AttDef>* trajectoryAttDefs = currentTrack->GetAttDefs();

        addAttDefs(type, trajectoryAttDefs);
    
        // these attValues are non-standard, so can only be added when we have the attDef.
        type->addAttValue("Ch", 0.0);
        type->addAttValue("Color", 1.0, 1.0, 1.0, 1.0);
        type->addAttValue("ID", -1);
        type->addAttValue("IMom", G4String(""));
        type->addAttValue("IMag", 0.0);
        type->addAttValue("PDG", -1);
        type->addAttValue("PN", G4String(""));
        type->addAttValue("PID", -1);

        addAttVals(instance, trajectoryAttDefs, trajectoryAttValues);
    
        delete trajectoryAttValues;
        
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

addAttVals()

void G4HepRepSceneHandler::addAttVals ( HEPREP::HepRepAttribute *  attribute, const std::map< G4String, G4AttDef > *  attDefs, std::vector< G4AttValue > *  attValues  )

private

Definition at line 1293 of file G4HepRepSceneHandler.cc.

                                                                                                                                      {
    if (attValues == NULL) return;

    // Copy the instance's G4AttValues to HepRepAttValues.
    for (vector<G4AttValue>::iterator attValIterator = attValues->begin(); attValIterator != attValues->end(); attValIterator++) {        
        G4String name = attValIterator->GetName();

        HepRepPoint* point = dynamic_cast<HepRepPoint*>(attribute);
        if ((name == "Pos") && (point != NULL)) {
            G4String pos = attValIterator->GetValue();
//            cout << "Pos* " << pos << endl;
            int is = 0;
            int in = 0;
            int im = 0;
            G4String unit;
            for (unsigned int i=0; i<pos.length(); i++) {
                if (pos[i] == ' ') {
                    if (in == 0) {
                        // first coordinate
                        double factor = atof(pos.substr(is, i-is).c_str())/point->getX();
                        im = (int)(std::log10(factor)+((factor < 1) ? -0.5 : 0.5));
//                        cout << factor << ", " << im << endl;
                    } else if (in == 3) {
                        // unit
                        unit = pos.substr(is, i-is);
                        if (unit == G4String("mum")) {
                            im += -6;
                        } else if (unit == G4String("mm")) {
                            im += -3;
                        } else if (unit == G4String("cm")) {
                            im += -2;
                        } else if (unit == G4String("m")) {
                            im += 0;
                        } else if (unit == G4String("km")) {
                            im += 3;
                        } else {
                            cerr << "HepRepSceneHandler: Unrecognized Unit: '" << unit << "'" << endl;
                        }
                    }
                    is = i+1;
                    in++;
                }
            }
            switch(im) {
                case -6:
                    unit = G4String("mum");
                    break;
                case -3:
                    unit = G4String("mm");
                    break;
                case -2:
                    unit = G4String("cm");
                    break;
                case 0:
                    unit = G4String("m");
                    break;
                case 3:
                    unit = G4String("km");
                    break;
                default:
                    cerr << "HepRepSceneHandler: No valid unit found for im: " << im << endl;
                    unit = G4String("*im");                        
                    break;
            }
//            cout << "U: " << unit << endl;
            setAttribute(attribute, G4String("PointUnit"), unit);
            continue;
        }
                
        // NTP already in points being written
        if (name == "NTP") continue;
        
        // find type of attribute using def
        const map<G4String,G4AttDef>::const_iterator attDefIterator = attDefs->find(name);
        G4String type = attDefIterator->second.GetValueType();
                
        // set based on type
        if ((type == "G4double") || (type == "double")) {   
            setAttribute(attribute, attValIterator->GetName(), atof(attValIterator->GetValue()));           
        } else if ((type == "G4int") || (type == "int")) {  
            setAttribute(attribute, attValIterator->GetName(), atoi(attValIterator->GetValue()));           
        } else { // G4String, string and others
            setAttribute(attribute, attValIterator->GetName(), attValIterator->GetValue());
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

AddCompound() [1/4]

void G4HepRepSceneHandler::AddCompound ( const G4VTrajectory &  trajectory )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 987 of file G4HepRepSceneHandler.cc.

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

Here is the call graph for this function:

AddCompound() [2/4]

void G4HepRepSceneHandler::AddCompound ( const G4VHit &  hit )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 999 of file G4HepRepSceneHandler.cc.

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

Here is the call graph for this function:

AddCompound() [3/4]

void G4HepRepSceneHandler::AddCompound ( const G4VDigi &  digi )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 84 of file G4HepRepSceneHandler.hh.

                                               {
      G4VSceneHandler::AddCompound(digi);
    }

Here is the call graph for this function:

AddCompound() [4/4]

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

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 87 of file G4HepRepSceneHandler.hh.

                                                            {
      G4VSceneHandler::AddCompound(hits);
    }

Here is the call graph for this function:

AddPrimitive() [1/7]

void G4HepRepSceneHandler::AddPrimitive ( const G4Polyline &  line )

virtual

Implements G4VSceneHandler.

Definition at line 741 of file G4HepRepSceneHandler.cc.

                                                               {

#ifdef PDEBUG
    cout << "G4HepRepSceneHandler::AddPrimitive(G4Polyline&) " << line.size() << endl;
#endif
    if (dontWrite()) return;

    if (fProcessing2D) {
      static G4bool warned = false;
      if (!warned) {
    warned = true;
    G4Exception
      ("G4HepRepSceneHandler::AddPrimitive (const G4Polyline&)",
       "vis-HepRep1001", JustWarning,
       "2D polylines not implemented.  Ignored.");
      }
      return;
    }

    HepRepInstance* instance = factory->createHepRepInstance(getEventInstance(), getTrajectoryType());

    addAttributes(instance, getTrajectoryType());

    setColor(instance, GetColor(line));

    setVisibility(instance, line);

    setLine(instance, line);

    for (size_t i=0; i < line.size(); i++) {
        G4Point3D vertex = transform * line[i];
        factory->createHepRepPoint(instance, vertex.x(), vertex.y(), vertex.z());
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

AddPrimitive() [2/7]

void G4HepRepSceneHandler::AddPrimitive ( const G4Text &  )

virtual

Implements G4VSceneHandler.

Definition at line 925 of file G4HepRepSceneHandler.cc.

                                                      {
#ifdef PDEBUG
    cout << "G4HepRepSceneHandler::AddPrimitive(G4Text&) " << endl;
#endif
    if (dontWrite()) return;

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

    cout << "G4HepRepSceneHandler::AddPrimitive G4Text : not yet implemented. " << endl;
}

Here is the call graph for this function:

AddPrimitive() [3/7]

void G4HepRepSceneHandler::AddPrimitive ( const G4Circle &  circle )

virtual

Implements G4VSceneHandler.

Definition at line 828 of file G4HepRepSceneHandler.cc.

                                                               {
#ifdef PDEBUG
    cout << "G4HepRepSceneHandler::AddPrimitive(G4Circle&) " << endl;
#endif
    if (dontWrite()) return;

    if (fProcessing2D) {
      static G4bool warned = false;
      if (!warned) {
    warned = true;
    G4Exception
      ("G4HepRepSceneHandler::AddPrimitive (const G4Circle&)",
       "vis-HepRep1003", JustWarning,
       "2D circles not implemented.  Ignored.");
      }
      return;
    }

    HepRepInstance* instance = factory->createHepRepInstance(getEventInstance(), getHitType());

    addAttributes(instance, getHitType());

    G4Point3D center = transform * circle.GetPosition();

    setColor (instance, GetColor(circle));

    setVisibility(instance, circle);

    setMarker(instance, circle);

    factory->createHepRepPoint(instance, center.x(), center.y(), center.z());
}

Here is the call graph for this function:

AddPrimitive() [4/7]

void G4HepRepSceneHandler::AddPrimitive ( const G4Square &  square )

virtual

Implements G4VSceneHandler.

Definition at line 949 of file G4HepRepSceneHandler.cc.

                                                               {
#ifdef PDEBUG
    cout << "G4HepRepSceneHandler::AddPrimitive(G4Square&) " << endl;
#endif
    if (dontWrite()) return;

    if (fProcessing2D) {
      static G4bool warned = false;
      if (!warned) {
    warned = true;
    G4Exception
      ("G4HepRepSceneHandler::AddPrimitive (const G4Square&)",
       "vis-HepRep1006", JustWarning,
       "2D squares not implemented.  Ignored.");
      }
      return;
    }

    HepRepInstance* instance = factory->createHepRepInstance(getEventInstance(), getHitType());

    addAttributes(instance, getHitType());

    G4Point3D center = transform * square.GetPosition();

    setColor (instance, getColorFor(square));

    setVisibility(instance, square);

    setMarker(instance, square);

    factory->createHepRepPoint(instance, center.x(), center.y(), center.z());
}

Here is the call graph for this function:

AddPrimitive() [5/7]

void G4HepRepSceneHandler::AddPrimitive ( const G4Polyhedron &  polyhedron )

virtual

Implements G4VSceneHandler.

Definition at line 862 of file G4HepRepSceneHandler.cc.

                                                                       {

#ifdef PDEBUG
    cout << "G4HepRepSceneHandler::AddPrimitive(G4Polyhedron&) " << endl;
#endif
    if (dontWrite()) return;

    if (fProcessing2D) {
      static G4bool warned = false;
      if (!warned) {
    warned = true;
    G4Exception
      ("G4HepRepSceneHandler::AddPrimitive (const G4Polyhedron&)",
       "vis-HepRep1004", JustWarning,
       "2D polyhedra not implemented.  Ignored.");
      }
      return;
    }

    G4Normal3D surfaceNormal;
    G4Point3D vertex;

    if (polyhedron.GetNoFacets()==0) return;

    HepRepInstance* instance = getGeometryOrEventInstance(getCalHitType());
        
    addAttributes(instance, getCalHitType());

    setVisibility(instance, polyhedron);
    
    G4int currentDepth = 0;
    G4PhysicalVolumeModel* pPVModel =
      dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
    if (pPVModel) currentDepth = pPVModel->GetCurrentDepth();

    G4bool notLastFace;
    do {
        HepRepInstance* face;
        if (isEventData()) {
            face = factory->createHepRepInstance(instance, getCalHitFaceType());
        } else {
            face = getGeometryInstance("*Face", currentDepth+1);
            setAttribute(face, "PickParent", true);
            setAttribute(face, "DrawAs", G4String("Polygon"));
        }
        
        setLine(face, polyhedron);
        setColor(face, GetColor(polyhedron));
        if (isEventData()) setColor(face, GetColor(polyhedron), G4String("FillColor"));

        notLastFace = polyhedron.GetNextNormal (surfaceNormal);

        G4int edgeFlag = 1;
        G4bool notLastEdge;
        do {
            notLastEdge = polyhedron.GetNextVertex (vertex, edgeFlag);
            vertex = transform * vertex;
            factory->createHepRepPoint(face, vertex.x(), vertex.y(), vertex.z());
        } while (notLastEdge);
    } while (notLastFace);
}

Here is the call graph for this function:

AddPrimitive() [6/7]

void G4HepRepSceneHandler::AddPrimitive ( const G4Polymarker &  line )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 777 of file G4HepRepSceneHandler.cc.

                                                                 {

#ifdef PDEBUG
    cout << "G4HepRepSceneHandler::AddPrimitive(G4Polymarker&) " << line.size() << endl;
#endif
    if (dontWrite()) return;

    if (fProcessing2D) {
      static G4bool warned = false;
      if (!warned) {
    warned = true;
    G4Exception
      ("G4HepRepSceneHandler::AddPrimitive (const G4Polymarker&)",
       "vis-HepRep1002", JustWarning,
       "2D polymarkers not implemented.  Ignored.");
      }
      return;
    }

    HepRepInstance* instance = factory->createHepRepInstance(getEventInstance(), getHitType());

    addAttributes(instance, getHitType());

    setColor(instance, GetColor(line));

    setVisibility(instance, line);

    setMarker(instance, line);

    // Default MarkName is set to Circle for this Type.
    int mtype = line.GetMarkerType();
    
    // Cannot be case statement since line.xxx is not a constant
    if (mtype == line.dots) {
        setAttribute(instance, "Fill", true);
        setColor(instance, GetColor(line), G4String("FillColor"));
    } else if (mtype == line.circles) {
    } else if (line.squares) {
        setAttribute(instance, "MarkName", G4String("Box"));
    } else {
        // line.line + default
        setAttribute(instance, "MarkName", G4String("Plus"));
    }

    for (size_t i=0; i < line.size(); i++) {
        G4Point3D vertex = transform * line[i];
        factory->createHepRepPoint(instance, vertex.x(), vertex.y(), vertex.z());
    }
}

Here is the call graph for this function:

AddPrimitive() [7/7]

void G4HepRepSceneHandler::AddPrimitive ( const G4Scale &  scale )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 982 of file G4HepRepSceneHandler.cc.

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

Here is the call graph for this function:

AddSolid() [1/11]

void G4HepRepSceneHandler::AddSolid ( const G4Box &  box )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 468 of file G4HepRepSceneHandler.cc.

                                                    {
#ifdef SDEBUG
    cout << "G4HepRepSceneHandler::AddSolid(const G4Box& box)" << endl;
#endif

    if (dontWrite()) return;
    
    G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();

    if (! messenger->useSolids()) {
        G4VSceneHandler::AddSolid(box);
        return;
    }
    
    G4double dx = box.GetXHalfLength();
    G4double dy = box.GetYHalfLength();
    G4double dz = box.GetZHalfLength();
    
    G4Point3D vertex1(G4Point3D( dx, dy,-dz));
    G4Point3D vertex2(G4Point3D( dx,-dy,-dz));
    G4Point3D vertex3(G4Point3D(-dx,-dy,-dz));
    G4Point3D vertex4(G4Point3D(-dx, dy,-dz));
    G4Point3D vertex5(G4Point3D( dx, dy, dz));
    G4Point3D vertex6(G4Point3D( dx,-dy, dz));
    G4Point3D vertex7(G4Point3D(-dx,-dy, dz));
    G4Point3D vertex8(G4Point3D(-dx, dy, dz));
    
    vertex1 = (transform) * vertex1;
    vertex2 = (transform) * vertex2;
    vertex3 = (transform) * vertex3;
    vertex4 = (transform) * vertex4;
    vertex5 = (transform) * vertex5;
    vertex6 = (transform) * vertex6;
    vertex7 = (transform) * vertex7;
    vertex8 = (transform) * vertex8;

    HepRepInstance* instance = getGeometryOrEventInstance(getCalHitType());
    addAttributes(instance, getCalHitType());

    setAttribute(instance, "DrawAs", G4String("Prism"));
        
    setVisibility(instance, box);
    setLine(instance, box);
    setColor(instance, getColorFor(box));

    factory->createHepRepPoint(instance, vertex1.x(), vertex1.y(), vertex1.z());
    factory->createHepRepPoint(instance, vertex2.x(), vertex2.y(), vertex2.z());
    factory->createHepRepPoint(instance, vertex3.x(), vertex3.y(), vertex3.z());
    factory->createHepRepPoint(instance, vertex4.x(), vertex4.y(), vertex4.z());
    factory->createHepRepPoint(instance, vertex5.x(), vertex5.y(), vertex5.z());
    factory->createHepRepPoint(instance, vertex6.x(), vertex6.y(), vertex6.z());
    factory->createHepRepPoint(instance, vertex7.x(), vertex7.y(), vertex7.z());
    factory->createHepRepPoint(instance, vertex8.x(), vertex8.y(), vertex8.z());
}

Here is the call graph for this function:

AddSolid() [2/11]

void G4HepRepSceneHandler::AddSolid ( const G4Cons &  cons )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 524 of file G4HepRepSceneHandler.cc.

                                                      {
#ifdef SDEBUG
    cout << "G4HepRepSceneHandler::AddSolid(const G4Cons& cons)" << endl;
#endif

    if (dontWrite()) return;
    
    G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();

    if (! messenger->useSolids() || (cons.GetDeltaPhiAngle() < twopi)) {
        G4VSceneHandler::AddSolid(cons);
        return;
    }

    G4PhysicalVolumeModel* pPVModel =
      dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
    if (!pPVModel) {
      G4VSceneHandler::AddSolid(cons);
        return;
    }

    G4LogicalVolume* pCurrentLV = pPVModel->GetCurrentLV();
    G4int currentDepth = pPVModel->GetCurrentDepth();
    G4Material* pCurrentMaterial = pPVModel->GetCurrentMaterial();

    G4Point3D vertex1(G4Point3D( 0., 0., cons.GetZHalfLength()));
    G4Point3D vertex2(G4Point3D( 0., 0.,-cons.GetZHalfLength()));

    vertex1 = (transform) * vertex1;
    vertex2 = (transform) * vertex2;

    HepRepInstance* instance = getGeometryInstance(pCurrentLV, pCurrentMaterial, currentDepth);
    setAttribute(instance, "DrawAs", G4String("Cylinder"));
        
    setVisibility(instance, cons);
    setLine(instance, cons);
    setColor(instance, getColorFor(cons));

    HepRepType* type = getGeometryType(pCurrentLV->GetName(), currentDepth);

    // Outer cylinder.
    HepRepInstance* outer = factory->createHepRepInstance(instance, type);
    outer->addAttValue("pickParent",true);
    outer->addAttValue("showParentAttributes",true);
    
    HepRepPoint* op1 = factory->createHepRepPoint(outer, vertex1.x(), vertex1.y(), vertex1.z());
    op1->addAttValue("Radius",cons.GetOuterRadiusPlusZ());
    
    HepRepPoint* op2 = factory->createHepRepPoint(outer, vertex2.x(), vertex2.y(), vertex2.z());
    op2->addAttValue("Radius",cons.GetOuterRadiusMinusZ());

    // Inner cylinder.
    HepRepInstance* inner = factory->createHepRepInstance(instance, type);
    inner->addAttValue("pickParent",true);
    inner->addAttValue("showParentAttributes",true);
    
    HepRepPoint* ip1 = factory->createHepRepPoint(inner, vertex1.x(), vertex1.y(), vertex1.z());
    ip1->addAttValue("Radius",cons.GetInnerRadiusPlusZ());
    
    HepRepPoint* ip2 = factory->createHepRepPoint(inner, vertex2.x(), vertex2.y(), vertex2.z());
    ip2->addAttValue("Radius",cons.GetInnerRadiusMinusZ());
}

Here is the call graph for this function:

AddSolid() [3/11]

void G4HepRepSceneHandler::AddSolid ( const G4Tubs &  tubs )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 588 of file G4HepRepSceneHandler.cc.

                                                      {
#ifdef SDEBUG
    cout << "G4HepRepSceneHandler::AddSolid(const G4Tubs& tubs)" << endl;
#endif

    if (dontWrite()) return;
    
    G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();

    if (! messenger->useSolids() || (tubs.GetDeltaPhiAngle() < twopi)) {
        G4VSceneHandler::AddSolid(tubs);
        return;
    }
    
    G4PhysicalVolumeModel* pPVModel =
      dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
    if (!pPVModel) {
      G4VSceneHandler::AddSolid(tubs);
        return;
    }

    G4LogicalVolume* pCurrentLV = pPVModel->GetCurrentLV();
    G4int currentDepth = pPVModel->GetCurrentDepth();
    G4Material* pCurrentMaterial = pPVModel->GetCurrentMaterial();

    G4Point3D vertex1(G4Point3D( 0., 0., tubs.GetZHalfLength()));
    G4Point3D vertex2(G4Point3D( 0., 0.,-tubs.GetZHalfLength()));

    vertex1 = (transform) * vertex1;
    vertex2 = (transform) * vertex2;

    HepRepInstance* instance = getGeometryInstance(pCurrentLV, pCurrentMaterial, currentDepth);
    setAttribute(instance, "DrawAs", G4String("Cylinder"));
        
    setVisibility(instance, tubs);
    setLine(instance, tubs);
    setColor(instance, getColorFor(tubs));

    HepRepType* type = getGeometryType(pCurrentLV->GetName(), currentDepth);

    // Outer cylinder.
    HepRepInstance* outer = factory->createHepRepInstance(instance, type);
    outer->addAttValue("Radius",tubs.GetOuterRadius());
    outer->addAttValue("pickParent",true);
    outer->addAttValue("showParentAttributes",true);
    factory->createHepRepPoint(outer, vertex1.x(), vertex1.y(), vertex1.z());
    factory->createHepRepPoint(outer, vertex2.x(), vertex2.y(), vertex2.z());

    // Inner cylinder.
    if (tubs.GetInnerRadius() > 0.) {
        HepRepInstance* inner = factory->createHepRepInstance(instance, type);
        inner->addAttValue("Radius",tubs.GetInnerRadius());
        inner->addAttValue("pickParent",true);
        inner->addAttValue("showParentAttributes",true);
        factory->createHepRepPoint(inner, vertex1.x(), vertex1.y(), vertex1.z());
        factory->createHepRepPoint(inner, vertex2.x(), vertex2.y(), vertex2.z());
    }
}

Here is the call graph for this function:

AddSolid() [4/11]

void G4HepRepSceneHandler::AddSolid ( const G4Trd &  trd )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 648 of file G4HepRepSceneHandler.cc.

                                                    {
#ifdef SDEBUG
    cout << "G4HepRepSceneHandler::AddSolid(const G4Trd& trd)" << endl;
#endif
    if (dontWrite()) return;
    
    G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();

    if (! messenger->useSolids()) {
        G4VSceneHandler::AddSolid(trd);
        return;
    }
    
    G4double dx1 = trd.GetXHalfLength1();
    G4double dy1 = trd.GetYHalfLength1();
    G4double dx2 = trd.GetXHalfLength2();
    G4double dy2 = trd.GetYHalfLength2();
    G4double dz = trd.GetZHalfLength();
    
    G4Point3D vertex1(G4Point3D( dx1, dy1,-dz));
    G4Point3D vertex2(G4Point3D( dx1,-dy1,-dz));
    G4Point3D vertex3(G4Point3D(-dx1,-dy1,-dz));
    G4Point3D vertex4(G4Point3D(-dx1, dy1,-dz));
    G4Point3D vertex5(G4Point3D( dx2, dy2, dz));
    G4Point3D vertex6(G4Point3D( dx2,-dy2, dz));
    G4Point3D vertex7(G4Point3D(-dx2,-dy2, dz));
    G4Point3D vertex8(G4Point3D(-dx2, dy2, dz));
    
    vertex1 = (transform) * vertex1;
    vertex2 = (transform) * vertex2;
    vertex3 = (transform) * vertex3;
    vertex4 = (transform) * vertex4;
    vertex5 = (transform) * vertex5;
    vertex6 = (transform) * vertex6;
    vertex7 = (transform) * vertex7;
    vertex8 = (transform) * vertex8;

    HepRepInstance* instance = getGeometryOrEventInstance(getCalHitType());

    addAttributes(instance, getCalHitType());

    setAttribute(instance, "DrawAs", G4String("Prism"));
        
    setVisibility(instance, trd);
    setLine(instance, trd);
    setColor(instance, getColorFor(trd));

    factory->createHepRepPoint(instance, vertex1.x(), vertex1.y(), vertex1.z());
    factory->createHepRepPoint(instance, vertex2.x(), vertex2.y(), vertex2.z());
    factory->createHepRepPoint(instance, vertex3.x(), vertex3.y(), vertex3.z());
    factory->createHepRepPoint(instance, vertex4.x(), vertex4.y(), vertex4.z());
    factory->createHepRepPoint(instance, vertex5.x(), vertex5.y(), vertex5.z());
    factory->createHepRepPoint(instance, vertex6.x(), vertex6.y(), vertex6.z());
    factory->createHepRepPoint(instance, vertex7.x(), vertex7.y(), vertex7.z());
    factory->createHepRepPoint(instance, vertex8.x(), vertex8.y(), vertex8.z());
}

Here is the call graph for this function:

AddSolid() [5/11]

void G4HepRepSceneHandler::AddSolid ( const G4Trap &  trap )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 705 of file G4HepRepSceneHandler.cc.

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

Here is the call graph for this function:

AddSolid() [6/11]

void G4HepRepSceneHandler::AddSolid ( const G4Sphere &  sphere )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 710 of file G4HepRepSceneHandler.cc.

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

Here is the call graph for this function:

AddSolid() [7/11]

void G4HepRepSceneHandler::AddSolid ( const G4Para &  para )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 715 of file G4HepRepSceneHandler.cc.

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

Here is the call graph for this function:

AddSolid() [8/11]

void G4HepRepSceneHandler::AddSolid ( const G4Torus &  torus )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 720 of file G4HepRepSceneHandler.cc.

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

Here is the call graph for this function:

AddSolid() [9/11]

void G4HepRepSceneHandler::AddSolid ( const G4Polycone &  polycone )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 725 of file G4HepRepSceneHandler.cc.

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

Here is the call graph for this function:

AddSolid() [10/11]

void G4HepRepSceneHandler::AddSolid ( const G4Polyhedra &  polyhedra )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 730 of file G4HepRepSceneHandler.cc.

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

Here is the call graph for this function:

AddSolid() [11/11]

void G4HepRepSceneHandler::AddSolid ( const G4VSolid &  solid )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 735 of file G4HepRepSceneHandler.cc.

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

Here is the call graph for this function:

addTopLevelAttributes()

void G4HepRepSceneHandler::addTopLevelAttributes ( HEPREP::HepRepType *  type )

private

Definition at line 1387 of file G4HepRepSceneHandler.cc.

                                                                 {
    
    // Some non-standard attributes
    type->addAttDef(  "Generator", "Generator of the file", "General", "");
    type->addAttValue("Generator", G4String("Geant4"));

    type->addAttDef(  "GeneratorVersion", "Version of the Generator", "General", "");
    G4String versionString = G4Version;
    versionString = versionString.substr(1,versionString.size()-2);
    versionString = " Geant4 version " + versionString + "   " + G4Date;
    type->addAttValue("GeneratorVersion", versionString);
    
    const G4ViewParameters parameters = GetCurrentViewer()->GetViewParameters();
    const G4Vector3D& viewPointDirection = parameters.GetViewpointDirection();    
    type->addAttDef(  "ViewTheta", "Theta of initial suggested viewpoint", "Draw", "rad");
    type->addAttValue("ViewTheta", viewPointDirection.theta());    
    
    type->addAttDef(  "ViewPhi", "Phi of initial suggested viewpoint", "Draw", "rad");
    type->addAttValue("ViewPhi", viewPointDirection.phi());    
    
    type->addAttDef(  "ViewScale", "Scale of initial suggested viewpoint", "Draw", "");
    type->addAttValue("ViewScale", parameters.GetZoomFactor());    
    
// FIXME, no way to set these
    type->addAttDef(  "ViewTranslateX", "Translate in X of initial suggested viewpoint", "Draw", "");
    type->addAttValue("ViewTranslateX", 0.0);    
    
    type->addAttDef(  "ViewTranslateY", "Translate in Y of initial suggested viewpoint", "Draw", "");
    type->addAttValue("ViewTranslateY", 0.0);    
    
    type->addAttDef(  "ViewTranslateZ", "Translate in Z of initial suggested viewpoint", "Draw", "");
    type->addAttValue("ViewTranslateZ", 0.0);    
    
    type->addAttDef(  "PointUnit", "Length", "Physics", "");
    type->addAttValue("PointUnit", G4String("m"));
    
    G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();

    type->addAttDef(  "UseSolids", "Use HepRep Solids rather than Geant4 Primitives", "Draw", "");
    type->addAttValue("UseSolids", messenger->useSolids());

    type->addAttDef(  "WriteInvisibles", "Write Invisible Objects", "Draw", "");
    type->addAttValue("WriteInvisibles", messenger->writeInvisibles());
}           

Here is the call graph for this function:

Here is the caller graph for this function:

BeginModeling()

void G4HepRepSceneHandler::BeginModeling ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 453 of file G4HepRepSceneHandler.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

BeginPrimitives()

void G4HepRepSceneHandler::BeginPrimitives ( const G4Transform3D &  objectTransformation )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1030 of file G4HepRepSceneHandler.cc.

                                                                                     {
#ifdef SDEBUG
    cout << "G4HepRepSceneHandler::BeginPrimitives(G4Transform3D&)" << endl;
#endif

    G4VSceneHandler::BeginPrimitives (objectTransformation);
    transform = objectTransformation;
}

Here is the call graph for this function:

Here is the caller graph for this function:

close()

void G4HepRepSceneHandler::close ( )

private

Definition at line 413 of file G4HepRepSceneHandler.cc.

                                 {

#ifdef LDEBUG
    cout << "G4HepRepSceneHandler::Close() " << endl;
#endif

    if (writer == NULL) return;
    
    if (!writeMultipleFiles) {
        closeHepRep(true);
        closeFile();
    }
    
    G4HepRepViewer* viewer = dynamic_cast<G4HepRepViewer*>(GetCurrentViewer());
    viewer->reset();
}

Here is the call graph for this function:

Here is the caller graph for this function:

closeFile()

void G4HepRepSceneHandler::closeFile

(

)

Definition at line 435 of file G4HepRepSceneHandler.cc.

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

    delete out;
    out = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

closeHepRep()

bool G4HepRepSceneHandler::closeHepRep

(

bool

final = false

)

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

Definition at line 295 of file G4HepRepSceneHandler.cc.

                                                 {
    if (_heprep == NULL) return true;

#ifdef LDEBUG
    cout << "G4HepRepSceneHandler::CloseHepRep() start" << endl;
#endif

    // if this is the final close, then there should not be any event pending to be written.
    if (final) {
        if (_eventInstanceTree != NULL) {
            cerr << "WARNING: you probably used '/vis/viewer/endOfEventAction accumulate' and "
                 << "forgot to call /vis/viewer/update before exit. No event written." << endl;
        }
    } else {
        
        G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();

        // add geometry to the heprep if there is an event (separate geometries are written
        // using DrawView() called from /vis/viewer/flush)
        if (_eventInstanceTree != NULL) {
            GetCurrentViewer()->DrawView();
        
            // couple geometry

            if ( messenger->appendGeometry()) {
                // couple geometry to event if geometry was written
                if ((_geometryInstanceTree != NULL)) {
                    getEventInstanceTree()->addInstanceTree(getGeometryInstanceTree());
                }
            } else {
                char name[128];
                if (writeMultipleFiles) {
                    sprintf(name, "%s%s%s#%s", baseName.c_str(), "-geometry", extension.c_str(), "G4GeometryData");
                } else {
                    sprintf(name, "%s%s#%s", "geometry", (writeBinary ? ".bheprep" : ".heprep"), "G4GeometryData");
                }   
                getEventInstanceTree()->addInstanceTree(factory->createHepRepTreeID(name, "1.0"));
            }
        }
    
        // force inclusion of all subtypes of event
        if (_eventInstanceTree != NULL) {
            getEventType();
            getTrajectoryType();
            getHitType();
            getCalHitType();
            getCalHitFaceType();
        }
    
        // Give this HepRep all of the layer order info for both geometry and event,
        // since these will both end up in a single HepRep.
        writeLayers(_heprepGeometry);
        writeLayers(_heprep);

        // open heprep file
        if (writer == NULL) {
            open((GetScene() == NULL) ? G4String("G4HepRepOutput.heprep.zip") : GetScene()->GetName());
        }

        // write out separate geometry
        if (! messenger->appendGeometry() && (_heprepGeometry != NULL)) {
            if (writeMultipleFiles) {
                char fileName[128];
                sprintf(fileName, "%s%s%s", baseName.c_str(), "-geometry", extension.c_str());
                openFile(G4String(fileName));
            }

            char name[128];
            sprintf(name, "%s%s", "geometry", (writeBinary ? ".bheprep" : ".heprep"));
            if (!writeMultipleFiles) {
                writer->addProperty("RecordLoop.ignore", name);
            }

            writer->write(_heprepGeometry, G4String(name));
            
            delete _heprepGeometry;
            _heprepGeometry = NULL;
            
            if (writeMultipleFiles) closeFile();
        }
    
        if (writeMultipleFiles) {
// NOTE: does not work on Solaris 5.2 and Linux 2.95.2
//            stringstream fileName;
//            fileName << baseName << eventNumberPrefix << setw(eventNumberWidth) << setfill('0') << eventNumber << eventNumberSuffix << extension;
//            openFile(fileName.str());
// Use instead:
            char fileName[128];
            char fileFormat[128];
            sprintf(fileFormat, "%s%d%s", "%s%s%0", eventNumberWidth, "d%s%s");
            sprintf(fileName, fileFormat, baseName.c_str(), eventNumberPrefix.c_str(), eventNumber, eventNumberSuffix.c_str(), extension.c_str());
            openFile(G4String(fileName));
        }
            
        // write out the heprep
// NOTE: does not work on Solaris 5.2 and Linux 2.95.2
//        stringstream eventName;
//        eventName << "event-" << setw(eventNumberWidth) << setfill('0') << eventNumber << (writeBinary ? ".bheprep" : ".heprep");
//        writer->write(_heprep, eventName.str());
// Use instead:
        char eventName[128];
        char eventFormat[128];
        sprintf(eventFormat, "%s%d%s%s", "event-%0", eventNumberWidth, "d", (writeBinary ? ".bheprep" : ".heprep"));
        sprintf(eventName, eventFormat, eventNumber);
        if (writer) writer->write(_heprep, G4String(eventName));

        eventNumber++;
    }
    
    delete _heprep;
    _heprep = NULL;

    if (writeMultipleFiles) closeFile();

    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

dontWrite()

G4bool G4HepRepSceneHandler::dontWrite ( )

private

Definition at line 1048 of file G4HepRepSceneHandler.cc.

                                       {    
    G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
    return !( messenger->writeInvisibles() || (fpVisAttribs ? (bool)fpVisAttribs->IsVisible() : true));
}

Here is the call graph for this function:

Here is the caller graph for this function:

EndModeling()

void G4HepRepSceneHandler::EndModeling ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 461 of file G4HepRepSceneHandler.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

EndPrimitives()

void G4HepRepSceneHandler::EndPrimitives ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1040 of file G4HepRepSceneHandler.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

getCalHitFaceType()

HepRepType * G4HepRepSceneHandler::getCalHitFaceType ( )

private

Definition at line 1733 of file G4HepRepSceneHandler.cc.

                                                    {
    if (_calHitFaceType == NULL) {
        _calHitFaceType = factory->createHepRepType(getCalHitType(), "CalHitFace");
        _calHitFaceType->addAttValue("PickParent", true);
    }
    return _calHitFaceType;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getCalHitType()

HepRepType * G4HepRepSceneHandler::getCalHitType ( )

private

Definition at line 1723 of file G4HepRepSceneHandler.cc.

                                                {
    if (_calHitType == NULL) {
        _calHitType = factory->createHepRepType(getEventType(), "CalHit");
        _calHitType->addAttValue("Layer", calHitLayer);
        _calHitType->addAttValue("Fill", true);
        _calHitType->addAttValue("DrawAs", G4String("Polygon"));
    }
    return _calHitType;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getColorFor() [1/2]

G4Color G4HepRepSceneHandler::getColorFor ( const G4Visible &  visible )

private

Definition at line 1069 of file G4HepRepSceneHandler.cc.

                                                                   {
    return GetColor(visible);
}

Here is the call graph for this function:

Here is the caller graph for this function:

getColorFor() [2/2]

G4Color G4HepRepSceneHandler::getColorFor ( const G4VSolid &  solid )

private

Definition at line 1065 of file G4HepRepSceneHandler.cc.

                                                            {
    return fpVisAttribs ? fpVisAttribs->GetColor() : GetColor(NULL);    
}

Here is the call graph for this function:

getEventInstance()

HepRepInstance * G4HepRepSceneHandler::getEventInstance ( )

private

Definition at line 1649 of file G4HepRepSceneHandler.cc.

                                                       {
    if (_eventInstance == NULL) {
        // Create the top level Event Instance.
        _eventInstance = factory->createHepRepInstance(getEventInstanceTree(), getEventType());
    }
    return _eventInstance;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getEventInstanceTree()

HepRepInstanceTree * G4HepRepSceneHandler::getEventInstanceTree ( )

private

Definition at line 1640 of file G4HepRepSceneHandler.cc.

                                                               {
    if (_eventInstanceTree == NULL) {
        // Create the Event InstanceTree.
        _eventInstanceTree = factory->createHepRepInstanceTree("G4EventData", "1.0", getEventTypeTree());
        getHepRep()->addInstanceTree(_eventInstanceTree);
    }
    return _eventInstanceTree;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getEventType()

HepRepType * G4HepRepSceneHandler::getEventType ( )

private

Definition at line 1668 of file G4HepRepSceneHandler.cc.

                                               {
    if (_eventType == NULL) {
        // Create the top level Event Type.
        _eventType = factory->createHepRepType(getEventTypeTree(), "Event");
        _eventType->addAttValue("Layer", eventLayer);

        // add defaults for Events
        _eventType->addAttValue("Visibility", true);
        _eventType->addAttValue("Color", 1.0, 1.0, 1.0, 1.0);
        _eventType->addAttValue("FillColor", 1.0, 1.0, 1.0, 1.0);
        _eventType->addAttValue("LineWidth", 1.0);
        _eventType->addAttValue("HasFrame", true);
        _eventType->addAttValue("PickParent", false);
        _eventType->addAttValue("ShowParentAttributes", false);

        _eventType->addAttValue("MarkSizeMultiplier", 4.0);
        _eventType->addAttValue("LineWidthMultiplier", 1.0);

        addTopLevelAttributes(_eventType);
    }
    
    return _eventType;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getEventTypeTree()

HepRepTypeTree * G4HepRepSceneHandler::getEventTypeTree ( )

private

Definition at line 1657 of file G4HepRepSceneHandler.cc.

                                                       {
    if (_eventTypeTree == NULL) {
        // Create the Event TypeTree.
        HepRepTreeID* eventTreeID = factory->createHepRepTreeID("G4EventTypes", "1.0");
        _eventTypeTree = factory->createHepRepTypeTree(eventTreeID);
        getHepRep()->addTypeTree(_eventTypeTree);    
    }
    
    return _eventTypeTree;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getFullTypeName()

G4String G4HepRepSceneHandler::getFullTypeName ( G4String  volumeName, int  depth  )

private

Definition at line 1611 of file G4HepRepSceneHandler.cc.

                                                                             {
    // check for name depth
    if (depth > (int)_geometryTypeName.size()) {
        // there is a problem, book this type under problems
        G4String problem = "HierarchyProblem";
        if (_geometryType["/"+problem] == NULL) {
            // HepRep uses hierarchical names
            HepRepType* type = factory->createHepRepType(getGeometryRootType(), problem);
            _geometryType["/"+problem] = type;
        }
        return "/" + problem + "/" + volumeName;
    }
    
    // adjust name depth, also pop the current volumeName
    while ((int)_geometryTypeName.size() > depth) {
        _geometryTypeName.pop_back();
    }
    
    // construct full name and push it
    G4String name = (_geometryTypeName.empty()) ? G4String("/"+rootVolumeName) : _geometryTypeName.back();
    name = name + "/" + volumeName;
    _geometryTypeName.push_back(name);
    return name;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getGeometryInstance() [1/2]

HepRepInstance * G4HepRepSceneHandler::getGeometryInstance ( G4LogicalVolume *  volume, G4Material *  material, int  depth  )

private

Definition at line 1486 of file G4HepRepSceneHandler.cc.

                                                                                                                  {
    HepRepInstance* instance = getGeometryInstance(volume->GetName(), depth);

    setAttribute(instance, "LVol",       volume->GetName());
    G4Region* region = volume->GetRegion();
    G4String regionName = region? region->GetName(): G4String("No region");
    setAttribute(instance, "Region",     regionName);
    setAttribute(instance, "RootRegion", volume->IsRootRegion());
    setAttribute(instance, "Solid",      volume->GetSolid()->GetName());
    setAttribute(instance, "EType",      volume->GetSolid()->GetEntityType());
    G4String matName = material? material->GetName(): G4String("No material");
    setAttribute(instance, "Material",   matName );
    G4double matDensity = material? material->GetDensity(): 0.;
    setAttribute(instance, "Density",    matDensity);
    G4double matRadlen = material? material->GetRadlen(): 0.;
    setAttribute(instance, "Radlen",     matRadlen);
    
    G4State matState = material? material->GetState(): kStateUndefined;
    G4String state = materialState[matState];
    setAttribute(instance, "State", state);
    
    return instance;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getGeometryInstance() [2/2]

HepRepInstance * G4HepRepSceneHandler::getGeometryInstance ( G4String  volumeName, int  depth  )

private

Definition at line 1510 of file G4HepRepSceneHandler.cc.

                                                                                        {
    // no extra checks since these are done in the geometryType already

    // adjust depth, also pop the current instance
    while ((int)_geometryInstance.size() > depth) {
        _geometryInstance.pop_back();
    }
    
    // get parent
    HepRepInstance* parent = (_geometryInstance.empty()) ? getGeometryRootInstance() : _geometryInstance.back();
    
    // get type
    HepRepType* type = getGeometryType(volumeName, depth);
    
    // create instance
    HepRepInstance* instance = factory->createHepRepInstance(parent, type);
    _geometryInstance.push_back(instance);

    return instance;
}

Here is the call graph for this function:

getGeometryInstanceTree()

HepRepInstanceTree * G4HepRepSceneHandler::getGeometryInstanceTree ( )

private

Definition at line 1463 of file G4HepRepSceneHandler.cc.

                                                                  {
    if (_geometryInstanceTree == NULL) {
        // Create the Geometry InstanceTree.
        _geometryInstanceTree = factory->createHepRepInstanceTree("G4GeometryData", "1.0", getGeometryTypeTree());
        
        G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
        if ( messenger->appendGeometry()) {
            getHepRep()->addInstanceTree(_geometryInstanceTree);
        } else {
            getHepRepGeometry()->addInstanceTree(_geometryInstanceTree);
        }
    }
    return _geometryInstanceTree;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getGeometryOrEventInstance()

HepRepInstance * G4HepRepSceneHandler::getGeometryOrEventInstance ( HEPREP::HepRepType *  type )

private

Definition at line 1433 of file G4HepRepSceneHandler.cc.

                                                                                 {
    if (isEventData()) {
      return factory->createHepRepInstance(getEventInstance(), type);
    } else {
      G4PhysicalVolumeModel* pPVModel =
    dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
      assert(pPVModel);  // To keep Coverity happy.
      G4LogicalVolume* pCurrentLV = pPVModel->GetCurrentLV();
      G4int currentDepth = pPVModel->GetCurrentDepth();
      G4Material* pCurrentMaterial = pPVModel->GetCurrentMaterial();
      return getGeometryInstance(pCurrentLV, pCurrentMaterial, currentDepth);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

getGeometryRootInstance()

HepRepInstance * G4HepRepSceneHandler::getGeometryRootInstance ( )

private

Definition at line 1478 of file G4HepRepSceneHandler.cc.

                                                              {
    if (_geometryRootInstance == NULL) {
        // Create the top level Geometry Instance.
        _geometryRootInstance = factory->createHepRepInstance(getGeometryInstanceTree(), getGeometryRootType());
    }
    return _geometryRootInstance;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getGeometryRootType()

HepRepType * G4HepRepSceneHandler::getGeometryRootType ( )

private

Definition at line 1547 of file G4HepRepSceneHandler.cc.

                                                      {
    if (_geometryRootType == NULL) {
        // Create the top level Geometry Type.
        _geometryRootType = factory->createHepRepType(getGeometryTypeTree(), rootVolumeName);
        _geometryRootType->addAttValue("Layer", geometryLayer);
    
        // Add attdefs used by all geometry types.
        _geometryRootType->addAttDef  ("LVol", "Logical Volume", "Physics","");
        _geometryRootType->addAttValue("LVol", G4String(""));
        _geometryRootType->addAttDef  ("Region", "Cuts Region", "Physics","");
        _geometryRootType->addAttValue("Region", G4String(""));
        _geometryRootType->addAttDef  ("RootRegion", "Root Region", "Physics","");
        _geometryRootType->addAttValue("RootRegion", false);
        _geometryRootType->addAttDef  ("Solid", "Solid Name", "Physics","");
        _geometryRootType->addAttValue("Solid", G4String(""));
        _geometryRootType->addAttDef  ("EType", "Entity Type", "Physics","");
        _geometryRootType->addAttValue("EType", G4String("G4Box"));
        _geometryRootType->addAttDef  ("Material", "Material Name", "Physics","");
        _geometryRootType->addAttValue("Material", G4String("Air"));
        _geometryRootType->addAttDef  ("Density", "Material Density", "Physics","");
        _geometryRootType->addAttValue("Density", 0.0);
        _geometryRootType->addAttDef  ("State", "Material State", "Physics","");
        _geometryRootType->addAttValue("State", G4String("Gas"));
        _geometryRootType->addAttDef  ("Radlen", "Material Radiation Length", "Physics","");
        _geometryRootType->addAttValue("Radlen", 0.0);
        
        // add defaults for Geometry
        _geometryRootType->addAttValue("Color", 0.8, 0.8, 0.8, 1.0);
        _geometryRootType->addAttValue("Visibility", true);
        _geometryRootType->addAttValue("FillColor", 0.8, 0.8, 0.8, 1.0);
        _geometryRootType->addAttValue("LineWidth", 1.0);
        _geometryRootType->addAttValue("DrawAs", G4String("Polygon"));
        _geometryRootType->addAttValue("PickParent", false);
        _geometryRootType->addAttValue("ShowParentAttributes", true);
        
        _geometryRootType->addAttValue("MarkSizeMultiplier", 4.0);
        _geometryRootType->addAttValue("LineWidthMultiplier", 1.0);

        addTopLevelAttributes(_geometryRootType);       
                
        _geometryType["/"+_geometryRootType->getName()] = _geometryRootType;
    }
    return _geometryRootType;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getGeometryType()

HepRepType * G4HepRepSceneHandler::getGeometryType ( G4String  volumeName, int  depth  )

private

Definition at line 1592 of file G4HepRepSceneHandler.cc.

                                                                                {
    // make sure we have a root
    getGeometryRootType();   

    // construct the full name for this volume
    G4String name = getFullTypeName(volumeName, depth);
    
    // lookup type and create if necessary
    HepRepType* type = _geometryType[name];    
    if (type == NULL) {
        G4String parentName = getParentTypeName(depth);
        HepRepType* parentType = _geometryType[parentName];
        // HepRep uses hierarchical names
        type = factory->createHepRepType(parentType, volumeName);
        _geometryType[name] = type;
    }
    return type;   
}

Here is the call graph for this function:

Here is the caller graph for this function:

getGeometryTypeTree()

HepRepTypeTree * G4HepRepSceneHandler::getGeometryTypeTree ( )

private

Definition at line 1531 of file G4HepRepSceneHandler.cc.

                                                          {
    if (_geometryTypeTree == NULL) {
        // Create the Geometry TypeTree.
        HepRepTreeID* geometryTreeID = factory->createHepRepTreeID("G4GeometryTypes", "1.0");
        _geometryTypeTree = factory->createHepRepTypeTree(geometryTreeID);
        
        G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
        if ( messenger->appendGeometry()) {
            getHepRep()->addTypeTree(_geometryTypeTree);
        } else {
            getHepRepGeometry()->addTypeTree(_geometryTypeTree);
        }
    }
    return _geometryTypeTree;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getHepRep()

HepRep * G4HepRepSceneHandler::getHepRep ( )

private

Definition at line 1447 of file G4HepRepSceneHandler.cc.

                                        {
    if (_heprep == NULL) {
        // Create the HepRep that holds the Trees.
        _heprep = factory->createHepRep();
    }
    return _heprep;
}   

Here is the call graph for this function:

Here is the caller graph for this function:

getHepRepGeometry()

HepRep * G4HepRepSceneHandler::getHepRepGeometry ( )

private

Definition at line 1455 of file G4HepRepSceneHandler.cc.

                                                {
    if (_heprepGeometry == NULL) {
        // Create the HepRep that holds the Trees.
        _heprepGeometry = factory->createHepRep();
    }
    return _heprepGeometry;
}   

Here is the call graph for this function:

Here is the caller graph for this function:

getHitType()

HepRepType * G4HepRepSceneHandler::getHitType ( )

private

Definition at line 1710 of file G4HepRepSceneHandler.cc.

                                             {
    if (_hitType == NULL) {
        _hitType = factory->createHepRepType(getEventType(), "Hit");
        _hitType->addAttValue("Layer", hitLayer);
        _hitType->addAttValue("DrawAs", G4String("Point"));
        _hitType->addAttValue("MarkName", G4String("Box"));
        _hitType->addAttValue("MarkSize", 4.0);
        _hitType->addAttValue("MarkType", G4String("Symbol"));
        _hitType->addAttValue("Fill", true);
    }
    return _hitType;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getParentTypeName()

G4String G4HepRepSceneHandler::getParentTypeName ( int  currentDepth )

private

Definition at line 1636 of file G4HepRepSceneHandler.cc.

                                                          {
    return (depth >= 1) ? _geometryTypeName[depth-1] : G4String("/"+rootVolumeName);
}       

Here is the caller graph for this function:

getTrajectoryType()

HepRepType * G4HepRepSceneHandler::getTrajectoryType ( )

private

Definition at line 1692 of file G4HepRepSceneHandler.cc.

                                                    {
    if (_trajectoryType == NULL) {
        _trajectoryType = factory->createHepRepType(getEventType(), "Trajectory");
        
        _trajectoryType->addAttValue("Layer", trajectoryLayer);
        _trajectoryType->addAttValue("DrawAs", G4String("Line"));

        _trajectoryType->addAttValue("LineWidthMultiplier", 2.0);
        
        // attributes to draw the points of a track as markers.
        _trajectoryType->addAttValue("MarkName", G4String("Box"));
        _trajectoryType->addAttValue("MarkSize", 4);
        _trajectoryType->addAttValue("MarkType", G4String("Symbol"));
        _trajectoryType->addAttValue("Fill", true);
    }
    return _trajectoryType;
}

Here is the call graph for this function:

Here is the caller graph for this function:

isEventData()

bool G4HepRepSceneHandler::isEventData ( )

private

Definition at line 1381 of file G4HepRepSceneHandler.cc.

                                        {
    G4PhysicalVolumeModel* pPVModel =
      dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
    return !pPVModel || fReadyForTransients || currentHit || currentTrack;
}

Here is the caller graph for this function:

open()

void G4HepRepSceneHandler::open ( G4String  name )

private

Definition at line 149 of file G4HepRepSceneHandler.cc.

                                             {
    if (writer != NULL) return;

    if (name == "stdout") {
#ifdef LDEBUG
        cout << "G4HepRepSceneHandler::Open() stdout" << endl;
#endif
        writer = factory->createHepRepWriter(&cout, false, false);
        out  = NULL;
        baseName = name;
        eventNumberPrefix = "";
        eventNumberSuffix = "";
        extension = "";
        writeBinary = false;
        writeZip = false;
        writeGZ = false;
        writeMultipleFiles = false;
        eventNumber = 0;
        eventNumberWidth = 0;        
    } else if (name == "stderr") {
#ifdef LDEBUG
        cout << "G4HepRepSceneHandler::Open() stderr" << endl;
#endif
        writer = factory->createHepRepWriter(&cerr, false, false);
        out = NULL;
        baseName = name;
        eventNumberPrefix = "";
        eventNumberSuffix = "";
        extension = "";
        writeBinary = false;
        writeZip = false;
        writeGZ = false;
        writeMultipleFiles = false;
        eventNumber = 0;
        eventNumberWidth = 0;        
    } else {
#ifdef LDEBUG
        cout << "G4HepRepSceneHandler::Open() " << name << endl;
#endif
        if (eventNumberWidth < 0) {
            // derive filename(s)
            // check for extensions
            const unsigned int numberOfExtensions = 8;
            string ext[numberOfExtensions] = {".heprep", ".heprep.xml", ".heprep.zip", ".heprep.gz",
                                              ".bheprep", ".bheprep.xml", ".bheprep.zip", ".bheprep.gz"};
            unsigned int i=0;
            while (i < numberOfExtensions) {
                int dot = name.size() - ext[i].size();
                if ((dot >= 0) && 
                    (name.substr(dot, ext[i].size()) == ext[i])) break;
                i++;
            }
        
            if (i != numberOfExtensions) {
                extension = ext[i];
                writeBinary = i >= (numberOfExtensions/2);
                writeZip = (i == 2) || (i == 6);
                writeGZ = (i == 3) || (i == 7);

                int dot = name.length() - extension.length();
                baseName = (dot >= 0) ? name.substr(0, dot) : "";

            } else {
                // Default for no extension  
                extension = ".heprep.zip";
                writeBinary = false;
                writeZip = true;
                writeGZ = false;
                baseName = name;
            }
        
            writeMultipleFiles = false;
            int startDigit = -1; int endDigit = -1;

            G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();

            string suffix = messenger->getEventNumberSuffix();
            if (suffix != "") {
                // look for 0000 pattern in suffix
                endDigit = suffix.length()-1; 
                while (endDigit >= 0) {
                    if (isdigit(suffix.at(endDigit))) break;
                    endDigit--;
                }
                if (endDigit < 0) {
                    cerr << "/vis/heprep/appendEventNumberSuffix contains no digits" << endl;
                } else {
                    writeMultipleFiles = true;
                    startDigit = endDigit;
                    while (startDigit >= 0) {
                        if (!isdigit(suffix.at(startDigit))) break;
                        startDigit--;
                    }
                    startDigit++;
                }                
            }

            if (writeMultipleFiles) {
                eventNumberPrefix = suffix.substr(0, startDigit);
                eventNumber = atoi(suffix.substr(startDigit, endDigit).c_str());
                eventNumberWidth = endDigit +1 - startDigit;
                eventNumberSuffix = suffix.substr(endDigit+1);
            } else {
                // open single file here
                openFile(baseName+extension);
        
                eventNumber = 1;
                eventNumberWidth = 10;
                eventNumberPrefix = "";
                eventNumberSuffix = "";
            }   
        }    
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

openFile()

void G4HepRepSceneHandler::openFile

(

G4String

name

)

Definition at line 430 of file G4HepRepSceneHandler.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

openHepRep()

void G4HepRepSceneHandler::openHepRep

(

)

Definition at line 265 of file G4HepRepSceneHandler.cc.

                                      {
#ifdef LDEBUG
    cout << "G4HepRepSceneHandler::OpenHepRep() " << endl;
#endif

    if (_heprep != NULL) return;

    // all done on demand, once pointers are set to NULL
    _heprepGeometry       = NULL;
    _geometryInstanceTree = NULL;
    _geometryRootInstance = NULL;
    _geometryInstance.clear();
    _geometryTypeTree     = NULL;
    _geometryRootType     = NULL;
    _geometryTypeName.clear();
    _geometryType.clear();
    _eventInstanceTree    = NULL;
    _eventInstance        = NULL;
    _eventTypeTree        = NULL;
    _eventType            = NULL;
    _trajectoryType       = NULL;
    _hitType              = NULL;
    _calHitType           = NULL;
    _calHitFaceType       = NULL;     
}

Here is the caller graph for this function:

operator=()

G4HepRepSceneHandler& G4HepRepSceneHandler::operator= ( const G4HepRepSceneHandler &  )

private

Here is the caller graph for this function:

PostAddSolid()

void G4HepRepSceneHandler::PostAddSolid ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1022 of file G4HepRepSceneHandler.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

PreAddSolid()

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

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1010 of file G4HepRepSceneHandler.cc.

                                                     {

    G4VSceneHandler::PreAddSolid (objectTransformation, visAttribs);

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

Here is the call graph for this function:

Here is the caller graph for this function:

setAttribute() [1/6]

void G4HepRepSceneHandler::setAttribute ( HEPREP::HepRepAttribute *  attribute, G4String  name, char *  value  )

inlineprivate

Definition at line 140 of file G4HepRepSceneHandler.hh.

                                                                                                {
            setAttribute(attribute, name, G4String(value));
        }

Here is the call graph for this function:

Here is the caller graph for this function:

setAttribute() [2/6]

void G4HepRepSceneHandler::setAttribute ( HEPREP::HepRepAttribute *  attribute, G4String  name, G4String  value  )

private

Definition at line 1164 of file G4HepRepSceneHandler.cc.

                                                                                                 {
    HepRepAttValue* attValue = attribute->getAttValue(name);
    if ((attValue == NULL) || (attValue->getString() != value)) {
        HepRepPoint* point = dynamic_cast<HepRepPoint*>(attribute);
        if (point != NULL) {
            if (point->getInstance()->getAttValueFromNode(name) == NULL) {
                attribute = point->getInstance();
            }
        }
        
        HepRepInstance* instance = dynamic_cast<HepRepInstance*>(attribute);
        if (instance != NULL) {
            // look for definition on type (node only)
            if (instance->getType()->getAttValueFromNode(name) == NULL) {
                attribute = instance->getType();
            }   
        }
        
        attribute->addAttValue(name, value);
    }
}

Here is the call graph for this function:

setAttribute() [3/6]

void G4HepRepSceneHandler::setAttribute ( HEPREP::HepRepAttribute *  attribute, G4String  name, bool  value  )

private

Definition at line 1186 of file G4HepRepSceneHandler.cc.

                                                                                             {
    HepRepAttValue* attValue = attribute->getAttValue(name);
    if ((attValue == NULL) || (attValue->getBoolean() != value)) {
        HepRepPoint* point = dynamic_cast<HepRepPoint*>(attribute);
        if (point != NULL) {
            if (point->getInstance()->getAttValueFromNode(name) == NULL) {
                attribute = point->getInstance();
            }
        }
        
        HepRepInstance* instance = dynamic_cast<HepRepInstance*>(attribute);
        if (instance != NULL) {
            // look for definition on type (node only)
            if (instance->getType()->getAttValueFromNode(name) == NULL) {
                attribute = instance->getType();
            }   
        }
        
        attribute->addAttValue(name, value);
    }
}

Here is the call graph for this function:

setAttribute() [4/6]

void G4HepRepSceneHandler::setAttribute ( HEPREP::HepRepAttribute *  attribute, G4String  name, double  value  )

private

Definition at line 1208 of file G4HepRepSceneHandler.cc.

                                                                                               {
    HepRepAttValue* attValue = attribute->getAttValue(name);
    if ((attValue == NULL) || (attValue->getDouble() != value)) {
        HepRepPoint* point = dynamic_cast<HepRepPoint*>(attribute);
        if (point != NULL) {
            if (point->getInstance()->getAttValueFromNode(name) == NULL) {
                attribute = point->getInstance();
            }
        }
        
        HepRepInstance* instance = dynamic_cast<HepRepInstance*>(attribute);
        if (instance != NULL) {
            // look for definition on type (node only)
            if (instance->getType()->getAttValueFromNode(name) == NULL) {
                attribute = instance->getType();
            }   
        }
        
        attribute->addAttValue(name, value);
    }
}

Here is the call graph for this function:

setAttribute() [5/6]

void G4HepRepSceneHandler::setAttribute ( HEPREP::HepRepAttribute *  attribute, G4String  name, int  value  )

private

Definition at line 1230 of file G4HepRepSceneHandler.cc.

                                                                                            {
    HepRepAttValue* attValue = attribute->getAttValue(name);
    if ((attValue == NULL) || (attValue->getInteger() != value)) {
        HepRepPoint* point = dynamic_cast<HepRepPoint*>(attribute);
        if (point != NULL) {
            if (point->getInstance()->getAttValueFromNode(name) == NULL) {
                attribute = point->getInstance();
            }
        }
        
        HepRepInstance* instance = dynamic_cast<HepRepInstance*>(attribute);
        if (instance != NULL) {
            // look for definition on type (node only)
            if (instance->getType()->getAttValueFromNode(name) == NULL) {
                attribute = instance->getType();
            }   
        }
        
        attribute->addAttValue(name, value);
    }
}

Here is the call graph for this function:

setAttribute() [6/6]

void G4HepRepSceneHandler::setAttribute ( HEPREP::HepRepAttribute *  attribute, G4String  name, double  red, double  green, double  blue, double  alpha  )

private

Definition at line 1252 of file G4HepRepSceneHandler.cc.

                                                                                                                                      {
    HepRepAttValue* attValue = attribute->getAttValue(name);
    vector<double> color;
    if (attValue != NULL) color = attValue->getColor();
    if ((color.size() == 0) ||
        (color[0] != red) ||
        (color[1] != green) ||
        (color[2] != blue) ||
        ((color.size() > 3) && (color[3] != alpha))) {
        
        HepRepPoint* point = dynamic_cast<HepRepPoint*>(attribute);
        if (point != NULL) {
            if (point->getInstance()->getAttValueFromNode(name) == NULL) {
                attribute = point->getInstance();
            }
        }
        
        HepRepInstance* instance = dynamic_cast<HepRepInstance*>(attribute);
        if (instance != NULL) {
            // look for definition on type (node only)
            if (instance->getType()->getAttValueFromNode(name) == NULL) {
                attribute = instance->getType();
            }   
        }
        
        attribute->addAttValue(name, red, green, blue, alpha);
    }
}

Here is the call graph for this function:

setColor()

void G4HepRepSceneHandler::setColor ( HEPREP::HepRepAttribute *  attribute, const G4Color &  color, const G4String &  key = G4String("Color")  )

private

Definition at line 1053 of file G4HepRepSceneHandler.cc.

                                           {
#ifdef CDEBUG
    cout << "G4HepRepSceneHandler::setColor : red : " << color.GetRed ()   <<
                                  " green : " << color.GetGreen () <<
                                  " blue : " << color.GetBlue ()   << endl;
#endif

    setAttribute(attribute, key, color.GetRed(), color.GetGreen(), color.GetBlue(), color.GetAlpha());
}

Here is the call graph for this function:

Here is the caller graph for this function:

setLine() [1/2]

void G4HepRepSceneHandler::setLine ( HEPREP::HepRepAttribute *  attribute, const G4VSolid &  solid  )

private

Definition at line 1083 of file G4HepRepSceneHandler.cc.

                                                                                 {
    setAttribute(attribute, "LineWidth", 1.0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

setLine() [2/2]

void G4HepRepSceneHandler::setLine ( HEPREP::HepRepAttribute *  attribute, const G4Visible &  visible  )

private

Definition at line 1087 of file G4HepRepSceneHandler.cc.

                                                                                        {
    const G4VisAttributes* atts = visible.GetVisAttributes();
    
    setAttribute(attribute, "LineWidth", (atts != NULL) ? atts->GetLineWidth() : 1.0);
    
    if (atts != NULL) {
        switch (atts->GetLineStyle()) {
            case G4VisAttributes::dotted:
                setAttribute(attribute, "LineStyle", G4String("Dotted"));
                break;
            case G4VisAttributes::dashed:
                setAttribute(attribute, "LineStyle", G4String("Dashed"));
                break;
            case G4VisAttributes::unbroken:
            default:
                break;
        }
    }
}

Here is the call graph for this function:

setMarker()

void G4HepRepSceneHandler::setMarker ( HEPREP::HepRepAttribute *  attribute, const G4VMarker &  marker  )

private

Definition at line 1107 of file G4HepRepSceneHandler.cc.

                                                                                         {
    MarkerSizeType markerType;
    G4double size = GetMarkerRadius( marker , markerType );

    setAttribute(attribute, "MarkSize", size);

    if (markerType == screen) setAttribute(attribute, "MarkType", G4String("Symbol"));
    if (marker.GetFillStyle() == G4VMarker::noFill) {
        setAttribute(attribute, "Fill", false);
    } else {
        setColor(attribute, GetColor(marker), G4String("FillColor"));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

setVisibility() [1/2]

void G4HepRepSceneHandler::setVisibility ( HEPREP::HepRepAttribute *  attribute, const G4VSolid &  solid  )

private

Definition at line 1073 of file G4HepRepSceneHandler.cc.

                                                                                       {
    setAttribute(attribute, "Visibility", (fpVisAttribs ? (bool)fpVisAttribs->IsVisible() : true));
}

Here is the call graph for this function:

Here is the caller graph for this function:

setVisibility() [2/2]

void G4HepRepSceneHandler::setVisibility ( HEPREP::HepRepAttribute *  attribute, const G4Visible &  visible  )

private

Definition at line 1077 of file G4HepRepSceneHandler.cc.

                                                                                               {
    const G4VisAttributes* atts = visible.GetVisAttributes();

    setAttribute(attribute, "Visibility", (atts && (atts->IsVisible()==0)) ? false : true);
}

Here is the call graph for this function:

writeLayers()

void G4HepRepSceneHandler::writeLayers ( HEPREP::HepRep *  heprep )

private

Definition at line 444 of file G4HepRepSceneHandler.cc.

                                                     {
    if (heprep == NULL) return;
    heprep->addLayer(geometryLayer); 
    heprep->addLayer(eventLayer);
    heprep->addLayer(calHitLayer);
    heprep->addLayer(trajectoryLayer);
    heprep->addLayer(hitLayer);
}  

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

_calHitFaceType

HEPREP::HepRepType* G4HepRepSceneHandler::_calHitFaceType

private

Definition at line 222 of file G4HepRepSceneHandler.hh.

_calHitType

HEPREP::HepRepType* G4HepRepSceneHandler::_calHitType

private

Definition at line 221 of file G4HepRepSceneHandler.hh.

_eventInstance

HEPREP::HepRepInstance* G4HepRepSceneHandler::_eventInstance

private

Definition at line 216 of file G4HepRepSceneHandler.hh.

_eventInstanceTree

HEPREP::HepRepInstanceTree* G4HepRepSceneHandler::_eventInstanceTree

private

Definition at line 215 of file G4HepRepSceneHandler.hh.

_eventType

HEPREP::HepRepType* G4HepRepSceneHandler::_eventType

private

Definition at line 218 of file G4HepRepSceneHandler.hh.

_eventTypeTree

HEPREP::HepRepTypeTree* G4HepRepSceneHandler::_eventTypeTree

private

Definition at line 217 of file G4HepRepSceneHandler.hh.

_geometryInstance

std::vector<HEPREP::HepRepInstance*> G4HepRepSceneHandler::_geometryInstance

private

Definition at line 209 of file G4HepRepSceneHandler.hh.

_geometryInstanceTree

HEPREP::HepRepInstanceTree* G4HepRepSceneHandler::_geometryInstanceTree

private

Definition at line 208 of file G4HepRepSceneHandler.hh.

_geometryRootInstance

HEPREP::HepRepInstance* G4HepRepSceneHandler::_geometryRootInstance

private

Definition at line 210 of file G4HepRepSceneHandler.hh.

_geometryRootType

HEPREP::HepRepType* G4HepRepSceneHandler::_geometryRootType

private

Definition at line 214 of file G4HepRepSceneHandler.hh.

_geometryType

std::map<G4String, HEPREP::HepRepType*> G4HepRepSceneHandler::_geometryType

private

Definition at line 213 of file G4HepRepSceneHandler.hh.

_geometryTypeName

std::vector<G4String> G4HepRepSceneHandler::_geometryTypeName

private

Definition at line 212 of file G4HepRepSceneHandler.hh.

_geometryTypeTree

HEPREP::HepRepTypeTree* G4HepRepSceneHandler::_geometryTypeTree

private

Definition at line 211 of file G4HepRepSceneHandler.hh.

_heprep

HEPREP::HepRep* G4HepRepSceneHandler::_heprep

private

Definition at line 206 of file G4HepRepSceneHandler.hh.

_heprepGeometry

HEPREP::HepRep* G4HepRepSceneHandler::_heprepGeometry

private

Definition at line 207 of file G4HepRepSceneHandler.hh.

_hitType

HEPREP::HepRepType* G4HepRepSceneHandler::_hitType

private

Definition at line 220 of file G4HepRepSceneHandler.hh.

_trajectoryType

HEPREP::HepRepType* G4HepRepSceneHandler::_trajectoryType

private

Definition at line 219 of file G4HepRepSceneHandler.hh.

baseName

G4String G4HepRepSceneHandler::baseName

private

Definition at line 192 of file G4HepRepSceneHandler.hh.

calHitLayer

G4String G4HepRepSceneHandler::calHitLayer

private

Definition at line 188 of file G4HepRepSceneHandler.hh.

currentHit

const G4VHit* G4HepRepSceneHandler::currentHit

private

Definition at line 202 of file G4HepRepSceneHandler.hh.

currentTrack

const G4VTrajectory* G4HepRepSceneHandler::currentTrack

private

Definition at line 203 of file G4HepRepSceneHandler.hh.

eventLayer

G4String G4HepRepSceneHandler::eventLayer

private

Definition at line 188 of file G4HepRepSceneHandler.hh.

eventNumber

G4int G4HepRepSceneHandler::eventNumber

private

Definition at line 195 of file G4HepRepSceneHandler.hh.

eventNumberPrefix

G4String G4HepRepSceneHandler::eventNumberPrefix

private

Definition at line 193 of file G4HepRepSceneHandler.hh.

eventNumberSuffix

G4String G4HepRepSceneHandler::eventNumberSuffix

private

Definition at line 194 of file G4HepRepSceneHandler.hh.

eventNumberWidth

G4int G4HepRepSceneHandler::eventNumberWidth

private

Definition at line 196 of file G4HepRepSceneHandler.hh.

extension

G4String G4HepRepSceneHandler::extension

private

Definition at line 197 of file G4HepRepSceneHandler.hh.

factory

HEPREP::HepRepFactory* G4HepRepSceneHandler::factory

private

Definition at line 121 of file G4HepRepSceneHandler.hh.

geometryLayer

G4String G4HepRepSceneHandler::geometryLayer

private

Definition at line 188 of file G4HepRepSceneHandler.hh.

hitLayer

G4String G4HepRepSceneHandler::hitLayer

private

Definition at line 189 of file G4HepRepSceneHandler.hh.

materialState

std::map<int, G4String> G4HepRepSceneHandler::materialState

private

Definition at line 224 of file G4HepRepSceneHandler.hh.

out

std::ostream* G4HepRepSceneHandler::out

private

Definition at line 120 of file G4HepRepSceneHandler.hh.

rootVolumeName

G4String G4HepRepSceneHandler::rootVolumeName

private

Definition at line 190 of file G4HepRepSceneHandler.hh.

sceneIdCount

G4int G4HepRepSceneHandler::sceneIdCount = 0

staticprivate

Definition at line 116 of file G4HepRepSceneHandler.hh.

trajectoryLayer

G4String G4HepRepSceneHandler::trajectoryLayer

private

Definition at line 189 of file G4HepRepSceneHandler.hh.

transform

G4Transform3D G4HepRepSceneHandler::transform

private

Definition at line 118 of file G4HepRepSceneHandler.hh.

writeBinary

G4bool G4HepRepSceneHandler::writeBinary

private

Definition at line 198 of file G4HepRepSceneHandler.hh.

writeGZ

G4bool G4HepRepSceneHandler::writeGZ

private

Definition at line 200 of file G4HepRepSceneHandler.hh.

writeMultipleFiles

G4bool G4HepRepSceneHandler::writeMultipleFiles

private

Definition at line 201 of file G4HepRepSceneHandler.hh.

writer

HEPREP::HepRepWriter* G4HepRepSceneHandler::writer

private

Definition at line 122 of file G4HepRepSceneHandler.hh.

writeZip

G4bool G4HepRepSceneHandler::writeZip

private

Definition at line 199 of file G4HepRepSceneHandler.hh.

---

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

• G4HepRepSceneHandler.hh
• G4HepRepSceneHandler.cc