]>
Commit | Line | Data |
---|---|---|
2817d3e2 | 1 | // $Id$ |
2 | // Category: visualization | |
3 | // | |
4 | // According to visualization/management/include/MyVisManager.* | |
5 | // John Allison 24th January 1998. | |
6 | // I. Hrivnacova 12.5.98 | |
7 | // | |
8 | // Renamed to TG4VisManager | |
9 | // I. Hrivnacova, 3.9.99 | |
10 | // | |
11 | // Added AliMC implementation | |
12 | // A. Gheata, 22.2.00 | |
13 | // | |
14 | // Added OpenGL*Win32, RayTracer (as replacement of RayX) drivers | |
15 | // based on G4 suggestions. | |
16 | // I. Gonzalez, 4.4.2000 | |
17 | // | |
18 | // Example Visualization Manager description: | |
19 | // Implements virtual function RegisterGraphicsSystems. | |
20 | // Exploits C-pre-processor variables G4VIS_USE_DAWN, etc., | |
21 | // which are set by the G4 makefiles if | |
22 | // environment variables of the same name are set. | |
23 | // | |
24 | // So all you have to do is set environment variables and compile and | |
25 | // instantiate this in your main(). | |
26 | // | |
27 | // Alternatively, you can implement an empty function here and just | |
28 | // register the systems you want in your main(), e.g.: | |
29 | // G4VisManager* myVisManager = new MyVisManager; | |
30 | // myVisManager -> RegisterGraphicsSystem (new MyGraphicsSystem); | |
31 | ||
32 | ||
304cd517 | 33 | #ifdef G4VIS_USE |
34 | ||
35 | #include "TG4VisManager.h" | |
2817d3e2 | 36 | #include "TG4Globals.h" |
37 | ||
38 | #include <G4LogicalVolumeStore.hh> | |
39 | #include <G4PhysicalVolumeStore.hh> | |
2817d3e2 | 40 | #include <G4TransportationManager.hh> |
41 | #include <G4Material.hh> | |
304cd517 | 42 | #include <G4PhysicalVolumeModel.hh> |
2817d3e2 | 43 | #include <G4VVisManager.hh> |
44 | ||
45 | // Supported drivers... | |
46 | ||
47 | #ifdef G4VIS_USE_DAWN | |
48 | #include <G4FukuiRenderer.hh> | |
49 | #endif | |
50 | ||
51 | #ifdef G4VIS_USE_DAWNFILE | |
52 | #include <G4DAWNFILE.hh> | |
53 | #endif | |
54 | ||
55 | #ifdef G4VIS_USE_OPACS | |
56 | #include <G4Wo.hh> | |
57 | #include <G4Xo.hh> | |
58 | #endif | |
59 | ||
60 | #ifdef G4VIS_USE_OPENGLX | |
61 | #include <G4OpenGLImmediateX.hh> | |
62 | #include <G4OpenGLStoredX.hh> | |
63 | #endif | |
64 | ||
65 | #ifdef G4VIS_USE_OPENGLXM | |
66 | #include <G4OpenGLImmediateXm.hh> | |
67 | #include <G4OpenGLStoredXm.hh> | |
68 | #endif | |
69 | ||
70 | #ifdef G4VIS_USE_OPENGLWIN32 | |
71 | #include "G4OpenGLImmediateWin32.hh" | |
72 | #include "G4OpenGLStoredWin32.hh" | |
73 | #endif | |
74 | ||
75 | #ifdef G4VIS_USE_OIX | |
76 | #include <G4OpenInventorX.hh> | |
77 | #endif | |
78 | ||
79 | #ifdef G4VIS_USE_OIWIN32 | |
80 | #include <G4OpenInventorWin32.hh> | |
81 | #endif | |
82 | ||
83 | #ifdef G4VIS_USE_RAYTRACER | |
84 | #include "G4RayTracer.hh" | |
85 | #endif | |
86 | ||
87 | #ifdef G4VIS_USE_VRML | |
88 | #include <G4VRML1.hh> | |
89 | #include <G4VRML2.hh> | |
90 | #endif | |
91 | ||
92 | #ifdef G4VIS_USE_VRMLFILE | |
93 | #include <G4VRML1File.hh> | |
94 | #include <G4VRML2File.hh> | |
95 | #endif | |
96 | ||
97 | TG4VisManager::TG4VisManager(G4int verboseLevel) { | |
98 | // | |
99 | fVerbose = verboseLevel; | |
100 | fColourFlag = true; | |
101 | } | |
102 | ||
103 | TG4VisManager::TG4VisManager(const TG4VisManager& right) { | |
104 | // | |
105 | TG4Globals::Exception( | |
106 | "Attempt to copy TG4VisManager singleton."); | |
107 | } | |
108 | ||
109 | TG4VisManager::~TG4VisManager() { | |
110 | // | |
111 | } | |
112 | ||
113 | // operators | |
114 | ||
115 | TG4VisManager& TG4VisManager::operator=(const TG4VisManager& right) | |
116 | { | |
117 | // check assignement to self | |
118 | if (this == &right) return *this; | |
119 | ||
120 | TG4Globals::Exception( | |
121 | "Attempt to assign TG4VisManager singleton."); | |
122 | ||
123 | return *this; | |
124 | } | |
125 | ||
126 | // private methods | |
127 | ||
128 | void TG4VisManager::RegisterGraphicsSystems() | |
129 | { | |
130 | // Registers the graphics systems. | |
131 | // --- | |
132 | ||
133 | // all created graphics system instances are | |
134 | // deleted in G4VisManager::~G4VisManager() | |
135 | #ifdef G4VIS_USE_DAWN | |
136 | RegisterGraphicsSystem(new G4FukuiRenderer); | |
137 | #endif | |
138 | ||
139 | #ifdef G4VIS_USE_DAWNFILE | |
140 | RegisterGraphicsSystem(new G4DAWNFILE); | |
141 | #endif | |
142 | ||
143 | #ifdef G4VIS_USE_OPACS | |
144 | RegisterGraphicsSystem(new G4Wo); | |
145 | RegisterGraphicsSystem(new G4Xo); | |
146 | #endif | |
147 | ||
148 | #ifdef G4VIS_USE_OPENGLX | |
149 | RegisterGraphicsSystem(new G4OpenGLImmediateX); | |
150 | RegisterGraphicsSystem(new G4OpenGLStoredX); | |
151 | #endif | |
152 | ||
153 | #ifdef G4VIS_USE_OPENGLXM | |
154 | RegisterGraphicsSystem(new G4OpenGLImmediateXm); | |
155 | RegisterGraphicsSystem(new G4OpenGLStoredXm); | |
156 | #endif | |
157 | ||
158 | #ifdef G4VIS_USE_OPENGLWIN32 | |
159 | RegisterGraphicsSystem (new G4OpenGLImmediateWin32); | |
160 | RegisterGraphicsSystem (new G4OpenGLStoredWin32); | |
161 | #endif | |
162 | ||
163 | #ifdef G4VIS_USE_OIX | |
164 | RegisterGraphicsSystem(new G4OpenInventorX); | |
165 | #endif | |
166 | ||
167 | #ifdef G4VIS_USE_OIWIN32 | |
168 | RegisterGraphicsSystem(new G4OpenInventorWin32); | |
169 | #endif | |
170 | ||
171 | #ifdef G4VIS_USE_RAYTRACER | |
172 | RegisterGraphicsSystem (new G4RayTracer); | |
173 | #endif | |
174 | ||
175 | #ifdef G4VIS_USE_VRML | |
176 | RegisterGraphicsSystem(new G4VRML1); | |
177 | RegisterGraphicsSystem(new G4VRML2); | |
178 | #endif | |
179 | ||
180 | #ifdef G4VIS_USE_VRMLFILE | |
181 | RegisterGraphicsSystem(new G4VRML1File); | |
182 | RegisterGraphicsSystem(new G4VRML2File); | |
183 | #endif | |
184 | ||
185 | if (fVerbose > 0) { | |
3c7cd15a | 186 | G4cout << |
2817d3e2 | 187 | "\nYou have successfully chosen to use the following graphics systems." |
3c7cd15a | 188 | << G4endl; |
2817d3e2 | 189 | PrintAvailableGraphicsSystems(); |
190 | } | |
191 | } | |
192 | ||
193 | //--------------------------------------------------------------- | |
194 | // private methods | |
195 | //--------------------------------------------------------------- | |
196 | ||
197 | ||
198 | G4RWTPtrOrderedVector<G4LogicalVolume> TG4VisManager::GetLVList(G4String name) | |
199 | { | |
200 | // Get function returning the list of logical volumes | |
201 | // associated to NAME; G4 built clones of a G3 volume (identified | |
202 | // with NAME_NUMBER will be added to the list) | |
203 | // NAME can be the name of a logical or physical volume | |
204 | // --- | |
205 | ||
206 | G4RWTPtrOrderedVector <G4LogicalVolume> lvList; | |
207 | G4LogicalVolumeStore* pLVStore = G4LogicalVolumeStore::GetInstance(); | |
208 | G4LogicalVolume* pLV = 0; | |
209 | if (pLVStore) | |
210 | { | |
211 | for (G4int i=0; i<pLVStore->entries(); i++) | |
212 | { | |
213 | pLV = pLVStore->at(i); | |
214 | if (CaseInsensitiveEqual(name,pLV->GetName())) | |
215 | { | |
216 | if (!lvList.contains(pLV)) lvList.append(pLV); | |
217 | } | |
218 | } | |
219 | } | |
220 | if (!lvList.isEmpty()) return lvList; | |
221 | G4PhysicalVolumeStore* pPVStore = G4PhysicalVolumeStore::GetInstance(); | |
222 | G4VPhysicalVolume* pPV = 0; | |
223 | if (pPVStore) | |
224 | { | |
225 | for (G4int i=0; i<pPVStore->entries(); i++) | |
226 | { | |
227 | pPV = pPVStore->at(i); | |
228 | if (CaseInsensitiveEqual(name,pPV->GetName())) | |
229 | { | |
230 | pLV = pPV->GetLogicalVolume(); | |
231 | if (!lvList.contains(pLV)) lvList.append(pLV); | |
232 | } | |
233 | } | |
234 | } | |
235 | return lvList; | |
236 | } | |
237 | ||
238 | ||
239 | G4RWTPtrOrderedVector<G4VPhysicalVolume> TG4VisManager::GetPVList(G4String name) | |
240 | { | |
241 | // Get function returning the physical volume pointer for NAME | |
242 | // --- | |
243 | ||
244 | G4RWTPtrOrderedVector <G4VPhysicalVolume> pvList; | |
245 | G4PhysicalVolumeStore* pPVStore = G4PhysicalVolumeStore::GetInstance(); | |
246 | if (!pPVStore) | |
247 | { | |
248 | TG4Globals::Warning("TG4VisManager::Gdraw : No volume store !"); | |
249 | return pvList; | |
250 | } | |
251 | G4VPhysicalVolume* pPV = 0; | |
252 | for (G4int i=0; i<pPVStore->entries(); i++) | |
253 | { | |
254 | pPV = pPVStore->at(i); | |
255 | if (CaseInsensitiveEqual(name,pPV->GetName())) | |
256 | { | |
257 | if (!pvList.contains(pPV)) pvList.append(pPV); | |
258 | } | |
259 | } | |
260 | return pvList; | |
261 | } | |
262 | ||
263 | ||
264 | G4bool TG4VisManager::CaseInsensitiveEqual(const G4String string1, | |
265 | const G4String string2) | |
266 | { | |
267 | // Case insensitive comparison of 2 strings | |
268 | // --- | |
269 | ||
270 | G4int i; | |
271 | if (string1 == string2) return true; | |
272 | // if (string1.length() != string2.length()) return false; | |
273 | for (i=0; i<string1.length(); i++) | |
274 | { | |
275 | G4int diff = abs((G4int)string1(i)-(G4int)string2(i)); | |
276 | if (diff && (diff!=32)) return false; | |
277 | } | |
278 | if (string2.length() > string1.length()) | |
279 | { | |
280 | if (string2(i) == '_') return true; | |
281 | return false; | |
282 | } | |
283 | return true; | |
284 | } | |
285 | ||
286 | ||
287 | void TG4VisManager::SetAtt4Daughters(G4LogicalVolume* const lv, | |
5317affd | 288 | const TG4G3Attribute att, const G4int val) |
2817d3e2 | 289 | { |
290 | // Iterator for setting a visual attribute for all daughters | |
291 | // --- | |
292 | ||
293 | SetG4Attribute(lv,att,val); | |
294 | ||
295 | G4String lvName = lv->GetName(); | |
296 | G4int nOfDaughters = lv->GetNoDaughters(); | |
297 | if (nOfDaughters>0) | |
298 | { | |
299 | G4String previousName = ""; | |
300 | for (G4int i=0; i<nOfDaughters; i++) | |
301 | { | |
302 | G4LogicalVolume* lvd = lv->GetDaughter(i)->GetLogicalVolume(); | |
303 | G4String currentName = lvd->GetName(); | |
304 | if (currentName != lvName && currentName != previousName) | |
305 | { | |
306 | SetAtt4Daughters(lvd, att, val); | |
307 | previousName = currentName; | |
308 | } | |
309 | } | |
310 | } | |
311 | } | |
312 | ||
313 | ||
314 | G4bool TG4VisManager::IsSharedVisAttributes(const G4LogicalVolume* pLV) | |
315 | { | |
316 | // Function seeking if the volume's visible attributes are shared with | |
317 | // other volumes | |
318 | // --- | |
319 | ||
320 | G4LogicalVolumeStore* pLVStore = G4LogicalVolumeStore::GetInstance(); | |
321 | G4LogicalVolume* pLVCurrent = 0; | |
322 | const G4VisAttributes* pVisAtt = pLV->GetVisAttributes(); | |
323 | if (!pVisAtt) return false; | |
324 | for (G4int i=0; i<pLVStore->entries(); i++) | |
325 | { | |
326 | pLVCurrent = pLVStore->at(i); | |
327 | if (pLVCurrent != pLV) | |
328 | { | |
329 | if (pLVCurrent->GetVisAttributes() == pVisAtt) | |
330 | { | |
331 | return true; | |
332 | } | |
333 | } | |
334 | } | |
335 | return false; | |
336 | } | |
337 | ||
338 | ||
339 | void TG4VisManager::SetG4Attribute(G4LogicalVolume* const lv, | |
5317affd | 340 | const TG4G3Attribute att, const G4int val) |
2817d3e2 | 341 | { |
342 | // Set the G4 attribute fo volume LV accordingly to the G3 description | |
343 | // of (att- val) | |
344 | // -- | |
345 | ||
346 | if (!lv) return; | |
347 | // Dupplicating old vis. attributes | |
348 | const G4VisAttributes* visAttributes = lv->GetVisAttributes(); | |
349 | G4VisAttributes* newVisAttributes; | |
350 | if (!visAttributes) | |
351 | newVisAttributes = new G4VisAttributes(false); | |
0e8db0fe | 352 | else { |
353 | G4bool visibility = visAttributes->IsVisible(); | |
354 | G4Colour colour = visAttributes->GetColour(); | |
355 | newVisAttributes = new G4VisAttributes(visibility, colour); | |
356 | } | |
2817d3e2 | 357 | |
b15a2a93 | 358 | const G4int kAbsVal = abs(val); // the functionality is given by the abs value |
2817d3e2 | 359 | |
360 | // Default visible attributes | |
361 | G4double red(0),green(0),blue(0); // default is black | |
362 | G4bool isVisible(false); | |
363 | G4bool isDaughtersInvisible(false); | |
364 | G4VisAttributes::LineStyle lineStyle = G4VisAttributes::unbroken; | |
365 | G4double lineWidth = 1.0; | |
366 | G4bool isForceDrawingStyle(false); | |
367 | G4VisAttributes::ForcedDrawingStyle drawingStyle = G4VisAttributes::wireframe; | |
368 | ||
369 | // a 'hardcopy' of old vis attributes is needed because the copy constructor | |
370 | // resets to defaults some of the data members of G4VisAttributes class | |
371 | if (visAttributes) | |
372 | { | |
373 | isVisible = visAttributes->IsVisible(); | |
374 | isDaughtersInvisible = visAttributes->IsDaughtersInvisible(); | |
375 | red = visAttributes->GetColour().GetRed(); | |
376 | green = visAttributes->GetColour().GetGreen(); | |
377 | blue = visAttributes->GetColour().GetBlue(); // old RGB components | |
378 | lineStyle = visAttributes->GetLineStyle(); | |
379 | lineWidth = visAttributes->GetLineWidth(); | |
380 | isForceDrawingStyle = visAttributes->IsForceDrawingStyle(); | |
381 | if (isForceDrawingStyle) | |
382 | drawingStyle = visAttributes->GetForcedDrawingStyle(); | |
383 | ||
384 | } | |
385 | G4double luminosityBin(0.04), // bin for luminosity | |
386 | luminosity(0); // colour luminosity | |
387 | ||
388 | // Delete old vis. attributes if they are not shared | |
389 | if (visAttributes && !IsSharedVisAttributes(lv)) delete visAttributes; | |
390 | ||
391 | // Set the required attribute | |
392 | switch (att) | |
393 | { | |
394 | case kSEEN: | |
395 | switch (val) | |
396 | { | |
397 | case 0: | |
398 | isVisible = false; | |
399 | break; | |
400 | case 1: | |
401 | isVisible = true; | |
402 | break; | |
403 | case -1: | |
404 | isVisible = false; | |
405 | break; | |
406 | case -2: | |
407 | isVisible = false; | |
408 | break; | |
409 | default: | |
410 | isVisible = false; | |
411 | } | |
412 | break; | |
413 | case kLSTY: | |
b15a2a93 | 414 | switch (kAbsVal) |
2817d3e2 | 415 | { |
416 | case 1: | |
417 | lineStyle = G4VisAttributes::unbroken; break; | |
418 | case 2: | |
419 | lineStyle = G4VisAttributes::dashed; break; | |
420 | case 3: | |
421 | lineStyle = G4VisAttributes::dotted; break; | |
422 | default: | |
423 | if (fVerbose > 0) | |
3c7cd15a | 424 | G4cout << "TG4VisManager::Gsatt() Usage of LSTY :" << G4endl |
425 | << "ATT = 1,2,3 means line unbroken, dashed or dotted" << G4endl | |
426 | << "any other value resets to the default : unbroken" << G4endl; | |
2817d3e2 | 427 | lineStyle = G4VisAttributes::unbroken; |
428 | } | |
429 | break; | |
430 | case kLWID: | |
b15a2a93 | 431 | lineWidth = kAbsVal; |
2817d3e2 | 432 | if (lineWidth > 7) lineWidth = 7; |
433 | if (fVerbose > 0) | |
3c7cd15a | 434 | G4cout << "TG4VisManager::Gsatt() Usage for LWID :" << G4endl |
2817d3e2 | 435 | << " The VAL you supply means the width of lines in pixels " |
3c7cd15a | 436 | << "for the screen and in 0.1*mm for paper." << G4endl |
2817d3e2 | 437 | << " Negative values means the same, but for all daughters" |
3c7cd15a | 438 | << G4endl; |
2817d3e2 | 439 | break; |
440 | case kCOLO: | |
b15a2a93 | 441 | if (kAbsVal < 8) // G3 base colours |
2817d3e2 | 442 | { |
b15a2a93 | 443 | switch (kAbsVal) |
2817d3e2 | 444 | { |
445 | case 1: | |
446 | red=0; green=0; blue=0; //black | |
447 | break; | |
448 | case 2: | |
449 | red=1; green=0; blue=0; //red | |
450 | break; | |
451 | case 3: | |
452 | red=0; green=1; blue=0; //green | |
453 | break; | |
454 | case 4: | |
455 | red=0; green=0; blue=1; //blue | |
456 | break; | |
457 | case 5: | |
458 | red=1; green=1; blue=0; //yellow | |
459 | break; | |
460 | case 6: | |
461 | red=1; green=0; blue=1; //violet | |
462 | break; | |
463 | case 7: | |
464 | red=0; green=1; blue=1; //lightblue (almost !) | |
465 | } | |
466 | luminosity = 0.; | |
467 | } | |
b15a2a93 | 468 | if (kAbsVal>=8 && kAbsVal<=16) |
2817d3e2 | 469 | { |
470 | red=0; green=0; blue=0; | |
b15a2a93 | 471 | luminosity = (kAbsVal-7)*luminosityBin; |
2817d3e2 | 472 | } |
b15a2a93 | 473 | if (kAbsVal>=17 && kAbsVal<=41) |
2817d3e2 | 474 | { |
475 | red=1; green=0; blue=0; | |
b15a2a93 | 476 | luminosity = (kAbsVal-16)*luminosityBin; |
2817d3e2 | 477 | } |
b15a2a93 | 478 | if (kAbsVal>=67 && kAbsVal<=91) |
2817d3e2 | 479 | { |
480 | red=0; green=1; blue=0; | |
b15a2a93 | 481 | luminosity = (kAbsVal-66)*luminosityBin; |
2817d3e2 | 482 | } |
b15a2a93 | 483 | if (kAbsVal>=117 && kAbsVal<=141) |
2817d3e2 | 484 | { |
485 | red=0; green=0; blue=1; | |
b15a2a93 | 486 | luminosity = (kAbsVal-116)*luminosityBin; |
2817d3e2 | 487 | } |
b15a2a93 | 488 | if (kAbsVal>=42 && kAbsVal<=66) |
2817d3e2 | 489 | { |
490 | red=1; green=1; blue=0; | |
b15a2a93 | 491 | luminosity = (kAbsVal-41)*luminosityBin; |
2817d3e2 | 492 | } |
b15a2a93 | 493 | if (kAbsVal>=142 && kAbsVal<=166) |
2817d3e2 | 494 | { |
495 | red=1; green=0; blue=1; | |
b15a2a93 | 496 | luminosity = (kAbsVal-141)*luminosityBin; |
2817d3e2 | 497 | } |
b15a2a93 | 498 | if (kAbsVal>=92 && kAbsVal<=116) |
2817d3e2 | 499 | { |
500 | red=0; green=1; blue=1; | |
b15a2a93 | 501 | luminosity = (kAbsVal-91)*luminosityBin; |
2817d3e2 | 502 | } |
503 | if (red < luminosityBin) red += luminosity; | |
504 | if (green < luminosityBin) green += luminosity; | |
505 | if (blue < luminosityBin) blue += luminosity; | |
506 | break; | |
507 | case kFILL: | |
508 | isForceDrawingStyle = true; | |
b15a2a93 | 509 | switch (kAbsVal) |
2817d3e2 | 510 | { |
511 | case 0: | |
512 | drawingStyle = G4VisAttributes::wireframe; | |
513 | break; | |
514 | case 1: | |
515 | drawingStyle = G4VisAttributes::solid; | |
516 | break; | |
517 | default: | |
518 | if (fVerbose > 0) | |
3c7cd15a | 519 | G4cout << "TG4VisManager::Gsatt() FILL usage :" << G4endl |
520 | << " The FILL values you can supply are only :" << G4endl | |
521 | << "+/- 1 : forces wireframe drawing (default)" << G4endl | |
522 | << "+/- 2 : forces solid drawing" << G4endl | |
2817d3e2 | 523 | << "other values sets the drawing style to solid" |
3c7cd15a | 524 | << G4endl; |
2817d3e2 | 525 | drawingStyle = G4VisAttributes::solid; |
526 | } | |
527 | } | |
528 | // Register vis. attributes | |
529 | newVisAttributes->SetVisibility(isVisible); | |
530 | newVisAttributes->SetDaughtersInvisible(isDaughtersInvisible); | |
531 | newVisAttributes->SetColour(red,green,blue); | |
532 | newVisAttributes->SetLineStyle(lineStyle); | |
533 | newVisAttributes->SetLineWidth(lineWidth); | |
534 | if (drawingStyle == G4VisAttributes::wireframe) | |
535 | newVisAttributes->SetForceWireframe(isForceDrawingStyle); | |
536 | if (drawingStyle == G4VisAttributes::solid) | |
537 | newVisAttributes->SetForceSolid(isForceDrawingStyle); | |
538 | ||
539 | lv->SetVisAttributes(newVisAttributes); | |
540 | } | |
541 | ||
542 | //----------------------------------------------------------------- | |
543 | // functions for drawing | |
544 | //----------------------------------------------------------------- | |
545 | ||
546 | void TG4VisManager::DrawOneSpec(const char* name) | |
547 | { | |
548 | // Function called when one double-clicks on a volume name | |
549 | // in a TPaveLabel drawn by Gdtree | |
550 | // --- | |
551 | ||
552 | G4cout << "TG4VisManager::DrawOneSpec() Not yet implemented"; | |
553 | } | |
554 | ||
555 | ||
556 | void TG4VisManager::SetColors() | |
557 | { | |
558 | // Function for setting default volume colours | |
559 | // --- | |
560 | ||
561 | G4LogicalVolumeStore* pLVStore = G4LogicalVolumeStore::GetInstance(); | |
562 | const G4LogicalVolume* pLV = 0; | |
563 | if (!pLVStore) | |
564 | { | |
565 | TG4Globals::Warning("TG4VisManager::SetColors : Ignored, geometry not built."); | |
566 | return; | |
567 | } | |
568 | // parse the LV tree and set colours according to material density | |
569 | for (G4int i=0; i<pLVStore->entries(); i++) | |
570 | { | |
571 | pLV = pLVStore->at(i); | |
3c7cd15a | 572 | // G4cout << "VOLUME : " << pLV->GetName() << G4endl; |
2817d3e2 | 573 | const G4Material* pMaterial = pLV->GetMaterial(); |
b15a2a93 | 574 | const G4State kState = pMaterial->GetState(); |
2817d3e2 | 575 | G4double density = (pMaterial->GetDensity())*cm3/g; |
576 | G4String nState = "Undefined"; | |
577 | G4int colour = 1; //black by default | |
578 | G4double luminosity = 0.; | |
b15a2a93 | 579 | if (kState == kStateUndefined) |
2817d3e2 | 580 | { |
581 | nState = "Undefined"; | |
582 | } | |
b15a2a93 | 583 | if (kState == kStateSolid) |
2817d3e2 | 584 | { |
585 | nState = "Solid"; | |
586 | if (density < 2) | |
587 | { | |
588 | colour = 17; //red | |
589 | luminosity = 25 - 25*density/2; | |
590 | } | |
591 | else if (density < 3) | |
592 | { | |
593 | colour = 117; //blue | |
594 | luminosity = 25 - 25*(density-2); | |
595 | } | |
596 | else if (density < 10) | |
597 | { | |
598 | colour = 67; //green | |
599 | luminosity = 25 - 25*(density-5)/5; | |
600 | } | |
601 | else if (density < 15) | |
602 | { | |
603 | colour = 92; //cyan | |
604 | luminosity = 25 - 25*(density-10)/5; | |
605 | } | |
606 | else if (density < 20) | |
607 | { | |
608 | colour = 8; //black | |
609 | luminosity = 9 - 9*(density-15)/5; | |
610 | } | |
611 | } | |
b15a2a93 | 612 | if (kState == kStateLiquid) |
2817d3e2 | 613 | { |
614 | nState = "Liquid"; | |
615 | colour = 142; //violet | |
616 | luminosity = 25 - 25*density/2; | |
617 | } | |
b15a2a93 | 618 | if (kState == kStateGas) |
2817d3e2 | 619 | { |
620 | nState = "Gas"; | |
621 | if (density < 0.001) {colour = 42;} //yellow | |
622 | else if (density < 0.002) {colour = 27;} //light red | |
623 | else if (density < 0.003) {colour = 77;} //light green | |
624 | else {colour = 102;} //light cyan | |
625 | luminosity = 0; | |
626 | } | |
627 | if (luminosity < 0) luminosity=0; | |
628 | colour += (G4int)luminosity; | |
629 | // Setting the corresponding colour | |
630 | Gsatt(pLV->GetName(),"COLO",colour); | |
631 | } | |
632 | } | |
633 | ||
634 | ||
635 | void TG4VisManager::Gsatt(const char* name, const char* att, Int_t val) | |
636 | { | |
637 | // Geant3 description : | |
638 | // | |
639 | // NAME Volume name | |
640 | // IOPT Name of the attribute to be set | |
641 | // IVAL Value to which the attribute is to be set | |
642 | // | |
643 | // name= "*" stands for all the volumes. | |
644 | // iopt can be chosen among the following : | |
645 | // kWORK, kSEEN, kLSTY, kLWID, kCOLO, kFILL, kSET, kDET, kDTYP | |
646 | // --- | |
647 | ||
648 | G4int ival = val; | |
649 | G4LogicalVolume* lv = 0; | |
650 | G4RWTPtrOrderedVector<G4LogicalVolume> lvList; | |
651 | G4String sname(name), | |
652 | satt(att); | |
653 | ||
654 | // seek for known attributes | |
5317affd | 655 | TG4G3Attribute attribute = kUNKNOWN; |
2817d3e2 | 656 | if (CaseInsensitiveEqual(att,"WORK")) |
657 | { | |
658 | G4String message = "TG4VisManager::Gsatt: G3Attribute "; | |
659 | message += satt + " not used in G4"; | |
660 | TG4Globals::Warning(message); | |
661 | return; | |
662 | } | |
663 | if (CaseInsensitiveEqual(att,"SEEN")) attribute = kSEEN; | |
664 | if (CaseInsensitiveEqual(att,"LSTY")) attribute = kLSTY; | |
665 | if (CaseInsensitiveEqual(att,"LWID")) attribute = kLWID; | |
666 | if (CaseInsensitiveEqual(att,"COLO")) attribute = kCOLO; | |
667 | if (CaseInsensitiveEqual(att,"FILL")) attribute = kFILL; | |
668 | if (CaseInsensitiveEqual(att,"SET")) | |
669 | { | |
670 | G4String message = "TG4VisManager::Gsatt: G3Attribute "; | |
671 | message += satt + " not used in G4"; | |
672 | TG4Globals::Warning(message); | |
673 | return; | |
674 | } | |
675 | if (CaseInsensitiveEqual(att,"DET")) | |
676 | { | |
677 | G4String message = "TG4VisManager::Gsatt: G3Attribute "; | |
678 | message += satt + " not used in G4"; | |
679 | TG4Globals::Warning(message); | |
680 | return; | |
681 | } | |
682 | if (CaseInsensitiveEqual(att,"DTYP")) | |
683 | { | |
684 | G4String message = "TG4VisManager::Gsatt: G3Attribute "; | |
685 | message += satt + " not used in G4"; | |
686 | TG4Globals::Warning(message); | |
687 | return; | |
688 | } | |
689 | if (attribute == kUNKNOWN) | |
690 | { | |
691 | G4String message = "TG4VisManager::Gsatt: G3Attribute "; | |
692 | message += satt + " unknown"; | |
693 | TG4Globals::Warning(message); | |
694 | return; | |
695 | } | |
696 | G4bool doForDaughters(false), // tree iterator flag | |
697 | doForAll(false), // activated if NAME is "*" | |
698 | topVisible(false); // activated for kSEEN/-2 | |
699 | if (sname == "*") doForAll = true; | |
700 | if (val < 0 && sname!="*") doForDaughters = true; | |
701 | if (attribute==kSEEN && val==-2) topVisible = true; | |
702 | ||
703 | // parse all the tree | |
704 | if (doForAll) | |
705 | { | |
706 | G4LogicalVolumeStore* pLVStore = G4LogicalVolumeStore::GetInstance(); | |
707 | for (G4int i=0; i<pLVStore->entries(); i++) | |
708 | { | |
709 | lv = pLVStore->at(i); | |
710 | SetG4Attribute(lv,attribute,ival); | |
711 | } | |
712 | return; | |
713 | } | |
714 | ||
715 | // get the logical volume pointer corresponding to NAME | |
716 | lvList = GetLVList(name); | |
717 | if (lvList.isEmpty()) | |
718 | { | |
719 | G4String message = "TG4VisManager::Gsatt(): Ignored\n"; | |
720 | message += " Logical volume " + sname + " has not been found.\n"; | |
721 | TG4Globals::Warning(message); | |
722 | return; | |
723 | } | |
724 | // set attribute for all descendents | |
725 | if (doForDaughters) | |
726 | { | |
727 | for (G4int i=0; i<lvList.entries(); i++) | |
728 | { | |
729 | lv = lvList[i]; | |
730 | SetAtt4Daughters(lv,attribute,ival); | |
731 | } | |
732 | } | |
733 | else | |
734 | { | |
735 | for (G4int i=0; i<lvList.entries(); i++) | |
736 | { | |
737 | lv = lvList[i]; | |
738 | SetG4Attribute(lv,attribute,ival); | |
739 | } | |
740 | } | |
741 | if (topVisible) | |
742 | { | |
743 | for (G4int i=0; i<lvList.entries(); i++) | |
744 | { | |
745 | lv = lvList[i]; | |
746 | SetG4Attribute(lv,attribute,1); | |
747 | } | |
748 | } | |
749 | } | |
750 | ||
751 | ||
752 | void TG4VisManager::Gdraw(const char *name,Float_t theta, Float_t phi, Float_t psi, | |
753 | Float_t u0,Float_t v0,Float_t ul,Float_t vl) | |
754 | { | |
755 | // Draw the physical volume NAME and all descendents; | |
756 | // Mandatory : the graphics system, scene and view must be | |
757 | // initialized, e.g. "/vis~/create_view/new_graphics_system OGLSX"; | |
758 | // Any call of Gdraw() will use the current graphics system and | |
759 | // the current window. | |
760 | // The result will be a centered view drawing of the designated volume, | |
761 | // lights moving with camera, viewpoint direction given by theta/phi | |
762 | // and rotation on the screen given by psi; | |
763 | // The u0, v0, ul, vl factors are ignored since the object will be | |
764 | // automatically centered and will be confortable in the window | |
765 | // at any viewing angle. | |
766 | // | |
767 | // check if G4 graphics is ready for drawing | |
768 | // --- | |
769 | ||
770 | G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance(); | |
771 | if (!pVVisManager) { | |
772 | TG4Globals::Warning( | |
773 | "TG4VisManager::Gdraw: Ignored - No graphics driver is built. "); | |
774 | return; | |
775 | } | |
776 | if (NeedSetColours()) | |
777 | { | |
778 | SetColors(); | |
779 | SetColourFlag(false); | |
780 | } | |
781 | ||
b15a2a93 | 782 | const G4double kRad = M_PI/180.; |
2817d3e2 | 783 | G4RWTPtrOrderedVector<G4VPhysicalVolume> pvList; |
784 | G4String sname(name); | |
785 | G4bool successful = false; | |
786 | ||
787 | pvList = GetPVList(name); | |
788 | if (pvList.isEmpty()) | |
789 | { | |
790 | G4String message = "TG4VisManager::Gdraw() :\n"; | |
791 | message += "Volume " + sname + " not found. Bailing out"; | |
792 | TG4Globals::Warning(message); | |
793 | return; | |
794 | } | |
795 | ||
796 | G4VPhysicalVolume *pPV = 0; | |
797 | ||
798 | // clear the current scene if not empty | |
799 | if (!fpScene->IsEmpty()) fpScene->Clear(); | |
800 | ||
801 | // create and add object's model list to the runtime-duration model | |
802 | // list and draw it | |
803 | // (it is deleted in the VisManager destructor within | |
804 | // all the RWTPtrOrderedVectors of the scene) | |
805 | for (G4int i=0; i<pvList.entries(); i++) | |
806 | { | |
807 | pPV = pvList[i]; | |
808 | G4LogicalVolume* pLV = pPV->GetLogicalVolume(); | |
809 | G4VSolid* pSolid = pLV->GetSolid(); | |
2817d3e2 | 810 | successful = fpScene->AddRunDurationModel(new G4PhysicalVolumeModel(pPV)); |
811 | if (!successful) | |
812 | { | |
813 | G4String message = "TG4VisManager::Gdraw() Could not add "; | |
814 | message += pPV->GetName() + " to the drawing list. Probably "; | |
815 | message += "it is already in the list."; | |
816 | TG4Globals::Warning(message); | |
817 | } | |
818 | } | |
819 | // get the standard target point of the scene | |
b15a2a93 | 820 | const G4Point3D kTargetPoint = fpScene->GetStandardTargetPoint(); |
2817d3e2 | 821 | |
822 | // set the viewpoint and the rotation on the screen | |
b15a2a93 | 823 | G4Vector3D viewpointDirection(sin(theta*kRad)*cos(phi*kRad), |
824 | sin(theta*kRad)*sin(phi*kRad), cos(theta*kRad)); | |
825 | G4Vector3D upVector(sin(psi*kRad), cos(psi*kRad),0); | |
2817d3e2 | 826 | |
827 | // set and register view parameters to the viewer | |
828 | ||
829 | fVP.SetLightsMoveWithCamera(true); | |
830 | fVP.SetViewGeom(); | |
831 | fVP.UnsetViewHits(); | |
832 | fVP.UnsetViewDigis(); | |
833 | fVP.SetNoOfSides(48); | |
b15a2a93 | 834 | fVP.SetCurrentTargetPoint(kTargetPoint); |
2817d3e2 | 835 | fVP.SetViewpointDirection(viewpointDirection); |
836 | fVP.SetUpVector(upVector); | |
837 | fVP.SetDensityCulling(true); | |
838 | fpViewer->SetViewParameters(fVP); | |
839 | ||
840 | if (IsValidView()) | |
841 | { | |
842 | fpSceneHandler->SetScene(fpScene); | |
843 | fpSceneHandler->SetCurrentViewer(fpViewer); | |
844 | fpViewer->DrawView(); | |
845 | fpViewer->ShowView(); | |
846 | } | |
847 | else TG4Globals::Warning( | |
848 | "TG4VisManager::Gdraw: Ignored - Failed to register volume"); | |
849 | } | |
850 | #endif //G4VIS_USE |