G4HepRepSceneHandler Class Reference

#include <G4HepRepSceneHandler.hh>

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

Additional Inherited Members
Public Types inherited from G4VSceneHandler
enum	MarkerSizeType { world, screen }
Protected Member Functions inherited from G4VSceneHandler
virtual void	ProcessScene ()
virtual void	RequestPrimitives (const G4VSolid &solid)
virtual G4VSolid *	CreateSectionSolid ()
virtual G4VSolid *	CreateCutawaySolid ()
void	LoadAtts (const G4Visible &, G4AttHolder *)
Protected Attributes inherited from G4VSceneHandler
G4VGraphicsSystem &	fSystem
const G4int	fSceneHandlerId
G4String	fName
G4int	fViewCount
G4ViewerList	fViewerList
G4VViewer *	fpViewer
G4Scene *	fpScene
G4bool	fMarkForClearingTransientStore
G4bool	fReadyForTransients
G4bool	fTransientsDrawnThisEvent
G4bool	fTransientsDrawnThisRun
G4bool	fProcessingSolid
G4bool	fProcessing2D
G4VModel *	fpModel
G4Transform3D	fObjectTransformation
G4int	fNestingDepth
const G4VisAttributes *	fpVisAttribs
const G4Transform3D	fIdentityTransformation

Detailed Description

Author

Mark Donszelmann

Definition at line 64 of file G4HepRepSceneHandler.hh.

Constructor & Destructor Documentation

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

Definition at line 93 of file G4HepRepSceneHandler.cc.

References kStateGas, kStateLiquid, kStateSolid, kStateUndefined, and openHepRep().

        : 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();
}

G4HepRepSceneHandler::~G4HepRepSceneHandler ( )

virtual

Definition at line 135 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::GetGraphicsSystem(), and G4HepRep::removeSceneHandler().

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

    delete factory;
    factory = NULL;

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

Member Function Documentation

void G4HepRepSceneHandler::AddCompound ( const G4VTrajectory &  trajectory )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 987 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::AddCompound().

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

void G4HepRepSceneHandler::AddCompound ( const G4VHit &  hit )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 999 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::AddCompound().

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

void G4HepRepSceneHandler::AddCompound ( const G4VDigi &  digi )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 84 of file G4HepRepSceneHandler.hh.

References G4VSceneHandler::AddCompound().

                                               {
      G4VSceneHandler::AddCompound(digi);
    }

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

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 87 of file G4HepRepSceneHandler.hh.

References G4VSceneHandler::AddCompound().

                                                            {
      G4VSceneHandler::AddCompound(hits);
    }

void G4HepRepSceneHandler::AddPrimitive ( const G4Polyline &  line )

virtual

Implements G4VSceneHandler.

Definition at line 741 of file G4HepRepSceneHandler.cc.

References HEPREP::HepRepFactory::createHepRepInstance(), HEPREP::HepRepFactory::createHepRepPoint(), G4VSceneHandler::fProcessing2D, G4Exception(), G4VSceneHandler::GetColor(), JustWarning, HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

                                                               {

#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());
    }
}

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;
}

void G4HepRepSceneHandler::AddPrimitive ( const G4Circle &  circle )

virtual

Implements G4VSceneHandler.

Definition at line 828 of file G4HepRepSceneHandler.cc.

References HEPREP::HepRepFactory::createHepRepInstance(), HEPREP::HepRepFactory::createHepRepPoint(), G4VSceneHandler::fProcessing2D, G4Exception(), G4VSceneHandler::GetColor(), G4VMarker::GetPosition(), JustWarning, HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

                                                               {
#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());
}

void G4HepRepSceneHandler::AddPrimitive ( const G4Square &  square )

virtual

Implements G4VSceneHandler.

Definition at line 949 of file G4HepRepSceneHandler.cc.

References HEPREP::HepRepFactory::createHepRepInstance(), HEPREP::HepRepFactory::createHepRepPoint(), G4VSceneHandler::fProcessing2D, G4Exception(), G4VMarker::GetPosition(), JustWarning, HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

                                                               {
#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());
}

void G4HepRepSceneHandler::AddPrimitive ( const G4Polyhedron &  polyhedron )

virtual

Implements G4VSceneHandler.

Definition at line 862 of file G4HepRepSceneHandler.cc.

References HEPREP::HepRepFactory::createHepRepInstance(), HEPREP::HepRepFactory::createHepRepPoint(), G4VSceneHandler::fpModel, G4VSceneHandler::fProcessing2D, G4Exception(), G4VSceneHandler::GetColor(), G4PhysicalVolumeModel::GetCurrentDepth(), HepPolyhedron::GetNextNormal(), HepPolyhedron::GetNextVertex(), HepPolyhedron::GetNoFacets(), and JustWarning.

                                                                       {

#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);
}

void G4HepRepSceneHandler::AddPrimitive ( const G4Polymarker &  line )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 777 of file G4HepRepSceneHandler.cc.

References G4Polymarker::circles, HEPREP::HepRepFactory::createHepRepInstance(), HEPREP::HepRepFactory::createHepRepPoint(), G4Polymarker::dots, G4VSceneHandler::fProcessing2D, G4Exception(), G4VSceneHandler::GetColor(), G4Polymarker::GetMarkerType(), JustWarning, G4Polymarker::squares, HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

                                                                 {

#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());
    }
}

void G4HepRepSceneHandler::AddPrimitive ( const G4Scale &  scale )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 982 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::AddPrimitive().

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

void G4HepRepSceneHandler::AddSolid ( const G4Box &  box )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 468 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::AddSolid(), HEPREP::HepRepFactory::createHepRepPoint(), G4HepRepMessenger::GetInstance(), G4Box::GetXHalfLength(), G4Box::GetYHalfLength(), G4Box::GetZHalfLength(), G4HepRepMessenger::useSolids(), HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

                                                    {
#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());
}

void G4HepRepSceneHandler::AddSolid ( const G4Cons &  cons )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 524 of file G4HepRepSceneHandler.cc.

References HEPREP::HepRepAttribute::addAttValue(), G4VSceneHandler::AddSolid(), HEPREP::HepRepFactory::createHepRepInstance(), HEPREP::HepRepFactory::createHepRepPoint(), G4VSceneHandler::fpModel, G4PhysicalVolumeModel::GetCurrentDepth(), G4PhysicalVolumeModel::GetCurrentLV(), G4PhysicalVolumeModel::GetCurrentMaterial(), G4Cons::GetDeltaPhiAngle(), G4Cons::GetInnerRadiusMinusZ(), G4Cons::GetInnerRadiusPlusZ(), G4HepRepMessenger::GetInstance(), G4LogicalVolume::GetName(), G4Cons::GetOuterRadiusMinusZ(), G4Cons::GetOuterRadiusPlusZ(), G4Cons::GetZHalfLength(), python.hepunit::twopi, G4HepRepMessenger::useSolids(), HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

                                                      {
#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());
}

void G4HepRepSceneHandler::AddSolid ( const G4Tubs &  tubs )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 588 of file G4HepRepSceneHandler.cc.

References HEPREP::HepRepAttribute::addAttValue(), G4VSceneHandler::AddSolid(), HEPREP::HepRepFactory::createHepRepInstance(), HEPREP::HepRepFactory::createHepRepPoint(), G4VSceneHandler::fpModel, G4PhysicalVolumeModel::GetCurrentDepth(), G4PhysicalVolumeModel::GetCurrentLV(), G4PhysicalVolumeModel::GetCurrentMaterial(), G4Tubs::GetDeltaPhiAngle(), G4Tubs::GetInnerRadius(), G4HepRepMessenger::GetInstance(), G4LogicalVolume::GetName(), G4Tubs::GetOuterRadius(), G4Tubs::GetZHalfLength(), python.hepunit::twopi, G4HepRepMessenger::useSolids(), HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

                                                      {
#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());
    }
}

void G4HepRepSceneHandler::AddSolid ( const G4Trd &  trd )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 648 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::AddSolid(), HEPREP::HepRepFactory::createHepRepPoint(), G4HepRepMessenger::GetInstance(), G4Trd::GetXHalfLength1(), G4Trd::GetXHalfLength2(), G4Trd::GetYHalfLength1(), G4Trd::GetYHalfLength2(), G4Trd::GetZHalfLength(), G4HepRepMessenger::useSolids(), HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

                                                    {
#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());
}

void G4HepRepSceneHandler::AddSolid ( const G4Trap &  trap )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 705 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::AddSolid().

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

void G4HepRepSceneHandler::AddSolid ( const G4Sphere &  sphere )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 710 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::AddSolid().

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

void G4HepRepSceneHandler::AddSolid ( const G4Para &  para )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 715 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::AddSolid().

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

void G4HepRepSceneHandler::AddSolid ( const G4Torus &  torus )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 720 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::AddSolid().

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

void G4HepRepSceneHandler::AddSolid ( const G4Polycone &  polycone )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 725 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::AddSolid().

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

void G4HepRepSceneHandler::AddSolid ( const G4Polyhedra &  polyhedra )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 730 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::AddSolid().

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

void G4HepRepSceneHandler::AddSolid ( const G4VSolid &  solid )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 735 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::AddSolid().

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

void G4HepRepSceneHandler::BeginModeling ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 453 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::BeginModeling().

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

void G4HepRepSceneHandler::BeginPrimitives ( const G4Transform3D &  objectTransformation )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1030 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::BeginPrimitives().

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

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

void G4HepRepSceneHandler::closeFile

(

)

Definition at line 435 of file G4HepRepSceneHandler.cc.

References HEPREP::HepRepWriter::close().

Referenced by closeHepRep().

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

    delete out;
    out = NULL;
}

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.

References HEPREP::HepRepInstanceTree::addInstanceTree(), HEPREP::HepRepWriter::addProperty(), G4HepRepMessenger::appendGeometry(), closeFile(), HEPREP::HepRepFactory::createHepRepTreeID(), G4VViewer::DrawView(), G4VSceneHandler::GetCurrentViewer(), G4HepRepMessenger::GetInstance(), G4VSceneHandler::GetName(), G4VSceneHandler::GetScene(), openFile(), and HEPREP::HepRepWriter::write().

Referenced by G4HepRepViewer::ShowView().

                                                 {
    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;
}

void G4HepRepSceneHandler::EndModeling ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 461 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::EndModeling().

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

void G4HepRepSceneHandler::EndPrimitives ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1040 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::EndPrimitives().

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

void G4HepRepSceneHandler::openFile

(

G4String

name

)

Definition at line 430 of file G4HepRepSceneHandler.cc.

References HEPREP::HepRepFactory::createHepRepWriter().

Referenced by closeHepRep().

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

void G4HepRepSceneHandler::openHepRep

(

)

Definition at line 265 of file G4HepRepSceneHandler.cc.

Referenced by G4HepRepSceneHandler(), and G4HepRepViewer::ShowView().

                                      {
#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;     
}

void G4HepRepSceneHandler::PostAddSolid ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1022 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::PostAddSolid().

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

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

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1010 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::PreAddSolid().

                                                     {

    G4VSceneHandler::PreAddSolid (objectTransformation, visAttribs);

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

---

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

• G4HepRepSceneHandler.hh
• G4HepRepSceneHandler.cc