| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer << 3 // * DISCLAIMER *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th << 5 // * The following disclaimer summarizes all the specific disclaimers *
6 // * the Geant4 Collaboration. It is provided << 6 // * of contributors to this software. The specific disclaimers,which *
7 // * conditions of the Geant4 Software License << 7 // * govern, are listed with their locations in: *
8 // * LICENSE and available at http://cern.ch/ << 8 // * http://cern.ch/geant4/license *
9 // * include a list of copyright holders. <<
10 // * 9 // * *
11 // * Neither the authors of this software syst 10 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 11 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 12 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 13 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file << 14 // * use. *
16 // * for the full disclaimer and the limitatio <<
17 // * 15 // * *
18 // * This code implementation is the result << 16 // * This code implementation is the intellectual property of the *
19 // * technical work of the GEANT4 collaboratio << 17 // * GEANT4 collaboration. *
20 // * By using, copying, modifying or distri << 18 // * By copying, distributing or modifying the Program (or any work *
21 // * any work based on the software) you ag << 19 // * based on the Program) you indicate your acceptance of this *
22 // * use in resulting scientific publicati << 20 // * statement, and all its terms. *
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* 21 // ********************************************************************
25 // 22 //
26 // 23 //
>> 24 // $Id: G4HepRepFileSceneHandler.cc,v 1.7 2002/02/03 22:22:58 perl Exp $
>> 25 // GEANT4 tag $Name: geant4-04-01 $
27 // 26 //
>> 27 //
28 // Joseph Perl 27th January 2002 28 // Joseph Perl 27th January 2002
29 // A base class for a scene handler to export 29 // A base class for a scene handler to export geometry and trajectories
30 // to the HepRep xml file format. 30 // to the HepRep xml file format.
31 31
32 #include "G4HepRepFileSceneHandler.hh" 32 #include "G4HepRepFileSceneHandler.hh"
33 #include "G4HepRepFile.hh" 33 #include "G4HepRepFile.hh"
34 #include "G4HepRepMessenger.hh" <<
35 #include "G4UIcommand.hh" <<
36 34
37 #include "G4PhysicalConstants.hh" <<
38 #include "G4SystemOfUnits.hh" <<
39 #include "G4Version.hh" <<
40 #include "G4VSolid.hh" 35 #include "G4VSolid.hh"
41 #include "G4PhysicalVolumeModel.hh" 36 #include "G4PhysicalVolumeModel.hh"
42 #include "G4VPhysicalVolume.hh" 37 #include "G4VPhysicalVolume.hh"
43 #include "G4LogicalVolume.hh" 38 #include "G4LogicalVolume.hh"
44 #include "G4RotationMatrix.hh" <<
45 #include "G4Material.hh" 39 #include "G4Material.hh"
>> 40 #include "G4ModelingParameters.hh"
46 #include "G4Polymarker.hh" 41 #include "G4Polymarker.hh"
47 #include "G4Polyline.hh" 42 #include "G4Polyline.hh"
48 #include "G4Text.hh" 43 #include "G4Text.hh"
49 #include "G4Circle.hh" 44 #include "G4Circle.hh"
50 #include "G4Square.hh" 45 #include "G4Square.hh"
51 #include "G4Polyhedron.hh" 46 #include "G4Polyhedron.hh"
52 #include "G4VTrajectory.hh" << 47 #include "G4NURBS.hh"
53 #include "G4VTrajectoryPoint.hh" <<
54 #include "G4TrajectoriesModel.hh" <<
55 #include "G4VHit.hh" <<
56 #include "G4AttDef.hh" <<
57 #include "G4AttValue.hh" <<
58 #include "G4AttCheck.hh" <<
59 #include "G4VisManager.hh" <<
60 #include "G4VisTrajContext.hh" <<
61 #include "G4VTrajectoryModel.hh" <<
62 48
63 // HepRep << 49 //HepRep
64 #include "G4HepRepFileXMLWriter.hh" << 50 #include "HepRepXMLWriter.hh"
65 51
66 G4int G4HepRepFileSceneHandler::fSceneIdCount 52 G4int G4HepRepFileSceneHandler::fSceneIdCount = 0;
67 // Counter for HepRep scene handlers. 53 // Counter for HepRep scene handlers.
68 54
>> 55 G4int G4HepRepFileSceneHandler::fSceneCount = 0;
>> 56 // No. of extanct scene handlers.
>> 57
69 G4HepRepFileSceneHandler::G4HepRepFileSceneHan 58 G4HepRepFileSceneHandler::G4HepRepFileSceneHandler(G4VGraphicsSystem& system,
70 << 59 const G4String& name):
71 : G4VSceneHandler(system, fSceneIdCount++, n << 60 G4VSceneHandler(system, fSceneIdCount++, name),
>> 61 fCurrentDepth (0),
>> 62 fpCurrentPV (0),
>> 63 fpCurrentLV (0)
72 { 64 {
73 hepRepXMLWriter = ((G4HepRepFile*) (&system) << 65 fSceneCount++;
74 fileCounter = 0; <<
75 66
76 inPrimitives2D = false; << 67 hepRepXMLWriter = ((G4HepRepFile*)(&system))->GetHepRepXMLWriter();
77 warnedAbout3DText = false; << 68 fileCounter = 0;
78 warnedAbout2DMarkers = false; <<
79 haveVisible = false; <<
80 drawingTraj = false; <<
81 doneInitTraj = false; <<
82 drawingHit = false; <<
83 doneInitHit = false; <<
84 trajContext = 0; <<
85 trajAttValues = 0; <<
86 trajAttDefs = 0; <<
87 hitAttValues = 0; <<
88 hitAttDefs = 0; <<
89 } 69 }
90 70
91 G4HepRepFileSceneHandler::~G4HepRepFileSceneHa 71 G4HepRepFileSceneHandler::~G4HepRepFileSceneHandler() {}
92 72
93 void G4HepRepFileSceneHandler::BeginModeling() << 73 void G4HepRepFileSceneHandler::EstablishSpecials
94 { << 74 (G4PhysicalVolumeModel& pvModel) {
95 G4VisManager* visManager = G4VisManag << 75 pvModel.DefinePointersToWorkingSpace (&fCurrentDepth,
96 const G4VTrajectoryModel* model = visManager << 76 &fpCurrentPV,
97 trajContext = &model->Ge << 77 &fpCurrentLV);
>> 78 }
98 79
>> 80 void G4HepRepFileSceneHandler::BeginModeling() {
99 G4VSceneHandler::BeginModeling(); // Requir 81 G4VSceneHandler::BeginModeling(); // Required: see G4VSceneHandler.hh.
>> 82 // Force culling off...
>> 83 if (fpModel) {
>> 84 fpOriginalMP = fpModel->GetModelingParameters();
>> 85 if (fpOriginalMP) {
>> 86 fpNonCullingMP = new G4ModelingParameters(*fpOriginalMP);
>> 87 fpNonCullingMP->SetCulling(false);
>> 88 fpModel->SetModelingParameters(fpNonCullingMP);
>> 89 }
>> 90 }
100 } 91 }
101 92
102 void G4HepRepFileSceneHandler::EndModeling() << 93 void G4HepRepFileSceneHandler::EndModeling() {
103 { << 94 if (fpModel && fpOriginalMP) {
>> 95 fpModel->SetModelingParameters(fpOriginalMP);
>> 96 delete fpNonCullingMP;
>> 97 }
104 G4VSceneHandler::EndModeling(); // Required 98 G4VSceneHandler::EndModeling(); // Required: see G4VSceneHandler.hh.
105 } 99 }
106 100
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 101 #ifdef G4HEPREPFILEDEBUG
127 void G4HepRepFileSceneHandler::PrintThings() << 102 void G4HepRepFileSceneHandler::PrintThings() {
128 { << 103 G4cout <<
129 G4cout << " with transformation " << fObjec << 104 " with transformation "
130 G4PhysicalVolumeModel* pPVModel = << 105 << (void*)fpObjectTransformation;
131 dynamic_cast<G4PhysicalVolumeModel*>(fpMod << 106 if (fpCurrentPV) {
132 if(pPVModel) << 107 G4cout <<
133 { << 108 "\n current physical volume: "
134 G4VPhysicalVolume* pCurrentPV = pPVModel-> << 109 << fpCurrentPV->GetName() <<
135 G4LogicalVolume* pCurrentLV = pPVModel-> << 110 "\n current logical volume: "
136 G4int currentDepth = pPVModel-> << 111 << fpCurrentLV->GetName() <<
137 G4cout << "\n current physical volume: " << 112 "\n current depth of geometry tree: "
138 << "\n current logical volume: " < << 113 << fCurrentDepth;
139 << "\n current depth of geometry t <<
140 } 114 }
141 G4cout << G4endl; 115 G4cout << G4endl;
142 } 116 }
143 #endif 117 #endif
144 118
145 void G4HepRepFileSceneHandler::AddSolid(const << 119 void G4HepRepFileSceneHandler::AddThis(const G4Box& box) {
146 { <<
147 #ifdef G4HEPREPFILEDEBUG 120 #ifdef G4HEPREPFILEDEBUG
148 G4cout << "G4HepRepFileSceneHandler::AddSoli << 121 G4cout <<
149 << box.GetName() << G4endl; << 122 "G4HepRepFileSceneHandler::AddThis(const G4Box& box) called for "
>> 123 << box.GetName()
>> 124 << G4endl;
150 PrintThings(); 125 PrintThings();
151 #endif 126 #endif
152 << 127 G4VSceneHandler::AddThis(box); // Invoke default action.
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 } 128 }
203 129
204 void G4HepRepFileSceneHandler::AddSolid(const << 130 void G4HepRepFileSceneHandler::AddThis(const G4Cons& cons) {
205 { <<
206 #ifdef G4HEPREPFILEDEBUG 131 #ifdef G4HEPREPFILEDEBUG
207 G4cout << "G4HepRepFileSceneHandler::AddSoli << 132 G4cout <<
208 << cons.GetName() << G4endl; << 133 "G4HepRepFileSceneHandler::AddThis(const G4Cons& cons) called for "
>> 134 << cons.GetName()
>> 135 << G4endl;
209 PrintThings(); 136 PrintThings();
210 #endif 137 #endif
211 << 138 G4VSceneHandler::AddThis(cons); // Invoke default action.
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 } 139 }
274 140
275 void G4HepRepFileSceneHandler::AddSolid(const << 141 void G4HepRepFileSceneHandler::AddThis(const G4Tubs& tubs) {
276 { <<
277 #ifdef G4HEPREPFILEDEBUG 142 #ifdef G4HEPREPFILEDEBUG
278 G4cout << "G4HepRepFileSceneHandler::AddSoli << 143 G4cout <<
279 << tubs.GetName() << G4endl; << 144 "G4HepRepFileSceneHandler::AddThis(const G4Tubs& tubs) called for "
>> 145 << tubs.GetName()
>> 146 << G4endl;
280 PrintThings(); 147 PrintThings();
281 #endif 148 #endif
282 << 149 G4VSceneHandler::AddThis(tubs); // Invoke default action.
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 } 150 }
348 151
349 void G4HepRepFileSceneHandler::AddSolid(const << 152 void G4HepRepFileSceneHandler::AddThis(const G4Trd& trd) {
350 { <<
351 #ifdef G4HEPREPFILEDEBUG 153 #ifdef G4HEPREPFILEDEBUG
352 G4cout << "G4HepRepFileSceneHandler::AddSoli << 154 G4cout <<
353 << trd.GetName() << G4endl; << 155 "G4HepRepFileSceneHandler::AddThis(const G4Trd& trd) called for "
>> 156 << trd.GetName()
>> 157 << G4endl;
354 PrintThings(); 158 PrintThings();
355 #endif 159 #endif
356 << 160 G4VSceneHandler::AddThis(trd); // Invoke default action.
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 } 161 }
409 162
410 void G4HepRepFileSceneHandler::AddSolid(const << 163 void G4HepRepFileSceneHandler::AddThis(const G4Trap& trap) {
411 { <<
412 #ifdef G4HEPREPFILEDEBUG 164 #ifdef G4HEPREPFILEDEBUG
413 G4cout << "G4HepRepFileSceneHandler::AddSoli << 165 G4cout <<
414 << trap.GetName() << G4endl; << 166 "G4HepRepFileSceneHandler::AddThis(const G4Trap& trap) called for "
>> 167 << trap.GetName()
>> 168 << G4endl;
415 PrintThings(); 169 PrintThings();
416 #endif 170 #endif
417 G4VSceneHandler::AddSolid(trap); // Invoke << 171 G4VSceneHandler::AddThis(trap); // Invoke default action.
418 } 172 }
419 173
420 void G4HepRepFileSceneHandler::AddSolid(const << 174 void G4HepRepFileSceneHandler::AddThis(const G4Sphere& sphere) {
421 { <<
422 #ifdef G4HEPREPFILEDEBUG 175 #ifdef G4HEPREPFILEDEBUG
423 G4cout << 176 G4cout <<
424 << "G4HepRepFileSceneHandler::AddSolid(con << 177 "G4HepRepFileSceneHandler::AddThis(const G4Sphere& sphere) called for "
425 << sphere.GetName() << G4endl; << 178 << sphere.GetName()
>> 179 << G4endl;
426 PrintThings(); 180 PrintThings();
427 #endif 181 #endif
428 G4VSceneHandler::AddSolid(sphere); // Invok << 182 G4VSceneHandler::AddThis(sphere); // Invoke default action.
429 } 183 }
430 184
431 void G4HepRepFileSceneHandler::AddSolid(const << 185 void G4HepRepFileSceneHandler::AddThis(const G4Para& para) {
432 { <<
433 #ifdef G4HEPREPFILEDEBUG 186 #ifdef G4HEPREPFILEDEBUG
434 G4cout << "G4HepRepFileSceneHandler::AddSoli << 187 G4cout <<
435 << para.GetName() << G4endl; << 188 "G4HepRepFileSceneHandler::AddThis(const G4Para& para) called for "
>> 189 << para.GetName()
>> 190 << G4endl;
436 PrintThings(); 191 PrintThings();
437 #endif 192 #endif
438 G4VSceneHandler::AddSolid(para); // Invoke << 193 G4VSceneHandler::AddThis(para); // Invoke default action.
439 } 194 }
440 195
441 void G4HepRepFileSceneHandler::AddSolid(const << 196 void G4HepRepFileSceneHandler::AddThis(const G4Torus& torus) {
442 { <<
443 #ifdef G4HEPREPFILEDEBUG 197 #ifdef G4HEPREPFILEDEBUG
444 G4cout << 198 G4cout <<
445 << "G4HepRepFileSceneHandler::AddSolid(con << 199 "G4HepRepFileSceneHandler::AddThis(const G4Torus& torus) called for "
446 << torus.GetName() << G4endl; << 200 << torus.GetName()
>> 201 << G4endl;
447 PrintThings(); 202 PrintThings();
448 #endif 203 #endif
449 G4VSceneHandler::AddSolid(torus); // Invoke << 204 G4VSceneHandler::AddThis(torus); // Invoke default action.
450 } 205 }
451 206
452 void G4HepRepFileSceneHandler::AddSolid(const << 207 void G4HepRepFileSceneHandler::AddThis(const G4Polycone& polycone) {
453 { <<
454 #ifdef G4HEPREPFILEDEBUG 208 #ifdef G4HEPREPFILEDEBUG
455 G4cout << "G4HepRepFileSceneHandler::AddSoli << 209 G4cout <<
456 "called for " << 210 "G4HepRepFileSceneHandler::AddThis(const G4Polycone& polycone) called for "
457 << polycone.GetName() << G4endl; << 211 << polycone.GetName()
>> 212 << G4endl;
458 PrintThings(); 213 PrintThings();
459 #endif 214 #endif
460 G4VSceneHandler::AddSolid(polycone); // Inv << 215 G4VSceneHandler::AddThis(polycone); // Invoke default action.
461 } 216 }
462 217
463 void G4HepRepFileSceneHandler::AddSolid(const << 218 void G4HepRepFileSceneHandler::AddThis(const G4Polyhedra& polyhedra) {
464 { <<
465 #ifdef G4HEPREPFILEDEBUG <<
466 G4cout << "G4HepRepFileSceneHandler::AddSoli <<
467 "called for " <<
468 << polyhedra.GetName() << G4endl; <<
469 PrintThings(); <<
470 #endif <<
471 G4VSceneHandler::AddSolid(polyhedra); // In <<
472 } <<
473 <<
474 void G4HepRepFileSceneHandler::AddSolid(const <<
475 { <<
476 #ifdef G4HEPREPFILEDEBUG 219 #ifdef G4HEPREPFILEDEBUG
477 G4cout << "G4HepRepFileSceneHandler::AddSoli << 220 G4cout <<
478 << orb.GetName() << G4endl; << 221 "G4HepRepFileSceneHandler::AddThis(const G4Polyhedra& polyhedra) called for "
>> 222 << polyhedra.GetName()
>> 223 << G4endl;
479 PrintThings(); 224 PrintThings();
480 #endif 225 #endif
481 G4VSceneHandler::AddSolid(orb); // Invoke d << 226 G4VSceneHandler::AddThis(polyhedra); // Invoke default action.
482 } 227 }
483 228
484 void G4HepRepFileSceneHandler::AddSolid(const << 229 void G4HepRepFileSceneHandler::AddThis(const G4VSolid& solid) {
485 { <<
486 #ifdef G4HEPREPFILEDEBUG 230 #ifdef G4HEPREPFILEDEBUG
487 G4cout << "G4HepRepFileSceneHandler::AddSoli << 231 G4cout <<
488 "called for " << 232 "G4HepRepFileSceneHandler::AddThis(const G4Solid& solid) called for "
489 << ellipsoid.GetName() << G4endl; << 233 << solid.GetName()
>> 234 << G4endl;
490 PrintThings(); 235 PrintThings();
491 #endif 236 #endif
492 G4VSceneHandler::AddSolid(ellipsoid); // In << 237 G4VSceneHandler::AddThis(solid); // Invoke default action.
493 } 238 }
494 239
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 240
506 void G4HepRepFileSceneHandler::AddSolid(const << 241 void G4HepRepFileSceneHandler::AddPrimitive(const G4Polyline& polyline) {
507 { <<
508 #ifdef G4HEPREPFILEDEBUG 242 #ifdef G4HEPREPFILEDEBUG
509 G4cout << 243 G4cout <<
510 << "G4HepRepFileSceneHandler::AddSolid(con << 244 "G4HepRepFileSceneHandler::AddPrimitive(const G4Polyline& polyline) called:"
511 << solid.GetName() << G4endl; << 245 "\n polyline: " << polyline
>> 246 << G4endl;
512 PrintThings(); 247 PrintThings();
513 #endif 248 #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 249
731 // Specify attributes common to all trajec << 250 AddHepRepInstance("Line",polyline);
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 251
745 // Loop over all points on this trajectory << 252 hepRepXMLWriter->addPrimitive();
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 253
800 // Each trajectory point is made of a si << 254 for (size_t i=0; i < polyline.size(); i++) {
801 hepRepXMLWriter->addPrimitive(); << 255 G4Point3D vertex = (*fpObjectTransformation) * polyline[i];
802 G4Point3D vertex = aTrajectoryPoint->Get <<
803 hepRepXMLWriter->addPoint(vertex.x(), ve 256 hepRepXMLWriter->addPoint(vertex.x(), vertex.y(), vertex.z());
804 } <<
805 } <<
806 <<
807 // Draw Auxiliary Points <<
808 if(trajContext->GetDrawAuxPts()) <<
809 { <<
810 if(!doneInitTraj) <<
811 InitTrajectory(); <<
812 // Create Trajectory Points as a subType o <<
813 // Note that we should create this heprep <<
814 // points. This allows the user to tell th <<
815 // odd) rather than that they were omitted <<
816 previousName = hepRepXMLWriter->prevTypeNa <<
817 hepRepXMLWriter->addType("Trajectory Auxil <<
818 <<
819 float redness; <<
820 float greenness; <<
821 float blueness; <<
822 G4int markSize; <<
823 G4bool visible; <<
824 G4bool square; <<
825 G4Colour colour = trajContext->GetAuxPtsCo <<
826 redness = colour.GetRed(); <<
827 greenness = colour.GetGreen(); <<
828 blueness = colour.GetBlue(); <<
829 markSize = (G4int) trajContext->Get <<
830 visible = (G4int) trajContext->Get <<
831 square = (trajContext->GetAuxPtsT <<
832 <<
833 // Avoiding drawing anything black on blac <<
834 if(redness == 0. && greenness == 0. && blu <<
835 { <<
836 redness = 1.; <<
837 greenness = 1.; <<
838 blueness = 1.; <<
839 } <<
840 <<
841 // Specify attributes common to all trajec <<
842 if(strcmp("Trajectory Auxiliary Points", p <<
843 { <<
844 hepRepXMLWriter->addAttValue("DrawAs", " <<
845 hepRepXMLWriter->addAttValue("MarkColor" <<
846 hepRepXMLWriter->addAttValue("MarkSize", <<
847 hepRepXMLWriter->addAttValue("Layer", 11 <<
848 hepRepXMLWriter->addAttValue("Visibility <<
849 if(square) <<
850 hepRepXMLWriter->addAttValue("MarkName <<
851 else <<
852 hepRepXMLWriter->addAttValue("MarkName <<
853 } <<
854 <<
855 // Loop over all points on this trajectory <<
856 for(i = 0; i < traj.GetPointEntries(); i++ <<
857 { <<
858 G4VTrajectoryPoint* aTrajectoryPoint = t <<
859 <<
860 // Each point is a separate instance of <<
861 hepRepXMLWriter->addInstance(); <<
862 <<
863 // Pointers to hold trajectory point att <<
864 std::vector<G4AttValue>* rawPointAttValu <<
865 aTrajectoryPoint->CreateAttValues(); <<
866 std::vector<G4AttValue>* pointAttValues <<
867 std::map<G4String, G4AttDef>* pointAttDe <<
868 new std::map<G4String, G4AttDef>; <<
869 <<
870 // Get trajectory point attributes and d <<
871 // style (uniform units, 3Vectors decomp <<
872 if(rawPointAttValues) <<
873 { <<
874 G4bool error = <<
875 G4AttCheck(rawPointAttValues, aTraje <<
876 .Standard(pointAttValues, pointAtt <<
877 if(error) <<
878 { <<
879 G4cout <<
880 << "G4HepRepFileSceneHandler::AddC <<
881 "\nERROR found during conversio <<
882 << G4endl; <<
883 } <<
884 <<
885 // Write out point attribute values. <<
886 if(pointAttValues) <<
887 { <<
888 for(iAttVal = pointAttValues->begin( <<
889 iAttVal != pointAttValues->end() <<
890 // Do not write out the Aux or Pos <<
891 // to the HepRep rule that each ob <<
892 // a given AttValue. Both of these <<
893 // actual position information of <<
894 if(strcmp(iAttVal->GetName(), "Aux <<
895 strcmp(iAttVal->GetName(), "Aux <<
896 strcmp(iAttVal->GetName(), "Aux <<
897 strcmp(iAttVal->GetName(), "Pos <<
898 strcmp(iAttVal->GetName(), "Pos <<
899 strcmp(iAttVal->GetName(), "Pos <<
900 hepRepXMLWriter->addAttValue(iAt <<
901 iAt <<
902 } <<
903 } <<
904 <<
905 // Clean up point attributes. <<
906 delete pointAttDefs; <<
907 delete pointAttValues; <<
908 delete rawPointAttValues; <<
909 <<
910 // Each trajectory point is made of a si <<
911 G4Point3D vertex = aTrajectoryPoint->Get <<
912 <<
913 // Loop over auxiliary points associated <<
914 const std::vector<G4ThreeVector>* auxili <<
915 aTrajectoryPoint->GetAuxiliaryPoints() <<
916 if(0 != auxiliaries) <<
917 { <<
918 for(size_t iAux = 0; iAux < auxiliarie <<
919 { <<
920 const G4ThreeVector auxPos((*auxilia <<
921 hepRepXMLWriter->addPrimitive(); <<
922 hepRepXMLWriter->addPoint(auxPos.x() <<
923 } <<
924 } <<
925 } <<
926 } <<
927 } <<
928 <<
929 void G4HepRepFileSceneHandler::AddCompound(con <<
930 { <<
931 #ifdef G4HEPREPFILEDEBUG <<
932 G4cout << "G4HepRepFileSceneHandler::AddComp <<
933 #endif <<
934 <<
935 // Pointers to hold hit attribute values and <<
936 std::vector<G4AttValue>* rawHitAttValues = h <<
937 hitAttValues = n <<
938 hitAttDefs = n <<
939 <<
940 // Iterators to use with attribute values an <<
941 std::vector<G4AttValue>::iterator iAttVal; <<
942 std::map<G4String, G4AttDef>::const_iterator <<
943 <<
944 // Get hit attributes and definitions in sta <<
945 // (uniform units, 3Vectors decomposed). <<
946 if(rawHitAttValues) <<
947 { <<
948 G4bool error = G4AttCheck(rawHitAttValues, <<
949 .Standard(hitAttValues, h <<
950 if(error) <<
951 { <<
952 G4cout << "G4HepRepFileSceneHandler::Add <<
953 "\nERROR found during conversi <<
954 << G4endl; <<
955 } <<
956 #ifdef G4HEPREPFILEDEBUG <<
957 G4cout << "G4HepRepFileSceneHandler::AddCo <<
958 "attributes:\n" <<
959 << G4AttCheck(hitAttValues, hitAttD <<
960 #endif <<
961 delete rawHitAttValues; <<
962 } <<
963 <<
964 // Open the HepRep output file if it is not <<
965 CheckFileOpen(); <<
966 <<
967 // Add the Event Data Type if it hasn't alre <<
968 if(strcmp("Event Data", hepRepXMLWriter->pre <<
969 { <<
970 hepRepXMLWriter->addType("Event Data", 0); <<
971 hepRepXMLWriter->addInstance(); <<
972 } <<
973 <<
974 // Find out the current HitType. <<
975 G4String hitType = "Hits"; <<
976 if(hitAttValues) <<
977 { <<
978 G4bool found = false; <<
979 for(iAttVal = hitAttValues->begin(); <<
980 iAttVal != hitAttValues->end() && !fou <<
981 { <<
982 if(strcmp(iAttVal->GetName(), "HitType") <<
983 { <<
984 hitType = iAttVal->GetValue(); <<
985 found = true; <<
986 } <<
987 } <<
988 } <<
989 <<
990 // Add the Hits Type. <<
991 G4String previousName = hepRepXMLWriter->pre <<
992 hepRepXMLWriter->addType(hitType, 1); <<
993 <<
994 // If this is the first hit of this event, <<
995 // specify attribute values common to all hi <<
996 if(strcmp(hitType, previousName) != 0) <<
997 { <<
998 hepRepXMLWriter->addAttValue("Layer", 130) <<
999 <<
1000 // Take all Hit attDefs from first hit. <<
1001 // Would rather be able to get these attD <<
1002 // from any particular hit, but don't kno <<
1003 // attribute definitions. <<
1004 if(hitAttValues && hitAttDefs) <<
1005 { <<
1006 for(iAttVal = hitAttValues->begin(); iA <<
1007 ++iAttVal) <<
1008 { <<
1009 iAttDef = hitAttDefs->find(iAttVal->G <<
1010 if(iAttDef != hitAttDefs->end()) <<
1011 { <<
1012 // Protect against incorrect use of <<
1013 // than the standard ones will be c <<
1014 // category. <<
1015 G4String category = iAttDef->second <<
1016 if(strcmp(category, "Draw") != 0 && <<
1017 strcmp(category, "Physics") != 0 <<
1018 strcmp(category, "Association") <<
1019 strcmp(category, "PickAction") ! <<
1020 category = "Physics"; <<
1021 hepRepXMLWriter->addAttDef(iAttVal- <<
1022 iAttDef- <<
1023 iAttDef- <<
1024 } <<
1025 } <<
1026 } <<
1027 } // end of special treatment for when thi <<
1028 <<
1029 // Now that we have written out all of the <<
1030 // hit's particulars, call base class to de <<
1031 drawingHit = true; <<
1032 doneInitHit = false; <<
1033 G4VSceneHandler::AddCompound(hit); // Invo <<
1034 drawingHit = false; <<
1035 } <<
1036 <<
1037 void G4HepRepFileSceneHandler::InitTrajectory <<
1038 { <<
1039 if(!doneInitTraj) <<
1040 { <<
1041 // For every trajectory, add an instance <<
1042 hepRepXMLWriter->addInstance(); <<
1043 <<
1044 // Write out the trajectory's attribute v <<
1045 if(trajAttValues) <<
1046 { <<
1047 std::vector<G4AttValue>::iterator iAttV <<
1048 for(iAttVal = trajAttValues->begin(); i <<
1049 ++iAttVal) <<
1050 hepRepXMLWriter->addAttValue(iAttVal- <<
1051 delete trajAttValues; <<
1052 } <<
1053 <<
1054 // Clean up trajectory attributes. <<
1055 if(trajAttDefs) <<
1056 delete trajAttDefs; <<
1057 <<
1058 doneInitTraj = true; <<
1059 } <<
1060 } <<
1061 <<
1062 void G4HepRepFileSceneHandler::InitHit() <<
1063 { <<
1064 if(!doneInitHit) <<
1065 { <<
1066 // For every hit, add an instance of Type <<
1067 hepRepXMLWriter->addInstance(); <<
1068 <<
1069 // Write out the hit's attribute values. <<
1070 if(hitAttValues) <<
1071 { <<
1072 std::vector<G4AttValue>::iterator iAttV <<
1073 for(iAttVal = hitAttValues->begin(); iA <<
1074 ++iAttVal) <<
1075 hepRepXMLWriter->addAttValue(iAttVal- <<
1076 delete hitAttValues; <<
1077 } <<
1078 <<
1079 // Clean up hit attributes. <<
1080 if(hitAttDefs) <<
1081 delete hitAttDefs; <<
1082 <<
1083 doneInitHit = true; <<
1084 } 257 }
1085 } 258 }
1086 259
1087 void G4HepRepFileSceneHandler::AddPrimitive(c <<
1088 { <<
1089 #ifdef G4HEPREPFILEDEBUG <<
1090 G4cout << "G4HepRepFileSceneHandler::AddPri <<
1091 "polyline) called:" <<
1092 "\n polyline: " <<
1093 << polyline << G4endl; <<
1094 PrintThings(); <<
1095 #endif <<
1096 <<
1097 G4HepRepMessenger* messenger = G4HepRepMess <<
1098 <<
1099 if(fpVisAttribs && (fpVisAttribs->IsVisible <<
1100 messenger->getCullInvisibles()) <<
1101 return; <<
1102 <<
1103 if(inPrimitives2D) <<
1104 { <<
1105 if(!warnedAbout2DMarkers) <<
1106 { <<
1107 G4cout << "HepRepFile does not currentl <<
1108 warnedAbout2DMarkers = true; <<
1109 } <<
1110 return; <<
1111 } <<
1112 <<
1113 if(drawingTraj) <<
1114 InitTrajectory(); <<
1115 260
1116 if(drawingHit) << 261 void G4HepRepFileSceneHandler::AddPrimitive (const G4Polymarker& line) {
1117 InitHit(); <<
1118 <<
1119 haveVisible = true; <<
1120 AddHepRepInstance("Line", polyline); <<
1121 <<
1122 hepRepXMLWriter->addPrimitive(); <<
1123 <<
1124 for(size_t i = 0; i < polyline.size(); i++) <<
1125 { <<
1126 G4Point3D vertex = (fObjectTransformation <<
1127 hepRepXMLWriter->addPoint(vertex.x(), ver <<
1128 } <<
1129 } <<
1130 <<
1131 void G4HepRepFileSceneHandler::AddPrimitive(c <<
1132 { <<
1133 #ifdef G4HEPREPFILEDEBUG 262 #ifdef G4HEPREPFILEDEBUG
1134 G4cout << 263 G4cout <<
1135 << "G4HepRepFileSceneHandler::AddPrimitiv << 264 "G4HepRepFileSceneHandler::AddPrimitive(const G4Polymarker& line) called"
1136 << G4endl; << 265 << G4endl;
1137 PrintThings(); 266 PrintThings();
1138 #endif 267 #endif
1139 268
1140 G4HepRepMessenger* messenger = G4HepRepMess << 269 AddHepRepInstance("Point",line);
1141 <<
1142 if(fpVisAttribs && (fpVisAttribs->IsVisible <<
1143 messenger->getCullInvisibles()) <<
1144 return; <<
1145 <<
1146 if(inPrimitives2D) <<
1147 { <<
1148 if(!warnedAbout2DMarkers) <<
1149 { <<
1150 G4cout << "HepRepFile does not currentl <<
1151 warnedAbout2DMarkers = true; <<
1152 } <<
1153 return; <<
1154 } <<
1155 <<
1156 MarkerSizeType sizeType; <<
1157 G4double size = GetMarkerSize(line, sizeTyp <<
1158 if(sizeType == world) <<
1159 size = 4.; <<
1160 <<
1161 if(drawingTraj) <<
1162 return; <<
1163 <<
1164 if(drawingHit) <<
1165 InitHit(); <<
1166 <<
1167 haveVisible = true; <<
1168 AddHepRepInstance("Point", line); <<
1169 270
1170 hepRepXMLWriter->addAttValue("MarkName", "D 271 hepRepXMLWriter->addAttValue("MarkName", "Dot");
1171 hepRepXMLWriter->addAttValue("MarkSize", (G << 272 hepRepXMLWriter->addAttValue("MarkSize", 4);
1172 273
1173 hepRepXMLWriter->addPrimitive(); 274 hepRepXMLWriter->addPrimitive();
1174 << 275
1175 for(size_t i = 0; i < line.size(); i++) << 276 for (size_t i=0; i < line.size(); i++) {
1176 { << 277 G4Point3D vertex = (*fpObjectTransformation) * line[i];
1177 G4Point3D vertex = (fObjectTransformation << 278 hepRepXMLWriter->addPoint(vertex.x(), vertex.y(), vertex.z());
1178 hepRepXMLWriter->addPoint(vertex.x(), ver <<
1179 } 279 }
1180 } 280 }
1181 281
1182 void G4HepRepFileSceneHandler::AddPrimitive(c << 282 void G4HepRepFileSceneHandler::AddPrimitive(const G4Text& text) {
1183 { <<
1184 #ifdef G4HEPREPFILEDEBUG 283 #ifdef G4HEPREPFILEDEBUG
1185 G4cout << "G4HepRepFileSceneHandler::AddPri << 284 G4cout <<
1186 "\n text: " << 285 "G4HepRepFileSceneHandler::AddPrimitive(const G4Text& text) called:"
1187 << text.GetText() << G4endl; << 286 "\n text: " << text.GetText()
>> 287 << G4endl;
1188 PrintThings(); 288 PrintThings();
1189 #endif 289 #endif
1190 << 290 G4cout << "G4HepRepFileSceneHandler::AddPrimitive G4Text : not yet implemented. " << G4endl;
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 } 291 }
1243 292
1244 void G4HepRepFileSceneHandler::AddPrimitive(c << 293 void G4HepRepFileSceneHandler::AddPrimitive(const G4Circle& circle) {
1245 { <<
1246 #ifdef G4HEPREPFILEDEBUG 294 #ifdef G4HEPREPFILEDEBUG
1247 G4cout << 295 G4cout <<
1248 << "G4HepRepFileSceneHandler::AddPrimitiv << 296 "G4HepRepFileSceneHandler::AddPrimitive(const G4Circle& circle) called:"
1249 "\n radius: " << 297 "\n radius: " << circle.GetWorldRadius()
1250 << circle.GetWorldRadius() << G4endl; << 298 << G4endl;
1251 PrintThings(); 299 PrintThings();
1252 #endif 300 #endif
1253 301
1254 G4HepRepMessenger* messenger = G4HepRepMess << 302 AddHepRepInstance("Point",circle);
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 303
1284 hepRepXMLWriter->addAttValue("MarkName", "D 304 hepRepXMLWriter->addAttValue("MarkName", "Dot");
1285 hepRepXMLWriter->addAttValue("MarkSize", (G << 305 hepRepXMLWriter->addAttValue("MarkSize", 4);
1286 << 306
1287 hepRepXMLWriter->addPrimitive(); 307 hepRepXMLWriter->addPrimitive();
1288 308
1289 G4Point3D center = (fObjectTransformation) << 309 G4Point3D center = (*fpObjectTransformation) * circle.GetPosition();
1290 hepRepXMLWriter->addPoint(center.x(), cente 310 hepRepXMLWriter->addPoint(center.x(), center.y(), center.z());
1291 } 311 }
1292 312
1293 void G4HepRepFileSceneHandler::AddPrimitive(c << 313 void G4HepRepFileSceneHandler::AddPrimitive(const G4Square& square) {
1294 { <<
1295 #ifdef G4HEPREPFILEDEBUG 314 #ifdef G4HEPREPFILEDEBUG
1296 G4cout << 315 G4cout <<
1297 << "G4HepRepFileSceneHandler::AddPrimitiv << 316 "G4HepRepFileSceneHandler::AddPrimitive(const G4Square& square) called:"
1298 "\n side: " << 317 "\n side: " << square.GetWorldRadius()
1299 << square.GetWorldRadius() << G4endl; << 318 << G4endl;
1300 PrintThings(); 319 PrintThings();
1301 #endif 320 #endif
1302 321
1303 G4HepRepMessenger* messenger = G4HepRepMess << 322 AddHepRepInstance("Point",square);
1304 <<
1305 if(fpVisAttribs && (fpVisAttribs->IsVisible <<
1306 messenger->getCullInvisibles()) <<
1307 return; <<
1308 <<
1309 if(inPrimitives2D) <<
1310 { <<
1311 if(!warnedAbout2DMarkers) <<
1312 { <<
1313 G4cout << "HepRepFile does not currentl <<
1314 warnedAbout2DMarkers = true; <<
1315 } <<
1316 return; <<
1317 } <<
1318 <<
1319 MarkerSizeType sizeType; <<
1320 G4double size = GetMarkerSize(square, sizeT <<
1321 if(sizeType == world) <<
1322 size = 4.; <<
1323 <<
1324 if(drawingTraj) <<
1325 return; <<
1326 <<
1327 if(drawingHit) <<
1328 InitHit(); <<
1329 <<
1330 haveVisible = true; <<
1331 AddHepRepInstance("Point", square); <<
1332 323
1333 hepRepXMLWriter->addAttValue("MarkName", "S 324 hepRepXMLWriter->addAttValue("MarkName", "Square");
1334 hepRepXMLWriter->addAttValue("MarkSize", (G << 325 hepRepXMLWriter->addAttValue("MarkSize", 4);
1335 326
1336 hepRepXMLWriter->addPrimitive(); 327 hepRepXMLWriter->addPrimitive();
1337 328
1338 G4Point3D center = (fObjectTransformation) << 329 G4Point3D center = (*fpObjectTransformation) * square.GetPosition();
1339 hepRepXMLWriter->addPoint(center.x(), cente 330 hepRepXMLWriter->addPoint(center.x(), center.y(), center.z());
1340 } 331 }
1341 332
1342 void G4HepRepFileSceneHandler::AddPrimitive(c << 333 void G4HepRepFileSceneHandler::AddPrimitive(const G4Polyhedron& polyhedron) {
1343 { <<
1344 #ifdef G4HEPREPFILEDEBUG 334 #ifdef G4HEPREPFILEDEBUG
1345 G4cout << "G4HepRepFileSceneHandler::AddPri << 335 G4cout <<
1346 "polyhedron) called." << 336 "G4HepRepFileSceneHandler::AddPrimitive(const G4Polyhedron& polyhedron) called."
1347 << G4endl; << 337 << G4endl;
1348 PrintThings(); 338 PrintThings();
1349 #endif 339 #endif
1350 340
1351 G4HepRepMessenger* messenger = G4HepRepMess << 341 AddHepRepInstance("Polygon",polyhedron);
1352 <<
1353 if(fpVisAttribs && (fpVisAttribs->IsVisible <<
1354 messenger->getCullInvisibles()) <<
1355 return; <<
1356 <<
1357 if(polyhedron.GetNoFacets() == 0) <<
1358 return; <<
1359 342
1360 if(drawingTraj) << 343 if(polyhedron.GetNoFacets()==0)return;
1361 return; <<
1362 <<
1363 if(drawingHit) <<
1364 InitHit(); <<
1365 <<
1366 haveVisible = true; <<
1367 AddHepRepInstance("Polygon", polyhedron); <<
1368 344
1369 G4Normal3D surfaceNormal; 345 G4Normal3D surfaceNormal;
1370 G4Point3D vertex; 346 G4Point3D vertex;
1371 347
1372 G4bool notLastFace; 348 G4bool notLastFace;
1373 do << 349 do {
1374 { << 350 hepRepXMLWriter->addPrimitive();
1375 hepRepXMLWriter->addPrimitive(); << 351 notLastFace = polyhedron.GetNextNormal (surfaceNormal);
1376 notLastFace = polyhedron.GetNextNormal(su <<
1377 <<
1378 G4int edgeFlag = 1; <<
1379 G4bool notLastEdge; <<
1380 do <<
1381 { <<
1382 notLastEdge = polyhedron.GetNextVertex( <<
1383 vertex = (fObjectTransformation) * <<
1384 hepRepXMLWriter->addPoint(vertex.x(), v <<
1385 } while(notLastEdge); <<
1386 } while(notLastFace); <<
1387 } <<
1388 352
1389 G4HepRepFileXMLWriter* G4HepRepFileSceneHandl << 353 G4int edgeFlag = 1;
1390 { << 354 G4bool notLastEdge;
1391 return hepRepXMLWriter; << 355 do {
>> 356 notLastEdge = polyhedron.GetNextVertex (vertex, edgeFlag);
>> 357 vertex = (*fpObjectTransformation) * vertex;
>> 358 hepRepXMLWriter->addPoint(vertex.x(), vertex.y(), vertex.z());
>> 359 } while (notLastEdge);
>> 360 } while (notLastFace);
1392 } 361 }
1393 362
1394 void G4HepRepFileSceneHandler::AddHepRepInsta << 363 void G4HepRepFileSceneHandler::AddPrimitive(const G4NURBS& nurbs) {
1395 <<
1396 { <<
1397 #ifdef G4HEPREPFILEDEBUG 364 #ifdef G4HEPREPFILEDEBUG
1398 G4cout << "G4HepRepFileSceneHandler::AddHep << 365 G4cout <<
>> 366 "G4HepRepFileSceneHandler::AddPrimitive(const G4NURBS& nurbs) called."
>> 367 << G4endl;
>> 368 PrintThings();
1399 #endif 369 #endif
>> 370 G4cout << "G4HepRepFileSceneHandler::AddPrimitive G4NURBS : not implemented. " << G4endl;
>> 371 }
1400 372
1401 // Open the HepRep output file if it is not << 373 HepRepXMLWriter *G4HepRepFileSceneHandler::GetHepRepXMLWriter() {
1402 CheckFileOpen(); << 374 return hepRepXMLWriter;
1403 << 375 }
1404 G4VPhysicalVolume* pCurrentPV = 0; <<
1405 G4LogicalVolume* pCurrentLV = 0; <<
1406 G4int currentDepth = 0; <<
1407 G4PhysicalVolumeModel* pPVModel = <<
1408 dynamic_cast<G4PhysicalVolumeModel*>(fpMo <<
1409 if(pPVModel) <<
1410 { <<
1411 pCurrentPV = pPVModel->GetCurrentPV(); <<
1412 pCurrentLV = pPVModel->GetCurrentLV(); <<
1413 currentDepth = pPVModel->GetCurrentDepth( <<
1414 } <<
1415 376
>> 377 void G4HepRepFileSceneHandler::AddHepRepInstance(const char* primName,
>> 378 const G4Visible visible) {
1416 #ifdef G4HEPREPFILEDEBUG 379 #ifdef G4HEPREPFILEDEBUG
1417 G4cout << "pCurrentPV:" << pCurrentPV << 380 G4cout <<
1418 << ", readyForTransients:" << fReady << 381 "G4HepRepFileSceneHandler::AddHepRepInstance called."
>> 382 << G4endl;
1419 #endif 383 #endif
1420 384
1421 if(drawingTraj || drawingHit) << 385 if (!hepRepXMLWriter->isOpen) {
1422 { << 386 char* newFileSpec;
1423 // In this case, HepRep type, layer and i << 387 newFileSpec = new char [100];
1424 // in the AddCompound method. << 388 int length;
1425 } << 389 length = sprintf (newFileSpec, "%s%d%s","G4Data",fileCounter,".heprep");
1426 else if(fReadyForTransients) << 390 hepRepXMLWriter->open(newFileSpec);
1427 { << 391 fileCounter++;
1428 if(strcmp("Event Data", hepRepXMLWriter-> << 392
1429 { << 393 hepRepXMLWriter->addAttDef("LVol", "Logical Volume", "Physics","");
1430 hepRepXMLWriter->addType("Event Data", << 394 hepRepXMLWriter->addAttDef("Solid", "Solid Name", "Physics","");
1431 hepRepXMLWriter->addInstance(); << 395 hepRepXMLWriter->addAttDef("EType", "Entity Type", "Physics","");
1432 } << 396 hepRepXMLWriter->addAttDef("Material", "Material Name", "Physics","");
1433 << 397 hepRepXMLWriter->addAttDef("Density", "Material Density", "Physics","");
1434 // Applications have the option of either << 398 hepRepXMLWriter->addAttDef("State", "Material State", "Physics","");
1435 // and AddSolid(G4VHits&), or of just dec << 399 hepRepXMLWriter->addAttDef("Radlen", "Material Radiation Length", "Physics","");
1436 // primitives. In the former case, drawin << 400 }
1437 // include setting of physics attributes. << 401
1438 // older style of working, we end up draw << 402 // Handle Type declaration for Event Data.
1439 // where we have no access to physics att << 403 // Should be able to just test on fReadyForTransients, but this seems to
1440 // here. We can figure out that these ar << 404 // be falsely false if no geometry has yet been drawn.
1441 // exactly what these transients represen << 405 // So I test on both !fpCurrentPV (means no geometry has yet been drawn)
1442 // being used as in G4VTrajectory, hence << 406 // and fReadyForTransients.
1443 // Squares that come after we've seen tra << 407 if (!fpCurrentPV || fReadyForTransients) {
1444 // Circles that come after we've seen tra << 408 if (strcmp("Event Data",hepRepXMLWriter->prevTypeName[0])!=0) {
1445 // Other primitives are Hits << 409 hepRepXMLWriter->addType("Event Data",0);
1446 <<
1447 int layer; <<
1448 <<
1449 if(strcmp("Text", primName) == 0) <<
1450 { <<
1451 hepRepXMLWriter->addType("EventID", 1); <<
1452 } <<
1453 else <<
1454 { <<
1455 if(strcmp("Line", primName) == 0) <<
1456 { <<
1457 hepRepXMLWriter->addType("TransientPo <<
1458 layer = 100; <<
1459 } <<
1460 else <<
1461 { <<
1462 if(strcmp(hepRepXMLWriter->prevTypeNa <<
1463 0 && <<
1464 strcmp("Square", primName) == 0) <<
1465 { <<
1466 hepRepXMLWriter->addType("Auxiliary <<
1467 layer = 110; <<
1468 } <<
1469 else <<
1470 { <<
1471 if(strcmp(hepRepXMLWriter->prevType <<
1472 0 && <<
1473 strcmp("Circle", primName) == 0) <<
1474 { <<
1475 hepRepXMLWriter->addType("StepPoi <<
1476 layer = 120; <<
1477 } <<
1478 else <<
1479 { <<
1480 hepRepXMLWriter->addType("Hits", <<
1481 layer = 130; <<
1482 } <<
1483 } <<
1484 } <<
1485 hepRepXMLWriter->addAttValue("Layer", l <<
1486 } <<
1487 <<
1488 hepRepXMLWriter->addInstance(); <<
1489 <<
1490 // Handle Type declaration for Axes, Rule <<
1491 } <<
1492 else if(pCurrentPV == 0) <<
1493 { <<
1494 if(strcmp("AxesEtc", hepRepXMLWriter->pre <<
1495 { <<
1496 hepRepXMLWriter->addType("AxesEtc", 0); <<
1497 hepRepXMLWriter->addInstance(); 410 hepRepXMLWriter->addInstance();
1498 } 411 }
1499 412
1500 int layer; << 413 if (strcmp("Line",primName)==0)
1501 << 414 hepRepXMLWriter->addType("Trajectories",1);
1502 if(strcmp("Text", primName) == 0) << 415 else {
1503 { << 416 if (strcmp(hepRepXMLWriter->prevTypeName[1],"Trajectories")==0)
1504 hepRepXMLWriter->addType("Text", 1); << 417 hepRepXMLWriter->addType("Trajectory Points",2);
1505 } <<
1506 else <<
1507 { <<
1508 if(strcmp("Line", primName) == 0) <<
1509 { <<
1510 hepRepXMLWriter->addType("Polylines", <<
1511 layer = 100; <<
1512 } <<
1513 else 418 else
1514 { << 419 hepRepXMLWriter->addType("Trajectory Points",1);
1515 hepRepXMLWriter->addType("Points", 1) <<
1516 layer = 130; <<
1517 } <<
1518 hepRepXMLWriter->addAttValue("Layer", l <<
1519 } 420 }
1520 421
1521 hepRepXMLWriter->addInstance(); 422 hepRepXMLWriter->addInstance();
1522 << 423
1523 // Handle Type declaration for Detector G 424 // Handle Type declaration for Detector Geometry,
1524 // replacing G4's top geometry level name 425 // replacing G4's top geometry level name "worldPhysical" with the
1525 // name "Detector Geometry". 426 // name "Detector Geometry".
1526 } << 427 } else {
1527 else << 428 if (strcmp("Detector Geometry",hepRepXMLWriter->prevTypeName[0])!=0) {
1528 { << 429 hepRepXMLWriter->addType("Detector Geometry",0);
1529 // G4cout << "CurrentDepth" << currentDep <<
1530 // G4cout << "currentName" << pCurrentPV- <<
1531 if(strcmp("Detector Geometry", hepRepXMLW <<
1532 { <<
1533 // G4cout << "Adding Det Geom type" << <<
1534 hepRepXMLWriter->addType("Detector Geom <<
1535 hepRepXMLWriter->addInstance(); 430 hepRepXMLWriter->addInstance();
1536 } 431 }
1537 432
1538 // Re-insert any layers of the hierarchy << 433 // Re-insert any layers of the hierarchy that were removed by G4's culling process.
1539 // process. Don't bother checking if same << 434 while (hepRepXMLWriter->typeDepth < (fCurrentDepth-1)) {
1540 if(strcmp(hepRepXMLWriter->prevTypeName[c << 435 hepRepXMLWriter->addType("G4 Culled Layer", hepRepXMLWriter->typeDepth + 1);
1541 pCurrentPV->GetName()) != 0) << 436 hepRepXMLWriter->addInstance();
1542 { <<
1543 // G4cout << "Looking for mother of:" < <<
1544 typedef G4PhysicalVolumeModel::G4Physic <<
1545 typedef std::vector<PVNodeID> PVPath; <<
1546 const PVPath& drawnPVPath = pPV <<
1547 PVPath::const_reverse_iterator ri = ++d <<
1548 G4int drawnMotherDepth; <<
1549 if(ri != drawnPVPath.rend()) <<
1550 { <<
1551 // This volume has a mother. <<
1552 drawnMotherDepth = ri->GetNonCulledDe <<
1553 // G4cout << "drawnMotherDepth" << dr <<
1554 } <<
1555 else <<
1556 { <<
1557 // This volume has no mother. Must b <<
1558 drawnMotherDepth = -1; <<
1559 // G4cout << "Mother must be very top <<
1560 } <<
1561 <<
1562 while(drawnMotherDepth < (currentDepth <<
1563 { <<
1564 G4String culledParentName = "Culled p <<
1565 // G4cout << "Inserting culled layer <<
1566 // depth:" << drawnMotherDepth+2 << G <<
1567 hepRepXMLWriter->addType(culledParent <<
1568 hepRepXMLWriter->addInstance(); <<
1569 drawnMotherDepth++; <<
1570 } <<
1571 } 437 }
1572 << 438
>> 439 if (fCurrentDepth!=0) {
1573 // Add the HepRepType for the current vol 440 // Add the HepRepType for the current volume.
1574 hepRepXMLWriter->addType(pCurrentPV->GetN << 441 hepRepXMLWriter->addType(fpCurrentPV->GetName(),fCurrentDepth);
1575 hepRepXMLWriter->addInstance(); << 442 hepRepXMLWriter->addInstance();
1576 <<
1577 G4HepRepMessenger* messenger = G4HepRepMe <<
1578 <<
1579 if(fpVisAttribs && (fpVisAttribs->IsVisib <<
1580 messenger->getCullInvisibles()) <<
1581 return; <<
1582 <<
1583 // Additional attributes. <<
1584 hepRepXMLWriter->addAttValue("Layer", hep <<
1585 hepRepXMLWriter->addAttValue("LVol", pCur <<
1586 G4Region* region = pCurrentLV->GetRegi <<
1587 G4String regionName = region ? region->Ge <<
1588 hepRepXMLWriter->addAttValue("Region", re <<
1589 hepRepXMLWriter->addAttValue("RootRegion" <<
1590 hepRepXMLWriter->addAttValue("Solid", pCu <<
1591 hepRepXMLWriter->addAttValue("EType", <<
1592 pCurrentLV-> <<
1593 G4Material* material = pPVModel->GetCurre <<
1594 G4String matName = material ? material->G <<
1595 hepRepXMLWriter->addAttValue("Material", <<
1596 G4double matDensity = material ? material <<
1597 hepRepXMLWriter->addAttValue("Density", m <<
1598 G4State matState = material ? material->G <<
1599 hepRepXMLWriter->addAttValue("State", mat <<
1600 G4double matRadlen = material ? material- <<
1601 hepRepXMLWriter->addAttValue("Radlen", ma <<
1602 } <<
1603 <<
1604 hepRepXMLWriter->addAttValue("DrawAs", prim <<
1605 <<
1606 // Handle color and visibility attributes. <<
1607 float redness; <<
1608 float greenness; <<
1609 float blueness; <<
1610 G4bool isVisible; <<
1611 <<
1612 if(fpVisAttribs || haveVisible) <<
1613 { <<
1614 G4Colour colour; <<
1615 <<
1616 if(fpVisAttribs) <<
1617 { <<
1618 colour = fpVisAttribs->GetColour(); <<
1619 isVisible = fpVisAttribs->IsVisible(); <<
1620 } <<
1621 else <<
1622 { <<
1623 colour = visible.GetVisAttributes()->Ge <<
1624 isVisible = <<
1625 fpViewer->GetApplicableVisAttributes( <<
1626 ->IsVisible(); <<
1627 } <<
1628 <<
1629 redness = colour.GetRed(); <<
1630 greenness = colour.GetGreen(); <<
1631 blueness = colour.GetBlue(); <<
1632 <<
1633 // Avoiding drawing anything black on bla <<
1634 if(redness == 0. && greenness == 0. && bl <<
1635 { <<
1636 redness = 1.; <<
1637 greenness = 1.; <<
1638 blueness = 1.; <<
1639 } 443 }
1640 } << 444
1641 else << 445 // Additional attributes.
1642 { << 446 hepRepXMLWriter->addAttValue("LVol", fpCurrentLV->GetName());
1643 #ifdef G4HEPREPFILEDEBUG << 447 hepRepXMLWriter->addAttValue("Solid", fpCurrentLV->GetSolid()->GetName());
1644 G4cout << 448 hepRepXMLWriter->addAttValue("EType", fpCurrentLV->GetSolid()->GetEntityType());
1645 << "G4HepRepFileSceneHandler::AddHepRep << 449 hepRepXMLWriter->addAttValue("Material", fpCurrentLV->GetMaterial()->GetName());
1646 << G4endl; << 450 hepRepXMLWriter->addAttValue("Density", fpCurrentLV->GetMaterial()->GetDensity());
1647 #endif << 451 hepRepXMLWriter->addAttValue("State", fpCurrentLV->GetMaterial()->GetState());
1648 redness = 1.; << 452 hepRepXMLWriter->addAttValue("Radlen", fpCurrentLV->GetMaterial()->GetRadlen());
>> 453 }
>> 454
>> 455 hepRepXMLWriter->addAttValue("DrawAs",primName);
>> 456 hepRepXMLWriter->addAttValue("Layer",hepRepXMLWriter->typeDepth);
>> 457
>> 458 // Handle color attribute, avoiding drawing anything black on black.
>> 459 G4Colour colour = GetColour(visible);
>> 460 float redness = colour.GetRed();
>> 461 float greenness = colour.GetGreen();
>> 462 float blueness = colour.GetBlue();
>> 463
>> 464 if (redness==0. && greenness==0. && blueness==0.) {
>> 465 redness = 1.;
1649 greenness = 1.; 466 greenness = 1.;
1650 blueness = 1.; << 467 blueness = 1.;
1651 isVisible = true; <<
1652 } 468 }
1653 << 469
1654 if(strcmp(primName, "Point") == 0) << 470 if (strcmp(primName,"Point")==0)
1655 hepRepXMLWriter->addAttValue("MarkColor", << 471 hepRepXMLWriter->addAttValue("MarkColor",redness,greenness,blueness);
1656 else 472 else
1657 hepRepXMLWriter->addAttValue("LineColor", << 473 hepRepXMLWriter->addAttValue("LineColor",redness,greenness,blueness);
1658 <<
1659 hepRepXMLWriter->addAttValue("Visibility", <<
1660 } <<
1661 474
1662 void G4HepRepFileSceneHandler::CheckFileOpen( << 475 // Handle visibility attribute.
1663 { << 476 const G4VisAttributes* visAtts = visible.GetVisAttributes();
1664 #ifdef G4HEPREPFILEDEBUG << 477 if (visAtts && (visAtts->IsVisible()==0))
1665 G4cout << "G4HepRepFileSceneHandler::CheckF << 478 hepRepXMLWriter->addAttValue("Visibility",false);
1666 #endif << 479 else
1667 << 480 hepRepXMLWriter->addAttValue("Visibility",true);
1668 if(!hepRepXMLWriter->isOpen) <<
1669 { <<
1670 G4String newFileSpec; <<
1671 <<
1672 G4HepRepMessenger* messenger = G4HepRepMe <<
1673 <<
1674 if(messenger->getOverwrite()) <<
1675 { <<
1676 newFileSpec = <<
1677 messenger->getFileDir() + messenger-> <<
1678 } <<
1679 else <<
1680 { <<
1681 newFileSpec = messenger->getFileDir() + <<
1682 G4UIcommand::ConvertToStr <<
1683 } <<
1684 <<
1685 G4cout << "HepRepFile writing to " << new <<
1686 <<
1687 hepRepXMLWriter->open(newFileSpec); <<
1688 <<
1689 if(!messenger->getOverwrite()) <<
1690 fileCounter++; <<
1691 <<
1692 hepRepXMLWriter->addAttDef("Generator", " <<
1693 ""); <<
1694 G4String versionString = G4Version; <<
1695 versionString = versionString.su <<
1696 versionString = " Geant4 version " + vers <<
1697 hepRepXMLWriter->addAttValue("Generator", <<
1698 <<
1699 hepRepXMLWriter->addAttDef("LVol", "Logic <<
1700 hepRepXMLWriter->addAttDef("Region", "Cut <<
1701 hepRepXMLWriter->addAttDef("RootRegion", <<
1702 hepRepXMLWriter->addAttDef("Solid", "Soli <<
1703 hepRepXMLWriter->addAttDef("EType", "Enti <<
1704 hepRepXMLWriter->addAttDef("Material", "M <<
1705 hepRepXMLWriter->addAttDef("Density", "Ma <<
1706 "kg/m3"); <<
1707 hepRepXMLWriter->addAttDef("State", "Mate <<
1708 hepRepXMLWriter->addAttDef("Radlen", "Mat <<
1709 "m"); <<
1710 } <<
1711 } <<
1712 <<
1713 void G4HepRepFileSceneHandler::ClearTransient <<
1714 { <<
1715 // This is typically called after an update <<
1716 // of the next event. To simulate the clea <<
1717 // (hits, etc.) the detector is redrawn... <<
1718 if(fpViewer) <<
1719 { <<
1720 fpViewer->SetView(); <<
1721 fpViewer->ClearView(); <<
1722 fpViewer->DrawView(); <<
1723 } <<
1724 } 481 }
1725 482