]> git.uio.no Git - u/mrichter/AliRoot.git/blame - ITS/AliITSvBeamTestITS04.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Preprocessor with new DA
[u/mrichter/AliRoot.git] / ITS / AliITSvBeamTestITS04.cxx
CommitLineData
5ba31760 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////////////////////////////////////////////////////////
0237c22c 6
7#include <TLorentzVector.h>
8
9#include <TGeoManager.h>
10#include <TGeoVolume.h>
11#include <TGeoPcon.h>
5ba31760 12#include "AliRun.h"
13#include "AliITSvBeamTestITS04.h"
5ba31760 14#include <TClonesArray.h>
15#include <TString.h>
5ba31760 16#include "AliITS.h"
5ba31760 17#include "AliMagF.h"
18#include "TVirtualMC.h"
19#include "AliMC.h"
0237c22c 20#include "AliTrackReference.h"
21#include "AliITSgeom.h"
22#include "AliITShit.h"
5ba31760 23
24const Int_t AliITSvBeamTestITS04::fgkNumberOfSPD = 4;
25const Int_t AliITSvBeamTestITS04::fgkNumberOfSDD = 2;
26const Int_t AliITSvBeamTestITS04::fgkNumberOfSSD = 4;
5ba31760 27// Dimension (thickness:Y (beam direction), width:X, length:Z)
28
29const char* AliITSvBeamTestITS04::fgSPDsensitiveVolName = "ITSspdSensitiv";
30//dimensions (preliminary values from Petra (in cms))
31const Double_t AliITSvBeamTestITS04::fgkSPDthickness = 0.02;
32const Double_t AliITSvBeamTestITS04::fgkSPDwidth = 1.4;
33const Double_t AliITSvBeamTestITS04::fgkSPDlength = 7.2;
34const Double_t AliITSvBeamTestITS04::fgkSPDthickSens = 0.02;
35const Double_t AliITSvBeamTestITS04::fgkSPDwidthSens = 1.2;
36const Double_t AliITSvBeamTestITS04::fgkSPDlengthSens = 7.0;
37//position
38const Double_t AliITSvBeamTestITS04::fgkSPD0y = 23.7;
39const Double_t AliITSvBeamTestITS04::fgkSPD1y = 33.7;
40
41//===
42const char* AliITSvBeamTestITS04::fgSDDsensitiveVolName = "ITSsddSensitiv";
43//dimensions (preliminary values from Ludovic (in cms))
44const Double_t AliITSvBeamTestITS04::fgkSDDthickness = 0.03;
45const Double_t AliITSvBeamTestITS04::fgkSDDwidth = 7.22;
46const Double_t AliITSvBeamTestITS04::fgkSDDlength = 8.76;
47const Double_t AliITSvBeamTestITS04::fgkSDDthickSens = 0.02998;
48const Double_t AliITSvBeamTestITS04::fgkSDDwidthSens = 7.017;
49const Double_t AliITSvBeamTestITS04::fgkSDDlengthSens = 7.497;
50//position
51const Double_t AliITSvBeamTestITS04::fgkSDD0y = 51.7;
52const Double_t AliITSvBeamTestITS04::fgkSDD1y = 57.2;
53
54//===
55const char* AliITSvBeamTestITS04::fgSSDsensitiveVolName = "ITSssdSensitiv";
56//dimensions (final values from Javier (in cms))
57const Double_t AliITSvBeamTestITS04::fgkSSDthickness = 0.03;
58const Double_t AliITSvBeamTestITS04::fgkSSDwidth = 7.7;
59const Double_t AliITSvBeamTestITS04::fgkSSDlength = 4.4;
60const Double_t AliITSvBeamTestITS04::fgkSSDthickSens = 0.03;
61const Double_t AliITSvBeamTestITS04::fgkSSDwidthSens = 7.5;
62const Double_t AliITSvBeamTestITS04::fgkSSDlengthSens = 4.2;
63//position
64const Double_t AliITSvBeamTestITS04::fgkSSD0y = 73.6;
65const Double_t AliITSvBeamTestITS04::fgkSSD1y = 80.6;
66
67//===============================================================
68
5ba31760 69
5ba31760 70
71ClassImp(AliITSvBeamTestITS04)
72
73//_____________________________________________________________
012f0f4c 74 AliITSvBeamTestITS04::AliITSvBeamTestITS04() :
75AliITS(), // Base class
76fITSmotherVolume(0), // Pointer to ITS mother volume.
77fNspd(fgkNumberOfSPD), //Number of SPD modules
78fNsdd(fgkNumberOfSDD), //Number of SDD modules
79fNssd(fgkNumberOfSSD), //Number of SSD modules
80fGeomDetOut(kFALSE), // Flag to write .det file out
81fGeomDetIn(kFALSE), // Flag to read geometry file (JC)
82fWrite(), //! file name to write .det file
83fRead(), // file name to read .det file (JC)
84fMajorVersion(kvITS04),// Major Version
85fMinorVersion(1), // Minor Version
86fIgm(kvITS04) //! Init geometry object
87{
5ba31760 88 //
89 // Constructor
90 //
012f0f4c 91
5ba31760 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
5ba31760 100 for(Int_t a=0;a<60;a++) fWrite[a] = '\0';
101}
5ba31760 102//_____________________________________________________________
012f0f4c 103AliITSvBeamTestITS04::AliITSvBeamTestITS04(const char* name,const char *title):
104AliITS(name,title), // Base class
105fITSmotherVolume(0), // Pointer to ITS mother volume.
106fNspd(fgkNumberOfSPD), //Number of SPD modules
107fNsdd(fgkNumberOfSDD), //Number of SDD modules
108fNssd(fgkNumberOfSSD), //Number of SSD modules
109fGeomDetOut(kFALSE), // Flag to write .det file out
110fGeomDetIn(kFALSE), // Flag to read geometry file (JC)
111fWrite(), //! file name to write .det file
112fRead(), // file name to read .det file (JC)
113fMajorVersion(kvITS04),// Major Version
114fMinorVersion(1), // Minor Version
115fIgm(kvITS04) //! Init geometry object
5ba31760 116{
117 //
118 // Constructor
119 //
012f0f4c 120
5ba31760 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;
5ba31760 128 for(Int_t a=0;a<60;a++) fWrite[a] = '\0';
129}
5ba31760 130//__________________________________________________________________
012f0f4c 131AliITSvBeamTestITS04::~AliITSvBeamTestITS04(){
5ba31760 132 //
133 // Destructor
134 //
135}
5ba31760 136//______________________________________________________________________
012f0f4c 137void AliITSvBeamTestITS04::CreateMaterials(){
5ba31760 138 // Media defined here should correspond to the one defined in galice.cuts
139 // This file is read in (AliMC*) fMCApp::Init() { ReadTransPar(); }
5ba31760 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//______________________________________________________________________
012f0f4c 179void 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$";
5ba31760 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
012f0f4c 196 TGeoMedium *air = geoManager->GetMedium("ITSair");
197 fITSmotherVolume = new TGeoVolume("ITSV",sITS,air);
0237c22c 198 const Int_t kLength=100;
199 Char_t vstrng[kLength];
200 if(fIgm.WriteVersionString(vstrng,kLength,(AliITSVersion_t)IsVersion(),
012f0f4c 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
5ba31760 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//______________________________________________________________________
231void AliITSvBeamTestITS04::Init()
232{
233 // Initialize the ITS after it has been created.
012f0f4c 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();
5ba31760 245 AliITS::Init();
012f0f4c 246 if(fGeomDetOut) GetITSgeom()->WriteNewFile(fWrite);
5ba31760 247
012f0f4c 248 //
5ba31760 249}
012f0f4c 250/*
5ba31760 251//______________________________________________________________________
252void 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;
7d62fb64 266 if (GetITSgeom()) SetITSgeom(0x0);
267 AliITSgeom* geom = new AliITSgeom(0,knlayers,nlad,ndet,nModTot);
268 SetITSgeom(geom);
012f0f4c 269 // *** Set default shapes
5ba31760 270 const Float_t kDxyzSPD[] = {fgkSPDwidthSens/2, fgkSPDthickSens/2,fgkSPDlengthSens/2};
7d62fb64 271 if(!(GetITSgeom()->IsShapeDefined(kSPD)))
272 GetITSgeom()->ReSetShape(kSPD,new AliITSgeomSPD425Short(3,(Float_t *)kDxyzSPD));
5ba31760 273
274 const Float_t kDxyzSDD[] = {fgkSDDwidthSens/2., fgkSDDthickSens/2.,fgkSDDlengthSens/2.};
7d62fb64 275 if(!(GetITSgeom()->IsShapeDefined(kSDD)))
276 GetITSgeom()->ReSetShape(kSDD, new AliITSgeomSDD256(3,(Float_t *)kDxyzSDD));
5ba31760 277
278 const Float_t kDxyzSSD[] = {fgkSSDlengthSens/2, fgkSSDthickSens/2,fgkSSDwidthSens/2};
7d62fb64 279 if(!(GetITSgeom()->IsShapeDefined(kSSD)))
280 GetITSgeom()->ReSetShape(kSSD,new AliITSgeomSSD75and275(3,(Float_t *)kDxyzSSD));
5ba31760 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;
023ae34b 305 GetITSgeom()->CreateMatrix(startMod,iLay,iLad,iDet,kSPD,trans,rot);
5ba31760 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;
023ae34b 324 GetITSgeom()->CreateMatrix(startMod,iLay,iLad,iDet,kSDD,trans,rot);
5ba31760 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;
023ae34b 345 GetITSgeom()->CreateMatrix(startMod,iLay,iLad,iDet,kSSD,trans,rot);
5ba31760 346 startMod++;
347 };
348 };
349
350 return;
351}
5ba31760 352//______________________________________________________________________
353void AliITSvBeamTestITS04::SetDefaults()
354{
355 // (from AliITSv11) mln
356
357 const Float_t kconv = 1.0e+04; // convert cm to microns
358
7d62fb64 359 if(!fDetTypeSim) fDetTypeSim = new AliITSDetTypeSim();
360 fDetTypeSim->SetITSgeom(GetITSgeom());
fcf95fc7 361 fDetTypeSim->ResetCalibrationArray();
7d62fb64 362 fDetTypeSim->ResetSegmentation();
363
5ba31760 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)
7d62fb64 372 if(GetITSgeom()!=0) SetITSgeom(0x0);
373 AliITSgeom* geom = new AliITSgeom();
374 SetITSgeom(geom);
375 if(fGeomDetIn) GetITSgeom()->ReadNewFile(fRead);
5ba31760 376 if(!fGeomDetIn) this->InitAliITSgeom();
7d62fb64 377 if(fGeomDetOut) GetITSgeom()->WriteNewFile(fWrite);
5ba31760 378
379
380 // SPD
7d62fb64 381
382 s0 = (AliITSgeomSPD*) GetITSgeom()->GetShape(kSPD);// Get shape info.
5ba31760 383 if (s0) {
fcf95fc7 384 AliITSCalibration *resp0=new AliITSCalibrationSPD();
385 SetCalibrationModel(kSPD,resp0);
7d62fb64 386
023ae34b 387 AliITSsegmentationSPD *seg0=new AliITSsegmentationSPD();
5ba31760 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
fcf95fc7 403 const char *kData0=(fDetTypeSim->GetCalibrationModel(kSPD))->DataType();
5ba31760 404 if (strstr(kData0,"real"))
7d62fb64 405 fDetTypeSim->SetDigitClassName(kSPD,"AliITSdigit");
406 else fDetTypeSim->SetDigitClassName(kSPD,"AliITSdigitSPD");
407 }
5ba31760 408
409 // SDD
7d62fb64 410
411 s1 = (AliITSgeomSDD*) GetITSgeom()->GetShape(kSDD);// Get shape info.
5ba31760 412 if (s1) {
fcf95fc7 413 AliITSCalibrationSDD *resp1=new AliITSCalibrationSDD("simulated");
414 SetCalibrationModel(kSDD,resp1);
023ae34b 415 AliITSsegmentationSDD *seg1=new AliITSsegmentationSDD();
3a7c3e6d 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.
4952f440 419 seg1->SetDriftSpeed(AliITSresponseSDD::DefaultDriftSpeed());
3a7c3e6d 420 seg1->SetNPads(256,256);// Use AliITSgeomSDD for now
421 SetSegmentationModel(kSDD,seg1);
fcf95fc7 422 const char *kData1=(fDetTypeSim->GetCalibrationModel(kSDD))->DataType();
423 const char *kopt=resp1->GetZeroSuppOption();
3a7c3e6d 424 if((!strstr(kopt,"2D")) && (!strstr(kopt,"1D")) || strstr(kData1,"real") ){
425 fDetTypeSim->SetDigitClassName(kSDD,"AliITSdigit");
7d62fb64 426 } else fDetTypeSim->SetDigitClassName(kSDD,"AliITSdigitSDD");
427 }
5ba31760 428
429 // SSD
7d62fb64 430
431 s2 = (AliITSgeomSSD*) GetITSgeom()->GetShape(kSSD);// Get shape info. Do it this way for now.
5ba31760 432 if (s2) {
fcf95fc7 433 AliITSCalibration *resp2=new AliITSCalibrationSSD("simulated");
434 SetCalibrationModel(kSSD,resp2);
7d62fb64 435
023ae34b 436 AliITSsegmentationSSD *seg2=new AliITSsegmentationSSD();
7d62fb64 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);
fcf95fc7 446 const char *kData2=(fDetTypeSim->GetCalibrationModel(kSSD))->DataType();
7d62fb64 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!");}
5ba31760 452 return;
e93245aa 453}
012f0f4c 454*/
5ba31760 455//______________________________________________________________________
456void 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);
e93245aa 485}
5ba31760 486
487
488//______________________________________________________________________
489void 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);
e93245aa 513}
5ba31760 514
515
516//______________________________________________________________________
517void 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);
e93245aa 549}
5ba31760 550
551//______________________________________________________________________
552void 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
012f0f4c 558 Int_t cpy0,mod,status,id,kk;
5ba31760 559 TLorentzVector position, momentum;
012f0f4c 560 static AliITShit hit;// Saves on calls to construtors
5ba31760 561
012f0f4c 562 if(!(this->IsActive())) return;
5ba31760 563 if(!(gMC->TrackCharge())) return;
012f0f4c 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;
5ba31760 577
012f0f4c 578 id=gMC->CurrentVolID(cpy0);
5ba31760 579
580 Bool_t sensvol = kFALSE;
012f0f4c 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);
5ba31760 585 //
5ba31760 586 // Fill hit structure.
012f0f4c 587 //
588 hit.SetModule(mod);
589 hit.SetTrack(gAlice->GetMCApp()->GetCurrentTrackNumber());
5ba31760 590 gMC->TrackPosition(position);
591 gMC->TrackMomentum(momentum);
012f0f4c 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());
5ba31760 598 if(gMC->IsTrackEntering()){
012f0f4c 599 hit.SetStartPosition(position);
600 hit.SetStartTime(gMC->TrackTime());
601 hit.SetStartStatus(status);
602 return; // don't save entering hit.
5ba31760 603 } // end if IsEntering
604 // Fill hit structure with this new hit.
012f0f4c 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);
5ba31760 611 return;
e93245aa 612}
012f0f4c 613/*
5ba31760 614//______________________________________________________________________
615Int_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;
e93245aa 646}
012f0f4c 647*/
5ba31760 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 }