Changes to compile with Root6 on macosx64
[u/mrichter/AliRoot.git] / AD / AliADv1.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: AliAD.cxx  $ */
17
18 ///////////////////////////////////////////////////////////////////////////
19 //                                                                       //
20 //                  AD (ALICE Diffractive)  Detector                     //
21 //                                                                       //
22 //  This class contains the base procedures for the AD  detector         //
23 //  Default geometry of 2013: 16 modules                                 //
24 //  All comments should be sent to :                                     //
25 //                                                                       //
26 //                                                                       //
27 ///////////////////////////////////////////////////////////////////////////
28
29 // --- Standard libraries ---
30 #include <Riostream.h>
31
32 // --- ROOT libraries ---
33 #include <TMath.h>
34 #include <TString.h>
35 #include <TVirtualMC.h>
36 #include <TGeoManager.h>
37 #include <TGeoMatrix.h>
38 #include <TGeoTube.h>
39 #include <TGeoCone.h>
40 #include <TGeoShape.h>
41 #include <TTree.h>
42 #include <TSystem.h>
43 #include <TGeoCompositeShape.h>
44 #include <TGeoGlobalMagField.h>
45 #include <TGeoMaterial.h>
46 #include <TGeoMedium.h>
47 #include <TGeoVolume.h>
48 #include <TGeoArb8.h>
49 #include <TClonesArray.h>
50 #include <TGeoTrd2.h>
51 #include <TParticle.h>
52
53 #include <TH2F.h>
54 #include <TCanvas.h>
55
56 // --- AliRoot header files ---
57
58
59 #include "AliADhit.h"
60 #include "AliADdigit.h"
61 #include "AliADv1.h"
62 #include "AliLog.h"
63 #include "AliConst.h"
64 #include "AliMagF.h"
65 #include "AliRun.h"
66 #include "AliMC.h"
67
68
69 ClassImp(AliADv1)
70 //__________________________________________________________________
71 AliADv1::AliADv1()
72   : AliAD(),
73   fADCLightYield(93.75),
74   fADCPhotoCathodeEfficiency(0.18),
75   fADALightYield(93.75),
76   fADAPhotoCathodeEfficiency(0.18)
77
78 {
79    // Default Constructor
80     fHits = 0;
81 }
82
83 //_____________________________________________________________________________
84 AliADv1::AliADv1(const char *name, const char *title) : 
85   AliAD(name,title),  
86   fADCLightYield(93.75),
87   fADCPhotoCathodeEfficiency(0.18),
88   fADALightYield(93.75),
89   fADAPhotoCathodeEfficiency(0.18)
90 {
91    // Standard constructor for AD Detector
92   
93    AliModule* pipe = gAlice->GetModule("PIPE");
94    if( (!pipe) ) {
95       Error("Constructor","AD needs PIPE!!!\n");
96       exit(1);
97    } 
98    fHits = new TClonesArray("AliADhit",400);
99    gAlice->GetMCApp()->AddHitList(fHits);
100 }
101
102 //_____________________________________________________________________________
103 AliADv1::~AliADv1()
104 {
105         // default destructor
106 }
107 //_____________________________________________________________________________
108 void AliADv1::Init()
109 {
110   // Initialise L3 magnet after it has been built
111   Int_t i;
112   if(AliLog::GetGlobalDebugLevel()>0) {
113     printf("\n%s: ",ClassName());
114     for(i=0;i<35;i++) printf("*");
115     printf(" ADv1_INIT ");
116     for(i=0;i<35;i++) printf("*");
117     printf("\n%s: ",ClassName());
118     for(i=0;i<80;i++) printf("*");
119     printf("\n");
120   }
121 }
122
123 //_____________________________________________________________________________
124 void AliADv1::CreateGeometry()
125 {
126   //
127   // Create the geometry for the AD arrays
128   //
129   
130   CreateAD();
131   
132 }
133
134
135 //_____________________________________________________________________________
136 void AliADv1::CreateAD()
137 {
138
139         // here we create AD: ADA & ADC
140
141         // Get ALICE volume
142
143         TGeoVolume *alice = gGeoManager->GetVolume("ALIC");
144
145         // Define the mother volume for AD
146
147         TGeoVolume *ad = new TGeoVolumeAssembly("AD");
148
149         // Get medium
150
151         TGeoMedium *medADASci           = gGeoManager->GetMedium("AD_NE102"); // AD Scin. 
152         TGeoMedium *medADALG            = gGeoManager->GetMedium("AD_PMMA");  // lightGuide
153         TGeoMedium *medADAPMGlass       = gGeoManager->GetMedium("AD_Glass"); // Glass for Aluminium simulation
154         TGeoMedium *medADAPMAlum        = gGeoManager->GetMedium("AD_Alum");  // Aluminium 
155
156
157         ///  ADA Scintillator Pad Measures
158         const Double_t kADATriangleSide   = 7.8;   //
159         const Double_t kADACellSide       = 20.0;
160         const Double_t kADACellThickness  = 2.0;  // Half thickness
161         const int kColorADA = kGreen;
162  
163
164         // Creation of the Box's pad
165
166         new TGeoBBox( "ADAbox", kADACellSide/2.0-kADATriangleSide/2., kADACellSide/2.0, kADACellThickness );
167         const Double_t boxSide2 = kADACellSide/2.0-kADATriangleSide/2.;
168         new TGeoBBox( "ADAbox1", kADATriangleSide/2., boxSide2, kADACellThickness );
169         
170         // translation
171
172         TGeoTranslation *trada2 = new TGeoTranslation( -kADACellSide/2.0,  kADACellSide/2.0 - boxSide2, 0. );
173         trada2->SetName( "trada2" );
174         trada2->RegisterYourself();
175
176         TGeoArb8* sADAtriang = new TGeoArb8( "ADAtriang", kADACellThickness );
177         for ( int iz = 0; iz < 2; iz++ ) {
178                 sADAtriang->SetVertex( 0+iz*4, kADACellSide/2.0, kADACellSide/2.0 );
179                 sADAtriang->SetVertex( 1+iz*4, kADACellSide/2.0, (kADACellSide/2.0)-kADATriangleSide );
180                 sADAtriang->SetVertex( 2+iz*4, kADACellSide/2.0, (kADACellSide/2.0)-kADATriangleSide );
181                 sADAtriang->SetVertex( 3+iz*4, kADACellSide/2.0-kADATriangleSide, kADACellSide/2.0 );
182         }    
183         TGeoTranslation *trada1 = new TGeoTranslation( -kADACellSide+kADATriangleSide/2. , -kADACellSide+kADATriangleSide, 0. );
184         trada1->SetName( "trada1" );
185         trada1->RegisterYourself();
186
187         TGeoCompositeShape *sADA1 = new TGeoCompositeShape ( "sADA1s1", "ADAbox+(ADAbox1:trada2)+(ADAtriang:trada1)" );
188         TGeoVolume *vADA1 = new TGeoVolume( "ADApad", sADA1, medADASci );
189         vADA1->SetLineColor( kColorADA ); 
190
191         /// Light guide
192         Double_t kADALGThickness   = 2.0; // Half thickness
193         Double_t kADALGSideScint   = 20.0;
194         Double_t kADALGHeigth      = TMath::Sqrt( kADALGSideScint*kADALGSideScint - (10.5 * 10.5) );
195         Double_t kADALGSideCoupling = 3.0; 
196         const int kColorADALG = kYellow;
197  
198           // Triangle
199         TGeoTrd2* sADALGtriang = new TGeoTrd2( kADALGThickness, kADALGThickness, kADALGSideScint/2., kADALGSideCoupling/2., kADALGHeigth/2.0);
200         TGeoVolume *vADALGtriang = new TGeoVolume( "ADALG", sADALGtriang, medADALG );
201         vADALGtriang->SetLineColor( kColorADALG ); 
202
203         // Coupling
204         Double_t kADALGCoupling = 5.0; 
205         TGeoTube* sADACouplTube = new TGeoTube( "ADACouplTube", 0, 1.4, kADALGCoupling/2. );
206         TGeoVolume * vADACoupling = new TGeoVolume( "ADACoupling", sADACouplTube, medADALG );
207         vADACoupling->SetLineColor( kColorADALG ); 
208    
209         TGeoVolume * vADALG1  = new TGeoVolumeAssembly( "ADALG" );
210         vADALG1->AddNode( vADALGtriang, 1 );   
211         vADALG1->AddNode( vADACoupling, 1, new TGeoTranslation(0., 0., kADALGHeigth/2.+kADALGCoupling/2.) );   
212         vADALG1->SetLineColor( kColorADALG ); 
213       
214         /// PMT  Hamamatsu R5946
215         Double_t kADAPMR1 = 1.95;          // 3.9 cm diameter
216         Double_t kADAPMR2 = 2.15;          // + 2 mm?? aluminium case 
217         Double_t kADAPMlength = 6.4;      // 5 cm PMT + 1.4 socket 
218         const int kColorPMG   = kWhite;
219         const int kColorPMA   = kGray;
220  
221         TGeoTube *sADAPMg1   = new TGeoTube( "sADAPMg", 0., kADAPMR1, kADAPMlength/2. );
222         TGeoVolume *vADAPMg1 = new TGeoVolume( "ADAPMg", sADAPMg1, medADAPMGlass );
223         vADAPMg1->SetLineColor( kColorPMG );
224         TGeoTube *sADAPMa1   = new TGeoTube( "ADAPMa", kADAPMR1, kADAPMR2, kADAPMlength/2. );
225         TGeoVolume *vADAPMa1 = new TGeoVolume( "ADAPMa", sADAPMa1, medADAPMAlum );
226         vADAPMa1->SetLineColor( kColorPMA );
227         TGeoVolume *vADAPM1  = new TGeoVolumeAssembly("ADAPM");
228         vADAPM1->AddNode( vADAPMg1, 1 );
229         vADAPM1->AddNode( vADAPMa1, 1 );
230  
231         /// Sector (Assembly:  Scintillator Pad + Light guide + PM )
232         TGeoVolume *secADA  = new TGeoVolumeAssembly( "ADAsec" ); 
233         // Add PAD
234         secADA->AddNode( vADA1, 1, new TGeoTranslation( kADACellSide/2.0+kADATriangleSide/2. + 0.05, kADACellSide/2.0 + 0.05, 0. ) );
235         // Add Light Guide
236         TGeoCombiTrans *transrot = new TGeoCombiTrans( kADACellSide + kADALGHeigth/2.0 + 0.05, kADALGSideScint/2.0 + 0.05, 0., 
237                                                   new TGeoRotation("rot",90.,90.,90.) );
238         secADA->AddNode( vADALG1, 1, transrot );   
239         // Add PM
240         transrot = new TGeoCombiTrans( kADACellSide + kADALGHeigth  + kADALGCoupling + kADAPMlength/2. + 0.05, kADACellSide/2.0 + 0.05, 0, 
241                                   new TGeoRotation("rot",90.,90.,0.) );
242         secADA->AddNode(vADAPM1, 1, transrot);
243
244         // TODO: Add mechanical support
245    
246         /// Assembling ADA adding 4 sectors                                       //  Sectors
247         TGeoVolume *vADAarray = new TGeoVolumeAssembly( "ADA" );                  //        ^ y
248         vADAarray->AddNode( secADA, 1 );                                          //        |   
249         vADAarray->AddNode( secADA, 2, new TGeoRotation("rot",0.  , 180.,0.) );   //   4    |   1
250         vADAarray->AddNode( secADA, 3, new TGeoRotation("rot",180., 0.,  0.) );   // --------------->  x     
251         vADAarray->AddNode( secADA, 4, new TGeoRotation("rot",180., 180.,0.) );   //   3    |   2
252         TGeoRotation *rotADA90 = new TGeoRotation("adarot",90,0,0);
253         // here I add ADA to AD volume
254         const Float_t kPosADA = 1700.0;
255         ad->AddNode(vADAarray,1, new TGeoCombiTrans("ada",0,0,kPosADA,rotADA90));                                                                     //        |
256  
257         if (GetADAToInstalled())
258         {
259                 const Float_t kPosADA2 = 1695.0;
260                 ad->AddNode(vADAarray,2, new TGeoCombiTrans("ada",0,0,kPosADA2,rotADA90));
261         }
262
263         // Creation of ADC
264
265         // Get Medium for ADC (in principle is the same as ADA, but I keep the previous variables)
266
267         TGeoMedium *medADCSci     = gGeoManager->GetMedium("AD_NE102");
268         TGeoMedium *medADCLG      = gGeoManager->GetMedium("AD_PMMA");
269         TGeoMedium *medADCPMGlass = gGeoManager->GetMedium("AD_Glass");
270         TGeoMedium *medADCPMAlum  = gGeoManager->GetMedium("AD_Alum");
271  
272         /// Creation of assembly of one ADC sector
273  
274         /// ADC Scintillator Pad 
275         const Double_t kADCCellSide = 30.;
276         const Double_t kADCCellThickness = 4.0;
277         const int kColorADC = kGreen;
278    
279         new TGeoBBox( "ADCbox0", kADCCellSide/4.0, kADCCellSide/2.0, kADCCellThickness/2.0 );
280         new TGeoBBox( "ADCbox1", kADCCellSide/4.0, kADCCellSide/4.0, kADCCellThickness/2.0 );
281         new TGeoBBox( "ADCbox2", 2.5, 5.5, kADCCellThickness/2.0 );
282         TGeoTranslation *tradd1 = new TGeoTranslation( -kADCCellSide/2.0, kADCCellSide/4.0, 0. );
283         TGeoTranslation *tradd2 = new TGeoTranslation( -kADCCellSide/4.0 - 2.5, -kADCCellSide/2.0 + 5.5 , 0. );
284         tradd1->SetName( "tradd1" );
285         tradd2->SetName( "tradd2" );
286         tradd1->RegisterYourself();
287         tradd2->RegisterYourself();
288         TGeoCompositeShape *sADC1 = new TGeoCompositeShape ( "sADCpad", "ADCbox0+(ADCbox1:tradd1)+(ADCbox2:tradd2)" );
289         TGeoVolume *vADC = new TGeoVolume( "ADCpad", sADC1, medADCSci );      
290         vADC->SetLineColor( kColorADC );
291
292         /// Light guide
293         const Double_t kADCLGThickness    = 4.0;
294         const Double_t kADCLGHeigth       = 28.95;        // Dist from scint to coupling
295         const Double_t kADCLGSideScint    = kADCCellSide; // 30.0 
296         const Double_t kADCLGSideCoupling = 4.0; 
297         const int kColorADCLG = kYellow;
298   
299         // Triangle
300         TGeoTrd2* sADCLGtriang = new TGeoTrd2( kADCLGThickness/2., kADCLGThickness/2., kADCLGSideScint/2., kADCLGSideCoupling/2., kADCLGHeigth/2.0);
301         TGeoVolume *vADCLGtriang = new TGeoVolume( "ADCLG", sADCLGtriang, medADCLG );
302         vADCLGtriang->SetLineColor( kColorADCLG ); 
303
304         // Coupling
305         Double_t kADCLGCoupling = 10.0; // Total lenght
306         new TGeoCone( "ADCCouplCone", kADCLGCoupling/4., 0, kADCLGSideCoupling/TMath::Sqrt(2.), 0, 1.4 );
307         new TGeoBBox( "ADCCouplBox", kADCLGSideCoupling/2., kADCLGSideCoupling/2., kADCLGCoupling/4. );
308         new TGeoTube( "ADCCouplTube", 0, 1.4, kADCLGCoupling/4. );
309         TGeoTranslation *tradd3 = new TGeoTranslation(0, 0, kADCLGCoupling/2. );
310         tradd3->SetName( "tradd3" );
311         tradd3->RegisterYourself();
312    
313         TGeoCompositeShape * sADCCoupling = new TGeoCompositeShape ( "sADCCoupling", "ADCCouplBox * ADCCouplCone + (ADCCouplTube:tradd3)" );
314         TGeoVolume * vADCCoupling = new TGeoVolume( "ADCCoupling", sADCCoupling, medADCLG );
315         vADCCoupling->SetLineColor( kColorADCLG ); 
316    
317         TGeoVolume * vADCLG  = new TGeoVolumeAssembly( "ADCLG" );
318         vADCLG->AddNode( vADCLGtriang, 1 );   
319         vADCLG->AddNode( vADCCoupling, 1, new TGeoTranslation(0., 0., kADCLGHeigth/2.+kADCLGCoupling/4.) );   
320         vADCLG->SetLineColor( kColorADCLG ); 
321    
322         /// PM  Hamamatsu R5946  
323         const Double_t kADCPMR1 = 1.95;          // 3.9 cm diameter
324         const Double_t kADCPMR2 = 2.15;          // + 2 mm?? aluminium case 
325         const Double_t kADCPMlength = 6.4;       // 5 cm PMT + 1.4 socket 
326         //const int kColorPMG   = kWhite;
327         ////const int kColorPMA   = kGray;
328  
329         TGeoTube *sADCPMg   = new TGeoTube( "sADCPMg", 0., kADCPMR1, kADCPMlength/2. );
330         TGeoVolume *vADCPMg = new TGeoVolume( "ADCPMg", sADCPMg, medADCPMGlass );
331         vADCPMg->SetLineColor(kColorPMG);
332         TGeoTube *sADCPMa   = new TGeoTube( "ADCPMa", kADCPMR1, kADCPMR2, kADCPMlength/2. );
333         TGeoVolume *vADCPMa = new TGeoVolume( "ADCPMa", sADCPMa, medADCPMAlum );
334         vADCPMa->SetLineColor( kColorPMA );
335         TGeoVolume *vADCPM  = new TGeoVolumeAssembly( "ADCPM" );
336         vADCPM->AddNode( vADCPMg, 1 );
337         vADCPM->AddNode( vADCPMa, 1 );
338
339         /// Sector (Asembly:  Scintillator Pad + Light guide + PM )
340         TGeoVolume *secADC  = new TGeoVolumeAssembly("ADCsec");
341         // Add PAD
342         TGeoCombiTrans *transrot1 = new TGeoCombiTrans( 3*kADCCellSide/4.0, kADCCellSide/2.0, 0., new TGeoRotation("rot",0.,0.,0.) );
343         secADC->AddNode( vADC, 1, transrot1 );
344         // Add Light Guide
345         transrot1 = new TGeoCombiTrans( kADCCellSide + kADCLGHeigth/2.0, kADCLGSideScint/2.0, 0., new TGeoRotation("rot",90.,90.,90.) );
346         secADC->AddNode( vADCLG, 1, transrot1 );
347         // Add PM
348         transrot1 = new TGeoCombiTrans( kADCCellSide + kADCLGHeigth  + kADCLGCoupling + kADCPMlength/2., kADCCellSide/2.0, 0, new TGeoRotation("rot",90.,90.,0.) );
349         secADC->AddNode( vADCPM, 1, transrot1 );
350
351         // TODO: Add mechanical support
352
353         /// Assembling ADC adding the 4 sectors                                   //  Sectors
354         TGeoVolume *vADCarray = new TGeoVolumeAssembly("ADC");                    //        ^ y
355         vADCarray->AddNode( secADC, 1 );                                          //        |   
356         vADCarray->AddNode( secADC, 2, new TGeoRotation("rot", 0.  , 180., 0.) ); //   4    |   1
357         vADCarray->AddNode( secADC, 3, new TGeoRotation("rot", 180., 0.,   0.) ); // --------------->  x  
358         vADCarray->AddNode( secADC, 4, new TGeoRotation("rot", 180., 180., 0.) ); //   3    |   2
359                                                                              //        |
360         // here I add ADC to AD volume
361
362         //const Float_t kPosADC = -1902.75;  // -1902.75 (with 4cm thick) puts the ADC just next to the YSAA3_CC_BLOCK
363         const Float_t kPosADC = -1900.0;
364         ad->AddNode(vADCarray,3,new TGeoTranslation(0,0,kPosADC));
365         // add second array
366         if (GetADCToInstalled())
367         {
368                 const Float_t kPosADC2 = -1895.0;
369                 ad->AddNode(vADCarray,4,new TGeoTranslation(0,0,kPosADC2));
370         }
371
372         // at the end, I add "AD" volume into ALICE
373
374         alice->AddNode(ad,1);
375 }
376
377 //_____________________________________________________________________________
378 void AliADv1::AddAlignableVolumes() const
379 {
380    //
381    // Create entries for alignable volumes associating the symbolic volume
382    // name with the corresponding volume path. Needs to be syncronized with
383    // eventual changes in the geometry.
384    //
385    // ADA and ADC 
386
387
388    
389    TString volpath1 = "/ALIC_1/AD_1/ADC_3";
390    TString volpath2 = "/ALIC_1/AD_1/ADC_4";
391    TString volpath3 = "/ALIC_1/AD_1/ADA_1";
392    TString volpath4 = "/ALIC_1/AD_1/ADA_2";
393  
394    TString symname1 = "AD/ADC3";
395    TString symname2 = "AD/ADC4"; 
396    TString symname3 = "AD/ADA1";
397    TString symname4 = "AD/ADA2"; 
398    
399    if ( !gGeoManager->SetAlignableEntry(symname1.Data(), volpath1.Data()) )
400       AliFatal(Form( "Alignable entry %s not created. Volume path %s not valid", symname1.Data(), volpath1.Data()) );
401    if ( GetADCToInstalled() && !gGeoManager->SetAlignableEntry(symname2.Data(), volpath2.Data()) )
402       AliFatal(Form( "Alignable entry %s not created. Volume path %s not valid", symname2.Data(), volpath2.Data()) );
403    if ( !gGeoManager->SetAlignableEntry(symname3.Data(), volpath3.Data()) )
404       AliFatal(Form( "Alignable entry %s not created. Volume path %s not valid", symname3.Data(), volpath3.Data()) );
405    if ( GetADAToInstalled() && !gGeoManager->SetAlignableEntry(symname4.Data(), volpath4.Data()) )
406       AliFatal(Form("Alignable entry %s not created. Volume path %s not valid", symname4.Data(), volpath4.Data()) );
407    
408 }
409
410
411 //_____________________________________________________________________________
412 void AliADv1::StepManager()
413 {
414
415    //
416    // Routine called at every step in the AD
417    //
418
419    // ADA and ADC static Variables         //
420    //static  Int_t   numStep_ad = 0;         //
421 //   static  Int_t   vol_ad[2];              //
422   
423    /////////////////////////////////////////////////////////////////////////
424    // ADA and ADC
425    /////////////////////////////////////////////////////////////////////////
426       
427       
428    // Get sensitive volumes id (scintillator pads)
429    static Int_t idADA = TVirtualMC::GetMC()->VolId( "ADApad" );
430    static Int_t idADC = TVirtualMC::GetMC()->VolId( "ADCpad" );
431    
432    // We keep only charged tracks : 
433    // if ( !TVirtualMC::GetMC()->TrackCharge() || !TVirtualMC::GetMC()->IsTrackAlive() ) return;   
434    // We keep charged and non-charged tracks : 
435    if ( !TVirtualMC::GetMC()->IsTrackAlive() ) return;   
436    
437    Int_t copy;
438    Int_t current_volid = TVirtualMC::GetMC()->CurrentVolID( copy );
439
440    // check is the track is in a sensitive volume
441    if( current_volid != idADA && current_volid != idADC ) {
442       return; // not in the sensitive volume 
443    }
444    
445    // First read the position, otherwise weird reults! //ecv
446    Double_t s[3];
447    Float_t  x[3];
448    TVirtualMC::GetMC()->TrackPosition( s[0], s[1], s[2] );
449    for ( Int_t j=0; j<3; j++ ) x[j] = s[j];
450    
451    // Set detectro type: ADA or ADC
452    Int_t detType = (current_volid == idADA ) ? 0 : 1;
453    
454    // Get sector copy (1,2,3,4) ( 1 level up from pad )
455    Int_t sect;
456    TVirtualMC::GetMC()->CurrentVolOffID( 1, sect );
457
458    // Get Detector copy (1,2) ( 2 levels up from pad )
459    Int_t detc;
460    TVirtualMC::GetMC()->CurrentVolOffID( 2, detc );
461    
462    // Sector number 
463    // ADA1 = 10-14
464    // ADA2 = 20-24
465    // ADC1 = 30-34
466    // ADC2 = 40-44
467    Int_t sectorNumber_AD = detType*20 + detc*10 + sect;
468    
469    Double_t lightYield_ad;
470    Double_t photoCathodeEfficiency;
471   
472    if( detType == 1 )  {
473       lightYield_ad          = fADCLightYield;
474       photoCathodeEfficiency = fADCPhotoCathodeEfficiency;
475    } else  {
476       lightYield_ad          = fADALightYield;
477       photoCathodeEfficiency = fADAPhotoCathodeEfficiency;
478    }
479       
480    Float_t destep_ad = TVirtualMC::GetMC()->Edep();
481    Float_t step_ad   = TVirtualMC::GetMC()->TrackStep();
482    Int_t  nPhotonsInStep_ad = Int_t( destep_ad / (lightYield_ad * 1e-9) ); 
483    nPhotonsInStep_ad = gRandom->Poisson( nPhotonsInStep_ad );
484    
485    static  Float_t eloss_ad    = 0.;
486    static  Float_t tlength_ad  = 0.;   
487    static  Int_t   nPhotons_ad = 0;      
488    static  Float_t hits_ad[11];            
489    static  Int_t   vol_ad[5];
490
491    eloss_ad   += destep_ad;
492    tlength_ad += step_ad;  
493  
494    if ( TVirtualMC::GetMC()->IsTrackEntering() ) { 
495       nPhotons_ad = nPhotonsInStep_ad;
496       Double_t p[4];
497       TVirtualMC::GetMC()->TrackMomentum( p[0], p[1], p[2], p[3] );
498       Float_t pt  = TMath::Sqrt( p[0]*p[0] + p[1]*p[1] + p[2]*p[2] ); 
499       TParticle *par = gAlice->GetMCApp()->Particle(gAlice->GetMCApp()->GetCurrentTrackNumber());
500       Int_t imo = par->GetFirstMother();
501       Int_t pdgMo = 0;
502       if ( imo > 0 ) {
503          TParticle * pmot = gAlice->GetMCApp()->Particle(imo);
504          pdgMo = pmot->GetPdgCode();
505       }
506
507       // Set integer values
508       vol_ad[0]  = par->GetStatusCode();    // secondary flag //ecv
509       vol_ad[1]  = par->GetPdgCode();       // PDG code
510       vol_ad[2]  = pdgMo;                   // PDG of the mother
511       // Set float values
512       hits_ad[0]  = x[0];     // X
513       hits_ad[1]  = x[1];     // Y 
514       hits_ad[2]  = x[2];     // Z       
515       hits_ad[3]  = p[3];     // kinetic energy of the entering particle
516       hits_ad[4]  = pt;       // Pt
517       hits_ad[5]  = p[0];     // Px
518       hits_ad[6]  = p[1];     // Py
519       hits_ad[7]  = p[2];     // Pz
520       hits_ad[8]  = 1.0e09*TVirtualMC::GetMC()->TrackTime(); // in ns!
521   
522       tlength_ad = 0.0;
523       eloss_ad   = 0.0; 
524       
525       return; // without return, we count 2 times nPhotonsInStep_ad !!!???
526    }
527    
528    nPhotons_ad += nPhotonsInStep_ad;
529
530    if( TVirtualMC::GetMC()->IsTrackExiting() || TVirtualMC::GetMC()->IsTrackStop() || TVirtualMC::GetMC()->IsTrackDisappeared() ) {
531
532       // Set integer values
533       vol_ad[3]  = nPhotons_ad;
534         // brutal correction for ADA_1
535       if (sectorNumber_AD==11) sectorNumber_AD=0;
536       if (sectorNumber_AD==12) sectorNumber_AD=1;
537       if (sectorNumber_AD==13) sectorNumber_AD=2;
538       if (sectorNumber_AD==14) sectorNumber_AD=3;
539
540         // same for ADA_2
541       if (sectorNumber_AD==21) sectorNumber_AD=4;
542       if (sectorNumber_AD==22) sectorNumber_AD=5;
543       if (sectorNumber_AD==23) sectorNumber_AD=6;
544       if (sectorNumber_AD==24) sectorNumber_AD=7;
545
546         // brutal correction for ADC_3
547       if (sectorNumber_AD==51) sectorNumber_AD=8;
548       if (sectorNumber_AD==52) sectorNumber_AD=9;
549       if (sectorNumber_AD==53) sectorNumber_AD=10;
550       if (sectorNumber_AD==54) sectorNumber_AD=11;
551
552         // same for ADC_4
553       if (sectorNumber_AD==61) sectorNumber_AD=12;
554       if (sectorNumber_AD==62) sectorNumber_AD=13;
555       if (sectorNumber_AD==63) sectorNumber_AD=14;
556       if (sectorNumber_AD==64) sectorNumber_AD=15;
557
558
559       vol_ad[4]  = sectorNumber_AD;  // sector number (scintillator ID)
560       // Set float values
561       hits_ad[9]  = tlength_ad;    // track lenght inside ADC or ADA
562       hits_ad[10] = eloss_ad;      // energy loss
563       Int_t track = gAlice->GetMCApp()->GetCurrentTrackNumber();
564       AddHit( track, vol_ad, hits_ad ); // <-- this is in AliAD.cxx
565       tlength_ad        = 0.0;
566       eloss_ad          = 0.0; 
567       nPhotons_ad       = 0;
568    }
569        
570    //   Do we need track reference ????
571    // if( TVirtualMC::GetMC()->IsTrackEntering() || TVirtualMC::GetMC()->IsTrackExiting() ) {
572    //    AddTrackReference(gAlice->GetMCApp()->GetCurrentTrackNumber(), 49);
573    // }
574 }
575 //_________________________________________________________
576 void AliADv1::AddHit(Int_t track, Int_t *vol, Float_t *hits)
577 {
578         TClonesArray &lhits = *fHits;
579         new(lhits[fNhits++]) AliADhit(fIshunt,track,vol,hits);
580 }
581 //_________________________________________________________
582 void AliADv1::AddDigits(Int_t* track, Int_t module, Float_t time)
583 {
584         TClonesArray &ldigits = *fDigits;
585         new(ldigits[fNdigits++]) AliADdigit(track,module,time);
586 }
587 //_________________________________________________________
588 void AliADv1::MakeBranch(Option_t *option)
589 {
590
591         // Create branches in the current tree
592         TString branchname(Form("%s",GetName()));
593         AliDebug(2,Form("fBufferSize = %d",fBufferSize));
594         const char *cH = strstr(option,"H");
595         if (fHits && fLoader->TreeH() && cH)
596         {
597                 fLoader->TreeH()->Branch(branchname.Data(),&fHits,fBufferSize);
598                 AliDebug(2,Form("Making Branch %s for hits",branchname.Data()));
599         }
600         const char *cD = strstr(option,"D");
601         if (fDigits   && fLoader->TreeD() && cD) 
602         {
603                 fLoader->TreeD()->Branch(branchname.Data(),&fDigits, fBufferSize);
604                 AliDebug(2,Form("Making Branch %s for digits",branchname.Data()));
605         }  
606 }