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 10.6.p2)


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