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