Geometry defined by TGeoModeler
[u/mrichter/AliRoot.git] / VZERO / AliVZEROv6.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 /* $Id$ */
17
18 //////////////////////////////////////////////////////////////////////
19 //                                                                  //
20 //  (V-zero) detector  version 6  as designed by the Lyon group     //
21 //   All comments should be sent to Brigitte CHEYNIS :              //
22 //                                  b.cheynis@ipnl.in2p3.fr         // 
23 //   Geometry of september 2005 done with ROOT geometrical modeler  //                                  //
24 //   V0R (now V0C) sits between Z values  -89.5 and  -84.8 cm       //
25 //   V0L (now V0A) sits between Z values +339.0 and +341.0 cm       //
26 //   New coordinate system has been implemented in october 2003     //
27 //                                                                  //
28 //////////////////////////////////////////////////////////////////////
29
30 // --- Standard libraries ---
31 #include <Riostream.h>
32 #include <stdlib.h>
33 #include <string.h>
34
35 // --- ROOT libraries ---
36 #include <TClonesArray.h>
37 #include <TGeometry.h>
38 #include <TLorentzVector.h>
39 #include <TMath.h>
40 #include <TNode.h>
41 #include <TObjectTable.h>
42 #include <TVirtualMC.h>
43 #include <TParticle.h>
44
45 #include <TGeoManager.h>
46 #include <TGeoMaterial.h>
47 #include <TGeoMedium.h>
48 #include <TGeoNode.h>
49 #include <TGeoVolume.h>
50 #include "TGeoTube.h"
51 #include "TGeoMatrix.h"
52
53 // --- AliRoot header files ---
54 #include "AliRun.h"
55 #include "AliMC.h"
56 #include "AliConst.h"
57 #include "AliMagF.h"
58 #include "AliVZEROLoader.h"
59 #include "AliVZEROdigit.h"
60 #include "AliVZEROhit.h"
61 #include "AliVZEROv6.h"
62 #include "AliLog.h"
63  
64 ClassImp(AliVZEROv6)
65
66 //_____________________________________________________________________________
67 AliVZEROv6:: AliVZEROv6():AliVZERO()
68 {
69 // Standard default constructor 
70 }
71
72 //_____________________________________________________________________________
73 AliVZEROv6::AliVZEROv6(const char *name, const char *title):
74  AliVZERO(name,title)
75 {
76
77 // Standard constructor for V-zero Detector  version 6
78
79   AliDebug(2,"Create VZERO object ");
80   
81   fVersion            =     6;  // version number
82   
83 // Parameters related to geometry :
84 // V0 part in front of muon arm absorber 
85
86   fV0CHeight1         =    2.5; // height of cell 1, in cm
87   fV0CHeight2         =    4.4; // height of cell 2, in cm
88   fV0CHeight3         =    7.4; // height of cell 3, in cm
89   fV0CHeight4         =   12.5; // height of cell 4, in cm
90   fV0CRMin            =    4.6; 
91   fV0CRBox            =   38.0; // outer radius of box, in cm
92   fV0CLidThickness    =   0.30; // thickness of Carbon lid
93   fV0CCellThickness   =   2.00; // thickness of elementary cell
94   fV0CBoxThickness    =   4.70; // thickness of V0C Box
95   fV0COffsetFibers    =    1.0; // offset to output fibers, in cm
96
97 // V0 part on the other side with respect to Interaction Point
98
99   fV0AHeight1         =    3.3; // height of cell 1, in cm
100   fV0AHeight2         =    6.2; // height of cell 2, in cm
101   fV0AHeight3         =    8.9; // height of cell 3, in cm
102   fV0AHeight4         =   20.9; // height of cell 4, in cm
103   fV0ARMin            =   4.30; 
104   fV0ACellThickness   =   2.00; // thickness of elementary cell  
105   
106 // Parameters related to light output :
107          
108   fLightYield         =  93.75; // Light yield in BC408 (93.75 eV per photon)
109   fLightAttenuation   =   0.05; // Light attenuation in fiber (0.05 per meter)
110   fnMeters            =   15.0; // Number of meters of clear fibers to PM
111   fFibToPhot          =    0.3; // Attenuation at fiber-photocathode interface
112 }
113      
114 //_____________________________________________________________________________
115
116 void AliVZEROv6::BuildGeometry()
117
118           
119 }
120             
121 //_____________________________________________________________________________
122 void AliVZEROv6::CreateGeometry()
123 {
124   
125 // Constructs TGeo geometry 
126
127   const int kColorVZERO  = kGreen;  
128   
129   AliDebug(2,"VZERO ConstructGeometry");
130   
131   TGeoManager *geoManager = gGeoManager;
132   TGeoMedium  *medAir = gGeoManager->GetMedium("VZERO_Air"); 
133   TGeoMedium  *medAlu = gGeoManager->GetMedium("VZERO_Aluminum");
134   TGeoMedium  *medCar = gGeoManager->GetMedium("VZERO_Carbon");
135   TGeoMedium  *medSci = gGeoManager->GetMedium("VZERO_Scintillator");
136     
137   TGeoVolume *top = gGeoManager->GetVolume("ALIC");
138   
139   top->SetLineColor(kMagenta);
140
141   Float_t  heightRight, r4Right;
142   
143   Float_t  zdet   =    90.0 - 0.5 - fV0CBoxThickness/2.0;
144   heightRight     =    fV0CHeight1 + fV0CHeight2 + fV0CHeight3 + fV0CHeight4;
145   r4Right         =    fV0CRMin + heightRight + 3.0*0.2;  // 3 spacings of 2mm between rings
146     
147   Float_t   partube[3];
148
149   partube[0] =  fV0CRMin - 0.3;
150   partube[1] =  fV0CRBox + 0.3;
151   partube[2] =  fV0CBoxThickness/2.0;   
152
153 // Creation of mother volume V0RI - right part - :
154
155   TGeoTube   *sV0RI = new TGeoTube("V0RI",partube[0], partube[1], partube[2]);
156   TGeoVolume *v0RI  = new TGeoVolume("V0RI",sV0RI,medAir);
157   TGeoTranslation *tr1 = new TGeoTranslation(0.,0.,-zdet);
158   top->AddNode(v0RI,1,tr1);
159   v0RI->SetVisibility(kFALSE);
160
161 // Creation of  carbon lids (3.0 mm thick) to keep V0C box shut :
162   
163   partube[0] =   fV0CRMin;
164   partube[1] =   fV0CRBox;
165   partube[2] =   fV0CLidThickness/2.0;
166   
167   TGeoTube   *sV0CA = new TGeoTube("V0CA", partube[0], partube[1], partube[2]);
168   TGeoVolume *v0CA  = new TGeoVolume("V0CA",sV0CA,medCar);
169   TGeoTranslation *tr2 = new TGeoTranslation(0.,0., fV0CBoxThickness/2.0-partube[2]);
170   TGeoTranslation *tr3 = new TGeoTranslation(0.,0.,-fV0CBoxThickness/2.0+partube[2]);
171   v0RI->AddNode(v0CA,1,tr2);
172   v0RI->AddNode(v0CA,2,tr3);
173   v0CA->SetLineColor(kYellow);
174   
175 // Creation of aluminum rings 3.0 mm thick to maintain the v0RI pieces : 
176  
177   partube[0] =   fV0CRMin - 0.3;
178   partube[1] =   fV0CRMin;
179   partube[2] =   fV0CBoxThickness/2.0;
180   
181   TGeoTube   *sV0IR = new TGeoTube("V0IR", partube[0], partube[1], partube[2]);
182   TGeoVolume *v0IR  = new TGeoVolume("V0IR",sV0IR,medAlu);
183   v0RI->AddNode(v0IR,1,0);
184   v0IR->SetLineColor(kYellow);
185   
186   partube[0] =   fV0CRBox;
187   partube[1] =   fV0CRBox + 0.3; 
188   partube[2] =   fV0CBoxThickness/2.0;
189
190   TGeoTube   *sV0ER = new TGeoTube("V0ER", partube[0], partube[1], partube[2]);
191   TGeoVolume *v0ER  = new TGeoVolume("V0ER",sV0ER,medAlu);
192   v0RI->AddNode(v0ER,1,0);
193   v0ER->SetLineColor(kYellow);
194   
195 // Mother volume v0R0 in which will be set the scintillator cells 
196   
197   Float_t   partubs[5];
198  
199   partubs[0]      =  fV0CRMin;
200   partubs[1]      =   r4Right;
201   partubs[2]      =  fV0CBoxThickness/2.0;
202   partubs[3]      =  90.0-22.5;
203   partubs[4]      = 135.0-22.5;
204
205   TGeoTubeSeg  *sV0R0 = new TGeoTubeSeg("V0R0", partubs[0], partubs[1], partubs[2], 
206                                                 partubs[3], partubs[4]);
207   TGeoVolume   *v0R0  = new TGeoVolume("V0R0",sV0R0,medAir);
208                                           
209                                                  
210 // Elementary cell of ring 1  - right part - :
211 // (cells of ring 1 will be shifted by 2.0 cm backwards to output fibers)
212                                                   
213   Float_t   r1Right =  fV0CRMin + fV0CHeight1;
214   Float_t   offset  = fV0CBoxThickness/2.0 - fV0CLidThickness - fV0CCellThickness/2.0; 
215     
216   partubs[0]     =  fV0CRMin;
217   partubs[1]     =  r1Right;
218   partubs[2]     =  fV0CCellThickness/2.0;
219
220   TGeoTubeSeg  *sV0R1 = new TGeoTubeSeg("V0R1", partubs[0], partubs[1], partubs[2], 
221                                                 partubs[3], partubs[4]);
222   TGeoVolume   *v0R1  =  new TGeoVolume("V0R1",sV0R1,medSci);                                  
223   TGeoTranslation *tr4 = new TGeoTranslation(0.,0.,-offset);
224   v0R0->AddNode(v0R1,1,tr4);
225   v0R1->SetLineColor(kColorVZERO);
226
227 // Elementary cell of ring 2 - right part - :
228 // (cells of ring 2 will be shifted by 1.0 cm backwards to output fibers)
229
230   Float_t   r2Right  =  r1Right + fV0CHeight2;  
231
232   partubs[0]     =  r1Right;  //  must be equal to 7.1
233   partubs[1]     =  r2Right;  //  must be equal to 11.5
234   TGeoTubeSeg *sV0R2 = new TGeoTubeSeg("V0R2", partubs[0], partubs[1], partubs[2], 
235                                                partubs[3], partubs[4]);
236   TGeoVolume  *v0R2  = new TGeoVolume("V0R2",sV0R2,medSci);                                                   
237   TGeoTranslation *tr5 = new TGeoTranslation(0.0,0.2,-offset + fV0COffsetFibers);                                             
238   v0R0->AddNode(v0R2,1,tr5);
239   v0R2->SetLineColor(kColorVZERO);
240    
241 // Ring 3 - right part -  :
242
243 //  Float_t   x = TMath::ATan(1.0/156.0) * ((180./TMath::Pi()));
244   
245   r2Right  =  r2Right + 0.2;
246   Float_t   r3Right  =  r2Right + fV0CHeight3;     
247 //  printf(" r2 = %f, r3 = %f \n\n", r2Right,r3Right  ); 
248   
249   partubs[0]     =  r2Right;  //  must be equal to 11.7
250   partubs[1]     =  r3Right;  //  must be equal to 19.1
251   partubs[3]     =  90.0-22.5;
252   partubs[4]     = 112.5-22.5;
253   
254   TGeoTubeSeg *sV0R3 = new TGeoTubeSeg("V0R3", partubs[0], partubs[1], partubs[2], 
255                                                partubs[3], partubs[4]); 
256   TGeoVolume  *v0R3  = new TGeoVolume("V0R3",sV0R3,medSci);                                           
257   TGeoTranslation *tr6 = new TGeoTranslation(0.,0.2,-offset + 2.0*fV0COffsetFibers);                                           
258   v0R0->AddNode(v0R3,1,tr6);
259   v0R3->SetLineColor(kColorVZERO);
260  
261   partubs[3]     = 112.5-22.5;
262   partubs[4]     = 135.0-22.5;
263   
264   TGeoTubeSeg *sV0R4 = new TGeoTubeSeg("V0R4", partubs[0], partubs[1], partubs[2], 
265                                                partubs[3], partubs[4]);  
266   TGeoVolume  *v0R4  = new TGeoVolume("V0R4",sV0R4,medSci);                                                                                   
267   v0R0->AddNode(v0R4,1,tr6);
268   v0R4->SetLineColor(kColorVZERO);
269   
270 // Ring 4 - right part -  : 
271
272   Float_t x = TMath::ATan(3.5/257.5) * ((180./TMath::Pi()));
273   r3Right = r3Right + 0.2 + 0.2;   // + 0.2 because no shift in translation here !!
274    
275   partubs[0]     =  r3Right;  //  must be equal to 19.5
276   partubs[1]     =  r4Right;  //  must be equal to 32.0
277   partubs[3]     =  90.0-22.5+x;
278   partubs[4]     = 112.5-22.5-x;
279   
280   TGeoTubeSeg *sV0R5 = new TGeoTubeSeg("V0R5", partubs[0], partubs[1], partubs[2], 
281                                                partubs[3], partubs[4]);
282   TGeoVolume  *v0R5  = new TGeoVolume("V0R5",sV0R5,medSci);
283   TGeoTranslation *tr7 = new TGeoTranslation(0.,0.0,-offset + 2.0*fV0COffsetFibers);                                          
284   v0R0->AddNode(v0R5,1,tr7);
285   v0R5->SetLineColor(kColorVZERO);
286   
287   partubs[3]     = 112.5-22.5+x;
288   partubs[4]     = 135.0-22.5-x;
289   
290   TGeoTubeSeg *sV0R6 = new TGeoTubeSeg("V0R6", partubs[0], partubs[1], partubs[2], 
291                                                partubs[3], partubs[4]);
292   TGeoVolume  *v0R6  = new TGeoVolume("V0R6",sV0R6,medSci);                                                   
293   v0R0->AddNode(v0R6,1,tr7);
294   v0R6->SetLineColor(kColorVZERO);
295   
296   Float_t  phi;
297   Float_t  phiDeg= 180./4.;
298     
299   Int_t    nsecR = 1;     // number of sectors in right part of V0
300   Int_t    ncellsR;       // number of scintillating cells 
301  
302   for (phi = 22.5; phi < 360.0; phi = phi + phiDeg)
303   
304   {              
305     TGeoRotation  *rot1 = new TGeoRotation("rot1", 90.0, +phi, 90., 90.+phi, 0.0, 0.0 ); 
306     
307     v0RI->AddNode(v0R0,nsecR,rot1);    
308     nsecR++;        
309   } 
310      
311   ncellsR = (nsecR - 1) * 6;    // 6 cells per sector (2 cells in  ring 3 and 4)  
312   AliInfo(Form("Number of cells on Right side  - V0C =   %d",  ncellsR)); 
313   
314 // Creation of mother volume v0LE - left part - :
315 // Entrance face at  +339.0 cm  (new coordinate system) ...
316           
317   Float_t   heightLeft  = fV0AHeight1 + fV0AHeight2 + fV0AHeight3 + fV0AHeight4;   
318   Float_t   r4Left      = fV0ARMin + heightLeft; 
319
320   partube[0] =  fV0ARMin;
321   partube[1] =  r4Left;
322   partube[2] =  fV0ACellThickness/2.0; 
323
324   TGeoTube   *sV0LE = new TGeoTube("V0LE",partube[0], partube[1], partube[2]);
325   TGeoVolume *v0LE  = new TGeoVolume("V0LE",sV0LE,medAir);
326   TGeoTranslation *tr8 = new TGeoTranslation(0.,0.,339.0 + fV0ACellThickness/2.0);
327   top->AddNode(v0LE,1,tr8);
328    
329   partubs[0]      =  fV0ARMin;
330   partubs[1]      =  r4Left;
331   partubs[2]      =  fV0ACellThickness/2.0;
332   partubs[3]      =  90.0-22.5;
333   partubs[4]      = 135.0-22.5;
334
335   TGeoTubeSeg  *sV0L0 = new TGeoTubeSeg("V0L0", partubs[0], partubs[1], partubs[2], 
336                                                 partubs[3], partubs[4]);
337   TGeoVolume   *v0L0  = new TGeoVolume("V0L0",sV0L0,medAir);
338   v0L0->SetVisibility(kFALSE);                                    
339    
340   Float_t   offsetLeft;
341   offsetLeft    = - fV0ACellThickness/2.0; 
342
343   Float_t   r1Left =  fV0ARMin + fV0AHeight1;        
344       
345   partubs[0]     =  fV0ARMin;
346   partubs[1]     =  r1Left;
347
348   TGeoTubeSeg  *sV0L1 = new TGeoTubeSeg("V0L1", partubs[0], partubs[1], partubs[2], 
349                                                 partubs[3], partubs[4]);
350   TGeoVolume   *v0L1  =  new TGeoVolume("V0L1",sV0L1,medSci);                                  
351   v0L0->AddNode(v0L1,1,gGeoIdentity);
352   v0L1->SetLineColor(kColorVZERO);
353   v0L1->SetVisibility(kTRUE);
354          
355   Float_t   r2Left =  r1Left + fV0AHeight2;       
356   
357   partubs[0]     =  r1Left;
358   partubs[1]     =  r2Left;
359   
360   TGeoTubeSeg  *sV0L2 = new TGeoTubeSeg("V0L2", partubs[0], partubs[1], partubs[2], 
361                                                 partubs[3], partubs[4]);
362   TGeoVolume   *v0L2  =  new TGeoVolume("V0L2",sV0L2,medSci);                                  
363   v0L0->AddNode(v0L2,1,gGeoIdentity);
364   v0L2->SetLineColor(kColorVZERO);
365   v0L2->SetVisibility(kTRUE);
366
367   Float_t   r3Left =  r2Left + fV0AHeight3; 
368    
369   partubs[0]     =  r2Left;
370   partubs[1]     =  r3Left;
371   
372   TGeoTubeSeg  *sV0L3 = new TGeoTubeSeg("V0L3", partubs[0], partubs[1], partubs[2], 
373                                                 partubs[3], partubs[4]);
374   TGeoVolume   *v0L3  =  new TGeoVolume("V0L3",sV0L3,medSci);                                  
375   v0L0->AddNode(v0L3,1,gGeoIdentity);
376   v0L3->SetLineColor(kColorVZERO);
377   v0L3->SetVisibility(kTRUE);
378
379   partubs[0]     =  r3Left;
380   partubs[1]     =  r4Left;
381
382   TGeoTubeSeg  *sV0L4 = new TGeoTubeSeg("V0L4", partubs[0], partubs[1], partubs[2], 
383                                                 partubs[3], partubs[4]);
384   TGeoVolume   *v0L4  =  new TGeoVolume("V0L4",sV0L4,medSci);                                  
385   v0L0->AddNode(v0L4,1,gGeoIdentity);
386   v0L4->SetLineColor(kColorVZERO);
387   v0L4->SetVisibility(kTRUE);
388
389   Int_t    nsecL = 1;     // number of sectors in left part of V0
390   Int_t    ncellsL;       // number of scintillating cells 
391   
392   for (phi = 22.5; phi < 360.0; phi = phi + phiDeg)
393   
394   {                  
395     TGeoRotation  *rot1 = new TGeoRotation("rot1", 90.0, +phi, 90., 90.+phi, 0.0, 0.0 ); 
396     v0LE->AddNode(v0L0,nsecL,rot1);    
397     nsecL++;        
398   } 
399      
400   ncellsL = (nsecL - 1) * 4;    // 4 cells per sector
401   AliInfo(Form("Number of cells on Left  side  - V0A =   %d\n",  ncellsL));
402  
403   gGeoManager->CloseGeometry();  
404 //  gGeoManager-> SetVisLevel(4);
405   geoManager->Export("VZEROGeometry.root"); 
406 }  
407     
408 //_____________________________________________________________________________
409 void AliVZEROv6::CreateMaterials()
410 {
411
412 // Creates materials used for geometry 
413
414    AliDebug(2,"Create materials");
415
416 //   Int_t  *idtmed = fIdtmed->GetArray()-2999;
417       
418    Int_t     fieldType       = gAlice->Field()->Integ();     // Field type 
419    Double_t  maxField        = gAlice->Field()->Max();     // Field max.
420    Double_t  maxBending      = 0;     // Max Angle
421    Double_t  maxStepSize     = 0.001; // Max step size 
422    Double_t  maxEnergyLoss   = 1;     // Max Delta E
423    Double_t  precision       = 0.001; // Precision
424    Double_t  minStepSize     = 0.001; // Minimum step size 
425    Int_t     id;
426    Double_t  a, z, density, radLength, absLength; 
427    Float_t   tmaxfd, stemax, deemax, epsil, stmin;
428    
429    a = 0.0; z = 0.0; 
430    density   = 0.0;
431    radLength = 0.0; 
432    absLength = 999.0;
433    tmaxfd    = 10.;
434    stemax    = 0.1;
435    deemax    = 0.1;     
436    epsil     = 0.001;
437    stmin     = 0.001;
438    
439 // Parameters  for Air (=  0.01% C + 75% N + 23% O + 1% Ar )
440
441     Float_t aa[] = { 12.0107, 14.0067,   15.9994,  39.948 };
442     Float_t za[] = {  6.,      7.,       8.,       18. };
443     Float_t wa[] = { 0.000124, 0.755267, 0.231781, 0.012827 }; 
444     density      = 0.00120479;
445     maxBending   = 1;
446     maxStepSize  = .001;
447     precision    = .001;
448     minStepSize  = .001;
449     id           = 1;
450     AliMixture(id, "Air", aa, za, density, 4, wa);
451     AliMedium(id, "Air", id, 1, fieldType, maxField, maxBending,
452                          maxStepSize, maxEnergyLoss, precision, minStepSize);
453                         
454 // Parameters  for Aluminum
455  
456     a = 26.98; 
457     z = 13.00;
458     density    = 2.7;
459     radLength  = 8.9;
460     maxBending  = 10;
461     maxStepSize = .01;
462     precision   = .003;
463     minStepSize = .003;
464     id = 2;
465     AliMaterial( id, "Aluminum", a, z, density, radLength, 37.2, 0, 0);
466     AliMedium(id, "Aluminum", id, 1, fieldType, maxField, maxBending,
467                               maxStepSize, maxEnergyLoss, precision, minStepSize);
468                     
469 // Parameters  for Carbon 
470
471     a = 12.01; 
472     z =  6.00;
473     density     = 2.265;
474     radLength   = 18.8;
475     id = 3;
476     AliMaterial(id, "Carbon",  a, z, density, radLength, 49.9, 0, 0);
477     AliMedium(id,   "Carbon", id, 1, fieldType, maxField, maxBending,
478                               maxStepSize, maxEnergyLoss, precision, minStepSize);
479                     
480 // Parameters  for scintillator 
481
482     Float_t as[] = { 1.00794, 12.011};
483     Float_t zs[] = { 1.,  6.};
484     Float_t ws[] = { 1.,  1.};
485     density      = 1.032;
486     maxBending   = 10;
487     maxStepSize  = .01;
488     precision    = .003;
489     minStepSize  = .003;
490     id           = 4;
491     AliMixture(id, "Scintillator", as, zs, density, -2, ws);
492     AliMedium(id,  "Scintillator", id, 1, fieldType, maxField, maxBending,
493                                    maxStepSize,maxEnergyLoss,precision,minStepSize);
494
495                                                              
496 }
497
498 //_____________________________________________________________________________
499 void AliVZEROv6::DrawModule() const
500 {
501
502 //  Drawing is done in DrawVZERO.C
503
504    AliDebug(2,"DrawModule");
505 }
506
507
508 //_____________________________________________________________________________
509 void AliVZEROv6::DrawGeometry() 
510 {
511
512 //  Drawing of V0 geometry done in DrawV0.C
513
514    AliDebug(2,"DrawGeometry");
515  
516 //  Here is  DrawV0.C :
517
518 // void DrawV0()
519 // {
520 //    TGeoVolume *top = gGeoManager->GetMasterVolume();
521 //    gGeoManager->SetNsegments(80);
522 //    Int_t nd = top->GetNdaughters();
523 //    for (Int_t i=0; i<nd; i++) top->GetNode(i)->GetVolume()->InvisibleAll();
524 //    TGeoVolume *v0ri = gGeoManager->GetVolume("V0RI");  
525 //    TGeoVolume *v0le = gGeoManager->GetVolume("V0LE");
526 //    v0ri->SetVisibility(kTRUE);
527 //    v0ri->VisibleDaughters(kTRUE);
528 //    v0le->SetVisibility(kTRUE);
529 //    v0le->VisibleDaughters(kTRUE);
530 //    top->SetVisibility(kTRUE);
531 //    top->Draw();
532 // }
533    
534 }
535
536 //_____________________________________________________________________________
537 void AliVZEROv6::Init()
538 {
539 // Initialises version of the VZERO Detector given in Config
540 // Just prints an information message
541   
542    AliInfo(Form("VZERO version %d initialized \n",IsVersion()));
543    
544    AliVZERO::Init();  
545 }
546
547 //_____________________________________________________________________________
548 void AliVZEROv6::StepManager()
549 {
550  
551 // Step Manager, called at each step 
552  
553      Int_t     copy;
554      static    Int_t   vol[4];
555      static    Float_t hits[21];
556      static    Float_t eloss, tlength;
557      static    Int_t   nPhotonsInStep;
558      static    Int_t   nPhotons; 
559      static    Int_t   numStep;
560      Float_t   ringNumber;
561      Float_t   destep, step;
562      
563      numStep += 1; 
564           
565 //   We keep only charged tracks :
566      
567      if ( !gMC->TrackCharge() || !gMC->IsTrackAlive() ) return; 
568
569      vol[0]    = gMC->CurrentVolOffID(1, vol[1]);
570      vol[2]    = gMC->CurrentVolID(copy);
571      vol[3]    = copy;
572      
573      static Int_t idV0R1 = gMC->VolId("V0R1");
574      static Int_t idV0L1 = gMC->VolId("V0L1");
575      static Int_t idV0R2 = gMC->VolId("V0R2");
576      static Int_t idV0L2 = gMC->VolId("V0L2");
577      static Int_t idV0R3 = gMC->VolId("V0R3");
578      static Int_t idV0L3 = gMC->VolId("V0L3");
579      static Int_t idV0R4 = gMC->VolId("V0R4");
580      static Int_t idV0L4 = gMC->VolId("V0L4");
581      static Int_t idV0R5 = gMC->VolId("V0R5");
582      static Int_t idV0R6 = gMC->VolId("V0R6");
583    
584      if      ( gMC->CurrentVolID(copy) == idV0R1 ||
585                gMC->CurrentVolID(copy) == idV0L1 )
586                ringNumber = 1.0;
587      else if ( gMC->CurrentVolID(copy) == idV0R2 ||
588                gMC->CurrentVolID(copy) == idV0L2 ) 
589                ringNumber = 2.0;  
590      else if ( gMC->CurrentVolID(copy) == idV0R3 ||
591                gMC->CurrentVolID(copy) == idV0R4 ||
592                gMC->CurrentVolID(copy) == idV0L3 )
593                ringNumber = 3.0;
594      else if ( gMC->CurrentVolID(copy) == idV0R5 ||
595                gMC->CurrentVolID(copy) == idV0R6 ||
596                gMC->CurrentVolID(copy) == idV0L4 )
597                ringNumber = 4.0;               
598      else
599                ringNumber = 0.0;
600                
601  
602      if  (  ringNumber > 0.5  ) { 
603      
604         destep    = gMC->Edep();
605         step      = gMC->TrackStep();
606         
607         nPhotonsInStep  = Int_t(destep / (fLightYield *1e-9) ); 
608         nPhotonsInStep  = gRandom->Poisson(nPhotonsInStep);
609         
610         eloss    += destep;
611         tlength  += step;        
612         
613         if  ( gMC->IsTrackEntering()  )  { 
614          
615             nPhotons  =  nPhotonsInStep;       
616             gMC->TrackPosition(fTrackPosition);
617             gMC->TrackMomentum(fTrackMomentum);
618             
619             Float_t pt  = TMath::Sqrt( fTrackMomentum.Px() * fTrackMomentum.Px() +
620                                        fTrackMomentum.Py() * fTrackMomentum.Py() );
621                
622             hits[0]  = fTrackPosition.X();
623             hits[1]  = fTrackPosition.Y();
624             hits[2]  = fTrackPosition.Z();               
625             hits[3]  = Float_t (gMC->TrackPid()); 
626
627             hits[4]  = gMC->TrackTime();
628             hits[5]  = gMC->TrackCharge();
629             hits[6]  = fTrackMomentum.Theta()*TMath::RadToDeg();
630             hits[7]  = fTrackMomentum.Phi()*TMath::RadToDeg();
631             hits[8]  = ringNumber;
632          
633             hits[9]  = pt;
634             hits[10] = fTrackMomentum.P();
635             hits[11] = fTrackMomentum.Px();
636             hits[12] = fTrackMomentum.Py();
637             hits[13] = fTrackMomentum.Pz();
638             
639             TParticle *par = gAlice->GetMCApp()->Particle(gAlice->GetMCApp()->GetCurrentTrackNumber());
640             hits[14] = par->Vx();
641             hits[15] = par->Vy();
642             hits[16] = par->Vz();
643             
644             tlength  = 0.0;
645             eloss    = 0.0;         
646          }
647          
648          nPhotons  = nPhotons + nPhotonsInStep;
649          
650          if( gMC->IsTrackExiting() || gMC->IsTrackStop() || gMC->IsTrackDisappeared()){
651          
652          nPhotons  = nPhotons - Int_t((Float_t(nPhotons) * fLightAttenuation * fnMeters));       
653          nPhotons  = nPhotons - Int_t( Float_t(nPhotons) * fFibToPhot);  
654          
655          hits[17] =   eloss;
656          hits[18] = tlength;
657          hits[19] = nPhotons;
658          hits[20] = GetCellId (vol, hits); 
659                  
660          AddHit(gAlice->GetMCApp()->GetCurrentTrackNumber(), vol, hits);
661                  
662          tlength         = 0.0;
663          eloss           = 0.0; 
664          nPhotons        =   0;
665          nPhotonsInStep  =   0;
666          
667          numStep         =   0;  
668          } 
669     }
670       
671 }
672
673 //_____________________________________________________________________________
674 void AliVZEROv6::AddHit(Int_t track, Int_t *vol, Float_t *hits)
675 {
676   
677 //  Adds a VZERO hit
678   
679   TClonesArray &lhits = *fHits;
680   new(lhits[fNhits++]) AliVZEROhit(fIshunt,track,vol,hits);
681 }
682
683 //_____________________________________________________________________________
684 void AliVZEROv6::AddDigits(Int_t *tracks, Int_t* digits) 
685 {
686
687 //  Adds a VZERO digit
688
689    TClonesArray  &ldigits = *fDigits;
690    new(ldigits[fNdigits++]) AliVZEROdigit(tracks, digits);
691 }
692
693 //_____________________________________________________________________________
694 void AliVZEROv6::MakeBranch(Option_t *option)
695 {
696   
697 // Creates new branches in the current Root Tree
698     
699   char branchname[10];
700   sprintf(branchname,"%s",GetName());
701   AliDebug(2,Form("fBufferSize = %d",fBufferSize));
702   
703   const char *cH = strstr(option,"H");
704   
705   if (fHits   && TreeH() && cH) {
706     TreeH()->Branch(branchname,&fHits, fBufferSize);
707     AliDebug(2,Form("Making Branch %s for hits",branchname));
708   }     
709
710   const char *cD = strstr(option,"D");
711   
712   if (fDigits   && fLoader->TreeD() && cD) {
713     fLoader->TreeD()->Branch(branchname,&fDigits, fBufferSize);
714     AliDebug(2,Form("Making Branch %s for digits",branchname));
715   }  
716    
717 }
718
719 //_____________________________________________________________________________
720 Int_t AliVZEROv6::GetCellId(Int_t *vol, Float_t *hits) 
721 {
722
723   //   Returns Id of scintillator cell
724   //   Right side from  0 to 47
725   //   Left  side from 48 to 95
726   
727   //   hits[8] = ring number (1 to 4)
728   //   vol[1]  = copy number (1 to 8)
729
730    Int_t index      = vol[1];
731    Int_t RingNumber = Int_t(hits[8]);   
732    fCellId          = 0;
733    
734 //    cout << "volID = " << vol[0] << "  copy = " << vol[1] << endl;
735 //    cout << "X     = " << hits[0] << "    Y = " << hits[1] << endl;
736    
737    Float_t phi = Float_t(TMath::ATan2(Double_t(hits[1]),Double_t(hits[0])) ); 
738    Float_t kRaddeg = 180.0/TMath::Pi();
739    phi = kRaddeg * phi;
740     
741    if (index < 7) index = index + 8; 
742    
743    if (hits[2] < 0.0) { 
744       if(RingNumber < 3) {
745          index = (index - 7) + ( ( RingNumber - 1 ) * 8);}
746       else if(RingNumber >= 3){ 
747        if(gMC->CurrentVolID(vol[1]) == gMC->VolId("V0R3")|| 
748           gMC->CurrentVolID(vol[1]) == gMC->VolId("V0R5") ) 
749          {index = (index*2 - 14) + ( ( RingNumber - 2 ) * 16); }
750        if(gMC->CurrentVolID(vol[1]) == gMC->VolId("V0R4")||
751           gMC->CurrentVolID(vol[1]) == gMC->VolId("V0R6") ) 
752          {index = (index*2 - 13) + ( ( RingNumber - 2 ) * 16); }
753       }
754       fCellId   = index;           
755    }
756            
757    else if (hits[2] > 0.0){
758       index = (index - 7 + 48) + ( ( RingNumber - 1 ) * 8);
759       fCellId   = index;}
760              
761 //    cout << " ring   = " << RingNumber << " phi = "<<  phi << endl; 
762 //    cout << " cellID = " << fCellId <<  endl;
763 //    cout <<  "**********" << endl;         
764            
765    return fCellId;
766    
767    
768 }