| Geant4 Cross Reference |
1 // 1
2 // *******************************************
3 // * License and Disclaimer
4 // *
5 // * The Geant4 software is copyright of th
6 // * the Geant4 Collaboration. It is provided
7 // * conditions of the Geant4 Software License
8 // * LICENSE and available at http://cern.ch/
9 // * include a list of copyright holders.
10 // *
11 // * Neither the authors of this software syst
12 // * institutes,nor the agencies providing fin
13 // * work make any representation or warran
14 // * regarding this software system or assum
15 // * use. Please see the license in the file
16 // * for the full disclaimer and the limitatio
17 // *
18 // * This code implementation is the result
19 // * technical work of the GEANT4 collaboratio
20 // * By using, copying, modifying or distri
21 // * any work based on the software) you ag
22 // * use in resulting scientific publicati
23 // * acceptance of all terms of the Geant4 Sof
24 // *******************************************
25 //
26 //
27 //
28 // Joseph Perl 27th January 2002
29 // A base class for a scene handler to export
30 // to the HepRep xml file format.
31
32 #include "G4HepRepFileSceneHandler.hh"
33 #include "G4HepRepFile.hh"
34 #include "G4HepRepMessenger.hh"
35 #include "G4UIcommand.hh"
36
37 #include "G4PhysicalConstants.hh"
38 #include "G4SystemOfUnits.hh"
39 #include "G4Version.hh"
40 #include "G4VSolid.hh"
41 #include "G4PhysicalVolumeModel.hh"
42 #include "G4VPhysicalVolume.hh"
43 #include "G4LogicalVolume.hh"
44 #include "G4RotationMatrix.hh"
45 #include "G4Material.hh"
46 #include "G4Polymarker.hh"
47 #include "G4Polyline.hh"
48 #include "G4Text.hh"
49 #include "G4Circle.hh"
50 #include "G4Square.hh"
51 #include "G4Polyhedron.hh"
52 #include "G4VTrajectory.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
63 // HepRep
64 #include "G4HepRepFileXMLWriter.hh"
65
66 G4int G4HepRepFileSceneHandler::fSceneIdCount
67 // Counter for HepRep scene handlers.
68
69 G4HepRepFileSceneHandler::G4HepRepFileSceneHan
70
71 : G4VSceneHandler(system, fSceneIdCount++, n
72 {
73 hepRepXMLWriter = ((G4HepRepFile*) (&system)
74 fileCounter = 0;
75
76 inPrimitives2D = false;
77 warnedAbout3DText = false;
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 }
90
91 G4HepRepFileSceneHandler::~G4HepRepFileSceneHa
92
93 void G4HepRepFileSceneHandler::BeginModeling()
94 {
95 G4VisManager* visManager = G4VisManag
96 const G4VTrajectoryModel* model = visManager
97 trajContext = &model->Ge
98
99 G4VSceneHandler::BeginModeling(); // Requir
100 }
101
102 void G4HepRepFileSceneHandler::EndModeling()
103 {
104 G4VSceneHandler::EndModeling(); // Required
105 }
106
107 void G4HepRepFileSceneHandler::BeginPrimitives
108 const G4Transform3D& objectTransformation)
109 {
110 #ifdef G4HEPREPFILEDEBUG
111 G4cout << "G4HepRepFileSceneHandler::BeginPr
112 #endif
113 inPrimitives2D = true;
114 G4VSceneHandler::BeginPrimitives2D(objectTra
115 }
116
117 void G4HepRepFileSceneHandler::EndPrimitives2D
118 {
119 #ifdef G4HEPREPFILEDEBUG
120 G4cout << "G4HepRepFileSceneHandler::EndPrim
121 #endif
122 G4VSceneHandler::EndPrimitives2D();
123 inPrimitives2D = false;
124 }
125
126 #ifdef G4HEPREPFILEDEBUG
127 void G4HepRepFileSceneHandler::PrintThings()
128 {
129 G4cout << " with transformation " << fObjec
130 G4PhysicalVolumeModel* pPVModel =
131 dynamic_cast<G4PhysicalVolumeModel*>(fpMod
132 if(pPVModel)
133 {
134 G4VPhysicalVolume* pCurrentPV = pPVModel->
135 G4LogicalVolume* pCurrentLV = pPVModel->
136 G4int currentDepth = pPVModel->
137 G4cout << "\n current physical volume: "
138 << "\n current logical volume: " <
139 << "\n current depth of geometry t
140 }
141 G4cout << G4endl;
142 }
143 #endif
144
145 void G4HepRepFileSceneHandler::AddSolid(const
146 {
147 #ifdef G4HEPREPFILEDEBUG
148 G4cout << "G4HepRepFileSceneHandler::AddSoli
149 << box.GetName() << G4endl;
150 PrintThings();
151 #endif
152
153 if(drawingTraj)
154 return;
155
156 if(drawingHit)
157 InitHit();
158
159 haveVisible = false;
160 AddHepRepInstance("Prism", NULL);
161
162 G4HepRepMessenger* messenger = G4HepRepMesse
163
164 // Get and check applicable vis attributes.
165 fpVisAttribs = fpViewer->GetApplicableVisAtt
166 if(fpVisAttribs && (fpVisAttribs->IsVisible(
167 messenger->getCullInvisibles())
168 return;
169
170 hepRepXMLWriter->addPrimitive();
171
172 G4double dx = box.GetXHalfLength();
173 G4double dy = box.GetYHalfLength();
174 G4double dz = box.GetZHalfLength();
175
176 G4Point3D vertex1(G4Point3D(dx, dy, -dz));
177 G4Point3D vertex2(G4Point3D(dx, -dy, -dz));
178 G4Point3D vertex3(G4Point3D(-dx, -dy, -dz));
179 G4Point3D vertex4(G4Point3D(-dx, dy, -dz));
180 G4Point3D vertex5(G4Point3D(dx, dy, dz));
181 G4Point3D vertex6(G4Point3D(dx, -dy, dz));
182 G4Point3D vertex7(G4Point3D(-dx, -dy, dz));
183 G4Point3D vertex8(G4Point3D(-dx, dy, dz));
184
185 vertex1 = (fObjectTransformation) *vertex1;
186 vertex2 = (fObjectTransformation) *vertex2;
187 vertex3 = (fObjectTransformation) *vertex3;
188 vertex4 = (fObjectTransformation) *vertex4;
189 vertex5 = (fObjectTransformation) *vertex5;
190 vertex6 = (fObjectTransformation) *vertex6;
191 vertex7 = (fObjectTransformation) *vertex7;
192 vertex8 = (fObjectTransformation) *vertex8;
193
194 hepRepXMLWriter->addPoint(vertex1.x(), verte
195 hepRepXMLWriter->addPoint(vertex2.x(), verte
196 hepRepXMLWriter->addPoint(vertex3.x(), verte
197 hepRepXMLWriter->addPoint(vertex4.x(), verte
198 hepRepXMLWriter->addPoint(vertex5.x(), verte
199 hepRepXMLWriter->addPoint(vertex6.x(), verte
200 hepRepXMLWriter->addPoint(vertex7.x(), verte
201 hepRepXMLWriter->addPoint(vertex8.x(), verte
202 }
203
204 void G4HepRepFileSceneHandler::AddSolid(const
205 {
206 #ifdef G4HEPREPFILEDEBUG
207 G4cout << "G4HepRepFileSceneHandler::AddSoli
208 << cons.GetName() << G4endl;
209 PrintThings();
210 #endif
211
212 // HepRApp does not correctly represent the
213 // non-standard angles, let the base class c
214 G4RotationMatrix r = fObjectTransformation.g
215 G4bool linedUpWithAnAxis =
216 (std::fabs(r.phiX()) <= .001 || std::fabs(
217 std::fabs(r.phiZ()) <= .001 || std::fabs(
218 std::fabs(r.phiY() - pi) <= .001 || std::
219 // G4cout << "Angle X:" << r.phiX() << ", An
220 // Z:" << r.phiZ() << G4endl; G4cout << "lin
221 // linedUpWithAnAxis << G4endl;
222
223 // HepRep does not have a primitive for a cu
224 // so if this cone is cut, let the base clas
225 // solid to polygons.
226 G4HepRepMessenger* messenger = G4HepRepMesse
227 if(cons.GetDeltaPhiAngle() < twopi || !lined
228 messenger->renderCylAsPolygons())
229 {
230 G4VSceneHandler::AddSolid(cons); // Invok
231 }
232 else
233 {
234 if(drawingTraj)
235 return;
236
237 if(drawingHit)
238 InitHit();
239
240 haveVisible = false;
241 AddHepRepInstance("Cylinder", NULL);
242
243 // Get and check applicable vis attributes
244 fpVisAttribs = fpViewer->GetApplicableVisA
245 if(fpVisAttribs && (fpVisAttribs->IsVisibl
246 messenger->getCullInvisibles())
247 return;
248
249 G4Point3D vertex1(G4Point3D(0., 0., -cons.
250 G4Point3D vertex2(G4Point3D(0., 0., cons.G
251
252 vertex1 = (fObjectTransformation) *vertex1
253 vertex2 = (fObjectTransformation) *vertex2
254
255 // Outer cylinder.
256 hepRepXMLWriter->addPrimitive();
257 hepRepXMLWriter->addAttValue("Radius1", me
258
259 hepRepXMLWriter->addAttValue("Radius2", me
260
261 hepRepXMLWriter->addPoint(vertex1.x(), ver
262 hepRepXMLWriter->addPoint(vertex2.x(), ver
263
264 // Inner cylinder.
265 hepRepXMLWriter->addPrimitive();
266 hepRepXMLWriter->addAttValue("Radius1", me
267
268 hepRepXMLWriter->addAttValue("Radius2", me
269
270 hepRepXMLWriter->addPoint(vertex1.x(), ver
271 hepRepXMLWriter->addPoint(vertex2.x(), ver
272 }
273 }
274
275 void G4HepRepFileSceneHandler::AddSolid(const
276 {
277 #ifdef G4HEPREPFILEDEBUG
278 G4cout << "G4HepRepFileSceneHandler::AddSoli
279 << tubs.GetName() << G4endl;
280 PrintThings();
281 #endif
282
283 // HepRApp does not correctly represent the
284 // non-standard angles, let the base class c
285 G4RotationMatrix r = fObjectTransformation.g
286 G4bool linedUpWithAnAxis =
287 (std::fabs(r.phiX()) <= .001 || std::fabs(
288 std::fabs(r.phiZ()) <= .001 || std::fabs(
289 std::fabs(r.phiY() - pi) <= .001 || std::
290 // G4cout << "Angle X:" << r.phiX() << ", An
291 // Z:" << r.phiZ() << G4endl; G4cout << "lin
292 // linedUpWithAnAxis << G4endl;
293
294 // HepRep does not have a primitive for a cu
295 // so if this cylinder is cut, let the base
296 // solid to polygons.
297 G4HepRepMessenger* messenger = G4HepRepMesse
298 if(tubs.GetDeltaPhiAngle() < twopi || !lined
299 messenger->renderCylAsPolygons())
300 {
301 G4VSceneHandler::AddSolid(tubs); // Invok
302 }
303 else
304 {
305 if(drawingTraj)
306 return;
307
308 if(drawingHit)
309 InitHit();
310
311 haveVisible = false;
312 AddHepRepInstance("Cylinder", NULL);
313
314 // Get and check applicable vis attributes
315 fpVisAttribs = fpViewer->GetApplicableVisA
316 if(fpVisAttribs && (fpVisAttribs->IsVisibl
317 messenger->getCullInvisibles())
318 return;
319
320 G4Point3D vertex1(G4Point3D(0., 0., -tubs.
321 G4Point3D vertex2(G4Point3D(0., 0., tubs.G
322
323 vertex1 = (fObjectTransformation) *vertex1
324 vertex2 = (fObjectTransformation) *vertex2
325
326 // Outer cylinder.
327 hepRepXMLWriter->addPrimitive();
328 hepRepXMLWriter->addAttValue("Radius1",
329 messenger->ge
330 hepRepXMLWriter->addAttValue("Radius2",
331 messenger->ge
332 hepRepXMLWriter->addPoint(vertex1.x(), ver
333 hepRepXMLWriter->addPoint(vertex2.x(), ver
334
335 // Inner cylinder.
336 if(tubs.GetInnerRadius() != 0.)
337 {
338 hepRepXMLWriter->addPrimitive();
339 hepRepXMLWriter->addAttValue("Radius1",
340
341 hepRepXMLWriter->addAttValue("Radius2",
342
343 hepRepXMLWriter->addPoint(vertex1.x(), v
344 hepRepXMLWriter->addPoint(vertex2.x(), v
345 }
346 }
347 }
348
349 void G4HepRepFileSceneHandler::AddSolid(const
350 {
351 #ifdef G4HEPREPFILEDEBUG
352 G4cout << "G4HepRepFileSceneHandler::AddSoli
353 << trd.GetName() << G4endl;
354 PrintThings();
355 #endif
356
357 if(drawingTraj)
358 return;
359
360 if(drawingHit)
361 InitHit();
362
363 haveVisible = false;
364 AddHepRepInstance("Prism", NULL);
365
366 G4HepRepMessenger* messenger = G4HepRepMesse
367
368 // Get and check applicable vis attributes.
369 fpVisAttribs = fpViewer->GetApplicableVisAtt
370 if(fpVisAttribs && (fpVisAttribs->IsVisible(
371 messenger->getCullInvisibles())
372 return;
373
374 hepRepXMLWriter->addPrimitive();
375
376 G4double dx1 = trd.GetXHalfLength1();
377 G4double dy1 = trd.GetYHalfLength1();
378 G4double dx2 = trd.GetXHalfLength2();
379 G4double dy2 = trd.GetYHalfLength2();
380 G4double dz = trd.GetZHalfLength();
381
382 G4Point3D vertex1(G4Point3D(dx1, dy1, -dz));
383 G4Point3D vertex2(G4Point3D(dx1, -dy1, -dz))
384 G4Point3D vertex3(G4Point3D(-dx1, -dy1, -dz)
385 G4Point3D vertex4(G4Point3D(-dx1, dy1, -dz))
386 G4Point3D vertex5(G4Point3D(dx2, dy2, dz));
387 G4Point3D vertex6(G4Point3D(dx2, -dy2, dz));
388 G4Point3D vertex7(G4Point3D(-dx2, -dy2, dz))
389 G4Point3D vertex8(G4Point3D(-dx2, dy2, dz));
390
391 vertex1 = (fObjectTransformation) *vertex1;
392 vertex2 = (fObjectTransformation) *vertex2;
393 vertex3 = (fObjectTransformation) *vertex3;
394 vertex4 = (fObjectTransformation) *vertex4;
395 vertex5 = (fObjectTransformation) *vertex5;
396 vertex6 = (fObjectTransformation) *vertex6;
397 vertex7 = (fObjectTransformation) *vertex7;
398 vertex8 = (fObjectTransformation) *vertex8;
399
400 hepRepXMLWriter->addPoint(vertex1.x(), verte
401 hepRepXMLWriter->addPoint(vertex2.x(), verte
402 hepRepXMLWriter->addPoint(vertex3.x(), verte
403 hepRepXMLWriter->addPoint(vertex4.x(), verte
404 hepRepXMLWriter->addPoint(vertex5.x(), verte
405 hepRepXMLWriter->addPoint(vertex6.x(), verte
406 hepRepXMLWriter->addPoint(vertex7.x(), verte
407 hepRepXMLWriter->addPoint(vertex8.x(), verte
408 }
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
431 void G4HepRepFileSceneHandler::AddSolid(const
432 {
433 #ifdef G4HEPREPFILEDEBUG
434 G4cout << "G4HepRepFileSceneHandler::AddSoli
435 << para.GetName() << G4endl;
436 PrintThings();
437 #endif
438 G4VSceneHandler::AddSolid(para); // Invoke
439 }
440
441 void G4HepRepFileSceneHandler::AddSolid(const
442 {
443 #ifdef G4HEPREPFILEDEBUG
444 G4cout
445 << "G4HepRepFileSceneHandler::AddSolid(con
446 << torus.GetName() << G4endl;
447 PrintThings();
448 #endif
449 G4VSceneHandler::AddSolid(torus); // Invoke
450 }
451
452 void G4HepRepFileSceneHandler::AddSolid(const
453 {
454 #ifdef G4HEPREPFILEDEBUG
455 G4cout << "G4HepRepFileSceneHandler::AddSoli
456 "called for "
457 << polycone.GetName() << G4endl;
458 PrintThings();
459 #endif
460 G4VSceneHandler::AddSolid(polycone); // Inv
461 }
462
463 void G4HepRepFileSceneHandler::AddSolid(const
464 {
465 #ifdef G4HEPREPFILEDEBUG
466 G4cout << "G4HepRepFileSceneHandler::AddSoli
467 "called for "
468 << polyhedra.GetName() << G4endl;
469 PrintThings();
470 #endif
471 G4VSceneHandler::AddSolid(polyhedra); // In
472 }
473
474 void G4HepRepFileSceneHandler::AddSolid(const
475 {
476 #ifdef G4HEPREPFILEDEBUG
477 G4cout << "G4HepRepFileSceneHandler::AddSoli
478 << orb.GetName() << G4endl;
479 PrintThings();
480 #endif
481 G4VSceneHandler::AddSolid(orb); // Invoke d
482 }
483
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 }
1061
1062 void G4HepRepFileSceneHandler::InitHit()
1063 {
1064 if(!doneInitHit)
1065 {
1066 // For every hit, add an instance of Type
1067 hepRepXMLWriter->addInstance();
1068
1069 // Write out the hit's attribute values.
1070 if(hitAttValues)
1071 {
1072 std::vector<G4AttValue>::iterator iAttV
1073 for(iAttVal = hitAttValues->begin(); iA
1074 ++iAttVal)
1075 hepRepXMLWriter->addAttValue(iAttVal-
1076 delete hitAttValues;
1077 }
1078
1079 // Clean up hit attributes.
1080 if(hitAttDefs)
1081 delete hitAttDefs;
1082
1083 doneInitHit = true;
1084 }
1085 }
1086
1087 void G4HepRepFileSceneHandler::AddPrimitive(c
1088 {
1089 #ifdef G4HEPREPFILEDEBUG
1090 G4cout << "G4HepRepFileSceneHandler::AddPri
1091 "polyline) called:"
1092 "\n polyline: "
1093 << polyline << G4endl;
1094 PrintThings();
1095 #endif
1096
1097 G4HepRepMessenger* messenger = G4HepRepMess
1098
1099 if(fpVisAttribs && (fpVisAttribs->IsVisible
1100 messenger->getCullInvisibles())
1101 return;
1102
1103 if(inPrimitives2D)
1104 {
1105 if(!warnedAbout2DMarkers)
1106 {
1107 G4cout << "HepRepFile does not currentl
1108 warnedAbout2DMarkers = true;
1109 }
1110 return;
1111 }
1112
1113 if(drawingTraj)
1114 InitTrajectory();
1115
1116 if(drawingHit)
1117 InitHit();
1118
1119 haveVisible = true;
1120 AddHepRepInstance("Line", polyline);
1121
1122 hepRepXMLWriter->addPrimitive();
1123
1124 for(size_t i = 0; i < polyline.size(); i++)
1125 {
1126 G4Point3D vertex = (fObjectTransformation
1127 hepRepXMLWriter->addPoint(vertex.x(), ver
1128 }
1129 }
1130
1131 void G4HepRepFileSceneHandler::AddPrimitive(c
1132 {
1133 #ifdef G4HEPREPFILEDEBUG
1134 G4cout
1135 << "G4HepRepFileSceneHandler::AddPrimitiv
1136 << G4endl;
1137 PrintThings();
1138 #endif
1139
1140 G4HepRepMessenger* messenger = G4HepRepMess
1141
1142 if(fpVisAttribs && (fpVisAttribs->IsVisible
1143 messenger->getCullInvisibles())
1144 return;
1145
1146 if(inPrimitives2D)
1147 {
1148 if(!warnedAbout2DMarkers)
1149 {
1150 G4cout << "HepRepFile does not currentl
1151 warnedAbout2DMarkers = true;
1152 }
1153 return;
1154 }
1155
1156 MarkerSizeType sizeType;
1157 G4double size = GetMarkerSize(line, sizeTyp
1158 if(sizeType == world)
1159 size = 4.;
1160
1161 if(drawingTraj)
1162 return;
1163
1164 if(drawingHit)
1165 InitHit();
1166
1167 haveVisible = true;
1168 AddHepRepInstance("Point", line);
1169
1170 hepRepXMLWriter->addAttValue("MarkName", "D
1171 hepRepXMLWriter->addAttValue("MarkSize", (G
1172
1173 hepRepXMLWriter->addPrimitive();
1174
1175 for(size_t i = 0; i < line.size(); i++)
1176 {
1177 G4Point3D vertex = (fObjectTransformation
1178 hepRepXMLWriter->addPoint(vertex.x(), ver
1179 }
1180 }
1181
1182 void G4HepRepFileSceneHandler::AddPrimitive(c
1183 {
1184 #ifdef G4HEPREPFILEDEBUG
1185 G4cout << "G4HepRepFileSceneHandler::AddPri
1186 "\n text: "
1187 << text.GetText() << G4endl;
1188 PrintThings();
1189 #endif
1190
1191 if(!inPrimitives2D)
1192 {
1193 if(!warnedAbout3DText)
1194 {
1195 G4cout << "HepRepFile does not currentl
1196 G4cout
1197 << "HepRep browsers can directly disp
1198 << G4endl;
1199 G4cout << "See Application Developers G
1200 "to viewable objects."
1201 << G4endl;
1202 warnedAbout3DText = true;
1203 }
1204 return;
1205 }
1206
1207 MarkerSizeType sizeType;
1208 G4double size = GetMarkerSize(text, sizeTyp
1209 if(sizeType == world)
1210 size = 12.;
1211
1212 haveVisible = true;
1213 AddHepRepInstance("Text", text);
1214
1215 hepRepXMLWriter->addAttValue("VAlign", "Top
1216 hepRepXMLWriter->addAttValue("HAlign", "Lef
1217 hepRepXMLWriter->addAttValue("FontName", "A
1218 hepRepXMLWriter->addAttValue("FontStyle", "
1219 hepRepXMLWriter->addAttValue("FontSize", (G
1220 hepRepXMLWriter->addAttValue("FontHasBanner
1221 hepRepXMLWriter->addAttValue("FontBannerCol
1222
1223 const G4Colour& colour = GetTextColour(text
1224 float redness = colour.GetRed();
1225 float greenness = colour.GetGreen();
1226 float blueness = colour.GetBlue();
1227
1228 // Avoiding drawing anything black on black
1229 if(redness == 0. && greenness == 0. && blue
1230 {
1231 redness = 1.;
1232 greenness = 1.;
1233 blueness = 1.;
1234 }
1235 hepRepXMLWriter->addAttValue("FontColor", r
1236
1237 hepRepXMLWriter->addPrimitive();
1238
1239 hepRepXMLWriter->addAttValue("Text", text.G
1240 hepRepXMLWriter->addAttValue("VPos", .99 -
1241 hepRepXMLWriter->addAttValue("HPos", text.G
1242 }
1243
1244 void G4HepRepFileSceneHandler::AddPrimitive(c
1245 {
1246 #ifdef G4HEPREPFILEDEBUG
1247 G4cout
1248 << "G4HepRepFileSceneHandler::AddPrimitiv
1249 "\n radius: "
1250 << circle.GetWorldRadius() << G4endl;
1251 PrintThings();
1252 #endif
1253
1254 G4HepRepMessenger* messenger = G4HepRepMess
1255
1256 if(fpVisAttribs && (fpVisAttribs->IsVisible
1257 messenger->getCullInvisibles())
1258 return;
1259
1260 if(inPrimitives2D)
1261 {
1262 if(!warnedAbout2DMarkers)
1263 {
1264 G4cout << "HepRepFile does not currentl
1265 warnedAbout2DMarkers = true;
1266 }
1267 return;
1268 }
1269
1270 MarkerSizeType sizeType;
1271 G4double size = GetMarkerSize(circle, sizeT
1272 if(sizeType == world)
1273 size = 4.;
1274
1275 if(drawingTraj)
1276 return;
1277
1278 if(drawingHit)
1279 InitHit();
1280
1281 haveVisible = true;
1282 AddHepRepInstance("Point", circle);
1283
1284 hepRepXMLWriter->addAttValue("MarkName", "D
1285 hepRepXMLWriter->addAttValue("MarkSize", (G
1286
1287 hepRepXMLWriter->addPrimitive();
1288
1289 G4Point3D center = (fObjectTransformation)
1290 hepRepXMLWriter->addPoint(center.x(), cente
1291 }
1292
1293 void G4HepRepFileSceneHandler::AddPrimitive(c
1294 {
1295 #ifdef G4HEPREPFILEDEBUG
1296 G4cout
1297 << "G4HepRepFileSceneHandler::AddPrimitiv
1298 "\n side: "
1299 << square.GetWorldRadius() << G4endl;
1300 PrintThings();
1301 #endif
1302
1303 G4HepRepMessenger* messenger = G4HepRepMess
1304
1305 if(fpVisAttribs && (fpVisAttribs->IsVisible
1306 messenger->getCullInvisibles())
1307 return;
1308
1309 if(inPrimitives2D)
1310 {
1311 if(!warnedAbout2DMarkers)
1312 {
1313 G4cout << "HepRepFile does not currentl
1314 warnedAbout2DMarkers = true;
1315 }
1316 return;
1317 }
1318
1319 MarkerSizeType sizeType;
1320 G4double size = GetMarkerSize(square, sizeT
1321 if(sizeType == world)
1322 size = 4.;
1323
1324 if(drawingTraj)
1325 return;
1326
1327 if(drawingHit)
1328 InitHit();
1329
1330 haveVisible = true;
1331 AddHepRepInstance("Point", square);
1332
1333 hepRepXMLWriter->addAttValue("MarkName", "S
1334 hepRepXMLWriter->addAttValue("MarkSize", (G
1335
1336 hepRepXMLWriter->addPrimitive();
1337
1338 G4Point3D center = (fObjectTransformation)
1339 hepRepXMLWriter->addPoint(center.x(), cente
1340 }
1341
1342 void G4HepRepFileSceneHandler::AddPrimitive(c
1343 {
1344 #ifdef G4HEPREPFILEDEBUG
1345 G4cout << "G4HepRepFileSceneHandler::AddPri
1346 "polyhedron) called."
1347 << G4endl;
1348 PrintThings();
1349 #endif
1350
1351 G4HepRepMessenger* messenger = G4HepRepMess
1352
1353 if(fpVisAttribs && (fpVisAttribs->IsVisible
1354 messenger->getCullInvisibles())
1355 return;
1356
1357 if(polyhedron.GetNoFacets() == 0)
1358 return;
1359
1360 if(drawingTraj)
1361 return;
1362
1363 if(drawingHit)
1364 InitHit();
1365
1366 haveVisible = true;
1367 AddHepRepInstance("Polygon", polyhedron);
1368
1369 G4Normal3D surfaceNormal;
1370 G4Point3D vertex;
1371
1372 G4bool notLastFace;
1373 do
1374 {
1375 hepRepXMLWriter->addPrimitive();
1376 notLastFace = polyhedron.GetNextNormal(su
1377
1378 G4int edgeFlag = 1;
1379 G4bool notLastEdge;
1380 do
1381 {
1382 notLastEdge = polyhedron.GetNextVertex(
1383 vertex = (fObjectTransformation) *
1384 hepRepXMLWriter->addPoint(vertex.x(), v
1385 } while(notLastEdge);
1386 } while(notLastFace);
1387 }
1388
1389 G4HepRepFileXMLWriter* G4HepRepFileSceneHandl
1390 {
1391 return hepRepXMLWriter;
1392 }
1393
1394 void G4HepRepFileSceneHandler::AddHepRepInsta
1395
1396 {
1397 #ifdef G4HEPREPFILEDEBUG
1398 G4cout << "G4HepRepFileSceneHandler::AddHep
1399 #endif
1400
1401 // Open the HepRep output file if it is not
1402 CheckFileOpen();
1403
1404 G4VPhysicalVolume* pCurrentPV = 0;
1405 G4LogicalVolume* pCurrentLV = 0;
1406 G4int currentDepth = 0;
1407 G4PhysicalVolumeModel* pPVModel =
1408 dynamic_cast<G4PhysicalVolumeModel*>(fpMo
1409 if(pPVModel)
1410 {
1411 pCurrentPV = pPVModel->GetCurrentPV();
1412 pCurrentLV = pPVModel->GetCurrentLV();
1413 currentDepth = pPVModel->GetCurrentDepth(
1414 }
1415
1416 #ifdef G4HEPREPFILEDEBUG
1417 G4cout << "pCurrentPV:" << pCurrentPV
1418 << ", readyForTransients:" << fReady
1419 #endif
1420
1421 if(drawingTraj || drawingHit)
1422 {
1423 // In this case, HepRep type, layer and i
1424 // in the AddCompound method.
1425 }
1426 else if(fReadyForTransients)
1427 {
1428 if(strcmp("Event Data", hepRepXMLWriter->
1429 {
1430 hepRepXMLWriter->addType("Event Data",
1431 hepRepXMLWriter->addInstance();
1432 }
1433
1434 // Applications have the option of either
1435 // and AddSolid(G4VHits&), or of just dec
1436 // primitives. In the former case, drawin
1437 // include setting of physics attributes.
1438 // older style of working, we end up draw
1439 // where we have no access to physics att
1440 // here. We can figure out that these ar
1441 // exactly what these transients represen
1442 // being used as in G4VTrajectory, hence
1443 // Squares that come after we've seen tra
1444 // Circles that come after we've seen tra
1445 // Other primitives are Hits
1446
1447 int layer;
1448
1449 if(strcmp("Text", primName) == 0)
1450 {
1451 hepRepXMLWriter->addType("EventID", 1);
1452 }
1453 else
1454 {
1455 if(strcmp("Line", primName) == 0)
1456 {
1457 hepRepXMLWriter->addType("TransientPo
1458 layer = 100;
1459 }
1460 else
1461 {
1462 if(strcmp(hepRepXMLWriter->prevTypeNa
1463 0 &&
1464 strcmp("Square", primName) == 0)
1465 {
1466 hepRepXMLWriter->addType("Auxiliary
1467 layer = 110;
1468 }
1469 else
1470 {
1471 if(strcmp(hepRepXMLWriter->prevType
1472 0 &&
1473 strcmp("Circle", primName) == 0)
1474 {
1475 hepRepXMLWriter->addType("StepPoi
1476 layer = 120;
1477 }
1478 else
1479 {
1480 hepRepXMLWriter->addType("Hits",
1481 layer = 130;
1482 }
1483 }
1484 }
1485 hepRepXMLWriter->addAttValue("Layer", l
1486 }
1487
1488 hepRepXMLWriter->addInstance();
1489
1490 // Handle Type declaration for Axes, Rule
1491 }
1492 else if(pCurrentPV == 0)
1493 {
1494 if(strcmp("AxesEtc", hepRepXMLWriter->pre
1495 {
1496 hepRepXMLWriter->addType("AxesEtc", 0);
1497 hepRepXMLWriter->addInstance();
1498 }
1499
1500 int layer;
1501
1502 if(strcmp("Text", primName) == 0)
1503 {
1504 hepRepXMLWriter->addType("Text", 1);
1505 }
1506 else
1507 {
1508 if(strcmp("Line", primName) == 0)
1509 {
1510 hepRepXMLWriter->addType("Polylines",
1511 layer = 100;
1512 }
1513 else
1514 {
1515 hepRepXMLWriter->addType("Points", 1)
1516 layer = 130;
1517 }
1518 hepRepXMLWriter->addAttValue("Layer", l
1519 }
1520
1521 hepRepXMLWriter->addInstance();
1522
1523 // Handle Type declaration for Detector G
1524 // replacing G4's top geometry level name
1525 // name "Detector Geometry".
1526 }
1527 else
1528 {
1529 // G4cout << "CurrentDepth" << currentDep
1530 // G4cout << "currentName" << pCurrentPV-
1531 if(strcmp("Detector Geometry", hepRepXMLW
1532 {
1533 // G4cout << "Adding Det Geom type" <<
1534 hepRepXMLWriter->addType("Detector Geom
1535 hepRepXMLWriter->addInstance();
1536 }
1537
1538 // Re-insert any layers of the hierarchy
1539 // process. Don't bother checking if same
1540 if(strcmp(hepRepXMLWriter->prevTypeName[c
1541 pCurrentPV->GetName()) != 0)
1542 {
1543 // G4cout << "Looking for mother of:" <
1544 typedef G4PhysicalVolumeModel::G4Physic
1545 typedef std::vector<PVNodeID> PVPath;
1546 const PVPath& drawnPVPath = pPV
1547 PVPath::const_reverse_iterator ri = ++d
1548 G4int drawnMotherDepth;
1549 if(ri != drawnPVPath.rend())
1550 {
1551 // This volume has a mother.
1552 drawnMotherDepth = ri->GetNonCulledDe
1553 // G4cout << "drawnMotherDepth" << dr
1554 }
1555 else
1556 {
1557 // This volume has no mother. Must b
1558 drawnMotherDepth = -1;
1559 // G4cout << "Mother must be very top
1560 }
1561
1562 while(drawnMotherDepth < (currentDepth
1563 {
1564 G4String culledParentName = "Culled p
1565 // G4cout << "Inserting culled layer
1566 // depth:" << drawnMotherDepth+2 << G
1567 hepRepXMLWriter->addType(culledParent
1568 hepRepXMLWriter->addInstance();
1569 drawnMotherDepth++;
1570 }
1571 }
1572
1573 // Add the HepRepType for the current vol
1574 hepRepXMLWriter->addType(pCurrentPV->GetN
1575 hepRepXMLWriter->addInstance();
1576
1577 G4HepRepMessenger* messenger = G4HepRepMe
1578
1579 if(fpVisAttribs && (fpVisAttribs->IsVisib
1580 messenger->getCullInvisibles())
1581 return;
1582
1583 // Additional attributes.
1584 hepRepXMLWriter->addAttValue("Layer", hep
1585 hepRepXMLWriter->addAttValue("LVol", pCur
1586 G4Region* region = pCurrentLV->GetRegi
1587 G4String regionName = region ? region->Ge
1588 hepRepXMLWriter->addAttValue("Region", re
1589 hepRepXMLWriter->addAttValue("RootRegion"
1590 hepRepXMLWriter->addAttValue("Solid", pCu
1591 hepRepXMLWriter->addAttValue("EType",
1592 pCurrentLV->
1593 G4Material* material = pPVModel->GetCurre
1594 G4String matName = material ? material->G
1595 hepRepXMLWriter->addAttValue("Material",
1596 G4double matDensity = material ? material
1597 hepRepXMLWriter->addAttValue("Density", m
1598 G4State matState = material ? material->G
1599 hepRepXMLWriter->addAttValue("State", mat
1600 G4double matRadlen = material ? material-
1601 hepRepXMLWriter->addAttValue("Radlen", ma
1602 }
1603
1604 hepRepXMLWriter->addAttValue("DrawAs", prim
1605
1606 // Handle color and visibility attributes.
1607 float redness;
1608 float greenness;
1609 float blueness;
1610 G4bool isVisible;
1611
1612 if(fpVisAttribs || haveVisible)
1613 {
1614 G4Colour colour;
1615
1616 if(fpVisAttribs)
1617 {
1618 colour = fpVisAttribs->GetColour();
1619 isVisible = fpVisAttribs->IsVisible();
1620 }
1621 else
1622 {
1623 colour = visible.GetVisAttributes()->Ge
1624 isVisible =
1625 fpViewer->GetApplicableVisAttributes(
1626 ->IsVisible();
1627 }
1628
1629 redness = colour.GetRed();
1630 greenness = colour.GetGreen();
1631 blueness = colour.GetBlue();
1632
1633 // Avoiding drawing anything black on bla
1634 if(redness == 0. && greenness == 0. && bl
1635 {
1636 redness = 1.;
1637 greenness = 1.;
1638 blueness = 1.;
1639 }
1640 }
1641 else
1642 {
1643 #ifdef G4HEPREPFILEDEBUG
1644 G4cout
1645 << "G4HepRepFileSceneHandler::AddHepRep
1646 << G4endl;
1647 #endif
1648 redness = 1.;
1649 greenness = 1.;
1650 blueness = 1.;
1651 isVisible = true;
1652 }
1653
1654 if(strcmp(primName, "Point") == 0)
1655 hepRepXMLWriter->addAttValue("MarkColor",
1656 else
1657 hepRepXMLWriter->addAttValue("LineColor",
1658
1659 hepRepXMLWriter->addAttValue("Visibility",
1660 }
1661
1662 void G4HepRepFileSceneHandler::CheckFileOpen(
1663 {
1664 #ifdef G4HEPREPFILEDEBUG
1665 G4cout << "G4HepRepFileSceneHandler::CheckF
1666 #endif
1667
1668 if(!hepRepXMLWriter->isOpen)
1669 {
1670 G4String newFileSpec;
1671
1672 G4HepRepMessenger* messenger = G4HepRepMe
1673
1674 if(messenger->getOverwrite())
1675 {
1676 newFileSpec =
1677 messenger->getFileDir() + messenger->
1678 }
1679 else
1680 {
1681 newFileSpec = messenger->getFileDir() +
1682 G4UIcommand::ConvertToStr
1683 }
1684
1685 G4cout << "HepRepFile writing to " << new
1686
1687 hepRepXMLWriter->open(newFileSpec);
1688
1689 if(!messenger->getOverwrite())
1690 fileCounter++;
1691
1692 hepRepXMLWriter->addAttDef("Generator", "
1693 "");
1694 G4String versionString = G4Version;
1695 versionString = versionString.su
1696 versionString = " Geant4 version " + vers
1697 hepRepXMLWriter->addAttValue("Generator",
1698
1699 hepRepXMLWriter->addAttDef("LVol", "Logic
1700 hepRepXMLWriter->addAttDef("Region", "Cut
1701 hepRepXMLWriter->addAttDef("RootRegion",
1702 hepRepXMLWriter->addAttDef("Solid", "Soli
1703 hepRepXMLWriter->addAttDef("EType", "Enti
1704 hepRepXMLWriter->addAttDef("Material", "M
1705 hepRepXMLWriter->addAttDef("Density", "Ma
1706 "kg/m3");
1707 hepRepXMLWriter->addAttDef("State", "Mate
1708 hepRepXMLWriter->addAttDef("Radlen", "Mat
1709 "m");
1710 }
1711 }
1712
1713 void G4HepRepFileSceneHandler::ClearTransient
1714 {
1715 // This is typically called after an update
1716 // of the next event. To simulate the clea
1717 // (hits, etc.) the detector is redrawn...
1718 if(fpViewer)
1719 {
1720 fpViewer->SetView();
1721 fpViewer->ClearView();
1722 fpViewer->DrawView();
1723 }
1724 }
1725