Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/visualization/HepRep/src/G4HepRepFileSceneHandler.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /visualization/HepRep/src/G4HepRepFileSceneHandler.cc (Version 11.3.0) and /visualization/HepRep/src/G4HepRepFileSceneHandler.cc (Version 8.2.p1)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
                                                   >>  26 // $Id: G4HepRepFileSceneHandler.cc,v 1.64 2006/11/16 21:06:11 perl Exp $
                                                   >>  27 // GEANT4 tag $Name: geant4-08-02-patch-01 $
 26 //                                                 28 //
 27 //                                                 29 //
 28 // Joseph Perl  27th January 2002                  30 // Joseph Perl  27th January 2002
 29 // A base class for a scene handler to export      31 // A base class for a scene handler to export geometry and trajectories
 30 // to the HepRep xml file format.                  32 // to the HepRep xml file format.
 31                                                    33 
 32 #include "G4HepRepFileSceneHandler.hh"             34 #include "G4HepRepFileSceneHandler.hh"
 33 #include "G4HepRepFile.hh"                         35 #include "G4HepRepFile.hh"
 34 #include "G4HepRepMessenger.hh"                << 
 35 #include "G4UIcommand.hh"                      << 
 36                                                    36 
 37 #include "G4PhysicalConstants.hh"              << 
 38 #include "G4SystemOfUnits.hh"                  << 
 39 #include "G4Version.hh"                            37 #include "G4Version.hh"
 40 #include "G4VSolid.hh"                             38 #include "G4VSolid.hh"
 41 #include "G4PhysicalVolumeModel.hh"                39 #include "G4PhysicalVolumeModel.hh"
 42 #include "G4VPhysicalVolume.hh"                    40 #include "G4VPhysicalVolume.hh"
 43 #include "G4LogicalVolume.hh"                      41 #include "G4LogicalVolume.hh"
 44 #include "G4RotationMatrix.hh"                 << 
 45 #include "G4Material.hh"                           42 #include "G4Material.hh"
 46 #include "G4Polymarker.hh"                         43 #include "G4Polymarker.hh"
 47 #include "G4Polyline.hh"                           44 #include "G4Polyline.hh"
 48 #include "G4Text.hh"                               45 #include "G4Text.hh"
 49 #include "G4Circle.hh"                             46 #include "G4Circle.hh"
 50 #include "G4Square.hh"                             47 #include "G4Square.hh"
 51 #include "G4Polyhedron.hh"                         48 #include "G4Polyhedron.hh"
                                                   >>  49 #include "G4NURBS.hh"
 52 #include "G4VTrajectory.hh"                        50 #include "G4VTrajectory.hh"
 53 #include "G4VTrajectoryPoint.hh"                   51 #include "G4VTrajectoryPoint.hh"
 54 #include "G4TrajectoriesModel.hh"                  52 #include "G4TrajectoriesModel.hh"
 55 #include "G4VHit.hh"                               53 #include "G4VHit.hh"
 56 #include "G4AttDef.hh"                             54 #include "G4AttDef.hh"
 57 #include "G4AttValue.hh"                           55 #include "G4AttValue.hh"
 58 #include "G4AttCheck.hh"                           56 #include "G4AttCheck.hh"
 59 #include "G4VisManager.hh"                         57 #include "G4VisManager.hh"
 60 #include "G4VisTrajContext.hh"                     58 #include "G4VisTrajContext.hh"
 61 #include "G4VTrajectoryModel.hh"                   59 #include "G4VTrajectoryModel.hh"
 62                                                    60 
 63 // HepRep                                      <<  61 //HepRep
 64 #include "G4HepRepFileXMLWriter.hh"                62 #include "G4HepRepFileXMLWriter.hh"
 65                                                    63 
 66 G4int G4HepRepFileSceneHandler::fSceneIdCount      64 G4int G4HepRepFileSceneHandler::fSceneIdCount = 0;
 67 // Counter for HepRep scene handlers.              65 // Counter for HepRep scene handlers.
 68                                                    66 
 69 G4HepRepFileSceneHandler::G4HepRepFileSceneHan     67 G4HepRepFileSceneHandler::G4HepRepFileSceneHandler(G4VGraphicsSystem& system,
 70                                                <<  68                            const G4String& name):
 71   : G4VSceneHandler(system, fSceneIdCount++, n <<  69 G4VSceneHandler(system, fSceneIdCount++, name)
 72 {                                                  70 {
 73   hepRepXMLWriter = ((G4HepRepFile*) (&system) <<  71   hepRepXMLWriter = ((G4HepRepFile*)(&system))->GetHepRepXMLWriter();
 74   fileCounter     = 0;                         <<  72   fileCounter = 0;
 75                                                <<  73   int length;
 76   inPrimitives2D       = false;                <<  74   
 77   warnedAbout3DText    = false;                <<  75   if (getenv("G4HEPREPFILE_DIR") == NULL)
 78   warnedAbout2DMarkers = false;                <<  76     strcpy(fileDir, "");
 79   haveVisible          = false;                <<  77   else
 80   drawingTraj          = false;                <<  78     length = sprintf (fileDir, "%s%s", getenv("G4HEPREPFILE_DIR"),"/");
 81   doneInitTraj         = false;                <<  79   
 82   drawingHit           = false;                <<  80   if (getenv("G4HEPREPFILE_NAME") == NULL)
 83   doneInitHit          = false;                <<  81     strcpy(fileName, "G4Data");
 84   trajContext          = 0;                    <<  82   else
 85   trajAttValues        = 0;                    <<  83     strcpy(fileName, getenv("G4HEPREPFILE_NAME"));
 86   trajAttDefs          = 0;                    <<  84   
 87   hitAttValues         = 0;                    <<  85   if (getenv("G4HEPREPFILE_OVERWRITE") == NULL)
 88   hitAttDefs           = 0;                    <<  86     fileOverwrite = false;
 89 }                                              <<  87   else
 90                                                <<  88     fileOverwrite = strcmp(getenv("G4HEPREPFILE_OVERWRITE"),"0");
 91 G4HepRepFileSceneHandler::~G4HepRepFileSceneHa <<  89   
 92                                                <<  90   if (getenv("G4HEPREPFILE_CULL") == NULL)
 93 void G4HepRepFileSceneHandler::BeginModeling() <<  91     cullInvisibleObjects = false;
 94 {                                              <<  92   else
 95   G4VisManager* visManager        = G4VisManag <<  93     cullInvisibleObjects = strcmp(getenv("G4HEPREPFILE_CULL"),"0");
 96   const G4VTrajectoryModel* model = visManager <<  94   
 97   trajContext                     = &model->Ge <<  95   inPrimitives2D = false;
 98                                                <<  96   warnedAbout3DText = false;
 99   G4VSceneHandler::BeginModeling();  // Requir <<  97   warnedAbout2DMarkers = false;
100 }                                              <<  98   haveVisible = false;
101                                                <<  99   drawingTraj = false;
102 void G4HepRepFileSceneHandler::EndModeling()   << 100   doneInitTraj = false;
103 {                                              << 101   drawingHit = false;
104   G4VSceneHandler::EndModeling();  // Required << 102   doneInitHit = false;
105 }                                              << 
106                                                << 
107 void G4HepRepFileSceneHandler::BeginPrimitives << 
108   const G4Transform3D& objectTransformation)   << 
109 {                                              << 
110 #ifdef G4HEPREPFILEDEBUG                       << 
111   G4cout << "G4HepRepFileSceneHandler::BeginPr << 
112 #endif                                         << 
113   inPrimitives2D = true;                       << 
114   G4VSceneHandler::BeginPrimitives2D(objectTra << 
115 }                                              << 
116                                                << 
117 void G4HepRepFileSceneHandler::EndPrimitives2D << 
118 {                                              << 
119 #ifdef G4HEPREPFILEDEBUG                       << 
120   G4cout << "G4HepRepFileSceneHandler::EndPrim << 
121 #endif                                         << 
122   G4VSceneHandler::EndPrimitives2D();          << 
123   inPrimitives2D = false;                      << 
124 }                                              << 
125                                                << 
126 #ifdef G4HEPREPFILEDEBUG                       << 
127 void G4HepRepFileSceneHandler::PrintThings()   << 
128 {                                              << 
129   G4cout << "  with transformation " << fObjec << 
130   G4PhysicalVolumeModel* pPVModel =            << 
131     dynamic_cast<G4PhysicalVolumeModel*>(fpMod << 
132   if(pPVModel)                                 << 
133   {                                            << 
134     G4VPhysicalVolume* pCurrentPV = pPVModel-> << 
135     G4LogicalVolume* pCurrentLV   = pPVModel-> << 
136     G4int currentDepth            = pPVModel-> << 
137     G4cout << "\n  current physical volume: "  << 
138            << "\n  current logical volume: " < << 
139            << "\n  current depth of geometry t << 
140   }                                            << 
141   G4cout << G4endl;                            << 
142 }                                              << 
143 #endif                                         << 
144                                                << 
145 void G4HepRepFileSceneHandler::AddSolid(const  << 
146 {                                              << 
147 #ifdef G4HEPREPFILEDEBUG                       << 
148   G4cout << "G4HepRepFileSceneHandler::AddSoli << 
149          << box.GetName() << G4endl;           << 
150   PrintThings();                               << 
151 #endif                                         << 
152                                                << 
153   if(drawingTraj)                              << 
154     return;                                    << 
155                                                << 
156   if(drawingHit)                               << 
157     InitHit();                                 << 
158                                                << 
159   haveVisible = false;                         << 
160   AddHepRepInstance("Prism", NULL);            << 
161                                                << 
162   G4HepRepMessenger* messenger = G4HepRepMesse << 
163                                                << 
164   // Get and check applicable vis attributes.  << 
165   fpVisAttribs = fpViewer->GetApplicableVisAtt << 
166   if(fpVisAttribs && (fpVisAttribs->IsVisible( << 
167      messenger->getCullInvisibles())           << 
168     return;                                    << 
169                                                << 
170   hepRepXMLWriter->addPrimitive();             << 
171                                                << 
172   G4double dx = box.GetXHalfLength();          << 
173   G4double dy = box.GetYHalfLength();          << 
174   G4double dz = box.GetZHalfLength();          << 
175                                                << 
176   G4Point3D vertex1(G4Point3D(dx, dy, -dz));   << 
177   G4Point3D vertex2(G4Point3D(dx, -dy, -dz));  << 
178   G4Point3D vertex3(G4Point3D(-dx, -dy, -dz)); << 
179   G4Point3D vertex4(G4Point3D(-dx, dy, -dz));  << 
180   G4Point3D vertex5(G4Point3D(dx, dy, dz));    << 
181   G4Point3D vertex6(G4Point3D(dx, -dy, dz));   << 
182   G4Point3D vertex7(G4Point3D(-dx, -dy, dz));  << 
183   G4Point3D vertex8(G4Point3D(-dx, dy, dz));   << 
184                                                << 
185   vertex1 = (fObjectTransformation) *vertex1;  << 
186   vertex2 = (fObjectTransformation) *vertex2;  << 
187   vertex3 = (fObjectTransformation) *vertex3;  << 
188   vertex4 = (fObjectTransformation) *vertex4;  << 
189   vertex5 = (fObjectTransformation) *vertex5;  << 
190   vertex6 = (fObjectTransformation) *vertex6;  << 
191   vertex7 = (fObjectTransformation) *vertex7;  << 
192   vertex8 = (fObjectTransformation) *vertex8;  << 
193                                                << 
194   hepRepXMLWriter->addPoint(vertex1.x(), verte << 
195   hepRepXMLWriter->addPoint(vertex2.x(), verte << 
196   hepRepXMLWriter->addPoint(vertex3.x(), verte << 
197   hepRepXMLWriter->addPoint(vertex4.x(), verte << 
198   hepRepXMLWriter->addPoint(vertex5.x(), verte << 
199   hepRepXMLWriter->addPoint(vertex6.x(), verte << 
200   hepRepXMLWriter->addPoint(vertex7.x(), verte << 
201   hepRepXMLWriter->addPoint(vertex8.x(), verte << 
202 }                                              << 
203                                                << 
204 void G4HepRepFileSceneHandler::AddSolid(const  << 
205 {                                              << 
206 #ifdef G4HEPREPFILEDEBUG                       << 
207   G4cout << "G4HepRepFileSceneHandler::AddSoli << 
208          << cons.GetName() << G4endl;          << 
209   PrintThings();                               << 
210 #endif                                         << 
211                                                << 
212   // HepRApp does not correctly represent the  << 
213   // non-standard angles, let the base class c << 
214   G4RotationMatrix r = fObjectTransformation.g << 
215   G4bool linedUpWithAnAxis =                   << 
216     (std::fabs(r.phiX()) <= .001 || std::fabs( << 
217      std::fabs(r.phiZ()) <= .001 || std::fabs( << 
218      std::fabs(r.phiY() - pi) <= .001 || std:: << 
219   // G4cout << "Angle X:" << r.phiX() << ", An << 
220   // Z:" << r.phiZ() << G4endl; G4cout << "lin << 
221   // linedUpWithAnAxis << G4endl;              << 
222                                                << 
223   // HepRep does not have a primitive for a cu << 
224   // so if this cone is cut, let the base clas << 
225   // solid to polygons.                        << 
226   G4HepRepMessenger* messenger = G4HepRepMesse << 
227   if(cons.GetDeltaPhiAngle() < twopi || !lined << 
228      messenger->renderCylAsPolygons())         << 
229   {                                            << 
230     G4VSceneHandler::AddSolid(cons);  // Invok << 
231   }                                            << 
232   else                                         << 
233   {                                            << 
234     if(drawingTraj)                            << 
235       return;                                  << 
236                                                << 
237     if(drawingHit)                             << 
238       InitHit();                               << 
239                                                << 
240     haveVisible = false;                       << 
241     AddHepRepInstance("Cylinder", NULL);       << 
242                                                << 
243     // Get and check applicable vis attributes << 
244     fpVisAttribs = fpViewer->GetApplicableVisA << 
245     if(fpVisAttribs && (fpVisAttribs->IsVisibl << 
246        messenger->getCullInvisibles())         << 
247       return;                                  << 
248                                                << 
249     G4Point3D vertex1(G4Point3D(0., 0., -cons. << 
250     G4Point3D vertex2(G4Point3D(0., 0., cons.G << 
251                                                << 
252     vertex1 = (fObjectTransformation) *vertex1 << 
253     vertex2 = (fObjectTransformation) *vertex2 << 
254                                                << 
255     // Outer cylinder.                         << 
256     hepRepXMLWriter->addPrimitive();           << 
257     hepRepXMLWriter->addAttValue("Radius1", me << 
258                                                << 
259     hepRepXMLWriter->addAttValue("Radius2", me << 
260                                                << 
261     hepRepXMLWriter->addPoint(vertex1.x(), ver << 
262     hepRepXMLWriter->addPoint(vertex2.x(), ver << 
263                                                << 
264     // Inner cylinder.                         << 
265     hepRepXMLWriter->addPrimitive();           << 
266     hepRepXMLWriter->addAttValue("Radius1", me << 
267                                                << 
268     hepRepXMLWriter->addAttValue("Radius2", me << 
269                                                << 
270     hepRepXMLWriter->addPoint(vertex1.x(), ver << 
271     hepRepXMLWriter->addPoint(vertex2.x(), ver << 
272   }                                            << 
273 }                                              << 
274                                                << 
275 void G4HepRepFileSceneHandler::AddSolid(const  << 
276 {                                              << 
277 #ifdef G4HEPREPFILEDEBUG                       << 
278   G4cout << "G4HepRepFileSceneHandler::AddSoli << 
279          << tubs.GetName() << G4endl;          << 
280   PrintThings();                               << 
281 #endif                                         << 
282                                                << 
283   // HepRApp does not correctly represent the  << 
284   // non-standard angles, let the base class c << 
285   G4RotationMatrix r = fObjectTransformation.g << 
286   G4bool linedUpWithAnAxis =                   << 
287     (std::fabs(r.phiX()) <= .001 || std::fabs( << 
288      std::fabs(r.phiZ()) <= .001 || std::fabs( << 
289      std::fabs(r.phiY() - pi) <= .001 || std:: << 
290   // G4cout << "Angle X:" << r.phiX() << ", An << 
291   // Z:" << r.phiZ() << G4endl; G4cout << "lin << 
292   // linedUpWithAnAxis << G4endl;              << 
293                                                << 
294   // HepRep does not have a primitive for a cu << 
295   // so if this cylinder is cut, let the base  << 
296   // solid to polygons.                        << 
297   G4HepRepMessenger* messenger = G4HepRepMesse << 
298   if(tubs.GetDeltaPhiAngle() < twopi || !lined << 
299      messenger->renderCylAsPolygons())         << 
300   {                                            << 
301     G4VSceneHandler::AddSolid(tubs);  // Invok << 
302   }                                            << 
303   else                                         << 
304   {                                            << 
305     if(drawingTraj)                            << 
306       return;                                  << 
307                                                << 
308     if(drawingHit)                             << 
309       InitHit();                               << 
310                                                << 
311     haveVisible = false;                       << 
312     AddHepRepInstance("Cylinder", NULL);       << 
313                                                << 
314     // Get and check applicable vis attributes << 
315     fpVisAttribs = fpViewer->GetApplicableVisA << 
316     if(fpVisAttribs && (fpVisAttribs->IsVisibl << 
317        messenger->getCullInvisibles())         << 
318       return;                                  << 
319                                                << 
320     G4Point3D vertex1(G4Point3D(0., 0., -tubs. << 
321     G4Point3D vertex2(G4Point3D(0., 0., tubs.G << 
322                                                << 
323     vertex1 = (fObjectTransformation) *vertex1 << 
324     vertex2 = (fObjectTransformation) *vertex2 << 
325                                                << 
326     // Outer cylinder.                         << 
327     hepRepXMLWriter->addPrimitive();           << 
328     hepRepXMLWriter->addAttValue("Radius1",    << 
329                                  messenger->ge << 
330     hepRepXMLWriter->addAttValue("Radius2",    << 
331                                  messenger->ge << 
332     hepRepXMLWriter->addPoint(vertex1.x(), ver << 
333     hepRepXMLWriter->addPoint(vertex2.x(), ver << 
334                                                << 
335     // Inner cylinder.                         << 
336     if(tubs.GetInnerRadius() != 0.)            << 
337     {                                          << 
338       hepRepXMLWriter->addPrimitive();         << 
339       hepRepXMLWriter->addAttValue("Radius1",  << 
340                                                << 
341       hepRepXMLWriter->addAttValue("Radius2",  << 
342                                                << 
343       hepRepXMLWriter->addPoint(vertex1.x(), v << 
344       hepRepXMLWriter->addPoint(vertex2.x(), v << 
345     }                                          << 
346   }                                            << 
347 }                                              << 
348                                                << 
349 void G4HepRepFileSceneHandler::AddSolid(const  << 
350 {                                              << 
351 #ifdef G4HEPREPFILEDEBUG                       << 
352   G4cout << "G4HepRepFileSceneHandler::AddSoli << 
353          << trd.GetName() << G4endl;           << 
354   PrintThings();                               << 
355 #endif                                         << 
356                                                << 
357   if(drawingTraj)                              << 
358     return;                                    << 
359                                                << 
360   if(drawingHit)                               << 
361     InitHit();                                 << 
362                                                << 
363   haveVisible = false;                         << 
364   AddHepRepInstance("Prism", NULL);            << 
365                                                << 
366   G4HepRepMessenger* messenger = G4HepRepMesse << 
367                                                << 
368   // Get and check applicable vis attributes.  << 
369   fpVisAttribs = fpViewer->GetApplicableVisAtt << 
370   if(fpVisAttribs && (fpVisAttribs->IsVisible( << 
371      messenger->getCullInvisibles())           << 
372     return;                                    << 
373                                                << 
374   hepRepXMLWriter->addPrimitive();             << 
375                                                << 
376   G4double dx1 = trd.GetXHalfLength1();        << 
377   G4double dy1 = trd.GetYHalfLength1();        << 
378   G4double dx2 = trd.GetXHalfLength2();        << 
379   G4double dy2 = trd.GetYHalfLength2();        << 
380   G4double dz  = trd.GetZHalfLength();         << 
381                                                << 
382   G4Point3D vertex1(G4Point3D(dx1, dy1, -dz)); << 
383   G4Point3D vertex2(G4Point3D(dx1, -dy1, -dz)) << 
384   G4Point3D vertex3(G4Point3D(-dx1, -dy1, -dz) << 
385   G4Point3D vertex4(G4Point3D(-dx1, dy1, -dz)) << 
386   G4Point3D vertex5(G4Point3D(dx2, dy2, dz));  << 
387   G4Point3D vertex6(G4Point3D(dx2, -dy2, dz)); << 
388   G4Point3D vertex7(G4Point3D(-dx2, -dy2, dz)) << 
389   G4Point3D vertex8(G4Point3D(-dx2, dy2, dz)); << 
390                                                << 
391   vertex1 = (fObjectTransformation) *vertex1;  << 
392   vertex2 = (fObjectTransformation) *vertex2;  << 
393   vertex3 = (fObjectTransformation) *vertex3;  << 
394   vertex4 = (fObjectTransformation) *vertex4;  << 
395   vertex5 = (fObjectTransformation) *vertex5;  << 
396   vertex6 = (fObjectTransformation) *vertex6;  << 
397   vertex7 = (fObjectTransformation) *vertex7;  << 
398   vertex8 = (fObjectTransformation) *vertex8;  << 
399                                                << 
400   hepRepXMLWriter->addPoint(vertex1.x(), verte << 
401   hepRepXMLWriter->addPoint(vertex2.x(), verte << 
402   hepRepXMLWriter->addPoint(vertex3.x(), verte << 
403   hepRepXMLWriter->addPoint(vertex4.x(), verte << 
404   hepRepXMLWriter->addPoint(vertex5.x(), verte << 
405   hepRepXMLWriter->addPoint(vertex6.x(), verte << 
406   hepRepXMLWriter->addPoint(vertex7.x(), verte << 
407   hepRepXMLWriter->addPoint(vertex8.x(), verte << 
408 }                                                 103 }
409                                                   104 
410 void G4HepRepFileSceneHandler::AddSolid(const  << 
411 {                                              << 
412 #ifdef G4HEPREPFILEDEBUG                       << 
413   G4cout << "G4HepRepFileSceneHandler::AddSoli << 
414          << trap.GetName() << G4endl;          << 
415   PrintThings();                               << 
416 #endif                                         << 
417   G4VSceneHandler::AddSolid(trap);  // Invoke  << 
418 }                                              << 
419                                                   105 
420 void G4HepRepFileSceneHandler::AddSolid(const  << 106 G4HepRepFileSceneHandler::~G4HepRepFileSceneHandler() {}
421 {                                              << 
422 #ifdef G4HEPREPFILEDEBUG                       << 
423   G4cout                                       << 
424     << "G4HepRepFileSceneHandler::AddSolid(con << 
425     << sphere.GetName() << G4endl;             << 
426   PrintThings();                               << 
427 #endif                                         << 
428   G4VSceneHandler::AddSolid(sphere);  // Invok << 
429 }                                              << 
430                                                << 
431 void G4HepRepFileSceneHandler::AddSolid(const  << 
432 {                                              << 
433 #ifdef G4HEPREPFILEDEBUG                       << 
434   G4cout << "G4HepRepFileSceneHandler::AddSoli << 
435          << para.GetName() << G4endl;          << 
436   PrintThings();                               << 
437 #endif                                         << 
438   G4VSceneHandler::AddSolid(para);  // Invoke  << 
439 }                                              << 
440                                                << 
441 void G4HepRepFileSceneHandler::AddSolid(const  << 
442 {                                              << 
443 #ifdef G4HEPREPFILEDEBUG                       << 
444   G4cout                                       << 
445     << "G4HepRepFileSceneHandler::AddSolid(con << 
446     << torus.GetName() << G4endl;              << 
447   PrintThings();                               << 
448 #endif                                         << 
449   G4VSceneHandler::AddSolid(torus);  // Invoke << 
450 }                                              << 
451                                                << 
452 void G4HepRepFileSceneHandler::AddSolid(const  << 
453 {                                              << 
454 #ifdef G4HEPREPFILEDEBUG                       << 
455   G4cout << "G4HepRepFileSceneHandler::AddSoli << 
456             "called for "                      << 
457          << polycone.GetName() << G4endl;      << 
458   PrintThings();                               << 
459 #endif                                         << 
460   G4VSceneHandler::AddSolid(polycone);  // Inv << 
461 }                                              << 
462                                                   107 
463 void G4HepRepFileSceneHandler::AddSolid(const  << 
464 {                                              << 
465 #ifdef G4HEPREPFILEDEBUG                       << 
466   G4cout << "G4HepRepFileSceneHandler::AddSoli << 
467             "called for "                      << 
468          << polyhedra.GetName() << G4endl;     << 
469   PrintThings();                               << 
470 #endif                                         << 
471   G4VSceneHandler::AddSolid(polyhedra);  // In << 
472 }                                              << 
473                                                   108 
474 void G4HepRepFileSceneHandler::AddSolid(const  << 109 void G4HepRepFileSceneHandler::BeginModeling() {
475 {                                              << 110     G4VisManager* visManager = G4VisManager::GetInstance();
476 #ifdef G4HEPREPFILEDEBUG                       << 111     const G4VTrajectoryModel* model = visManager->CurrentTrajDrawModel();
477   G4cout << "G4HepRepFileSceneHandler::AddSoli << 112     trajContext = & model->GetContext();
478          << orb.GetName() << G4endl;           << 113   
479   PrintThings();                               << 114   G4VSceneHandler::BeginModeling();  // Required: see G4VSceneHandler.hh.
                                                   >> 115 }
                                                   >> 116 
                                                   >> 117 
                                                   >> 118 void G4HepRepFileSceneHandler::EndModeling() {
                                                   >> 119   G4VSceneHandler::EndModeling();  // Required: see G4VSceneHandler.hh.
                                                   >> 120 }
                                                   >> 121 
                                                   >> 122 void G4HepRepFileSceneHandler::BeginPrimitives2D () {
                                                   >> 123 #ifdef G4HEPREPFILEDEBUG
                                                   >> 124   G4cout << "G4HepRepFileSceneHandler::BeginPrimitives2D() " << G4endl;
                                                   >> 125 #endif
                                                   >> 126   inPrimitives2D = true;
                                                   >> 127   G4VSceneHandler::BeginPrimitives2D();
                                                   >> 128 }
                                                   >> 129 
                                                   >> 130 void G4HepRepFileSceneHandler::EndPrimitives2D () {
                                                   >> 131 #ifdef G4HEPREPFILEDEBUG
                                                   >> 132   G4cout << "G4HepRepFileSceneHandler::EndPrimitives2D() " << G4endl;
                                                   >> 133 #endif
                                                   >> 134   G4VSceneHandler::EndPrimitives2D();
                                                   >> 135   inPrimitives2D = false;
                                                   >> 136 }
                                                   >> 137 
                                                   >> 138 
                                                   >> 139 #ifdef G4HEPREPFILEDEBUG
                                                   >> 140 void G4HepRepFileSceneHandler::PrintThings() {
                                                   >> 141   G4cout <<
                                                   >> 142     "  with transformation "
                                                   >> 143   << (void*)fpObjectTransformation;
                                                   >> 144   G4PhysicalVolumeModel* pPVModel =
                                                   >> 145     dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
                                                   >> 146   if (pPVModel) {
                                                   >> 147     G4VPhysicalVolume* pCurrentPV = pPVModel->GetCurrentPV();
                                                   >> 148     G4LogicalVolume* pCurrentLV = pPVModel->GetCurrentLV();
                                                   >> 149     G4int currentDepth = pPVModel->GetCurrentDepth();
                                                   >> 150     G4cout <<
                                                   >> 151       "\n  current physical volume: "
                                                   >> 152       << pCurrentPV->GetName() <<
                                                   >> 153       "\n  current logical volume: "
                                                   >> 154       << pCurrentLV->GetName() <<
                                                   >> 155       "\n  current depth of geometry tree: "
                                                   >> 156       << currentDepth;
                                                   >> 157   }
                                                   >> 158   G4cout << G4endl;
                                                   >> 159 }
                                                   >> 160 #endif
                                                   >> 161 
                                                   >> 162 
                                                   >> 163 void G4HepRepFileSceneHandler::AddSolid(const G4Box& box) {
                                                   >> 164 #ifdef G4HEPREPFILEDEBUG
                                                   >> 165   G4cout <<
                                                   >> 166     "G4HepRepFileSceneHandler::AddSolid(const G4Box& box) called for "
                                                   >> 167   << box.GetName()
                                                   >> 168   << G4endl;
                                                   >> 169   PrintThings();
                                                   >> 170 #endif
                                                   >> 171   
                                                   >> 172   if (drawingTraj)
                                                   >> 173     return;
                                                   >> 174   
                                                   >> 175   if (drawingHit)
                                                   >> 176     InitHit();
                                                   >> 177   
                                                   >> 178   haveVisible = false;
                                                   >> 179   AddHepRepInstance("Prism", NULL);
                                                   >> 180   
                                                   >> 181   if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && cullInvisibleObjects)
                                                   >> 182     return;
                                                   >> 183   
                                                   >> 184   hepRepXMLWriter->addPrimitive();
                                                   >> 185   
                                                   >> 186   G4double dx = box.GetXHalfLength();
                                                   >> 187   G4double dy = box.GetYHalfLength();
                                                   >> 188   G4double dz = box.GetZHalfLength();
                                                   >> 189   
                                                   >> 190   G4Point3D vertex1(G4Point3D( dx, dy,-dz));
                                                   >> 191   G4Point3D vertex2(G4Point3D( dx,-dy,-dz));
                                                   >> 192   G4Point3D vertex3(G4Point3D(-dx,-dy,-dz));
                                                   >> 193   G4Point3D vertex4(G4Point3D(-dx, dy,-dz));
                                                   >> 194   G4Point3D vertex5(G4Point3D( dx, dy, dz));
                                                   >> 195   G4Point3D vertex6(G4Point3D( dx,-dy, dz));
                                                   >> 196   G4Point3D vertex7(G4Point3D(-dx,-dy, dz));
                                                   >> 197   G4Point3D vertex8(G4Point3D(-dx, dy, dz));
                                                   >> 198   
                                                   >> 199   vertex1 = (*fpObjectTransformation) * vertex1;
                                                   >> 200   vertex2 = (*fpObjectTransformation) * vertex2;
                                                   >> 201   vertex3 = (*fpObjectTransformation) * vertex3;
                                                   >> 202   vertex4 = (*fpObjectTransformation) * vertex4;
                                                   >> 203   vertex5 = (*fpObjectTransformation) * vertex5;
                                                   >> 204   vertex6 = (*fpObjectTransformation) * vertex6;
                                                   >> 205   vertex7 = (*fpObjectTransformation) * vertex7;
                                                   >> 206   vertex8 = (*fpObjectTransformation) * vertex8;
                                                   >> 207   
                                                   >> 208   hepRepXMLWriter->addPoint(vertex1.x(), vertex1.y(), vertex1.z());
                                                   >> 209   hepRepXMLWriter->addPoint(vertex2.x(), vertex2.y(), vertex2.z());
                                                   >> 210   hepRepXMLWriter->addPoint(vertex3.x(), vertex3.y(), vertex3.z());
                                                   >> 211   hepRepXMLWriter->addPoint(vertex4.x(), vertex4.y(), vertex4.z());
                                                   >> 212   hepRepXMLWriter->addPoint(vertex5.x(), vertex5.y(), vertex5.z());
                                                   >> 213   hepRepXMLWriter->addPoint(vertex6.x(), vertex6.y(), vertex6.z());
                                                   >> 214   hepRepXMLWriter->addPoint(vertex7.x(), vertex7.y(), vertex7.z());
                                                   >> 215   hepRepXMLWriter->addPoint(vertex8.x(), vertex8.y(), vertex8.z());
                                                   >> 216 }
                                                   >> 217 
                                                   >> 218 
                                                   >> 219 void G4HepRepFileSceneHandler::AddSolid(const G4Cons& cons) {
                                                   >> 220 #ifdef G4HEPREPFILEDEBUG
                                                   >> 221   G4cout <<
                                                   >> 222     "G4HepRepFileSceneHandler::AddSolid(const G4Cons& cons) called for "
                                                   >> 223   << cons.GetName()
                                                   >> 224   << G4endl;
                                                   >> 225   PrintThings();
                                                   >> 226 #endif
                                                   >> 227   
                                                   >> 228   // HepRep does not have a primitive for a cut cone,
                                                   >> 229   // so if this cone is cut, let the base class convert this
                                                   >> 230   // solid to polygons.
                                                   >> 231   if (cons.GetDeltaPhiAngle() < twopi) {
                                                   >> 232     G4VSceneHandler::AddSolid(cons);  // Invoke default action.
                                                   >> 233   } else {
                                                   >> 234   
                                                   >> 235     if (drawingTraj)
                                                   >> 236       return;
                                                   >> 237     
                                                   >> 238     if (drawingHit)
                                                   >> 239       InitHit();
                                                   >> 240 
                                                   >> 241     haveVisible = false;
                                                   >> 242     AddHepRepInstance("Cylinder", NULL);
                                                   >> 243     
                                                   >> 244     if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && cullInvisibleObjects)
                                                   >> 245       return;
                                                   >> 246     
                                                   >> 247     G4Point3D vertex1(G4Point3D( 0., 0., -cons.GetZHalfLength()));
                                                   >> 248     G4Point3D vertex2(G4Point3D( 0., 0.,  cons.GetZHalfLength()));
                                                   >> 249     
                                                   >> 250     vertex1 = (*fpObjectTransformation) * vertex1;
                                                   >> 251     vertex2 = (*fpObjectTransformation) * vertex2;
                                                   >> 252     
                                                   >> 253     // Outer cylinder.
                                                   >> 254     hepRepXMLWriter->addPrimitive();
                                                   >> 255     hepRepXMLWriter->addAttValue("Radius1",cons.GetOuterRadiusMinusZ());
                                                   >> 256     hepRepXMLWriter->addAttValue("Radius2",cons.GetOuterRadiusPlusZ());
                                                   >> 257     hepRepXMLWriter->addPoint(vertex1.x(), vertex1.y(), vertex1.z());
                                                   >> 258     hepRepXMLWriter->addPoint(vertex2.x(), vertex2.y(), vertex2.z());
                                                   >> 259     
                                                   >> 260     // Inner cylinder.
                                                   >> 261     hepRepXMLWriter->addPrimitive();
                                                   >> 262     hepRepXMLWriter->addAttValue("Radius1",cons.GetInnerRadiusMinusZ());
                                                   >> 263     hepRepXMLWriter->addAttValue("Radius2",cons.GetInnerRadiusPlusZ());
                                                   >> 264     hepRepXMLWriter->addPoint(vertex1.x(), vertex1.y(), vertex1.z());
                                                   >> 265     hepRepXMLWriter->addPoint(vertex2.x(), vertex2.y(), vertex2.z());
                                                   >> 266   }
                                                   >> 267 }
                                                   >> 268 
                                                   >> 269 
                                                   >> 270 void G4HepRepFileSceneHandler::AddSolid(const G4Tubs& tubs) {
                                                   >> 271 #ifdef G4HEPREPFILEDEBUG
                                                   >> 272   G4cout <<
                                                   >> 273     "G4HepRepFileSceneHandler::AddSolid(const G4Tubs& tubs) called for "
                                                   >> 274   << tubs.GetName()
                                                   >> 275   << G4endl;
                                                   >> 276   PrintThings();
                                                   >> 277 #endif
                                                   >> 278   
                                                   >> 279   // HepRep does not have a primitive for a cut cylinder,
                                                   >> 280   // so if this cylinder is cut, let the base class convert this
                                                   >> 281   // solid to polygons.
                                                   >> 282   if (tubs.GetDeltaPhiAngle() < twopi) {
                                                   >> 283     G4VSceneHandler::AddSolid(tubs);  // Invoke default action.
                                                   >> 284   } else {
                                                   >> 285   
                                                   >> 286     if (drawingTraj)
                                                   >> 287       return;
                                                   >> 288     
                                                   >> 289     if (drawingHit)
                                                   >> 290       InitHit();
                                                   >> 291 
                                                   >> 292     haveVisible = false;
                                                   >> 293     AddHepRepInstance("Cylinder", NULL);
                                                   >> 294     
                                                   >> 295     if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && cullInvisibleObjects)
                                                   >> 296       return;
                                                   >> 297     
                                                   >> 298     G4Point3D vertex1(G4Point3D( 0., 0., -tubs.GetZHalfLength()));
                                                   >> 299     G4Point3D vertex2(G4Point3D( 0., 0.,  tubs.GetZHalfLength()));
                                                   >> 300     
                                                   >> 301     vertex1 = (*fpObjectTransformation) * vertex1;
                                                   >> 302     vertex2 = (*fpObjectTransformation) * vertex2;
                                                   >> 303     
                                                   >> 304     // Outer cylinder.
                                                   >> 305     hepRepXMLWriter->addPrimitive();
                                                   >> 306     hepRepXMLWriter->addAttValue("Radius1", tubs.GetOuterRadius());
                                                   >> 307     hepRepXMLWriter->addAttValue("Radius2", tubs.GetOuterRadius());
                                                   >> 308     hepRepXMLWriter->addPoint(vertex1.x(), vertex1.y(), vertex1.z());
                                                   >> 309     hepRepXMLWriter->addPoint(vertex2.x(), vertex2.y(), vertex2.z());
                                                   >> 310     
                                                   >> 311     // Inner cylinder.
                                                   >> 312     if (tubs.GetInnerRadius() != 0.) {
                                                   >> 313       hepRepXMLWriter->addPrimitive();
                                                   >> 314       hepRepXMLWriter->addAttValue("Radius1", tubs.GetInnerRadius());
                                                   >> 315       hepRepXMLWriter->addAttValue("Radius2", tubs.GetInnerRadius());
                                                   >> 316       hepRepXMLWriter->addPoint(vertex1.x(), vertex1.y(), vertex1.z());
                                                   >> 317       hepRepXMLWriter->addPoint(vertex2.x(), vertex2.y(), vertex2.z());
                                                   >> 318     }
                                                   >> 319   }
                                                   >> 320 }
                                                   >> 321 
                                                   >> 322 
                                                   >> 323 void G4HepRepFileSceneHandler::AddSolid(const G4Trd& trd) {
                                                   >> 324 #ifdef G4HEPREPFILEDEBUG
                                                   >> 325   G4cout <<
                                                   >> 326     "G4HepRepFileSceneHandler::AddSolid(const G4Trd& trd) called for "
                                                   >> 327   << trd.GetName()
                                                   >> 328   << G4endl;
                                                   >> 329   PrintThings();
                                                   >> 330 #endif
                                                   >> 331   
                                                   >> 332   if (drawingTraj)
                                                   >> 333     return;
                                                   >> 334   
                                                   >> 335   if (drawingHit)
                                                   >> 336     InitHit();
                                                   >> 337   
                                                   >> 338   haveVisible = false;
                                                   >> 339   AddHepRepInstance("Prism", NULL);
                                                   >> 340   
                                                   >> 341   if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && cullInvisibleObjects)
                                                   >> 342     return;
                                                   >> 343   
                                                   >> 344   hepRepXMLWriter->addPrimitive();
                                                   >> 345   
                                                   >> 346   G4double dx1 = trd.GetXHalfLength1();
                                                   >> 347   G4double dy1 = trd.GetYHalfLength1();
                                                   >> 348   G4double dx2 = trd.GetXHalfLength2();
                                                   >> 349   G4double dy2 = trd.GetYHalfLength2();
                                                   >> 350   G4double dz = trd.GetZHalfLength();
                                                   >> 351   
                                                   >> 352   G4Point3D vertex1(G4Point3D( dx1, dy1,-dz));
                                                   >> 353   G4Point3D vertex2(G4Point3D( dx1,-dy1,-dz));
                                                   >> 354   G4Point3D vertex3(G4Point3D(-dx1,-dy1,-dz));
                                                   >> 355   G4Point3D vertex4(G4Point3D(-dx1, dy1,-dz));
                                                   >> 356   G4Point3D vertex5(G4Point3D( dx2, dy2, dz));
                                                   >> 357   G4Point3D vertex6(G4Point3D( dx2,-dy2, dz));
                                                   >> 358   G4Point3D vertex7(G4Point3D(-dx2,-dy2, dz));
                                                   >> 359   G4Point3D vertex8(G4Point3D(-dx2, dy2, dz));
                                                   >> 360   
                                                   >> 361   vertex1 = (*fpObjectTransformation) * vertex1;
                                                   >> 362   vertex2 = (*fpObjectTransformation) * vertex2;
                                                   >> 363   vertex3 = (*fpObjectTransformation) * vertex3;
                                                   >> 364   vertex4 = (*fpObjectTransformation) * vertex4;
                                                   >> 365   vertex5 = (*fpObjectTransformation) * vertex5;
                                                   >> 366   vertex6 = (*fpObjectTransformation) * vertex6;
                                                   >> 367   vertex7 = (*fpObjectTransformation) * vertex7;
                                                   >> 368   vertex8 = (*fpObjectTransformation) * vertex8;
                                                   >> 369   
                                                   >> 370   hepRepXMLWriter->addPoint(vertex1.x(), vertex1.y(), vertex1.z());
                                                   >> 371   hepRepXMLWriter->addPoint(vertex2.x(), vertex2.y(), vertex2.z());
                                                   >> 372   hepRepXMLWriter->addPoint(vertex3.x(), vertex3.y(), vertex3.z());
                                                   >> 373   hepRepXMLWriter->addPoint(vertex4.x(), vertex4.y(), vertex4.z());
                                                   >> 374   hepRepXMLWriter->addPoint(vertex5.x(), vertex5.y(), vertex5.z());
                                                   >> 375   hepRepXMLWriter->addPoint(vertex6.x(), vertex6.y(), vertex6.z());
                                                   >> 376   hepRepXMLWriter->addPoint(vertex7.x(), vertex7.y(), vertex7.z());
                                                   >> 377   hepRepXMLWriter->addPoint(vertex8.x(), vertex8.y(), vertex8.z());
                                                   >> 378 }
                                                   >> 379 
                                                   >> 380 
                                                   >> 381 void G4HepRepFileSceneHandler::AddSolid(const G4Trap& trap) {
                                                   >> 382 #ifdef G4HEPREPFILEDEBUG
                                                   >> 383   G4cout <<
                                                   >> 384     "G4HepRepFileSceneHandler::AddSolid(const G4Trap& trap) called for "
                                                   >> 385   << trap.GetName()
                                                   >> 386   << G4endl;
                                                   >> 387   PrintThings();
                                                   >> 388 #endif
                                                   >> 389   G4VSceneHandler::AddSolid(trap);  // Invoke default action.
                                                   >> 390 }
                                                   >> 391 
                                                   >> 392 
                                                   >> 393 void G4HepRepFileSceneHandler::AddSolid(const G4Sphere& sphere) {
                                                   >> 394 #ifdef G4HEPREPFILEDEBUG
                                                   >> 395   G4cout <<
                                                   >> 396     "G4HepRepFileSceneHandler::AddSolid(const G4Sphere& sphere) called for "
                                                   >> 397   << sphere.GetName()
                                                   >> 398   << G4endl;
                                                   >> 399   PrintThings();
                                                   >> 400 #endif
                                                   >> 401   G4VSceneHandler::AddSolid(sphere);  // Invoke default action.
                                                   >> 402 }
                                                   >> 403 
                                                   >> 404 
                                                   >> 405 void G4HepRepFileSceneHandler::AddSolid(const G4Para& para) {
                                                   >> 406 #ifdef G4HEPREPFILEDEBUG
                                                   >> 407   G4cout <<
                                                   >> 408     "G4HepRepFileSceneHandler::AddSolid(const G4Para& para) called for "
                                                   >> 409   << para.GetName()
                                                   >> 410   << G4endl;
                                                   >> 411   PrintThings();
                                                   >> 412 #endif
                                                   >> 413   G4VSceneHandler::AddSolid(para);  // Invoke default action.
                                                   >> 414 }
                                                   >> 415 
                                                   >> 416 
                                                   >> 417 void G4HepRepFileSceneHandler::AddSolid(const G4Torus& torus) {
                                                   >> 418 #ifdef G4HEPREPFILEDEBUG
                                                   >> 419   G4cout <<
                                                   >> 420     "G4HepRepFileSceneHandler::AddSolid(const G4Torus& torus) called for "
                                                   >> 421   << torus.GetName()
                                                   >> 422   << G4endl;
                                                   >> 423   PrintThings();
                                                   >> 424 #endif
                                                   >> 425   G4VSceneHandler::AddSolid(torus);  // Invoke default action.
                                                   >> 426 }
                                                   >> 427 
                                                   >> 428 
                                                   >> 429 void G4HepRepFileSceneHandler::AddSolid(const G4Polycone& polycone) {
                                                   >> 430 #ifdef G4HEPREPFILEDEBUG
                                                   >> 431   G4cout <<
                                                   >> 432     "G4HepRepFileSceneHandler::AddSolid(const G4Polycone& polycone) called for "
                                                   >> 433   << polycone.GetName()
                                                   >> 434   << G4endl;
                                                   >> 435   PrintThings();
                                                   >> 436 #endif
                                                   >> 437   G4VSceneHandler::AddSolid(polycone);  // Invoke default action.
                                                   >> 438 }
                                                   >> 439 
                                                   >> 440 
                                                   >> 441 void G4HepRepFileSceneHandler::AddSolid(const G4Polyhedra& polyhedra) {
                                                   >> 442 #ifdef G4HEPREPFILEDEBUG
                                                   >> 443   G4cout <<
                                                   >> 444     "G4HepRepFileSceneHandler::AddSolid(const G4Polyhedra& polyhedra) called for "
                                                   >> 445   << polyhedra.GetName()
                                                   >> 446   << G4endl;
                                                   >> 447   PrintThings();
                                                   >> 448 #endif
                                                   >> 449   G4VSceneHandler::AddSolid(polyhedra);  // Invoke default action.
                                                   >> 450 }
                                                   >> 451 
                                                   >> 452 
                                                   >> 453 void G4HepRepFileSceneHandler::AddSolid(const G4VSolid& solid) {
                                                   >> 454 #ifdef G4HEPREPFILEDEBUG
                                                   >> 455   G4cout <<
                                                   >> 456     "G4HepRepFileSceneHandler::AddSolid(const G4Solid& solid) called for "
                                                   >> 457   << solid.GetName()
                                                   >> 458   << G4endl;
                                                   >> 459   PrintThings();
                                                   >> 460 #endif
                                                   >> 461   G4VSceneHandler::AddSolid(solid);  // Invoke default action.
                                                   >> 462 }
                                                   >> 463 
                                                   >> 464 
                                                   >> 465 void G4HepRepFileSceneHandler::AddCompound (const G4VTrajectory& traj) {
                                                   >> 466 #ifdef G4HEPREPFILEDEBUG
                                                   >> 467   G4cout << "G4HepRepFileSceneHandler::AddCompound(const G4VTrajectory&) " << G4endl;
                                                   >> 468 #endif
                                                   >> 469   
                                                   >> 470   G4TrajectoriesModel* pTrModel =
                                                   >> 471     dynamic_cast<G4TrajectoriesModel*>(fpModel);
                                                   >> 472   if (!pTrModel) G4Exception
                                                   >> 473     ("G4HepRepFileSceneHandler::AddCompound(const G4VTrajectory&): Not a G4TrajectoriesModel.");
                                                   >> 474   G4int drawingMode = pTrModel->GetDrawingMode();
                                                   >> 475   
                                                   >> 476   // Pointers to hold trajectory attribute values and definitions.
                                                   >> 477   std::vector<G4AttValue>* rawTrajAttValues = traj.CreateAttValues();
                                                   >> 478   trajAttValues =
                                                   >> 479     new std::vector<G4AttValue>;
                                                   >> 480   trajAttDefs =
                                                   >> 481     new std::map<G4String,G4AttDef>;
                                                   >> 482   
                                                   >> 483   // Iterators to use with attribute values and definitions.
                                                   >> 484   std::vector<G4AttValue>::iterator iAttVal;
                                                   >> 485   std::map<G4String,G4AttDef>::const_iterator iAttDef;
                                                   >> 486   G4int i;
                                                   >> 487   
                                                   >> 488   // Get trajectory attributes and definitions in standard HepRep style
                                                   >> 489   // (uniform units, 3Vectors decomposed).
                                                   >> 490   if (rawTrajAttValues) {
                                                   >> 491     G4bool error = G4AttCheck(rawTrajAttValues,
                                                   >> 492                   traj.GetAttDefs()).Standard(trajAttValues,trajAttDefs);
                                                   >> 493     if (error) {
                                                   >> 494       G4cout << "G4HepRepFileSceneHandler::AddCompound(traj):"
                                                   >> 495       "\nERROR found during conversion to standard trajectory attributes."
                                                   >> 496       << G4endl;
                                                   >> 497     }
                                                   >> 498 #ifdef G4HEPREPFILEDEBUG 
                                                   >> 499     G4cout <<
                                                   >> 500       "G4HepRepFileSceneHandler::AddCompound(traj): standardised attributes:\n"
                                                   >> 501       << G4AttCheck(trajAttValues,trajAttDefs) << G4endl;
                                                   >> 502 #endif
                                                   >> 503     delete rawTrajAttValues;
                                                   >> 504   }
                                                   >> 505   
                                                   >> 506   // Open the HepRep output file if it is not already open.
                                                   >> 507   CheckFileOpen();
                                                   >> 508   
                                                   >> 509   // Add the Event Data Type if it hasn't already been added.
                                                   >> 510   if (strcmp("Event Data",hepRepXMLWriter->prevTypeName[0])!=0) {
                                                   >> 511     hepRepXMLWriter->addType("Event Data",0);
                                                   >> 512     hepRepXMLWriter->addInstance();
                                                   >> 513   }
                                                   >> 514   
                                                   >> 515   // Add the Trajectories Type.
                                                   >> 516   G4String previousName = hepRepXMLWriter->prevTypeName[1];
                                                   >> 517   hepRepXMLWriter->addType("Trajectories",1);
                                                   >> 518   
                                                   >> 519   // If this is the first trajectory of this event,
                                                   >> 520   // specify attribute values common to all trajectories.
                                                   >> 521   if (strcmp("Trajectories",previousName)!=0) {
                                                   >> 522     hepRepXMLWriter->addAttValue("Layer",100);
                                                   >> 523     
                                                   >> 524     // Take all Trajectory attDefs from first trajectory.
                                                   >> 525     // Would rather be able to get these attDefs without needing a reference from any
                                                   >> 526     // particular trajectory, but don't know how to do that.
                                                   >> 527     // Write out trajectory attribute definitions.
                                                   >> 528     if (trajAttValues && trajAttDefs) {
                                                   >> 529       for (iAttVal = trajAttValues->begin();
                                                   >> 530          iAttVal != trajAttValues->end(); ++iAttVal) {
                                                   >> 531         iAttDef = trajAttDefs->find(iAttVal->GetName());
                                                   >> 532         if (iAttDef != trajAttDefs->end()) {
                                                   >> 533           // Protect against incorrect use of Category.  Anything value other than the
                                                   >> 534           // standard ones will be considered to be in the physics category.
                                                   >> 535           G4String category = iAttDef->second.GetCategory();
                                                   >> 536           if (strcmp(category,"Draw")!=0 &&
                                                   >> 537             strcmp(category,"Physics")!=0 &&
                                                   >> 538             strcmp(category,"Association")!=0 &&
                                                   >> 539             strcmp(category,"PickAction")!=0)
                                                   >> 540             category = "Physics";
                                                   >> 541           hepRepXMLWriter->addAttDef(iAttVal->GetName(), iAttDef->second.GetDesc(),
                                                   >> 542                          category, iAttDef->second.GetExtra());
                                                   >> 543         }
                                                   >> 544       } 
                                                   >> 545     }
                                                   >> 546     
                                                   >> 547     // Take all TrajectoryPoint attDefs from first point of first trajectory.
                                                   >> 548     // Would rather be able to get these attDefs without needing a reference from any
                                                   >> 549     // particular point, but don't know how to do that.
                                                   >> 550     if ((drawingMode!=0 || trajContext->GetDrawStepPts() || trajContext->GetDrawAuxPts())
                                                   >> 551       && traj.GetPointEntries()>0) {
                                                   >> 552       G4VTrajectoryPoint* aTrajectoryPoint = traj.GetPoint(0);
                                                   >> 553       
                                                   >> 554       // Pointers to hold trajectory point attribute values and definitions.
                                                   >> 555       std::vector<G4AttValue>* rawPointAttValues = aTrajectoryPoint->CreateAttValues();
                                                   >> 556       std::vector<G4AttValue>* pointAttValues =
                                                   >> 557       new std::vector<G4AttValue>;
                                                   >> 558       std::map<G4String,G4AttDef>* pointAttDefs =
                                                   >> 559       new std::map<G4String,G4AttDef>;
                                                   >> 560       
                                                   >> 561       // Get first trajectory point's attributes and definitions in standard HepRep style
                                                   >> 562       // (uniform units, 3Vectors decomposed).
                                                   >> 563       if (rawPointAttValues) {
                                                   >> 564         G4bool error = G4AttCheck(rawPointAttValues,
                                                   >> 565                       aTrajectoryPoint->GetAttDefs()).Standard(pointAttValues,pointAttDefs);
                                                   >> 566         if (error) {
                                                   >> 567           G4cout << "G4HepRepFileSceneHandler::AddCompound(traj):"
                                                   >> 568           "\nERROR found during conversion to standard first point attributes." << G4endl;
                                                   >> 569         }
                                                   >> 570         
                                                   >> 571         // Write out point attribute definitions.
                                                   >> 572         if (pointAttValues && pointAttDefs) {
                                                   >> 573           for (iAttVal = pointAttValues->begin();
                                                   >> 574              iAttVal != pointAttValues->end(); ++iAttVal) {
                                                   >> 575             iAttDef =
                                                   >> 576             pointAttDefs->find(iAttVal->GetName());
                                                   >> 577             if (iAttDef != pointAttDefs->end()) {
                                                   >> 578               // Protect against incorrect use of Category.  Anything value other than the
                                                   >> 579               // standard ones will be considered to be in the physics category.
                                                   >> 580               G4String category = iAttDef->second.GetCategory();
                                                   >> 581               if (strcmp(category,"Draw")!=0 &&
                                                   >> 582                 strcmp(category,"Physics")!=0 &&
                                                   >> 583                 strcmp(category,"Association")!=0 &&
                                                   >> 584                 strcmp(category,"PickAction")!=0)
                                                   >> 585                 category = "Physics";
                                                   >> 586               // Do not write out the Aux or Pos attribute.  Aux does not conform to the HepRep rule
                                                   >> 587               // that each object can have only one instance of a given AttValue.
                                                   >> 588               // Both of these attributes are redundant to actual position information of the point.
                                                   >> 589               // New Wired can just tell the user the point position itself.
                                                   >> 590               if (strcmp(iAttVal->GetName(),"Aux-X")!=0 &&
                                                   >> 591                 strcmp(iAttVal->GetName(),"Aux-Y")!=0 &&
                                                   >> 592                 strcmp(iAttVal->GetName(),"Aux-Z")!=0 &&
                                                   >> 593                 strcmp(iAttVal->GetName(),"Pos-X")!=0 &&
                                                   >> 594                 strcmp(iAttVal->GetName(),"Pos-Y")!=0 &&
                                                   >> 595                 strcmp(iAttVal->GetName(),"Pos-Z")!=0)
                                                   >> 596                 hepRepXMLWriter->addAttDef(iAttVal->GetName(), iAttDef->second.GetDesc(),
                                                   >> 597                             category, iAttDef->second.GetExtra());
                                                   >> 598             }
                                                   >> 599           }
                                                   >> 600         }
                                                   >> 601         delete rawPointAttValues;
                                                   >> 602       }
                                                   >> 603       
                                                   >> 604       // Clean up point attributes.
                                                   >> 605       if (pointAttValues)
                                                   >> 606         delete pointAttValues;
                                                   >> 607       if (pointAttDefs)
                                                   >> 608         delete pointAttDefs;
                                                   >> 609     }
                                                   >> 610   } // end of special treatment for when this is the first trajectory.
                                                   >> 611   
                                                   >> 612   // Now that we have written out all of the attributes that are based on the
                                                   >> 613   // trajectory's particulars, call base class to deconstruct trajectory into polyline and/or points
                                                   >> 614   // (or nothing if trajectory is to be filtered out).
                                                   >> 615   // If base class calls for drawing points, no points will actually be drawn there since we
                                                   >> 616   // instead need to do point drawing from here (in order to obtain the points attributes,
                                                   >> 617   // not available from AddPrimitive(...point).  Instead, such a call will just serve to set the
                                                   >> 618   // flag that tells us that point drawing was requested for this trajectory (depends on several
                                                   >> 619   // factors including i_mode, trajContext and filtering).
                                                   >> 620   drawingTraj = true;
                                                   >> 621   doneInitTraj = false;
                                                   >> 622   G4VSceneHandler::AddCompound(traj);
                                                   >> 623   drawingTraj = false;
                                                   >> 624   
                                                   >> 625   // Draw step points.
                                                   >> 626   if (drawingMode!=0 || trajContext->GetDrawStepPts()) {
                                                   >> 627     if (!doneInitTraj)
                                                   >> 628       InitTrajectory();
                                                   >> 629     // Create Trajectory Points as a subType of Trajectories.
                                                   >> 630     // Note that we should create this heprep type even if there are no actual points.
                                                   >> 631     // This allows the user to tell that points don't exist (admittedly odd) rather
                                                   >> 632     // than that they were omitted by the drawing mode.
                                                   >> 633     previousName = hepRepXMLWriter->prevTypeName[2];
                                                   >> 634     hepRepXMLWriter->addType("Trajectory Step Points",2);
                                                   >> 635 
                                                   >> 636     float redness;
                                                   >> 637     float greenness;
                                                   >> 638     float blueness;     
                                                   >> 639     G4int markSize;
                                                   >> 640     G4bool visible;
                                                   >> 641     G4bool square;
                                                   >> 642     if (drawingMode==0) {
                                                   >> 643       G4Colour colour = trajContext->GetStepPtsColour();
                                                   >> 644       redness = colour.GetRed();
                                                   >> 645       greenness = colour.GetGreen();
                                                   >> 646       blueness = colour.GetBlue();
                                                   >> 647       markSize = (G4int) trajContext->GetStepPtsSize();
                                                   >> 648       visible = (G4int) trajContext->GetStepPtsVisible();
                                                   >> 649       square = (trajContext->GetStepPtsType()==G4Polymarker::squares);
                                                   >> 650     } else {
                                                   >> 651       redness = 1.;
                                                   >> 652       greenness = 1.;
                                                   >> 653       blueness = 1.;
                                                   >> 654       markSize = std::abs(drawingMode/1000);
                                                   >> 655       visible = true;
                                                   >> 656       square = false;
                                                   >> 657     }
                                                   >> 658 
                                                   >> 659     // Avoiding drawing anything black on black.  
                                                   >> 660     if (redness==0. && greenness==0. && blueness==0.) {
                                                   >> 661       redness = 1.;
                                                   >> 662       greenness = 1.;
                                                   >> 663       blueness = 1.;
                                                   >> 664     }
                                                   >> 665     
                                                   >> 666     // Specify attributes common to all trajectory points.
                                                   >> 667     if (strcmp("Trajectory Step Points",previousName)!=0) {
                                                   >> 668       hepRepXMLWriter->addAttValue("DrawAs","Point");
                                                   >> 669       hepRepXMLWriter->addAttValue("MarkColor", redness, greenness, blueness);
                                                   >> 670       hepRepXMLWriter->addAttValue("MarkSize",markSize);
                                                   >> 671       hepRepXMLWriter->addAttValue("Layer",110);
                                                   >> 672       hepRepXMLWriter->addAttValue("Visibility",visible);
                                                   >> 673       if (square)
                                                   >> 674         hepRepXMLWriter->addAttValue("MarkName","square");
                                                   >> 675       else
                                                   >> 676         hepRepXMLWriter->addAttValue("MarkName","dot");
                                                   >> 677     }
                                                   >> 678     
                                                   >> 679     // Loop over all points on this trajectory.
                                                   >> 680     for (i = 0; i < traj.GetPointEntries(); i++) {
                                                   >> 681       G4VTrajectoryPoint* aTrajectoryPoint = traj.GetPoint(i);
                                                   >> 682       
                                                   >> 683       // Each point is a separate instance of the type Trajectory Points.
                                                   >> 684       hepRepXMLWriter->addInstance();
                                                   >> 685       
                                                   >> 686       // Pointers to hold trajectory point attribute values and definitions.
                                                   >> 687       std::vector<G4AttValue>* rawPointAttValues = aTrajectoryPoint->CreateAttValues();
                                                   >> 688       std::vector<G4AttValue>* pointAttValues =
                                                   >> 689         new std::vector<G4AttValue>;
                                                   >> 690       std::map<G4String,G4AttDef>* pointAttDefs =
                                                   >> 691         new std::map<G4String,G4AttDef>;
                                                   >> 692       
                                                   >> 693       // Get trajectory point attributes and definitions in standard HepRep style
                                                   >> 694       // (uniform units, 3Vectors decomposed).
                                                   >> 695       if (rawPointAttValues) {
                                                   >> 696         G4bool error = G4AttCheck(rawPointAttValues,
                                                   >> 697                       aTrajectoryPoint->GetAttDefs()).Standard(pointAttValues,pointAttDefs);
                                                   >> 698         if (error) {
                                                   >> 699           G4cout << "G4HepRepFileSceneHandler::AddCompound(traj):"
                                                   >> 700           "\nERROR found during conversion to standard point attributes." << G4endl;
                                                   >> 701         }
                                                   >> 702         
                                                   >> 703         // Write out point attribute values.
                                                   >> 704         if (pointAttValues) {
                                                   >> 705           std::vector<G4AttValue>::iterator iAttVal;
                                                   >> 706           for (iAttVal = pointAttValues->begin();
                                                   >> 707              iAttVal != pointAttValues->end(); ++iAttVal)
                                                   >> 708             // Do not write out the Aux or Pos attribute.  Aux does not conform to the HepRep rule
                                                   >> 709             // that each object can have only one instance of a given AttValue.
                                                   >> 710             // Both of these attributes are redundant to actual position information of the point.
                                                   >> 711             // New Wired can just tell the user the point position itself.
                                                   >> 712             if (strcmp(iAttVal->GetName(),"Aux-X")!=0 &&
                                                   >> 713               strcmp(iAttVal->GetName(),"Aux-Y")!=0 &&
                                                   >> 714               strcmp(iAttVal->GetName(),"Aux-Z")!=0 &&
                                                   >> 715               strcmp(iAttVal->GetName(),"Pos-X")!=0 &&
                                                   >> 716               strcmp(iAttVal->GetName(),"Pos-Y")!=0 &&
                                                   >> 717               strcmp(iAttVal->GetName(),"Pos-Z")!=0)
                                                   >> 718               hepRepXMLWriter->addAttValue(iAttVal->GetName(), iAttVal->GetValue());
                                                   >> 719           delete pointAttValues;
                                                   >> 720         }
                                                   >> 721         delete rawPointAttValues;
                                                   >> 722       }
                                                   >> 723       
                                                   >> 724       // Clean up point attributes.
                                                   >> 725       if (pointAttDefs)
                                                   >> 726         delete pointAttDefs;
                                                   >> 727       
                                                   >> 728       // Each trajectory point is made of a single primitive, a point.
                                                   >> 729       hepRepXMLWriter->addPrimitive();
                                                   >> 730       G4Point3D vertex = aTrajectoryPoint->GetPosition();
                                                   >> 731       hepRepXMLWriter->addPoint(vertex.x(), vertex.y(), vertex.z());
                                                   >> 732     }
                                                   >> 733   }
                                                   >> 734   
                                                   >> 735   // Draw Auxiliary Points
                                                   >> 736   if (drawingMode!=0 || trajContext->GetDrawAuxPts()) {
                                                   >> 737     if (!doneInitTraj)
                                                   >> 738       InitTrajectory();
                                                   >> 739     // Create Trajectory Points as a subType of Trajectories.
                                                   >> 740     // Note that we should create this heprep type even if there are no actual points.
                                                   >> 741     // This allows the user to tell that points don't exist (admittedly odd) rather
                                                   >> 742     // than that they were omitted by the drawing mode.
                                                   >> 743     previousName = hepRepXMLWriter->prevTypeName[2];
                                                   >> 744     hepRepXMLWriter->addType("Trajectory Auxiliary Points",2);
                                                   >> 745 
                                                   >> 746     float redness;
                                                   >> 747     float greenness;
                                                   >> 748     float blueness;     
                                                   >> 749     G4int markSize;
                                                   >> 750     G4bool visible;
                                                   >> 751     G4bool square;
                                                   >> 752     if (drawingMode==0) {
                                                   >> 753       G4Colour colour = trajContext->GetAuxPtsColour();
                                                   >> 754       redness = colour.GetRed();
                                                   >> 755       greenness = colour.GetGreen();
                                                   >> 756       blueness = colour.GetBlue();
                                                   >> 757       markSize = (G4int) trajContext->GetAuxPtsSize();
                                                   >> 758       visible = (G4int) trajContext->GetAuxPtsVisible();
                                                   >> 759       square = (trajContext->GetAuxPtsType()==G4Polymarker::squares);
                                                   >> 760     } else {
                                                   >> 761       redness = 1.;
                                                   >> 762       greenness = 1.;
                                                   >> 763       blueness = 1.;
                                                   >> 764       markSize = std::abs(drawingMode/1000);
                                                   >> 765       visible = true;
                                                   >> 766       square = false;
                                                   >> 767     }
                                                   >> 768 
                                                   >> 769     // Avoiding drawing anything black on black.  
                                                   >> 770     if (redness==0. && greenness==0. && blueness==0.) {
                                                   >> 771       redness = 1.;
                                                   >> 772       greenness = 1.;
                                                   >> 773       blueness = 1.;
                                                   >> 774     }
                                                   >> 775     
                                                   >> 776     // Specify attributes common to all trajectory points.
                                                   >> 777     if (strcmp("Trajectory Auxiliary Points",previousName)!=0) {
                                                   >> 778       hepRepXMLWriter->addAttValue("DrawAs","Point");
                                                   >> 779       hepRepXMLWriter->addAttValue("MarkColor", redness, greenness, blueness);
                                                   >> 780       hepRepXMLWriter->addAttValue("MarkSize",markSize);
                                                   >> 781       hepRepXMLWriter->addAttValue("Layer",110);
                                                   >> 782       hepRepXMLWriter->addAttValue("Visibility",visible);
                                                   >> 783       if (square)
                                                   >> 784         hepRepXMLWriter->addAttValue("MarkName","Square");
                                                   >> 785       else
                                                   >> 786         hepRepXMLWriter->addAttValue("MarkName","Dot");
                                                   >> 787     }
                                                   >> 788     
                                                   >> 789     // Loop over all points on this trajectory.
                                                   >> 790     for (i = 0; i < traj.GetPointEntries(); i++) {
                                                   >> 791       G4VTrajectoryPoint* aTrajectoryPoint = traj.GetPoint(i);
                                                   >> 792       
                                                   >> 793       // Each point is a separate instance of the type Trajectory Points.
                                                   >> 794       hepRepXMLWriter->addInstance();
                                                   >> 795       
                                                   >> 796       // Pointers to hold trajectory point attribute values and definitions.
                                                   >> 797       std::vector<G4AttValue>* rawPointAttValues = aTrajectoryPoint->CreateAttValues();
                                                   >> 798       std::vector<G4AttValue>* pointAttValues =
                                                   >> 799         new std::vector<G4AttValue>;
                                                   >> 800       std::map<G4String,G4AttDef>* pointAttDefs =
                                                   >> 801         new std::map<G4String,G4AttDef>;
                                                   >> 802       
                                                   >> 803       // Get trajectory point attributes and definitions in standard HepRep style
                                                   >> 804       // (uniform units, 3Vectors decomposed).
                                                   >> 805       if (rawPointAttValues) {
                                                   >> 806         G4bool error = G4AttCheck(rawPointAttValues,
                                                   >> 807                       aTrajectoryPoint->GetAttDefs()).Standard(pointAttValues,pointAttDefs);
                                                   >> 808         if (error) {
                                                   >> 809           G4cout << "G4HepRepFileSceneHandler::AddCompound(traj):"
                                                   >> 810           "\nERROR found during conversion to standard point attributes." << G4endl;
                                                   >> 811         }
                                                   >> 812         
                                                   >> 813         // Write out point attribute values.
                                                   >> 814         if (pointAttValues) {
                                                   >> 815           std::vector<G4AttValue>::iterator iAttVal;
                                                   >> 816           for (iAttVal = pointAttValues->begin();
                                                   >> 817              iAttVal != pointAttValues->end(); ++iAttVal)
                                                   >> 818             // Do not write out the Aux or Pos attribute.  Aux does not conform to the HepRep rule
                                                   >> 819             // that each object can have only one instance of a given AttValue.
                                                   >> 820             // Both of these attributes are redundant to actual position information of the point.
                                                   >> 821             // New Wired can just tell the user the point position itself.
                                                   >> 822             if (strcmp(iAttVal->GetName(),"Aux-X")!=0 &&
                                                   >> 823               strcmp(iAttVal->GetName(),"Aux-Y")!=0 &&
                                                   >> 824               strcmp(iAttVal->GetName(),"Aux-Z")!=0 &&
                                                   >> 825               strcmp(iAttVal->GetName(),"Pos-X")!=0 &&
                                                   >> 826               strcmp(iAttVal->GetName(),"Pos-Y")!=0 &&
                                                   >> 827               strcmp(iAttVal->GetName(),"Pos-Z")!=0)
                                                   >> 828               hepRepXMLWriter->addAttValue(iAttVal->GetName(), iAttVal->GetValue());
                                                   >> 829           delete pointAttValues;
                                                   >> 830         }
                                                   >> 831         delete rawPointAttValues;
                                                   >> 832       }
                                                   >> 833       
                                                   >> 834       // Clean up point attributes.
                                                   >> 835       if (pointAttDefs)
                                                   >> 836         delete pointAttDefs;
                                                   >> 837       
                                                   >> 838       // Each trajectory point is made of a single primitive, a point.
                                                   >> 839       G4Point3D vertex = aTrajectoryPoint->GetPosition();
                                                   >> 840       
                                                   >> 841       // Loop over auxiliary points associated with this Trajectory Point.
                                                   >> 842       const std::vector<G4ThreeVector>* auxiliaries = aTrajectoryPoint->GetAuxiliaryPoints();
                                                   >> 843       if (0 != auxiliaries) {
                                                   >> 844         for (size_t iAux=0; iAux<auxiliaries->size(); ++iAux) {
                                                   >> 845           const G4ThreeVector auxPos((*auxiliaries)[iAux]);
                                                   >> 846           hepRepXMLWriter->addPrimitive();
                                                   >> 847           hepRepXMLWriter->addPoint(auxPos.x(), auxPos.y(), auxPos.z());
                                                   >> 848         }
                                                   >> 849       }
                                                   >> 850     }
                                                   >> 851   }
                                                   >> 852 }
                                                   >> 853 
                                                   >> 854 
                                                   >> 855 void G4HepRepFileSceneHandler::AddCompound (const G4VHit& hit) {
                                                   >> 856 #ifdef G4HEPREPFILEDEBUG
                                                   >> 857   G4cout << "G4HepRepFileSceneHandler::AddCompound(G4VHit&) " << G4endl;
                                                   >> 858 #endif
                                                   >> 859   
                                                   >> 860   // Pointers to hold hit attribute values and definitions.
                                                   >> 861   std::vector<G4AttValue>* rawHitAttValues = hit.CreateAttValues();
                                                   >> 862   hitAttValues =
                                                   >> 863     new std::vector<G4AttValue>;
                                                   >> 864   hitAttDefs =
                                                   >> 865     new std::map<G4String,G4AttDef>;
                                                   >> 866   
                                                   >> 867   // Iterators to use with attribute values and definitions.
                                                   >> 868   std::vector<G4AttValue>::iterator iAttVal;
                                                   >> 869   std::map<G4String,G4AttDef>::const_iterator iAttDef;
                                                   >> 870   
                                                   >> 871   // Get hit attributes and definitions in standard HepRep style
                                                   >> 872   // (uniform units, 3Vectors decomposed).
                                                   >> 873   if (rawHitAttValues) {
                                                   >> 874     G4bool error = G4AttCheck(rawHitAttValues,
                                                   >> 875                   hit.GetAttDefs()).Standard(hitAttValues,hitAttDefs);
                                                   >> 876     if (error) {
                                                   >> 877       G4cout << "G4HepRepFileSceneHandler::AddCompound(hit):"
                                                   >> 878       "\nERROR found during conversion to standard hit attributes."
                                                   >> 879       << G4endl;
                                                   >> 880     }
                                                   >> 881 #ifdef G4HEPREPFILEDEBUG 
                                                   >> 882     G4cout <<
                                                   >> 883       "G4HepRepFileSceneHandler::AddCompound(hit): standardised attributes:\n"
                                                   >> 884       << G4AttCheck(hitAttValues,hitAttDefs) << G4endl;
                                                   >> 885 #endif
                                                   >> 886     delete rawHitAttValues;
                                                   >> 887   }
                                                   >> 888   
                                                   >> 889   // Open the HepRep output file if it is not already open.
                                                   >> 890   CheckFileOpen();
                                                   >> 891   
                                                   >> 892   // Add the Event Data Type if it hasn't already been added.
                                                   >> 893   if (strcmp("Event Data",hepRepXMLWriter->prevTypeName[0])!=0) {
                                                   >> 894     hepRepXMLWriter->addType("Event Data",0);
                                                   >> 895     hepRepXMLWriter->addInstance();
                                                   >> 896   }
                                                   >> 897   
                                                   >> 898   // Find out the current HitType.
                                                   >> 899   G4String hitType = "Hits";
                                                   >> 900   if (hitAttValues) {
                                                   >> 901     G4bool found = false;
                                                   >> 902     for (iAttVal = hitAttValues->begin();
                                                   >> 903        iAttVal != hitAttValues->end() && !found; ++iAttVal) {
                                                   >> 904       if (strcmp(iAttVal->GetName(),"HitType")==0) {
                                                   >> 905         hitType = iAttVal->GetValue();
                                                   >> 906         found = true;
                                                   >> 907       }
                                                   >> 908     }
                                                   >> 909   }
                                                   >> 910   
                                                   >> 911   // Add the Hits Type.
                                                   >> 912   G4String previousName = hepRepXMLWriter->prevTypeName[1];
                                                   >> 913   hepRepXMLWriter->addType(hitType,1);
                                                   >> 914   
                                                   >> 915   // If this is the first hit of this event,
                                                   >> 916   // specify attribute values common to all hits.
                                                   >> 917   if (strcmp(hitType,previousName)!=0) {
                                                   >> 918     hepRepXMLWriter->addAttValue("Layer",130);
                                                   >> 919     
                                                   >> 920     // Take all Hit attDefs from first hit.
                                                   >> 921     // Would rather be able to get these attDefs without needing a reference from any
                                                   >> 922     // particular hit, but don't know how to do that.
                                                   >> 923     // Write out hit attribute definitions.
                                                   >> 924     if (hitAttValues && hitAttDefs) {
                                                   >> 925       for (iAttVal = hitAttValues->begin();
                                                   >> 926          iAttVal != hitAttValues->end(); ++iAttVal) {
                                                   >> 927         iAttDef = hitAttDefs->find(iAttVal->GetName());
                                                   >> 928         if (iAttDef != hitAttDefs->end()) {
                                                   >> 929           // Protect against incorrect use of Category.  Anything value other than the
                                                   >> 930           // standard ones will be considered to be in the physics category.
                                                   >> 931           G4String category = iAttDef->second.GetCategory();
                                                   >> 932           if (strcmp(category,"Draw")!=0 &&
                                                   >> 933             strcmp(category,"Physics")!=0 &&
                                                   >> 934             strcmp(category,"Association")!=0 &&
                                                   >> 935             strcmp(category,"PickAction")!=0)
                                                   >> 936             category = "Physics";
                                                   >> 937           hepRepXMLWriter->addAttDef(iAttVal->GetName(), iAttDef->second.GetDesc(),
                                                   >> 938                          category, iAttDef->second.GetExtra());
                                                   >> 939         }
                                                   >> 940       }
                                                   >> 941     }
                                                   >> 942   } // end of special treatment for when this is the first hit.
                                                   >> 943   
                                                   >> 944   // Now that we have written out all of the attributes that are based on the
                                                   >> 945   // hit's particulars, call base class to deconstruct hit into a primitives.
                                                   >> 946   drawingHit = true;
                                                   >> 947   doneInitHit = false;
                                                   >> 948   G4VSceneHandler::AddCompound(hit);  // Invoke default action.
                                                   >> 949   drawingHit = false;
                                                   >> 950 }
                                                   >> 951 
                                                   >> 952 
                                                   >> 953 void G4HepRepFileSceneHandler::InitTrajectory() {
                                                   >> 954   if (!doneInitTraj) {
                                                   >> 955     // For every trajectory, add an instance of Type Trajectory.
                                                   >> 956     hepRepXMLWriter->addInstance();
                                                   >> 957     
                                                   >> 958     // Write out the trajectory's attribute values.
                                                   >> 959     if (trajAttValues) {
                                                   >> 960       std::vector<G4AttValue>::iterator iAttVal;
                                                   >> 961       for (iAttVal = trajAttValues->begin();
                                                   >> 962          iAttVal != trajAttValues->end(); ++iAttVal)
                                                   >> 963         hepRepXMLWriter->addAttValue(iAttVal->GetName(), iAttVal->GetValue());
                                                   >> 964       delete trajAttValues; 
                                                   >> 965     }
                                                   >> 966     
                                                   >> 967     // Clean up trajectory attributes.
                                                   >> 968     if (trajAttDefs)
                                                   >> 969       delete trajAttDefs;
                                                   >> 970     
                                                   >> 971     doneInitTraj = true;
                                                   >> 972   }
                                                   >> 973 }
                                                   >> 974 
                                                   >> 975 
                                                   >> 976 void G4HepRepFileSceneHandler::InitHit() {
                                                   >> 977   if (!doneInitHit) {
                                                   >> 978     // For every hit, add an instance of Type Hit.
                                                   >> 979     hepRepXMLWriter->addInstance();
                                                   >> 980     
                                                   >> 981     // Write out the hit's attribute values.
                                                   >> 982     if (hitAttValues) {
                                                   >> 983       std::vector<G4AttValue>::iterator iAttVal;
                                                   >> 984       for (iAttVal = hitAttValues->begin();
                                                   >> 985          iAttVal != hitAttValues->end(); ++iAttVal)
                                                   >> 986         hepRepXMLWriter->addAttValue(iAttVal->GetName(), iAttVal->GetValue());
                                                   >> 987       delete hitAttValues;
                                                   >> 988     }
                                                   >> 989     
                                                   >> 990     // Clean up hit attributes.
                                                   >> 991     if (hitAttDefs)
                                                   >> 992       delete hitAttDefs;
                                                   >> 993     
                                                   >> 994     doneInitHit = true;
                                                   >> 995   }
                                                   >> 996 }
                                                   >> 997 
                                                   >> 998 
                                                   >> 999 void G4HepRepFileSceneHandler::AddPrimitive(const G4Polyline& polyline) {
                                                   >> 1000 #ifdef G4HEPREPFILEDEBUG
                                                   >> 1001   G4cout <<
                                                   >> 1002     "G4HepRepFileSceneHandler::AddPrimitive(const G4Polyline& polyline) called:"
                                                   >> 1003     "\n  polyline: " << polyline
                                                   >> 1004   << G4endl;
                                                   >> 1005   PrintThings();
                                                   >> 1006 #endif
                                                   >> 1007   
                                                   >> 1008   if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && cullInvisibleObjects)
                                                   >> 1009     return;
                                                   >> 1010   
                                                   >> 1011   if (inPrimitives2D) {
                                                   >> 1012     if (!warnedAbout2DMarkers) {
                                                   >> 1013       G4cout << "HepRepFile does not currently support 2D lines." << G4endl;
                                                   >> 1014       warnedAbout2DMarkers = true;
                                                   >> 1015     }
                                                   >> 1016     return;
                                                   >> 1017     }
                                                   >> 1018   
                                                   >> 1019   if (drawingTraj)
                                                   >> 1020     InitTrajectory();
                                                   >> 1021     
                                                   >> 1022   if (drawingHit)
                                                   >> 1023     InitHit();
                                                   >> 1024   
                                                   >> 1025   haveVisible = true;
                                                   >> 1026   AddHepRepInstance("Line", polyline);
                                                   >> 1027   
                                                   >> 1028   hepRepXMLWriter->addPrimitive();
                                                   >> 1029   
                                                   >> 1030   for (size_t i=0; i < polyline.size(); i++) {
                                                   >> 1031     G4Point3D vertex = (*fpObjectTransformation) * polyline[i];
                                                   >> 1032     hepRepXMLWriter->addPoint(vertex.x(), vertex.y(), vertex.z());
                                                   >> 1033   }
                                                   >> 1034 }
                                                   >> 1035 
                                                   >> 1036 
                                                   >> 1037 
                                                   >> 1038 void G4HepRepFileSceneHandler::AddPrimitive (const G4Polymarker& line) {
                                                   >> 1039 #ifdef G4HEPREPFILEDEBUG
                                                   >> 1040   G4cout <<
                                                   >> 1041     "G4HepRepFileSceneHandler::AddPrimitive(const G4Polymarker& line) called"
                                                   >> 1042   << G4endl;
                                                   >> 1043   PrintThings();
                                                   >> 1044 #endif
                                                   >> 1045   
                                                   >> 1046   if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && cullInvisibleObjects)
                                                   >> 1047     return;
                                                   >> 1048   
                                                   >> 1049   if (inPrimitives2D) {
                                                   >> 1050     if (!warnedAbout2DMarkers) {
                                                   >> 1051       G4cout << "HepRepFile does not currently support 2D lines." << G4endl;
                                                   >> 1052       warnedAbout2DMarkers = true;
                                                   >> 1053     }
                                                   >> 1054     return;
                                                   >> 1055     }
                                                   >> 1056   
                                                   >> 1057   MarkerSizeType sizeType;
                                                   >> 1058   G4double size = GetMarkerSize (line, sizeType);
                                                   >> 1059   if (sizeType==world)
                                                   >> 1060     size = 4.;
                                                   >> 1061   
                                                   >> 1062   if (drawingTraj)
                                                   >> 1063     return;
                                                   >> 1064   
                                                   >> 1065   if (drawingHit)
                                                   >> 1066     InitHit();
                                                   >> 1067   
                                                   >> 1068   haveVisible = true;
                                                   >> 1069   AddHepRepInstance("Point", line);
                                                   >> 1070   
                                                   >> 1071   hepRepXMLWriter->addAttValue("MarkName", "Dot");
                                                   >> 1072   hepRepXMLWriter->addAttValue("MarkSize", (G4int) size);
                                                   >> 1073   
                                                   >> 1074   hepRepXMLWriter->addPrimitive();
                                                   >> 1075   
                                                   >> 1076   for (size_t i=0; i < line.size(); i++) {
                                                   >> 1077     G4Point3D vertex = (*fpObjectTransformation) * line[i];
                                                   >> 1078     hepRepXMLWriter->addPoint(vertex.x(), vertex.y(), vertex.z());
                                                   >> 1079   }
                                                   >> 1080 }
                                                   >> 1081 
                                                   >> 1082 
                                                   >> 1083 void G4HepRepFileSceneHandler::AddPrimitive(const G4Text& text) {
                                                   >> 1084 #ifdef G4HEPREPFILEDEBUG
                                                   >> 1085   G4cout <<
                                                   >> 1086     "G4HepRepFileSceneHandler::AddPrimitive(const G4Text& text) called:"
                                                   >> 1087     "\n  text: " << text.GetText()
                                                   >> 1088   << G4endl;
                                                   >> 1089   PrintThings();
                                                   >> 1090 #endif
                                                   >> 1091   
                                                   >> 1092   if (!inPrimitives2D) {
                                                   >> 1093     if (!warnedAbout3DText) {
                                                   >> 1094       G4cout << "HepRepFile does not currently support 3D text." << G4endl;
                                                   >> 1095       G4cout << "HepRep browsers can directly display text attributes on request." << G4endl;
                                                   >> 1096       G4cout << "See Application Developers Guide for how to attach attributes to viewable objects." << G4endl;
                                                   >> 1097       warnedAbout3DText = true;
                                                   >> 1098     }
                                                   >> 1099     return;
                                                   >> 1100     }
                                                   >> 1101   
                                                   >> 1102   MarkerSizeType sizeType;
                                                   >> 1103   G4double size = GetMarkerSize (text, sizeType);
                                                   >> 1104   if (sizeType==world)
                                                   >> 1105     size = 12.;
                                                   >> 1106   
                                                   >> 1107   haveVisible = true;
                                                   >> 1108   AddHepRepInstance("Text", text);
                                                   >> 1109   
                                                   >> 1110   hepRepXMLWriter->addAttValue("VAlign", "Top");
                                                   >> 1111   hepRepXMLWriter->addAttValue("HAlign", "Left");
                                                   >> 1112   hepRepXMLWriter->addAttValue("FontName", "Arial");
                                                   >> 1113   hepRepXMLWriter->addAttValue("FontStyle", "Plain");
                                                   >> 1114   hepRepXMLWriter->addAttValue("FontSize", (G4int) size);
                                                   >> 1115   hepRepXMLWriter->addAttValue("FontHasBanner", "TRUE");
                                                   >> 1116   hepRepXMLWriter->addAttValue("FontBannerColor", "0,0,0");
                                                   >> 1117   
                                                   >> 1118   const G4Colour& colour = GetTextColour(text);
                                                   >> 1119   float redness = colour.GetRed();
                                                   >> 1120   float greenness = colour.GetGreen();
                                                   >> 1121   float blueness = colour.GetBlue();
                                                   >> 1122     
                                                   >> 1123   // Avoiding drawing anything black on black.  
                                                   >> 1124   if (redness==0. && greenness==0. && blueness==0.) {
                                                   >> 1125     redness = 1.;
                                                   >> 1126     greenness = 1.;
                                                   >> 1127     blueness = 1.;
                                                   >> 1128   }
                                                   >> 1129   hepRepXMLWriter->addAttValue("FontColor",redness,greenness,blueness);
                                                   >> 1130   
                                                   >> 1131   hepRepXMLWriter->addPrimitive();
                                                   >> 1132   
                                                   >> 1133   hepRepXMLWriter->addAttValue("Text", text.GetText());
                                                   >> 1134   hepRepXMLWriter->addAttValue("VPos", .99-text.GetYOffset());
                                                   >> 1135   hepRepXMLWriter->addAttValue("HPos", text.GetXOffset());
                                                   >> 1136 }
                                                   >> 1137 
                                                   >> 1138 
                                                   >> 1139 void G4HepRepFileSceneHandler::AddPrimitive(const G4Circle& circle) {
                                                   >> 1140 #ifdef G4HEPREPFILEDEBUG
                                                   >> 1141   G4cout <<
                                                   >> 1142     "G4HepRepFileSceneHandler::AddPrimitive(const G4Circle& circle) called:"
                                                   >> 1143     "\n  radius: " << circle.GetWorldRadius()
                                                   >> 1144   << G4endl;
                                                   >> 1145   PrintThings();
                                                   >> 1146 #endif
                                                   >> 1147   
                                                   >> 1148   if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && cullInvisibleObjects)
                                                   >> 1149     return;
                                                   >> 1150   
                                                   >> 1151   if (inPrimitives2D) {
                                                   >> 1152     if (!warnedAbout2DMarkers) {
                                                   >> 1153       G4cout << "HepRepFile does not currently support 2D circles." << G4endl;
                                                   >> 1154       warnedAbout2DMarkers = true;
                                                   >> 1155     }
                                                   >> 1156     return;
                                                   >> 1157     }
                                                   >> 1158   
                                                   >> 1159   MarkerSizeType sizeType;
                                                   >> 1160   G4double size = GetMarkerSize (circle, sizeType);
                                                   >> 1161   if (sizeType==world)
                                                   >> 1162     size = 4.;
                                                   >> 1163   
                                                   >> 1164   if (drawingTraj)
                                                   >> 1165     return;
                                                   >> 1166   
                                                   >> 1167   if (drawingHit)
                                                   >> 1168     InitHit();
                                                   >> 1169   
                                                   >> 1170   haveVisible = true;
                                                   >> 1171   AddHepRepInstance("Point", circle);
                                                   >> 1172   
                                                   >> 1173   hepRepXMLWriter->addAttValue("MarkName", "Dot");
                                                   >> 1174   hepRepXMLWriter->addAttValue("MarkSize", (G4int) size);
                                                   >> 1175   
                                                   >> 1176   hepRepXMLWriter->addPrimitive();
                                                   >> 1177   
                                                   >> 1178   G4Point3D center = (*fpObjectTransformation) * circle.GetPosition();
                                                   >> 1179   hepRepXMLWriter->addPoint(center.x(), center.y(), center.z());
                                                   >> 1180 }
                                                   >> 1181 
                                                   >> 1182 
                                                   >> 1183 void G4HepRepFileSceneHandler::AddPrimitive(const G4Square& square) {
                                                   >> 1184 #ifdef G4HEPREPFILEDEBUG
                                                   >> 1185   G4cout <<
                                                   >> 1186     "G4HepRepFileSceneHandler::AddPrimitive(const G4Square& square) called:"
                                                   >> 1187     "\n  side: " << square.GetWorldRadius()
                                                   >> 1188   << G4endl;
                                                   >> 1189   PrintThings();
                                                   >> 1190 #endif
                                                   >> 1191   
                                                   >> 1192   if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && cullInvisibleObjects)
                                                   >> 1193     return;
                                                   >> 1194   
                                                   >> 1195   if (inPrimitives2D) {
                                                   >> 1196     if (!warnedAbout2DMarkers) {
                                                   >> 1197       G4cout << "HepRepFile does not currently support 2D squares." << G4endl;
                                                   >> 1198       warnedAbout2DMarkers = true;
                                                   >> 1199     }
                                                   >> 1200     return;
                                                   >> 1201     }
                                                   >> 1202   
                                                   >> 1203   MarkerSizeType sizeType;
                                                   >> 1204   G4double size = GetMarkerSize (square, sizeType);
                                                   >> 1205   if (sizeType==world)
                                                   >> 1206     size = 4.;
                                                   >> 1207   
                                                   >> 1208   if (drawingTraj)
                                                   >> 1209     return;
                                                   >> 1210   
                                                   >> 1211   if (drawingHit)
                                                   >> 1212     InitHit();
                                                   >> 1213   
                                                   >> 1214   haveVisible = true;
                                                   >> 1215   AddHepRepInstance("Point", square);
                                                   >> 1216   
                                                   >> 1217   hepRepXMLWriter->addAttValue("MarkName", "Square");
                                                   >> 1218   hepRepXMLWriter->addAttValue("MarkSize", (G4int) size);
                                                   >> 1219   
                                                   >> 1220   hepRepXMLWriter->addPrimitive();
                                                   >> 1221   
                                                   >> 1222   G4Point3D center = (*fpObjectTransformation) * square.GetPosition();
                                                   >> 1223   hepRepXMLWriter->addPoint(center.x(), center.y(), center.z());
                                                   >> 1224 }
                                                   >> 1225 
                                                   >> 1226 
                                                   >> 1227 void G4HepRepFileSceneHandler::AddPrimitive(const G4Polyhedron& polyhedron) {
                                                   >> 1228 #ifdef G4HEPREPFILEDEBUG
                                                   >> 1229   G4cout <<
                                                   >> 1230     "G4HepRepFileSceneHandler::AddPrimitive(const G4Polyhedron& polyhedron) called."
                                                   >> 1231   << G4endl;
                                                   >> 1232   PrintThings();
                                                   >> 1233 #endif
                                                   >> 1234   
                                                   >> 1235   if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && cullInvisibleObjects)
                                                   >> 1236     return;
                                                   >> 1237   
                                                   >> 1238   if(polyhedron.GetNoFacets()==0)return;
                                                   >> 1239   
                                                   >> 1240   if (drawingTraj)
                                                   >> 1241     return;
                                                   >> 1242   
                                                   >> 1243   if (drawingHit)
                                                   >> 1244     InitHit();
                                                   >> 1245   
                                                   >> 1246   haveVisible = true;
                                                   >> 1247   AddHepRepInstance("Polygon", polyhedron);
                                                   >> 1248   
                                                   >> 1249   G4Normal3D surfaceNormal;
                                                   >> 1250   G4Point3D vertex;
                                                   >> 1251   
                                                   >> 1252   G4bool notLastFace;
                                                   >> 1253   do {
                                                   >> 1254     hepRepXMLWriter->addPrimitive();
                                                   >> 1255     notLastFace = polyhedron.GetNextNormal (surfaceNormal);
                                                   >> 1256     
                                                   >> 1257     G4int edgeFlag = 1;
                                                   >> 1258     G4bool notLastEdge;
                                                   >> 1259     do {
                                                   >> 1260       notLastEdge = polyhedron.GetNextVertex (vertex, edgeFlag);
                                                   >> 1261       vertex = (*fpObjectTransformation) * vertex;
                                                   >> 1262       hepRepXMLWriter->addPoint(vertex.x(), vertex.y(), vertex.z());
                                                   >> 1263     } while (notLastEdge);
                                                   >> 1264   } while (notLastFace);
                                                   >> 1265 }
                                                   >> 1266 
                                                   >> 1267 
                                                   >> 1268 void G4HepRepFileSceneHandler::AddPrimitive(const G4NURBS&) {
                                                   >> 1269 #ifdef G4HEPREPFILEDEBUG
                                                   >> 1270   G4cout <<
                                                   >> 1271     "G4HepRepFileSceneHandler::AddPrimitive(const G4NURBS& nurbs) called."
                                                   >> 1272   << G4endl;
                                                   >> 1273   PrintThings();
480 #endif                                            1274 #endif
481   G4VSceneHandler::AddSolid(orb);  // Invoke d << 1275     G4cout << "G4HepRepFileSceneHandler::AddPrimitive G4NURBS : not implemented. " << G4endl;
482 }                                                 1276 }
483                                                   1277 
484 void G4HepRepFileSceneHandler::AddSolid(const  << 
485 {                                              << 
486 #ifdef G4HEPREPFILEDEBUG                       << 
487   G4cout << "G4HepRepFileSceneHandler::AddSoli << 
488             "called for "                      << 
489          << ellipsoid.GetName() << G4endl;     << 
490   PrintThings();                               << 
491 #endif                                         << 
492   G4VSceneHandler::AddSolid(ellipsoid);  // In << 
493 }                                              << 
494                                                   1278 
495 void G4HepRepFileSceneHandler::AddSolid(const  << 1279 G4HepRepFileXMLWriter *G4HepRepFileSceneHandler::GetHepRepXMLWriter() {
496 {                                              << 1280     return hepRepXMLWriter;
497 #ifdef G4HEPREPFILEDEBUG                       << 
498   G4cout << "G4HepRepFileSceneHandler::AddSoli << 
499             "called for "                      << 
500          << tess.GetName() << G4endl;          << 
501   PrintThings();                               << 
502 #endif                                         << 
503   G4VSceneHandler::AddSolid(tess);  // Invoke  << 
504 }                                              << 
505                                                << 
506 void G4HepRepFileSceneHandler::AddSolid(const  << 
507 {                                              << 
508 #ifdef G4HEPREPFILEDEBUG                       << 
509   G4cout                                       << 
510     << "G4HepRepFileSceneHandler::AddSolid(con << 
511     << solid.GetName() << G4endl;              << 
512   PrintThings();                               << 
513 #endif                                         << 
514   G4VSceneHandler::AddSolid(solid);  // Invoke << 
515 }                                                 1281 }
516                                                   1282 
517 void G4HepRepFileSceneHandler::AddCompound(con << 
518 {                                              << 
519 #ifdef G4HEPREPFILEDEBUG                       << 
520   G4cout << "G4HepRepFileSceneHandler::AddComp << 
521          << G4endl;                            << 
522 #endif                                         << 
523                                                << 
524   G4TrajectoriesModel* pTrModel = dynamic_cast << 
525   if(!pTrModel)                                << 
526     G4Exception("G4HepRepFileSceneHandler::Add << 
527                 "vis-HepRep0001", FatalExcepti << 
528                                                << 
529   // Pointers to hold trajectory attribute val << 
530   std::vector<G4AttValue>* rawTrajAttValues =  << 
531   trajAttValues                             =  << 
532   trajAttDefs                               =  << 
533                                                << 
534   // Iterators to use with attribute values an << 
535   std::vector<G4AttValue>::iterator iAttVal;   << 
536   std::map<G4String, G4AttDef>::const_iterator << 
537   G4int i;                                     << 
538                                                << 
539   // Get trajectory attributes and definitions << 
540   // (uniform units, 3Vectors decomposed).     << 
541   if(rawTrajAttValues)                         << 
542   {                                            << 
543     G4bool error = G4AttCheck(rawTrajAttValues << 
544                      .Standard(trajAttValues,  << 
545     if(error)                                  << 
546     {                                          << 
547       G4cout                                   << 
548         << "G4HepRepFileSceneHandler::AddCompo << 
549            "\nERROR found during conversion to << 
550         << G4endl;                             << 
551     }                                          << 
552 #ifdef G4HEPREPFILEDEBUG                       << 
553     G4cout << "G4HepRepFileSceneHandler::AddCo << 
554               "attributes:\n"                  << 
555            << G4AttCheck(trajAttValues, trajAt << 
556 #endif                                         << 
557     delete rawTrajAttValues;                   << 
558   }                                            << 
559                                                << 
560   // Open the HepRep output file if it is not  << 
561   CheckFileOpen();                             << 
562                                                << 
563   // Add the Event Data Type if it hasn't alre << 
564   if(strcmp("Event Data", hepRepXMLWriter->pre << 
565   {                                            << 
566     hepRepXMLWriter->addType("Event Data", 0); << 
567     hepRepXMLWriter->addInstance();            << 
568   }                                            << 
569                                                << 
570   // Add the Trajectories Type.                << 
571   G4String previousName = hepRepXMLWriter->pre << 
572   hepRepXMLWriter->addType("Trajectories", 1); << 
573                                                << 
574   // If this is the first trajectory of this e << 
575   // specify attribute values common to all tr << 
576   if(strcmp("Trajectories", previousName) != 0 << 
577   {                                            << 
578     hepRepXMLWriter->addAttValue("Layer", 100) << 
579                                                << 
580     // Take all Trajectory attDefs from first  << 
581     // Would rather be able to get these attDe << 
582     // from any particular trajectory, but don << 
583     // trajectory attribute definitions.       << 
584     if(trajAttValues && trajAttDefs)           << 
585     {                                          << 
586       for(iAttVal = trajAttValues->begin(); iA << 
587           ++iAttVal)                           << 
588       {                                        << 
589         iAttDef = trajAttDefs->find(iAttVal->G << 
590         if(iAttDef != trajAttDefs->end())      << 
591         {                                      << 
592           // Protect against incorrect use of  << 
593           // than the standard ones will be co << 
594           // category.                         << 
595           G4String category = iAttDef->second. << 
596           if(strcmp(category, "Draw") != 0 &&  << 
597              strcmp(category, "Physics") != 0  << 
598              strcmp(category, "Association") ! << 
599              strcmp(category, "PickAction") != << 
600             category = "Physics";              << 
601           hepRepXMLWriter->addAttDef(iAttVal-> << 
602                                      iAttDef-> << 
603                                      iAttDef-> << 
604         }                                      << 
605       }                                        << 
606     }                                          << 
607                                                << 
608     // Take all TrajectoryPoint attDefs from f << 
609     // Would rather be able to get these attDe << 
610     // from any particular point, but don't kn << 
611     if((trajContext->GetDrawStepPts() || trajC << 
612        traj.GetPointEntries() > 0)             << 
613     {                                          << 
614       G4VTrajectoryPoint* aTrajectoryPoint = t << 
615                                                << 
616       // Pointers to hold trajectory point att << 
617       std::vector<G4AttValue>* rawPointAttValu << 
618         aTrajectoryPoint->CreateAttValues();   << 
619       std::vector<G4AttValue>* pointAttValues  << 
620       std::map<G4String, G4AttDef>* pointAttDe << 
621         new std::map<G4String, G4AttDef>;      << 
622                                                << 
623       // Get first trajectory point's attribut << 
624       // HepRep style (uniform units, 3Vectors << 
625       if(rawPointAttValues)                    << 
626       {                                        << 
627         G4bool error =                         << 
628           G4AttCheck(rawPointAttValues, aTraje << 
629             .Standard(pointAttValues, pointAtt << 
630         if(error)                              << 
631         {                                      << 
632           G4cout << "G4HepRepFileSceneHandler: << 
633                     "\nERROR found during conv << 
634                     "attributes."              << 
635                  << G4endl;                    << 
636         }                                      << 
637                                                << 
638         // Write out point attribute definitio << 
639         if(pointAttValues && pointAttDefs)     << 
640         {                                      << 
641           for(iAttVal = pointAttValues->begin( << 
642               iAttVal != pointAttValues->end() << 
643           {                                    << 
644             iAttDef = pointAttDefs->find(iAttV << 
645             if(iAttDef != pointAttDefs->end()) << 
646             {                                  << 
647               // Protect against incorrect use << 
648               // other than the standard ones  << 
649               // physics category.             << 
650               G4String category = iAttDef->sec << 
651               if(strcmp(category, "Draw") != 0 << 
652                  strcmp(category, "Physics") ! << 
653                  strcmp(category, "Association << 
654                  strcmp(category, "PickAction" << 
655                 category = "Physics";          << 
656               // Do not write out the Aux or P << 
657               // conform to the HepRep rule th << 
658               // instance of a given AttValue. << 
659               // redundant to actual position  << 
660               if(strcmp(iAttVal->GetName(), "A << 
661                  strcmp(iAttVal->GetName(), "A << 
662                  strcmp(iAttVal->GetName(), "A << 
663                  strcmp(iAttVal->GetName(), "P << 
664                  strcmp(iAttVal->GetName(), "P << 
665                  strcmp(iAttVal->GetName(), "P << 
666                 hepRepXMLWriter->addAttDef(iAt << 
667                                            iAt << 
668                                            iAt << 
669             }                                  << 
670           }                                    << 
671         }                                      << 
672         delete rawPointAttValues;              << 
673       }                                        << 
674                                                << 
675       // Clean up point attributes.            << 
676       if(pointAttValues)                       << 
677         delete pointAttValues;                 << 
678       if(pointAttDefs)                         << 
679         delete pointAttDefs;                   << 
680     }                                          << 
681   }  // end of special treatment for when this << 
682                                                << 
683   // Now that we have written out all of the a << 
684   // trajectory's particulars, call base class << 
685   // polyline and/or points (or nothing if tra << 
686   // base class calls for drawing points, no p << 
687   // since we instead need to do point drawing << 
688   // points attributes, not available from Add << 
689   // such a call will just serve to set the fl << 
690   // drawing was requested for this trajectory << 
691   // including trajContext and filtering).     << 
692   drawingTraj  = true;                         << 
693   doneInitTraj = false;                        << 
694   G4VSceneHandler::AddCompound(traj);          << 
695   drawingTraj = false;                         << 
696                                                << 
697   // Draw step points.                         << 
698   if(trajContext->GetDrawStepPts())            << 
699   {                                            << 
700     if(!doneInitTraj)                          << 
701       InitTrajectory();                        << 
702     // Create Trajectory Points as a subType o << 
703     // Note that we should create this heprep  << 
704     // points. This allows the user to tell th << 
705     // odd) rather than that they were omitted << 
706     previousName = hepRepXMLWriter->prevTypeNa << 
707     hepRepXMLWriter->addType("Trajectory Step  << 
708                                                << 
709     float redness;                             << 
710     float greenness;                           << 
711     float blueness;                            << 
712     G4int markSize;                            << 
713     G4bool visible;                            << 
714     G4bool square;                             << 
715     G4Colour colour = trajContext->GetStepPtsC << 
716     redness         = colour.GetRed();         << 
717     greenness       = colour.GetGreen();       << 
718     blueness        = colour.GetBlue();        << 
719     markSize        = (G4int) trajContext->Get << 
720     visible         = (G4int) trajContext->Get << 
721     square          = (trajContext->GetStepPts << 
722                                                << 
723     // Avoiding drawing anything black on blac << 
724     if(redness == 0. && greenness == 0. && blu << 
725     {                                          << 
726       redness   = 1.;                          << 
727       greenness = 1.;                          << 
728       blueness  = 1.;                          << 
729     }                                          << 
730                                                << 
731     // Specify attributes common to all trajec << 
732     if(strcmp("Trajectory Step Points", previo << 
733     {                                          << 
734       hepRepXMLWriter->addAttValue("DrawAs", " << 
735       hepRepXMLWriter->addAttValue("MarkColor" << 
736       hepRepXMLWriter->addAttValue("MarkSize", << 
737       hepRepXMLWriter->addAttValue("Layer", 11 << 
738       hepRepXMLWriter->addAttValue("Visibility << 
739       if(square)                               << 
740         hepRepXMLWriter->addAttValue("MarkName << 
741       else                                     << 
742         hepRepXMLWriter->addAttValue("MarkName << 
743     }                                          << 
744                                                << 
745     // Loop over all points on this trajectory << 
746     for(i = 0; i < traj.GetPointEntries(); i++ << 
747     {                                          << 
748       G4VTrajectoryPoint* aTrajectoryPoint = t << 
749                                                << 
750       // Each point is a separate instance of  << 
751       hepRepXMLWriter->addInstance();          << 
752                                                << 
753       // Pointers to hold trajectory point att << 
754       std::vector<G4AttValue>* rawPointAttValu << 
755         aTrajectoryPoint->CreateAttValues();   << 
756       std::vector<G4AttValue>* pointAttValues  << 
757       std::map<G4String, G4AttDef>* pointAttDe << 
758         new std::map<G4String, G4AttDef>;      << 
759                                                << 
760       // Get trajectory point attributes and d << 
761       // style (uniform units, 3Vectors decomp << 
762       if(rawPointAttValues)                    << 
763       {                                        << 
764         G4bool error =                         << 
765           G4AttCheck(rawPointAttValues, aTraje << 
766             .Standard(pointAttValues, pointAtt << 
767         if(error)                              << 
768         {                                      << 
769           G4cout                               << 
770             << "G4HepRepFileSceneHandler::AddC << 
771                "\nERROR found during conversio << 
772             << G4endl;                         << 
773         }                                      << 
774                                                << 
775         // Write out point attribute values.   << 
776         if(pointAttValues)                     << 
777         {                                      << 
778           for(iAttVal = pointAttValues->begin( << 
779               iAttVal != pointAttValues->end() << 
780             // Do not write out the Aux or Pos << 
781             // to the HepRep rule that each ob << 
782             // a given AttValue. Both of these << 
783             // actual position information of  << 
784             if(strcmp(iAttVal->GetName(), "Aux << 
785                strcmp(iAttVal->GetName(), "Aux << 
786                strcmp(iAttVal->GetName(), "Aux << 
787                strcmp(iAttVal->GetName(), "Pos << 
788                strcmp(iAttVal->GetName(), "Pos << 
789                strcmp(iAttVal->GetName(), "Pos << 
790               hepRepXMLWriter->addAttValue(iAt << 
791                                            iAt << 
792         }                                      << 
793       }                                        << 
794                                                << 
795       // Clean up point attributes.            << 
796       delete pointAttDefs;                     << 
797       delete pointAttValues;                   << 
798       delete rawPointAttValues;                << 
799                                                << 
800       // Each trajectory point is made of a si << 
801       hepRepXMLWriter->addPrimitive();         << 
802       G4Point3D vertex = aTrajectoryPoint->Get << 
803       hepRepXMLWriter->addPoint(vertex.x(), ve << 
804     }                                          << 
805   }                                            << 
806                                                << 
807   // Draw Auxiliary Points                     << 
808   if(trajContext->GetDrawAuxPts())             << 
809   {                                            << 
810     if(!doneInitTraj)                          << 
811       InitTrajectory();                        << 
812     // Create Trajectory Points as a subType o << 
813     // Note that we should create this heprep  << 
814     // points. This allows the user to tell th << 
815     // odd) rather than that they were omitted << 
816     previousName = hepRepXMLWriter->prevTypeNa << 
817     hepRepXMLWriter->addType("Trajectory Auxil << 
818                                                << 
819     float redness;                             << 
820     float greenness;                           << 
821     float blueness;                            << 
822     G4int markSize;                            << 
823     G4bool visible;                            << 
824     G4bool square;                             << 
825     G4Colour colour = trajContext->GetAuxPtsCo << 
826     redness         = colour.GetRed();         << 
827     greenness       = colour.GetGreen();       << 
828     blueness        = colour.GetBlue();        << 
829     markSize        = (G4int) trajContext->Get << 
830     visible         = (G4int) trajContext->Get << 
831     square          = (trajContext->GetAuxPtsT << 
832                                                << 
833     // Avoiding drawing anything black on blac << 
834     if(redness == 0. && greenness == 0. && blu << 
835     {                                          << 
836       redness   = 1.;                          << 
837       greenness = 1.;                          << 
838       blueness  = 1.;                          << 
839     }                                          << 
840                                                << 
841     // Specify attributes common to all trajec << 
842     if(strcmp("Trajectory Auxiliary Points", p << 
843     {                                          << 
844       hepRepXMLWriter->addAttValue("DrawAs", " << 
845       hepRepXMLWriter->addAttValue("MarkColor" << 
846       hepRepXMLWriter->addAttValue("MarkSize", << 
847       hepRepXMLWriter->addAttValue("Layer", 11 << 
848       hepRepXMLWriter->addAttValue("Visibility << 
849       if(square)                               << 
850         hepRepXMLWriter->addAttValue("MarkName << 
851       else                                     << 
852         hepRepXMLWriter->addAttValue("MarkName << 
853     }                                          << 
854                                                << 
855     // Loop over all points on this trajectory << 
856     for(i = 0; i < traj.GetPointEntries(); i++ << 
857     {                                          << 
858       G4VTrajectoryPoint* aTrajectoryPoint = t << 
859                                                << 
860       // Each point is a separate instance of  << 
861       hepRepXMLWriter->addInstance();          << 
862                                                << 
863       // Pointers to hold trajectory point att << 
864       std::vector<G4AttValue>* rawPointAttValu << 
865         aTrajectoryPoint->CreateAttValues();   << 
866       std::vector<G4AttValue>* pointAttValues  << 
867       std::map<G4String, G4AttDef>* pointAttDe << 
868         new std::map<G4String, G4AttDef>;      << 
869                                                << 
870       // Get trajectory point attributes and d << 
871       // style (uniform units, 3Vectors decomp << 
872       if(rawPointAttValues)                    << 
873       {                                        << 
874         G4bool error =                         << 
875           G4AttCheck(rawPointAttValues, aTraje << 
876             .Standard(pointAttValues, pointAtt << 
877         if(error)                              << 
878         {                                      << 
879           G4cout                               << 
880             << "G4HepRepFileSceneHandler::AddC << 
881                "\nERROR found during conversio << 
882             << G4endl;                         << 
883         }                                      << 
884                                                << 
885         // Write out point attribute values.   << 
886         if(pointAttValues)                     << 
887         {                                      << 
888           for(iAttVal = pointAttValues->begin( << 
889               iAttVal != pointAttValues->end() << 
890             // Do not write out the Aux or Pos << 
891             // to the HepRep rule that each ob << 
892             // a given AttValue. Both of these << 
893             // actual position information of  << 
894             if(strcmp(iAttVal->GetName(), "Aux << 
895                strcmp(iAttVal->GetName(), "Aux << 
896                strcmp(iAttVal->GetName(), "Aux << 
897                strcmp(iAttVal->GetName(), "Pos << 
898                strcmp(iAttVal->GetName(), "Pos << 
899                strcmp(iAttVal->GetName(), "Pos << 
900               hepRepXMLWriter->addAttValue(iAt << 
901                                            iAt << 
902         }                                      << 
903       }                                        << 
904                                                << 
905       // Clean up point attributes.            << 
906       delete pointAttDefs;                     << 
907       delete pointAttValues;                   << 
908       delete rawPointAttValues;                << 
909                                                << 
910       // Each trajectory point is made of a si << 
911       G4Point3D vertex = aTrajectoryPoint->Get << 
912                                                << 
913       // Loop over auxiliary points associated << 
914       const std::vector<G4ThreeVector>* auxili << 
915         aTrajectoryPoint->GetAuxiliaryPoints() << 
916       if(0 != auxiliaries)                     << 
917       {                                        << 
918         for(size_t iAux = 0; iAux < auxiliarie << 
919         {                                      << 
920           const G4ThreeVector auxPos((*auxilia << 
921           hepRepXMLWriter->addPrimitive();     << 
922           hepRepXMLWriter->addPoint(auxPos.x() << 
923         }                                      << 
924       }                                        << 
925     }                                          << 
926   }                                            << 
927 }                                              << 
928                                                << 
929 void G4HepRepFileSceneHandler::AddCompound(con << 
930 {                                              << 
931 #ifdef G4HEPREPFILEDEBUG                       << 
932   G4cout << "G4HepRepFileSceneHandler::AddComp << 
933 #endif                                         << 
934                                                << 
935   // Pointers to hold hit attribute values and << 
936   std::vector<G4AttValue>* rawHitAttValues = h << 
937   hitAttValues                             = n << 
938   hitAttDefs                               = n << 
939                                                << 
940   // Iterators to use with attribute values an << 
941   std::vector<G4AttValue>::iterator iAttVal;   << 
942   std::map<G4String, G4AttDef>::const_iterator << 
943                                                << 
944   // Get hit attributes and definitions in sta << 
945   // (uniform units, 3Vectors decomposed).     << 
946   if(rawHitAttValues)                          << 
947   {                                            << 
948     G4bool error = G4AttCheck(rawHitAttValues, << 
949                      .Standard(hitAttValues, h << 
950     if(error)                                  << 
951     {                                          << 
952       G4cout << "G4HepRepFileSceneHandler::Add << 
953                 "\nERROR found during conversi << 
954              << G4endl;                        << 
955     }                                          << 
956 #ifdef G4HEPREPFILEDEBUG                       << 
957     G4cout << "G4HepRepFileSceneHandler::AddCo << 
958               "attributes:\n"                  << 
959            << G4AttCheck(hitAttValues, hitAttD << 
960 #endif                                         << 
961     delete rawHitAttValues;                    << 
962   }                                            << 
963                                                << 
964   // Open the HepRep output file if it is not  << 
965   CheckFileOpen();                             << 
966                                                << 
967   // Add the Event Data Type if it hasn't alre << 
968   if(strcmp("Event Data", hepRepXMLWriter->pre << 
969   {                                            << 
970     hepRepXMLWriter->addType("Event Data", 0); << 
971     hepRepXMLWriter->addInstance();            << 
972   }                                            << 
973                                                << 
974   // Find out the current HitType.             << 
975   G4String hitType = "Hits";                   << 
976   if(hitAttValues)                             << 
977   {                                            << 
978     G4bool found = false;                      << 
979     for(iAttVal = hitAttValues->begin();       << 
980         iAttVal != hitAttValues->end() && !fou << 
981     {                                          << 
982       if(strcmp(iAttVal->GetName(), "HitType") << 
983       {                                        << 
984         hitType = iAttVal->GetValue();         << 
985         found   = true;                        << 
986       }                                        << 
987     }                                          << 
988   }                                            << 
989                                                << 
990   // Add the Hits Type.                        << 
991   G4String previousName = hepRepXMLWriter->pre << 
992   hepRepXMLWriter->addType(hitType, 1);        << 
993                                                << 
994   // If this is the first hit of this event,   << 
995   // specify attribute values common to all hi << 
996   if(strcmp(hitType, previousName) != 0)       << 
997   {                                            << 
998     hepRepXMLWriter->addAttValue("Layer", 130) << 
999                                                << 
1000     // Take all Hit attDefs from first hit.   << 
1001     // Would rather be able to get these attD << 
1002     // from any particular hit, but don't kno << 
1003     // attribute definitions.                 << 
1004     if(hitAttValues && hitAttDefs)            << 
1005     {                                         << 
1006       for(iAttVal = hitAttValues->begin(); iA << 
1007           ++iAttVal)                          << 
1008       {                                       << 
1009         iAttDef = hitAttDefs->find(iAttVal->G << 
1010         if(iAttDef != hitAttDefs->end())      << 
1011         {                                     << 
1012           // Protect against incorrect use of << 
1013           // than the standard ones will be c << 
1014           // category.                        << 
1015           G4String category = iAttDef->second << 
1016           if(strcmp(category, "Draw") != 0 && << 
1017              strcmp(category, "Physics") != 0 << 
1018              strcmp(category, "Association")  << 
1019              strcmp(category, "PickAction") ! << 
1020             category = "Physics";             << 
1021           hepRepXMLWriter->addAttDef(iAttVal- << 
1022                                      iAttDef- << 
1023                                      iAttDef- << 
1024         }                                     << 
1025       }                                       << 
1026     }                                         << 
1027   }  // end of special treatment for when thi << 
1028                                               << 
1029   // Now that we have written out all of the  << 
1030   // hit's particulars, call base class to de << 
1031   drawingHit  = true;                         << 
1032   doneInitHit = false;                        << 
1033   G4VSceneHandler::AddCompound(hit);  // Invo << 
1034   drawingHit = false;                         << 
1035 }                                             << 
1036                                               << 
1037 void G4HepRepFileSceneHandler::InitTrajectory << 
1038 {                                             << 
1039   if(!doneInitTraj)                           << 
1040   {                                           << 
1041     // For every trajectory, add an instance  << 
1042     hepRepXMLWriter->addInstance();           << 
1043                                               << 
1044     // Write out the trajectory's attribute v << 
1045     if(trajAttValues)                         << 
1046     {                                         << 
1047       std::vector<G4AttValue>::iterator iAttV << 
1048       for(iAttVal = trajAttValues->begin(); i << 
1049           ++iAttVal)                          << 
1050         hepRepXMLWriter->addAttValue(iAttVal- << 
1051       delete trajAttValues;                   << 
1052     }                                         << 
1053                                               << 
1054     // Clean up trajectory attributes.        << 
1055     if(trajAttDefs)                           << 
1056       delete trajAttDefs;                     << 
1057                                               << 
1058     doneInitTraj = true;                      << 
1059   }                                           << 
1060 }                                             << 
1061                                               << 
1062 void G4HepRepFileSceneHandler::InitHit()      << 
1063 {                                             << 
1064   if(!doneInitHit)                            << 
1065   {                                           << 
1066     // For every hit, add an instance of Type << 
1067     hepRepXMLWriter->addInstance();           << 
1068                                               << 
1069     // Write out the hit's attribute values.  << 
1070     if(hitAttValues)                          << 
1071     {                                         << 
1072       std::vector<G4AttValue>::iterator iAttV << 
1073       for(iAttVal = hitAttValues->begin(); iA << 
1074           ++iAttVal)                          << 
1075         hepRepXMLWriter->addAttValue(iAttVal- << 
1076       delete hitAttValues;                    << 
1077     }                                         << 
1078                                               << 
1079     // Clean up hit attributes.               << 
1080     if(hitAttDefs)                            << 
1081       delete hitAttDefs;                      << 
1082                                               << 
1083     doneInitHit = true;                       << 
1084   }                                           << 
1085 }                                             << 
1086                                               << 
1087 void G4HepRepFileSceneHandler::AddPrimitive(c << 
1088 {                                             << 
1089 #ifdef G4HEPREPFILEDEBUG                      << 
1090   G4cout << "G4HepRepFileSceneHandler::AddPri << 
1091             "polyline) called:"               << 
1092             "\n  polyline: "                  << 
1093          << polyline << G4endl;               << 
1094   PrintThings();                              << 
1095 #endif                                        << 
1096                                               << 
1097   G4HepRepMessenger* messenger = G4HepRepMess << 
1098                                               << 
1099   if(fpVisAttribs && (fpVisAttribs->IsVisible << 
1100      messenger->getCullInvisibles())          << 
1101     return;                                   << 
1102                                               << 
1103   if(inPrimitives2D)                          << 
1104   {                                           << 
1105     if(!warnedAbout2DMarkers)                 << 
1106     {                                         << 
1107       G4cout << "HepRepFile does not currentl << 
1108       warnedAbout2DMarkers = true;            << 
1109     }                                         << 
1110     return;                                   << 
1111   }                                           << 
1112                                               << 
1113   if(drawingTraj)                             << 
1114     InitTrajectory();                         << 
1115                                               << 
1116   if(drawingHit)                              << 
1117     InitHit();                                << 
1118                                               << 
1119   haveVisible = true;                         << 
1120   AddHepRepInstance("Line", polyline);        << 
1121                                               << 
1122   hepRepXMLWriter->addPrimitive();            << 
1123                                               << 
1124   for(size_t i = 0; i < polyline.size(); i++) << 
1125   {                                           << 
1126     G4Point3D vertex = (fObjectTransformation << 
1127     hepRepXMLWriter->addPoint(vertex.x(), ver << 
1128   }                                           << 
1129 }                                             << 
1130                                               << 
1131 void G4HepRepFileSceneHandler::AddPrimitive(c << 
1132 {                                             << 
1133 #ifdef G4HEPREPFILEDEBUG                      << 
1134   G4cout                                      << 
1135     << "G4HepRepFileSceneHandler::AddPrimitiv << 
1136     << G4endl;                                << 
1137   PrintThings();                              << 
1138 #endif                                        << 
1139                                               << 
1140   G4HepRepMessenger* messenger = G4HepRepMess << 
1141                                               << 
1142   if(fpVisAttribs && (fpVisAttribs->IsVisible << 
1143      messenger->getCullInvisibles())          << 
1144     return;                                   << 
1145                                               << 
1146   if(inPrimitives2D)                          << 
1147   {                                           << 
1148     if(!warnedAbout2DMarkers)                 << 
1149     {                                         << 
1150       G4cout << "HepRepFile does not currentl << 
1151       warnedAbout2DMarkers = true;            << 
1152     }                                         << 
1153     return;                                   << 
1154   }                                           << 
1155                                               << 
1156   MarkerSizeType sizeType;                    << 
1157   G4double size = GetMarkerSize(line, sizeTyp << 
1158   if(sizeType == world)                       << 
1159     size = 4.;                                << 
1160                                               << 
1161   if(drawingTraj)                             << 
1162     return;                                   << 
1163                                               << 
1164   if(drawingHit)                              << 
1165     InitHit();                                << 
1166                                               << 
1167   haveVisible = true;                         << 
1168   AddHepRepInstance("Point", line);           << 
1169                                               << 
1170   hepRepXMLWriter->addAttValue("MarkName", "D << 
1171   hepRepXMLWriter->addAttValue("MarkSize", (G << 
1172                                               << 
1173   hepRepXMLWriter->addPrimitive();            << 
1174                                               << 
1175   for(size_t i = 0; i < line.size(); i++)     << 
1176   {                                           << 
1177     G4Point3D vertex = (fObjectTransformation << 
1178     hepRepXMLWriter->addPoint(vertex.x(), ver << 
1179   }                                           << 
1180 }                                             << 
1181                                               << 
1182 void G4HepRepFileSceneHandler::AddPrimitive(c << 
1183 {                                             << 
1184 #ifdef G4HEPREPFILEDEBUG                      << 
1185   G4cout << "G4HepRepFileSceneHandler::AddPri << 
1186             "\n  text: "                      << 
1187          << text.GetText() << G4endl;         << 
1188   PrintThings();                              << 
1189 #endif                                        << 
1190                                               << 
1191   if(!inPrimitives2D)                         << 
1192   {                                           << 
1193     if(!warnedAbout3DText)                    << 
1194     {                                         << 
1195       G4cout << "HepRepFile does not currentl << 
1196       G4cout                                  << 
1197         << "HepRep browsers can directly disp << 
1198         << G4endl;                            << 
1199       G4cout << "See Application Developers G << 
1200                 "to viewable objects."        << 
1201              << G4endl;                       << 
1202       warnedAbout3DText = true;               << 
1203     }                                         << 
1204     return;                                   << 
1205   }                                           << 
1206                                               << 
1207   MarkerSizeType sizeType;                    << 
1208   G4double size = GetMarkerSize(text, sizeTyp << 
1209   if(sizeType == world)                       << 
1210     size = 12.;                               << 
1211                                               << 
1212   haveVisible = true;                         << 
1213   AddHepRepInstance("Text", text);            << 
1214                                               << 
1215   hepRepXMLWriter->addAttValue("VAlign", "Top << 
1216   hepRepXMLWriter->addAttValue("HAlign", "Lef << 
1217   hepRepXMLWriter->addAttValue("FontName", "A << 
1218   hepRepXMLWriter->addAttValue("FontStyle", " << 
1219   hepRepXMLWriter->addAttValue("FontSize", (G << 
1220   hepRepXMLWriter->addAttValue("FontHasBanner << 
1221   hepRepXMLWriter->addAttValue("FontBannerCol << 
1222                                               << 
1223   const G4Colour& colour = GetTextColour(text << 
1224   float redness          = colour.GetRed();   << 
1225   float greenness        = colour.GetGreen(); << 
1226   float blueness         = colour.GetBlue();  << 
1227                                               << 
1228   // Avoiding drawing anything black on black << 
1229   if(redness == 0. && greenness == 0. && blue << 
1230   {                                           << 
1231     redness   = 1.;                           << 
1232     greenness = 1.;                           << 
1233     blueness  = 1.;                           << 
1234   }                                           << 
1235   hepRepXMLWriter->addAttValue("FontColor", r << 
1236                                               << 
1237   hepRepXMLWriter->addPrimitive();            << 
1238                                               << 
1239   hepRepXMLWriter->addAttValue("Text", text.G << 
1240   hepRepXMLWriter->addAttValue("VPos", .99 -  << 
1241   hepRepXMLWriter->addAttValue("HPos", text.G << 
1242 }                                             << 
1243                                               << 
1244 void G4HepRepFileSceneHandler::AddPrimitive(c << 
1245 {                                             << 
1246 #ifdef G4HEPREPFILEDEBUG                      << 
1247   G4cout                                      << 
1248     << "G4HepRepFileSceneHandler::AddPrimitiv << 
1249        "\n  radius: "                         << 
1250     << circle.GetWorldRadius() << G4endl;     << 
1251   PrintThings();                              << 
1252 #endif                                        << 
1253                                               << 
1254   G4HepRepMessenger* messenger = G4HepRepMess << 
1255                                               << 
1256   if(fpVisAttribs && (fpVisAttribs->IsVisible << 
1257      messenger->getCullInvisibles())          << 
1258     return;                                   << 
1259                                               << 
1260   if(inPrimitives2D)                          << 
1261   {                                           << 
1262     if(!warnedAbout2DMarkers)                 << 
1263     {                                         << 
1264       G4cout << "HepRepFile does not currentl << 
1265       warnedAbout2DMarkers = true;            << 
1266     }                                         << 
1267     return;                                   << 
1268   }                                           << 
1269                                               << 
1270   MarkerSizeType sizeType;                    << 
1271   G4double size = GetMarkerSize(circle, sizeT << 
1272   if(sizeType == world)                       << 
1273     size = 4.;                                << 
1274                                               << 
1275   if(drawingTraj)                             << 
1276     return;                                   << 
1277                                               << 
1278   if(drawingHit)                              << 
1279     InitHit();                                << 
1280                                               << 
1281   haveVisible = true;                         << 
1282   AddHepRepInstance("Point", circle);         << 
1283                                               << 
1284   hepRepXMLWriter->addAttValue("MarkName", "D << 
1285   hepRepXMLWriter->addAttValue("MarkSize", (G << 
1286                                               << 
1287   hepRepXMLWriter->addPrimitive();            << 
1288                                               << 
1289   G4Point3D center = (fObjectTransformation)  << 
1290   hepRepXMLWriter->addPoint(center.x(), cente << 
1291 }                                             << 
1292                                               << 
1293 void G4HepRepFileSceneHandler::AddPrimitive(c << 
1294 {                                             << 
1295 #ifdef G4HEPREPFILEDEBUG                      << 
1296   G4cout                                      << 
1297     << "G4HepRepFileSceneHandler::AddPrimitiv << 
1298        "\n  side: "                           << 
1299     << square.GetWorldRadius() << G4endl;     << 
1300   PrintThings();                              << 
1301 #endif                                        << 
1302                                               << 
1303   G4HepRepMessenger* messenger = G4HepRepMess << 
1304                                               << 
1305   if(fpVisAttribs && (fpVisAttribs->IsVisible << 
1306      messenger->getCullInvisibles())          << 
1307     return;                                   << 
1308                                               << 
1309   if(inPrimitives2D)                          << 
1310   {                                           << 
1311     if(!warnedAbout2DMarkers)                 << 
1312     {                                         << 
1313       G4cout << "HepRepFile does not currentl << 
1314       warnedAbout2DMarkers = true;            << 
1315     }                                         << 
1316     return;                                   << 
1317   }                                           << 
1318                                               << 
1319   MarkerSizeType sizeType;                    << 
1320   G4double size = GetMarkerSize(square, sizeT << 
1321   if(sizeType == world)                       << 
1322     size = 4.;                                << 
1323                                               << 
1324   if(drawingTraj)                             << 
1325     return;                                   << 
1326                                               << 
1327   if(drawingHit)                              << 
1328     InitHit();                                << 
1329                                               << 
1330   haveVisible = true;                         << 
1331   AddHepRepInstance("Point", square);         << 
1332                                               << 
1333   hepRepXMLWriter->addAttValue("MarkName", "S << 
1334   hepRepXMLWriter->addAttValue("MarkSize", (G << 
1335                                               << 
1336   hepRepXMLWriter->addPrimitive();            << 
1337                                               << 
1338   G4Point3D center = (fObjectTransformation)  << 
1339   hepRepXMLWriter->addPoint(center.x(), cente << 
1340 }                                             << 
1341                                               << 
1342 void G4HepRepFileSceneHandler::AddPrimitive(c << 
1343 {                                             << 
1344 #ifdef G4HEPREPFILEDEBUG                      << 
1345   G4cout << "G4HepRepFileSceneHandler::AddPri << 
1346             "polyhedron) called."             << 
1347          << G4endl;                           << 
1348   PrintThings();                              << 
1349 #endif                                        << 
1350                                               << 
1351   G4HepRepMessenger* messenger = G4HepRepMess << 
1352                                               << 
1353   if(fpVisAttribs && (fpVisAttribs->IsVisible << 
1354      messenger->getCullInvisibles())          << 
1355     return;                                   << 
1356                                               << 
1357   if(polyhedron.GetNoFacets() == 0)           << 
1358     return;                                   << 
1359                                               << 
1360   if(drawingTraj)                             << 
1361     return;                                   << 
1362                                               << 
1363   if(drawingHit)                              << 
1364     InitHit();                                << 
1365                                               << 
1366   haveVisible = true;                         << 
1367   AddHepRepInstance("Polygon", polyhedron);   << 
1368                                               << 
1369   G4Normal3D surfaceNormal;                   << 
1370   G4Point3D vertex;                           << 
1371                                               << 
1372   G4bool notLastFace;                         << 
1373   do                                          << 
1374   {                                           << 
1375     hepRepXMLWriter->addPrimitive();          << 
1376     notLastFace = polyhedron.GetNextNormal(su << 
1377                                               << 
1378     G4int edgeFlag = 1;                       << 
1379     G4bool notLastEdge;                       << 
1380     do                                        << 
1381     {                                         << 
1382       notLastEdge = polyhedron.GetNextVertex( << 
1383       vertex      = (fObjectTransformation) * << 
1384       hepRepXMLWriter->addPoint(vertex.x(), v << 
1385     } while(notLastEdge);                     << 
1386   } while(notLastFace);                       << 
1387 }                                             << 
1388                                               << 
1389 G4HepRepFileXMLWriter* G4HepRepFileSceneHandl << 
1390 {                                             << 
1391   return hepRepXMLWriter;                     << 
1392 }                                             << 
1393                                                  1283 
1394 void G4HepRepFileSceneHandler::AddHepRepInsta    1284 void G4HepRepFileSceneHandler::AddHepRepInstance(const char* primName,
1395                                               << 1285                          const G4Visible visible) {
1396 {                                             << 
1397 #ifdef G4HEPREPFILEDEBUG                         1286 #ifdef G4HEPREPFILEDEBUG
1398   G4cout << "G4HepRepFileSceneHandler::AddHep << 1287   G4cout <<
1399 #endif                                        << 1288     "G4HepRepFileSceneHandler::AddHepRepInstance called."
1400                                               << 1289   << G4endl;
1401   // Open the HepRep output file if it is not << 1290 #endif
1402   CheckFileOpen();                            << 1291   
1403                                               << 1292   // Open the HepRep output file if it is not already open.
1404   G4VPhysicalVolume* pCurrentPV = 0;          << 1293   CheckFileOpen();
1405   G4LogicalVolume* pCurrentLV   = 0;          << 1294   
1406   G4int currentDepth            = 0;          << 1295   G4VPhysicalVolume* pCurrentPV = 0;
1407   G4PhysicalVolumeModel* pPVModel =           << 1296   G4LogicalVolume* pCurrentLV = 0;
1408     dynamic_cast<G4PhysicalVolumeModel*>(fpMo << 1297   G4int currentDepth = 0;
1409   if(pPVModel)                                << 1298   G4PhysicalVolumeModel* pPVModel = dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
1410   {                                           << 1299   if (pPVModel) {
1411     pCurrentPV   = pPVModel->GetCurrentPV();  << 1300     pCurrentPV = pPVModel->GetCurrentPV();
1412     pCurrentLV   = pPVModel->GetCurrentLV();  << 1301     pCurrentLV = pPVModel->GetCurrentLV();
1413     currentDepth = pPVModel->GetCurrentDepth( << 1302     currentDepth = pPVModel->GetCurrentDepth();
1414   }                                           << 1303   }
1415                                               << 1304   
1416 #ifdef G4HEPREPFILEDEBUG                      << 1305 #ifdef G4HEPREPFILEDEBUG
1417   G4cout << "pCurrentPV:" << pCurrentPV       << 1306   G4cout <<
1418          << ", readyForTransients:" << fReady << 1307     "pCurrentPV:" << pCurrentPV << ", readyForTransients:" << fReadyForTransients
1419 #endif                                        << 1308     << G4endl;
1420                                               << 1309 #endif
1421   if(drawingTraj || drawingHit)               << 1310   
1422   {                                           << 1311   if (drawingTraj || drawingHit) {
1423     // In this case, HepRep type, layer and i << 1312     // In this case, HepRep type, layer and instance were already created
1424     // in the AddCompound method.             << 1313     // in the AddCompound method.
1425   }                                           << 1314   }
1426   else if(fReadyForTransients)                << 1315   else if (fReadyForTransients) {
1427   {                                           << 1316     if (strcmp("Event Data",hepRepXMLWriter->prevTypeName[0])!=0) {
1428     if(strcmp("Event Data", hepRepXMLWriter-> << 1317       hepRepXMLWriter->addType("Event Data",0);
1429     {                                         << 1318       hepRepXMLWriter->addInstance();
1430       hepRepXMLWriter->addType("Event Data",  << 1319     }
1431       hepRepXMLWriter->addInstance();         << 1320     
1432     }                                         << 1321     // Applications have the option of either calling AddSolid(G4VTrajectory&) and
1433                                               << 1322     // AddSolid(G4VHits&), or of just decomposing these into simpler primitives.
1434     // Applications have the option of either << 1323     // In the former case, drawing will be handled above and will include setting of
1435     // and AddSolid(G4VHits&), or of just dec << 1324     // physics attributes.
1436     // primitives. In the former case, drawin << 1325     // In the latter case, which is an older style of working, we end up drawing the
1437     // include setting of physics attributes. << 1326     // trajectories and hits here, where we have no access to physics attributes. 
1438     // older style of working, we end up draw << 1327     // We receive primitives here.  We can figure out that these are transients, but we
1439     // where we have no access to physics att << 1328     // have to guess exactly what these transients represent.
1440     // here.  We can figure out that these ar << 1329     // We assume the primitives are being used as in G4VTrajectory, hence we assume:
1441     // exactly what these transients represen << 1330     // Lines are Trajectories
1442     // being used as in G4VTrajectory, hence  << 1331     // Squares that come after we've seen trajectories are Auxiliary Points
1443     // Squares that come after we've seen tra << 1332     // Circles that come after we've seen trajectories are Step Points
1444     // Circles that come after we've seen tra << 1333     // Other primitives are Hits
1445     // Other primitives are Hits              << 1334     
1446                                               << 1335     int layer;
1447     int layer;                                << 1336     
1448                                               << 1337     if (strcmp("Text",primName)==0) {
1449     if(strcmp("Text", primName) == 0)         << 1338       hepRepXMLWriter->addType("EventID",1);
1450     {                                         << 1339     } else {
1451       hepRepXMLWriter->addType("EventID", 1); << 1340       if (strcmp("Line",primName)==0) {
1452     }                                         << 1341         hepRepXMLWriter->addType("TransientPolylines",1);
1453     else                                      << 1342         layer = 100;
1454     {                                         << 1343       } else {
1455       if(strcmp("Line", primName) == 0)       << 1344         if (strcmp(hepRepXMLWriter->prevTypeName[1],"TransientPolylines")==0 &&
1456       {                                       << 1345           strcmp("Square",primName)==0)
1457         hepRepXMLWriter->addType("TransientPo << 1346         {
1458         layer = 100;                          << 1347           hepRepXMLWriter->addType("AuxiliaryPoints",2);
1459       }                                       << 1348           layer = 110;
1460       else                                    << 1349         } else {
1461       {                                       << 1350           if (strcmp(hepRepXMLWriter->prevTypeName[1],"TransientPolylines")==0 &&
1462         if(strcmp(hepRepXMLWriter->prevTypeNa << 1351             strcmp("Circle",primName)==0)
1463              0 &&                             << 1352           {
1464            strcmp("Square", primName) == 0)   << 1353             hepRepXMLWriter->addType("StepPoints",2);
1465         {                                     << 1354             layer = 120;
1466           hepRepXMLWriter->addType("Auxiliary << 1355           } else {
1467           layer = 110;                        << 1356             hepRepXMLWriter->addType("Hits",1);
1468         }                                     << 1357             layer = 130;
1469         else                                  << 1358           }
1470         {                                     << 1359         }
1471           if(strcmp(hepRepXMLWriter->prevType << 1360       }
1472                0 &&                           << 1361       hepRepXMLWriter->addAttValue("Layer",layer);
1473              strcmp("Circle", primName) == 0) << 1362     }
1474           {                                   << 1363     
1475             hepRepXMLWriter->addType("StepPoi << 1364     hepRepXMLWriter->addInstance();
1476             layer = 120;                      << 1365     
1477           }                                   << 1366     // Handle Type declaration for Axes, Ruler, etc.
1478           else                                << 1367   } else if (pCurrentPV==0) {
1479           {                                   << 1368     if (strcmp("AxesEtc",hepRepXMLWriter->prevTypeName[0])!=0) {
1480             hepRepXMLWriter->addType("Hits",  << 1369       hepRepXMLWriter->addType("AxesEtc",0);
1481             layer = 130;                      << 1370       hepRepXMLWriter->addInstance();
1482           }                                   << 1371     }
1483         }                                     << 1372     
1484       }                                       << 1373     int layer;
1485       hepRepXMLWriter->addAttValue("Layer", l << 1374     
1486     }                                         << 1375     if (strcmp("Text",primName)==0) {
1487                                               << 1376       hepRepXMLWriter->addType("Text",1);
1488     hepRepXMLWriter->addInstance();           << 1377     } else {
1489                                               << 1378       if (strcmp("Line",primName)==0) {
1490     // Handle Type declaration for Axes, Rule << 1379         hepRepXMLWriter->addType("Polylines",1);
1491   }                                           << 1380         layer = 100;
1492   else if(pCurrentPV == 0)                    << 1381       } else {
1493   {                                           << 1382         hepRepXMLWriter->addType("Points",1);
1494     if(strcmp("AxesEtc", hepRepXMLWriter->pre << 1383         layer = 130;
1495     {                                         << 1384       }
1496       hepRepXMLWriter->addType("AxesEtc", 0); << 1385       hepRepXMLWriter->addAttValue("Layer",layer);
1497       hepRepXMLWriter->addInstance();         << 1386     }
1498     }                                         << 1387     
1499                                               << 1388     hepRepXMLWriter->addInstance();
1500     int layer;                                << 1389     
1501                                               << 1390     // Handle Type declaration for Detector Geometry,
1502     if(strcmp("Text", primName) == 0)         << 1391     // replacing G4's top geometry level name "worldPhysical" with the
1503     {                                         << 1392     // name "Detector Geometry".
1504       hepRepXMLWriter->addType("Text", 1);    << 1393   } else {
1505     }                                         << 1394     if (strcmp("Detector Geometry",hepRepXMLWriter->prevTypeName[0])!=0) {
1506     else                                      << 1395       hepRepXMLWriter->addType("Detector Geometry",0);
1507     {                                         << 1396       hepRepXMLWriter->addInstance();
1508       if(strcmp("Line", primName) == 0)       << 1397     }
1509       {                                       << 1398     
1510         hepRepXMLWriter->addType("Polylines", << 1399     // Re-insert any layers of the hierarchy that were removed by G4's culling process.
1511         layer = 100;                          << 1400     // Don't bother checking if same type name as last instance.
1512       }                                       << 1401     if(strcmp(hepRepXMLWriter->prevTypeName[currentDepth],pCurrentPV->GetName())!=0) {
1513       else                                    << 1402       //G4cout << "Looking for mother of:" << pCurrentLV->GetName() << G4endl;
1514       {                                       << 1403       typedef G4PhysicalVolumeModel::G4PhysicalVolumeNodeID PVNodeID;
1515         hepRepXMLWriter->addType("Points", 1) << 1404       typedef std::vector<PVNodeID> PVPath;
1516         layer = 130;                          << 1405       const PVPath& drawnPVPath = pPVModel->GetDrawnPVPath();
1517       }                                       << 1406       PVPath::const_reverse_iterator ri = ++drawnPVPath.rbegin();
1518       hepRepXMLWriter->addAttValue("Layer", l << 1407       G4int drawnMotherDepth = 0;
1519     }                                         << 1408       if (ri != drawnPVPath.rend()) {
1520                                               << 1409         // This volume has a mother.
1521     hepRepXMLWriter->addInstance();           << 1410         drawnMotherDepth = ri->GetNonCulledDepth();
1522                                               << 1411       } else {
1523     // Handle Type declaration for Detector G << 1412         // This volume has no mother.  Must be a top level volume.
1524     // replacing G4's top geometry level name << 1413         //G4cout << "Mother must be very top" << G4endl;
1525     // name "Detector Geometry".              << 1414       }
1526   }                                           << 1415       
1527   else                                        << 1416       while (drawnMotherDepth < (currentDepth-1)) {
1528   {                                           << 1417         G4String culledParentName = "Culled parent of " + pCurrentPV->GetName();
1529     // G4cout << "CurrentDepth" << currentDep << 1418         //G4cout << "Inserting culled layer " << culledParentName << " at depth:" << drawnMotherDepth+1 << G4endl;
1530     // G4cout << "currentName" << pCurrentPV- << 1419         hepRepXMLWriter->addType(culledParentName, drawnMotherDepth+1);
1531     if(strcmp("Detector Geometry", hepRepXMLW << 1420         hepRepXMLWriter->addInstance();
1532     {                                         << 1421         drawnMotherDepth ++;
1533       // G4cout << "Adding Det Geom type" <<  << 1422       }
1534       hepRepXMLWriter->addType("Detector Geom << 1423     }
1535       hepRepXMLWriter->addInstance();         << 1424     
1536     }                                         << 1425     if (currentDepth!=0) {
1537                                               << 1426       // Add the HepRepType for the current volume.
1538     // Re-insert any layers of the hierarchy  << 1427       hepRepXMLWriter->addType(pCurrentPV->GetName(),currentDepth);
1539     // process. Don't bother checking if same << 1428       hepRepXMLWriter->addInstance();
1540     if(strcmp(hepRepXMLWriter->prevTypeName[c << 1429     }
1541               pCurrentPV->GetName()) != 0)    << 1430     
1542     {                                         << 1431     if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && cullInvisibleObjects)
1543       // G4cout << "Looking for mother of:" < << 1432       return;
1544       typedef G4PhysicalVolumeModel::G4Physic << 1433     
1545       typedef std::vector<PVNodeID> PVPath;   << 1434     // Additional attributes.
1546       const PVPath& drawnPVPath         = pPV << 1435     hepRepXMLWriter->addAttValue("Layer",hepRepXMLWriter->typeDepth);
1547       PVPath::const_reverse_iterator ri = ++d << 1436     hepRepXMLWriter->addAttValue("LVol", pCurrentLV->GetName());
1548       G4int drawnMotherDepth;                 << 1437     G4Region* region = pCurrentLV->GetRegion();
1549       if(ri != drawnPVPath.rend())            << 1438     G4String regionName = region? region->GetName(): G4String("No region");
1550       {                                       << 1439     hepRepXMLWriter->addAttValue("Region", regionName);
1551         // This volume has a mother.          << 1440     hepRepXMLWriter->addAttValue("RootRegion", pCurrentLV->IsRootRegion());
1552         drawnMotherDepth = ri->GetNonCulledDe << 1441     hepRepXMLWriter->addAttValue("Solid", pCurrentLV->GetSolid()->GetName());
1553         // G4cout << "drawnMotherDepth" << dr << 1442     hepRepXMLWriter->addAttValue("EType", pCurrentLV->GetSolid()->GetEntityType());
1554       }                                       << 1443     G4Material * material = pPVModel->GetCurrentMaterial();
1555       else                                    << 1444     G4String matName = material? material->GetName(): G4String("No material");
1556       {                                       << 1445     hepRepXMLWriter->addAttValue("Material", matName);
1557         // This volume has no mother.  Must b << 1446     G4double matDensity = material? material->GetDensity(): 0.;
1558         drawnMotherDepth = -1;                << 1447     hepRepXMLWriter->addAttValue("Density", matDensity*m3/kg);
1559         // G4cout << "Mother must be very top << 1448     G4State matState = material? material->GetState(): kStateUndefined;
1560       }                                       << 1449     hepRepXMLWriter->addAttValue("State", matState);
1561                                               << 1450     G4double matRadlen = material? material->GetRadlen(): 0.;
1562       while(drawnMotherDepth < (currentDepth  << 1451     hepRepXMLWriter->addAttValue("Radlen", matRadlen/m);
1563       {                                       << 1452   }
1564         G4String culledParentName = "Culled p << 1453   
1565         // G4cout << "Inserting culled layer  << 1454   hepRepXMLWriter->addAttValue("DrawAs",primName);
1566         // depth:" << drawnMotherDepth+2 << G << 1455   
1567         hepRepXMLWriter->addType(culledParent << 1456   // Handle color and visibility attributes.
1568         hepRepXMLWriter->addInstance();       << 1457   float redness;
1569         drawnMotherDepth++;                   << 1458   float greenness;
1570       }                                       << 1459   float blueness;
1571     }                                         << 1460   G4bool isVisible; 
1572                                               << 1461   
1573     // Add the HepRepType for the current vol << 1462   if (fpVisAttribs || haveVisible) {
1574     hepRepXMLWriter->addType(pCurrentPV->GetN << 1463     G4Colour colour;
1575     hepRepXMLWriter->addInstance();           << 1464     
1576                                               << 1465     if (fpVisAttribs) {
1577     G4HepRepMessenger* messenger = G4HepRepMe << 1466       colour = fpVisAttribs->GetColour();
1578                                               << 1467       isVisible = fpVisAttribs->IsVisible();
1579     if(fpVisAttribs && (fpVisAttribs->IsVisib << 1468     } else {
1580        messenger->getCullInvisibles())        << 1469       colour = GetColour(visible);
1581       return;                                 << 1470       isVisible = fpViewer->
1582                                               << 1471         GetApplicableVisAttributes(visible.GetVisAttributes())->IsVisible();
1583     // Additional attributes.                 << 1472     }
1584     hepRepXMLWriter->addAttValue("Layer", hep << 1473     
1585     hepRepXMLWriter->addAttValue("LVol", pCur << 1474     redness = colour.GetRed();
1586     G4Region* region    = pCurrentLV->GetRegi << 1475     greenness = colour.GetGreen();
1587     G4String regionName = region ? region->Ge << 1476     blueness = colour.GetBlue();
1588     hepRepXMLWriter->addAttValue("Region", re << 1477     
1589     hepRepXMLWriter->addAttValue("RootRegion" << 1478     // Avoiding drawing anything black on black.  
1590     hepRepXMLWriter->addAttValue("Solid", pCu << 1479     if (redness==0. && greenness==0. && blueness==0.) {
1591     hepRepXMLWriter->addAttValue("EType",     << 1480       redness = 1.;
1592                                  pCurrentLV-> << 1481       greenness = 1.;
1593     G4Material* material = pPVModel->GetCurre << 1482       blueness = 1.;
1594     G4String matName = material ? material->G << 1483     }
1595     hepRepXMLWriter->addAttValue("Material",  << 1484   } else {
1596     G4double matDensity = material ? material << 1485 #ifdef G4HEPREPFILEDEBUG
1597     hepRepXMLWriter->addAttValue("Density", m << 1486     G4cout <<
1598     G4State matState = material ? material->G << 1487     "G4HepRepFileSceneHandler::AddHepRepInstance using default colour."
1599     hepRepXMLWriter->addAttValue("State", mat << 1488     << G4endl;
1600     G4double matRadlen = material ? material- << 1489 #endif
1601     hepRepXMLWriter->addAttValue("Radlen", ma << 1490     redness = 1.;
1602   }                                           << 1491     greenness = 1.;
1603                                               << 1492     blueness = 1.;
1604   hepRepXMLWriter->addAttValue("DrawAs", prim << 1493     isVisible = true;
1605                                               << 1494   }
1606   // Handle color and visibility attributes.  << 1495   
1607   float redness;                              << 1496   if (strcmp(primName,"Point")==0)
1608   float greenness;                            << 1497     hepRepXMLWriter->addAttValue("MarkColor",redness,greenness,blueness);
1609   float blueness;                             << 1498   else
1610   G4bool isVisible;                           << 1499     hepRepXMLWriter->addAttValue("LineColor",redness,greenness,blueness);
1611                                               << 1500   
1612   if(fpVisAttribs || haveVisible)             << 1501   hepRepXMLWriter->addAttValue("Visibility",isVisible);
1613   {                                           << 1502 }
1614     G4Colour colour;                          << 1503 
1615                                               << 1504 
1616     if(fpVisAttribs)                          << 1505 void G4HepRepFileSceneHandler::CheckFileOpen() {
1617     {                                         << 1506 #ifdef G4HEPREPFILEDEBUG
1618       colour    = fpVisAttribs->GetColour();  << 1507   G4cout <<
1619       isVisible = fpVisAttribs->IsVisible();  << 1508     "G4HepRepFileSceneHandler::CheckFileOpen called."
1620     }                                         << 1509   << G4endl;
1621     else                                      << 1510 #endif
1622     {                                         << 1511   
1623       colour = visible.GetVisAttributes()->Ge << 1512   if (!hepRepXMLWriter->isOpen) {
1624       isVisible =                             << 1513     char* newFileSpec;
1625         fpViewer->GetApplicableVisAttributes( << 1514     newFileSpec = new char [256];
1626           ->IsVisible();                      << 1515     int length;
1627     }                                         << 1516     
1628                                               << 1517     if (fileOverwrite)
1629     redness   = colour.GetRed();              << 1518       length = sprintf (newFileSpec, "%s%s%s",fileDir,fileName,".heprep");
1630     greenness = colour.GetGreen();            << 1519     else
1631     blueness  = colour.GetBlue();             << 1520       length = sprintf (newFileSpec, "%s%s%d%s",fileDir,fileName,fileCounter,".heprep");
1632                                               << 1521     G4cout << "HepRepFile writing to " << newFileSpec << G4endl;
1633     // Avoiding drawing anything black on bla << 1522     
1634     if(redness == 0. && greenness == 0. && bl << 1523     hepRepXMLWriter->open(newFileSpec);
1635     {                                         << 1524     fileCounter++;
1636       redness   = 1.;                         << 1525     
1637       greenness = 1.;                         << 1526     hepRepXMLWriter->addAttDef("Generator", "HepRep Data Generator", "Physics","");
1638       blueness  = 1.;                         << 1527     G4String versionString = G4Version;
1639     }                                         << 1528     versionString = versionString.substr(1,versionString.size()-2);
1640   }                                           << 1529     versionString = " Geant4 version " + versionString + "   " + G4Date;
1641   else                                        << 1530     hepRepXMLWriter->addAttValue("Generator", versionString);
1642   {                                           << 1531     
1643 #ifdef G4HEPREPFILEDEBUG                      << 1532     hepRepXMLWriter->addAttDef("LVol", "Logical Volume", "Physics","");
1644     G4cout                                    << 1533     hepRepXMLWriter->addAttDef("Region", "Cuts Region", "Physics","");
1645       << "G4HepRepFileSceneHandler::AddHepRep << 1534     hepRepXMLWriter->addAttDef("RootRegion", "Root Region", "Physics","");
1646       << G4endl;                              << 1535     hepRepXMLWriter->addAttDef("Solid", "Solid Name", "Physics","");
1647 #endif                                        << 1536     hepRepXMLWriter->addAttDef("EType", "Entity Type", "Physics","");
1648     redness   = 1.;                           << 1537     hepRepXMLWriter->addAttDef("Material", "Material Name", "Physics","");
1649     greenness = 1.;                           << 1538     hepRepXMLWriter->addAttDef("Density", "Material Density", "Physics","kg/m3");
1650     blueness  = 1.;                           << 1539     hepRepXMLWriter->addAttDef("State", "Material State", "Physics","");
1651     isVisible = true;                         << 1540     hepRepXMLWriter->addAttDef("Radlen", "Material Radiation Length", "Physics","m");
1652   }                                           << 1541   }
1653                                               << 1542 }
1654   if(strcmp(primName, "Point") == 0)          << 1543 
1655     hepRepXMLWriter->addAttValue("MarkColor", << 1544 
1656   else                                        << 1545 void G4HepRepFileSceneHandler::ClearTransientStore() {
1657     hepRepXMLWriter->addAttValue("LineColor", << 1546   G4VSceneHandler::ClearTransientStore();
1658                                               << 1547   // This is typically called after an update and before drawing hits
1659   hepRepXMLWriter->addAttValue("Visibility",  << 1548   // of the next event.  To simulate the clearing of "transients"
1660 }                                             << 1549   // (hits, etc.) the detector is redrawn...
1661                                               << 1550   if (fpViewer) {
1662 void G4HepRepFileSceneHandler::CheckFileOpen( << 1551     fpViewer -> SetView();
1663 {                                             << 1552     fpViewer -> ClearView();
1664 #ifdef G4HEPREPFILEDEBUG                      << 1553     fpViewer -> DrawView();
1665   G4cout << "G4HepRepFileSceneHandler::CheckF << 1554   }
1666 #endif                                        << 
1667                                               << 
1668   if(!hepRepXMLWriter->isOpen)                << 
1669   {                                           << 
1670     G4String newFileSpec;                     << 
1671                                               << 
1672     G4HepRepMessenger* messenger = G4HepRepMe << 
1673                                               << 
1674     if(messenger->getOverwrite())             << 
1675     {                                         << 
1676       newFileSpec =                           << 
1677         messenger->getFileDir() + messenger-> << 
1678     }                                         << 
1679     else                                      << 
1680     {                                         << 
1681       newFileSpec = messenger->getFileDir() + << 
1682                     G4UIcommand::ConvertToStr << 
1683     }                                         << 
1684                                               << 
1685     G4cout << "HepRepFile writing to " << new << 
1686                                               << 
1687     hepRepXMLWriter->open(newFileSpec);       << 
1688                                               << 
1689     if(!messenger->getOverwrite())            << 
1690       fileCounter++;                          << 
1691                                               << 
1692     hepRepXMLWriter->addAttDef("Generator", " << 
1693                                "");           << 
1694     G4String versionString = G4Version;       << 
1695     versionString          = versionString.su << 
1696     versionString = " Geant4 version " + vers << 
1697     hepRepXMLWriter->addAttValue("Generator", << 
1698                                               << 
1699     hepRepXMLWriter->addAttDef("LVol", "Logic << 
1700     hepRepXMLWriter->addAttDef("Region", "Cut << 
1701     hepRepXMLWriter->addAttDef("RootRegion",  << 
1702     hepRepXMLWriter->addAttDef("Solid", "Soli << 
1703     hepRepXMLWriter->addAttDef("EType", "Enti << 
1704     hepRepXMLWriter->addAttDef("Material", "M << 
1705     hepRepXMLWriter->addAttDef("Density", "Ma << 
1706                                "kg/m3");      << 
1707     hepRepXMLWriter->addAttDef("State", "Mate << 
1708     hepRepXMLWriter->addAttDef("Radlen", "Mat << 
1709                                "m");          << 
1710   }                                           << 
1711 }                                             << 
1712                                               << 
1713 void G4HepRepFileSceneHandler::ClearTransient << 
1714 {                                             << 
1715   // This is typically called after an update << 
1716   // of the next event.  To simulate the clea << 
1717   // (hits, etc.) the detector is redrawn...  << 
1718   if(fpViewer)                                << 
1719   {                                           << 
1720     fpViewer->SetView();                      << 
1721     fpViewer->ClearView();                    << 
1722     fpViewer->DrawView();                     << 
1723   }                                           << 
1724 }                                                1555 }
1725                                                  1556