]> git.uio.no Git - u/mrichter/AliRoot.git/blame - TRD/AliTRDgeometry.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Move to numbers of atoms for gas mixture
[u/mrichter/AliRoot.git] / TRD / AliTRDgeometry.cxx
CommitLineData
f7336fa3 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
afc51ac2 16/* $Id$ */
f7336fa3 17
18///////////////////////////////////////////////////////////////////////////////
19// //
20// TRD geometry class //
21// //
22///////////////////////////////////////////////////////////////////////////////
23
793ff80c 24
bdbb05bb 25#include <TError.h>
b4a9cd27 26#include <TGeoManager.h>
27#include <TGeoPhysicalNode.h>
28#include <TGeoMatrix.h>
29
bdbb05bb 30
31#include "AliRunLoader.h"
f7336fa3 32#include "AliTRDgeometry.h"
a5cadd36 33#include "AliTRDpadPlane.h"
f7336fa3 34
b4a9cd27 35#include "AliAlignObj.h"
36#include "AliAlignObjAngles.h"
37
ecb36af7 38#include "AliRun.h"
39#include "AliTRD.h"
3551db50 40#include "AliTRDcalibDB.h"
41#include "AliTRDCommonParam.h"
ecb36af7 42
f7336fa3 43ClassImp(AliTRDgeometry)
44
793ff80c 45//_____________________________________________________________________________
46
47 //
48 // The geometry constants
49 //
50 const Int_t AliTRDgeometry::fgkNsect = kNsect;
51 const Int_t AliTRDgeometry::fgkNplan = kNplan;
52 const Int_t AliTRDgeometry::fgkNcham = kNcham;
53 const Int_t AliTRDgeometry::fgkNdet = kNdet;
54
55 //
56 // Dimensions of the detector
57 //
0a770ac9 58
59 // Inner and outer radius of the mother volumes
793ff80c 60 const Float_t AliTRDgeometry::fgkRmin = 294.0;
61 const Float_t AliTRDgeometry::fgkRmax = 368.0;
62
0a770ac9 63 // Upper and lower length of the mother volumes
793ff80c 64 const Float_t AliTRDgeometry::fgkZmax1 = 378.35;
65 const Float_t AliTRDgeometry::fgkZmax2 = 302.0;
66
0a770ac9 67 // Parameter of the BTR mother volumes
a797f961 68 const Float_t AliTRDgeometry::fgkSheight = 77.9;
69 const Float_t AliTRDgeometry::fgkSwidth1 = 94.881;
70 const Float_t AliTRDgeometry::fgkSwidth2 = 122.353;
793ff80c 71 const Float_t AliTRDgeometry::fgkSlenTR1 = 751.0;
72 const Float_t AliTRDgeometry::fgkSlenTR2 = 313.5;
73 const Float_t AliTRDgeometry::fgkSlenTR3 = 159.5;
74
73ae7b59 75 // The super module side plates
287c5d50 76 const Float_t AliTRDgeometry::fgkSMpltT = 0.2;
a797f961 77 //const Float_t AliTRDgeometry::fgkSMgapT = 0.5;
73ae7b59 78
0a770ac9 79 // Height of different chamber parts
80 // Radiator
81 const Float_t AliTRDgeometry::fgkCraH = 4.8;
82 // Drift region
83 const Float_t AliTRDgeometry::fgkCdrH = 3.0;
84 // Amplification region
85 const Float_t AliTRDgeometry::fgkCamH = 0.7;
86 // Readout
73ae7b59 87 const Float_t AliTRDgeometry::fgkCroH = 2.316;
0a770ac9 88 // Total height
89 const Float_t AliTRDgeometry::fgkCH = AliTRDgeometry::fgkCraH
90 + AliTRDgeometry::fgkCdrH
91 + AliTRDgeometry::fgkCamH
92 + AliTRDgeometry::fgkCroH;
93
94 // Vertical spacing of the chambers
73ae7b59 95 const Float_t AliTRDgeometry::fgkVspace = 1.784;
0a770ac9 96
97 // Horizontal spacing of the chambers
98 const Float_t AliTRDgeometry::fgkHspace = 2.0;
99
a797f961 100 // Radial distance of the first ROC to the outer plates of the SM
101 const Float_t AliTRDgeometry::fgkVrocsm = 1.2;
102
0a770ac9 103 // Thicknesses of different parts of the chamber frame
104 // Lower aluminum frame
105 const Float_t AliTRDgeometry::fgkCalT = 0.3;
106 // Lower G10 frame sides
107 const Float_t AliTRDgeometry::fgkCclsT = 0.3;
108 // Lower G10 frame front
109 const Float_t AliTRDgeometry::fgkCclfT = 1.0;
110 // Upper G10 frame
111 const Float_t AliTRDgeometry::fgkCcuT = 0.9;
112 // Upper Al frame
113 const Float_t AliTRDgeometry::fgkCauT = 1.5;
114
115 // Additional width of the readout chamber frames
116 const Float_t AliTRDgeometry::fgkCroW = 0.9;
117
118 // Difference of outer chamber width and pad plane width
73ae7b59 119 //const Float_t AliTRDgeometry::fgkCpadW = 1.0;
120 const Float_t AliTRDgeometry::fgkCpadW = 0.0;
de6df1b1 121 const Float_t AliTRDgeometry::fgkRpadW = 1.0;
793ff80c 122
123 //
124 // Thickness of the the material layers
125 //
db30bf0f 126 const Float_t AliTRDgeometry::fgkRaThick = 0.3646;
793ff80c 127 const Float_t AliTRDgeometry::fgkMyThick = 0.005;
0a770ac9 128 const Float_t AliTRDgeometry::fgkDrThick = AliTRDgeometry::fgkCdrH;
129 const Float_t AliTRDgeometry::fgkAmThick = AliTRDgeometry::fgkCamH;
130 const Float_t AliTRDgeometry::fgkXeThick = AliTRDgeometry::fgkDrThick
131 + AliTRDgeometry::fgkAmThick;
a797f961 132 const Float_t AliTRDgeometry::fgkCuThick = 0.0072;
793ff80c 133 const Float_t AliTRDgeometry::fgkSuThick = 0.06;
134 const Float_t AliTRDgeometry::fgkFeThick = 0.0044;
135 const Float_t AliTRDgeometry::fgkCoThick = 0.02;
db30bf0f 136 const Float_t AliTRDgeometry::fgkWaThick = 0.02;
a797f961 137 const Float_t AliTRDgeometry::fgkRcThick = 0.0058;
138 const Float_t AliTRDgeometry::fgkRpThick = 0.0632;
793ff80c 139
140 //
141 // Position of the material layers
142 //
0a770ac9 143 const Float_t AliTRDgeometry::fgkRaZpos = -1.50;
144 const Float_t AliTRDgeometry::fgkMyZpos = 0.895;
145 const Float_t AliTRDgeometry::fgkDrZpos = 2.4;
146 const Float_t AliTRDgeometry::fgkAmZpos = 0.0;
147 const Float_t AliTRDgeometry::fgkCuZpos = -0.9995;
793ff80c 148 const Float_t AliTRDgeometry::fgkSuZpos = 0.0000;
0a770ac9 149 const Float_t AliTRDgeometry::fgkFeZpos = 0.0322;
150 const Float_t AliTRDgeometry::fgkCoZpos = 0.97;
151 const Float_t AliTRDgeometry::fgkWaZpos = 0.99;
a797f961 152 const Float_t AliTRDgeometry::fgkRcZpos = 1.04;
153 const Float_t AliTRDgeometry::fgkRpZpos = 1.0;
3551db50 154
155 const Double_t AliTRDgeometry::fgkTime0Base = Rmin() + CraHght() + CdrHght() + CamHght()/2.;
156 const Float_t AliTRDgeometry::fgkTime0[6] = { fgkTime0Base + 0 * (Cheight() + Cspace()),
157 fgkTime0Base + 1 * (Cheight() + Cspace()),
158 fgkTime0Base + 2 * (Cheight() + Cspace()),
159 fgkTime0Base + 3 * (Cheight() + Cspace()),
160 fgkTime0Base + 4 * (Cheight() + Cspace()),
161 fgkTime0Base + 5 * (Cheight() + Cspace()) };
793ff80c 162
f7336fa3 163//_____________________________________________________________________________
164AliTRDgeometry::AliTRDgeometry():AliGeometry()
165{
166 //
167 // AliTRDgeometry default constructor
168 //
bd0f8685 169
170 fMatrixArray = 0;
171 fMatrixCorrectionArray = 0;
172
f7336fa3 173 Init();
bd0f8685 174
f7336fa3 175}
176
177//_____________________________________________________________________________
178AliTRDgeometry::~AliTRDgeometry()
179{
8230f242 180 //
181 // AliTRDgeometry destructor
182 //
bd0f8685 183
b4a9cd27 184 delete fMatrixArray;
185 delete fMatrixCorrectionArray;
bd0f8685 186
f7336fa3 187}
188
189//_____________________________________________________________________________
190void AliTRDgeometry::Init()
191{
192 //
193 // Initializes the geometry parameter
194 //
f7336fa3 195 // The maximum number of pads
196 // and the position of pad 0,0,0
197 //
198 // chambers seen from the top:
199 // +----------------------------+
200 // | |
793ff80c 201 // | | ^
202 // | | rphi|
203 // | | |
204 // |0 | |
205 // +----------------------------+ +------>
f7336fa3 206 // z
793ff80c 207 // chambers seen from the side: ^
208 // +----------------------------+ drift|
209 // |0 | |
210 // | | |
211 // +----------------------------+ +------>
f7336fa3 212 // z
213 //
a2b90f83 214 // IMPORTANT: time bin 0 is now the first one in the drift region
215 // closest to the readout !!!
793ff80c 216 //
f7336fa3 217
0a770ac9 218 Int_t icham;
219 Int_t iplan;
220 Int_t isect;
221
222 // The outer width of the chambers
287c5d50 223 fCwidth[0] = 90.4;
e0d47c25 224 fCwidth[1] = 94.8;
225 fCwidth[2] = 99.3;
226 fCwidth[3] = 103.7;
227 fCwidth[4] = 108.1;
228 fCwidth[5] = 112.6;
0a770ac9 229
230 // The outer lengths of the chambers
73ae7b59 231 // Includes the spacings between the chambers!
8737e16f 232 Float_t length[kNplan][kNcham] = { { 124.0, 124.0, 110.0, 124.0, 124.0 }
e0d47c25 233 , { 124.0, 124.0, 110.0, 124.0, 124.0 }
8737e16f 234 , { 131.0, 131.0, 110.0, 131.0, 131.0 }
235 , { 138.0, 138.0, 110.0, 138.0, 138.0 }
236 , { 145.0, 145.0, 110.0, 145.0, 145.0 }
e0d47c25 237 , { 147.0, 147.0, 110.0, 147.0, 147.0 } };
0a770ac9 238
239 for (icham = 0; icham < kNcham; icham++) {
240 for (iplan = 0; iplan < kNplan; iplan++) {
241 fClength[iplan][icham] = length[iplan][icham];
0a770ac9 242 }
243 }
244
793ff80c 245 // The rotation matrix elements
246 Float_t phi = 0;
247 for (isect = 0; isect < fgkNsect; isect++) {
5443e65e 248 phi = -2.0 * TMath::Pi() / (Float_t) fgkNsect * ((Float_t) isect + 0.5);
793ff80c 249 fRotA11[isect] = TMath::Cos(phi);
250 fRotA12[isect] = TMath::Sin(phi);
251 fRotA21[isect] = TMath::Sin(phi);
252 fRotA22[isect] = TMath::Cos(phi);
253 phi = -1.0 * phi;
254 fRotB11[isect] = TMath::Cos(phi);
255 fRotB12[isect] = TMath::Sin(phi);
256 fRotB21[isect] = TMath::Sin(phi);
257 fRotB22[isect] = TMath::Cos(phi);
258 }
bd0f8685 259
260 for (isect = 0; isect < fgkNsect; isect++) {
261 SetSMstatus(isect,1);
262 }
793ff80c 263
264}
265
f7336fa3 266//_____________________________________________________________________________
bd0f8685 267void AliTRDgeometry::CreateGeometry(Int_t *idtmed)
268{
269 //
270 // Create the TRD geometry without hole
271 //
272 //
273 // Names of the TRD volumina (xx = detector number):
274 //
275 // Volume (Air) wrapping the readout chamber components
276 // UTxx includes: UAxx, UDxx, UFxx, UUxx
277 // Obs:
278 // UUxx the services volume has been reduced by 7.42 mm
279 // in order to allow shifts in radial direction
280 //
281 // Lower part of the readout chambers (gas volume + radiator)
282 //
283 // UAxx Aluminum frames (Al)
284 // UBxx G10 frames (C)
285 // UCxx Inner volumes (Air)
286 //
287 // Upper part of the readout chambers (readout plane + fee)
288 //
289 // UDxx G10 frames (C)
290 // UExx Inner volumes of the G10 (Air)
291 // UFxx Aluminum frames (Al)
292 // UGxx Inner volumes of the Al (Air)
293 //
294 // Inner material layers
295 //
296 // UHxx Radiator (Rohacell)
297 // UIxx Entrance window (Mylar)
298 // UJxx Drift volume (Xe/CO2)
299 // UKxx Amplification volume (Xe/CO2)
300 // ULxx Pad plane (Cu)
301 // UMxx Support structure (Rohacell)
a797f961 302 // UNxx ROB base material (C)
303 // UOxx ROB copper (Cu)
bd0f8685 304 //
305
306 const Int_t kNparTrd = 4;
307 const Int_t kNparCha = 3;
308
309 Float_t xpos, ypos, zpos;
310
311 Float_t parTrd[kNparTrd];
312 Float_t parCha[kNparCha];
313
314 Char_t cTagV[6];
315 Char_t cTagM[5];
316
317 // The TRD mother volume for one sector (Air), full length in z-direction
318 // Provides material for side plates of super module
319 parTrd[0] = fgkSwidth1/2.;
320 parTrd[1] = fgkSwidth2/2.;
321 parTrd[2] = fgkSlenTR1/2.;
322 parTrd[3] = fgkSheight/2.;
323 gMC->Gsvolu("UTR1","TRD1",idtmed[1302-1],parTrd,kNparTrd);
324
325 //
a797f961 326 // The outer aluminum plates of the super module (Al)
327 parTrd[0] = fgkSwidth1/2.;
328 parTrd[1] = fgkSwidth2/2.;
bd0f8685 329 parTrd[2] = fgkSlenTR1/2.;
330 parTrd[3] = fgkSheight/2.;
331 gMC->Gsvolu("UTS1","TRD1",idtmed[1301-1],parTrd,kNparTrd);
332
333 // The inner part of the TRD mother volume for one sector (Air),
334 // full length in z-direction
a797f961 335 parTrd[0] = fgkSwidth1/2. - fgkSMpltT;
336 parTrd[1] = fgkSwidth2/2. - fgkSMpltT;
bd0f8685 337 parTrd[2] = fgkSlenTR1/2.;
a797f961 338 parTrd[3] = fgkSheight/2. - fgkSMpltT;
bd0f8685 339 gMC->Gsvolu("UTI1","TRD1",idtmed[1302-1],parTrd,kNparTrd);
340
341 for (Int_t icham = 0; icham < kNcham; icham++) {
342 for (Int_t iplan = 0; iplan < kNplan; iplan++) {
343
344 Int_t iDet = GetDetectorSec(iplan,icham);
345
346 // The lower part of the readout chambers (gas volume + radiator)
347 // The aluminum frames
348 sprintf(cTagV,"UA%02d",iDet);
349 parCha[0] = fCwidth[iplan]/2.;
350 parCha[1] = fClength[iplan][icham]/2. - fgkHspace/2.;
351 parCha[2] = fgkCraH/2. + fgkCdrH/2.;
352 fChamberUAboxd[iDet][0] = parCha[0];
353 fChamberUAboxd[iDet][1] = parCha[1];
354 fChamberUAboxd[iDet][2] = parCha[2];
355 gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parCha,kNparCha);
356 // The G10 frames
357 sprintf(cTagV,"UB%02d",iDet);
358 parCha[0] = fCwidth[iplan]/2. - fgkCalT;
359 parCha[1] = -1.;
360 parCha[2] = -1.;
361 gMC->Gsvolu(cTagV,"BOX ",idtmed[1307-1],parCha,kNparCha);
362 // The inner part (air)
363 sprintf(cTagV,"UC%02d",iDet);
364 parCha[0] = fCwidth[iplan]/2. - fgkCalT - fgkCclsT;
365 parCha[1] = fClength[iplan][icham]/2. - fgkHspace/2.- fgkCclfT;
366 parCha[2] = -1.;
367 gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
368
369 // The upper part of the readout chambers (readout plane)
370 // The G10 frames
371 sprintf(cTagV,"UD%02d",iDet);
372 parCha[0] = fCwidth[iplan]/2. + fgkCroW;
373 parCha[1] = fClength[iplan][icham]/2. - fgkHspace/2.;
374 parCha[2] = fgkCamH/2.;
375 fChamberUDboxd[iDet][0] = parCha[0];
376 fChamberUDboxd[iDet][1] = parCha[1];
377 fChamberUDboxd[iDet][2] = parCha[2];
378 gMC->Gsvolu(cTagV,"BOX ",idtmed[1307-1],parCha,kNparCha);
379 // The inner part of the G10 frame (air)
380 sprintf(cTagV,"UE%02d",iDet);
381 parCha[0] = fCwidth[iplan]/2. + fgkCroW - fgkCcuT;
382 parCha[1] = fClength[iplan][icham]/2. - fgkHspace/2.- fgkCcuT;
383 parCha[2] = -1.;
384 gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
385 // The aluminum frames
386 sprintf(cTagV,"UF%02d",iDet);
387 parCha[0] = fCwidth[iplan]/2. + fgkCroW;
388 parCha[1] = fClength[iplan][icham]/2. - fgkHspace/2.;
389 parCha[2] = fgkCroH/2.;
390 fChamberUFboxd[iDet][0] = parCha[0];
391 fChamberUFboxd[iDet][1] = parCha[1];
392 fChamberUFboxd[iDet][2] = parCha[2];
393 gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parCha,kNparCha);
394 // The inner part of the aluminum frames
395 sprintf(cTagV,"UG%02d",iDet);
396 parCha[0] = fCwidth[iplan]/2. + fgkCroW - fgkCauT;
397 parCha[1] = fClength[iplan][icham]/2. - fgkHspace/2.- fgkCauT;
398 parCha[2] = -1.;
399 gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
400
401 // The material layers inside the chambers
402 parCha[0] = -1.;
403 parCha[1] = -1.;
404 // Rohacell layer (radiator)
405 parCha[2] = fgkRaThick/2;
406 sprintf(cTagV,"UH%02d",iDet);
407 gMC->Gsvolu(cTagV,"BOX ",idtmed[1315-1],parCha,kNparCha);
408 // Mylar layer (entrance window + HV cathode)
409 parCha[2] = fgkMyThick/2;
410 sprintf(cTagV,"UI%02d",iDet);
411 gMC->Gsvolu(cTagV,"BOX ",idtmed[1308-1],parCha,kNparCha);
412 // Xe/Isobutane layer (drift volume)
413 parCha[2] = fgkDrThick/2.;
414 sprintf(cTagV,"UJ%02d",iDet);
415 gMC->Gsvolu(cTagV,"BOX ",idtmed[1309-1],parCha,kNparCha);
416 // Xe/Isobutane layer (amplification volume)
417 parCha[2] = fgkAmThick/2.;
418 sprintf(cTagV,"UK%02d",iDet);
419 gMC->Gsvolu(cTagV,"BOX ",idtmed[1309-1],parCha,kNparCha);
420 // Cu layer (pad plane)
421 parCha[2] = fgkCuThick/2;
422 sprintf(cTagV,"UL%02d",iDet);
423 gMC->Gsvolu(cTagV,"BOX ",idtmed[1305-1],parCha,kNparCha);
424 // G10 layer (support structure / honeycomb)
425 parCha[2] = fgkSuThick/2;
426 sprintf(cTagV,"UM%02d",iDet);
427 gMC->Gsvolu(cTagV,"BOX ",idtmed[1313-1],parCha,kNparCha);
a797f961 428 // G10 layer (readout board)
429 parCha[2] = fgkRpThick/2;
430 sprintf(cTagV,"UN%02d",iDet);
431 gMC->Gsvolu(cTagV,"BOX ",idtmed[1313-1],parCha,kNparCha);
432 // Cu layer (readout board)
433 parCha[2] = fgkRcThick/2;
434 sprintf(cTagV,"UO%02d",iDet);
435 gMC->Gsvolu(cTagV,"BOX ",idtmed[1306-1],parCha,kNparCha);
bd0f8685 436
437 // Position the layers in the chambers
438 xpos = 0;
439 ypos = 0;
440 // Lower part
441 // Rohacell layer (radiator)
442 zpos = fgkRaZpos;
443 sprintf(cTagV,"UH%02d",iDet);
444 sprintf(cTagM,"UC%02d",iDet);
445 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
446 // Mylar layer (entrance window + HV cathode)
447 zpos = fgkMyZpos;
448 sprintf(cTagV,"UI%02d",iDet);
449 sprintf(cTagM,"UC%02d",iDet);
450 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
451 // Xe/Isobutane layer (drift volume)
452 zpos = fgkDrZpos;
453 sprintf(cTagV,"UJ%02d",iDet);
454 sprintf(cTagM,"UC%02d",iDet);
455 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
456 // Upper part
457 // Xe/Isobutane layer (amplification volume)
458 zpos = fgkAmZpos;
459 sprintf(cTagV,"UK%02d",iDet);
460 sprintf(cTagM,"UE%02d",iDet);
461 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
462 // Readout part
463 // Cu layer (pad plane)
464 zpos = fgkCuZpos;
465 sprintf(cTagV,"UL%02d",iDet);
466 sprintf(cTagM,"UG%02d",iDet);
467 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
468 // G10 layer (support structure)
469 zpos = fgkSuZpos;
470 sprintf(cTagV,"UM%02d",iDet);
471 sprintf(cTagM,"UG%02d",iDet);
472 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
a797f961 473 // G10 layer (readout board)
474 zpos = fgkRpZpos;
475 sprintf(cTagV,"UN%02d",iDet);
476 sprintf(cTagM,"UG%02d",iDet);
477 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
478 // Cu layer (readout board)
479 zpos = fgkRcZpos;
480 sprintf(cTagV,"UO%02d",iDet);
481 sprintf(cTagM,"UG%02d",iDet);
482 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
bd0f8685 483
484 // Position the inner volumes of the chambers in the frames
485 xpos = 0.0;
486 ypos = 0.0;
487 zpos = 0.0;
488 // The inside of the lower G10 frame
489 sprintf(cTagV,"UC%02d",iDet);
490 sprintf(cTagM,"UB%02d",iDet);
491 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
492 // The lower G10 frame inside the aluminum frame
493 sprintf(cTagV,"UB%02d",iDet);
494 sprintf(cTagM,"UA%02d",iDet);
495 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
496 // The inside of the upper G10 frame
497 sprintf(cTagV,"UE%02d",iDet);
498 sprintf(cTagM,"UD%02d",iDet);
499 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
500 // The inside of the upper aluminum frame
501 sprintf(cTagV,"UG%02d",iDet);
502 sprintf(cTagM,"UF%02d",iDet);
503 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
504
505 // Position the frames of the chambers in the TRD mother volume
506 xpos = 0.;
507 ypos = - fClength[iplan][0] - fClength[iplan][1] - fClength[iplan][2]/2.;
508 for (Int_t ic = 0; ic < icham; ic++) {
509 ypos += fClength[iplan][ic];
510 }
511 ypos += fClength[iplan][icham]/2.;
a797f961 512 zpos = fgkVrocsm + fgkCraH/2. + fgkCdrH/2. - fgkSheight/2.
513 + iplan * (fgkCH + fgkVspace);
bd0f8685 514 // The lower aluminum frame, radiator + drift region
515 sprintf(cTagV,"UA%02d",iDet);
516 fChamberUAorig[iDet][0] = xpos;
517 fChamberUAorig[iDet][1] = ypos;
518 fChamberUAorig[iDet][2] = zpos;
519 // The upper G10 frame, amplification region
520 sprintf(cTagV,"UD%02d",iDet);
521 zpos += fgkCamH/2. + fgkCraH/2. + fgkCdrH/2.;
522 fChamberUDorig[iDet][0] = xpos;
523 fChamberUDorig[iDet][1] = ypos;
524 fChamberUDorig[iDet][2] = zpos;
525 // The upper aluminum frame
526 sprintf(cTagV,"UF%02d",iDet);
527 zpos += fgkCroH/2. + fgkCamH/2.;
528 fChamberUForig[iDet][0] = xpos;
529 fChamberUForig[iDet][1] = ypos;
530 fChamberUForig[iDet][2] = zpos;
531
532 }
533 }
534
535 // Create the volumes of the super module frame
536 CreateFrame(idtmed);
537
538 // Create the volumes of the services
539 CreateServices(idtmed);
540
541 for (Int_t icham = 0; icham < kNcham; icham++) {
542 for (Int_t iplan = 0; iplan < kNplan; iplan++) {
543 GroupChamber(iplan,icham,idtmed);
544 }
545 }
546
547 xpos = 0.;
548 ypos = 0.;
549 zpos = 0.;
550 gMC->Gspos("UTI1",1,"UTS1",xpos,ypos,zpos,0,"ONLY");
551
552 xpos = 0.;
553 ypos = 0.;
554 zpos = 0.;
555 gMC->Gspos("UTS1",1,"UTR1",xpos,ypos,zpos,0,"ONLY");
556
557 // Put the TRD volumes into the space frame mother volumes
558 // if enabled via status flag
559 xpos = 0.;
560 ypos = 0.;
561 zpos = 0.;
562 for (Int_t isect = 0; isect < kNsect; isect++) {
563 if (fSMstatus[isect]) {
564 sprintf(cTagV,"BTRD%d",isect);
565 gMC->Gspos("UTR1",1,cTagV,xpos,ypos,zpos,0,"ONLY");
566 }
567 }
568
569}
570
571//_____________________________________________________________________________
572void AliTRDgeometry::CreateFrame(Int_t *idtmed)
573{
574 //
575 // Create the geometry of the frame of the supermodule
576 //
577 // Names of the TRD services volumina
578 //
579 // USRL Support rails for the chambers (Al)
580 // USxx Support cross bars between the chambers (Al)
581 //
582
583 Int_t iplan = 0;
584
585 Float_t xpos = 0.0;
586 Float_t ypos = 0.0;
587 Float_t zpos = 0.0;
588
589 Char_t cTagV[5];
590
591 //
592 // The chamber support rails
593 //
594
595 const Float_t kSRLwid = 2.0;
596 const Float_t kSRLhgt = 2.3;
597 const Float_t kSRLdst = 0.6;
598 const Int_t kNparSRL = 3;
599 Float_t parSRL[kNparSRL];
600 parSRL[0] = kSRLwid/2.;
601 parSRL[1] = fgkSlenTR1/2.;
602 parSRL[2] = kSRLhgt/2.;
603 gMC->Gsvolu("USRL","BOX ",idtmed[1301-1],parSRL,kNparSRL);
604
605 xpos = 0.0;
606 ypos = 0.0;
607 zpos = 0.0;
608 for (iplan = 0; iplan < kNplan; iplan++) {
609
610 xpos = fCwidth[iplan]/2. + kSRLwid/2. + kSRLdst;
611 ypos = 0.0;
a797f961 612 zpos = fgkVrocsm + fgkCraH + fgkCdrH - fgkSheight/2. - kSRLhgt/2.
bd0f8685 613 + iplan * (fgkCH + fgkVspace);
614 gMC->Gspos("USRL",iplan+1 ,"UTI1", xpos,ypos,zpos,0,"ONLY");
615 gMC->Gspos("USRL",iplan+1+ kNplan,"UTI1",-xpos,ypos,zpos,0,"ONLY");
616
617 }
618
619 //
620 // The cross bars between the chambers
621 //
622
623 const Float_t kSCBwid = 1.0;
624 const Int_t kNparSCB = 3;
625 Float_t parSCB[kNparSCB];
626 parSCB[1] = kSCBwid/2.;
627 parSCB[2] = fgkCH/2.;
628
629 xpos = 0.0;
630 ypos = 0.0;
631 zpos = 0.0;
632 for (iplan = 0; iplan < kNplan; iplan++) {
633
634 parSCB[0] = fCwidth[iplan]/2. + kSRLdst/2.;
635
636 sprintf(cTagV,"US0%01d",iplan);
637 gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
638 xpos = 0.0;
639 ypos = fgkSlenTR1/2. - kSCBwid/2.;
a797f961 640 zpos = fgkVrocsm + fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
bd0f8685 641 gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
642
643 sprintf(cTagV,"US1%01d",iplan);
644 gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
645 xpos = 0.0;
646 ypos = fClength[iplan][2]/2. + fClength[iplan][1];
a797f961 647 zpos = fgkVrocsm + fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
bd0f8685 648 gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
649
650 sprintf(cTagV,"US2%01d",iplan);
651 gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
652 xpos = 0.0;
653 ypos = fClength[iplan][2]/2.;
a797f961 654 zpos = fgkVrocsm + fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
bd0f8685 655 gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
656
657 sprintf(cTagV,"US3%01d",iplan);
658 gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
659 xpos = 0.0;
660 ypos = - fClength[iplan][2]/2.;
a797f961 661 zpos = fgkVrocsm + fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
bd0f8685 662 gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
663
664 sprintf(cTagV,"US4%01d",iplan);
665 gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
666 xpos = 0.0;
667 ypos = - fClength[iplan][2]/2. - fClength[iplan][1];
a797f961 668 zpos = fgkVrocsm + fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
bd0f8685 669 gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
670
671 sprintf(cTagV,"US5%01d",iplan);
672 gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
673 xpos = 0.0;
674 ypos = - fgkSlenTR1/2. + kSCBwid/2.;
a797f961 675 zpos = fgkVrocsm + fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
bd0f8685 676 gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
677
678 }
679
680}
681
682//_____________________________________________________________________________
683void AliTRDgeometry::CreateServices(Int_t *idtmed)
684{
685 //
686 // Create the geometry of the services
687 //
688 // Names of the TRD services volumina
689 //
690 // UTCL Cooling arterias (Al)
691 // UTCW Cooling arterias (Water)
692 // UUxx Volumes for the services at the chambers (Air)
693 // UTPW Power bars (Cu)
694 // UTCP Cooling pipes (Al)
695 // UTCH Cooling pipes (Water)
696 // UTPL Power lines (Cu)
697 // UMCM Readout MCMs (G10/Cu/Si)
698 //
699
700 Int_t iplan = 0;
701 Int_t icham = 0;
702
703 Float_t xpos = 0.0;
704 Float_t ypos = 0.0;
705 Float_t zpos = 0.0;
706
707 Char_t cTagV[5];
708
709 // The rotation matrices
710 const Int_t kNmatrix = 3;
711 Int_t matrix[kNmatrix];
712 gMC->Matrix(matrix[0],100.0, 0.0, 90.0, 90.0, 10.0, 0.0);
713 gMC->Matrix(matrix[1], 80.0, 0.0, 90.0, 90.0, 10.0,180.0);
714 gMC->Matrix(matrix[2], 0.0, 0.0, 90.0, 90.0, 90.0, 0.0);
715
716 AliTRDCommonParam* commonParam = AliTRDCommonParam::Instance();
717 if (!commonParam)
718 {
719 AliError("Could not get common params\n");
720 return;
721 }
722
723 //
724 // The cooling arterias
725 //
726
727 // Width of the cooling arterias
728 const Float_t kCOLwid = 0.5;
729 // Height of the cooling arterias
730 const Float_t kCOLhgt = 5.5;
731 // Positioning of the cooling
732 const Float_t kCOLposx = 1.6;
733 const Float_t kCOLposz = -0.2;
734 // Thickness of the walls of the cooling arterias
735 const Float_t kCOLthk = 0.1;
736 const Int_t kNparCOL = 3;
737 Float_t parCOL[kNparCOL];
738 parCOL[0] = kCOLwid/2.;
739 parCOL[1] = fgkSlenTR1/2.;
740 parCOL[2] = kCOLhgt/2.;
741 gMC->Gsvolu("UTCL","BOX ",idtmed[1324-1],parCOL,kNparCOL);
742 parCOL[0] -= kCOLthk;
743 parCOL[1] = fgkSlenTR1/2.;
744 parCOL[2] -= kCOLthk;
745 gMC->Gsvolu("UTCW","BOX ",idtmed[1314-1],parCOL,kNparCOL);
746
747 xpos = 0.0;
748 ypos = 0.0;
749 zpos = 0.0;
750 gMC->Gspos("UTCW",1,"UTCL", xpos,ypos,zpos,0,"ONLY");
751
a797f961 752 for (iplan = 0; iplan < kNplan; iplan++) {
bd0f8685 753
754 xpos = fCwidth[iplan]/2. + kCOLwid/2. + kCOLposx;
755 ypos = 0.0;
a797f961 756 zpos = fgkVrocsm + kCOLhgt/2. - fgkSheight/2. + kCOLposz
757 + iplan * (fgkCH + fgkVspace);
bd0f8685 758 if (iplan == 0) zpos += 0.25; // To avoid overlaps !
759 gMC->Gspos("UTCL",iplan+1 ,"UTI1", xpos,ypos,zpos,matrix[0],"ONLY");
760 gMC->Gspos("UTCL",iplan+1+ kNplan,"UTI1",-xpos,ypos,zpos,matrix[1],"ONLY");
761
762 }
763
764 //
765 // The power bars
766 //
767
768 const Float_t kPWRwid = 0.6;
769 const Float_t kPWRhgt = 4.5;
770 const Float_t kPWRposx = 1.05;
771 const Float_t kPWRposz = 0.9;
772 const Int_t kNparPWR = 3;
773 Float_t parPWR[kNparPWR];
774 parPWR[0] = kPWRwid/2.;
775 parPWR[1] = fgkSlenTR1/2.;
776 parPWR[2] = kPWRhgt/2.;
777 gMC->Gsvolu("UTPW","BOX ",idtmed[1325-1],parPWR,kNparPWR);
778
a797f961 779 for (iplan = 0; iplan < kNplan; iplan++) {
bd0f8685 780
781 xpos = fCwidth[iplan]/2. + kPWRwid/2. + kPWRposx;
782 ypos = 0.0;
a797f961 783 zpos = fgkVrocsm + kPWRhgt/2. - fgkSheight/2. + kPWRposz
784 + iplan * (fgkCH + fgkVspace);
bd0f8685 785 gMC->Gspos("UTPW",iplan+1 ,"UTI1", xpos,ypos,zpos,matrix[0],"ONLY");
786 gMC->Gspos("UTPW",iplan+1+ kNplan,"UTI1",-xpos,ypos,zpos,matrix[1],"ONLY");
787
788 }
789
790 //
791 // The volumes for the services at the chambers
792 //
793
794 const Int_t kNparServ = 3;
795 Float_t parServ[kNparServ];
796
797 for (icham = 0; icham < kNcham; icham++) {
798 for (iplan = 0; iplan < kNplan; iplan++) {
bd0f8685 799
800 Int_t iDet = GetDetectorSec(iplan,icham);
801
802 sprintf(cTagV,"UU%02d",iDet);
803 parServ[0] = fCwidth[iplan]/2.;
804 parServ[1] = fClength[iplan][icham]/2. - fgkHspace/2.;
a797f961 805 parServ[2] = fgkVspace/2. - 0.742/2.; //!!!!!!!!!!!!!!
bd0f8685 806 fChamberUUboxd[iDet][0] = parServ[0];
807 fChamberUUboxd[iDet][1] = parServ[1];
808 fChamberUUboxd[iDet][2] = parServ[2];
bd0f8685 809 gMC->Gsvolu(cTagV,"BOX",idtmed[1302-1],parServ,kNparServ);
a797f961 810
bd0f8685 811 xpos = 0.;
812 ypos = - fClength[iplan][0] - fClength[iplan][1] - fClength[iplan][2]/2.;
813 for (Int_t ic = 0; ic < icham; ic++) {
814 ypos += fClength[iplan][ic];
815 }
816 ypos += fClength[iplan][icham]/2.;
a797f961 817 zpos = fgkVrocsm + fgkCH + fgkVspace/2. - fgkSheight/2.
818 + iplan * (fgkCH + fgkVspace);
bd0f8685 819 zpos -= 0.742/2.;
820 fChamberUUorig[iDet][0] = xpos;
821 fChamberUUorig[iDet][1] = ypos;
822 fChamberUUorig[iDet][2] = zpos;
823
824 }
825 }
826
827 //
828 // The cooling pipes inside the service volumes
829 //
830
831 const Int_t kNparTube = 3;
832 Float_t parTube[kNparTube];
833 // The aluminum pipe for the cooling
834 parTube[0] = 0.0;
835 parTube[1] = 0.0;
836 parTube[2] = 0.0;
837 gMC->Gsvolu("UTCP","TUBE",idtmed[1324-1],parTube,0);
838 // The cooling water
839 parTube[0] = 0.0;
840 parTube[1] = 0.2/2.;
841 parTube[2] = -1.;
842 gMC->Gsvolu("UTCH","TUBE",idtmed[1314-1],parTube,kNparTube);
843 // Water inside the cooling pipe
844 xpos = 0.0;
845 ypos = 0.0;
846 zpos = 0.0;
847 gMC->Gspos("UTCH",1,"UTCP",xpos,ypos,zpos,0,"ONLY");
848
849 // Position the cooling pipes in the mother volume
850 const Int_t kNpar = 3;
851 Float_t par[kNpar];
852 for (icham = 0; icham < kNcham; icham++) {
853 for (iplan = 0; iplan < kNplan; iplan++) {
bd0f8685 854 Int_t iDet = GetDetectorSec(iplan,icham);
855 Int_t iCopy = GetDetector(iplan,icham,0) * 100;
856 Int_t nMCMrow = commonParam->GetRowMax(iplan,icham,0);
857 Float_t ySize = (GetChamberLength(iplan,icham) - 2.*fgkRpadW)
858 / ((Float_t) nMCMrow);
859 sprintf(cTagV,"UU%02d",iDet);
860 for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
861 xpos = 0.0;
862 ypos = (0.5 + iMCMrow) * ySize - 1.9
863 - fClength[iplan][icham]/2. + fgkHspace/2.;
864 zpos = 0.0 + 0.742/2.;
865 par[0] = 0.0;
866 par[1] = 0.3/2.; // Thickness of the cooling pipes
867 par[2] = fCwidth[iplan]/2.;
868 gMC->Gsposp("UTCP",iCopy+iMCMrow,cTagV,xpos,ypos,zpos
869 ,matrix[2],"ONLY",par,kNpar);
870 }
871 }
872 }
873
874 //
875 // The power lines
876 //
877
878 // The copper power lines
879 parTube[0] = 0.0;
880 parTube[1] = 0.0;
881 parTube[2] = 0.0;
882 gMC->Gsvolu("UTPL","TUBE",idtmed[1305-1],parTube,0);
883
884 // Position the power lines in the mother volume
885 for (icham = 0; icham < kNcham; icham++) {
886 for (iplan = 0; iplan < kNplan; iplan++) {
bd0f8685 887 Int_t iDet = GetDetectorSec(iplan,icham);
888 Int_t iCopy = GetDetector(iplan,icham,0) * 100;
889 Int_t nMCMrow = commonParam->GetRowMax(iplan,icham,0);
890 Float_t ySize = (GetChamberLength(iplan,icham) - 2.*fgkRpadW)
891 / ((Float_t) nMCMrow);
892 sprintf(cTagV,"UU%02d",iDet);
893 for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
894 xpos = 0.0;
895 ypos = (0.5 + iMCMrow) * ySize - 1.0
896 - fClength[iplan][icham]/2. + fgkHspace/2.;
897 zpos = -0.4 + 0.742/2.;
898 par[0] = 0.0;
899 par[1] = 0.2/2.; // Thickness of the power lines
900 par[2] = fCwidth[iplan]/2.;
901 gMC->Gsposp("UTPL",iCopy+iMCMrow,cTagV,xpos,ypos,zpos
902 ,matrix[2],"ONLY",par,kNpar);
903 }
904 }
905 }
906
907 //
908 // The MCMs
909 //
910
911 // The mother volume for the MCMs (air)
912 const Int_t kNparMCM = 3;
913 Float_t parMCM[kNparMCM];
914 parMCM[0] = 3.0/2.;
915 parMCM[1] = 3.0/2.;
916 parMCM[2] = 0.14/2.;
917 gMC->Gsvolu("UMCM","BOX",idtmed[1302-1],parMCM,kNparMCM);
918
919 // The MCM carrier G10 layer
920 parMCM[0] = 3.0/2.;
921 parMCM[1] = 3.0/2.;
922 parMCM[2] = 0.1/2.;
923 gMC->Gsvolu("UMC1","BOX",idtmed[1319-1],parMCM,kNparMCM);
924 // The MCM carrier Cu layer
925 parMCM[0] = 3.0/2.;
926 parMCM[1] = 3.0/2.;
927 parMCM[2] = 0.0162/2.;
928 gMC->Gsvolu("UMC2","BOX",idtmed[1318-1],parMCM,kNparMCM);
929 // The silicon of the chips
930 parMCM[0] = 3.0/2.;
931 parMCM[1] = 3.0/2.;
932 parMCM[2] = 0.003/2.;
933 gMC->Gsvolu("UMC3","BOX",idtmed[1320-1],parMCM,kNparMCM);
934
935 // Put the MCM material inside the MCM mother volume
936 xpos = 0.0;
937 ypos = 0.0;
938 zpos = -0.07 + 0.1/2.;
939 gMC->Gspos("UMC1",1,"UMCM",xpos,ypos,zpos,0,"ONLY");
940 zpos += 0.1/2. + 0.0162/2.;
941 gMC->Gspos("UMC2",1,"UMCM",xpos,ypos,zpos,0,"ONLY");
942 zpos += 0.00162/2 + 0.003/2.;
943 gMC->Gspos("UMC3",1,"UMCM",xpos,ypos,zpos,0,"ONLY");
944
945 // Position the MCMs in the mother volume
946 for (icham = 0; icham < kNcham; icham++) {
947 for (iplan = 0; iplan < kNplan; iplan++) {
948 // Take out upper plane until TRD mothervolume is adjusted
949 //for (iplan = 0; iplan < kNplan-1; iplan++) {
950 Int_t iDet = GetDetectorSec(iplan,icham);
951 Int_t iCopy = GetDetector(iplan,icham,0) * 1000;
952 Int_t nMCMrow = commonParam->GetRowMax(iplan,icham,0);
953 Float_t ySize = (GetChamberLength(iplan,icham) - 2.*fgkRpadW)
954 / ((Float_t) nMCMrow);
955 Int_t nMCMcol = 8;
956 Float_t xSize = (GetChamberWidth(iplan) - 2.* fgkCpadW)
957 / ((Float_t) nMCMcol);
958 sprintf(cTagV,"UU%02d",iDet);
959 for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
960 for (Int_t iMCMcol = 0; iMCMcol < nMCMcol; iMCMcol++) {
961 xpos = (0.5 + iMCMcol) * xSize + 1.0
962 - fCwidth[iplan]/2.;
963 ypos = (0.5 + iMCMrow) * ySize + 1.0
964 - fClength[iplan][icham]/2. + fgkHspace/2.;
965 zpos = -0.4 + 0.742/2.;
966 par[0] = 0.0;
967 par[1] = 0.2/2.; // Thickness of the power lines
968 par[2] = fCwidth[iplan]/2.;
969 gMC->Gspos("UMCM",iCopy+iMCMrow*10+iMCMcol,cTagV
970 ,xpos,ypos,zpos,0,"ONLY");
971 }
972 }
973
974 }
975 }
976
977}
978
979//_____________________________________________________________________________
980void AliTRDgeometry::GroupChamber(Int_t iplan, Int_t icham, Int_t *idtmed)
f7336fa3 981{
982 //
bd0f8685 983 // Group volumes UA, UD, UF, UU in a single chamber (Air)
984 // UA, UD, UF, UU are boxes
985 // UT will be a box
0a770ac9 986 //
bd0f8685 987
988 const Int_t kNparCha = 3;
989
990 Int_t iDet = GetDetectorSec(iplan,icham);
991
992 Float_t xyzMin[3];
993 Float_t xyzMax[3];
994 Float_t xyzOrig[3];
995 Float_t xyzBoxd[3];
996
997 Char_t cTagV[5];
998 Char_t cTagM[5];
999
1000 for (Int_t i = 0; i < 3; i++) {
1001 xyzMin[i] = +9999; xyzMax[i] = -9999;
1002 }
1003
1004 for (Int_t i = 0; i < 3; i++) {
1005
1006 xyzMin[i] = TMath::Min(xyzMin[i],fChamberUAorig[iDet][i]-fChamberUAboxd[iDet][i]);
1007 xyzMax[i] = TMath::Max(xyzMax[i],fChamberUAorig[iDet][i]+fChamberUAboxd[iDet][i]);
1008
1009 xyzMin[i] = TMath::Min(xyzMin[i],fChamberUDorig[iDet][i]-fChamberUDboxd[iDet][i]);
1010 xyzMax[i] = TMath::Max(xyzMax[i],fChamberUDorig[iDet][i]+fChamberUDboxd[iDet][i]);
1011
1012 xyzMin[i] = TMath::Min(xyzMin[i],fChamberUForig[iDet][i]-fChamberUFboxd[iDet][i]);
1013 xyzMax[i] = TMath::Max(xyzMax[i],fChamberUForig[iDet][i]+fChamberUFboxd[iDet][i]);
1014
a797f961 1015 xyzMin[i] = TMath::Min(xyzMin[i],fChamberUUorig[iDet][i]-fChamberUUboxd[iDet][i]);
1016 xyzMax[i] = TMath::Max(xyzMax[i],fChamberUUorig[iDet][i]+fChamberUUboxd[iDet][i]);
bd0f8685 1017
1018 xyzOrig[i] = 0.5*(xyzMax[i]+xyzMin[i]);
1019 xyzBoxd[i] = 0.5*(xyzMax[i]-xyzMin[i]);
1020
1021 }
1022
1023 sprintf(cTagM,"UT%02d",iDet);
1024
1025 gMC->Gsvolu(cTagM,"BOX ",idtmed[1302-1],xyzBoxd,kNparCha);
1026
1027 sprintf(cTagV,"UA%02d",iDet);
1028 gMC->Gspos(cTagV,1,cTagM,
1029 fChamberUAorig[iDet][0]-xyzOrig[0],
1030 fChamberUAorig[iDet][1]-xyzOrig[1],
1031 fChamberUAorig[iDet][2]-xyzOrig[2],
1032 0,"ONLY");
1033
1034 sprintf(cTagV,"UD%02d",iDet);
1035 gMC->Gspos(cTagV,1,cTagM,
1036 fChamberUDorig[iDet][0]-xyzOrig[0],
1037 fChamberUDorig[iDet][1]-xyzOrig[1],
1038 fChamberUDorig[iDet][2]-xyzOrig[2],
1039 0,"ONLY");
1040
1041 sprintf(cTagV,"UF%02d",iDet);
1042 gMC->Gspos(cTagV,1,cTagM,
1043 fChamberUForig[iDet][0]-xyzOrig[0],
1044 fChamberUForig[iDet][1]-xyzOrig[1],
1045 fChamberUForig[iDet][2]-xyzOrig[2],
1046 0,"ONLY");
1047
a797f961 1048 sprintf(cTagV,"UU%02d",iDet);
1049 gMC->Gspos(cTagV,1,cTagM,
1050 fChamberUUorig[iDet][0]-xyzOrig[0],
1051 fChamberUUorig[iDet][1]-xyzOrig[1],
1052 fChamberUUorig[iDet][2]-xyzOrig[2],
1053 0,"ONLY");
bd0f8685 1054
1055 sprintf(cTagV,"UT%02d",iDet);
1056 gMC->Gspos(cTagV,1,"UTI1",xyzOrig[0],xyzOrig[1],xyzOrig[2],0,"ONLY");
f7336fa3 1057
1058}
1059
1060//_____________________________________________________________________________
a5cadd36 1061Bool_t AliTRDgeometry::Local2Global(Int_t idet, Double_t *local
dde59437 1062 , Double_t *global) const
f7336fa3 1063{
1064 //
1065 // Converts local pad-coordinates (row,col,time) into
1066 // global ALICE reference frame coordinates (x,y,z)
1067 //
1068
793ff80c 1069 Int_t icham = GetChamber(idet); // Chamber info (0-4)
1070 Int_t isect = GetSector(idet); // Sector info (0-17)
1071 Int_t iplan = GetPlane(idet); // Plane info (0-5)
f7336fa3 1072
dde59437 1073 return Local2Global(iplan,icham,isect,local,global);
f7336fa3 1074
1075}
1076
1077//_____________________________________________________________________________
1078Bool_t AliTRDgeometry::Local2Global(Int_t iplan, Int_t icham, Int_t isect
dde59437 1079 , Double_t *local, Double_t *global) const
f7336fa3 1080{
1081 //
1082 // Converts local pad-coordinates (row,col,time) into
1083 // global ALICE reference frame coordinates (x,y,z)
1084 //
1085
3551db50 1086 AliTRDCommonParam* commonParam = AliTRDCommonParam::Instance();
1087 if (!commonParam)
1088 return kFALSE;
5443e65e 1089
3551db50 1090 AliTRDcalibDB* calibration = AliTRDcalibDB::Instance();
1091 if (!calibration)
1092 return kFALSE;
1093
1094 AliTRDpadPlane *padPlane = commonParam->GetPadPlane(iplan,icham);
f7336fa3 1095
a5cadd36 1096 // calculate (x,y,z) position in rotated chamber
1097 Int_t row = ((Int_t) local[0]);
1098 Int_t col = ((Int_t) local[1]);
1099 Float_t timeSlice = local[2] + 0.5;
3551db50 1100 Float_t time0 = GetTime0(iplan);
f7336fa3 1101
7754cd1f 1102 Int_t idet = GetDetector(iplan, icham, isect);
1103
a5cadd36 1104 Double_t rot[3];
7754cd1f 1105 rot[0] = time0 - (timeSlice - calibration->GetT0(idet, col, row))
1106 * calibration->GetVdrift(idet, col, row)/calibration->GetSamplingFrequency();
a5cadd36 1107 rot[1] = padPlane->GetColPos(col) - 0.5 * padPlane->GetColSize(col);
1108 rot[2] = padPlane->GetRowPos(row) - 0.5 * padPlane->GetRowSize(row);
f7336fa3 1109
1110 // Rotate back to original position
1111 return RotateBack(idet,rot,global);
1112
1113}
1114
3d7b6a24 1115//_____________________________________________________________________________
a5cadd36 1116Bool_t AliTRDgeometry::Global2Local(Int_t mode, Double_t *local, Double_t *global
bd0f8685 1117 , Int_t* index) const
3d7b6a24 1118{
1119 //
1120 // Converts local pad-coordinates (row,col,time) into
1121 // global ALICE reference frame coordinates (x,y,z)
1122 //
e0d47c25 1123 // index[0] = plane number
1124 // index[1] = chamber number
1125 // index[2] = sector number
3d7b6a24 1126 //
1127 // mode=0 - local coordinate in y, z, x - rotated global
1128 // mode=2 - local coordinate in pad, and pad row, x - rotated global
1129 //
e0d47c25 1130
bd0f8685 1131 Int_t idet = GetDetector(index[0],index[1],index[2]); // Detector number
b4a9cd27 1132 RotateBack(idet,global,local);
bd0f8685 1133 if (mode == 0) return kTRUE;
3d7b6a24 1134
1135 return kTRUE;
1136
1137}
1138
a5cadd36 1139//_____________________________________________________________________________
3551db50 1140Bool_t AliTRDgeometry::Global2Detector(Double_t global[3], Int_t index[3])
3d7b6a24 1141{
1142 //
b4a9cd27 1143 // Find detector for given global point - Ideal geometry
1144 //
1145 //
e0d47c25 1146 // input = global position
1147 // output = index
1148 // index[0] = plane number
1149 // index[1] = chamber number
1150 // index[2] = sector number
3d7b6a24 1151 //
bd0f8685 1152
3d7b6a24 1153 //
b4a9cd27 1154 // Find sector
1155 //
1156 Float_t fi = TMath::ATan2(global[1],global[0]);
bd0f8685 1157 if (fi < 0) {
1158 fi += 2*TMath::Pi();
1159 }
1160 index[2] = fgkNsect - 1 - TMath::Nint((fi - GetAlpha()/2.)/GetAlpha());
1161
3d7b6a24 1162 //
b4a9cd27 1163 // Find plane
3d7b6a24 1164 //
1165 Float_t locx = global[0] * fRotA11[index[2]] + global[1] * fRotA12[index[2]];
1166 index[0] = 0;
3551db50 1167 Float_t max = locx - GetTime0(0);
3d7b6a24 1168 for (Int_t iplane=1; iplane<fgkNplan;iplane++){
3551db50 1169 Float_t dist = TMath::Abs(locx - GetTime0(iplane));
3d7b6a24 1170 if (dist < max){
1171 index[0] = iplane;
1172 max = dist;
1173 }
1174 }
bd0f8685 1175
b4a9cd27 1176 //
1177 // Find chamber
1178 //
1179 if (TMath::Abs(global[2]) < 0.5*GetChamberLength(index[0],2)){
1180 index[1]=2;
bd0f8685 1181 }
1182 else{
b4a9cd27 1183 Double_t localZ = global[2];
bd0f8685 1184 if (global[2] > 0){
b4a9cd27 1185 localZ -= 0.5*(GetChamberLength(index[0],2)+GetChamberLength(index[0],1));
1186 index[1] = (TMath::Abs(localZ) < 0.5*GetChamberLength(index[0],3)) ? 1:0;
1187 }
1188 else{
1189 localZ += 0.5*(GetChamberLength(index[0],2)+GetChamberLength(index[0],3));
1190 index[1] = (TMath::Abs(localZ) < 0.5*GetChamberLength(index[0],1)) ? 3:4;
1191 }
1192 }
bd0f8685 1193
3d7b6a24 1194 return kTRUE;
3d7b6a24 1195
bd0f8685 1196}
3d7b6a24 1197
f7336fa3 1198//_____________________________________________________________________________
a5cadd36 1199Bool_t AliTRDgeometry::Rotate(Int_t d, Double_t *pos, Double_t *rot) const
f7336fa3 1200{
1201 //
1202 // Rotates all chambers in the position of sector 0 and transforms
1203 // the coordinates in the ALICE restframe <pos> into the
1204 // corresponding local frame <rot>.
1205 //
1206
793ff80c 1207 Int_t sector = GetSector(d);
f7336fa3 1208
793ff80c 1209 rot[0] = pos[0] * fRotA11[sector] + pos[1] * fRotA12[sector];
1210 rot[1] = -pos[0] * fRotA21[sector] + pos[1] * fRotA22[sector];
f7336fa3 1211 rot[2] = pos[2];
1212
1213 return kTRUE;
1214
1215}
1216
1217//_____________________________________________________________________________
a5cadd36 1218Bool_t AliTRDgeometry::RotateBack(Int_t d, Double_t *rot, Double_t *pos) const
f7336fa3 1219{
1220 //
1221 // Rotates a chambers from the position of sector 0 into its
1222 // original position and transforms the corresponding local frame
1223 // coordinates <rot> into the coordinates of the ALICE restframe <pos>.
1224 //
1225
793ff80c 1226 Int_t sector = GetSector(d);
f7336fa3 1227
793ff80c 1228 pos[0] = rot[0] * fRotB11[sector] + rot[1] * fRotB12[sector];
1229 pos[1] = -rot[0] * fRotB21[sector] + rot[1] * fRotB22[sector];
6f1e466d 1230 pos[2] = rot[2];
f7336fa3 1231
1232 return kTRUE;
1233
1234}
1235
1236//_____________________________________________________________________________
3551db50 1237Int_t AliTRDgeometry::GetDetectorSec(Int_t p, Int_t c)
0a770ac9 1238{
1239 //
1240 // Convert plane / chamber into detector number for one single sector
1241 //
1242
1243 return (p + c * fgkNplan);
1244
1245}
1246
1247//_____________________________________________________________________________
3551db50 1248Int_t AliTRDgeometry::GetDetector(Int_t p, Int_t c, Int_t s)
f7336fa3 1249{
1250 //
1251 // Convert plane / chamber / sector into detector number
1252 //
1253
793ff80c 1254 return (p + c * fgkNplan + s * fgkNplan * fgkNcham);
f7336fa3 1255
1256}
1257
1258//_____________________________________________________________________________
afc51ac2 1259Int_t AliTRDgeometry::GetPlane(Int_t d) const
f7336fa3 1260{
1261 //
1262 // Reconstruct the plane number from the detector number
1263 //
1264
793ff80c 1265 return ((Int_t) (d % fgkNplan));
f7336fa3 1266
1267}
1268
1269//_____________________________________________________________________________
afc51ac2 1270Int_t AliTRDgeometry::GetChamber(Int_t d) const
f7336fa3 1271{
1272 //
1273 // Reconstruct the chamber number from the detector number
1274 //
1275
793ff80c 1276 return ((Int_t) (d % (fgkNplan * fgkNcham)) / fgkNplan);
f7336fa3 1277
1278}
1279
1280//_____________________________________________________________________________
afc51ac2 1281Int_t AliTRDgeometry::GetSector(Int_t d) const
f7336fa3 1282{
1283 //
1284 // Reconstruct the sector number from the detector number
1285 //
1286
793ff80c 1287 return ((Int_t) (d / (fgkNplan * fgkNcham)));
f7336fa3 1288
1289}
1290
bdbb05bb 1291//_____________________________________________________________________________
1292AliTRDgeometry* AliTRDgeometry::GetGeometry(AliRunLoader* runLoader)
1293{
1294 //
1295 // load the geometry from the galice file
1296 //
1297
1298 if (!runLoader) runLoader = AliRunLoader::GetRunLoader();
1299 if (!runLoader) {
1300 ::Error("AliTRDgeometry::GetGeometry", "No run loader");
1301 return NULL;
1302 }
1303
1304 TDirectory* saveDir = gDirectory;
1305 runLoader->CdGAFile();
1306
ecb36af7 1307 // Try from the galice.root file
bdbb05bb 1308 AliTRDgeometry* geom = (AliTRDgeometry*) gDirectory->Get("TRDgeometry");
ecb36af7 1309
1310 if (!geom) {
1311 // It is not in the file, try to get it from gAlice,
1312 // which corresponds to the run loader
1313 AliTRD * trd = (AliTRD*)runLoader->GetAliRun()->GetDetector("TRD");
1314 geom = trd->GetGeometry();
1315 }
bdbb05bb 1316 if (!geom) ::Error("AliTRDgeometry::GetGeometry", "Geometry not found");
1317
1318 saveDir->cd();
1319 return geom;
b4a9cd27 1320
bd0f8685 1321}
b4a9cd27 1322
1323//_____________________________________________________________________________
bd0f8685 1324Bool_t AliTRDgeometry::ReadGeoMatrices()
1325{
b4a9cd27 1326 //
1327 // Read geo matrices from current gGeoManager for each TRD sector
1328 //
1329
b4a9cd27 1330 if (!gGeoManager) return kFALSE;
1331 fMatrixArray = new TObjArray(kNdet);
1332 fMatrixCorrectionArray = new TObjArray(kNdet);
1333 fMatrixGeo = new TObjArray(kNdet);
1334 AliAlignObjAngles o;
bd0f8685 1335
b4a9cd27 1336 for (Int_t iLayer = AliAlignObj::kTRD1; iLayer <= AliAlignObj::kTRD6; iLayer++) {
1337 for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer); iModule++) {
1338 UShort_t volid = AliAlignObj::LayerToVolUID(iLayer,iModule);
1339 const char *path = AliAlignObj::GetVolPath(volid);
1340 if (!gGeoManager->cd(path)) return kFALSE;
1341 TGeoHMatrix* m = gGeoManager->GetCurrentMatrix();
1342 Int_t iLayerTRD = iLayer-AliAlignObj::kTRD1;
1343 Int_t isector = Nsect()-1-(iModule/Ncham());
1344 Int_t ichamber = Ncham()-1-(iModule%Ncham());
1345 Int_t lid = GetDetector(iLayerTRD,ichamber,isector);
bd0f8685 1346
b4a9cd27 1347 //
1348 // local geo system z-x-y to x-y--z
1349 //
1350 fMatrixGeo->AddAt(new TGeoHMatrix(*m),lid);
1351
1352 TGeoRotation mchange;
1353 mchange.RotateY(90); mchange.RotateX(90);
bd0f8685 1354
b4a9cd27 1355 TGeoHMatrix gMatrix(mchange.Inverse());
1356 gMatrix.MultiplyLeft(m);
1357 fMatrixArray->AddAt(new TGeoHMatrix(gMatrix),lid);
bd0f8685 1358
b4a9cd27 1359 //
1360 // Cluster transformation matrix
1361 //
1362 TGeoHMatrix rotMatrix(mchange.Inverse());
1363 rotMatrix.MultiplyLeft(m);
1364 Double_t sectorAngle = 20.*(isector%18)+10;
1365 TGeoHMatrix rotSector;
1366 rotSector.RotateZ(sectorAngle);
1367 rotMatrix.MultiplyLeft(&rotSector);
bd0f8685 1368
b4a9cd27 1369 fMatrixCorrectionArray->AddAt(new TGeoHMatrix(rotMatrix),lid);
bd0f8685 1370
b4a9cd27 1371 }
1372 }
bd0f8685 1373
b4a9cd27 1374 return kTRUE;
b4a9cd27 1375
bd0f8685 1376}
b4a9cd27 1377