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