Context Navigation

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

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: