Geant4  10.03.p03
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
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 G4Orb &orb)
 
void AddSolid (const G4Ellipsoid &ellipsoid)
 
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 AddCompound (const G4THitsMap< G4StatDouble > &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 G4VisExtentGetExtent () const
 
const G4StringGetName () const
 
G4int GetSceneHandlerId () const
 
G4int GetViewCount () const
 
G4VGraphicsSystemGetGraphicsSystem () const
 
G4SceneGetScene () const
 
const G4ViewerListGetViewerList () const
 
G4VModelGetModel () const
 
G4VViewerGetCurrentViewer () const
 
G4bool GetMarkForClearingTransientStore () const
 
G4bool IsReadyForTransients () const
 
G4bool GetTransientsDrawnThisEvent () const
 
G4bool GetTransientsDrawnThisRun () const
 
const G4Transform3DGetObjectTransformation () const
 
void SetName (const G4String &)
 
void SetCurrentViewer (G4VViewer *)
 
virtual void SetScene (G4Scene *)
 
G4ViewerListSetViewerList ()
 
void SetModel (G4VModel *)
 
void SetMarkForClearingTransientStore (G4bool)
 
void SetTransientsDrawnThisEvent (G4bool)
 
void SetTransientsDrawnThisRun (G4bool)
 
void SetObjectTransformation (const G4Transform3D &)
 
const G4ColourGetColour ()
 
const G4ColourGetColor ()
 
const G4ColourGetTextColour (const G4Text &)
 
const G4ColourGetTextColor (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 &)
 
G4ModelingParametersCreateModelingParameters ()
 
void DrawEvent (const G4Event *)
 
void DrawEndOfRunModels ()
 
template<class T >
void AddSolidT (const T &solid)
 
template<class T >
void AddSolidWithAuxiliaryEdges (const T &solid)
 
G4int IncrementViewCount ()
 
virtual void ClearStore ()
 
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 G4VSolidCreateSectionSolid ()
 
virtual G4VSolidCreateCutawaySolid ()
 
void LoadAtts (const G4Visible &, G4AttHolder *)
 
- Protected Attributes inherited from G4VSceneHandler
G4VGraphicsSystemfSystem
 
const G4int fSceneHandlerId
 
G4String fName
 
G4int fViewCount
 
G4ViewerList fViewerList
 
G4VViewerfpViewer
 
G4ScenefpScene
 
G4bool fMarkForClearingTransientStore
 
G4bool fReadyForTransients
 
G4bool fTransientsDrawnThisEvent
 
G4bool fTransientsDrawnThisRun
 
G4bool fProcessingSolid
 
G4bool fProcessing2D
 
G4VModelfpModel
 
G4Transform3D fObjectTransformation
 
G4int fNestingDepth
 
const G4VisAttributesfpVisAttribs
 
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.

94  : G4VSceneHandler (system, sceneIdCount++, name),
95  out (0),
96  geometryLayer ("Geometry"),
97  eventLayer ("Event"),
98  calHitLayer ("CalHit"),
99  trajectoryLayer ("Trajectory"),
100  hitLayer ("Hit"),
101  rootVolumeName ("Geometry"),
102  baseName (""),
103  eventNumberPrefix (""),
104  eventNumberSuffix (""),
105  eventNumber (1),
106  eventNumberWidth (-1),
107  extension (""),
108  writeBinary (false),
109  writeZip (false),
110  writeGZ (false),
111  writeMultipleFiles (false),
112  currentHit (NULL),
113  currentTrack (NULL),
114  _heprep (NULL),
115  _heprepGeometry (NULL)
116 {
117 
118 #ifdef LDEBUG
119  cout << "G4HepRepSceneHandler::G4HepRepSceneHandler: " << system << endl;
120 #endif
121 
122  materialState[kStateSolid] = G4String("Solid");
123  materialState[kStateLiquid] = G4String("Liquid");
124  materialState[kStateGas] = G4String("Gas");
125  materialState[kStateUndefined] = G4String("Undefined");
126 
127  factory = new XMLHepRepFactory();
128  writer = NULL;
129 
130  // opening of file deferred to closeHepRep();
131  openHepRep();
132 }
G4VSceneHandler(G4VGraphicsSystem &system, G4int id, const G4String &name="")

Here is the call graph for this function:

G4HepRepSceneHandler::~G4HepRepSceneHandler ( )
virtual

Definition at line 135 of file G4HepRepSceneHandler.cc.

135  {
136 #ifdef LDEBUG
137  cout << "G4HepRepSceneHandler::~G4HepRepSceneHandler() " << endl;
138 #endif
139  close();
140 
141  delete factory;
142  factory = NULL;
143 
144  G4HepRep* pHepRepSystem = dynamic_cast<G4HepRep*>(GetGraphicsSystem());
145  if (pHepRepSystem) pHepRepSystem->removeSceneHandler();
146 }
void removeSceneHandler()
Definition: G4HepRep.cc:79
G4VGraphicsSystem * GetGraphicsSystem() const

Here is the call graph for this function:

Member Function Documentation

void G4HepRepSceneHandler::AddCompound ( const G4VTrajectory trajectory)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 1001 of file G4HepRepSceneHandler.cc.

1001  {
1002 #ifdef PDEBUG
1003  cout << "G4HepRepSceneHandler::AddCompound(G4VTrajectory&) " << endl;
1004 #endif
1005  if (dontWrite()) return;
1006 
1007  currentTrack = &trajectory;
1008  G4VSceneHandler::AddCompound(trajectory);
1009  currentTrack = NULL;
1010 }
virtual void AddCompound(const G4VTrajectory &)

Here is the call graph for this function:

void G4HepRepSceneHandler::AddCompound ( const G4VHit hit)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 1013 of file G4HepRepSceneHandler.cc.

1013  {
1014 #ifdef PDEBUG
1015  cout << "G4HepRepSceneHandler::AddCompound(G4VHit&) " << endl;
1016 #endif
1017  if (dontWrite()) return;
1018 
1019  currentHit = &hit;
1021  currentHit = NULL;
1022 }
virtual void AddCompound(const G4VTrajectory &)

Here is the call graph for this function:

void G4HepRepSceneHandler::AddCompound ( const G4VDigi digi)
inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 86 of file G4HepRepSceneHandler.hh.

86  {
88  }
virtual void AddCompound(const G4VTrajectory &)

Here is the call graph for this function:

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

Reimplemented from G4VSceneHandler.

Definition at line 89 of file G4HepRepSceneHandler.hh.

89  {
91  }
virtual void AddCompound(const G4VTrajectory &)

Here is the call graph for this function:

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

Reimplemented from G4VSceneHandler.

Definition at line 92 of file G4HepRepSceneHandler.hh.

92  {
94  }
virtual void AddCompound(const G4VTrajectory &)

Here is the call graph for this function:

void G4HepRepSceneHandler::AddPrimitive ( const G4Polyline line)
virtual

Implements G4VSceneHandler.

Definition at line 751 of file G4HepRepSceneHandler.cc.

751  {
752 
753 #ifdef PDEBUG
754  cout << "G4HepRepSceneHandler::AddPrimitive(G4Polyline&) " << line.size() << endl;
755 #endif
756  if (dontWrite()) return;
757 
758  if (fProcessing2D) {
759  static G4bool warned = false;
760  if (!warned) {
761  warned = true;
763  ("G4HepRepSceneHandler::AddPrimitive (const G4Polyline&)",
764  "vis-HepRep1001", JustWarning,
765  "2D polylines not implemented. Ignored.");
766  }
767  return;
768  }
769 
770  HepRepInstance* instance = factory->createHepRepInstance(getEventInstance(), getTrajectoryType());
771 
772  addAttributes(instance, getTrajectoryType());
773 
775  setColor(instance, GetColor());
776 
777  setVisibility(instance, line);
778 
779  setLine(instance, line);
780 
781  for (size_t i=0; i < line.size(); i++) {
782  G4Point3D vertex = transform * line[i];
783  factory->createHepRepPoint(instance, vertex.x(), vertex.y(), vertex.z());
784  }
785 }
const G4VisAttributes * GetVisAttributes() const
virtual HepRepInstance * createHepRepInstance(HepRepInstance *parent, HepRepType *type)=0
virtual HepRepPoint * createHepRepPoint(HepRepInstance *instance, double x, double y, double z)=0
bool G4bool
Definition: G4Types.hh:79
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
const G4Colour & GetColor()
const G4VisAttributes * fpVisAttribs
static MCTruthManager * instance

Here is the call graph for this function:

void G4HepRepSceneHandler::AddPrimitive ( const G4Text )
virtual

Implements G4VSceneHandler.

Definition at line 939 of file G4HepRepSceneHandler.cc.

939  {
940 #ifdef PDEBUG
941  cout << "G4HepRepSceneHandler::AddPrimitive(G4Text&) " << endl;
942 #endif
943  if (dontWrite()) return;
944 
945  /*** You may need this
946  if (fProcessing2D) {
947  static G4bool warned = false;
948  if (!warned) {
949  warned = true;
950  G4Exception
951  ("G4HepRepSceneHandler::AddPrimitive (const G4Text&)",
952  "vis-HepRep1005", JustWarning,
953  "2D text not implemented. Ignored.");
954  }
955  return;
956  }
957  ***/
958 
959  cout << "G4HepRepSceneHandler::AddPrimitive G4Text : not yet implemented. " << endl;
960 }
void G4HepRepSceneHandler::AddPrimitive ( const G4Circle circle)
virtual

Implements G4VSceneHandler.

Definition at line 840 of file G4HepRepSceneHandler.cc.

840  {
841 #ifdef PDEBUG
842  cout << "G4HepRepSceneHandler::AddPrimitive(G4Circle&) " << endl;
843 #endif
844  if (dontWrite()) return;
845 
846  if (fProcessing2D) {
847  static G4bool warned = false;
848  if (!warned) {
849  warned = true;
851  ("G4HepRepSceneHandler::AddPrimitive (const G4Circle&)",
852  "vis-HepRep1003", JustWarning,
853  "2D circles not implemented. Ignored.");
854  }
855  return;
856  }
857 
858  HepRepInstance* instance = factory->createHepRepInstance(getEventInstance(), getHitType());
859 
860  addAttributes(instance, getHitType());
861 
862  G4Point3D center = transform * circle.GetPosition();
863 
864  fpVisAttribs = circle.GetVisAttributes();
865  setColor (instance, GetColor());
866 
867  setVisibility(instance, circle);
868 
869  setMarker(instance, circle);
870 
871  factory->createHepRepPoint(instance, center.x(), center.y(), center.z());
872 }
G4Point3D GetPosition() const
const G4VisAttributes * GetVisAttributes() const
virtual HepRepInstance * createHepRepInstance(HepRepInstance *parent, HepRepType *type)=0
virtual HepRepPoint * createHepRepPoint(HepRepInstance *instance, double x, double y, double z)=0
bool G4bool
Definition: G4Types.hh:79
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
const G4Colour & GetColor()
const G4VisAttributes * fpVisAttribs
static MCTruthManager * instance

Here is the call graph for this function:

void G4HepRepSceneHandler::AddPrimitive ( const G4Square square)
virtual

Implements G4VSceneHandler.

Definition at line 963 of file G4HepRepSceneHandler.cc.

963  {
964 #ifdef PDEBUG
965  cout << "G4HepRepSceneHandler::AddPrimitive(G4Square&) " << endl;
966 #endif
967  if (dontWrite()) return;
968 
969  if (fProcessing2D) {
970  static G4bool warned = false;
971  if (!warned) {
972  warned = true;
974  ("G4HepRepSceneHandler::AddPrimitive (const G4Square&)",
975  "vis-HepRep1006", JustWarning,
976  "2D squares not implemented. Ignored.");
977  }
978  return;
979  }
980 
981  HepRepInstance* instance = factory->createHepRepInstance(getEventInstance(), getHitType());
982 
983  addAttributes(instance, getHitType());
984 
985  G4Point3D center = transform * square.GetPosition();
986 
987  setColor (instance, getColorFor(square));
988 
989  setVisibility(instance, square);
990 
991  setMarker(instance, square);
992 
993  factory->createHepRepPoint(instance, center.x(), center.y(), center.z());
994 }
G4Point3D GetPosition() const
virtual HepRepInstance * createHepRepInstance(HepRepInstance *parent, HepRepType *type)=0
virtual HepRepPoint * createHepRepPoint(HepRepInstance *instance, double x, double y, double z)=0
bool G4bool
Definition: G4Types.hh:79
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
static MCTruthManager * instance

Here is the call graph for this function:

void G4HepRepSceneHandler::AddPrimitive ( const G4Polyhedron polyhedron)
virtual

Implements G4VSceneHandler.

Definition at line 875 of file G4HepRepSceneHandler.cc.

875  {
876 
877 #ifdef PDEBUG
878  cout << "G4HepRepSceneHandler::AddPrimitive(G4Polyhedron&) " << endl;
879 #endif
880  if (dontWrite()) return;
881 
882  if (fProcessing2D) {
883  static G4bool warned = false;
884  if (!warned) {
885  warned = true;
887  ("G4HepRepSceneHandler::AddPrimitive (const G4Polyhedron&)",
888  "vis-HepRep1004", JustWarning,
889  "2D polyhedra not implemented. Ignored.");
890  }
891  return;
892  }
893 
894  G4Normal3D surfaceNormal;
895  G4Point3D vertex;
896 
897  if (polyhedron.GetNoFacets()==0) return;
898 
899  HepRepInstance* instance = getGeometryOrEventInstance(getCalHitType());
900 
901  addAttributes(instance, getCalHitType());
902 
903  setVisibility(instance, polyhedron);
904 
905  G4int currentDepth = 0;
906  G4PhysicalVolumeModel* pPVModel =
907  dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
908  if (pPVModel) currentDepth = pPVModel->GetCurrentDepth();
909 
910  G4bool notLastFace;
911  do {
912  HepRepInstance* face;
913  if (isEventData()) {
914  face = factory->createHepRepInstance(instance, getCalHitFaceType());
915  } else {
916  face = getGeometryInstance("*Face", currentDepth+1);
917  setAttribute(face, "PickParent", true);
918  setAttribute(face, "DrawAs", G4String("Polygon"));
919  }
920 
921  setLine(face, polyhedron);
922  fpVisAttribs = polyhedron.GetVisAttributes();
923  setColor(face, GetColor());
924  if (isEventData()) setColor(face, GetColor(), G4String("FillColor"));
925 
926  notLastFace = polyhedron.GetNextNormal (surfaceNormal);
927 
928  G4int edgeFlag = 1;
929  G4bool notLastEdge;
930  do {
931  notLastEdge = polyhedron.GetNextVertex (vertex, edgeFlag);
932  vertex = transform * vertex;
933  factory->createHepRepPoint(face, vertex.x(), vertex.y(), vertex.z());
934  } while (notLastEdge);
935  } while (notLastFace);
936 }
G4bool GetNextNormal(G4Normal3D &normal) const
const G4VisAttributes * GetVisAttributes() const
int G4int
Definition: G4Types.hh:78
virtual HepRepInstance * createHepRepInstance(HepRepInstance *parent, HepRepType *type)=0
virtual HepRepPoint * createHepRepPoint(HepRepInstance *instance, double x, double y, double z)=0
bool G4bool
Definition: G4Types.hh:79
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
const G4Colour & GetColor()
const G4VisAttributes * fpVisAttribs
static MCTruthManager * instance
G4bool GetNextVertex(G4Point3D &vertex, G4int &edgeFlag) const
G4int GetNoFacets() const

Here is the call graph for this function:

void G4HepRepSceneHandler::AddPrimitive ( const G4Polymarker line)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 788 of file G4HepRepSceneHandler.cc.

788  {
789 
790 #ifdef PDEBUG
791  cout << "G4HepRepSceneHandler::AddPrimitive(G4Polymarker&) " << line.size() << endl;
792 #endif
793  if (dontWrite()) return;
794 
795  if (fProcessing2D) {
796  static G4bool warned = false;
797  if (!warned) {
798  warned = true;
800  ("G4HepRepSceneHandler::AddPrimitive (const G4Polymarker&)",
801  "vis-HepRep1002", JustWarning,
802  "2D polymarkers not implemented. Ignored.");
803  }
804  return;
805  }
806 
807  HepRepInstance* instance = factory->createHepRepInstance(getEventInstance(), getHitType());
808 
809  addAttributes(instance, getHitType());
810 
812  setColor(instance, GetColor());
813 
814  setVisibility(instance, line);
815 
816  setMarker(instance, line);
817 
818  // Default MarkName is set to Circle for this Type.
819  int mtype = line.GetMarkerType();
820 
821  // Cannot be case statement since line.xxx is not a constant
822  if (mtype == line.dots) {
823  setAttribute(instance, "Fill", true);
824  setColor(instance, GetColor(), G4String("FillColor"));
825  } else if (mtype == line.circles) {
826  } else if (mtype == line.squares) {
827  setAttribute(instance, "MarkName", G4String("Box"));
828  } else {
829  // line.line + default
830  setAttribute(instance, "MarkName", G4String("Plus"));
831  }
832 
833  for (size_t i=0; i < line.size(); i++) {
834  G4Point3D vertex = transform * line[i];
835  factory->createHepRepPoint(instance, vertex.x(), vertex.y(), vertex.z());
836  }
837 }
MarkerType GetMarkerType() const
const G4VisAttributes * GetVisAttributes() const
virtual HepRepInstance * createHepRepInstance(HepRepInstance *parent, HepRepType *type)=0
virtual HepRepPoint * createHepRepPoint(HepRepInstance *instance, double x, double y, double z)=0
bool G4bool
Definition: G4Types.hh:79
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
const G4Colour & GetColor()
const G4VisAttributes * fpVisAttribs
static MCTruthManager * instance

Here is the call graph for this function:

void G4HepRepSceneHandler::AddPrimitive ( const G4Scale scale)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 996 of file G4HepRepSceneHandler.cc.

996  {
997  if (dontWrite()) return;
999 }
virtual void AddPrimitive(const G4Polyline &)=0

Here is the call graph for this function:

void G4HepRepSceneHandler::AddSolid ( const G4Box box)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 468 of file G4HepRepSceneHandler.cc.

468  {
469 #ifdef SDEBUG
470  cout << "G4HepRepSceneHandler::AddSolid(const G4Box& box)" << endl;
471 #endif
472 
473  if (dontWrite()) return;
474 
476 
477  if (! messenger->useSolids()) {
479  return;
480  }
481 
482  G4double dx = box.GetXHalfLength();
483  G4double dy = box.GetYHalfLength();
484  G4double dz = box.GetZHalfLength();
485 
486  G4Point3D vertex1(G4Point3D( dx, dy,-dz));
487  G4Point3D vertex2(G4Point3D( dx,-dy,-dz));
488  G4Point3D vertex3(G4Point3D(-dx,-dy,-dz));
489  G4Point3D vertex4(G4Point3D(-dx, dy,-dz));
490  G4Point3D vertex5(G4Point3D( dx, dy, dz));
491  G4Point3D vertex6(G4Point3D( dx,-dy, dz));
492  G4Point3D vertex7(G4Point3D(-dx,-dy, dz));
493  G4Point3D vertex8(G4Point3D(-dx, dy, dz));
494 
495  vertex1 = (transform) * vertex1;
496  vertex2 = (transform) * vertex2;
497  vertex3 = (transform) * vertex3;
498  vertex4 = (transform) * vertex4;
499  vertex5 = (transform) * vertex5;
500  vertex6 = (transform) * vertex6;
501  vertex7 = (transform) * vertex7;
502  vertex8 = (transform) * vertex8;
503 
504  HepRepInstance* instance = getGeometryOrEventInstance(getCalHitType());
505  addAttributes(instance, getCalHitType());
506 
507  setAttribute(instance, "DrawAs", G4String("Prism"));
508 
509  setVisibility(instance, box);
510  setLine(instance, box);
511  setColor(instance, getColorFor(box));
512 
513  factory->createHepRepPoint(instance, vertex1.x(), vertex1.y(), vertex1.z());
514  factory->createHepRepPoint(instance, vertex2.x(), vertex2.y(), vertex2.z());
515  factory->createHepRepPoint(instance, vertex3.x(), vertex3.y(), vertex3.z());
516  factory->createHepRepPoint(instance, vertex4.x(), vertex4.y(), vertex4.z());
517  factory->createHepRepPoint(instance, vertex5.x(), vertex5.y(), vertex5.z());
518  factory->createHepRepPoint(instance, vertex6.x(), vertex6.y(), vertex6.z());
519  factory->createHepRepPoint(instance, vertex7.x(), vertex7.y(), vertex7.z());
520  factory->createHepRepPoint(instance, vertex8.x(), vertex8.y(), vertex8.z());
521 }
G4double GetXHalfLength() const
virtual void AddSolid(const G4Box &)
HepGeom::Point3D< G4double > G4Point3D
Definition: G4Point3D.hh:35
G4double GetZHalfLength() const
virtual HepRepPoint * createHepRepPoint(HepRepInstance *instance, double x, double y, double z)=0
static G4HepRepMessenger * GetInstance()
G4double GetYHalfLength() const
static MCTruthManager * instance
double G4double
Definition: G4Types.hh:76
virtual G4bool useSolids()

Here is the call graph for this function:

void G4HepRepSceneHandler::AddSolid ( const G4Cons cons)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 524 of file G4HepRepSceneHandler.cc.

524  {
525 #ifdef SDEBUG
526  cout << "G4HepRepSceneHandler::AddSolid(const G4Cons& cons)" << endl;
527 #endif
528 
529  if (dontWrite()) return;
530 
532 
533  if (! messenger->useSolids() || (cons.GetDeltaPhiAngle() < twopi)) {
535  return;
536  }
537 
538  G4PhysicalVolumeModel* pPVModel =
539  dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
540  if (!pPVModel) {
542  return;
543  }
544 
545  G4LogicalVolume* pCurrentLV = pPVModel->GetCurrentLV();
546  G4int currentDepth = pPVModel->GetCurrentDepth();
547  G4Material* pCurrentMaterial = pPVModel->GetCurrentMaterial();
548 
549  G4Point3D vertex1(G4Point3D( 0., 0., cons.GetZHalfLength()));
550  G4Point3D vertex2(G4Point3D( 0., 0.,-cons.GetZHalfLength()));
551 
552  vertex1 = (transform) * vertex1;
553  vertex2 = (transform) * vertex2;
554 
555  HepRepInstance* instance = getGeometryInstance(pCurrentLV, pCurrentMaterial, currentDepth);
556  setAttribute(instance, "DrawAs", G4String("Cylinder"));
557 
558  setVisibility(instance, cons);
559  setLine(instance, cons);
560  setColor(instance, getColorFor(cons));
561 
562  HepRepType* type = getGeometryType(pCurrentLV->GetName(), currentDepth);
563 
564  // Outer cylinder.
565  HepRepInstance* outer = factory->createHepRepInstance(instance, type);
566  outer->addAttValue("pickParent",true);
567  outer->addAttValue("showParentAttributes",true);
568 
569  HepRepPoint* op1 = factory->createHepRepPoint(outer, vertex1.x(), vertex1.y(), vertex1.z());
570  op1->addAttValue("Radius",cons.GetOuterRadiusPlusZ());
571 
572  HepRepPoint* op2 = factory->createHepRepPoint(outer, vertex2.x(), vertex2.y(), vertex2.z());
573  op2->addAttValue("Radius",cons.GetOuterRadiusMinusZ());
574 
575  // Inner cylinder.
576  HepRepInstance* inner = factory->createHepRepInstance(instance, type);
577  inner->addAttValue("pickParent",true);
578  inner->addAttValue("showParentAttributes",true);
579 
580  HepRepPoint* ip1 = factory->createHepRepPoint(inner, vertex1.x(), vertex1.y(), vertex1.z());
581  ip1->addAttValue("Radius",cons.GetInnerRadiusPlusZ());
582 
583  HepRepPoint* ip2 = factory->createHepRepPoint(inner, vertex2.x(), vertex2.y(), vertex2.z());
584  ip2->addAttValue("Radius",cons.GetInnerRadiusMinusZ());
585 }
virtual void AddSolid(const G4Box &)
G4Material * GetCurrentMaterial() const
HepGeom::Point3D< G4double > G4Point3D
Definition: G4Point3D.hh:35
G4double GetOuterRadiusMinusZ() const
int G4int
Definition: G4Types.hh:78
static constexpr double twopi
Definition: G4SIunits.hh:76
virtual HepRepInstance * createHepRepInstance(HepRepInstance *parent, HepRepType *type)=0
virtual HepRepPoint * createHepRepPoint(HepRepInstance *instance, double x, double y, double z)=0
static G4HepRepMessenger * GetInstance()
virtual void addAttValue(HepRepAttValue *attValue)=0
G4double GetInnerRadiusPlusZ() const
static MCTruthManager * instance
const G4String & GetName() const
G4double GetInnerRadiusMinusZ() const
G4LogicalVolume * GetCurrentLV() const
G4double GetOuterRadiusPlusZ() const
G4double GetZHalfLength() const
virtual G4bool useSolids()
G4double GetDeltaPhiAngle() const

Here is the call graph for this function:

void G4HepRepSceneHandler::AddSolid ( const G4Tubs tubs)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 588 of file G4HepRepSceneHandler.cc.

588  {
589 #ifdef SDEBUG
590  cout << "G4HepRepSceneHandler::AddSolid(const G4Tubs& tubs)" << endl;
591 #endif
592 
593  if (dontWrite()) return;
594 
596 
597  if (! messenger->useSolids() || (tubs.GetDeltaPhiAngle() < twopi)) {
599  return;
600  }
601 
602  G4PhysicalVolumeModel* pPVModel =
603  dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
604  if (!pPVModel) {
606  return;
607  }
608 
609  G4LogicalVolume* pCurrentLV = pPVModel->GetCurrentLV();
610  G4int currentDepth = pPVModel->GetCurrentDepth();
611  G4Material* pCurrentMaterial = pPVModel->GetCurrentMaterial();
612 
613  G4Point3D vertex1(G4Point3D( 0., 0., tubs.GetZHalfLength()));
614  G4Point3D vertex2(G4Point3D( 0., 0.,-tubs.GetZHalfLength()));
615 
616  vertex1 = (transform) * vertex1;
617  vertex2 = (transform) * vertex2;
618 
619  HepRepInstance* instance = getGeometryInstance(pCurrentLV, pCurrentMaterial, currentDepth);
620  setAttribute(instance, "DrawAs", G4String("Cylinder"));
621 
622  setVisibility(instance, tubs);
623  setLine(instance, tubs);
624  setColor(instance, getColorFor(tubs));
625 
626  HepRepType* type = getGeometryType(pCurrentLV->GetName(), currentDepth);
627 
628  // Outer cylinder.
629  HepRepInstance* outer = factory->createHepRepInstance(instance, type);
630  outer->addAttValue("Radius",tubs.GetOuterRadius());
631  outer->addAttValue("pickParent",true);
632  outer->addAttValue("showParentAttributes",true);
633  factory->createHepRepPoint(outer, vertex1.x(), vertex1.y(), vertex1.z());
634  factory->createHepRepPoint(outer, vertex2.x(), vertex2.y(), vertex2.z());
635 
636  // Inner cylinder.
637  if (tubs.GetInnerRadius() > 0.) {
638  HepRepInstance* inner = factory->createHepRepInstance(instance, type);
639  inner->addAttValue("Radius",tubs.GetInnerRadius());
640  inner->addAttValue("pickParent",true);
641  inner->addAttValue("showParentAttributes",true);
642  factory->createHepRepPoint(inner, vertex1.x(), vertex1.y(), vertex1.z());
643  factory->createHepRepPoint(inner, vertex2.x(), vertex2.y(), vertex2.z());
644  }
645 }
virtual void AddSolid(const G4Box &)
G4Material * GetCurrentMaterial() const
HepGeom::Point3D< G4double > G4Point3D
Definition: G4Point3D.hh:35
int G4int
Definition: G4Types.hh:78
static constexpr double twopi
Definition: G4SIunits.hh:76
virtual HepRepInstance * createHepRepInstance(HepRepInstance *parent, HepRepType *type)=0
virtual HepRepPoint * createHepRepPoint(HepRepInstance *instance, double x, double y, double z)=0
G4double GetDeltaPhiAngle() const
static G4HepRepMessenger * GetInstance()
virtual void addAttValue(HepRepAttValue *attValue)=0
G4double GetInnerRadius() const
G4double GetZHalfLength() const
static MCTruthManager * instance
const G4String & GetName() const
G4LogicalVolume * GetCurrentLV() const
virtual G4bool useSolids()
G4double GetOuterRadius() const

Here is the call graph for this function:

void G4HepRepSceneHandler::AddSolid ( const G4Trd trd)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 648 of file G4HepRepSceneHandler.cc.

648  {
649 #ifdef SDEBUG
650  cout << "G4HepRepSceneHandler::AddSolid(const G4Trd& trd)" << endl;
651 #endif
652  if (dontWrite()) return;
653 
655 
656  if (! messenger->useSolids()) {
658  return;
659  }
660 
661  G4double dx1 = trd.GetXHalfLength1();
662  G4double dy1 = trd.GetYHalfLength1();
663  G4double dx2 = trd.GetXHalfLength2();
664  G4double dy2 = trd.GetYHalfLength2();
665  G4double dz = trd.GetZHalfLength();
666 
667  G4Point3D vertex1(G4Point3D( dx1, dy1,-dz));
668  G4Point3D vertex2(G4Point3D( dx1,-dy1,-dz));
669  G4Point3D vertex3(G4Point3D(-dx1,-dy1,-dz));
670  G4Point3D vertex4(G4Point3D(-dx1, dy1,-dz));
671  G4Point3D vertex5(G4Point3D( dx2, dy2, dz));
672  G4Point3D vertex6(G4Point3D( dx2,-dy2, dz));
673  G4Point3D vertex7(G4Point3D(-dx2,-dy2, dz));
674  G4Point3D vertex8(G4Point3D(-dx2, dy2, dz));
675 
676  vertex1 = (transform) * vertex1;
677  vertex2 = (transform) * vertex2;
678  vertex3 = (transform) * vertex3;
679  vertex4 = (transform) * vertex4;
680  vertex5 = (transform) * vertex5;
681  vertex6 = (transform) * vertex6;
682  vertex7 = (transform) * vertex7;
683  vertex8 = (transform) * vertex8;
684 
685  HepRepInstance* instance = getGeometryOrEventInstance(getCalHitType());
686 
687  addAttributes(instance, getCalHitType());
688 
689  setAttribute(instance, "DrawAs", G4String("Prism"));
690 
691  setVisibility(instance, trd);
692  setLine(instance, trd);
693  setColor(instance, getColorFor(trd));
694 
695  factory->createHepRepPoint(instance, vertex1.x(), vertex1.y(), vertex1.z());
696  factory->createHepRepPoint(instance, vertex2.x(), vertex2.y(), vertex2.z());
697  factory->createHepRepPoint(instance, vertex3.x(), vertex3.y(), vertex3.z());
698  factory->createHepRepPoint(instance, vertex4.x(), vertex4.y(), vertex4.z());
699  factory->createHepRepPoint(instance, vertex5.x(), vertex5.y(), vertex5.z());
700  factory->createHepRepPoint(instance, vertex6.x(), vertex6.y(), vertex6.z());
701  factory->createHepRepPoint(instance, vertex7.x(), vertex7.y(), vertex7.z());
702  factory->createHepRepPoint(instance, vertex8.x(), vertex8.y(), vertex8.z());
703 }
virtual void AddSolid(const G4Box &)
G4double GetYHalfLength1() const
HepGeom::Point3D< G4double > G4Point3D
Definition: G4Point3D.hh:35
G4double GetZHalfLength() const
virtual HepRepPoint * createHepRepPoint(HepRepInstance *instance, double x, double y, double z)=0
G4double GetXHalfLength2() const
static G4HepRepMessenger * GetInstance()
G4double GetYHalfLength2() const
G4double GetXHalfLength1() const
static MCTruthManager * instance
double G4double
Definition: G4Types.hh:76
virtual G4bool useSolids()

Here is the call graph for this function:

void G4HepRepSceneHandler::AddSolid ( const G4Trap trap)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 705 of file G4HepRepSceneHandler.cc.

705  {
706  if (dontWrite()) return;
708 }
virtual void AddSolid(const G4Box &)

Here is the call graph for this function:

void G4HepRepSceneHandler::AddSolid ( const G4Sphere sphere)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 710 of file G4HepRepSceneHandler.cc.

710  {
711  if (dontWrite()) return;
712  G4VSceneHandler::AddSolid (sphere);
713 }
virtual void AddSolid(const G4Box &)

Here is the call graph for this function:

void G4HepRepSceneHandler::AddSolid ( const G4Para para)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 715 of file G4HepRepSceneHandler.cc.

715  {
716  if (dontWrite()) return;
718 }
virtual void AddSolid(const G4Box &)

Here is the call graph for this function:

void G4HepRepSceneHandler::AddSolid ( const G4Torus torus)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 720 of file G4HepRepSceneHandler.cc.

720  {
721  if (dontWrite()) return;
722  G4VSceneHandler::AddSolid (torus);
723 }
virtual void AddSolid(const G4Box &)

Here is the call graph for this function:

void G4HepRepSceneHandler::AddSolid ( const G4Polycone polycone)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 725 of file G4HepRepSceneHandler.cc.

725  {
726  if (dontWrite()) return;
727  G4VSceneHandler::AddSolid (polycone);
728 }
virtual void AddSolid(const G4Box &)

Here is the call graph for this function:

void G4HepRepSceneHandler::AddSolid ( const G4Polyhedra polyhedra)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 730 of file G4HepRepSceneHandler.cc.

730  {
731  if (dontWrite()) return;
732  G4VSceneHandler::AddSolid (polyhedra);
733 }
virtual void AddSolid(const G4Box &)

Here is the call graph for this function:

void G4HepRepSceneHandler::AddSolid ( const G4Orb orb)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 735 of file G4HepRepSceneHandler.cc.

735  {
736  if (dontWrite()) return;
738 }
virtual void AddSolid(const G4Box &)

Here is the call graph for this function:

void G4HepRepSceneHandler::AddSolid ( const G4Ellipsoid ellipsoid)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 740 of file G4HepRepSceneHandler.cc.

740  {
741  if (dontWrite()) return;
742  G4VSceneHandler::AddSolid (ellipsoid);
743 }
virtual void AddSolid(const G4Box &)

Here is the call graph for this function:

void G4HepRepSceneHandler::AddSolid ( const G4VSolid solid)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 745 of file G4HepRepSceneHandler.cc.

745  {
746  if (dontWrite()) return;
748 }
virtual void AddSolid(const G4Box &)

Here is the call graph for this function:

void G4HepRepSceneHandler::BeginModeling ( )
virtual

Reimplemented from G4VSceneHandler.

Definition at line 453 of file G4HepRepSceneHandler.cc.

453  {
454 #ifdef SDEBUG
455  cout << "G4HepRepSceneHandler::BeginModeling() " << endl;
456 #endif
458 }
virtual void BeginModeling()

Here is the call graph for this function:

void G4HepRepSceneHandler::BeginPrimitives ( const G4Transform3D objectTransformation)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 1044 of file G4HepRepSceneHandler.cc.

1044  {
1045 #ifdef SDEBUG
1046  cout << "G4HepRepSceneHandler::BeginPrimitives(G4Transform3D&)" << endl;
1047 #endif
1048 
1049  G4VSceneHandler::BeginPrimitives (objectTransformation);
1050  transform = objectTransformation;
1051 }
virtual void BeginPrimitives(const G4Transform3D &objectTransformation)

Here is the call graph for this function:

void G4HepRepSceneHandler::closeFile ( )

Definition at line 435 of file G4HepRepSceneHandler.cc.

435  {
436  writer->close();
437  delete writer;
438  writer = NULL;
439 
440  delete out;
441  out = NULL;
442 }
virtual bool close()=0

Here is the call graph for this function:

Here is the caller graph for this function:

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.

295  {
296  if (_heprep == NULL) return true;
297 
298 #ifdef LDEBUG
299  cout << "G4HepRepSceneHandler::CloseHepRep() start" << endl;
300 #endif
301 
302  // if this is the final close, then there should not be any event pending to be written.
303  if (final) {
304  if (_eventInstanceTree != NULL) {
305  cerr << "WARNING: you probably used '/vis/viewer/endOfEventAction accumulate' and "
306  << "forgot to call /vis/viewer/update before exit. No event written." << endl;
307  }
308  } else {
309 
311 
312  // add geometry to the heprep if there is an event (separate geometries are written
313  // using DrawView() called from /vis/viewer/flush)
314  if (_eventInstanceTree != NULL) {
316 
317  // couple geometry
318 
319  if ( messenger->appendGeometry()) {
320  // couple geometry to event if geometry was written
321  if ((_geometryInstanceTree != NULL)) {
322  getEventInstanceTree()->addInstanceTree(getGeometryInstanceTree());
323  }
324  } else {
325  char name[128];
326  if (writeMultipleFiles) {
327  sprintf(name, "%s%s%s#%s", baseName.c_str(), "-geometry", extension.c_str(), "G4GeometryData");
328  } else {
329  sprintf(name, "%s%s#%s", "geometry", (writeBinary ? ".bheprep" : ".heprep"), "G4GeometryData");
330  }
331  getEventInstanceTree()->addInstanceTree(factory->createHepRepTreeID(name, "1.0"));
332  }
333  }
334 
335  // force inclusion of all subtypes of event
336  if (_eventInstanceTree != NULL) {
337  getEventType();
338  getTrajectoryType();
339  getHitType();
340  getCalHitType();
341  getCalHitFaceType();
342  }
343 
344  // Give this HepRep all of the layer order info for both geometry and event,
345  // since these will both end up in a single HepRep.
346  writeLayers(_heprepGeometry);
347  writeLayers(_heprep);
348 
349  // open heprep file
350  if (writer == NULL) {
351  open((GetScene() == NULL) ? G4String("G4HepRepOutput.heprep.zip") : GetScene()->GetName());
352  }
353 
354  // write out separate geometry
355  if (! messenger->appendGeometry() && (_heprepGeometry != NULL)) {
356  if (writeMultipleFiles) {
357  char fileName[128];
358  sprintf(fileName, "%s%s%s", baseName.c_str(), "-geometry", extension.c_str());
359  openFile(G4String(fileName));
360  }
361 
362  char name[128];
363  sprintf(name, "%s%s", "geometry", (writeBinary ? ".bheprep" : ".heprep"));
364  if (!writeMultipleFiles) {
365  writer->addProperty("RecordLoop.ignore", name);
366  }
367 
368  writer->write(_heprepGeometry, G4String(name));
369 
370  delete _heprepGeometry;
371  _heprepGeometry = NULL;
372 
373  if (writeMultipleFiles) closeFile();
374  }
375 
376  if (writeMultipleFiles) {
377 // NOTE: does not work on Solaris 5.2 and Linux 2.95.2
378 // stringstream fileName;
379 // fileName << baseName << eventNumberPrefix << setw(eventNumberWidth) << setfill('0') << eventNumber << eventNumberSuffix << extension;
380 // openFile(fileName.str());
381 // Use instead:
382  char fileName[128];
383  char fileFormat[128];
384  sprintf(fileFormat, "%s%d%s", "%s%s%0", eventNumberWidth, "d%s%s");
385  sprintf(fileName, fileFormat, baseName.c_str(), eventNumberPrefix.c_str(), eventNumber, eventNumberSuffix.c_str(), extension.c_str());
386  openFile(G4String(fileName));
387  }
388 
389  // write out the heprep
390 // NOTE: does not work on Solaris 5.2 and Linux 2.95.2
391 // stringstream eventName;
392 // eventName << "event-" << setw(eventNumberWidth) << setfill('0') << eventNumber << (writeBinary ? ".bheprep" : ".heprep");
393 // writer->write(_heprep, eventName.str());
394 // Use instead:
395  char eventName[128];
396  char eventFormat[128];
397  sprintf(eventFormat, "%s%d%s%s", "event-%0", eventNumberWidth, "d", (writeBinary ? ".bheprep" : ".heprep"));
398  sprintf(eventName, eventFormat, eventNumber);
399  if (writer) writer->write(_heprep, G4String(eventName));
400 
401  eventNumber++;
402  }
403 
404  delete _heprep;
405  _heprep = NULL;
406 
407  if (writeMultipleFiles) closeFile();
408 
409  return true;
410 }
const XML_Char * name
Definition: expat.h:151
virtual bool write(HepRep *heprep, std::string name)=0
void openFile(G4String name)
virtual bool addProperty(std::string key, std::string value)=0
virtual HepRepTreeID * createHepRepTreeID(std::string name, std::string version, std::string qualifier="top-level")=0
G4VViewer * GetCurrentViewer() const
const G4String & GetName() const
virtual void addInstanceTree(HepRepTreeID *instanceTree)=0
static G4HepRepMessenger * GetInstance()
virtual G4bool appendGeometry()
G4Scene * GetScene() const
virtual void DrawView()=0

Here is the call graph for this function:

Here is the caller graph for this function:

void G4HepRepSceneHandler::EndModeling ( )
virtual

Reimplemented from G4VSceneHandler.

Definition at line 461 of file G4HepRepSceneHandler.cc.

461  {
462 #ifdef SDEBUG
463  cout << "G4HepRepSceneHandler::EndModeling() " << endl;
464 #endif
466 }
virtual void EndModeling()

Here is the call graph for this function:

void G4HepRepSceneHandler::EndPrimitives ( )
virtual

Reimplemented from G4VSceneHandler.

Definition at line 1054 of file G4HepRepSceneHandler.cc.

1054  {
1055 #ifdef SDEBUG
1056  cout << "G4HepRepSceneHandler::EndPrimitives" << endl;
1057 #endif
1059 }
virtual void EndPrimitives()

Here is the call graph for this function:

void G4HepRepSceneHandler::openFile ( G4String  name)

Definition at line 430 of file G4HepRepSceneHandler.cc.

430  {
431  out = new ofstream(name.c_str(), std::ios::out | std::ios::binary );
432  writer = factory->createHepRepWriter(out, writeZip, writeZip || writeGZ);
433 }
virtual HepRepWriter * createHepRepWriter(std::ostream *out, bool randomAccess, bool compress)=0

Here is the call graph for this function:

Here is the caller graph for this function:

void G4HepRepSceneHandler::openHepRep ( )

Definition at line 265 of file G4HepRepSceneHandler.cc.

265  {
266 #ifdef LDEBUG
267  cout << "G4HepRepSceneHandler::OpenHepRep() " << endl;
268 #endif
269 
270  if (_heprep != NULL) return;
271 
272  // all done on demand, once pointers are set to NULL
273  _heprepGeometry = NULL;
274  _geometryInstanceTree = NULL;
275  _geometryRootInstance = NULL;
276  _geometryInstance.clear();
277  _geometryTypeTree = NULL;
278  _geometryRootType = NULL;
279  _geometryTypeName.clear();
280  _geometryType.clear();
281  _eventInstanceTree = NULL;
282  _eventInstance = NULL;
283  _eventTypeTree = NULL;
284  _eventType = NULL;
285  _trajectoryType = NULL;
286  _hitType = NULL;
287  _calHitType = NULL;
288  _calHitFaceType = NULL;
289 }

Here is the caller graph for this function:

void G4HepRepSceneHandler::PostAddSolid ( )
virtual

Reimplemented from G4VSceneHandler.

Definition at line 1036 of file G4HepRepSceneHandler.cc.

1036  {
1037 #ifdef SDEBUG
1038  cout << "G4HepRepSceneHandler::PostAddSolid()" << endl;
1039 #endif
1041 }
virtual void PostAddSolid()

Here is the call graph for this function:

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

Reimplemented from G4VSceneHandler.

Definition at line 1024 of file G4HepRepSceneHandler.cc.

1025  {
1026 
1027  G4VSceneHandler::PreAddSolid (objectTransformation, visAttribs);
1028 
1029  transform = objectTransformation;
1030 #ifdef SDEBUG
1031  cout << "G4HepRepSceneHandler::PreAddSolid(G4Transform3D&, G4VisAttributes&)" << endl;
1032 #endif
1033 }
virtual void PreAddSolid(const G4Transform3D &objectTransformation, const G4VisAttributes &)

Here is the call graph for this function:


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