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

---

Detailed Description

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),
          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 134 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::GetGraphicsSystem().

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

    delete factory;
    factory = NULL;

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

---

Member Function Documentation

void G4HepRepSceneHandler::AddCompound

(

const G4THitsMap< G4double > &

hits

)

[inline, virtual]

Reimplemented from G4VSceneHandler.

Definition at line 87 of file G4HepRepSceneHandler.hh.

References G4VSceneHandler::AddCompound().

                                                            {
          G4VSceneHandler::AddCompound(hits);
        }

void G4HepRepSceneHandler::AddCompound

(

const G4VDigi &

digi

)

[inline, virtual]

Reimplemented from G4VSceneHandler.

Definition at line 84 of file G4HepRepSceneHandler.hh.

References G4VSceneHandler::AddCompound().

                                               {
          G4VSceneHandler::AddCompound(digi);
        }

void G4HepRepSceneHandler::AddCompound

(

const G4VHit &

hit

)

[virtual]

Reimplemented from G4VSceneHandler.

Definition at line 1049 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 G4VTrajectory &

)

[virtual]

Reimplemented from G4VSceneHandler.

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

(

const G4Scale &

scale

)

[virtual]

Reimplemented from G4VSceneHandler.

Definition at line 1032 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::AddPrimitive().

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

void G4HepRepSceneHandler::AddPrimitive

(

const G4Polymarker &

)

[virtual]

Reimplemented from G4VSceneHandler.

Definition at line 804 of file G4HepRepSceneHandler.cc.

References G4Polymarker::circles, G4Polymarker::dots, G4VSceneHandler::fProcessing2D, G4Exception(), G4VSceneHandler::GetColor(), G4Polymarker::GetMarkerType(), JustWarning, and G4Polymarker::squares.

                                                                 {

#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 G4NURBS &

)

[virtual]

Implements G4VSceneHandler.

Definition at line 1009 of file G4HepRepSceneHandler.cc.

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

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

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

void G4HepRepSceneHandler::AddPrimitive

(

const G4Polyhedron &

)

[virtual]

Implements G4VSceneHandler.

Definition at line 889 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::fpModel, G4VSceneHandler::fProcessing2D, G4Exception(), G4VSceneHandler::GetColor(), G4PhysicalVolumeModel::GetCurrentDepth(), 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 G4Square &

)

[virtual]

Implements G4VSceneHandler.

Definition at line 976 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::fProcessing2D, G4Exception(), G4VMarker::GetPosition(), and JustWarning.

                                                               {
#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 G4Circle &

)

[virtual]

Implements G4VSceneHandler.

Definition at line 855 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::fProcessing2D, G4Exception(), G4VSceneHandler::GetColor(), G4VMarker::GetPosition(), and JustWarning.

                                                               {
#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 G4Text &

)

[virtual]

Implements G4VSceneHandler.

Definition at line 952 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 G4Polyline &

)

[virtual]

Implements G4VSceneHandler.

Definition at line 768 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::fProcessing2D, G4Exception(), G4VSceneHandler::GetColor(), and JustWarning.

                                                               {

#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::AddSolid

(

const G4VSolid &

solid

)

[virtual]

Reimplemented from G4VSceneHandler.

Definition at line 762 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::AddSolid().

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

void G4HepRepSceneHandler::AddSolid

(

const G4Polyhedra &

polyhedra

)

[virtual]

Reimplemented from G4VSceneHandler.

Definition at line 757 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::AddSolid().

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

void G4HepRepSceneHandler::AddSolid

(

const G4Polycone &

polycone

)

[virtual]

Reimplemented from G4VSceneHandler.

Definition at line 752 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::AddSolid().

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

void G4HepRepSceneHandler::AddSolid

(

const G4Torus &

torus

)

[virtual]

Reimplemented from G4VSceneHandler.

Definition at line 747 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::AddSolid().

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

void G4HepRepSceneHandler::AddSolid

(

const G4Para &

para

)

[virtual]

Reimplemented from G4VSceneHandler.

Definition at line 742 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::AddSolid().

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

void G4HepRepSceneHandler::AddSolid

(

const G4Sphere &

sphere

)

[virtual]

Reimplemented from G4VSceneHandler.

Definition at line 737 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::AddSolid().

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

void G4HepRepSceneHandler::AddSolid

(

const G4Trap &

trap

)

[virtual]

Reimplemented from G4VSceneHandler.

Definition at line 732 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::AddSolid().

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

void G4HepRepSceneHandler::AddSolid

(

const G4Trd &

trd

)

[virtual]

Reimplemented from G4VSceneHandler.

Definition at line 675 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::AddSolid(), G4HepRepMessenger::GetInstance(), G4Trd::GetXHalfLength1(), G4Trd::GetXHalfLength2(), G4Trd::GetYHalfLength1(), G4Trd::GetYHalfLength2(), G4Trd::GetZHalfLength(), and G4HepRepMessenger::useSolids().

                                                    {
#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 G4Tubs &

tubs

)

[virtual]

Reimplemented from G4VSceneHandler.

Definition at line 615 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::AddSolid(), G4VSceneHandler::fpModel, G4PhysicalVolumeModel::GetCurrentDepth(), G4PhysicalVolumeModel::GetCurrentLV(), G4PhysicalVolumeModel::GetCurrentMaterial(), G4Tubs::GetDeltaPhiAngle(), G4Tubs::GetInnerRadius(), G4HepRepMessenger::GetInstance(), G4LogicalVolume::GetName(), G4Tubs::GetOuterRadius(), G4Tubs::GetZHalfLength(), and G4HepRepMessenger::useSolids().

                                                      {
#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 G4Cons &

cons

)

[virtual]

Reimplemented from G4VSceneHandler.

Definition at line 551 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::AddSolid(), G4VSceneHandler::fpModel, G4PhysicalVolumeModel::GetCurrentDepth(), G4PhysicalVolumeModel::GetCurrentLV(), G4PhysicalVolumeModel::GetCurrentMaterial(), G4Cons::GetDeltaPhiAngle(), G4Cons::GetInnerRadiusMinusZ(), G4Cons::GetInnerRadiusPlusZ(), G4HepRepMessenger::GetInstance(), G4LogicalVolume::GetName(), G4Cons::GetOuterRadiusMinusZ(), G4Cons::GetOuterRadiusPlusZ(), G4Cons::GetZHalfLength(), and G4HepRepMessenger::useSolids().

                                                      {
#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 G4Box &

box

)

[virtual]

Reimplemented from G4VSceneHandler.

Definition at line 495 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::AddSolid(), G4HepRepMessenger::GetInstance(), G4Box::GetXHalfLength(), G4Box::GetYHalfLength(), G4Box::GetZHalfLength(), and G4HepRepMessenger::useSolids().

                                                    {
#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::BeginModeling

(

)

[virtual]

Reimplemented from G4VSceneHandler.

Definition at line 480 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 1080 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 462 of file G4HepRepSceneHandler.cc.

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 322 of file G4HepRepSceneHandler.cc.

References G4HepRepMessenger::appendGeometry(), closeFile(), G4VViewer::DrawView(), G4VSceneHandler::GetCurrentViewer(), G4HepRepMessenger::GetInstance(), G4VSceneHandler::GetName(), G4VSceneHandler::GetScene(), and openFile().

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);
        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 488 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 1090 of file G4HepRepSceneHandler.cc.

References G4VSceneHandler::EndPrimitives().

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

void G4HepRepSceneHandler::openFile

(

G4String

name

)

Definition at line 457 of file G4HepRepSceneHandler.cc.

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 292 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 1072 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 1060 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

---