source: trunk/source/visualization/HepRep/src/G4HepRepSceneHandler.cc@ 1043

Last change on this file since 1043 was 944, checked in by garnier, 17 years ago

mise a jour des tags
File size: 60.0 KB
Line 
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: G4HepRepSceneHandler.cc,v 1.101 2007/11/16 20:29:04 perl Exp $
27// GEANT4 tag $Name: $
28//
29
30/**
31 * @author Mark Donszelmann
32 */
33
34#include <stdio.h>
35
36#include "globals.hh"
37#include <vector>
38#include <iostream>
39// NOTE not available on Solaris 5.2 and Linux g++ 2.95.2
40// #include <sstream>
41#include <iomanip>
42#include <fstream>
43#include <cmath>
44
45//HepRep
46#include "HEPREP/HepRep.h"
47
48//G4
49#include "G4Vector3D.hh"
50#include "G4Version.hh"
51#include "G4Types.hh"
52#include "G4Point3D.hh"
53#include "G4Normal3D.hh"
54#include "G4Polyline.hh"
55#include "G4Polymarker.hh"
56#include "G4Polyhedron.hh"
57#include "G4Circle.hh"
58#include "G4Square.hh"
59#include "G4Text.hh"
60#include "G4NURBS.hh"
61#include "G4VPhysicalVolume.hh"
62#include "G4VisAttributes.hh"
63#include "G4VSolid.hh"
64#include "G4VTrajectory.hh"
65#include "G4VTrajectoryPoint.hh"
66#include "G4VHit.hh"
67#include "G4Scene.hh"
68#include "G4Material.hh"
69#include "G4AttDef.hh"
70#include "G4AttValue.hh"
71#include "G4AttCheck.hh"
72
73// CHepRep
74#include "cheprep/XMLHepRepFactory.h"
75
76// This
77#include "G4HepRep.hh"
78#include "G4HepRepSceneHandler.hh"
79#include "G4HepRepViewer.hh"
80
81
82using namespace HEPREP;
83using namespace cheprep;
84using namespace std;
85
86G4int G4HepRepSceneHandler::sceneIdCount = 0;
87
88//#define LDEBUG 1
89//#define SDEBUG 1
90//#define PDEBUG 1
91
92G4HepRepSceneHandler::G4HepRepSceneHandler (G4VGraphicsSystem& system, G4HepRepMessenger& heprepMessenger, const G4String& name)
93 : G4VSceneHandler (system, sceneIdCount++, name),
94 messenger (heprepMessenger),
95 geometryLayer ("Geometry"),
96 eventLayer ("Event"),
97 calHitLayer ("CalHit"),
98 trajectoryLayer ("Trajectory"),
99 hitLayer ("Hit"),
100 rootVolumeName ("Geometry"),
101 baseName (""),
102 eventNumberPrefix (""),
103 eventNumberSuffix (""),
104 eventNumber (1),
105 eventNumberWidth (-1),
106 extension (""),
107 writeBinary (false),
108 writeZip (false),
109 writeGZ (false),
110 writeMultipleFiles (false),
111 currentHit (NULL),
112 currentTrack (NULL),
113 _heprep (NULL),
114 _heprepGeometry (NULL)
115{
116
117#ifdef LDEBUG
118 cout << "G4HepRepSceneHandler::G4HepRepSceneHandler: " << system << endl;
119#endif
120
121 materialState[kStateSolid] = G4String("Solid");
122 materialState[kStateLiquid] = G4String("Liquid");
123 materialState[kStateGas] = G4String("Gas");
124 materialState[kStateUndefined] = G4String("Undefined");
125
126 factory = new XMLHepRepFactory();
127 writer = NULL;
128
129 // opening of file deferred to closeHepRep();
130 openHepRep();
131}
132
133
134G4HepRepSceneHandler::~G4HepRepSceneHandler () {
135#ifdef LDEBUG
136 cout << "G4HepRepSceneHandler::~G4HepRepSceneHandler() " << endl;
137#endif
138 close();
139
140 delete factory;
141 factory = NULL;
142
143 dynamic_cast<G4HepRep*>(GetGraphicsSystem())->removeSceneHandler();
144}
145
146
147void G4HepRepSceneHandler::open(G4String name) {
148 if (writer != NULL) return;
149
150 if (name == "stdout") {
151#ifdef LDEBUG
152 cout << "G4HepRepSceneHandler::Open() stdout" << endl;
153#endif
154 writer = factory->createHepRepWriter(&cout, false, false);
155 out = NULL;
156 baseName = name;
157 eventNumberPrefix = "";
158 eventNumberSuffix = "";
159 extension = "";
160 writeBinary = false;
161 writeZip = false;
162 writeGZ = false;
163 writeMultipleFiles = false;
164 eventNumber = 0;
165 eventNumberWidth = 0;
166 } else if (name == "stderr") {
167#ifdef LDEBUG
168 cout << "G4HepRepSceneHandler::Open() stderr" << endl;
169#endif
170 writer = factory->createHepRepWriter(&cerr, false, false);
171 out = NULL;
172 baseName = name;
173 eventNumberPrefix = "";
174 eventNumberSuffix = "";
175 extension = "";
176 writeBinary = false;
177 writeZip = false;
178 writeGZ = false;
179 writeMultipleFiles = false;
180 eventNumber = 0;
181 eventNumberWidth = 0;
182 } else {
183#ifdef LDEBUG
184 cout << "G4HepRepSceneHandler::Open() " << name << endl;
185#endif
186 if (eventNumberWidth < 0) {
187 // derive filename(s)
188 // check for extensions
189 const unsigned int numberOfExtensions = 8;
190 string ext[numberOfExtensions] = {".heprep", ".heprep.xml", ".heprep.zip", ".heprep.gz",
191 ".bheprep", ".bheprep.xml", ".bheprep.zip", ".bheprep.gz"};
192 unsigned int i=0;
193 while (i < numberOfExtensions) {
194 int dot = name.size() - ext[i].size();
195 if ((dot >= 0) &&
196 (name.substr(dot, ext[i].size()) == ext[i])) break;
197 i++;
198 }
199
200 if (i != numberOfExtensions) {
201 extension = ext[i];
202 writeBinary = i >= (numberOfExtensions/2);
203 writeZip = (i == 2) || (i == 6);
204 writeGZ = (i == 3) || (i == 7);
205
206 int dot = name.length() - extension.length();
207 baseName = (dot >= 0) ? name.substr(0, dot) : "";
208
209#ifndef G4LIB_USE_ZLIB
210 if (writeGZ) {
211 cerr << endl;
212 cerr << "WARNING: the .gz output file you are creating will be a plain file," << endl;
213 cerr << " since compression support (ZLIB) was not compiled into the Geant4." << endl;
214 cerr << " To avoid confusion with real gz files, the output filename has been" << endl;
215 cerr << " extended with the name '.no-gz'." << endl;
216 cerr << " A plain heprep or bheprep file can be fairly large." << endl;
217 }
218 if (writeZip) {
219 cerr << endl;
220 cerr << "WARNING: the .zip output file you are creating will not be compressed," << endl;
221 cerr << " since compression support (ZLIB) was not compiled into the Geant4." << endl;
222 cerr << " A zip file containing non-compressed heprep or bheprep files can" << endl;
223 cerr << " be fairly large." << endl;
224 }
225 if (writeGZ || writeZip) {
226 cerr << "SOLUTION: To add compression support using ZLIB, you need to:" << endl;
227 cerr << " 1. Define G4LIB_USE_ZLIB and recompile the visualization category." << endl;
228 cerr << " 2. Optionally define G4_LIB_BUILD_ZLIB if your system does not have" << endl;
229 cerr << " zlib installed (e.g. WIN32-VC)." << endl;
230 cerr << " 3. Relink your application code." << endl;
231 cerr << endl;
232 }
233 if (writeGZ) {
234 extension = extension + ".no-gz";
235 writeGZ = false;
236 }
237#endif // G4LIB_USE_ZLIB
238 } else {
239 // Default for no extension
240 extension = ".heprep.zip";
241 writeBinary = false;
242 writeZip = true;
243 writeGZ = false;
244 baseName = name;
245 }
246
247 writeMultipleFiles = false;
248 int startDigit = -1; int endDigit = -1;
249 string suffix = messenger.getEventNumberSuffix();
250 if (suffix != "") {
251 // look for 0000 pattern in suffix
252 endDigit = suffix.length()-1;
253 while (endDigit >= 0) {
254 if (isdigit(suffix.at(endDigit))) break;
255 endDigit--;
256 }
257 if (endDigit < 0) {
258 cerr << "/vis/heprep/appendEventNumberSuffix contains no digits" << endl;
259 } else {
260 writeMultipleFiles = true;
261 startDigit = endDigit;
262 while (startDigit >= 0) {
263 if (!isdigit(suffix.at(startDigit))) break;
264 startDigit--;
265 }
266 startDigit++;
267 }
268 }
269
270 if (writeMultipleFiles) {
271 eventNumberPrefix = suffix.substr(0, startDigit);
272 eventNumber = atoi(suffix.substr(startDigit, endDigit).c_str());
273 eventNumberWidth = endDigit +1 - startDigit;
274 eventNumberSuffix = suffix.substr(endDigit+1);
275 } else {
276 // open single file here
277 openFile(baseName+extension);
278
279 eventNumber = 1;
280 eventNumberWidth = 10;
281 eventNumberPrefix = "";
282 eventNumberSuffix = "";
283 }
284 }
285 }
286}
287
288
289void G4HepRepSceneHandler::openHepRep() {
290#ifdef LDEBUG
291 cout << "G4HepRepSceneHandler::OpenHepRep() " << endl;
292#endif
293
294 if (_heprep != NULL) return;
295
296 // all done on demand, once pointers are set to NULL
297 _heprepGeometry = NULL;
298 _geometryInstanceTree = NULL;
299 _geometryRootInstance = NULL;
300 _geometryInstance.clear();
301 _geometryTypeTree = NULL;
302 _geometryRootType = NULL;
303 _geometryTypeName.clear();
304 _geometryType.clear();
305 _eventInstanceTree = NULL;
306 _eventInstance = NULL;
307 _eventTypeTree = NULL;
308 _eventType = NULL;
309 _trajectoryType = NULL;
310 _hitType = NULL;
311 _calHitType = NULL;
312 _calHitFaceType = NULL;
313}
314
315
316/**
317 * Returns true if the HepRep was (already) closed, false if the HepRep is still open
318 */
319bool G4HepRepSceneHandler::closeHepRep(bool final) {
320 if (_heprep == NULL) return true;
321
322#ifdef LDEBUG
323 cout << "G4HepRepSceneHandler::CloseHepRep() start" << endl;
324#endif
325
326 // if this is the final close, then there should not be any event pending to be written.
327 if (final) {
328 if (_eventInstanceTree != NULL) {
329 cerr << "WARNING: you probably used '/vis/viewer/endOfEventAction accumulate' and "
330 << "forgot to call /vis/viewer/update before exit. No event written." << endl;
331 }
332 } else {
333
334 // add geometry to the heprep if there is an event (separate geometries are written
335 // using DrawView() called from /vis/viewer/flush)
336 if (_eventInstanceTree != NULL) {
337 GetCurrentViewer()->DrawView();
338
339 // couple geometry
340 if (messenger.appendGeometry()) {
341 // couple geometry to event if geometry was written
342 if ((_geometryInstanceTree != NULL)) {
343 getEventInstanceTree()->addInstanceTree(getGeometryInstanceTree());
344 }
345 } else {
346 char name[128];
347 if (writeMultipleFiles) {
348 sprintf(name, "%s%s%s#%s", baseName.c_str(), "-geometry", extension.c_str(), "G4GeometryData");
349 } else {
350 sprintf(name, "%s%s#%s", "geometry", (writeBinary ? ".bheprep" : ".heprep"), "G4GeometryData");
351 }
352 getEventInstanceTree()->addInstanceTree(factory->createHepRepTreeID(name, "1.0"));
353 }
354 }
355
356 // force inclusion of all subtypes of event
357 if (_eventInstanceTree != NULL) {
358 getEventType();
359 getTrajectoryType();
360 getHitType();
361 getCalHitType();
362 getCalHitFaceType();
363 }
364
365 // Give this HepRep all of the layer order info for both geometry and event,
366 // since these will both end up in a single HepRep.
367 writeLayers(_heprepGeometry);
368 writeLayers(_heprep);
369
370 // open heprep file
371 if (writer == NULL) {
372 open((GetScene() == NULL) ? G4String("G4HepRepOutput.heprep.zip") : GetScene()->GetName());
373 }
374
375 // write out separate geometry
376 if (!messenger.appendGeometry() && (_heprepGeometry != NULL)) {
377 if (writeMultipleFiles) {
378 char fileName[128];
379 sprintf(fileName, "%s%s%s", baseName.c_str(), "-geometry", extension.c_str());
380 openFile(G4String(fileName));
381 }
382
383 char name[128];
384 sprintf(name, "%s%s", "geometry", (writeBinary ? ".bheprep" : ".heprep"));
385 if (!writeMultipleFiles) {
386 writer->addProperty("RecordLoop.ignore", name);
387 }
388
389 writer->write(_heprepGeometry, G4String(name));
390
391 delete _heprepGeometry;
392 _heprepGeometry = NULL;
393
394 if (writeMultipleFiles) closeFile();
395 }
396
397 if (writeMultipleFiles) {
398// NOTE: does not work on Solaris 5.2 and Linux 2.95.2
399// stringstream fileName;
400// fileName << baseName << eventNumberPrefix << setw(eventNumberWidth) << setfill('0') << eventNumber << eventNumberSuffix << extension;
401// openFile(fileName.str());
402// Use instead:
403 char fileName[128];
404 char fileFormat[128];
405 sprintf(fileFormat, "%s%d%s", "%s%s%0", eventNumberWidth, "d%s%s");
406 sprintf(fileName, fileFormat, baseName.c_str(), eventNumberPrefix.c_str(), eventNumber, eventNumberSuffix.c_str(), extension.c_str());
407 openFile(G4String(fileName));
408 }
409
410 // write out the heprep
411// NOTE: does not work on Solaris 5.2 and Linux 2.95.2
412// stringstream eventName;
413// eventName << "event-" << setw(eventNumberWidth) << setfill('0') << eventNumber << (writeBinary ? ".bheprep" : ".heprep");
414// writer->write(_heprep, eventName.str());
415// Use instead:
416 char eventName[128];
417 char eventFormat[128];
418 sprintf(eventFormat, "%s%d%s%s", "event-%0", eventNumberWidth, "d", (writeBinary ? ".bheprep" : ".heprep"));
419 sprintf(eventName, eventFormat, eventNumber);
420 writer->write(_heprep, G4String(eventName));
421
422 eventNumber++;
423 }
424
425 delete _heprep;
426 _heprep = NULL;
427
428 if (writeMultipleFiles) closeFile();
429
430 return true;
431}
432
433
434void G4HepRepSceneHandler::close() {
435
436#ifdef LDEBUG
437 cout << "G4HepRepSceneHandler::Close() " << endl;
438#endif
439
440 if (writer == NULL) return;
441
442 if (!writeMultipleFiles) {
443 closeHepRep(true);
444 closeFile();
445 }
446
447 G4HepRepViewer* viewer = dynamic_cast<G4HepRepViewer*>(GetCurrentViewer());
448 viewer->reset();
449}
450
451void G4HepRepSceneHandler::openFile(G4String name) {
452 out = new ofstream(name.c_str(), std::ios::out | std::ios::binary );
453 writer = factory->createHepRepWriter(out, writeZip, writeZip || writeGZ);
454}
455
456void G4HepRepSceneHandler::closeFile() {
457 writer->close();
458 delete writer;
459 writer = NULL;
460
461 delete out;
462 out = NULL;
463}
464
465void G4HepRepSceneHandler::writeLayers(HepRep* heprep) {
466 if (heprep == NULL) return;
467 heprep->addLayer(geometryLayer);
468 heprep->addLayer(eventLayer);
469 heprep->addLayer(calHitLayer);
470 heprep->addLayer(trajectoryLayer);
471 heprep->addLayer(hitLayer);
472}
473
474void G4HepRepSceneHandler::BeginModeling() {
475#ifdef SDEBUG
476 cout << "G4HepRepSceneHandler::BeginModeling() " << endl;
477#endif
478 G4VSceneHandler::BeginModeling();
479}
480
481
482void G4HepRepSceneHandler::EndModeling() {
483#ifdef SDEBUG
484 cout << "G4HepRepSceneHandler::EndModeling() " << endl;
485#endif
486 G4VSceneHandler::EndModeling();
487}
488
489void G4HepRepSceneHandler::AddSolid(const G4Box& box) {
490#ifdef SDEBUG
491 cout << "G4HepRepSceneHandler::AddSolid(const G4Box& box)" << endl;
492#endif
493
494 if (dontWrite()) return;
495
496 if (!messenger.useSolids()) {
497 G4VSceneHandler::AddSolid(box);
498 return;
499 }
500
501 G4double dx = box.GetXHalfLength();
502 G4double dy = box.GetYHalfLength();
503 G4double dz = box.GetZHalfLength();
504
505 G4Point3D vertex1(G4Point3D( dx, dy,-dz));
506 G4Point3D vertex2(G4Point3D( dx,-dy,-dz));
507 G4Point3D vertex3(G4Point3D(-dx,-dy,-dz));
508 G4Point3D vertex4(G4Point3D(-dx, dy,-dz));
509 G4Point3D vertex5(G4Point3D( dx, dy, dz));
510 G4Point3D vertex6(G4Point3D( dx,-dy, dz));
511 G4Point3D vertex7(G4Point3D(-dx,-dy, dz));
512 G4Point3D vertex8(G4Point3D(-dx, dy, dz));
513
514 vertex1 = (transform) * vertex1;
515 vertex2 = (transform) * vertex2;
516 vertex3 = (transform) * vertex3;
517 vertex4 = (transform) * vertex4;
518 vertex5 = (transform) * vertex5;
519 vertex6 = (transform) * vertex6;
520 vertex7 = (transform) * vertex7;
521 vertex8 = (transform) * vertex8;
522
523 HepRepInstance* instance = getGeometryOrEventInstance(getCalHitType());
524 addAttributes(instance, getCalHitType());
525
526 setAttribute(instance, "DrawAs", G4String("Prism"));
527
528 setVisibility(instance, box);
529 setLine(instance, box);
530 setColor(instance, getColorFor(box));
531
532 factory->createHepRepPoint(instance, vertex1.x(), vertex1.y(), vertex1.z());
533 factory->createHepRepPoint(instance, vertex2.x(), vertex2.y(), vertex2.z());
534 factory->createHepRepPoint(instance, vertex3.x(), vertex3.y(), vertex3.z());
535 factory->createHepRepPoint(instance, vertex4.x(), vertex4.y(), vertex4.z());
536 factory->createHepRepPoint(instance, vertex5.x(), vertex5.y(), vertex5.z());
537 factory->createHepRepPoint(instance, vertex6.x(), vertex6.y(), vertex6.z());
538 factory->createHepRepPoint(instance, vertex7.x(), vertex7.y(), vertex7.z());
539 factory->createHepRepPoint(instance, vertex8.x(), vertex8.y(), vertex8.z());
540}
541
542
543void G4HepRepSceneHandler::AddSolid(const G4Cons& cons) {
544#ifdef SDEBUG
545 cout << "G4HepRepSceneHandler::AddSolid(const G4Cons& cons)" << endl;
546#endif
547
548 if (dontWrite()) return;
549
550 if (!messenger.useSolids() || (cons.GetDeltaPhiAngle() < twopi)) {
551 G4VSceneHandler::AddSolid(cons);
552 return;
553 }
554
555 G4PhysicalVolumeModel* pPVModel =
556 dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
557 if (!pPVModel) {
558 G4VSceneHandler::AddSolid(cons);
559 return;
560 }
561
562 G4LogicalVolume* pCurrentLV = pPVModel->GetCurrentLV();
563 G4int currentDepth = pPVModel->GetCurrentDepth();
564 G4Material* pCurrentMaterial = pPVModel->GetCurrentMaterial();
565
566 G4Point3D vertex1(G4Point3D( 0., 0., cons.GetZHalfLength()));
567 G4Point3D vertex2(G4Point3D( 0., 0.,-cons.GetZHalfLength()));
568
569 vertex1 = (transform) * vertex1;
570 vertex2 = (transform) * vertex2;
571
572 HepRepInstance* instance = getGeometryInstance(pCurrentLV, pCurrentMaterial, currentDepth);
573 setAttribute(instance, "DrawAs", G4String("Cylinder"));
574
575 setVisibility(instance, cons);
576 setLine(instance, cons);
577 setColor(instance, getColorFor(cons));
578
579 HepRepType* type = getGeometryType(pCurrentLV->GetName(), currentDepth);
580
581 // Outer cylinder.
582 HepRepInstance* outer = factory->createHepRepInstance(instance, type);
583 outer->addAttValue("pickParent",true);
584 outer->addAttValue("showParentAttributes",true);
585
586 HepRepPoint* op1 = factory->createHepRepPoint(outer, vertex1.x(), vertex1.y(), vertex1.z());
587 op1->addAttValue("Radius",cons.GetOuterRadiusPlusZ());
588
589 HepRepPoint* op2 = factory->createHepRepPoint(outer, vertex2.x(), vertex2.y(), vertex2.z());
590 op2->addAttValue("Radius",cons.GetOuterRadiusMinusZ());
591
592 // Inner cylinder.
593 HepRepInstance* inner = factory->createHepRepInstance(instance, type);
594 inner->addAttValue("pickParent",true);
595 inner->addAttValue("showParentAttributes",true);
596
597 HepRepPoint* ip1 = factory->createHepRepPoint(inner, vertex1.x(), vertex1.y(), vertex1.z());
598 ip1->addAttValue("Radius",cons.GetInnerRadiusPlusZ());
599
600 HepRepPoint* ip2 = factory->createHepRepPoint(inner, vertex2.x(), vertex2.y(), vertex2.z());
601 ip2->addAttValue("Radius",cons.GetInnerRadiusMinusZ());
602}
603
604
605void G4HepRepSceneHandler::AddSolid(const G4Tubs& tubs) {
606#ifdef SDEBUG
607 cout << "G4HepRepSceneHandler::AddSolid(const G4Tubs& tubs)" << endl;
608#endif
609
610 if (dontWrite()) return;
611
612 if (!messenger.useSolids() || (tubs.GetDeltaPhiAngle() < twopi)) {
613 G4VSceneHandler::AddSolid(tubs);
614 return;
615 }
616
617 G4PhysicalVolumeModel* pPVModel =
618 dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
619 if (!pPVModel) {
620 G4VSceneHandler::AddSolid(tubs);
621 return;
622 }
623
624 G4LogicalVolume* pCurrentLV = pPVModel->GetCurrentLV();
625 G4int currentDepth = pPVModel->GetCurrentDepth();
626 G4Material* pCurrentMaterial = pPVModel->GetCurrentMaterial();
627
628 G4Point3D vertex1(G4Point3D( 0., 0., tubs.GetZHalfLength()));
629 G4Point3D vertex2(G4Point3D( 0., 0.,-tubs.GetZHalfLength()));
630
631 vertex1 = (transform) * vertex1;
632 vertex2 = (transform) * vertex2;
633
634 HepRepInstance* instance = getGeometryInstance(pCurrentLV, pCurrentMaterial, currentDepth);
635 setAttribute(instance, "DrawAs", G4String("Cylinder"));
636
637 setVisibility(instance, tubs);
638 setLine(instance, tubs);
639 setColor(instance, getColorFor(tubs));
640
641 HepRepType* type = getGeometryType(pCurrentLV->GetName(), currentDepth);
642
643 // Outer cylinder.
644 HepRepInstance* outer = factory->createHepRepInstance(instance, type);
645 outer->addAttValue("Radius",tubs.GetOuterRadius());
646 outer->addAttValue("pickParent",true);
647 outer->addAttValue("showParentAttributes",true);
648 factory->createHepRepPoint(outer, vertex1.x(), vertex1.y(), vertex1.z());
649 factory->createHepRepPoint(outer, vertex2.x(), vertex2.y(), vertex2.z());
650
651 // Inner cylinder.
652 if (tubs.GetInnerRadius() > 0.) {
653 HepRepInstance* inner = factory->createHepRepInstance(instance, type);
654 inner->addAttValue("Radius",tubs.GetInnerRadius());
655 inner->addAttValue("pickParent",true);
656 inner->addAttValue("showParentAttributes",true);
657 factory->createHepRepPoint(inner, vertex1.x(), vertex1.y(), vertex1.z());
658 factory->createHepRepPoint(inner, vertex2.x(), vertex2.y(), vertex2.z());
659 }
660}
661
662
663void G4HepRepSceneHandler::AddSolid(const G4Trd& trd) {
664#ifdef SDEBUG
665 cout << "G4HepRepSceneHandler::AddSolid(const G4Trd& trd)" << endl;
666#endif
667 if (dontWrite()) return;
668
669 if (!messenger.useSolids()) {
670 G4VSceneHandler::AddSolid(trd);
671 return;
672 }
673
674 G4double dx1 = trd.GetXHalfLength1();
675 G4double dy1 = trd.GetYHalfLength1();
676 G4double dx2 = trd.GetXHalfLength2();
677 G4double dy2 = trd.GetYHalfLength2();
678 G4double dz = trd.GetZHalfLength();
679
680 G4Point3D vertex1(G4Point3D( dx1, dy1,-dz));
681 G4Point3D vertex2(G4Point3D( dx1,-dy1,-dz));
682 G4Point3D vertex3(G4Point3D(-dx1,-dy1,-dz));
683 G4Point3D vertex4(G4Point3D(-dx1, dy1,-dz));
684 G4Point3D vertex5(G4Point3D( dx2, dy2, dz));
685 G4Point3D vertex6(G4Point3D( dx2,-dy2, dz));
686 G4Point3D vertex7(G4Point3D(-dx2,-dy2, dz));
687 G4Point3D vertex8(G4Point3D(-dx2, dy2, dz));
688
689 vertex1 = (transform) * vertex1;
690 vertex2 = (transform) * vertex2;
691 vertex3 = (transform) * vertex3;
692 vertex4 = (transform) * vertex4;
693 vertex5 = (transform) * vertex5;
694 vertex6 = (transform) * vertex6;
695 vertex7 = (transform) * vertex7;
696 vertex8 = (transform) * vertex8;
697
698 HepRepInstance* instance = getGeometryOrEventInstance(getCalHitType());
699
700 addAttributes(instance, getCalHitType());
701
702 setAttribute(instance, "DrawAs", G4String("Prism"));
703
704 setVisibility(instance, trd);
705 setLine(instance, trd);
706 setColor(instance, getColorFor(trd));
707
708 factory->createHepRepPoint(instance, vertex1.x(), vertex1.y(), vertex1.z());
709 factory->createHepRepPoint(instance, vertex2.x(), vertex2.y(), vertex2.z());
710 factory->createHepRepPoint(instance, vertex3.x(), vertex3.y(), vertex3.z());
711 factory->createHepRepPoint(instance, vertex4.x(), vertex4.y(), vertex4.z());
712 factory->createHepRepPoint(instance, vertex5.x(), vertex5.y(), vertex5.z());
713 factory->createHepRepPoint(instance, vertex6.x(), vertex6.y(), vertex6.z());
714 factory->createHepRepPoint(instance, vertex7.x(), vertex7.y(), vertex7.z());
715 factory->createHepRepPoint(instance, vertex8.x(), vertex8.y(), vertex8.z());
716}
717
718void G4HepRepSceneHandler::AddSolid (const G4Trap& trap) {
719 if (dontWrite()) return;
720 G4VSceneHandler::AddSolid (trap);
721}
722
723void G4HepRepSceneHandler::AddSolid (const G4Sphere& sphere) {
724 if (dontWrite()) return;
725 G4VSceneHandler::AddSolid (sphere);
726}
727
728void G4HepRepSceneHandler::AddSolid (const G4Para& para) {
729 if (dontWrite()) return;
730 G4VSceneHandler::AddSolid (para);
731}
732
733void G4HepRepSceneHandler::AddSolid (const G4Torus& torus) {
734 if (dontWrite()) return;
735 G4VSceneHandler::AddSolid (torus);
736}
737
738void G4HepRepSceneHandler::AddSolid (const G4Polycone& polycone) {
739 if (dontWrite()) return;
740 G4VSceneHandler::AddSolid (polycone);
741}
742
743void G4HepRepSceneHandler::AddSolid (const G4Polyhedra& polyhedra) {
744 if (dontWrite()) return;
745 G4VSceneHandler::AddSolid (polyhedra);
746}
747
748void G4HepRepSceneHandler::AddSolid (const G4VSolid& solid) {
749 if (dontWrite()) return;
750 G4VSceneHandler::AddSolid(solid);
751}
752
753
754void G4HepRepSceneHandler::AddPrimitive (const G4Polyline& line) {
755
756#ifdef PDEBUG
757 cout << "G4HepRepSceneHandler::AddPrimitive(G4Polyline&) " << line.size() << endl;
758#endif
759 if (dontWrite()) return;
760
761 HepRepInstance* instance = factory->createHepRepInstance(getEventInstance(), getTrajectoryType());
762
763 addAttributes(instance, getTrajectoryType());
764
765 setColor(instance, GetColor(line));
766
767 setVisibility(instance, line);
768
769 setLine(instance, line);
770
771 for (size_t i=0; i < line.size(); i++) {
772 G4Point3D vertex = transform * line[i];
773 factory->createHepRepPoint(instance, vertex.x(), vertex.y(), vertex.z());
774 }
775}
776
777
778void G4HepRepSceneHandler::AddPrimitive (const G4Polymarker& line) {
779
780#ifdef PDEBUG
781 cout << "G4HepRepSceneHandler::AddPrimitive(G4Polymarker&) " << line.size() << endl;
782#endif
783 if (dontWrite()) return;
784
785 HepRepInstance* instance = factory->createHepRepInstance(getEventInstance(), getHitType());
786
787 addAttributes(instance, getHitType());
788
789 setColor(instance, GetColor(line));
790
791 setVisibility(instance, line);
792
793 setMarker(instance, line);
794
795 // Default MarkName is set to Circle for this Type.
796 int mtype = line.GetMarkerType();
797
798 // Cannot be case statement since line.xxx is not a constant
799 if (mtype == line.dots) {
800 setAttribute(instance, "Fill", true);
801 setColor(instance, GetColor(line), G4String("FillColor"));
802 } else if (mtype == line.circles) {
803 } else if (line.squares) {
804 setAttribute(instance, "MarkName", G4String("Box"));
805 } else {
806 // line.line + default
807 setAttribute(instance, "MarkName", G4String("Plus"));
808 }
809
810 for (size_t i=0; i < line.size(); i++) {
811 G4Point3D vertex = transform * line[i];
812 factory->createHepRepPoint(instance, vertex.x(), vertex.y(), vertex.z());
813 }
814}
815
816
817void G4HepRepSceneHandler::AddPrimitive (const G4Circle& circle) {
818#ifdef PDEBUG
819 cout << "G4HepRepSceneHandler::AddPrimitive(G4Circle&) " << endl;
820#endif
821 if (dontWrite()) return;
822
823 HepRepInstance* instance = factory->createHepRepInstance(getEventInstance(), getHitType());
824
825 addAttributes(instance, getHitType());
826
827 G4Point3D center = transform * circle.GetPosition();
828
829 setColor (instance, GetColor(circle));
830
831 setVisibility(instance, circle);
832
833 setMarker(instance, circle);
834
835 factory->createHepRepPoint(instance, center.x(), center.y(), center.z());
836}
837
838
839void G4HepRepSceneHandler::AddPrimitive (const G4Polyhedron& polyhedron) {
840
841#ifdef PDEBUG
842 cout << "G4HepRepSceneHandler::AddPrimitive(G4Polyhedron&) " << endl;
843#endif
844 if (dontWrite()) return;
845
846 G4Normal3D surfaceNormal;
847 G4Point3D vertex;
848
849 if (polyhedron.GetNoFacets()==0) return;
850
851 HepRepInstance* instance = getGeometryOrEventInstance(getCalHitType());
852
853 addAttributes(instance, getCalHitType());
854
855 setVisibility(instance, polyhedron);
856
857 G4int currentDepth = 0;
858 G4PhysicalVolumeModel* pPVModel =
859 dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
860 if (pPVModel) currentDepth = pPVModel->GetCurrentDepth();
861
862 G4bool notLastFace;
863 do {
864 HepRepInstance* face;
865 if (isEventData()) {
866 face = factory->createHepRepInstance(instance, getCalHitFaceType());
867 } else {
868 face = getGeometryInstance("*Face", currentDepth+1);
869 setAttribute(face, "PickParent", true);
870 setAttribute(face, "DrawAs", G4String("Polygon"));
871 }
872
873 setLine(face, polyhedron);
874 setColor(face, GetColor(polyhedron));
875 if (isEventData()) setColor(face, GetColor(polyhedron), G4String("FillColor"));
876
877 notLastFace = polyhedron.GetNextNormal (surfaceNormal);
878
879 G4int edgeFlag = 1;
880 G4bool notLastEdge;
881 do {
882 notLastEdge = polyhedron.GetNextVertex (vertex, edgeFlag);
883 vertex = transform * vertex;
884 factory->createHepRepPoint(face, vertex.x(), vertex.y(), vertex.z());
885 } while (notLastEdge);
886 } while (notLastFace);
887}
888
889
890void G4HepRepSceneHandler::AddPrimitive (const G4Text&) {
891#ifdef PDEBUG
892 cout << "G4HepRepSceneHandler::AddPrimitive(G4Text&) " << endl;
893#endif
894 if (dontWrite()) return;
895
896 cout << "G4HepRepSceneHandler::AddPrimitive G4Text : not yet implemented. " << endl;
897}
898
899
900void G4HepRepSceneHandler::AddPrimitive (const G4Square& square) {
901#ifdef PDEBUG
902 cout << "G4HepRepSceneHandler::AddPrimitive(G4Square&) " << endl;
903#endif
904 if (dontWrite()) return;
905
906 HepRepInstance* instance = factory->createHepRepInstance(getEventInstance(), getHitType());
907
908 addAttributes(instance, getHitType());
909
910 G4Point3D center = transform * square.GetPosition();
911
912 setColor (instance, getColorFor(square));
913
914 setVisibility(instance, square);
915
916 setMarker(instance, square);
917
918 factory->createHepRepPoint(instance, center.x(), center.y(), center.z());
919}
920
921void G4HepRepSceneHandler::AddPrimitive (const G4NURBS&) {
922#ifdef PDEBUG
923 cout << "G4HepRepSceneHandler::AddPrimitive(G4NURBS&) " << endl;
924#endif
925 if (dontWrite()) return;
926
927 cout << "G4HepRepSceneHandler::AddPrimitive G4NURBS : not yet implemented. " << endl;
928}
929
930void G4HepRepSceneHandler::AddPrimitive (const G4Scale& scale) {
931 if (dontWrite()) return;
932 G4VSceneHandler::AddPrimitive(scale);
933}
934
935void G4HepRepSceneHandler::AddCompound (const G4VTrajectory& trajectory) {
936#ifdef PDEBUG
937 cout << "G4HepRepSceneHandler::AddCompound(G4VTrajectory&) " << endl;
938#endif
939 if (dontWrite()) return;
940
941 currentTrack = &trajectory;
942 G4VSceneHandler::AddCompound(trajectory);
943 currentTrack = NULL;
944}
945
946
947void G4HepRepSceneHandler::AddCompound (const G4VHit& hit) {
948#ifdef PDEBUG
949 cout << "G4HepRepSceneHandler::AddCompound(G4VHit&) " << endl;
950#endif
951 if (dontWrite()) return;
952
953 currentHit = &hit;
954 G4VSceneHandler::AddCompound(hit);
955 currentHit = NULL;
956}
957
958void G4HepRepSceneHandler::PreAddSolid (const G4Transform3D& objectTransformation,
959 const G4VisAttributes& visAttribs) {
960
961 G4VSceneHandler::PreAddSolid (objectTransformation, visAttribs);
962
963 transform = objectTransformation;
964#ifdef SDEBUG
965 cout << "G4HepRepSceneHandler::PreAddSolid(G4Transform3D&, G4VisAttributes&)" << endl;
966#endif
967}
968
969
970void G4HepRepSceneHandler::PostAddSolid () {
971#ifdef SDEBUG
972 cout << "G4HepRepSceneHandler::PostAddSolid()" << endl;
973#endif
974 G4VSceneHandler::PostAddSolid();
975}
976
977
978void G4HepRepSceneHandler::BeginPrimitives (const G4Transform3D& objectTransformation) {
979#ifdef SDEBUG
980 cout << "G4HepRepSceneHandler::BeginPrimitives(G4Transform3D&)" << endl;
981#endif
982
983 G4VSceneHandler::BeginPrimitives (objectTransformation);
984 transform = objectTransformation;
985}
986
987
988void G4HepRepSceneHandler::EndPrimitives () {
989#ifdef SDEBUG
990 cout << "G4HepRepSceneHandler::EndPrimitives" << endl;
991#endif
992 G4VSceneHandler::EndPrimitives ();
993}
994
995
996G4bool G4HepRepSceneHandler::dontWrite() {
997 return !(messenger.writeInvisibles() || (fpVisAttribs ? (bool)fpVisAttribs->IsVisible() : true));
998}
999
1000void G4HepRepSceneHandler::setColor (HepRepAttribute *attribute,
1001 const G4Color& color,
1002 const G4String& key) {
1003#ifdef CDEBUG
1004 cout << "G4HepRepSceneHandler::setColor : red : " << color.GetRed () <<
1005 " green : " << color.GetGreen () <<
1006 " blue : " << color.GetBlue () << endl;
1007#endif
1008
1009 setAttribute(attribute, key, color.GetRed(), color.GetGreen(), color.GetBlue(), color.GetAlpha());
1010}
1011
1012G4Color G4HepRepSceneHandler::getColorFor (const G4VSolid& /* solid */) {
1013 return fpVisAttribs ? fpVisAttribs->GetColor() : GetColor(NULL);
1014}
1015
1016G4Color G4HepRepSceneHandler::getColorFor (const G4Visible& visible) {
1017 return GetColor(visible);
1018}
1019
1020void G4HepRepSceneHandler::setVisibility (HepRepAttribute *attribute, const G4VSolid& /* solid */) {
1021 setAttribute(attribute, "Visibility", (fpVisAttribs ? (bool)fpVisAttribs->IsVisible() : true));
1022}
1023
1024void G4HepRepSceneHandler::setVisibility ( HepRepAttribute *attribute, const G4Visible& visible) {
1025 const G4VisAttributes* atts = visible.GetVisAttributes();
1026
1027 setAttribute(attribute, "Visibility", (atts && (atts->IsVisible()==0)) ? false : true);
1028}
1029
1030void G4HepRepSceneHandler::setLine (HepRepAttribute *attribute, const G4VSolid& /* solid*/) {
1031 setAttribute(attribute, "LineWidth", 1.0);
1032}
1033
1034void G4HepRepSceneHandler::setLine (HepRepAttribute *attribute, const G4Visible& visible) {
1035 const G4VisAttributes* atts = visible.GetVisAttributes();
1036
1037 setAttribute(attribute, "LineWidth", (atts != NULL) ? atts->GetLineWidth() : 1.0);
1038
1039 if (atts != NULL) {
1040 switch (atts->GetLineStyle()) {
1041 case G4VisAttributes::dotted:
1042 setAttribute(attribute, "LineStyle", G4String("Dotted"));
1043 break;
1044 case G4VisAttributes::dashed:
1045 setAttribute(attribute, "LineStyle", G4String("Dashed"));
1046 break;
1047 case G4VisAttributes::unbroken:
1048 default:
1049 break;
1050 }
1051 }
1052}
1053
1054void G4HepRepSceneHandler::setMarker (HepRepAttribute *attribute, const G4VMarker& marker) {
1055 MarkerSizeType markerType;
1056 G4double size = GetMarkerRadius( marker , markerType );
1057
1058 setAttribute(attribute, "MarkSize", size);
1059
1060 if (markerType == screen) setAttribute(attribute, "MarkType", G4String("Symbol"));
1061 if (marker.GetFillStyle() == G4VMarker::noFill) {
1062 setAttribute(attribute, "Fill", false);
1063 } else {
1064 setColor(attribute, GetColor(marker), G4String("FillColor"));
1065 }
1066}
1067
1068void G4HepRepSceneHandler::addAttributes(HepRepInstance* instance, HepRepType* type) {
1069 if (currentHit) {
1070 vector<G4AttValue>* hitAttValues = currentHit->CreateAttValues();
1071 const map<G4String,G4AttDef>* hitAttDefs = currentHit->GetAttDefs();
1072
1073 addAttDefs(getHitType(), hitAttDefs);
1074
1075 // these attValues are non-standard, so can only be added when we have the attDef.
1076 type->addAttValue("LVol", G4String(""));
1077 type->addAttValue("HitType", G4String(""));
1078 type->addAttValue("ID", -1);
1079 type->addAttValue("Column", -1);
1080 type->addAttValue("Row", -1);
1081 type->addAttValue("Energy", 0.0);
1082 type->addAttValue("Pos", G4String(""));
1083
1084 addAttVals(instance, hitAttDefs, hitAttValues);
1085
1086 delete hitAttValues;
1087
1088 } else if (currentTrack) {
1089 vector<G4AttValue>* trajectoryAttValues = currentTrack->CreateAttValues();
1090 const map<G4String,G4AttDef>* trajectoryAttDefs = currentTrack->GetAttDefs();
1091
1092 addAttDefs(type, trajectoryAttDefs);
1093
1094 // these attValues are non-standard, so can only be added when we have the attDef.
1095 type->addAttValue("Ch", 0.0);
1096 type->addAttValue("Color", 1.0, 1.0, 1.0, 1.0);
1097 type->addAttValue("ID", -1);
1098 type->addAttValue("IMom", G4String(""));
1099 type->addAttValue("IMag", 0.0);
1100 type->addAttValue("PDG", -1);
1101 type->addAttValue("PN", G4String(""));
1102 type->addAttValue("PID", -1);
1103
1104 addAttVals(instance, trajectoryAttDefs, trajectoryAttValues);
1105
1106 delete trajectoryAttValues;
1107
1108 }
1109}
1110
1111void G4HepRepSceneHandler::setAttribute(HepRepAttribute* attribute, G4String name, G4String value) {
1112 HepRepAttValue* attValue = attribute->getAttValue(name);
1113 if ((attValue == NULL) || (attValue->getString() != value)) {
1114 HepRepPoint* point = dynamic_cast<HepRepPoint*>(attribute);
1115 if (point != NULL) {
1116 if (point->getInstance()->getAttValueFromNode(name) == NULL) {
1117 attribute = point->getInstance();
1118 }
1119 }
1120
1121 HepRepInstance* instance = dynamic_cast<HepRepInstance*>(attribute);
1122 if (instance != NULL) {
1123 // look for definition on type (node only)
1124 if (instance->getType()->getAttValueFromNode(name) == NULL) {
1125 attribute = instance->getType();
1126 }
1127 }
1128
1129 attribute->addAttValue(name, value);
1130 }
1131}
1132
1133void G4HepRepSceneHandler::setAttribute(HepRepAttribute* attribute, G4String name, bool value) {
1134 HepRepAttValue* attValue = attribute->getAttValue(name);
1135 if ((attValue == NULL) || (attValue->getBoolean() != value)) {
1136 HepRepPoint* point = dynamic_cast<HepRepPoint*>(attribute);
1137 if (point != NULL) {
1138 if (point->getInstance()->getAttValueFromNode(name) == NULL) {
1139 attribute = point->getInstance();
1140 }
1141 }
1142
1143 HepRepInstance* instance = dynamic_cast<HepRepInstance*>(attribute);
1144 if (instance != NULL) {
1145 // look for definition on type (node only)
1146 if (instance->getType()->getAttValueFromNode(name) == NULL) {
1147 attribute = instance->getType();
1148 }
1149 }
1150
1151 attribute->addAttValue(name, value);
1152 }
1153}
1154
1155void G4HepRepSceneHandler::setAttribute(HepRepAttribute* attribute, G4String name, double value) {
1156 HepRepAttValue* attValue = attribute->getAttValue(name);
1157 if ((attValue == NULL) || (attValue->getDouble() != value)) {
1158 HepRepPoint* point = dynamic_cast<HepRepPoint*>(attribute);
1159 if (point != NULL) {
1160 if (point->getInstance()->getAttValueFromNode(name) == NULL) {
1161 attribute = point->getInstance();
1162 }
1163 }
1164
1165 HepRepInstance* instance = dynamic_cast<HepRepInstance*>(attribute);
1166 if (instance != NULL) {
1167 // look for definition on type (node only)
1168 if (instance->getType()->getAttValueFromNode(name) == NULL) {
1169 attribute = instance->getType();
1170 }
1171 }
1172
1173 attribute->addAttValue(name, value);
1174 }
1175}
1176
1177void G4HepRepSceneHandler::setAttribute(HepRepAttribute* attribute, G4String name, int value) {
1178 HepRepAttValue* attValue = attribute->getAttValue(name);
1179 if ((attValue == NULL) || (attValue->getInteger() != value)) {
1180 HepRepPoint* point = dynamic_cast<HepRepPoint*>(attribute);
1181 if (point != NULL) {
1182 if (point->getInstance()->getAttValueFromNode(name) == NULL) {
1183 attribute = point->getInstance();
1184 }
1185 }
1186
1187 HepRepInstance* instance = dynamic_cast<HepRepInstance*>(attribute);
1188 if (instance != NULL) {
1189 // look for definition on type (node only)
1190 if (instance->getType()->getAttValueFromNode(name) == NULL) {
1191 attribute = instance->getType();
1192 }
1193 }
1194
1195 attribute->addAttValue(name, value);
1196 }
1197}
1198
1199void G4HepRepSceneHandler::setAttribute(HepRepAttribute* attribute, G4String name, double red, double green, double blue, double alpha) {
1200 HepRepAttValue* attValue = attribute->getAttValue(name);
1201 vector<double> color;
1202 if (attValue != NULL) color = attValue->getColor();
1203 if ((color.size() == 0) ||
1204 (color[0] != red) ||
1205 (color[1] != green) ||
1206 (color[2] != blue) ||
1207 ((color.size() > 3) && (color[3] != alpha))) {
1208
1209 HepRepPoint* point = dynamic_cast<HepRepPoint*>(attribute);
1210 if (point != NULL) {
1211 if (point->getInstance()->getAttValueFromNode(name) == NULL) {
1212 attribute = point->getInstance();
1213 }
1214 }
1215
1216 HepRepInstance* instance = dynamic_cast<HepRepInstance*>(attribute);
1217 if (instance != NULL) {
1218 // look for definition on type (node only)
1219 if (instance->getType()->getAttValueFromNode(name) == NULL) {
1220 attribute = instance->getType();
1221 }
1222 }
1223
1224 attribute->addAttValue(name, red, green, blue, alpha);
1225 }
1226}
1227
1228void G4HepRepSceneHandler::addAttDefs(HepRepDefinition* definition, const map<G4String,G4AttDef>* attDefs) {
1229 if (attDefs == NULL) return;
1230
1231 // Specify additional attribute definitions.
1232 map<G4String,G4AttDef>::const_iterator attDefIterator = attDefs->begin();
1233 while (attDefIterator != attDefs->end()) {
1234 definition->addAttDef(attDefIterator->first, attDefIterator->second.GetDesc(),
1235 attDefIterator->second.GetCategory(), attDefIterator->second.GetExtra());
1236 attDefIterator++;
1237 }
1238}
1239
1240void G4HepRepSceneHandler::addAttVals(HepRepAttribute* attribute, const map<G4String,G4AttDef>* attDefs, vector<G4AttValue>* attValues) {
1241 if (attValues == NULL) return;
1242
1243 // Copy the instance's G4AttValues to HepRepAttValues.
1244 for (vector<G4AttValue>::iterator attValIterator = attValues->begin(); attValIterator != attValues->end(); attValIterator++) {
1245 G4String name = attValIterator->GetName();
1246
1247 HepRepPoint* point = dynamic_cast<HepRepPoint*>(attribute);
1248 if ((name == "Pos") && (point != NULL)) {
1249 G4String pos = attValIterator->GetValue();
1250// cout << "Pos* " << pos << endl;
1251 int s = 0;
1252 int n = 0;
1253 int m = 0;
1254 G4String unit;
1255 for (unsigned int i=0; i<pos.length(); i++) {
1256 if (pos[i] == ' ') {
1257 if (n == 0) {
1258 // first coordinate
1259 double factor = atof(pos.substr(s, i-s).c_str())/point->getX();
1260 m = (int)(std::log10(factor)+((factor < 1) ? -0.5 : 0.5));
1261// cout << factor << ", " << m << endl;
1262 } else if (n == 3) {
1263 // unit
1264 unit = pos.substr(s, i-s);
1265 if (unit == G4String("mum")) {
1266 m += -6;
1267 } else if (unit == G4String("mm")) {
1268 m += -3;
1269 } else if (unit == G4String("cm")) {
1270 m += -2;
1271 } else if (unit == G4String("m")) {
1272 m += 0;
1273 } else if (unit == G4String("km")) {
1274 m += 3;
1275 } else {
1276 cerr << "HepRepSceneHandler: Unrecognized Unit: '" << unit << "'" << endl;
1277 }
1278 }
1279 s = i+1;
1280 n++;
1281 }
1282 }
1283 switch(m) {
1284 case -6:
1285 unit = G4String("mum");
1286 break;
1287 case -3:
1288 unit = G4String("mm");
1289 break;
1290 case -2:
1291 unit = G4String("cm");
1292 break;
1293 case 0:
1294 unit = G4String("m");
1295 break;
1296 case 3:
1297 unit = G4String("km");
1298 break;
1299 default:
1300 cerr << "HepRepSceneHandler: No valid unit found for m: " << m << endl;
1301 unit = G4String("*m");
1302 break;
1303 }
1304// cout << "U: " << unit << endl;
1305 setAttribute(attribute, G4String("PointUnit"), unit);
1306 continue;
1307 }
1308
1309 // NTP already in points being written
1310 if (name == "NTP") continue;
1311
1312 // find type of attribute using def
1313 const map<G4String,G4AttDef>::const_iterator attDefIterator = attDefs->find(name);
1314 G4String type = attDefIterator->second.GetValueType();
1315
1316 // set based on type
1317 if ((type == "G4double") || (type == "double")) {
1318 setAttribute(attribute, attValIterator->GetName(), atof(attValIterator->GetValue()));
1319 } else if ((type == "G4int") || (type == "int")) {
1320 setAttribute(attribute, attValIterator->GetName(), atoi(attValIterator->GetValue()));
1321 } else { // G4String, string and others
1322 setAttribute(attribute, attValIterator->GetName(), attValIterator->GetValue());
1323 }
1324 }
1325}
1326
1327
1328bool G4HepRepSceneHandler::isEventData () {
1329 G4PhysicalVolumeModel* pPVModel =
1330 dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
1331 return !pPVModel || fReadyForTransients || currentHit || currentTrack;
1332}
1333
1334void G4HepRepSceneHandler::addTopLevelAttributes(HepRepType* type) {
1335
1336 // Some non-standard attributes
1337 type->addAttDef( "Generator", "Generator of the file", "General", "");
1338 type->addAttValue("Generator", G4String("Geant4"));
1339
1340 type->addAttDef( "GeneratorVersion", "Version of the Generator", "General", "");
1341 G4String versionString = G4Version;
1342 versionString = versionString.substr(1,versionString.size()-2);
1343 versionString = " Geant4 version " + versionString + " " + G4Date;
1344 type->addAttValue("GeneratorVersion", versionString);
1345
1346 const G4ViewParameters parameters = GetCurrentViewer()->GetViewParameters();
1347 const G4Vector3D& viewPointDirection = parameters.GetViewpointDirection();
1348 type->addAttDef( "ViewTheta", "Theta of initial suggested viewpoint", "Draw", "rad");
1349 type->addAttValue("ViewTheta", viewPointDirection.theta());
1350
1351 type->addAttDef( "ViewPhi", "Phi of initial suggested viewpoint", "Draw", "rad");
1352 type->addAttValue("ViewPhi", viewPointDirection.phi());
1353
1354 type->addAttDef( "ViewScale", "Scale of initial suggested viewpoint", "Draw", "");
1355 type->addAttValue("ViewScale", parameters.GetZoomFactor());
1356
1357// FIXME, no way to set these
1358 type->addAttDef( "ViewTranslateX", "Translate in X of initial suggested viewpoint", "Draw", "");
1359 type->addAttValue("ViewTranslateX", 0.0);
1360
1361 type->addAttDef( "ViewTranslateY", "Translate in Y of initial suggested viewpoint", "Draw", "");
1362 type->addAttValue("ViewTranslateY", 0.0);
1363
1364 type->addAttDef( "ViewTranslateZ", "Translate in Z of initial suggested viewpoint", "Draw", "");
1365 type->addAttValue("ViewTranslateZ", 0.0);
1366
1367 type->addAttDef( "PointUnit", "Length", "Physics", "");
1368 type->addAttValue("PointUnit", G4String("m"));
1369
1370 type->addAttDef( "UseSolids", "Use HepRep Solids rather than Geant4 Primitives", "Draw", "");
1371 type->addAttValue("UseSolids", messenger.useSolids());
1372
1373 type->addAttDef( "WriteInvisibles", "Write Invisible Objects", "Draw", "");
1374 type->addAttValue("WriteInvisibles", messenger.writeInvisibles());
1375}
1376
1377
1378HepRepInstance* G4HepRepSceneHandler::getGeometryOrEventInstance(HepRepType* type) {
1379 if (isEventData()) {
1380 return factory->createHepRepInstance(getEventInstance(), type);
1381 } else {
1382 G4PhysicalVolumeModel* pPVModel =
1383 dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
1384 G4LogicalVolume* pCurrentLV = pPVModel->GetCurrentLV();
1385 G4int currentDepth = pPVModel->GetCurrentDepth();
1386 G4Material* pCurrentMaterial = pPVModel->GetCurrentMaterial();
1387 return getGeometryInstance(pCurrentLV, pCurrentMaterial, currentDepth);
1388 }
1389}
1390
1391HepRep* G4HepRepSceneHandler::getHepRep() {
1392 if (_heprep == NULL) {
1393 // Create the HepRep that holds the Trees.
1394 _heprep = factory->createHepRep();
1395 }
1396 return _heprep;
1397}
1398
1399HepRep* G4HepRepSceneHandler::getHepRepGeometry() {
1400 if (_heprepGeometry == NULL) {
1401 // Create the HepRep that holds the Trees.
1402 _heprepGeometry = factory->createHepRep();
1403 }
1404 return _heprepGeometry;
1405}
1406
1407HepRepInstanceTree* G4HepRepSceneHandler::getGeometryInstanceTree() {
1408 if (_geometryInstanceTree == NULL) {
1409 // Create the Geometry InstanceTree.
1410 _geometryInstanceTree = factory->createHepRepInstanceTree("G4GeometryData", "1.0", getGeometryTypeTree());
1411 if (messenger.appendGeometry()) {
1412 getHepRep()->addInstanceTree(_geometryInstanceTree);
1413 } else {
1414 getHepRepGeometry()->addInstanceTree(_geometryInstanceTree);
1415 }
1416 }
1417 return _geometryInstanceTree;
1418}
1419
1420HepRepInstance* G4HepRepSceneHandler::getGeometryRootInstance() {
1421 if (_geometryRootInstance == NULL) {
1422 // Create the top level Geometry Instance.
1423 _geometryRootInstance = factory->createHepRepInstance(getGeometryInstanceTree(), getGeometryRootType());
1424 }
1425 return _geometryRootInstance;
1426}
1427
1428HepRepInstance* G4HepRepSceneHandler::getGeometryInstance(G4LogicalVolume* volume, G4Material* material, int depth) {
1429 HepRepInstance* instance = getGeometryInstance(volume->GetName(), depth);
1430
1431 setAttribute(instance, "LVol", volume->GetName());
1432 G4Region* region = volume->GetRegion();
1433 G4String regionName = region? region->GetName(): G4String("No region");
1434 setAttribute(instance, "Region", regionName);
1435 setAttribute(instance, "RootRegion", volume->IsRootRegion());
1436 setAttribute(instance, "Solid", volume->GetSolid()->GetName());
1437 setAttribute(instance, "EType", volume->GetSolid()->GetEntityType());
1438 G4String matName = material? material->GetName(): G4String("No material");
1439 setAttribute(instance, "Material", matName );
1440 G4double matDensity = material? material->GetDensity(): 0.;
1441 setAttribute(instance, "Density", matDensity);
1442 G4double matRadlen = material? material->GetRadlen(): 0.;
1443 setAttribute(instance, "Radlen", matRadlen);
1444
1445 G4State matState = material? material->GetState(): kStateUndefined;
1446 G4String state = materialState[matState];
1447 setAttribute(instance, "State", state);
1448
1449 return instance;
1450}
1451
1452HepRepInstance* G4HepRepSceneHandler::getGeometryInstance(G4String volumeName, int depth) {
1453 // no extra checks since these are done in the geometryType already
1454
1455 // adjust depth, also pop the current instance
1456 while ((int)_geometryInstance.size() > depth) {
1457 _geometryInstance.pop_back();
1458 }
1459
1460 // get parent
1461 HepRepInstance* parent = (_geometryInstance.empty()) ? getGeometryRootInstance() : _geometryInstance.back();
1462
1463 // get type
1464 HepRepType* type = getGeometryType(volumeName, depth);
1465
1466 // create instance
1467 HepRepInstance* instance = factory->createHepRepInstance(parent, type);
1468 _geometryInstance.push_back(instance);
1469
1470 return instance;
1471}
1472
1473HepRepTypeTree* G4HepRepSceneHandler::getGeometryTypeTree() {
1474 if (_geometryTypeTree == NULL) {
1475 // Create the Geometry TypeTree.
1476 HepRepTreeID* geometryTreeID = factory->createHepRepTreeID("G4GeometryTypes", "1.0");
1477 _geometryTypeTree = factory->createHepRepTypeTree(geometryTreeID);
1478 if (messenger.appendGeometry()) {
1479 getHepRep()->addTypeTree(_geometryTypeTree);
1480 } else {
1481 getHepRepGeometry()->addTypeTree(_geometryTypeTree);
1482 }
1483 }
1484 return _geometryTypeTree;
1485}
1486
1487HepRepType* G4HepRepSceneHandler::getGeometryRootType() {
1488 if (_geometryRootType == NULL) {
1489 // Create the top level Geometry Type.
1490 _geometryRootType = factory->createHepRepType(getGeometryTypeTree(), rootVolumeName);
1491 _geometryRootType->addAttValue("Layer", geometryLayer);
1492
1493 // Add attdefs used by all geometry types.
1494 _geometryRootType->addAttDef ("LVol", "Logical Volume", "Physics","");
1495 _geometryRootType->addAttValue("LVol", G4String(""));
1496 _geometryRootType->addAttDef ("Region", "Cuts Region", "Physics","");
1497 _geometryRootType->addAttValue("Region", G4String(""));
1498 _geometryRootType->addAttDef ("RootRegion", "Root Region", "Physics","");
1499 _geometryRootType->addAttValue("RootRegion", false);
1500 _geometryRootType->addAttDef ("Solid", "Solid Name", "Physics","");
1501 _geometryRootType->addAttValue("Solid", G4String(""));
1502 _geometryRootType->addAttDef ("EType", "Entity Type", "Physics","");
1503 _geometryRootType->addAttValue("EType", G4String("G4Box"));
1504 _geometryRootType->addAttDef ("Material", "Material Name", "Physics","");
1505 _geometryRootType->addAttValue("Material", G4String("Air"));
1506 _geometryRootType->addAttDef ("Density", "Material Density", "Physics","");
1507 _geometryRootType->addAttValue("Density", 0.0);
1508 _geometryRootType->addAttDef ("State", "Material State", "Physics","");
1509 _geometryRootType->addAttValue("State", G4String("Gas"));
1510 _geometryRootType->addAttDef ("Radlen", "Material Radiation Length", "Physics","");
1511 _geometryRootType->addAttValue("Radlen", 0.0);
1512
1513 // add defaults for Geometry
1514 _geometryRootType->addAttValue("Color", 0.8, 0.8, 0.8, 1.0);
1515 _geometryRootType->addAttValue("Visibility", true);
1516 _geometryRootType->addAttValue("FillColor", 0.8, 0.8, 0.8, 1.0);
1517 _geometryRootType->addAttValue("LineWidth", 1.0);
1518 _geometryRootType->addAttValue("DrawAs", G4String("Polygon"));
1519 _geometryRootType->addAttValue("PickParent", false);
1520 _geometryRootType->addAttValue("ShowParentAttributes", true);
1521
1522 _geometryRootType->addAttValue("MarkSizeMultiplier", 4.0);
1523 _geometryRootType->addAttValue("LineWidthMultiplier", 1.0);
1524
1525 addTopLevelAttributes(_geometryRootType);
1526
1527 _geometryType["/"+_geometryRootType->getName()] = _geometryRootType;
1528 }
1529 return _geometryRootType;
1530}
1531
1532HepRepType* G4HepRepSceneHandler::getGeometryType(G4String volumeName, int depth) {
1533 // make sure we have a root
1534 getGeometryRootType();
1535
1536 // construct the full name for this volume
1537 G4String name = getFullTypeName(volumeName, depth);
1538
1539 // lookup type and create if necessary
1540 HepRepType* type = _geometryType[name];
1541 if (type == NULL) {
1542 G4String parentName = getParentTypeName(depth);
1543 HepRepType* parentType = _geometryType[parentName];
1544 // HepRep uses hierarchical names
1545 type = factory->createHepRepType(parentType, volumeName);
1546 _geometryType[name] = type;
1547 }
1548 return type;
1549}
1550
1551G4String G4HepRepSceneHandler::getFullTypeName(G4String volumeName, int depth) {
1552 // check for name depth
1553 if (depth > (int)_geometryTypeName.size()) {
1554 // there is a problem, book this type under problems
1555 G4String problem = "HierarchyProblem";
1556 if (_geometryType["/"+problem] == NULL) {
1557 // HepRep uses hierarchical names
1558 HepRepType* type = factory->createHepRepType(getGeometryRootType(), problem);
1559 _geometryType["/"+problem] = type;
1560 }
1561 return "/" + problem + "/" + volumeName;
1562 }
1563
1564 // adjust name depth, also pop the current volumeName
1565 while ((int)_geometryTypeName.size() > depth) {
1566 _geometryTypeName.pop_back();
1567 }
1568
1569 // construct full name and push it
1570 G4String name = (_geometryTypeName.empty()) ? G4String("/"+rootVolumeName) : _geometryTypeName.back();
1571 name = name + "/" + volumeName;
1572 _geometryTypeName.push_back(name);
1573 return name;
1574}
1575
1576G4String G4HepRepSceneHandler::getParentTypeName(int depth) {
1577 return (depth >= 1) ? _geometryTypeName[depth-1] : G4String("/"+rootVolumeName);
1578}
1579
1580HepRepInstanceTree* G4HepRepSceneHandler::getEventInstanceTree() {
1581 if (_eventInstanceTree == NULL) {
1582 // Create the Event InstanceTree.
1583 _eventInstanceTree = factory->createHepRepInstanceTree("G4EventData", "1.0", getEventTypeTree());
1584 getHepRep()->addInstanceTree(_eventInstanceTree);
1585 }
1586 return _eventInstanceTree;
1587}
1588
1589HepRepInstance* G4HepRepSceneHandler::getEventInstance() {
1590 if (_eventInstance == NULL) {
1591 // Create the top level Event Instance.
1592 _eventInstance = factory->createHepRepInstance(getEventInstanceTree(), getEventType());
1593 }
1594 return _eventInstance;
1595}
1596
1597HepRepTypeTree* G4HepRepSceneHandler::getEventTypeTree() {
1598 if (_eventTypeTree == NULL) {
1599 // Create the Event TypeTree.
1600 HepRepTreeID* eventTreeID = factory->createHepRepTreeID("G4EventTypes", "1.0");
1601 _eventTypeTree = factory->createHepRepTypeTree(eventTreeID);
1602 getHepRep()->addTypeTree(_eventTypeTree);
1603 }
1604
1605 return _eventTypeTree;
1606}
1607
1608HepRepType* G4HepRepSceneHandler::getEventType() {
1609 if (_eventType == NULL) {
1610 // Create the top level Event Type.
1611 _eventType = factory->createHepRepType(getEventTypeTree(), "Event");
1612 _eventType->addAttValue("Layer", eventLayer);
1613
1614 // add defaults for Events
1615 _eventType->addAttValue("Visibility", true);
1616 _eventType->addAttValue("Color", 1.0, 1.0, 1.0, 1.0);
1617 _eventType->addAttValue("FillColor", 1.0, 1.0, 1.0, 1.0);
1618 _eventType->addAttValue("LineWidth", 1.0);
1619 _eventType->addAttValue("HasFrame", true);
1620 _eventType->addAttValue("PickParent", false);
1621 _eventType->addAttValue("ShowParentAttributes", false);
1622
1623 _eventType->addAttValue("MarkSizeMultiplier", 4.0);
1624 _eventType->addAttValue("LineWidthMultiplier", 1.0);
1625
1626 addTopLevelAttributes(_eventType);
1627 }
1628
1629 return _eventType;
1630}
1631
1632HepRepType* G4HepRepSceneHandler::getTrajectoryType() {
1633 if (_trajectoryType == NULL) {
1634 _trajectoryType = factory->createHepRepType(getEventType(), "Trajectory");
1635
1636 _trajectoryType->addAttValue("Layer", trajectoryLayer);
1637 _trajectoryType->addAttValue("DrawAs", G4String("Line"));
1638
1639 _trajectoryType->addAttValue("LineWidthMultiplier", 2.0);
1640
1641 // attributes to draw the points of a track as markers.
1642 _trajectoryType->addAttValue("MarkName", G4String("Box"));
1643 _trajectoryType->addAttValue("MarkSize", 4);
1644 _trajectoryType->addAttValue("MarkType", G4String("Symbol"));
1645 _trajectoryType->addAttValue("Fill", true);
1646 }
1647 return _trajectoryType;
1648}
1649
1650HepRepType* G4HepRepSceneHandler::getHitType() {
1651 if (_hitType == NULL) {
1652 _hitType = factory->createHepRepType(getEventType(), "Hit");
1653 _hitType->addAttValue("Layer", hitLayer);
1654 _hitType->addAttValue("DrawAs", G4String("Point"));
1655 _hitType->addAttValue("MarkName", G4String("Box"));
1656 _hitType->addAttValue("MarkSize", 4.0);
1657 _hitType->addAttValue("MarkType", G4String("Symbol"));
1658 _hitType->addAttValue("Fill", true);
1659 }
1660 return _hitType;
1661}
1662
1663HepRepType* G4HepRepSceneHandler::getCalHitType() {
1664 if (_calHitType == NULL) {
1665 _calHitType = factory->createHepRepType(getEventType(), "CalHit");
1666 _calHitType->addAttValue("Layer", calHitLayer);
1667 _calHitType->addAttValue("Fill", true);
1668 _calHitType->addAttValue("DrawAs", G4String("Polygon"));
1669 }
1670 return _calHitType;
1671}
1672
1673HepRepType* G4HepRepSceneHandler::getCalHitFaceType() {
1674 if (_calHitFaceType == NULL) {
1675 _calHitFaceType = factory->createHepRepType(getCalHitType(), "CalHitFace");
1676 _calHitFaceType->addAttValue("PickParent", true);
1677 }
1678 return _calHitFaceType;
1679}
1680
Note: See TracBrowser for help on using the repository browser.