New TTask based method to do Digits To clusters. Works with files of multiple
[u/mrichter/AliRoot.git] / TGeant3 / AliG3Volume.cxx
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 /*
21 Old Logs: AliDrawVolume.cxx,v $
22 Revision 1.1  2000/07/13 16:19:10  fca
23 Mainly coding conventions + some small bug fixes
24
25 Revision 1.8  2000/07/12 08:56:32  fca
26 Coding convention correction and warning removal
27
28 Revision 1.7  2000/06/28 21:27:45  morsch
29 Most coding rule violations corrected.
30 Still to do: Split the file (on file per class) ? Avoid the global variables.
31 Copy constructors and assignment operators (dummy ?)
32
33 Revision 1.6  2000/04/14 11:07:46  morsch
34 Correct volume to medium assignment in case several media are asigned to the
35 same material.
36
37 Revision 1.5  2000/03/20 15:11:03  fca
38 Mods to make the code compile on HP
39
40 Revision 1.4  2000/01/18 16:12:08  morsch
41 Bug in calculation of number of volume divisions and number of positionings corrected
42 Browser for Material and Media properties added
43
44 Revision 1.3  1999/11/14 14:31:14  fca
45 Correct small error and remove compilation warnings on HP
46
47 Revision 1.2  1999/11/10 16:53:35  fca
48 The 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
85 ClassImp(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
118 AliG3Volume::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
165 void 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
197 void 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
228 void 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
289 Float_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
335 void  AliG3Volume::AddCopy(AliG3Volume* volume)
336 {
337     volume->SetIdMaterial(Material());
338     fCopies->Add(volume);
339     fNCopies++;
340 }
341
342 AliG3Volume* AliG3Volume::Copy(Int_t i)
343 {
344     return (AliG3Volume*) fCopies->At(i);
345 }
346
347
348 TArrayF 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
360 void 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
371 void  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
382 void  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
401 void 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
559 void   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
567 void   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 }