4afd66993a37e3bf0f2eb7a54d425f107f5d107f
[u/mrichter/AliRoot.git] / ITS / AliITSvBeamTestITS04.cxx
1 ////////////////////////////////////////////////////////
2 // ITS geometry class and step manager for the        //
3 //   integrated ITS test beam of Nov. 04              //
4 //  Author: mercedes.lopez.noriega@cern.ch            //
5 ////////////////////////////////////////////////////////
6
7 #include <TLorentzVector.h>
8
9 #include <TGeoManager.h>
10 #include <TGeoVolume.h>
11 #include <TGeoPcon.h>
12 #include "AliRun.h"
13 #include "AliITSvBeamTestITS04.h"
14 #include <TClonesArray.h>
15 #include <TString.h>
16 #include "AliITS.h"
17 #include "AliMagF.h"
18 #include "TVirtualMC.h"
19 #include "AliMC.h"
20 #include "AliTrackReference.h"
21 #include "AliITSgeom.h"
22 #include "AliITShit.h"
23
24 const Int_t AliITSvBeamTestITS04::fgkNumberOfSPD = 4;
25 const Int_t AliITSvBeamTestITS04::fgkNumberOfSDD = 2;
26 const Int_t AliITSvBeamTestITS04::fgkNumberOfSSD = 4;
27 // Dimension (thickness:Y (beam direction), width:X, length:Z)
28
29 const char*    AliITSvBeamTestITS04::fgSPDsensitiveVolName = "ITSspdSensitiv";
30 //dimensions (preliminary values from Petra (in cms))
31 const Double_t AliITSvBeamTestITS04::fgkSPDthickness    = 0.02;
32 const Double_t AliITSvBeamTestITS04::fgkSPDwidth        = 1.4; 
33 const Double_t AliITSvBeamTestITS04::fgkSPDlength       = 7.2;
34 const Double_t AliITSvBeamTestITS04::fgkSPDthickSens    = 0.02;
35 const Double_t AliITSvBeamTestITS04::fgkSPDwidthSens    = 1.2; 
36 const Double_t AliITSvBeamTestITS04::fgkSPDlengthSens   = 7.0;
37 //position
38 const Double_t AliITSvBeamTestITS04::fgkSPD0y = 23.7;
39 const Double_t AliITSvBeamTestITS04::fgkSPD1y = 33.7;
40
41 //===
42 const char*    AliITSvBeamTestITS04::fgSDDsensitiveVolName = "ITSsddSensitiv";
43 //dimensions (preliminary values from Ludovic (in cms))
44 const Double_t AliITSvBeamTestITS04::fgkSDDthickness     = 0.03;
45 const Double_t AliITSvBeamTestITS04::fgkSDDwidth         = 7.22;
46 const Double_t AliITSvBeamTestITS04::fgkSDDlength        = 8.76;
47 const Double_t AliITSvBeamTestITS04::fgkSDDthickSens     = 0.02998;
48 const Double_t AliITSvBeamTestITS04::fgkSDDwidthSens     = 7.017;
49 const Double_t AliITSvBeamTestITS04::fgkSDDlengthSens    = 7.497;
50 //position
51 const Double_t AliITSvBeamTestITS04::fgkSDD0y = 51.7;
52 const Double_t AliITSvBeamTestITS04::fgkSDD1y = 57.2;
53
54 //===
55 const char*    AliITSvBeamTestITS04::fgSSDsensitiveVolName = "ITSssdSensitiv";
56 //dimensions (final values from Javier (in cms))
57 const Double_t AliITSvBeamTestITS04::fgkSSDthickness    = 0.03;
58 const Double_t AliITSvBeamTestITS04::fgkSSDwidth        = 7.7;
59 const Double_t AliITSvBeamTestITS04::fgkSSDlength       = 4.4;
60 const Double_t AliITSvBeamTestITS04::fgkSSDthickSens    = 0.03;
61 const Double_t AliITSvBeamTestITS04::fgkSSDwidthSens    = 7.5;
62 const Double_t AliITSvBeamTestITS04::fgkSSDlengthSens   = 4.2;
63 //position
64 const Double_t AliITSvBeamTestITS04::fgkSSD0y = 73.6;
65 const Double_t AliITSvBeamTestITS04::fgkSSD1y = 80.6;
66
67 //===============================================================
68
69
70
71 ClassImp(AliITSvBeamTestITS04)
72     
73 //_____________________________________________________________
74   AliITSvBeamTestITS04::AliITSvBeamTestITS04() : 
75 AliITS(),              // Base class
76 fITSmotherVolume(0),   // Pointer to ITS mother volume.
77 fNspd(fgkNumberOfSPD), //Number of SPD modules
78 fNsdd(fgkNumberOfSDD), //Number of SDD modules
79 fNssd(fgkNumberOfSSD), //Number of SSD modules
80 fGeomDetOut(kFALSE),   // Flag to write .det file out
81 fGeomDetIn(kFALSE),    // Flag to read geometry file (JC)
82 fWrite(),              //! file name to write .det file 
83 fRead(),               // file name to read .det file (JC)
84 fMajorVersion(kvITS04),// Major Version
85 fMinorVersion(1),      // Minor Version
86 fIgm(kvITS04)          //! Init geometry object
87 {
88     //
89     // Constructor
90     //
91
92     fIdN = 3;         
93     fIdName    = new TString[fIdN];
94     fIdName[0] = fgSPDsensitiveVolName;
95     fIdName[1] = fgSDDsensitiveVolName;
96     fIdName[2] = fgSSDsensitiveVolName;
97     fIdSens    = new Int_t[fIdN];
98     for(Int_t i=0; i<fIdN; i++) fIdSens[i] = 0;
99     
100     for(Int_t a=0;a<60;a++) fWrite[a] = '\0';
101 }
102 //_____________________________________________________________
103 AliITSvBeamTestITS04::AliITSvBeamTestITS04(const char* name,const char *title):
104 AliITS(name,title),   // Base class
105 fITSmotherVolume(0),   // Pointer to ITS mother volume.
106 fNspd(fgkNumberOfSPD), //Number of SPD modules
107 fNsdd(fgkNumberOfSDD), //Number of SDD modules
108 fNssd(fgkNumberOfSSD), //Number of SSD modules
109 fGeomDetOut(kFALSE),   // Flag to write .det file out
110 fGeomDetIn(kFALSE),    // Flag to read geometry file (JC)
111 fWrite(),              //! file name to write .det file 
112 fRead(),               // file name to read .det file (JC)
113 fMajorVersion(kvITS04),// Major Version
114 fMinorVersion(1),       // Minor Version
115 fIgm(kvITS04)          //! Init geometry object
116 {
117     //
118     // Constructor
119     //
120
121     fIdN = 3;         
122     fIdName    = new TString[fIdN];
123     fIdName[0] = fgSPDsensitiveVolName;
124     fIdName[1] = fgSDDsensitiveVolName;
125     fIdName[2] = fgSSDsensitiveVolName;
126     fIdSens    = new Int_t[fIdN];
127     for(Int_t i=0; i<fIdN; i++) fIdSens[i] = 0;
128     for(Int_t a=0;a<60;a++) fWrite[a] = '\0';    
129 }
130 //__________________________________________________________________
131 AliITSvBeamTestITS04::~AliITSvBeamTestITS04(){
132     //
133     // Destructor
134     //
135 }
136 //______________________________________________________________________
137 void AliITSvBeamTestITS04::CreateMaterials(){
138     // Media defined here should correspond to the one defined in galice.cuts
139     // This file is read in (AliMC*) fMCApp::Init() { ReadTransPar(); }
140     // Create ITS materials
141     Int_t   ifield = gAlice->Field()->Integ();
142     Float_t fieldm = gAlice->Field()->Max();
143     
144     Float_t tmaxfdSi = 0.1;
145     Float_t stemaxSi = 0.0075;
146     Float_t deemaxSi = 0.1;
147     Float_t epsilSi  = 1.0E-4;
148     Float_t stminSi  = 0.0;
149     
150     Float_t tmaxfdAir = 0.1;
151     Float_t stemaxAir = .10000E+01;
152     Float_t deemaxAir = 0.1;
153     Float_t epsilAir  = 1.0E-4;
154     Float_t stminAir  = 0.0;
155  
156     // AIR
157     Float_t aAir[4]={12.0107,14.0067,15.9994,39.948};
158     Float_t zAir[4]={6.,7.,8.,18.};
159     Float_t wAir[4]={0.000124,0.755267,0.231781,0.012827};
160     Float_t dAir = 1.20479E-3;
161     
162     AliMaterial(51,"ITSspdSi",0.28086E+02,0.14000E+02,0.23300E+01,0.93600E+01,0.99900E+03);
163     AliMedium(51,"ITSspdSi",51,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,epsilSi,stminSi);
164     
165     AliMaterial(1,"ITSsddSi",0.28086E+02,0.14000E+02,0.23300E+01,0.93600E+01,0.99900E+03);
166     AliMedium(1,"ITSsddSi",1,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,epsilSi,stminSi);
167     
168     //AliMaterial(?,"ITSssdSi",0.28086E+02,0.14000E+02,0.23300E+01,0.93600E+01,0.99900E+03);
169     //AliMedium(?,"ITSssdSi",51,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,epsilSi,stminSi);
170     
171     AliMixture(5,"ITSair",aAir,zAir,dAir,4,wAir);
172     AliMedium(5,"ITSair",5,0,ifield,fieldm,tmaxfdAir,stemaxAir,deemaxAir,epsilAir,stminAir);
173     
174 //NEED TO ADD PLASTIC OF SCINTILLATORS!!
175
176 }
177
178 //______________________________________________________________________
179 void AliITSvBeamTestITS04::CreateGeometry(){    
180     //Creates geometry
181     // These constant character strings are set by cvs during commit
182     // do not change them unless you know what you are doing!
183     const Char_t *cvsDate="$Date$";
184     const Char_t *cvsRevision="$Revision$";
185     TGeoManager *geoManager = gGeoManager;
186     TGeoVolume *vALIC = geoManager->GetTopVolume();
187     
188     //================================
189     //       ITS mother volume
190     //================================
191     TGeoPcon *sITS = new TGeoPcon("ITS Top Volume",0.0,360.0,2);
192     // DefineSection(section number, Z, Rmin, Rmax).
193     sITS->DefineSection(0,-100.0,0.01,100.0); // Units in cms
194     sITS->DefineSection(1,+100.0,0.01,100.0);
195     
196     TGeoMedium *air = geoManager->GetMedium("ITSair");
197     fITSmotherVolume = new TGeoVolume("ITSV",sITS,air);
198     const Int_t kLength=100;
199     Char_t vstrng[kLength];
200     if(fIgm.WriteVersionString(vstrng,kLength,(AliITSVersion_t)IsVersion(),
201                                fMinorVersion,cvsDate,cvsRevision))
202         fITSmotherVolume->SetTitle(vstrng);
203     else Error("CreateGeometry","Error writing/setting version string");
204     //printf("Title set to %s\n",vstrng);
205     if(vALIC==0) {
206         Error("CreateGeometry","alic=0");
207         return;
208     } // end if
209     fITSmotherVolume->SetVisibility(kFALSE);
210     vALIC->AddNode(fITSmotherVolume,1,0);
211     
212 //     //Scintillators
213 //     TGeoMedium *plasticScint = new TGeoMedium("plasticScint",1,Plastic);
214 //     //First Scintillator
215 //     TGeoBBox *Scint1Shape = new TGeoBBox("Scint1Shape",0.5,0.1,0.5,0); //1x1cm
216 //     TGeoVolume *Scint1 = new TGeoVolume("Scint1",Scint1Shape,plasticScint);
217 //     TGeoTranslation *firstScint = new TGeoTranslation(0,0.7,0);
218 //     vALIC->AddNode(Scint1,2,firstScint);
219 //     //Second Scintillator
220 //     TGeoBBox *Scint2Shape = new TGeoBBox("Scint2Shape",1.,0.1,1.,0); //2x2cm
221 //     TGeoVolume *Scint2 = new TGeoVolume("Scint2",Scint2Shape,plasticScint);
222 //     TGeoTranslation *secondScint = new TGeoTranslation(0,90.,0);
223 //     vALIC->AddNode(Scint2,3,secondScint);
224     
225     AddSPDGeometry(fITSmotherVolume);
226     AddSDDGeometry(fITSmotherVolume);
227     AddSSDGeometry(fITSmotherVolume);
228 }
229
230 //______________________________________________________________________
231 void AliITSvBeamTestITS04::Init()
232 {
233     // Initialize the ITS after it has been created.
234     // Inputs:
235     //   none.
236     // Outputs:
237     //   none.
238     // Return:
239     //   none.
240
241     AliDebug(1,Form("Init: Major version %d Minor version %d",fMajorVersion,
242                  fMinorVersion));
243     //
244     UpdateInternalGeometry();
245     AliITS::Init();
246     if(fGeomDetOut) GetITSgeom()->WriteNewFile(fWrite);
247
248     //
249 }
250 /*
251 //______________________________________________________________________
252 void AliITSvBeamTestITS04::InitAliITSgeom()
253 {    
254   //initialisation of ITSgeom
255     const Int_t knlayers = 6;
256     Int_t nlad[knlayers], ndet[knlayers];
257     
258     nlad[0] = 1; ndet[0] = 2;
259     nlad[1] = 1; ndet[1] = 2;
260     nlad[2] = 1; ndet[2] = 1;
261     nlad[3] = 1; ndet[3] = 1;
262     nlad[4] = 1; ndet[4] = 2;
263     nlad[5] = 1; ndet[5] = 2;
264
265     Int_t nModTot = fNspd + fNsdd + fNssd;
266     if (GetITSgeom()) SetITSgeom(0x0);
267     AliITSgeom* geom = new AliITSgeom(0,knlayers,nlad,ndet,nModTot);
268     SetITSgeom(geom);
269     // *** Set default shapes 
270     const Float_t kDxyzSPD[] = {fgkSPDwidthSens/2, fgkSPDthickSens/2,fgkSPDlengthSens/2};  
271     if(!(GetITSgeom()->IsShapeDefined(kSPD)))
272         GetITSgeom()->ReSetShape(kSPD,new AliITSgeomSPD425Short(3,(Float_t *)kDxyzSPD));
273     
274     const Float_t kDxyzSDD[] = {fgkSDDwidthSens/2., fgkSDDthickSens/2.,fgkSDDlengthSens/2.};
275     if(!(GetITSgeom()->IsShapeDefined(kSDD)))
276         GetITSgeom()->ReSetShape(kSDD, new AliITSgeomSDD256(3,(Float_t *)kDxyzSDD));
277     
278     const Float_t kDxyzSSD[] = {fgkSSDlengthSens/2, fgkSSDthickSens/2,fgkSSDwidthSens/2};
279     if(!(GetITSgeom()->IsShapeDefined(kSSD)))
280         GetITSgeom()->ReSetShape(kSSD,new AliITSgeomSSD75and275(3,(Float_t *)kDxyzSSD));
281     
282     // Creating the matrices in AliITSgeom for each sensitive volume
283     // (like in AliITSv11GeometrySDD) mln
284     // Here, each layer is one detector
285     
286     char layerName[30];
287     Int_t startMod = 0;
288     
289     // SPD
290     for (Int_t i=0; i<fNspd;i++) {
291         sprintf(layerName, "ITSspdWafer_%i",i+1);
292         TGeoNode *layNode = fITSmotherVolume->GetNode(layerName);
293         if (layNode) {
294             TGeoHMatrix layMatrix(*layNode->GetMatrix());           
295             Double_t *trans  = layMatrix.GetTranslation();
296             Double_t *r      = layMatrix.GetRotationMatrix();
297             Double_t rot[10] = {r[0],r[1],r[2],
298                                 r[3],r[4],r[5],
299                                 r[6],r[7],r[8], 1.0};
300             Int_t iDet = 1;
301             if ((i+1==2)||(i+1==4)) iDet = 2;
302             Int_t iLad = 1;
303             Int_t iLay = 1;
304             if (i+1>2) iLay = 2;
305             GetITSgeom()->CreateMatrix(startMod,iLay,iLad,iDet,kSPD,trans,rot);
306             startMod++;
307         };
308     };
309     
310     // SDD
311     for (Int_t i=0; i<fNsdd;i++) {
312         sprintf(layerName, "ITSsddWafer_%i",i+fNspd+1);
313         TGeoNode *layNode = fITSmotherVolume->GetNode(layerName);
314         if (layNode) {
315             TGeoHMatrix layMatrix(*layNode->GetMatrix());
316             Double_t *trans  = layMatrix.GetTranslation();
317             Double_t *r      = layMatrix.GetRotationMatrix();
318             Double_t rot[10] = {r[0],r[1],r[2],
319                                 r[3],r[4],r[5],
320                                 r[6],r[7],r[8], 1.0};
321             Int_t iDet = 1;
322             Int_t iLad = 1;
323             Int_t iLay = fNspd-1+i;
324             GetITSgeom()->CreateMatrix(startMod,iLay,iLad,iDet,kSDD,trans,rot);
325             startMod++;
326         };
327     };
328     
329     // SSD
330     for (Int_t i=0; i<fNssd;i++) {
331         sprintf(layerName, "ITSssdWafer_%i",i+fNspd+fNsdd+1);
332         TGeoNode *layNode = fITSmotherVolume->GetNode(layerName);
333         if (layNode) {
334             TGeoHMatrix layMatrix(*layNode->GetMatrix());           
335             Double_t *trans  = layMatrix.GetTranslation();
336             Double_t *r      = layMatrix.GetRotationMatrix();
337             Double_t rot[10] = {r[0],r[1],r[2],
338                                 r[3],r[4],r[5],
339                                 r[6],r[7],r[8], 1.0};
340             Int_t iDet = 1;
341             if ((i+1==2)||(i+1==4)) iDet = 2;
342             Int_t iLad = 1;
343             Int_t iLay = 5;
344             if (i+1>2) iLay = 6;
345             GetITSgeom()->CreateMatrix(startMod,iLay,iLad,iDet,kSSD,trans,rot);
346             startMod++;
347         };
348     };
349     
350     return;
351 }
352 //______________________________________________________________________
353 void AliITSvBeamTestITS04::SetDefaults()
354 {
355     // (from AliITSv11) mln
356     
357     const Float_t kconv = 1.0e+04; // convert cm to microns
358     
359     if(!fDetTypeSim) fDetTypeSim = new AliITSDetTypeSim();
360     fDetTypeSim->SetITSgeom(GetITSgeom());
361     fDetTypeSim->ResetCalibrationArray();
362     fDetTypeSim->ResetSegmentation();
363  
364     AliITSgeomSPD *s0;
365     AliITSgeomSDD *s1;
366     AliITSgeomSSD *s2;
367     Int_t i;
368     Float_t bx[256],bz[280];
369
370     // If fGeomDetIn is set true the geometry will
371     // be initialised from file (JC)
372     if(GetITSgeom()!=0) SetITSgeom(0x0);
373     AliITSgeom* geom = new AliITSgeom();
374     SetITSgeom(geom);
375     if(fGeomDetIn) GetITSgeom()->ReadNewFile(fRead);
376     if(!fGeomDetIn) this->InitAliITSgeom();
377     if(fGeomDetOut) GetITSgeom()->WriteNewFile(fWrite);
378
379    
380     // SPD
381
382     s0 = (AliITSgeomSPD*) GetITSgeom()->GetShape(kSPD);// Get shape info.
383     if (s0) {
384         AliITSCalibration *resp0=new AliITSCalibrationSPD();
385         SetCalibrationModel(kSPD,resp0);
386
387         AliITSsegmentationSPD *seg0=new AliITSsegmentationSPD();
388         seg0->SetDetSize(s0->GetDx()*2.*kconv, // base this on AliITSgeomSPD
389                          s0->GetDz()*2.*kconv, // for now.
390                          s0->GetDy()*2.*kconv);// x,z,y full width in microns.
391         seg0->SetNPads(256,160);               // Number of Bins in x and z
392         for(i=000;i<256;i++) bx[i] =  50.0;    // in x all are 50 microns.
393         for(i=000;i<160;i++) bz[i] = 425.0;    // most are 425 microns except below
394         for(i=160;i<280;i++) bz[i] =   0.0;    // Outside of detector.
395         bz[ 31] = bz[ 32] = 625.0;             // first chip boundry
396         bz[ 63] = bz[ 64] = 625.0;             // first chip boundry
397         bz[ 95] = bz[ 96] = 625.0;             // first chip boundry
398         bz[127] = bz[128] = 625.0;             // first chip boundry
399         bz[160] = 425.0;                       // Set so that there is no zero pixel size for fNz.
400         seg0->SetBinSize(bx,bz);               // Based on AliITSgeomSPD for now.
401         SetSegmentationModel(kSPD,seg0);
402         // set digit and raw cluster classes to be used
403         const char *kData0=(fDetTypeSim->GetCalibrationModel(kSPD))->DataType();
404         if (strstr(kData0,"real")) 
405           fDetTypeSim->SetDigitClassName(kSPD,"AliITSdigit");
406         else fDetTypeSim->SetDigitClassName(kSPD,"AliITSdigitSPD");
407     }
408   
409     // SDD
410    
411     s1 = (AliITSgeomSDD*) GetITSgeom()->GetShape(kSDD);// Get shape info.
412     if (s1) {
413       AliITSCalibrationSDD *resp1=new AliITSCalibrationSDD("simulated");
414       SetCalibrationModel(kSDD,resp1);
415       AliITSsegmentationSDD *seg1=new AliITSsegmentationSDD();
416       seg1->SetDetSize(s1->GetDx()*kconv, // base this on AliITSgeomSDD
417                        s1->GetDz()*4.*kconv, // for now.
418                        s1->GetDy()*4.*kconv); // x,z,y full width in microns.
419       seg1->SetDriftSpeed(AliITSresponseSDD::DefaultDriftSpeed());
420       seg1->SetNPads(256,256);// Use AliITSgeomSDD for now
421       SetSegmentationModel(kSDD,seg1);
422       const char *kData1=(fDetTypeSim->GetCalibrationModel(kSDD))->DataType();
423       const char *kopt=resp1->GetZeroSuppOption();
424       if((!strstr(kopt,"2D")) && (!strstr(kopt,"1D")) || strstr(kData1,"real") ){
425         fDetTypeSim->SetDigitClassName(kSDD,"AliITSdigit");
426         } else fDetTypeSim->SetDigitClassName(kSDD,"AliITSdigitSDD");
427     }
428     
429     // SSD
430     
431     s2 = (AliITSgeomSSD*) GetITSgeom()->GetShape(kSSD);// Get shape info. Do it this way for now.
432     if (s2) {
433       AliITSCalibration *resp2=new AliITSCalibrationSSD("simulated");
434       SetCalibrationModel(kSSD,resp2);
435
436       AliITSsegmentationSSD *seg2=new AliITSsegmentationSSD();
437       seg2->SetDetSize(s2->GetDx()*2.*kconv, // base this on AliITSgeomSSD
438                        s2->GetDz()*2.*kconv, // for now.
439                        s2->GetDy()*2.*kconv); // x,z,y full width in microns.
440       seg2->SetPadSize(95.,0.); // strip x pitch in microns
441       seg2->SetNPads(768,0); // number of strips on each side.
442       seg2->SetAngles(0.0075,0.0275); // strip angels rad P and N side.
443       seg2->SetAnglesLay5(0.0075,0.0275); // strip angels rad P and N side.
444       seg2->SetAnglesLay6(0.0275,0.0075); // strip angels rad P and N side.
445       SetSegmentationModel(kSSD,seg2); 
446       const char *kData2=(fDetTypeSim->GetCalibrationModel(kSSD))->DataType();
447       if(strstr(kData2,"real") ) fDetTypeSim->SetDigitClassName(kSSD,"AliITSdigit");
448       else fDetTypeSim->SetDigitClassName(kSSD,"AliITSdigitSSD");
449     }
450     
451   if(fgkNTYPES>3){Warning("SetDefaults","Only the four basic detector types are initialised!");}
452   return;
453 }
454 */
455 //______________________________________________________________________
456 void AliITSvBeamTestITS04::AddSPDGeometry(TGeoVolume *moth) const
457 {
458   //Adds SPD geometry
459     TGeoMedium *siliconSPD = gGeoManager->GetMedium("ITSspdSi");
460     
461     //outer volume
462     TGeoBBox *waferSPDshape = new TGeoBBox("ITSspdWaferShape",fgkSPDwidth/2,fgkSPDthickness/2,fgkSPDlength/2,0);
463     TGeoVolume *waferSPD = new TGeoVolume("ITSspdWafer",waferSPDshape,siliconSPD);
464     //sensitive volume
465     TGeoBBox *sensSPDbox = new TGeoBBox("ITSsddSensorSensBox",fgkSPDwidthSens/2,fgkSPDthickSens/2,fgkSPDlengthSens/2,0);
466     TGeoVolume *sensVolSPD = new TGeoVolume(fgSPDsensitiveVolName,sensSPDbox,siliconSPD);
467     waferSPD->AddNode(sensVolSPD, 1, 0); //added to outer volume
468     
469     //locate them in space (with respect top volume)
470     TGeoTranslation *spd1tr = new TGeoTranslation(0,fgkSPD0y,fgkSPDlength/2);
471     TGeoTranslation *spd2tr = new TGeoTranslation(0,fgkSPD0y,-fgkSPDlength/2);
472
473     TGeoTranslation *spd3tr = new TGeoTranslation(0,fgkSPD1y,fgkSPDlength/2);
474     TGeoTranslation *spd4tr = new TGeoTranslation(0,fgkSPD1y,-fgkSPDlength/2);
475     
476     //add to top volume
477     moth->AddNode(waferSPD, 1, spd1tr);
478     moth->AddNode(waferSPD, 2, spd2tr);
479     moth->AddNode(waferSPD, 3, spd3tr);
480     moth->AddNode(waferSPD, 4, spd4tr);
481     
482     //draw options
483     waferSPD->SetLineColor(4);
484     sensVolSPD->SetLineColor(4);
485 }
486
487
488 //______________________________________________________________________
489 void AliITSvBeamTestITS04::AddSDDGeometry(TGeoVolume *moth) const
490 {
491   //Adds SDD geometry
492     TGeoMedium *siliconSDD = gGeoManager->GetMedium("ITSsddSi");
493     
494     //outer volume
495     TGeoBBox *waferSDDshape = new TGeoBBox("ITSsddWaferShape",fgkSDDwidth/2,fgkSDDthickness/2,fgkSDDlength/2,0);
496     TGeoVolume *waferSDD = new TGeoVolume("ITSsddWafer",waferSDDshape,siliconSDD);
497     //sensitive volume
498     TGeoBBox *sensSDDbox = new TGeoBBox("ITSsddSensorSensBox",fgkSDDwidthSens/2,fgkSDDthickSens/2,fgkSDDlengthSens/2,0);
499     TGeoVolume *sensVolSDD = new TGeoVolume(fgSDDsensitiveVolName,sensSDDbox,siliconSDD);
500     waferSDD->AddNode(sensVolSDD, 1, 0); //added to outer volume
501     
502     //locate them in space
503     TGeoTranslation *sdd1tr = new TGeoTranslation(0,fgkSDD0y,0);
504     TGeoTranslation *sdd2tr = new TGeoTranslation(0,fgkSDD1y,0);
505         
506     //add to top volume
507     moth->AddNode(waferSDD, fNspd+1, sdd1tr);
508     moth->AddNode(waferSDD, fNspd+2, sdd2tr);
509     
510     //draw options
511     waferSDD->SetLineColor(3);
512     sensVolSDD->SetLineColor(3);
513 }
514
515
516 //______________________________________________________________________
517 void AliITSvBeamTestITS04::AddSSDGeometry(TGeoVolume *moth) const
518 {
519   //Adds SSD geometry
520     TGeoMedium *siliconSSD = gGeoManager->GetMedium("ITSspdSi"); // SSD medium still needed!!!
521     
522     //outer volume 
523     TGeoBBox *waferSSDshape = new TGeoBBox("ITSssdWaferShape",fgkSSDwidth/2,fgkSSDthickness/2,fgkSSDlength/2,0);
524     TGeoVolume *waferSSD = new TGeoVolume("ITSssdWafer",waferSSDshape,siliconSSD);
525     //sensitive volume
526     TGeoBBox *sensSSDbox = new TGeoBBox("ITSssdSensorSensBox",fgkSSDwidthSens/2,fgkSSDthickSens/2,fgkSSDlengthSens/2,0);
527     TGeoVolume *sensVolSSD = new TGeoVolume(fgSSDsensitiveVolName,sensSSDbox,siliconSSD);
528     waferSSD->AddNode(sensVolSSD, 1, 0);
529     
530     //locate them in space
531     /* In the SSD, there was an overlap of sensitive volumes of 2.9mm = 0.29cm (0.29/2=0.145) 
532        in the modules in the same plane, therefore the modules where not in the same plane in 
533        the Y direction, there was a "thickness" (0.03cm) difference */
534     TGeoTranslation *ssd1tr = new TGeoTranslation(0,fgkSSD0y,fgkSSDlength/2-0.145);
535     TGeoTranslation *ssd2tr = new TGeoTranslation(0,fgkSSD0y+0.03,-fgkSSDlength/2+0.145);
536
537     TGeoTranslation *ssd3tr = new TGeoTranslation(0,fgkSSD1y,fgkSSDlength/2-0.145);
538     TGeoTranslation *ssd4tr = new TGeoTranslation(0,fgkSSD1y+0.03,-fgkSSDlength/2+0.145);
539
540     //add to top volume
541     moth->AddNode(waferSSD, fNspd+fNsdd+1, ssd1tr);
542     moth->AddNode(waferSSD, fNspd+fNsdd+2, ssd2tr);
543     moth->AddNode(waferSSD, fNspd+fNsdd+3, ssd3tr);
544     moth->AddNode(waferSSD, fNspd+fNsdd+4, ssd4tr);
545     
546     //draw options
547     waferSSD->SetLineColor(2);
548     sensVolSSD->SetLineColor(2);
549 }
550
551 //______________________________________________________________________
552 void AliITSvBeamTestITS04::StepManager()
553 {
554     // Called for every step in the ITS, then calles the AliITShit class
555     // creator with the information to be recoreded about that hit.
556
557     // "Standard" StepManager. (Similar to AliITSv11) mln
558     Int_t cpy0,mod,status,id,kk;
559     TLorentzVector position, momentum;
560     static AliITShit hit;// Saves on calls to construtors
561     
562     if(!(this->IsActive())) return;
563     if(!(gMC->TrackCharge())) return;
564     //TClonesArray &lhits = *(GetDetTypeSim()->GetHits());
565     TClonesArray &lhits = *(Hits());
566     //
567     // Track status
568     // Track status
569     status = 0;
570     if(gMC->IsTrackInside())      status +=  1;
571     if(gMC->IsTrackEntering())    status +=  2;
572     if(gMC->IsTrackExiting())     status +=  4;
573     if(gMC->IsTrackOut())         status +=  8;
574     if(gMC->IsTrackDisappeared()) status += 16;
575     if(gMC->IsTrackStop())        status += 32;
576     if(gMC->IsTrackAlive())       status += 64;
577     
578     id=gMC->CurrentVolID(cpy0);
579     
580     Bool_t sensvol = kFALSE;
581     for(kk=0;kk<fIdN;kk++) if(id == fIdSens[kk]) sensvol = kTRUE;
582     if(!sensvol) return;
583
584     fIgm.DecodeDetector(mod,gGeoManager->GetMother(1)->GetNumber(),1,1,1);
585     //
586     // Fill hit structure.
587     //
588     hit.SetModule(mod);
589     hit.SetTrack(gAlice->GetMCApp()->GetCurrentTrackNumber());
590     gMC->TrackPosition(position);
591     gMC->TrackMomentum(momentum);
592     hit.SetPosition(position);
593     hit.SetTime(gMC->TrackTime());
594     hit.SetMomentum(momentum);
595     hit.SetStatus(status);
596     hit.SetEdep(gMC->Edep());
597     hit.SetShunt(GetIshunt());
598     if(gMC->IsTrackEntering()){
599         hit.SetStartPosition(position);
600         hit.SetStartTime(gMC->TrackTime());
601         hit.SetStartStatus(status);
602         return; // don't save entering hit.
603     } // end if IsEntering
604     // Fill hit structure with this new hit.
605     //Info("StepManager","Calling Copy Constructor");
606     new(lhits[fNhits++]) AliITShit(hit); // Use Copy Construtor.
607     // Save old position... for next hit.
608     hit.SetStartPosition(position);
609     hit.SetStartTime(gMC->TrackTime());
610     hit.SetStartStatus(status);
611     return;
612 }
613 /*
614 //______________________________________________________________________
615 Int_t AliITSvBeamTestITS04::GetCurrentLayLaddDet(Int_t &lay,Int_t &ladd, Int_t &det) const
616
617   // Function which gives the layer, ladder and det.
618   // index of the current volume. To be used in
619   // AliITS::StepManager()
620
621     det  = 1;   ladd = 1;
622     
623     TGeoNode *node = gGeoManager->GetMother(1);
624     if (!node) return kFALSE;
625     Int_t nodeNum = node->GetNumber();
626     
627     // GetNumber() return the index recorded in the node
628     
629     if (nodeNum==5||nodeNum==6) {         // SDD: one layer, one detector
630         lay = nodeNum-2;
631     } else if (nodeNum==3||nodeNum==4) {  // SPD layer 2
632         lay = 2;
633         if (nodeNum==4) det = 2;
634     } else if (nodeNum==1||nodeNum==2){   // SPD layer 1
635         lay = 1;
636         if (nodeNum==2) det = 2; 
637     } else if (nodeNum==9||nodeNum==10) { // SSD layer 2
638         lay = 6;
639         if (nodeNum==10) det = 2;
640     } else if (nodeNum==7||nodeNum==8){   // SSD layer 1
641         lay = 5;
642         if (nodeNum==8) det = 2; 
643     };  
644     
645     return kTRUE;
646 }
647 */
648 //_____________________________________________________________
649
650  Int_t AliITSvBeamTestITS04::GetNumberOfSubDet(const TString& det) const{
651     
652    //Get number of individual detectors
653     if(det.Contains("SPD")) return fNspd;
654     if(det.Contains("SDD")) return fNsdd;
655     if(det.Contains("SSD")) return fNssd;
656     return 0;
657   }