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