Minor corrections after big transformer changes
[u/mrichter/AliRoot.git] / TGeant3 / AliG3Volume.cxx
CommitLineData
3b7275e7 1/* *************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
16/*
17$Log$
18*/
19
20/*
21Old Logs: AliDrawVolume.cxx,v $
22Revision 1.1 2000/07/13 16:19:10 fca
23Mainly coding conventions + some small bug fixes
24
25Revision 1.8 2000/07/12 08:56:32 fca
26Coding convention correction and warning removal
27
28Revision 1.7 2000/06/28 21:27:45 morsch
29Most coding rule violations corrected.
30Still to do: Split the file (on file per class) ? Avoid the global variables.
31Copy constructors and assignment operators (dummy ?)
32
33Revision 1.6 2000/04/14 11:07:46 morsch
34Correct volume to medium assignment in case several media are asigned to the
35same material.
36
37Revision 1.5 2000/03/20 15:11:03 fca
38Mods to make the code compile on HP
39
40Revision 1.4 2000/01/18 16:12:08 morsch
41Bug in calculation of number of volume divisions and number of positionings corrected
42Browser for Material and Media properties added
43
44Revision 1.3 1999/11/14 14:31:14 fca
45Correct small error and remove compilation warnings on HP
46
47Revision 1.2 1999/11/10 16:53:35 fca
48The new geometry viewer from A.Morsch
49
50*/
51
52/*
53 * Version: 0
54 * Written by Andreas Morsch
55 *
56 *
57 *
58 * For questions critics and suggestions to this part of the code
59 * contact andreas.morsch@cern.ch
60 *
61 **************************************************************************/
62
63#include "AliG3Volume.h"
64#include <TArrayF.h>
65#include "TMaterial.h"
66#include "TShape.h"
67#include "TTUBE.h"
68#include "TBRIK.h"
69#include "TTRD1.h"
70#include "TTRD2.h"
71#include "TTRAP.h"
72#include "TTUBS.h"
73#include "TCONE.h"
74#include "TCONS.h"
75#include "TSPHE.h"
76#include "TPARA.h"
77#include "TPGON.h"
78#include "TPCON.h"
79#include "TTUBS.h"
80#include "TELTU.h"
81#include "THYPE.h"
82#include "TGTRA.h"
83#include "TCTUB.h"
84
85ClassImp(AliG3Volume)
86
87 AliG3Volume::AliG3Volume(const char* name)
88 : TNamed(name, " ")
89{
90// Constructor
91
92 fTheta = 30;
93 fPhi = 30;
94 fPsi = 0;
95 fU = 10;
96 fV = 10;
97 fUscale = 0.01;
98 fVscale = 0.01;
99 fHide=0;
100 fShadow=0;
101 fFill=1;
102 fSeen=1;
103 fClip=0;
104 fClipXmin=0.;
105 fClipXmax=2000.;
106 fClipYmin=0.;
107 fClipYmax=2000.;
108 fClipZmin=0.;
109 fClipZmax=2000.;
110 fNParam = 0;
111 fPosition.Set(3);
112 fCopies = new TList;
113 fNCopies = 0;
114 fPosp = kFALSE;
115 fAxis = -1;
116}
117
118AliG3Volume::AliG3Volume(const AliG3Volume& volume)
119 : TNamed(volume)
120{
121// Constructor
122
123 fTheta = 30;
124 fPhi = 30;
125 fPsi = 0;
126 fU = 10;
127 fV = 10;
128 fUscale = 0.01;
129 fVscale = 0.01;
130 fHide=0;
131 fShadow=0;
132 fFill=1;
133 fSeen=1;
134 fClip=0;
135 fClipXmin=0.;
136 fClipXmax=2000.;
137 fClipYmin=0.;
138 fClipYmax=2000.;
139 fClipZmin=0.;
140 fClipZmax=2000.;
141 fAxis = -1;
142//
143 fIdVolume = volume.GetIdVolume();
144 fIdCopy = volume.GetIdCopy();
145 fIdMedium = volume.Medium();
146 fIdMaterial = volume.Material();
147 fPosition = volume.Position(0);
148 fShape = volume.Shape();
149 fRotMatrix = volume.RotMatrix();
150 TArrayF par;
151 volume.Parameters(0, fParameters);
152 fNCopies = volume.NCopies();
153 fPosp = volume.Posp();
154
155 fNParam = volume.NParam();
156 fCopies = volume.Copies();
157 fRotMatrix = volume.RotMatrix();
158 volume.Division(fNdiv, fAxis, fStartC, fStep);
159
160}
161
162
163
164
165void AliG3Volume::Draw(Option_t *)
166{
167// Wraps the geant Gdraw
168 gMC->Gsatt(fName,"seen", fSeen);
169
170 if (fHide) {
171 gMC->Gdopt("hide", "on");
172 } else {
173 gMC->Gdopt("hide", "off");
174 }
175
176 if (fShadow) {
177 gMC->Gdopt("shad", "on");
178 gMC->Gsatt("*", "fill", fFill);
179 } else {
180 gMC->Gdopt("shad", "off");
181 }
182
183 gMC->SetClipBox(".");
184 if (fClip) {
185 gMC->SetClipBox("*", fClipXmin, fClipXmax,
186 fClipYmin, fClipYmax, fClipZmin, fClipZmax);
187 } else {
188 gMC->SetClipBox(".");
189 }
190
191
192 gMC->Gdraw(fName, fTheta, fPhi, fPsi, fU, fV, fUscale, fVscale);
193 THIGZ *higz = (THIGZ*)gROOT->GetListOfCanvases()->FindObject("higz");
194 if (higz) higz->Update();
195}
196
197void AliG3Volume::DrawSpec()
198{
199// Wraps the Geant DrawSpec
200 gMC->Gsatt(fName,"seen", fSeen);
201
202 if (fHide) {
203 gMC->Gdopt("hide", "on");
204 } else {
205 gMC->Gdopt("hide", "off");
206 }
207
208 if (fShadow) {
209 gMC->Gdopt("shad", "on");
210 gMC->Gsatt("*", "fill", fFill);
211 } else {
212 gMC->Gdopt("shad", "off");
213 }
214
215 gMC->SetClipBox(".");
216 if (fClip) {
217 gMC->SetClipBox("*", fClipXmin, fClipXmax, fClipYmin, fClipYmax, fClipZmin, fClipZmax);
218 } else {
219 gMC->SetClipBox(".");
220 }
221
222
223 ((TGeant3*) gMC)->DrawOneSpec(fName);
224 THIGZ *higz = (THIGZ*)gROOT->GetListOfCanvases()->FindObject("higz");
225 if (higz) higz->Update();
226}
227
228void AliG3Volume::SetParam(Int_t ip, Float_t param)
229{
230// Set drawing parameters
231 switch (ip) {
232 case kTheta:
233 fTheta=param;
234 break;
235 case kPhi:
236 fPhi=param;
237 break;
238 case kPsi:
239 fPsi=param;
240 break;
241 case kU:
242 fU=param;
243 break;
244 case kV:
245 fV=param;
246 break;
247 case kUscale:
248 fUscale=param;
249 break;
250 case kVscale:
251 fVscale=param;
252 break;
253 case kHide:
254 fHide=Int_t(param);
255 break;
256 case kShadow:
257 fShadow=Int_t(param);
258 break;
259 case kFill:
260 fFill=Int_t(param);
261 break;
262 case kSeen:
263 fSeen=Int_t(param);
264 break;
265 case kClip:
266 fClip=Int_t(param);
267 break;
268 case kClipXmin:
269 fClipXmin=param;
270 break;
271 case kClipXmax:
272 fClipXmax=param;
273 break;
274 case kClipYmin:
275 fClipYmin=param;
276 break;
277 case kClipYmax:
278 fClipYmax=param;
279 break;
280 case kClipZmin:
281 fClipZmin=param;
282 break;
283 case kClipZmax:
284 fClipZmax=param;
285 break;
286 }
287}
288
289Float_t AliG3Volume::GetParam(Int_t ip)
290{
291// Get drawing parameters
292 switch (ip) {
293 case kTheta:
294 return fTheta;
295 case kPhi:
296 return fPhi;
297 case kPsi:
298 return fPsi;
299 case kU:
300 return fU;
301 case kV:
302 return fV;
303 case kUscale:
304 return fUscale;
305 case kVscale:
306 return fVscale;
307 case kHide:
308 return Float_t(fHide);
309 case kShadow:
310 return Float_t(fShadow);
311 case kFill:
312 return Float_t(fFill);
313 case kSeen:
314 return Float_t(fSeen);
315 case kClip:
316 return Float_t(fClip);
317 case kClipXmin:
318 return fClipXmin;
319 case kClipXmax:
320 return fClipXmax;
321 case kClipYmin:
322 return fClipYmin;
323 case kClipYmax:
324 return fClipYmax;
325 case kClipZmin:
326 return fClipZmin;
327 case kClipZmax:
328 return fClipZmax;
329 default:
330 return 0.;
331 }
332 return 0.;
333}
334
335void AliG3Volume::AddCopy(AliG3Volume* volume)
336{
337 volume->SetIdMaterial(Material());
338 fCopies->Add(volume);
339 fNCopies++;
340}
341
342AliG3Volume* AliG3Volume::Copy(Int_t i)
343{
344 return (AliG3Volume*) fCopies->At(i);
345}
346
347
348TArrayF AliG3Volume::Position(Int_t i) const
349{
350//
351// Get position for volume copy i
352//
353 if (i==0) {
354 return fPosition;
355 } else {
356 return ((AliG3Volume*) fCopies->At(i-1))->Position(0);
357 }
358}
359
360void AliG3Volume::SetPosition(Float_t x, Float_t y, Float_t z)
361{
362//
363// Set position
364//
365 fPosition[0] = x;
366 fPosition[1] = y;
367 fPosition[2] = z;
368}
369
370
371void AliG3Volume::SetParameters(Int_t np, Float_t* param)
372{
373//
374// Set parameters
375//
376 fParameters.Set(np);
377 for (Int_t j=0; j<np; j++) fParameters[j]=param[j];
378 fNParam = np;
379}
380
381
382void AliG3Volume::Parameters(Int_t i, TArrayF& param) const
383{
384//
385// Get parameters for volume copy i
386//
387 TArrayF p;
388 if (i==0) {
389 p = fParameters;
390 } else {
391 ((AliG3Volume*) (fCopies->At(i-1)))->Parameters(0, p);
392 }
393 Int_t np = fNParam;
394 param.Set(np);
395 for (Int_t j=0; j<np; j++) {
396 param[j] = p.At(j);
397 }
398}
399
400
401void AliG3Volume::CreateTShape(char* nameV, TMaterial* mat)
402{
403//
404// Create a root volume from G3 volume
405//
406 Int_t ip;
407
408 Float_t kRadDeg = 180./TMath::Pi();
409 Float_t theta, phi, alpha1, alpha2;
410 Float_t p1, p2;
411
412 TShape* nShape=0;
413 const char* tmp = mat->GetName();
414 char nameM[21];
415 strncpy(nameM, tmp, 20);
416 nameM[20]='\0';
417 switch(fShape)
418 {
419 case 1:
420// BOX
421 nShape = new TBRIK(nameV,"BRIK",nameM,fParameters[0], fParameters[1], fParameters[2]);
422 break;
423
424 case 2:
425// TRD1
426 nShape = new TTRD1(nameV, "TRD1", nameM, fParameters[0], fParameters[1], fParameters[2],
427 fParameters[3]);
428 break;
429
430 case 3:
431// TRD2
432 nShape = new TTRD2(nameV, "TRD2", nameM, fParameters[0], fParameters[1], fParameters[2],
433 fParameters[3], fParameters[4]);
434 break;
435
436 case 4:
437// TRAP
438 p1 = fParameters[1];
439 p2 = fParameters[2];
440
441 theta = TMath::ATan(TMath::Sqrt(p1*p1+p2*p2))*kRadDeg;
442 phi = TMath::ATan2(p2,p1)*kRadDeg;
443 alpha1 = fParameters[6 ]*kRadDeg;
444 alpha2 = fParameters[10]*kRadDeg;
445
446 if (theta < 0.) theta+=180.;
447
448 nShape = new TTRAP(nameV, "TRAP", nameM, fParameters[0],
449 theta, phi,
450 fParameters[3], fParameters[4], fParameters[5],
451 alpha1,
452 fParameters[7], fParameters[8], fParameters[9],
453 alpha2);
454 break;
455
456 case 5:
457// TUBE
458 nShape = new TTUBE(nameV,"TUBE",nameM,fParameters[0], fParameters[1], fParameters[2]);
459 break;
460
461 case 6:
462// TUBS
463 nShape = new TTUBS(nameV,"TUBS",nameM,fParameters[0], fParameters[1], fParameters[2],
464 fParameters[3], fParameters[4]);
465 break;
466
467 case 7:
468// CONE
469 nShape = new TCONE(nameV, "CONE", nameM, fParameters[0], fParameters[1], fParameters[2],
470 fParameters[3], fParameters[4]);
471 break;
472
473 case 8:
474
475// CONS
476 nShape = new TCONS(nameV, "CONS", nameM, fParameters[0], fParameters[1], fParameters[2],
477 fParameters[3], fParameters[4], fParameters[5], fParameters[6]);
478 break;
479
480 case 9:
481// SPHE
482
483 nShape = new TSPHE(nameV, "SPHE", nameM, fParameters[0], fParameters[1], fParameters[2],
484 fParameters[3], fParameters[4], fParameters[5]);
485 break;
486
487 case 10:
488// PARA
489 alpha1 = fParameters[3]*kRadDeg;
490 p1 = fParameters[4];
491 p2 = fParameters[5];
492 theta = TMath::ATan(TMath::Sqrt(p1*p1+p2*p2))*kRadDeg;
493 phi = TMath::ATan2(p2,p1)*kRadDeg;
494
495 nShape = new TPARA(nameV, "PARA", nameM, fParameters[0], fParameters[1], fParameters[2],
496 alpha1, theta, phi);
497 break;
498
499 case 11:
500// PGON
501 nShape = new TPGON(nameV, "PGON", nameM, fParameters[0], fParameters[1], Int_t(fParameters[2]),
502 Int_t(fParameters[3]));
503 for (ip=0; ip<Int_t(fParameters[3]); ip++) {
504 ((TPGON*) nShape)->DefineSection(ip, fParameters[4+3*ip], fParameters[4+3*ip+1],
505 fParameters[4+3*ip+2]);
506 }
507 break;
508
509 case 12:
510// PCON
511 nShape = new TPCON(nameV, "PCON", nameM, fParameters[0], fParameters[1], Int_t(fParameters[2]));
512 for (ip=0; ip<Int_t(fParameters[2]); ip++) {
513 ((TPCON*) nShape)->DefineSection(ip, fParameters[3+3*ip], fParameters[3+3*ip+1],
514 fParameters[3+3*ip+2]);
515 }
516 break;
517
518 case 13:
519// ELTU
520 nShape = new TELTU(nameV,"ELTU",nameM,fParameters[0], fParameters[1], fParameters[2]);
521 break;
522
523 case 14:
524// HYPE
525 nShape = new THYPE(nameV,"HYPE",nameM,fParameters[0], fParameters[1], fParameters[2],
526 fParameters[3]);
527 break;
528
529 case 15:
530// GTRA
531 nShape = new TGTRA(nameV, "GTRA", nameM, fParameters[0], fParameters[1], fParameters[2],
532 fParameters[3], fParameters[4], fParameters[5], fParameters[6],
533 fParameters[7], fParameters[8], fParameters[9], fParameters[10],
534 fParameters[11]);
535 break;
536
537 case 16:
538// CTUB
539 nShape = new TCTUB(nameV, "CTUB", nameM, fParameters[0], fParameters[1], fParameters[2],
540 fParameters[3], fParameters[4], fParameters[5], fParameters[6],
541 fParameters[7], fParameters[8], fParameters[9], fParameters[10]);
542 break;
543 default:
544 break;
545 }
546 if (nShape) {
547 Float_t density = mat->GetDensity();
548 if (density < 0.01) {
549 nShape->SetVisibility(0);
550 } else {
551 nShape->SetVisibility(1);
552 }
553
554 Int_t color = Int_t(density/20.*100.);
555 nShape->SetLineColor(color);
556 }
557}
558
559void AliG3Volume::SetDivision(Int_t ndiv, Int_t axis, Float_t start, Float_t step)
560{
561 fNdiv = ndiv;
562 fAxis = axis;
563 fStartC = start;
564 fStep = step;
565}
566
567void AliG3Volume::Division(Int_t& ndiv, Int_t& axis, Float_t& start, Float_t& step) const
568{
569 ndiv = fNdiv;
570 axis = fAxis;
571 start = fStartC;
572 step = fStep;
573}