For Pythia with tune don't switch off MI in ConfigHeavyFlavor
[u/mrichter/AliRoot.git] / ITS / AliITSv11.cxx
1 /**************************************************************************
2  * Copyright(c) 2007-2008, 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 //************************************************************************
18 //
19 //                 Inner Traking System geometry v11
20 //
21 //  Based on ROOT geometrical modeler
22 //
23 // B. Nilsen, L. Gaudichet
24 //************************************************************************
25
26 #include <TClonesArray.h>
27 #include <TGeoManager.h>
28 #include <TGeoPcon.h>
29 #include <TGeoVolume.h>
30 #include <TLorentzVector.h>
31 #include <TVirtualMC.h>
32
33 #include "AliITS.h"
34 #include "AliITSCalibrationSDD.h"
35 #include "AliITSDetTypeSim.h"
36 #include "AliITSgeom.h"
37 #include "AliITShit.h"
38 #include "AliITSsegmentationSDD.h"
39 #include "AliITSsegmentationSPD.h"
40 #include "AliITSsegmentationSSD.h"
41 #include "AliITSv11.h"
42 #include "AliITSv11GeometrySDD.h"
43 #include "AliITSv11GeometrySPD.h"
44 #include "AliITSv11GeometrySSD.h"
45 #include "AliITSv11GeometrySupport.h"
46 #include "AliMC.h"
47 #include "AliMagF.h"
48 #include "AliRun.h"
49 #include "AliTrackReference.h"
50
51 ClassImp(AliITSv11)
52  
53 //______________________________________________________________________
54 AliITSv11::AliITSv11() : 
55 fByThick(kTRUE),
56 fMajorVersion(IsVersion()),
57 fMinorVersion(0),
58 fSPDgeom(),
59 fSDDgeom(0),
60 fSSDgeom(),
61 fSupgeom(),
62 fIgm(kv11)
63 {
64   //    Standard default constructor for the ITS version 11.
65
66     fIdN          = 0;
67     fIdName       = 0;
68     fIdSens       = 0;
69 }
70
71
72 //______________________________________________________________________
73 AliITSv11::AliITSv11(const char *name, const char *title): 
74 AliITS("ITS", title),
75 fByThick(kTRUE),
76 fMajorVersion(IsVersion()),
77 fMinorVersion(0),
78 fSPDgeom(),
79 fSDDgeom(0),
80 fSSDgeom(),
81 fSupgeom(),
82 fIgm(kv11)
83 {
84   //    Standard constructor for the ITS version 11.
85
86   fSDDgeom = new AliITSv11GeometrySDD(0);
87
88   Int_t i;
89   fIdN = 6;
90   fIdName = new TString[fIdN];
91   fIdName[0] = name; // removes warning message
92   fIdName[0] = "ITS1";
93   fIdName[1] = "ITS2";
94   fIdName[2] = fSDDgeom->GetSenstiveVolumeName3();
95   fIdName[3] = fSDDgeom->GetSenstiveVolumeName4();
96   fIdName[4] = "ITS5";
97   fIdName[5] = "ITS6";
98   fIdSens    = new Int_t[fIdN];
99   for(i=0;i<fIdN;i++) fIdSens[i] = 0;
100   // not needed, fByThick set to kTRUE in in the member initialization lis
101   
102 }
103 //______________________________________________________________________
104 AliITSv11::AliITSv11(Int_t debugITS,Int_t debugSPD,Int_t debugSDD,
105                    Int_t debugSSD,Int_t debugSUP) :
106 AliITS("ITS","ITS geometry v11"),
107 fByThick(kTRUE),
108 fMajorVersion(IsVersion()),
109 fMinorVersion(0),
110 fSPDgeom(),
111 fSDDgeom(0),
112 fSSDgeom(),
113 fSupgeom(),
114 fIgm(kv11)
115 {
116   // Standard default constructor for the ITS version 11.
117
118
119   //   fSPDgeom = new AliITSv11GeometrySPD(debugSPD);
120   fSDDgeom = new AliITSv11GeometrySDD(debugSDD);
121   fSDDgeom->SetDebug(debugSDD);
122   //   fSupgeom = new AliITSv11GeometrySupport(debugSUP);
123
124   Int_t i;
125   fIdN = 6;
126   fIdName = new TString[fIdN];
127   fIdName[0] = fSPDgeom->GetSenstiveVolumeName1();
128   fIdName[1] = fSPDgeom->GetSenstiveVolumeName2();
129   fIdName[2] = fSDDgeom->GetSenstiveVolumeName3();
130   fIdName[3] = fSDDgeom->GetSenstiveVolumeName4();
131   fIdName[4] = fSSDgeom->GetSenstiveVolumeName5();
132   fIdName[5] = fSSDgeom->GetSenstiveVolumeName6();
133   fIdSens    = new Int_t[fIdN];
134   for(i=0;i<fIdN;i++) fIdSens[i] = 0;
135   debugITS = (debugSPD && debugSSD && debugSUP && debugSDD); //remove temp. warnings
136 }
137 //______________________________________________________________________
138 AliITSv11::~AliITSv11() {
139   delete fSDDgeom;
140 }
141 //______________________________________________________________________
142 void AliITSv11::CreateGeometry(){
143     //
144     // Create ROOT geometry
145     //
146     // These constant character strings are set by cvs during commit
147     // do not change them unless you know what you are doing!
148     const Char_t *cvsDate="$Date$";
149     const Char_t *cvsRevision="$Revision$";
150
151     TGeoManager *geoManager = gGeoManager;
152     TGeoVolume *vALIC = geoManager->GetTopVolume();
153
154     TGeoPcon *sITS = new TGeoPcon("ITS Top Volume",0.0,360.0,2);
155
156     // DefineSection(section number, Z, Rmin, Rmax).
157     const Double_t kcm = 1.0;
158     sITS->DefineSection(0,-300.0*kcm,0.01*kcm,50.0*kcm);
159     sITS->DefineSection(1,+300.0*kcm,0.01*kcm,50.0*kcm);
160
161     TGeoMedium *air = gGeoManager->GetMedium("ITS_AIR$");
162     TGeoVolume *vITS = new TGeoVolume("ITSV",sITS,air);
163     vITS->SetVisibility(kFALSE);
164     const Int_t length=100;
165     Char_t vstrng[length];
166     if(fIgm.WriteVersionString(vstrng,length,(AliITSVersion_t)IsVersion(),
167                                fMinorVersion,cvsDate,cvsRevision))
168         vITS->SetTitle(vstrng);
169     //printf("Title set to %s\n",vstrng);
170     vALIC->AddNode(vITS,1,0);
171
172 //   fSPDgeom->CenteralSPD(vITS);
173
174   fSDDgeom->Layer3(vITS);
175   fSDDgeom->Layer4(vITS);
176
177 //     fSupgeom->SPDCone(vITS);
178 //     fSupgeom->SPDThermalSheald(vITS);
179 //     fSupgeom->SDDCone(vITS);
180 //     fSupgeom->SSDCone(vITS);
181 //     fSupgeom->ServicesCableSupport(vITS);
182
183 }
184 //______________________________________________________________________
185 void AliITSv11::CreateMaterials(){
186     // Create Standard ITS Materials
187     // Inputs:
188     //  none.
189     // Outputs:
190     //  none.
191     // Return:
192     // none.
193
194     
195     //
196     fSPDgeom->AliITSv11Geometry::CreateDefaultMaterials();
197     // Detector specific material definistions
198     fSPDgeom->CreateMaterials();
199     fSDDgeom->CreateMaterials();
200     fSSDgeom->CreateMaterials();
201     fSupgeom->CreateMaterials();
202 }
203 /*
204 //______________________________________________________________________
205 void AliITSv11::InitAliITSgeom(){
206   //
207   // Fill fITSgeom with the 3 sub-detector geometries
208   //
209
210   if (gGeoManager) gGeoManager->Export("geometry.root");
211
212     const Int_t knlayers = 6;
213     const Int_t kndeep = 3;
214     const AliITSDetector kidet[knlayers]={kSPD,kSPD,kSDD,kSDD,kSSD,kSSD};
215     const TString knames[knlayers] = {
216       "AliITSv11:spd missing",  // lay=1
217       "AliITSv11:spd missing",  // lay=2
218       "/ALIC_1/ITSV_1/ITSsddLayer3_1/ITSsddLadd_%d/ITSsddSensor_%d/ITSsddWafer_%d", // lay=3
219       "/ALIC_1/ITSV_1/ITSsddLayer4_1/ITSsddLadd_%d/ITSsddSensor_%d/ITSsddWafer_%d", // lay=4
220       "AliITSv11:ssd missing",  // lay=5
221       "AliITSv11:ssd missing"   // lay=6
222     };
223
224     const Int_t kitsGeomTreeCopys[knlayers][kndeep]= {{10, 2, 4},// lay=1
225                                                      {10, 4, 4}, // lay=2
226                                                      {14, 6, 1}, // lay=3
227                                                      {22, 8, 1}, // lay=4
228                                                      {34,22, 1}, // lay=5
229                                                      {38,25, 1}};// lay=6
230     Int_t       nlad[knlayers],ndet[knlayers];
231     Int_t       mod,lay,lad=0,det=0,i,j,k,cp0,cp1,cp2;
232     TString path,shapeName;
233     TGeoHMatrix materix;
234     Double_t trans[3]={3*0.0},rot[10]={9*0.0,1.0};
235     TArrayD shapePar;
236     TArrayF shapeParF;
237     Bool_t shapeDefined[3]={kFALSE,kFALSE,kFALSE};
238
239     AliDebug(1,"Reading Geometry transformation directly from Modler.");
240     mod = 0;
241     for(i=0;i<knlayers;i++){
242         k = 1;
243         for(j=0;j<kndeep;j++) if(kitsGeomTreeCopys[i][j]!=0)
244             k *= TMath::Abs(kitsGeomTreeCopys[i][j]);
245         mod += k;
246     } // end for i
247
248     SetITSgeom(0);
249     nlad[0]=20;nlad[1]=40;nlad[2]=14;nlad[3]=22;nlad[4]=34;nlad[5]=38;
250     ndet[0]= 4;ndet[1]= 4;ndet[2]= 6;ndet[3]= 8;ndet[4]=22;ndet[5]=25;
251     AliITSgeom* geom = new AliITSgeom(0,6,nlad,ndet,mod);
252     SetITSgeom(geom);
253     mod = 0;
254     for(lay=1;lay<=knlayers;lay++){
255
256         for(cp0=0; cp0<kitsGeomTreeCopys[lay-1][0]; cp0++){
257             for(cp1=0; cp1<kitsGeomTreeCopys[lay-1][1]; cp1++){
258                 for(cp2=1; cp2<=kitsGeomTreeCopys[lay-1][2]; cp2++){
259
260                     path.Form(knames[lay-1].Data(),
261                               cp0,cp1,cp2);
262                     switch (lay){
263                     case 1:{
264                         det = cp2;
265                         lad = cp1+2*(cp0-1);
266                     }break;
267                     case 2:{
268                         det = cp2;
269                         lad = cp1+4*(cp0-1);
270                     } break;
271                     case 3: case 4: case 5: case 6:{
272                         det = cp1;
273                         lad = cp0;
274                     } break;
275                     } // end switch
276                          //AliInfo(Form("path=%s lay=%d lad=%d det=%d",
277                          //             path.Data(),lay,lad,det));
278                     gMC->GetTransformation(path.Data(),materix);
279                     gMC->GetShape(path.Data(),shapeName,shapePar);
280                     shapeParF.Set(shapePar.GetSize());
281                     for(i=0;i<shapePar.GetSize();i++) shapeParF[i]=shapePar[i];
282                     geom->CreateMatrix(mod,lay,lad,det,kidet[lay-1],trans,rot);
283                     geom->SetTrans(mod,materix.GetTranslation());
284                     geom->SetRotMatrix(mod,materix.GetRotationMatrix());
285                     geom->GetGeomMatrix(mod)->SetPath(path.Data());
286                     switch (lay){
287                     case 1: case 2:
288                         if(!shapeDefined[kSPD]){
289                         geom->ReSetShape(kSPD,new AliITSgeomSPD425Short(
290                                 shapeParF.GetSize(),shapeParF.GetArray()));
291                         shapeDefined[kSPD] = kTRUE;
292                     }break;
293                     case 3: case 4:
294                         if(!shapeDefined[kSDD]){
295                         geom->ReSetShape(kSDD,new AliITSgeomSDD256(
296                                 shapeParF.GetSize(),shapeParF.GetArray()));
297                         shapeDefined[kSDD] = kTRUE;
298                     }break;
299                     case 5: case 6:
300                         if(!shapeDefined[kSSD]){
301                         geom->ReSetShape(kSSD,new AliITSgeomSSD75and275(
302                                 shapeParF.GetSize(),shapeParF.GetArray()));
303                         shapeDefined[kSSD] = kTRUE;
304                     }break;
305                     default:{
306                     }break;
307                     } // end switch
308                     mod++;
309                 } /// end for cp2
310             } // end for cp1
311         } // end for cp0
312     } // end for lay
313
314 //   fSDDgeom->ExportSensorGeometry(GetITSgeom(), +3, 0);  //SDD
315 }
316 */
317 //______________________________________________________________________
318 void AliITSv11::Init(){
319   //
320   //     Initialise the ITS after it has been created.
321   //
322
323   //AliInfo(Form("Minor version %d",fMinorVersion));
324     //
325     UpdateInternalGeometry();
326     AliITS::Init();
327
328     //
329 /*
330     if(GetITSgeom()!=0) SetITSgeom(0x0);
331     AliITSgeom* geom = new AliITSgeom();
332     SetITSgeom(geom);
333     AliITS::Init();
334 */    //
335 }
336
337
338 //______________________________________________________________________
339 void AliITSv11::SetDefaults(){
340   //
341   // Set response and segmentation models for SPD, SDD and SSD
342   //
343
344 //     if(!fDetTypeSim) fDetTypeSim = new AliITSDetTypeSim();
345 //     fDetTypeSim->SetITSgeom(GetITSgeom());
346     if(!fDetTypeSim) {
347       Warning("SetDefaults","Error fDetTypeSim not defined");
348       return;
349     }
350   
351     fDetTypeSim->ResetCalibrationArray();
352     fDetTypeSim->ResetSegmentation();
353     fDetTypeSim->SetDefaults();
354     
355     if(fgkNTYPES>3){
356         Warning("SetDefaults",
357                 "Only the four basic detector types are initialised!");
358     }// end if
359
360     
361     return;
362 }
363
364
365
366
367
368 //______________________________________________________________________
369 void AliITSv11::DrawModule() const{
370
371 }
372
373 // //______________________________________________________________________
374 // void AliITSv11::StepManager(){
375 //   //
376 //   //    Called for every step in the ITS, then calles the AliITShit class
377 //   // creator with the information to be recoreded about that hit.
378 //   //
379 //     Int_t         copy, id;
380 //     TLorentzVector position, momentum;
381 //     static TLorentzVector position0;
382 //     static Int_t stat0=0;
383
384 //     if(!(this->IsActive())){
385 //      return;
386 //     } // end if !Active volume.
387
388 //     if(!(gMC->TrackCharge())) return;
389
390 //     id=gMC->CurrentVolID(copy);
391
392 //     Bool_t sensvol = kFALSE;
393 //     for(Int_t kk=0;kk<6;kk++)if(id == fIdSens[kk])sensvol=kTRUE;
394 //     if(sensvol && (gMC->IsTrackExiting())){
395 //      copy = fTrackReferences->GetEntriesFast();
396 //      TClonesArray &lTR = *fTrackReferences;
397 //      // Fill TrackReference structure with this new TrackReference.
398 //      new(lTR[copy]) AliTrackReference(gAlice->GetMCApp()->GetCurrentTrackNumber());
399 //     } // if Outer ITS mother Volume
400
401
402 //     Int_t   copy1,copy2;  
403 //     Int_t   vol[5];
404 //     TClonesArray &lhits = *fHits;
405 //     //
406 //     // Track status
407 //     vol[3] = 0;
408 //     vol[4] = 0;
409 //     if(gMC->IsTrackInside())      vol[3] +=  1;
410 //     if(gMC->IsTrackEntering())    vol[3] +=  2;
411 //     if(gMC->IsTrackExiting())     vol[3] +=  4;
412 //     if(gMC->IsTrackOut())         vol[3] +=  8;
413 //     if(gMC->IsTrackDisappeared()) vol[3] += 16;
414 //     if(gMC->IsTrackStop())        vol[3] += 32;
415 //     if(gMC->IsTrackAlive())       vol[3] += 64;
416 //     //
417 //     // Fill hit structure.
418 //     if(!(gMC->TrackCharge())) return;
419 //     //
420 //     // Only entering charged tracks
421 //     if((id = gMC->CurrentVolID(copy)) == fIdSens[0]) {
422 //      vol[0] = 1;
423 //      id = gMC->CurrentVolOffID(2,copy);
424 //      //detector copy in the ladder = 1<->4  (ITS1 < I101 < I103 < I10A)
425 //      vol[1] = copy;
426 //      gMC->CurrentVolOffID(3,copy1);
427 //      //ladder copy in the module   = 1<->2  (I10A < I12A)
428 //      gMC->CurrentVolOffID(4,copy2);
429 //      //module copy in the layer    = 1<->10 (I12A < IT12)
430 //      vol[2] = copy1+(copy2-1)*2;//# of ladders in one module  = 2
431 //     } else if(id == fIdSens[1]){
432 //      vol[0] = 2;
433 //      id = gMC->CurrentVolOffID(2,copy);
434 //      //detector copy in the ladder = 1<->4  (ITS2 < I1D1 < I1D3 < I20A)
435 //      vol[1] = copy;
436 //      gMC->CurrentVolOffID(3,copy1);
437 //      //ladder copy in the module   = 1<->4  (I20A < I12A)
438 //      gMC->CurrentVolOffID(4,copy2);
439 //      //module copy in the layer    = 1<->10 (I12A < IT12)
440 //      vol[2] = copy1+(copy2-1)*4;//# of ladders in one module  = 4
441 //     } else if(id == fIdSens[2]){
442 //      vol[0] = 3;
443 //      id = gMC->CurrentVolOffID(1,copy);
444 //      //detector copy in the ladder = 1<->6  (ITS3 < I302 < I004)
445 //      vol[1] = copy;
446 //      id = gMC->CurrentVolOffID(2,copy);
447 //      //ladder copy in the layer    = 1<->14 (I004 < IT34)
448 //      vol[2] = copy;
449 //     } else if(id == fIdSens[3]){
450 //      vol[0] = 4;
451 //      id = gMC->CurrentVolOffID(1,copy);
452 //      //detector copy in the ladder = 1<->8  (ITS4 < I402 < I005)
453 //      vol[1] = copy;
454 //      id = gMC->CurrentVolOffID(2,copy);
455 //      //ladder copy in the layer    = 1<->22 (I005 < IT34))
456 //      vol[2] = copy;
457 //     }else if(id == fIdSens[4]){
458 //      vol[0] = 5;
459 //      id = gMC->CurrentVolOffID(1,copy);
460 //      //detector copy in the ladder = 1<->22  (ITS5 < I562 < I565)
461 //      vol[1] = copy;
462 //      id = gMC->CurrentVolOffID(2,copy);
463 //      //ladder copy in the layer    = 1<->34 (I565 < IT56)
464 //      vol[2] = copy;
465 //     }else if(id == fIdSens[5]){
466 //      vol[0] = 6;
467 //      id = gMC->CurrentVolOffID(1,copy);
468 //      //detector copy in the ladder = 1<->25  (ITS6 < I566 < I569)
469 //      vol[1] = copy;
470 //      id = gMC->CurrentVolOffID(2,copy);
471 //      //ladder copy in the layer = 1<->38 (I569 < IT56)
472 //      vol[2] = copy;
473 //     } else {
474 //      return; // not an ITS volume?
475 //     } // end if/else if (gMC->CurentVolID(copy) == fIdSens[i])
476 //     //
477 //     gMC->TrackPosition(position);
478 //     gMC->TrackMomentum(momentum);
479 //     vol[4] = stat0;
480 //     if(gMC->IsTrackEntering()){
481 //      position0 = position;
482 //      stat0 = vol[3];
483 //      return;
484 //     } // end if IsEntering
485 //     // Fill hit structure with this new hit.
486     
487 //     new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->GetMCApp()->GetCurrentTrackNumber(),vol,
488 //                                 gMC->Edep(),gMC->TrackTime(),position,
489 //                                 position0,momentum);
490
491 //     position0 = position;
492 //     stat0 = vol[3];
493
494 //     return;
495 // }
496
497
498 //______________________________________________________________________
499 void AliITSv11::StepManager(){
500   //
501   //    Called for every step in the ITS, then calles the AliITShit class
502   // creator with the information to be recoreded about that hit.
503   //
504     Int_t         copy, id;
505     TLorentzVector position, momentum;
506     static TLorentzVector position0;
507     static Int_t stat0=0;
508
509     if(!(this->IsActive())){
510         return;
511     } // end if !Active volume.
512
513     if(!(gMC->TrackCharge())) return;
514
515     id=gMC->CurrentVolID(copy);
516
517     Bool_t sensvol = kFALSE;
518     for(Int_t kk=0;kk<6;kk++)if(id == fIdSens[kk])sensvol=kTRUE;
519     if(sensvol && (gMC->IsTrackExiting())){
520         AddTrackReference(gAlice->GetMCApp()->GetCurrentTrackNumber(), AliTrackReference::kITS);
521     } // if Outer ITS mother Volume
522
523
524     Int_t   copy1,copy2;  
525     Int_t   vol[5];
526     TClonesArray &lhits = *fHits;
527     //
528     // Track status
529     vol[3] = 0;
530     vol[4] = 0;
531     if(gMC->IsTrackInside())      vol[3] +=  1;
532     if(gMC->IsTrackEntering())    vol[3] +=  2;
533     if(gMC->IsTrackExiting())     vol[3] +=  4;
534     if(gMC->IsTrackOut())         vol[3] +=  8;
535     if(gMC->IsTrackDisappeared()) vol[3] += 16;
536     if(gMC->IsTrackStop())        vol[3] += 32;
537     if(gMC->IsTrackAlive())       vol[3] += 64;
538     //
539     // Fill hit structure.
540     if(!(gMC->TrackCharge())) return;
541
542     // Only entering charged tracks
543     if((id = gMC->CurrentVolID(copy)) == fIdSens[0]) {
544         vol[0] = 1;
545         id = gMC->CurrentVolOffID(2,copy);
546         //detector copy in the ladder = 1<->4  (ITS1 < I101 < I103 < I10A)
547         vol[1] = copy;
548         gMC->CurrentVolOffID(3,copy1);
549         //ladder copy in the module   = 1<->2  (I10A < I12A)
550         gMC->CurrentVolOffID(4,copy2);
551         //module copy in the layer    = 1<->10 (I12A < IT12)
552         vol[2] = copy1+(copy2-1)*2;//# of ladders in one module  = 2
553
554     } else if(id == fIdSens[1]){
555         vol[0] = 2;
556         id = gMC->CurrentVolOffID(2,copy);
557         //detector copy in the ladder = 1<->4  (ITS2 < I1D1 < I1D3 < I20A)
558         vol[1] = copy;
559         gMC->CurrentVolOffID(3,copy1);
560         //ladder copy in the module   = 1<->4  (I20A < I12A)
561         gMC->CurrentVolOffID(4,copy2);
562         //module copy in the layer    = 1<->10 (I12A < IT12)
563         vol[2] = copy1+(copy2-1)*4;//# of ladders in one module  = 4
564
565     } else if(id == fIdSens[2]){
566         vol[0] = 3;
567         id = gMC->CurrentVolOffID(1,copy);
568         //detector copy in the ladder = 1<->6  (ITS3 < I302 < I004)
569         vol[1] = copy;
570         id = gMC->CurrentVolOffID(2,copy);
571         //ladder copy in the layer    = 1<->14 (I004 < IT34)
572         vol[2] = copy;
573
574     } else if(id == fIdSens[3]){
575         vol[0] = 4;
576         id = gMC->CurrentVolOffID(1,copy);
577         //detector copy in the ladder = 1<->8  (ITS4 < I402 < I005)
578         vol[1] = copy;
579         id = gMC->CurrentVolOffID(2,copy);
580         //ladder copy in the layer    = 1<->22 (I005 < IT34))
581         vol[2] = copy;
582
583     }else if(id == fIdSens[4]){
584         vol[0] = 5;
585         id = gMC->CurrentVolOffID(1,copy);
586         //detector copy in the ladder = 1<->22  (ITS5 < I562 < I565)
587         vol[1] = copy;
588         id = gMC->CurrentVolOffID(2,copy);
589         //ladder copy in the layer    = 1<->34 (I565 < IT56)
590         vol[2] = copy;
591
592     }else if(id == fIdSens[5]){
593         vol[0] = 6;
594         id = gMC->CurrentVolOffID(1,copy);
595         //detector copy in the ladder = 1<->25  (ITS6 < I566 < I569)
596         vol[1] = copy;
597         id = gMC->CurrentVolOffID(2,copy);
598         //ladder copy in the layer = 1<->38 (I569 < IT56)
599         vol[2] = copy;
600     } else {
601         return; // not an ITS volume?
602     } // end if/else if (gMC->CurentVolID(copy) == fIdSens[i])
603     //
604     gMC->TrackPosition(position);
605     gMC->TrackMomentum(momentum);
606     vol[4] = stat0;
607     if(gMC->IsTrackEntering()){
608         position0 = position;
609         stat0 = vol[3];
610         return;
611     } // end if IsEntering
612     // Fill hit structure with this new hit.
613     
614     new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->GetMCApp()->GetCurrentTrackNumber(),vol,
615                                    gMC->Edep(),gMC->TrackTime(),position,
616                                    position0,momentum);
617
618     position0 = position;
619     stat0 = vol[3];
620
621     return;
622 }
623