1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
18 ///////////////////////////////////////////////////////////////////////////////
20 // TRD geometry class //
22 ///////////////////////////////////////////////////////////////////////////////
24 #include <TGeoManager.h>
25 #include <TGeoPhysicalNode.h>
26 #include <TVirtualMC.h>
30 #include "AliAlignObjParams.h"
32 #include "AliTRDgeometry.h"
33 #include "AliTRDpadPlane.h"
35 ClassImp(AliTRDgeometry)
37 //_____________________________________________________________________________
40 // The geometry constants
42 const Int_t AliTRDgeometry::fgkNsector = kNsector;
43 const Int_t AliTRDgeometry::fgkNlayer = kNlayer;
44 const Int_t AliTRDgeometry::fgkNstack = kNstack;
45 const Int_t AliTRDgeometry::fgkNdet = kNdet;
48 // Dimensions of the detector
51 // Total length of the TRD mother volume
52 const Float_t AliTRDgeometry::fgkTlength = 751.0;
54 // Parameter of the super module mother volumes
55 const Float_t AliTRDgeometry::fgkSheight = 77.9;
56 const Float_t AliTRDgeometry::fgkSwidth1 = 94.881;
57 const Float_t AliTRDgeometry::fgkSwidth2 = 122.353;
58 const Float_t AliTRDgeometry::fgkSlength = 702.0;
60 // Length of the additional space in front of the supermodule
62 const Float_t AliTRDgeometry::fgkFlength = (AliTRDgeometry::fgkTlength
63 - AliTRDgeometry::fgkSlength) / 2.0;
65 // The super module side plates
66 const Float_t AliTRDgeometry::fgkSMpltT = 0.2;
68 // Vertical spacing of the chambers
69 const Float_t AliTRDgeometry::fgkVspace = 1.784;
70 // Horizontal spacing of the chambers
71 const Float_t AliTRDgeometry::fgkHspace = 2.0;
72 // Radial distance of the first ROC to the outer plates of the SM
73 const Float_t AliTRDgeometry::fgkVrocsm = 1.2;
75 // Height of different chamber parts
77 const Float_t AliTRDgeometry::fgkCraH = 4.8;
79 const Float_t AliTRDgeometry::fgkCdrH = 3.0;
80 // Amplification region
81 const Float_t AliTRDgeometry::fgkCamH = 0.7;
83 const Float_t AliTRDgeometry::fgkCroH = 2.316;
84 // Additional width of the readout chamber frames
85 const Float_t AliTRDgeometry::fgkCroW = 0.9;
86 // Services on top of ROC
87 const Float_t AliTRDgeometry::fgkCsvH = AliTRDgeometry::fgkVspace
89 // Total height (w/o services)
90 const Float_t AliTRDgeometry::fgkCH = AliTRDgeometry::fgkCraH
91 + AliTRDgeometry::fgkCdrH
92 + AliTRDgeometry::fgkCamH
93 + AliTRDgeometry::fgkCroH;
94 // Total height (with services)
96 const Float_t AliTRDgeometry::fgkCHsv = AliTRDgeometry::fgkCH
97 + AliTRDgeometry::fgkCsvH;
99 // Distance of anode wire plane relative to middle of alignable volume
100 const Float_t AliTRDgeometry::fgkAnodePos = AliTRDgeometry::fgkCraH
101 + AliTRDgeometry::fgkCdrH
102 + AliTRDgeometry::fgkCamH/2.0
103 - AliTRDgeometry::fgkCHsv/2.0;
105 // Thicknesses of different parts of the chamber frame
106 // Lower aluminum frame
107 const Float_t AliTRDgeometry::fgkCalT = 0.4;
108 // Lower Wacosit frame sides
109 const Float_t AliTRDgeometry::fgkCclsT = 0.21;
110 // Lower Wacosit frame front
111 const Float_t AliTRDgeometry::fgkCclfT = 1.0;
112 // Thickness of glue around radiator
113 const Float_t AliTRDgeometry::fgkCglT = 0.25;
114 // Upper Wacosit frame around amplification region
115 const Float_t AliTRDgeometry::fgkCcuTa = 1.0;
116 const Float_t AliTRDgeometry::fgkCcuTb = 0.8;
117 // Al frame of back panel
118 const Float_t AliTRDgeometry::fgkCauT = 1.5;
119 // Additional Al ledge at the lower chamber frame
120 // Actually the dimensions are not realistic, but
121 // modified in order to allow to mis-alignment.
122 // The amount of material is, however, correct
123 const Float_t AliTRDgeometry::fgkCalW = 2.5;
124 const Float_t AliTRDgeometry::fgkCalH = 0.4;
125 const Float_t AliTRDgeometry::fgkCalWmod = 0.4;
126 const Float_t AliTRDgeometry::fgkCalHmod = 2.5;
127 // Additional Wacosit ledge at the lower chamber frame
128 const Float_t AliTRDgeometry::fgkCwsW = 1.2;
129 const Float_t AliTRDgeometry::fgkCwsH = 0.3;
131 // Difference of outer chamber width and pad plane width
132 const Float_t AliTRDgeometry::fgkCpadW = 0.0;
133 const Float_t AliTRDgeometry::fgkRpadW = 1.0;
136 // Thickness of the the material layers
138 const Float_t AliTRDgeometry::fgkDrThick = AliTRDgeometry::fgkCdrH;
139 const Float_t AliTRDgeometry::fgkAmThick = AliTRDgeometry::fgkCamH;
140 const Float_t AliTRDgeometry::fgkXeThick = AliTRDgeometry::fgkDrThick
141 + AliTRDgeometry::fgkAmThick;
142 const Float_t AliTRDgeometry::fgkWrThick = 0.00011;
144 const Float_t AliTRDgeometry::fgkRMyThick = 0.0015;
145 const Float_t AliTRDgeometry::fgkRCbThick = 0.0055;
146 const Float_t AliTRDgeometry::fgkRGlThick = 0.0065;
147 const Float_t AliTRDgeometry::fgkRRhThick = 0.8;
148 const Float_t AliTRDgeometry::fgkRFbThick = fgkCraH - 2.0 * (fgkRMyThick
152 const Float_t AliTRDgeometry::fgkPPdThick = 0.0025;
153 const Float_t AliTRDgeometry::fgkPPpThick = 0.0356;
154 const Float_t AliTRDgeometry::fgkPGlThick = 0.1428;
155 const Float_t AliTRDgeometry::fgkPCbThick = 0.019;
156 const Float_t AliTRDgeometry::fgkPPcThick = 0.0486;
157 const Float_t AliTRDgeometry::fgkPRbThick = 0.0057;
158 const Float_t AliTRDgeometry::fgkPElThick = 0.0029;
159 const Float_t AliTRDgeometry::fgkPHcThick = fgkCroH - fgkPPdThick
168 // Position of the material layers
170 const Float_t AliTRDgeometry::fgkDrZpos = 2.4;
171 const Float_t AliTRDgeometry::fgkAmZpos = 0.0;
172 const Float_t AliTRDgeometry::fgkWrZposA = 0.0;
173 const Float_t AliTRDgeometry::fgkWrZposB = -fgkAmThick/2.0 + 0.001;
174 const Float_t AliTRDgeometry::fgkCalZpos = 0.3;
176 const Int_t AliTRDgeometry::fgkMCMmax = 16;
177 const Int_t AliTRDgeometry::fgkMCMrow = 4;
178 const Int_t AliTRDgeometry::fgkROBmaxC0 = 6;
179 const Int_t AliTRDgeometry::fgkROBmaxC1 = 8;
180 const Int_t AliTRDgeometry::fgkADCmax = 21;
181 const Int_t AliTRDgeometry::fgkTBmax = 60;
182 const Int_t AliTRDgeometry::fgkPadmax = 18;
183 const Int_t AliTRDgeometry::fgkColmax = 144;
184 const Int_t AliTRDgeometry::fgkRowmaxC0 = 12;
185 const Int_t AliTRDgeometry::fgkRowmaxC1 = 16;
187 const Double_t AliTRDgeometry::fgkTime0Base = 300.65;
188 const Float_t AliTRDgeometry::fgkTime0[6] = { fgkTime0Base + 0 * (Cheight() + Cspace())
189 , fgkTime0Base + 1 * (Cheight() + Cspace())
190 , fgkTime0Base + 2 * (Cheight() + Cspace())
191 , fgkTime0Base + 3 * (Cheight() + Cspace())
192 , fgkTime0Base + 4 * (Cheight() + Cspace())
193 , fgkTime0Base + 5 * (Cheight() + Cspace())};
195 const Double_t AliTRDgeometry::fgkXtrdBeg = 288.43; // Values depend on position of TRD
196 const Double_t AliTRDgeometry::fgkXtrdEnd = 366.33; // mother volume inside space frame !!!
198 //_____________________________________________________________________________
199 AliTRDgeometry::AliTRDgeometry()
201 ,fClusterMatrixArray(0)
205 // AliTRDgeometry default constructor
212 //_____________________________________________________________________________
213 AliTRDgeometry::AliTRDgeometry(const AliTRDgeometry &g)
215 ,fClusterMatrixArray(0)
219 // AliTRDgeometry copy constructor
226 //_____________________________________________________________________________
227 AliTRDgeometry::~AliTRDgeometry()
230 // AliTRDgeometry destructor
233 if (fClusterMatrixArray) {
234 fClusterMatrixArray->Delete();
235 delete fClusterMatrixArray;
236 fClusterMatrixArray = 0;
239 if (fPadPlaneArray) {
240 fPadPlaneArray->Delete();
241 delete fPadPlaneArray;
247 //_____________________________________________________________________________
248 AliTRDgeometry &AliTRDgeometry::operator=(const AliTRDgeometry &g)
251 // Assignment operator
262 //_____________________________________________________________________________
263 void AliTRDgeometry::Init()
266 // Initializes the geometry parameter
273 // The outer width of the chambers
281 // The outer lengths of the chambers
282 // Includes the spacings between the chambers!
283 Float_t length[kNlayer][kNstack] = { { 124.0, 124.0, 110.0, 124.0, 124.0 }
284 , { 124.0, 124.0, 110.0, 124.0, 124.0 }
285 , { 131.0, 131.0, 110.0, 131.0, 131.0 }
286 , { 138.0, 138.0, 110.0, 138.0, 138.0 }
287 , { 145.0, 145.0, 110.0, 145.0, 145.0 }
288 , { 147.0, 147.0, 110.0, 147.0, 147.0 } };
290 for (istack = 0; istack < kNstack; istack++) {
291 for (ilayer = 0; ilayer < kNlayer; ilayer++) {
292 fClength[ilayer][istack] = length[ilayer][istack];
296 // The rotation matrix elements
298 for (isector = 0; isector < fgkNsector; isector++) {
299 phi = 2.0 * TMath::Pi() / (Float_t) fgkNsector * ((Float_t) isector + 0.5);
300 fRotB11[isector] = TMath::Cos(phi);
301 fRotB12[isector] = TMath::Sin(phi);
302 fRotB21[isector] = TMath::Sin(phi);
303 fRotB22[isector] = TMath::Cos(phi);
307 for (Int_t i = 0; i < kNsector; i++) {
313 //_____________________________________________________________________________
314 void AliTRDgeometry::CreatePadPlaneArray()
317 // Creates the array of AliTRDpadPlane objects
320 if (fPadPlaneArray) {
321 fPadPlaneArray->Delete();
322 delete fPadPlaneArray;
325 fPadPlaneArray = new TObjArray(fgkNlayer * fgkNstack);
326 for (Int_t ilayer = 0; ilayer < fgkNlayer; ilayer++) {
327 for (Int_t istack = 0; istack < fgkNstack; istack++) {
328 Int_t ipp = GetDetectorSec(ilayer,istack);
329 fPadPlaneArray->AddAt(CreatePadPlane(ilayer,istack),ipp);
335 //_____________________________________________________________________________
336 AliTRDpadPlane *AliTRDgeometry::CreatePadPlane(Int_t ilayer, Int_t istack)
339 // Creates an AliTRDpadPlane object
342 AliTRDpadPlane *padPlane = new AliTRDpadPlane();
344 padPlane->SetLayer(ilayer);
345 padPlane->SetStack(istack);
347 padPlane->SetRowSpacing(0.0);
348 padPlane->SetColSpacing(0.0);
350 padPlane->SetLengthRim(1.0);
351 padPlane->SetWidthRim(0.5);
353 padPlane->SetNcols(144);
355 padPlane->SetAnodeWireOffset(0.25);
358 // The pad plane parameter
364 padPlane->SetNrows(12);
365 padPlane->SetLength(108.0);
366 padPlane->SetWidth(92.2);
367 padPlane->SetLengthOPad(8.0);
368 padPlane->SetWidthOPad(0.515);
369 padPlane->SetLengthIPad(9.0);
370 padPlane->SetWidthIPad(0.635);
371 padPlane->SetTiltingAngle(2.0);
375 padPlane->SetNrows(16);
376 padPlane->SetLength(122.0);
377 padPlane->SetWidth(92.2);
378 padPlane->SetLengthOPad(7.5);
379 padPlane->SetWidthOPad(0.515);
380 padPlane->SetLengthIPad(7.5);
381 padPlane->SetWidthIPad(0.635);
382 padPlane->SetTiltingAngle(2.0);
388 padPlane->SetNrows(12);
389 padPlane->SetLength(108.0);
390 padPlane->SetWidth(96.6);
391 padPlane->SetLengthOPad(8.0);
392 padPlane->SetWidthOPad(0.585);
393 padPlane->SetLengthIPad(9.0);
394 padPlane->SetWidthIPad(0.665);
395 padPlane->SetTiltingAngle(-2.0);
399 padPlane->SetNrows(16);
400 padPlane->SetLength(122.0);
401 padPlane->SetWidth(96.6);
402 padPlane->SetLengthOPad(7.5);
403 padPlane->SetWidthOPad(0.585);
404 padPlane->SetLengthIPad(7.5);
405 padPlane->SetWidthIPad(0.665);
406 padPlane->SetTiltingAngle(-2.0);
412 padPlane->SetNrows(12);
413 padPlane->SetLength(108.0);
414 padPlane->SetWidth(101.1);
415 padPlane->SetLengthOPad(8.0);
416 padPlane->SetWidthOPad(0.705);
417 padPlane->SetLengthIPad(9.0);
418 padPlane->SetWidthIPad(0.695);
419 padPlane->SetTiltingAngle(2.0);
423 padPlane->SetNrows(16);
424 padPlane->SetLength(129.0);
425 padPlane->SetWidth(101.1);
426 padPlane->SetLengthOPad(7.5);
427 padPlane->SetWidthOPad(0.705);
428 padPlane->SetLengthIPad(8.0);
429 padPlane->SetWidthIPad(0.695);
430 padPlane->SetTiltingAngle(2.0);
436 padPlane->SetNrows(12);
437 padPlane->SetLength(108.0);
438 padPlane->SetWidth(105.5);
439 padPlane->SetLengthOPad(8.0);
440 padPlane->SetWidthOPad(0.775);
441 padPlane->SetLengthIPad(9.0);
442 padPlane->SetWidthIPad(0.725);
443 padPlane->SetTiltingAngle(-2.0);
447 padPlane->SetNrows(16);
448 padPlane->SetLength(136.0);
449 padPlane->SetWidth(105.5);
450 padPlane->SetLengthOPad(7.5);
451 padPlane->SetWidthOPad(0.775);
452 padPlane->SetLengthIPad(8.5);
453 padPlane->SetWidthIPad(0.725);
454 padPlane->SetTiltingAngle(-2.0);
460 padPlane->SetNrows(12);
461 padPlane->SetLength(108.0);
462 padPlane->SetWidth(109.9);
463 padPlane->SetLengthOPad(8.0);
464 padPlane->SetWidthOPad(0.845);
465 padPlane->SetLengthIPad(9.0);
466 padPlane->SetWidthIPad(0.755);
467 padPlane->SetTiltingAngle(2.0);
471 padPlane->SetNrows(16);
472 padPlane->SetLength(143.0);
473 padPlane->SetWidth(109.9);
474 padPlane->SetLengthOPad(7.5);
475 padPlane->SetWidthOPad(0.845);
476 padPlane->SetLengthIPad(9.0);
477 padPlane->SetWidthIPad(0.755);
478 padPlane->SetTiltingAngle(2.0);
484 padPlane->SetNrows(12);
485 padPlane->SetLength(108.0);
486 padPlane->SetWidth(114.4);
487 padPlane->SetLengthOPad(8.0);
488 padPlane->SetWidthOPad(0.965);
489 padPlane->SetLengthIPad(9.0);
490 padPlane->SetWidthIPad(0.785);
491 padPlane->SetTiltingAngle(-2.0);
495 padPlane->SetNrows(16);
496 padPlane->SetLength(145.0);
497 padPlane->SetWidth(114.4);
498 padPlane->SetLengthOPad(8.5);
499 padPlane->SetWidthOPad(0.965);
500 padPlane->SetLengthIPad(9.0);
501 padPlane->SetWidthIPad(0.785);
502 padPlane->SetTiltingAngle(-2.0);
508 // The positions of the borders of the pads
512 Double_t row = fClength[ilayer][istack] / 2.0
514 - padPlane->GetLengthRim();
515 for (Int_t ir = 0; ir < padPlane->GetNrows(); ir++) {
516 padPlane->SetPadRow(ir,row);
517 row -= padPlane->GetRowSpacing();
519 row -= padPlane->GetLengthOPad();
522 row -= padPlane->GetLengthIPad();
528 Double_t col = - fCwidth[ilayer] / 2.0
530 + padPlane->GetWidthRim();
531 for (Int_t ic = 0; ic < padPlane->GetNcols(); ic++) {
532 padPlane->SetPadCol(ic,col);
533 col += padPlane->GetColSpacing();
535 col += padPlane->GetWidthOPad();
538 col += padPlane->GetWidthIPad();
541 // Calculate the offset to translate from the local ROC system into
542 // the local supermodule system, which is used for clusters
543 Double_t rowTmp = fClength[ilayer][0]
544 + fClength[ilayer][1]
545 + fClength[ilayer][2] / 2.0;
546 for (Int_t jstack = 0; jstack < istack; jstack++) {
547 rowTmp -= fClength[ilayer][jstack];
549 padPlane->SetPadRowSMOffset(rowTmp - fClength[ilayer][istack]/2.0);
555 //_____________________________________________________________________________
556 void AliTRDgeometry::CreateGeometry(Int_t *idtmed)
559 // Create the TRD geometry
562 // Names of the TRD volumina (xx = detector number):
564 // Volume (Air) wrapping the readout chamber components
565 // UTxx includes: UAxx, UDxx, UFxx, UUxx
567 // Lower part of the readout chambers (drift volume + radiator)
568 // UAxx Aluminum frames (Al)
570 // Upper part of the readout chambers (readout plane + fee)
571 // UDxx Wacosit frames of amp. region (Wacosit)
572 // UFxx Aluminum frame of back panel (Al)
574 // Services on chambers (cooling, cables, MCMs, DCS boards, ...)
575 // UUxx Volume containing the services (Air)
577 // Material layers inside sensitive area:
578 // Name Description Mat. Thick. Dens. Radl. X/X_0
580 // URMYxx Mylar layers (x2) Mylar 0.0015 1.39 28.5464 0.005%
581 // URCBxx Carbon layer (x2) Carbon 0.0055 1.75 24.2824 0.023%
582 // URGLxx Glue on the carbon layers (x2) Araldite 0.0065 1.12 37.0664 0.018%
583 // URRHxx Rohacell layer (x2) Rohacell 0.8 0.075 536.005 0.149%
584 // URFBxx Fiber mat layer PP 3.186 0.068 649.727 0.490%
586 // UJxx Drift region Xe/CO2 3.0 0.00495 1792.37 0.167%
587 // UKxx Amplification region Xe/CO2 0.7 0.00495 1792.37 0.039%
588 // UWxx Wire planes (x2) Copper 0.00011 8.96 1.43503 0.008%
590 // UPPDxx Copper of pad plane Copper 0.0025 8.96 1.43503 0.174%
591 // UPPPxx PCB of pad plane G10 0.0356 2.0 14.9013 0.239%
592 // UPGLxx Glue on pad planes Araldite 0.0923 1.12 37.0664 0.249%
593 // + add. glue (ca. 600g) Araldite 0.0505 1.12 37.0663 0.107%
594 // UPCBxx Carbon fiber mats (x2) Carbon 0.019 1.75 24.2824 0.078%
595 // UPHCxx Honeycomb structure Aramide 2.0299 0.032 1198.84 0.169%
596 // UPPCxx PCB of readout board G10 0.0486 2.0 14.9013 0.326%
597 // UPRDxx Copper of readout board Copper 0.0057 8.96 1.43503 0.404%
598 // UPELxx Electronics + cables Copper 0.0029 8.96 1.43503 0.202%
601 const Int_t kNparTrd = 4;
602 const Int_t kNparCha = 3;
608 Float_t parTrd[kNparTrd];
609 Float_t parCha[kNparCha];
614 // There are three TRD volumes for the supermodules in order to accomodate
615 // the different arrangements in front of PHOS
616 // UTR1: Default supermodule
617 // UTR2: Supermodule in front of PHOS with double carbon cover
618 // UTR3: As UTR2, but w/o middle stack
620 // The mother volume for one sector (Air), full length in z-direction
621 // Provides material for side plates of super module
622 parTrd[0] = fgkSwidth1/2.0;
623 parTrd[1] = fgkSwidth2/2.0;
624 parTrd[2] = fgkSlength/2.0;
625 parTrd[3] = fgkSheight/2.0;
626 gMC->Gsvolu("UTR1","TRD1",idtmed[1302-1],parTrd,kNparTrd);
627 gMC->Gsvolu("UTR2","TRD1",idtmed[1302-1],parTrd,kNparTrd);
628 gMC->Gsvolu("UTR3","TRD1",idtmed[1302-1],parTrd,kNparTrd);
629 // The outer aluminum plates of the super module (Al)
630 parTrd[0] = fgkSwidth1/2.0;
631 parTrd[1] = fgkSwidth2/2.0;
632 parTrd[2] = fgkSlength/2.0;
633 parTrd[3] = fgkSheight/2.0;
634 gMC->Gsvolu("UTS1","TRD1",idtmed[1301-1],parTrd,kNparTrd);
635 gMC->Gsvolu("UTS2","TRD1",idtmed[1301-1],parTrd,kNparTrd);
636 gMC->Gsvolu("UTS3","TRD1",idtmed[1301-1],parTrd,kNparTrd);
637 // The inner part of the TRD mother volume for one sector (Air),
638 // full length in z-direction
639 parTrd[0] = fgkSwidth1/2.0 - fgkSMpltT;
640 parTrd[1] = fgkSwidth2/2.0 - fgkSMpltT;
641 parTrd[2] = fgkSlength/2.0;
642 parTrd[3] = fgkSheight/2.0 - fgkSMpltT;
643 gMC->Gsvolu("UTI1","TRD1",idtmed[1302-1],parTrd,kNparTrd);
644 gMC->Gsvolu("UTI2","TRD1",idtmed[1302-1],parTrd,kNparTrd);
645 gMC->Gsvolu("UTI3","TRD1",idtmed[1302-1],parTrd,kNparTrd);
647 // The inner part of the TRD mother volume for services in front
648 // of the supermodules (Air),
649 parTrd[0] = fgkSwidth1/2.0;
650 parTrd[1] = fgkSwidth2/2.0;
651 parTrd[2] = fgkFlength/2.0;
652 parTrd[3] = fgkSheight/2.0;
653 gMC->Gsvolu("UTF1","TRD1",idtmed[1302-1],parTrd,kNparTrd);
654 gMC->Gsvolu("UTF2","TRD1",idtmed[1302-1],parTrd,kNparTrd);
656 for (Int_t istack = 0; istack < kNstack; istack++) {
657 for (Int_t ilayer = 0; ilayer < kNlayer; ilayer++) {
659 Int_t iDet = GetDetectorSec(ilayer,istack);
661 // The lower part of the readout chambers (drift volume + radiator)
662 // The aluminum frames
663 sprintf(cTagV,"UA%02d",iDet);
664 parCha[0] = fCwidth[ilayer]/2.0;
665 parCha[1] = fClength[ilayer][istack]/2.0 - fgkHspace/2.0;
666 parCha[2] = fgkCraH/2.0 + fgkCdrH/2.0;
667 gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parCha,kNparCha);
668 // The additional aluminum on the frames
669 // This part has not the correct shape but is just supposed to
670 // represent the missing material. The correct form of the L-shaped
671 // profile would not fit into the alignable volume.
672 sprintf(cTagV,"UZ%02d",iDet);
673 parCha[0] = fgkCalWmod/2.0;
674 parCha[1] = fClength[ilayer][istack]/2.0 - fgkHspace/2.0;
675 parCha[2] = fgkCalHmod/2.0;
676 gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parCha,kNparCha);
677 // The additional Wacosit on the frames
678 sprintf(cTagV,"UP%02d",iDet);
679 parCha[0] = fgkCwsW/2.0;
680 parCha[1] = fClength[ilayer][istack]/2.0 - fgkHspace/2.0;
681 parCha[2] = fgkCwsH/2.0;
682 gMC->Gsvolu(cTagV,"BOX ",idtmed[1307-1],parCha,kNparCha);
683 // The Wacosit frames
684 sprintf(cTagV,"UB%02d",iDet);
685 parCha[0] = fCwidth[ilayer]/2.0 - fgkCalT;
688 gMC->Gsvolu(cTagV,"BOX ",idtmed[1307-1],parCha,kNparCha);
689 // The glue around the radiator
690 sprintf(cTagV,"UX%02d",iDet);
691 parCha[0] = fCwidth[ilayer]/2.0 - fgkCalT - fgkCclsT;
692 parCha[1] = fClength[ilayer][istack]/2.0 - fgkHspace/2.0 - fgkCclfT;
693 parCha[2] = fgkCraH/2.0;
694 gMC->Gsvolu(cTagV,"BOX ",idtmed[1311-1],parCha,kNparCha);
695 // The inner part of radiator (air)
696 sprintf(cTagV,"UC%02d",iDet);
697 parCha[0] = fCwidth[ilayer]/2.0 - fgkCalT - fgkCclsT - fgkCglT;
698 parCha[1] = fClength[ilayer][istack]/2.0 - fgkHspace/2.0 - fgkCclfT - fgkCglT;
700 gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
702 // The upper part of the readout chambers (amplification volume)
703 // The Wacosit frames
704 sprintf(cTagV,"UD%02d",iDet);
705 parCha[0] = fCwidth[ilayer]/2.0 + fgkCroW;
706 parCha[1] = fClength[ilayer][istack]/2.0 - fgkHspace/2.0;
707 parCha[2] = fgkCamH/2.0;
708 gMC->Gsvolu(cTagV,"BOX ",idtmed[1307-1],parCha,kNparCha);
709 // The inner part of the Wacosit frame (air)
710 sprintf(cTagV,"UE%02d",iDet);
711 parCha[0] = fCwidth[ilayer]/2.0 + fgkCroW - fgkCcuTb;
712 parCha[1] = fClength[ilayer][istack]/2.0 - fgkHspace/2.0 - fgkCcuTa;
714 gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
716 // The back panel, including pad plane and readout boards
717 // The aluminum frames
718 sprintf(cTagV,"UF%02d",iDet);
719 parCha[0] = fCwidth[ilayer]/2.0 + fgkCroW;
720 parCha[1] = fClength[ilayer][istack]/2.0 - fgkHspace/2.0;
721 parCha[2] = fgkCroH/2.0;
722 gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parCha,kNparCha);
723 // The inner part of the aluminum frames
724 sprintf(cTagV,"UG%02d",iDet);
725 parCha[0] = fCwidth[ilayer]/2.0 + fgkCroW - fgkCauT;
726 parCha[1] = fClength[ilayer][istack]/2.0 - fgkHspace/2.0 - fgkCauT;
728 gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
731 // The material layers inside the chambers
734 // Mylar layer (radiator)
737 parCha[2] = fgkRMyThick/2.0;
738 sprintf(cTagV,"URMY%02d",iDet);
739 gMC->Gsvolu(cTagV,"BOX ",idtmed[1327-1],parCha,kNparCha);
740 // Carbon layer (radiator)
743 parCha[2] = fgkRCbThick/2.0;
744 sprintf(cTagV,"URCB%02d",iDet);
745 gMC->Gsvolu(cTagV,"BOX ",idtmed[1326-1],parCha,kNparCha);
746 // Araldite layer (radiator)
749 parCha[2] = fgkRGlThick/2.0;
750 sprintf(cTagV,"URGL%02d",iDet);
751 gMC->Gsvolu(cTagV,"BOX ",idtmed[1311-1],parCha,kNparCha);
752 // Rohacell layer (radiator)
755 parCha[2] = fgkRRhThick/2.0;
756 sprintf(cTagV,"URRH%02d",iDet);
757 gMC->Gsvolu(cTagV,"BOX ",idtmed[1315-1],parCha,kNparCha);
758 // Fiber layer (radiator)
761 parCha[2] = fgkRFbThick/2.0;
762 sprintf(cTagV,"URFB%02d",iDet);
763 gMC->Gsvolu(cTagV,"BOX ",idtmed[1328-1],parCha,kNparCha);
765 // Xe/Isobutane layer (drift volume)
766 parCha[0] = fCwidth[ilayer]/2.0 - fgkCalT - fgkCclsT;
767 parCha[1] = fClength[ilayer][istack]/2.0 - fgkHspace/2.0 - fgkCclfT;
768 parCha[2] = fgkDrThick/2.0;
769 sprintf(cTagV,"UJ%02d",iDet);
770 gMC->Gsvolu(cTagV,"BOX ",idtmed[1309-1],parCha,kNparCha);
772 // Xe/Isobutane layer (amplification volume)
775 parCha[2] = fgkAmThick/2.0;
776 sprintf(cTagV,"UK%02d",iDet);
777 gMC->Gsvolu(cTagV,"BOX ",idtmed[1309-1],parCha,kNparCha);
778 // Cu layer (wire plane)
781 parCha[2] = fgkWrThick/2.0;
782 sprintf(cTagV,"UW%02d",iDet);
783 gMC->Gsvolu(cTagV,"BOX ",idtmed[1303-1],parCha,kNparCha);
785 // Cu layer (pad plane)
788 parCha[2] = fgkPPdThick/2.0;
789 sprintf(cTagV,"UPPD%02d",iDet);
790 gMC->Gsvolu(cTagV,"BOX ",idtmed[1305-1],parCha,kNparCha);
791 // G10 layer (pad plane)
794 parCha[2] = fgkPPpThick/2.0;
795 sprintf(cTagV,"UPPP%02d",iDet);
796 gMC->Gsvolu(cTagV,"BOX ",idtmed[1313-1],parCha,kNparCha);
797 // Araldite layer (glue)
800 parCha[2] = fgkPGlThick/2.0;
801 sprintf(cTagV,"UPGL%02d",iDet);
802 gMC->Gsvolu(cTagV,"BOX ",idtmed[1311-1],parCha,kNparCha);
803 // Carbon layer (carbon fiber mats)
806 parCha[2] = fgkPCbThick/2.0;
807 sprintf(cTagV,"UPCB%02d",iDet);
808 gMC->Gsvolu(cTagV,"BOX ",idtmed[1326-1],parCha,kNparCha);
809 // Aramide layer (honeycomb)
812 parCha[2] = fgkPHcThick/2.0;
813 sprintf(cTagV,"UPHC%02d",iDet);
814 gMC->Gsvolu(cTagV,"BOX ",idtmed[1310-1],parCha,kNparCha);
815 // G10 layer (PCB readout board)
818 parCha[2] = fgkPPcThick/2;
819 sprintf(cTagV,"UPPC%02d",iDet);
820 gMC->Gsvolu(cTagV,"BOX ",idtmed[1313-1],parCha,kNparCha);
821 // Cu layer (traces in readout board)
824 parCha[2] = fgkPRbThick/2.0;
825 sprintf(cTagV,"UPRB%02d",iDet);
826 gMC->Gsvolu(cTagV,"BOX ",idtmed[1306-1],parCha,kNparCha);
827 // Cu layer (other material on in readout board, incl. screws)
830 parCha[2] = fgkPElThick/2.0;
831 sprintf(cTagV,"UPEL%02d",iDet);
832 gMC->Gsvolu(cTagV,"BOX ",idtmed[1304-1],parCha,kNparCha);
835 // Position the layers in the chambers
841 // Mylar layers (radiator)
842 zpos = fgkRMyThick/2.0 - fgkCraH/2.0;
843 sprintf(cTagV,"URMY%02d",iDet);
844 sprintf(cTagM,"UC%02d",iDet);
845 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
846 zpos = -fgkRMyThick/2.0 + fgkCraH/2.0;
847 sprintf(cTagV,"URMY%02d",iDet);
848 sprintf(cTagM,"UC%02d",iDet);
849 gMC->Gspos(cTagV,2,cTagM,xpos,ypos,zpos,0,"ONLY");
850 // Carbon layers (radiator)
851 zpos = fgkRCbThick/2.0 + fgkRMyThick - fgkCraH/2.0;
852 sprintf(cTagV,"URCB%02d",iDet);
853 sprintf(cTagM,"UC%02d",iDet);
854 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
855 zpos = -fgkRCbThick/2.0 - fgkRMyThick + fgkCraH/2.0;
856 sprintf(cTagV,"URCB%02d",iDet);
857 sprintf(cTagM,"UC%02d",iDet);
858 gMC->Gspos(cTagV,2,cTagM,xpos,ypos,zpos,0,"ONLY");
859 // Carbon layers (radiator)
860 zpos = fgkRGlThick/2.0 + fgkRCbThick + fgkRMyThick - fgkCraH/2.0;
861 sprintf(cTagV,"URGL%02d",iDet);
862 sprintf(cTagM,"UC%02d",iDet);
863 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
864 zpos = -fgkRGlThick/2.0 - fgkRCbThick - fgkRMyThick + fgkCraH/2.0;
865 sprintf(cTagV,"URGL%02d",iDet);
866 sprintf(cTagM,"UC%02d",iDet);
867 gMC->Gspos(cTagV,2,cTagM,xpos,ypos,zpos,0,"ONLY");
868 // Rohacell layers (radiator)
869 zpos = fgkRRhThick/2.0 + fgkRGlThick + fgkRCbThick + fgkRMyThick - fgkCraH/2.0;
870 sprintf(cTagV,"URRH%02d",iDet);
871 sprintf(cTagM,"UC%02d",iDet);
872 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
873 zpos = -fgkRRhThick/2.0 - fgkRGlThick - fgkRCbThick - fgkRMyThick + fgkCraH/2.0;
874 sprintf(cTagV,"URRH%02d",iDet);
875 sprintf(cTagM,"UC%02d",iDet);
876 gMC->Gspos(cTagV,2,cTagM,xpos,ypos,zpos,0,"ONLY");
877 // Fiber layers (radiator)
879 sprintf(cTagV,"URFB%02d",iDet);
880 sprintf(cTagM,"UC%02d",iDet);
881 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
883 // Xe/Isobutane layer (drift volume)
885 sprintf(cTagV,"UJ%02d",iDet);
886 sprintf(cTagM,"UB%02d",iDet);
887 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
890 // Xe/Isobutane layer (amplification volume)
892 sprintf(cTagV,"UK%02d",iDet);
893 sprintf(cTagM,"UE%02d",iDet);
894 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
895 // Cu layer (wire planes inside amplification volume)
897 sprintf(cTagV,"UW%02d",iDet);
898 sprintf(cTagM,"UK%02d",iDet);
899 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
901 sprintf(cTagV,"UW%02d",iDet);
902 sprintf(cTagM,"UK%02d",iDet);
903 gMC->Gspos(cTagV,2,cTagM,xpos,ypos,zpos,0,"ONLY");
905 // Back panel + pad plane + readout part
906 // Cu layer (pad plane)
907 zpos = fgkPPdThick/2.0 - fgkCroH/2.0;
908 sprintf(cTagV,"UPPD%02d",iDet);
909 sprintf(cTagM,"UG%02d",iDet);
910 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
911 // G10 layer (pad plane)
912 zpos = fgkPPpThick/2.0 + fgkPPdThick - fgkCroH/2.0;
913 sprintf(cTagV,"UPPP%02d",iDet);
914 sprintf(cTagM,"UG%02d",iDet);
915 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
916 // Araldite layer (glue)
917 zpos = fgkPGlThick/2.0 + fgkPPpThick + fgkPPdThick - fgkCroH/2.0;
918 sprintf(cTagV,"UPGL%02d",iDet);
919 sprintf(cTagM,"UG%02d",iDet);
920 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
921 // Carbon layers (carbon fiber mats)
922 zpos = fgkPCbThick/2.0 + fgkPGlThick + fgkPPpThick + fgkPPdThick - fgkCroH/2.0;
923 sprintf(cTagV,"UPCB%02d",iDet);
924 sprintf(cTagM,"UG%02d",iDet);
925 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
926 zpos = -fgkPCbThick/2.0 - fgkPPcThick - fgkPRbThick - fgkPElThick + fgkCroH/2.0;
927 sprintf(cTagV,"UPCB%02d",iDet);
928 sprintf(cTagM,"UG%02d",iDet);
929 gMC->Gspos(cTagV,2,cTagM,xpos,ypos,zpos,0,"ONLY");
930 // Aramide layer (honeycomb)
931 zpos = fgkPHcThick/2.0 + fgkPCbThick + fgkPGlThick + fgkPPpThick + fgkPPdThick - fgkCroH/2.0;
932 sprintf(cTagV,"UPHC%02d",iDet);
933 sprintf(cTagM,"UG%02d",iDet);
934 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
935 // G10 layer (PCB readout board)
936 zpos = -fgkPPcThick/2.0 - fgkPRbThick - fgkPElThick + fgkCroH/2.0;
937 sprintf(cTagV,"UPPC%02d",iDet);
938 sprintf(cTagM,"UG%02d",iDet);
939 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
940 // Cu layer (traces in readout board)
941 zpos = -fgkPRbThick/2.0 - fgkPElThick + fgkCroH/2.0;
942 sprintf(cTagV,"UPRB%02d",iDet);
943 sprintf(cTagM,"UG%02d",iDet);
944 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
945 // Cu layer (other materials on readout board, incl. screws)
946 zpos = -fgkPElThick/2.0 + fgkCroH/2.0;
947 sprintf(cTagV,"UPEL%02d",iDet);
948 sprintf(cTagM,"UG%02d",iDet);
949 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
951 // Position the inner volumes of the chambers in the frames
955 // The inner part of the radiator (air)
957 sprintf(cTagV,"UC%02d",iDet);
958 sprintf(cTagM,"UX%02d",iDet);
959 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
960 // The glue around the radiator
961 zpos = fgkCraH/2.0 - fgkCdrH/2.0 - fgkCraH/2.0;
962 sprintf(cTagV,"UX%02d",iDet);
963 sprintf(cTagM,"UB%02d",iDet);
964 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
965 // The lower Wacosit frame inside the aluminum frame
967 sprintf(cTagV,"UB%02d",iDet);
968 sprintf(cTagM,"UA%02d",iDet);
969 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
971 // The inside of the upper Wacosit frame
973 sprintf(cTagV,"UE%02d",iDet);
974 sprintf(cTagM,"UD%02d",iDet);
975 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
977 // The inside of the upper aluminum frame
979 sprintf(cTagV,"UG%02d",iDet);
980 sprintf(cTagM,"UF%02d",iDet);
981 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
986 // Create the volumes of the super module frame
989 // Create the volumes of the services
990 CreateServices(idtmed);
992 for (Int_t istack = 0; istack < kNstack; istack++) {
993 for (Int_t ilayer = 0; ilayer < kNlayer; ilayer++) {
994 AssembleChamber(ilayer,istack);
1001 gMC->Gspos("UTI1",1,"UTS1",xpos,ypos,zpos,0,"ONLY");
1002 gMC->Gspos("UTI2",1,"UTS2",xpos,ypos,zpos,0,"ONLY");
1003 gMC->Gspos("UTI3",1,"UTS3",xpos,ypos,zpos,0,"ONLY");
1008 gMC->Gspos("UTS1",1,"UTR1",xpos,ypos,zpos,0,"ONLY");
1009 gMC->Gspos("UTS2",1,"UTR2",xpos,ypos,zpos,0,"ONLY");
1010 gMC->Gspos("UTS3",1,"UTR3",xpos,ypos,zpos,0,"ONLY");
1012 // Put the TRD volumes into the space frame mother volumes
1013 // if enabled via status flag
1017 for (Int_t isector = 0; isector < kNsector; isector++) {
1018 if (GetSMstatus(isector)) {
1019 sprintf(cTagV,"BTRD%d",isector);
1024 // Double carbon, w/o middle stack
1025 gMC->Gspos("UTR3",1,cTagV,xpos,ypos,zpos,0,"ONLY");
1029 // Double carbon, all stacks
1030 gMC->Gspos("UTR2",1,cTagV,xpos,ypos,zpos,0,"ONLY");
1033 // Standard supermodule
1034 gMC->Gspos("UTR1",1,cTagV,xpos,ypos,zpos,0,"ONLY");
1039 // Put the TRD volumes into the space frame mother volumes
1040 // if enabled via status flag
1042 ypos = 0.5*fgkSlength + 0.5*fgkFlength;
1044 for (Int_t isector = 0; isector < kNsector; isector++) {
1045 if (GetSMstatus(isector)) {
1046 sprintf(cTagV,"BTRD%d",isector);
1047 gMC->Gspos("UTF1",1,cTagV,xpos, ypos,zpos,0,"ONLY");
1048 gMC->Gspos("UTF2",1,cTagV,xpos,-ypos,zpos,0,"ONLY");
1054 //_____________________________________________________________________________
1055 void AliTRDgeometry::CreateFrame(Int_t *idtmed)
1058 // Create the geometry of the frame of the supermodule
1060 // Names of the TRD services volumina
1062 // USRL Support rails for the chambers (Al)
1063 // USxx Support cross bars between the chambers (Al)
1064 // USHx Horizontal connection between the cross bars (Al)
1065 // USLx Long corner ledges (Al)
1077 const Int_t kNparTRD = 4;
1078 Float_t parTRD[kNparTRD];
1079 const Int_t kNparBOX = 3;
1080 Float_t parBOX[kNparBOX];
1081 const Int_t kNparTRP = 11;
1082 Float_t parTRP[kNparTRP];
1084 // The rotation matrices
1085 const Int_t kNmatrix = 7;
1086 Int_t matrix[kNmatrix];
1087 gMC->Matrix(matrix[0], 100.0, 0.0, 90.0, 90.0, 10.0, 0.0);
1088 gMC->Matrix(matrix[1], 80.0, 0.0, 90.0, 90.0, 10.0, 180.0);
1089 gMC->Matrix(matrix[2], 90.0, 0.0, 0.0, 0.0, 90.0, 90.0);
1090 gMC->Matrix(matrix[3], 90.0, 180.0, 0.0, 180.0, 90.0, 90.0);
1091 gMC->Matrix(matrix[4], 170.0, 0.0, 80.0, 0.0, 90.0, 90.0);
1092 gMC->Matrix(matrix[5], 170.0, 180.0, 80.0, 180.0, 90.0, 90.0);
1093 gMC->Matrix(matrix[6], 180.0, 180.0, 90.0, 180.0, 90.0, 90.0);
1096 // The carbon inserts in the top/bottom aluminum plates
1099 const Int_t kNparCrb = 3;
1100 Float_t parCrb[kNparCrb];
1104 gMC->Gsvolu("USCR","BOX ",idtmed[1326-1],parCrb,0);
1105 // Bottom 1 (all sectors)
1106 parCrb[0] = 77.49/2.0;
1107 parCrb[1] = 104.60/2.0;
1108 parCrb[2] = fgkSMpltT/2.0;
1111 zpos = fgkSMpltT/2.0 - fgkSheight/2.0;
1112 gMC->Gsposp("USCR", 1,"UTS1", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1113 gMC->Gsposp("USCR", 2,"UTS2", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1114 gMC->Gsposp("USCR", 3,"UTS3", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1115 // Bottom 2 (all sectors)
1116 parCrb[0] = 77.49/2.0;
1117 parCrb[1] = 55.80/2.0;
1118 parCrb[2] = fgkSMpltT/2.0;
1121 zpos = fgkSMpltT/2.0 - fgkSheight/2.0;
1122 gMC->Gsposp("USCR", 4,"UTS1", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1123 gMC->Gsposp("USCR", 5,"UTS2", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1124 gMC->Gsposp("USCR", 6,"UTS3", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1125 gMC->Gsposp("USCR", 7,"UTS1", xpos,-ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1126 gMC->Gsposp("USCR", 8,"UTS2", xpos,-ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1127 gMC->Gsposp("USCR", 9,"UTS3", xpos,-ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1128 // Bottom 3 (all sectors)
1129 parCrb[0] = 77.49/2.0;
1130 parCrb[1] = 56.00/2.0;
1131 parCrb[2] = fgkSMpltT/2.0;
1134 zpos = fgkSMpltT/2.0 - fgkSheight/2.0;
1135 gMC->Gsposp("USCR",10,"UTS1", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1136 gMC->Gsposp("USCR",11,"UTS2", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1137 gMC->Gsposp("USCR",12,"UTS3", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1138 gMC->Gsposp("USCR",13,"UTS1", xpos,-ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1139 gMC->Gsposp("USCR",14,"UTS2", xpos,-ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1140 gMC->Gsposp("USCR",15,"UTS3", xpos,-ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1141 // Bottom 4 (all sectors)
1142 parCrb[0] = 77.49/2.0;
1143 parCrb[1] = 118.00/2.0;
1144 parCrb[2] = fgkSMpltT/2.0;
1147 zpos = fgkSMpltT/2.0 - fgkSheight/2.0;
1148 gMC->Gsposp("USCR",16,"UTS1", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1149 gMC->Gsposp("USCR",17,"UTS2", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1150 gMC->Gsposp("USCR",18,"UTS3", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1151 gMC->Gsposp("USCR",19,"UTS1", xpos,-ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1152 gMC->Gsposp("USCR",20,"UTS2", xpos,-ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1153 gMC->Gsposp("USCR",21,"UTS3", xpos,-ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1154 // Top 1 (only in front of PHOS)
1155 parCrb[0] = 111.48/2.0;
1156 parCrb[1] = 105.00/2.0;
1157 parCrb[2] = fgkSMpltT/2.0;
1160 zpos = fgkSMpltT/2.0 - fgkSheight/2.0;
1161 gMC->Gsposp("USCR",22,"UTS2", xpos, ypos,-zpos,0,"ONLY",parCrb,kNparCrb);
1162 gMC->Gsposp("USCR",23,"UTS3", xpos, ypos,-zpos,0,"ONLY",parCrb,kNparCrb);
1163 // Top 2 (only in front of PHOS)
1164 parCrb[0] = 111.48/2.0;
1165 parCrb[1] = 56.00/2.0;
1166 parCrb[2] = fgkSMpltT/2.0;
1169 zpos = fgkSMpltT/2.0 - fgkSheight/2.0;
1170 gMC->Gsposp("USCR",24,"UTS2", xpos, ypos,-zpos,0,"ONLY",parCrb,kNparCrb);
1171 gMC->Gsposp("USCR",25,"UTS3", xpos, ypos,-zpos,0,"ONLY",parCrb,kNparCrb);
1172 gMC->Gsposp("USCR",26,"UTS2", xpos,-ypos,-zpos,0,"ONLY",parCrb,kNparCrb);
1173 gMC->Gsposp("USCR",27,"UTS3", xpos,-ypos,-zpos,0,"ONLY",parCrb,kNparCrb);
1176 // The chamber support rails
1179 const Float_t kSRLhgt = 2.00;
1180 const Float_t kSRLwidA = 2.3;
1181 const Float_t kSRLwidB = 1.947;
1182 const Float_t kSRLdst = 1.135;
1183 const Int_t kNparSRL = 11;
1184 Float_t parSRL[kNparSRL];
1185 // Trapezoidal shape
1186 parSRL[ 0] = fgkSlength/2.0;
1189 parSRL[ 3] = kSRLhgt /2.0;
1190 parSRL[ 4] = kSRLwidB /2.0;
1191 parSRL[ 5] = kSRLwidA /2.0;
1193 parSRL[ 7] = kSRLhgt /2.0;
1194 parSRL[ 8] = kSRLwidB /2.0;
1195 parSRL[ 9] = kSRLwidA /2.0;
1197 gMC->Gsvolu("USRL","TRAP",idtmed[1301-1],parSRL,kNparSRL);
1202 for (ilayer = 1; ilayer < kNlayer; ilayer++) {
1203 xpos = fCwidth[ilayer]/2.0 + kSRLwidA/2.0 + kSRLdst;
1205 zpos = fgkVrocsm + fgkSMpltT - fgkCalZpos - fgkSheight/2.0
1206 + fgkCraH + fgkCdrH - fgkCalH - kSRLhgt/2.0
1207 + ilayer * (fgkCH + fgkVspace);
1208 gMC->Gspos("USRL",ilayer+1 ,"UTI1", xpos,ypos,zpos,matrix[2],"ONLY");
1209 gMC->Gspos("USRL",ilayer+1+ kNlayer,"UTI1",-xpos,ypos,zpos,matrix[3],"ONLY");
1210 gMC->Gspos("USRL",ilayer+1+2*kNlayer,"UTI2", xpos,ypos,zpos,matrix[2],"ONLY");
1211 gMC->Gspos("USRL",ilayer+1+3*kNlayer,"UTI2",-xpos,ypos,zpos,matrix[3],"ONLY");
1212 gMC->Gspos("USRL",ilayer+1+4*kNlayer,"UTI3", xpos,ypos,zpos,matrix[2],"ONLY");
1213 gMC->Gspos("USRL",ilayer+1+5*kNlayer,"UTI3",-xpos,ypos,zpos,matrix[3],"ONLY");
1217 // The cross bars between the chambers
1220 const Float_t kSCBwid = 1.0;
1221 const Float_t kSCBthk = 2.0;
1222 const Float_t kSCHhgt = 0.3;
1224 const Int_t kNparSCB = 3;
1225 Float_t parSCB[kNparSCB];
1226 parSCB[1] = kSCBwid/2.0;
1227 parSCB[2] = fgkCH /2.0 + fgkVspace/2.0 - kSCHhgt;
1229 const Int_t kNparSCI = 3;
1230 Float_t parSCI[kNparSCI];
1236 for (ilayer = 0; ilayer < kNlayer; ilayer++) {
1238 // The aluminum of the cross bars
1239 parSCB[0] = fCwidth[ilayer]/2.0 + kSRLdst/2.0;
1240 sprintf(cTagV,"USF%01d",ilayer);
1241 gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
1243 // The empty regions in the cross bars
1244 Float_t thkSCB = kSCBthk;
1248 parSCI[2] = parSCB[2] - thkSCB;
1249 parSCI[0] = parSCB[0]/4.0 - kSCBthk;
1250 sprintf(cTagV,"USI%01d",ilayer);
1251 gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parSCI,kNparSCI);
1253 sprintf(cTagV,"USI%01d",ilayer);
1254 sprintf(cTagM,"USF%01d",ilayer);
1257 xpos = parSCI[0] + thkSCB/2.0;
1258 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
1259 xpos = - parSCI[0] - thkSCB/2.0;
1260 gMC->Gspos(cTagV,2,cTagM,xpos,ypos,zpos,0,"ONLY");
1261 xpos = 3.0 * parSCI[0] + 1.5 * thkSCB;
1262 gMC->Gspos(cTagV,3,cTagM,xpos,ypos,zpos,0,"ONLY");
1263 xpos = - 3.0 * parSCI[0] - 1.5 * thkSCB;
1264 gMC->Gspos(cTagV,4,cTagM,xpos,ypos,zpos,0,"ONLY");
1266 sprintf(cTagV,"USF%01d",ilayer);
1268 zpos = fgkVrocsm + fgkSMpltT + parSCB[2] - fgkSheight/2.0
1269 + ilayer * (fgkCH + fgkVspace);
1271 ypos = fClength[ilayer][2]/2.0 + fClength[ilayer][1];
1272 gMC->Gspos(cTagV, 1,"UTI1", xpos,ypos,zpos,0,"ONLY");
1273 gMC->Gspos(cTagV, 3,"UTI2", xpos,ypos,zpos,0,"ONLY");
1274 gMC->Gspos(cTagV, 5,"UTI3", xpos,ypos,zpos,0,"ONLY");
1276 ypos = - fClength[ilayer][2]/2.0 - fClength[ilayer][1];
1277 gMC->Gspos(cTagV, 2,"UTI1", xpos,ypos,zpos,0,"ONLY");
1278 gMC->Gspos(cTagV, 4,"UTI2", xpos,ypos,zpos,0,"ONLY");
1279 gMC->Gspos(cTagV, 6,"UTI3", xpos,ypos,zpos,0,"ONLY");
1284 // The horizontal connections between the cross bars
1287 const Int_t kNparSCH = 3;
1288 Float_t parSCH[kNparSCH];
1290 for (ilayer = 1; ilayer < kNlayer-1; ilayer++) {
1292 parSCH[0] = fCwidth[ilayer]/2.0;
1293 parSCH[1] = (fClength[ilayer+1][2]/2.0 + fClength[ilayer+1][1]
1294 - fClength[ilayer ][2]/2.0 - fClength[ilayer ][1])/2.0;
1295 parSCH[2] = kSCHhgt/2.0;
1297 sprintf(cTagV,"USH%01d",ilayer);
1298 gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCH,kNparSCH);
1300 ypos = fClength[ilayer][2]/2.0 + fClength[ilayer][1] + parSCH[1];
1301 zpos = fgkVrocsm + fgkSMpltT - kSCHhgt/2.0 - fgkSheight/2.0
1302 + (ilayer+1) * (fgkCH + fgkVspace);
1303 gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
1304 gMC->Gspos(cTagV,3,"UTI2", xpos,ypos,zpos,0,"ONLY");
1305 gMC->Gspos(cTagV,5,"UTI3", xpos,ypos,zpos,0,"ONLY");
1307 gMC->Gspos(cTagV,2,"UTI1", xpos,ypos,zpos,0,"ONLY");
1308 gMC->Gspos(cTagV,4,"UTI2", xpos,ypos,zpos,0,"ONLY");
1309 gMC->Gspos(cTagV,6,"UTI3", xpos,ypos,zpos,0,"ONLY");
1314 // The aymmetric flat frame in the middle
1317 // The envelope volume (aluminum)
1318 parTRD[0] = 87.60/2.0;
1319 parTRD[1] = 114.00/2.0;
1320 parTRD[2] = 1.20/2.0;
1321 parTRD[3] = 71.30/2.0;
1322 gMC->Gsvolu("USDB","TRD1",idtmed[1301-1],parTRD,kNparTRD);
1323 // Empty spaces (air)
1324 parTRP[ 0] = 1.20/2.0;
1327 parTRP[ 3] = 27.00/2.0;
1328 parTRP[ 4] = 50.60/2.0;
1329 parTRP[ 5] = 5.00/2.0;
1331 parTRP[ 7] = 27.00/2.0;
1332 parTRP[ 8] = 50.60/2.0;
1333 parTRP[ 9] = 5.00/2.0;
1335 gMC->Gsvolu("USD1","TRAP",idtmed[1302-1],parTRP,kNparTRP);
1338 zpos = 27.00/2.0 - 71.3/2.0;
1339 gMC->Gspos("USD1",1,"USDB", xpos, ypos, zpos,matrix[2],"ONLY");
1340 // Empty spaces (air)
1341 parTRP[ 0] = 1.20/2.0;
1344 parTRP[ 3] = 33.00/2.0;
1345 parTRP[ 4] = 5.00/2.0;
1346 parTRP[ 5] = 62.10/2.0;
1348 parTRP[ 7] = 33.00/2.0;
1349 parTRP[ 8] = 5.00/2.0;
1350 parTRP[ 9] = 62.10/2.0;
1352 gMC->Gsvolu("USD2","TRAP",idtmed[1302-1],parTRP,kNparTRP);
1355 zpos = 71.3/2.0 - 33.0/2.0;
1356 gMC->Gspos("USD2",1,"USDB", xpos, ypos, zpos,matrix[2],"ONLY");
1357 // Empty spaces (air)
1358 parBOX[ 0] = 22.50/2.0;
1359 parBOX[ 1] = 1.20/2.0;
1360 parBOX[ 2] = 70.50/2.0;
1361 gMC->Gsvolu("USD3","BOX ",idtmed[1302-1],parBOX,kNparBOX);
1365 gMC->Gspos("USD3",1,"USDB", xpos, ypos, zpos, 0,"ONLY");
1366 // Empty spaces (air)
1367 parTRP[ 0] = 1.20/2.0;
1370 parTRP[ 3] = 25.50/2.0;
1371 parTRP[ 4] = 5.00/2.0;
1372 parTRP[ 5] = 65.00/2.0;
1374 parTRP[ 7] = 25.50/2.0;
1375 parTRP[ 8] = 5.00/2.0;
1376 parTRP[ 9] = 65.00/2.0;
1378 gMC->Gsvolu("USD4","TRAP",idtmed[1302-1],parTRP,kNparTRP);
1382 gMC->Gspos("USD4",1,"USDB", xpos, ypos, zpos,matrix[6],"ONLY");
1383 // Empty spaces (air)
1384 parTRP[ 0] = 1.20/2.0;
1387 parTRP[ 3] = 23.50/2.0;
1388 parTRP[ 4] = 63.50/2.0;
1389 parTRP[ 5] = 5.00/2.0;
1391 parTRP[ 7] = 23.50/2.0;
1392 parTRP[ 8] = 63.50/2.0;
1393 parTRP[ 9] = 5.00/2.0;
1395 gMC->Gsvolu("USD5","TRAP",idtmed[1302-1],parTRP,kNparTRP);
1399 gMC->Gspos("USD5",1,"USDB", xpos, ypos, zpos,matrix[5],"ONLY");
1400 // Empty spaces (air)
1401 parTRP[ 0] = 1.20/2.0;
1404 parTRP[ 3] = 70.50/2.0;
1405 parTRP[ 4] = 4.50/2.0;
1406 parTRP[ 5] = 16.50/2.0;
1408 parTRP[ 7] = 70.50/2.0;
1409 parTRP[ 8] = 4.50/2.0;
1410 parTRP[ 9] = 16.50/2.0;
1412 gMC->Gsvolu("USD6","TRAP",idtmed[1302-1],parTRP,kNparTRP);
1416 gMC->Gspos("USD6",1,"USDB", xpos, ypos, zpos,matrix[2],"ONLY");
1418 ypos = fClength[5][2]/2.0;
1420 gMC->Gspos("USDB",1,"UTI1", xpos, ypos, zpos, 0,"ONLY");
1421 gMC->Gspos("USDB",2,"UTI1", xpos,-ypos, zpos, 0,"ONLY");
1422 gMC->Gspos("USDB",3,"UTI2", xpos, ypos, zpos, 0,"ONLY");
1423 gMC->Gspos("USDB",4,"UTI2", xpos,-ypos, zpos, 0,"ONLY");
1424 gMC->Gspos("USDB",5,"UTI3", xpos, ypos, zpos, 0,"ONLY");
1425 gMC->Gspos("USDB",6,"UTI3", xpos,-ypos, zpos, 0,"ONLY");
1426 // Upper bar (aluminum)
1427 parBOX[0] = 95.00/2.0;
1428 parBOX[1] = 1.20/2.0;
1429 parBOX[2] = 3.00/2.0;
1430 gMC->Gsvolu("USD7","BOX ",idtmed[1301-1],parBOX,kNparBOX);
1432 ypos = fClength[5][2]/2.0;
1433 zpos = fgkSheight/2.0 - fgkSMpltT - 3.00/2.0;
1434 gMC->Gspos("USD7",1,"UTI1", xpos, ypos, zpos, 0,"ONLY");
1435 gMC->Gspos("USD7",2,"UTI1", xpos,-ypos, zpos, 0,"ONLY");
1436 gMC->Gspos("USD7",3,"UTI2", xpos, ypos, zpos, 0,"ONLY");
1437 gMC->Gspos("USD7",4,"UTI2", xpos,-ypos, zpos, 0,"ONLY");
1438 gMC->Gspos("USD7",5,"UTI3", xpos, ypos, zpos, 0,"ONLY");
1439 gMC->Gspos("USD7",6,"UTI3", xpos,-ypos, zpos, 0,"ONLY");
1440 // Lower bar (aluminum)
1441 parBOX[0] = 90.22/2.0;
1442 parBOX[1] = 1.20/2.0;
1443 parBOX[2] = 1.74/2.0;
1444 gMC->Gsvolu("USD8","BOX ",idtmed[1301-1],parBOX,kNparBOX);
1446 ypos = fClength[5][2]/2.0 - 0.1;
1447 zpos = -fgkSheight/2.0 + fgkSMpltT + 2.27;
1448 gMC->Gspos("USD8",1,"UTI1", xpos, ypos, zpos, 0,"ONLY");
1449 gMC->Gspos("USD8",2,"UTI1", xpos,-ypos, zpos, 0,"ONLY");
1450 gMC->Gspos("USD8",3,"UTI2", xpos, ypos, zpos, 0,"ONLY");
1451 gMC->Gspos("USD8",4,"UTI2", xpos,-ypos, zpos, 0,"ONLY");
1452 gMC->Gspos("USD8",5,"UTI3", xpos, ypos, zpos, 0,"ONLY");
1453 gMC->Gspos("USD8",6,"UTI3", xpos,-ypos, zpos, 0,"ONLY");
1454 // Lower bar (aluminum)
1455 parBOX[0] = 82.60/2.0;
1456 parBOX[1] = 1.20/2.0;
1457 parBOX[2] = 1.40/2.0;
1458 gMC->Gsvolu("USD9","BOX ",idtmed[1301-1],parBOX,kNparBOX);
1460 ypos = fClength[5][2]/2.0;
1461 zpos = -fgkSheight/2.0 + fgkSMpltT + 1.40/2.0;
1462 gMC->Gspos("USD9",1,"UTI1", xpos, ypos, zpos, 0,"ONLY");
1463 gMC->Gspos("USD9",2,"UTI1", xpos,-ypos, zpos, 0,"ONLY");
1464 gMC->Gspos("USD9",3,"UTI2", xpos, ypos, zpos, 0,"ONLY");
1465 gMC->Gspos("USD9",4,"UTI2", xpos,-ypos, zpos, 0,"ONLY");
1466 gMC->Gspos("USD9",5,"UTI3", xpos, ypos, zpos, 0,"ONLY");
1467 gMC->Gspos("USD9",6,"UTI3", xpos,-ypos, zpos, 0,"ONLY");
1468 // Front sheet (aluminum)
1469 parTRP[ 0] = 0.10/2.0;
1472 parTRP[ 3] = 74.50/2.0;
1473 parTRP[ 4] = 31.70/2.0;
1474 parTRP[ 5] = 44.00/2.0;
1476 parTRP[ 7] = 74.50/2.0;
1477 parTRP[ 8] = 31.70/2.0;
1478 parTRP[ 9] = 44.00/2.0;
1480 gMC->Gsvolu("USDF","TRAP",idtmed[1302-1],parTRP,kNparTRP);
1482 ypos = fClength[5][2]/2.0 + 1.20/2.0 + 0.10/2.0;
1484 gMC->Gspos("USDF",1,"UTI1", xpos, ypos, zpos,matrix[2],"ONLY");
1485 gMC->Gspos("USDF",2,"UTI1", xpos,-ypos, zpos,matrix[2],"ONLY");
1486 gMC->Gspos("USDF",3,"UTI2", xpos, ypos, zpos,matrix[2],"ONLY");
1487 gMC->Gspos("USDF",4,"UTI2", xpos,-ypos, zpos,matrix[2],"ONLY");
1488 gMC->Gspos("USDF",5,"UTI3", xpos, ypos, zpos,matrix[2],"ONLY");
1489 gMC->Gspos("USDF",6,"UTI3", xpos,-ypos, zpos,matrix[2],"ONLY");
1492 // The flat frame in front of the chambers
1495 // The envelope volume (aluminum)
1496 parTRD[0] = 90.00/2.0 - 0.1;
1497 parTRD[1] = 114.00/2.0 - 0.1;
1498 parTRD[2] = 1.50/2.0;
1499 parTRD[3] = 70.30/2.0;
1500 gMC->Gsvolu("USCB","TRD1",idtmed[1301-1],parTRD,kNparTRD);
1501 // Empty spaces (air)
1502 parTRD[0] = 87.00/2.0;
1503 parTRD[1] = 10.00/2.0;
1504 parTRD[2] = 1.50/2.0;
1505 parTRD[3] = 26.35/2.0;
1506 gMC->Gsvolu("USC1","TRD1",idtmed[1302-1],parTRD,kNparTRD);
1509 zpos = 26.35/2.0 - 70.3/2.0;
1510 gMC->Gspos("USC1",1,"USCB",xpos,ypos,zpos,0,"ONLY");
1511 // Empty spaces (air)
1512 parTRD[0] = 10.00/2.0;
1513 parTRD[1] = 111.00/2.0;
1514 parTRD[2] = 1.50/2.0;
1515 parTRD[3] = 35.05/2.0;
1516 gMC->Gsvolu("USC2","TRD1",idtmed[1302-1],parTRD,kNparTRD);
1519 zpos = 70.3/2.0 - 35.05/2.0;
1520 gMC->Gspos("USC2",1,"USCB",xpos,ypos,zpos,0,"ONLY");
1521 // Empty spaces (air)
1522 parTRP[ 0] = 1.50/2.0;
1525 parTRP[ 3] = 37.60/2.0;
1526 parTRP[ 4] = 63.90/2.0;
1527 parTRP[ 5] = 8.86/2.0;
1529 parTRP[ 7] = 37.60/2.0;
1530 parTRP[ 8] = 63.90/2.0;
1531 parTRP[ 9] = 8.86/2.0;
1533 gMC->Gsvolu("USC3","TRAP",idtmed[1302-1],parTRP,kNparTRP);
1537 gMC->Gspos("USC3",1,"USCB", xpos, ypos, zpos,matrix[4],"ONLY");
1538 gMC->Gspos("USC3",2,"USCB",-xpos, ypos, zpos,matrix[5],"ONLY");
1540 ypos = fClength[5][2]/2.0 + fClength[5][1] + fClength[5][0];
1542 gMC->Gspos("USCB",1,"UTI1", xpos, ypos, zpos, 0,"ONLY");
1543 gMC->Gspos("USCB",2,"UTI1", xpos,-ypos, zpos, 0,"ONLY");
1544 gMC->Gspos("USCB",3,"UTI2", xpos, ypos, zpos, 0,"ONLY");
1545 gMC->Gspos("USCB",4,"UTI2", xpos,-ypos, zpos, 0,"ONLY");
1546 gMC->Gspos("USCB",5,"UTI3", xpos, ypos, zpos, 0,"ONLY");
1547 gMC->Gspos("USCB",6,"UTI3", xpos,-ypos, zpos, 0,"ONLY");
1548 // Upper bar (aluminum)
1549 parBOX[0] = 95.00/2.0;
1550 parBOX[1] = 1.50/2.0;
1551 parBOX[2] = 3.00/2.0;
1552 gMC->Gsvolu("USC4","BOX ",idtmed[1301-1],parBOX,kNparBOX);
1554 ypos = fClength[5][2]/2.0 + fClength[5][1] + fClength[5][0];
1555 zpos = fgkSheight/2.0 - fgkSMpltT - 3.00/2.0;
1556 gMC->Gspos("USC4",1,"UTI1", xpos, ypos, zpos, 0,"ONLY");
1557 gMC->Gspos("USC4",2,"UTI1", xpos,-ypos, zpos, 0,"ONLY");
1558 gMC->Gspos("USC4",3,"UTI2", xpos, ypos, zpos, 0,"ONLY");
1559 gMC->Gspos("USC4",4,"UTI2", xpos,-ypos, zpos, 0,"ONLY");
1560 gMC->Gspos("USC4",5,"UTI3", xpos, ypos, zpos, 0,"ONLY");
1561 gMC->Gspos("USC4",6,"UTI3", xpos,-ypos, zpos, 0,"ONLY");
1562 // Lower bar (aluminum)
1563 parBOX[0] = 90.22/2.0;
1564 parBOX[1] = 1.50/2.0;
1565 parBOX[2] = 2.00/2.0;
1566 gMC->Gsvolu("USC5","BOX ",idtmed[1301-1],parBOX,kNparBOX);
1568 ypos = fClength[5][2]/2.0 + fClength[5][1] + fClength[5][0];
1569 zpos = -fgkSheight/2.0 + fgkSMpltT + 2.60;
1570 gMC->Gspos("USC5",1,"UTI1", xpos, ypos, zpos, 0,"ONLY");
1571 gMC->Gspos("USC5",2,"UTI1", xpos,-ypos, zpos, 0,"ONLY");
1572 gMC->Gspos("USC5",3,"UTI2", xpos, ypos, zpos, 0,"ONLY");
1573 gMC->Gspos("USC5",4,"UTI2", xpos,-ypos, zpos, 0,"ONLY");
1574 gMC->Gspos("USC5",5,"UTI3", xpos, ypos, zpos, 0,"ONLY");
1575 gMC->Gspos("USC5",6,"UTI3", xpos,-ypos, zpos, 0,"ONLY");
1576 // Lower bar (aluminum)
1577 parBOX[0] = 82.60/2.0;
1578 parBOX[1] = 1.50/2.0;
1579 parBOX[2] = 1.60/2.0;
1580 gMC->Gsvolu("USC6","BOX ",idtmed[1301-1],parBOX,kNparBOX);
1582 ypos = fClength[5][2]/2.0 + fClength[5][1] + fClength[5][0];
1583 zpos = -fgkSheight/2.0 + fgkSMpltT + 1.60/2.0;
1584 gMC->Gspos("USC6",1,"UTI1", xpos, ypos, zpos, 0,"ONLY");
1585 gMC->Gspos("USC6",2,"UTI1", xpos,-ypos, zpos, 0,"ONLY");
1586 gMC->Gspos("USC6",3,"UTI2", xpos, ypos, zpos, 0,"ONLY");
1587 gMC->Gspos("USC6",4,"UTI2", xpos,-ypos, zpos, 0,"ONLY");
1588 gMC->Gspos("USC6",5,"UTI3", xpos, ypos, zpos, 0,"ONLY");
1589 gMC->Gspos("USC6",6,"UTI3", xpos,-ypos, zpos, 0,"ONLY");
1592 // The long corner ledges
1595 const Int_t kNparSCL = 3;
1596 Float_t parSCL[kNparSCL];
1597 const Int_t kNparSCLb = 11;
1598 Float_t parSCLb[kNparSCLb];
1601 // Thickness of the corner ledges
1602 const Float_t kSCLthkUa = 0.6;
1603 const Float_t kSCLthkUb = 0.6;
1604 // Width of the corner ledges
1605 const Float_t kSCLwidUa = 3.2;
1606 const Float_t kSCLwidUb = 4.8;
1607 // Position of the corner ledges
1608 const Float_t kSCLposxUa = 0.7;
1609 const Float_t kSCLposxUb = 3.3;
1610 const Float_t kSCLposzUa = 1.65;
1611 const Float_t kSCLposzUb = 0.3;
1613 parSCL[0] = kSCLthkUa /2.0;
1614 parSCL[1] = fgkSlength/2.0;
1615 parSCL[2] = kSCLwidUa /2.0;
1616 gMC->Gsvolu("USL1","BOX ",idtmed[1301-1],parSCL,kNparSCL);
1617 xpos = fgkSwidth2/2.0 - fgkSMpltT - kSCLposxUa;
1619 zpos = fgkSheight/2.0 - fgkSMpltT - kSCLposzUa;
1620 gMC->Gspos("USL1",1,"UTI1", xpos,ypos,zpos,matrix[0],"ONLY");
1622 gMC->Gspos("USL1",2,"UTI1", xpos,ypos,zpos,matrix[1],"ONLY");
1624 parSCL[0] = kSCLwidUb /2.0;
1625 parSCL[1] = fgkSlength/2.0;
1626 parSCL[2] = kSCLthkUb /2.0;
1627 gMC->Gsvolu("USL2","BOX ",idtmed[1301-1],parSCL,kNparSCL);
1628 xpos = fgkSwidth2/2.0 - fgkSMpltT - kSCLposxUb;
1630 zpos = fgkSheight/2.0 - fgkSMpltT - kSCLposzUb;
1631 gMC->Gspos("USL2",1,"UTI1", xpos,ypos,zpos, 0,"ONLY");
1632 gMC->Gspos("USL2",3,"UTI2", xpos,ypos,zpos, 0,"ONLY");
1633 gMC->Gspos("USL2",5,"UTI3", xpos,ypos,zpos, 0,"ONLY");
1635 gMC->Gspos("USL2",2,"UTI1", xpos,ypos,zpos, 0,"ONLY");
1636 gMC->Gspos("USL2",4,"UTI2", xpos,ypos,zpos, 0,"ONLY");
1637 gMC->Gspos("USL2",6,"UTI3", xpos,ypos,zpos, 0,"ONLY");
1640 // Thickness of the corner ledges
1641 const Float_t kSCLthkLa = 2.464;
1642 const Float_t kSCLthkLb = 1.0;
1643 // Width of the corner ledges
1644 const Float_t kSCLwidLa = 8.3;
1645 const Float_t kSCLwidLb = 4.0;
1646 // Position of the corner ledges
1647 const Float_t kSCLposxLa = (3.0 * kSCLthkLb - kSCLthkLa) / 4.0 + 0.05;
1648 const Float_t kSCLposxLb = kSCLthkLb + kSCLwidLb/2.0 + 0.05;
1649 const Float_t kSCLposzLa = kSCLwidLa/2.0;
1650 const Float_t kSCLposzLb = kSCLthkLb/2.0;
1652 // Trapezoidal shape
1653 parSCLb[ 0] = fgkSlength/2.0;
1656 parSCLb[ 3] = kSCLwidLa /2.0;
1657 parSCLb[ 4] = kSCLthkLb /2.0;
1658 parSCLb[ 5] = kSCLthkLa /2.0;
1660 parSCLb[ 7] = kSCLwidLa /2.0;
1661 parSCLb[ 8] = kSCLthkLb /2.0;
1662 parSCLb[ 9] = kSCLthkLa /2.0;
1664 gMC->Gsvolu("USL3","TRAP",idtmed[1301-1],parSCLb,kNparSCLb);
1665 xpos = fgkSwidth1/2.0 - fgkSMpltT - kSCLposxLa;
1667 zpos = - fgkSheight/2.0 + fgkSMpltT + kSCLposzLa;
1668 gMC->Gspos("USL3",1,"UTI1", xpos,ypos,zpos,matrix[2],"ONLY");
1669 gMC->Gspos("USL3",3,"UTI2", xpos,ypos,zpos,matrix[2],"ONLY");
1670 gMC->Gspos("USL3",5,"UTI3", xpos,ypos,zpos,matrix[2],"ONLY");
1672 gMC->Gspos("USL3",2,"UTI1", xpos,ypos,zpos,matrix[3],"ONLY");
1673 gMC->Gspos("USL3",4,"UTI2", xpos,ypos,zpos,matrix[3],"ONLY");
1674 gMC->Gspos("USL3",6,"UTI3", xpos,ypos,zpos,matrix[3],"ONLY");
1676 parSCL[0] = kSCLwidLb /2.0;
1677 parSCL[1] = fgkSlength/2.0;
1678 parSCL[2] = kSCLthkLb /2.0;
1679 gMC->Gsvolu("USL4","BOX ",idtmed[1301-1],parSCL,kNparSCL);
1680 xpos = fgkSwidth1/2.0 - fgkSMpltT - kSCLposxLb;
1682 zpos = - fgkSheight/2.0 + fgkSMpltT + kSCLposzLb;
1683 gMC->Gspos("USL4",1,"UTI1", xpos,ypos,zpos, 0,"ONLY");
1684 gMC->Gspos("USL4",3,"UTI2", xpos,ypos,zpos, 0,"ONLY");
1685 gMC->Gspos("USL4",5,"UTI3", xpos,ypos,zpos, 0,"ONLY");
1687 gMC->Gspos("USL4",2,"UTI1", xpos,ypos,zpos, 0,"ONLY");
1688 gMC->Gspos("USL4",4,"UTI2", xpos,ypos,zpos, 0,"ONLY");
1689 gMC->Gspos("USL4",6,"UTI3", xpos,ypos,zpos, 0,"ONLY");
1692 // Aluminum plates in the front part of the super modules
1695 const Int_t kNparTrd = 4;
1696 Float_t parTrd[kNparTrd];
1697 parTrd[0] = fgkSwidth1/2.0 - 2.5;
1698 parTrd[1] = fgkSwidth2/2.0 - 2.5;
1699 parTrd[2] = fgkSMpltT /2.0;
1700 parTrd[3] = fgkSheight/2.0 - 1.0;
1701 gMC->Gsvolu("UTA1","TRD1",idtmed[1301-1],parTrd,kNparTrd);
1703 ypos = fgkSMpltT/2.0 - fgkFlength/2.0;
1705 gMC->Gspos("UTA1",1,"UTF1",xpos, ypos,zpos, 0,"ONLY");
1706 gMC->Gspos("UTA1",2,"UTF2",xpos,-ypos,zpos, 0,"ONLY");
1708 const Int_t kNparPlt = 3;
1709 Float_t parPlt[kNparPlt];
1713 gMC->Gsvolu("UTA2","BOX ",idtmed[1301-1],parPlt,0);
1716 zpos = fgkSheight/2.0 - fgkSMpltT/2.0;
1717 parPlt[0] = fgkSwidth2/2.0 - 0.2;
1718 parPlt[1] = fgkFlength/2.0;
1719 parPlt[2] = fgkSMpltT /2.0;
1720 gMC->Gsposp("UTA2",1,"UTF2",xpos,ypos,zpos
1721 , 0,"ONLY",parPlt,kNparPlt);
1722 xpos = (fgkSwidth1 + fgkSwidth2)/4.0 - fgkSMpltT/2.0 - 0.0016;
1725 parPlt[0] = fgkSMpltT /2.0;
1726 parPlt[1] = fgkFlength/2.0;
1727 parPlt[2] = fgkSheight/2.0;
1728 gMC->Gsposp("UTA2",2,"UTF2", xpos,ypos,zpos
1729 ,matrix[0],"ONLY",parPlt,kNparPlt);
1730 gMC->Gsposp("UTA2",3,"UTF2",-xpos,ypos,zpos
1731 ,matrix[1],"ONLY",parPlt,kNparPlt);
1733 // Additional aluminum bar
1734 parBOX[0] = 80.0/2.0;
1735 parBOX[1] = 1.0/2.0;
1736 parBOX[2] = 10.0/2.0;
1737 gMC->Gsvolu("UTA3","BOX ",idtmed[1301-1],parBOX,kNparBOX);
1739 ypos = 1.0/2.0 + fgkSMpltT - fgkFlength/2.0;
1740 zpos = fgkSheight/2.0 - 1.5 - 10.0/2.0;
1741 gMC->Gspos("UTA3",1,"UTF1", xpos, ypos, zpos, 0,"ONLY");
1742 gMC->Gspos("UTA3",2,"UTF2", xpos,-ypos, zpos, 0,"ONLY");
1746 //_____________________________________________________________________________
1747 void AliTRDgeometry::CreateServices(Int_t *idtmed)
1750 // Create the geometry of the services
1752 // Names of the TRD services volumina
1754 // UTC1 Cooling arterias (Al)
1755 // UTC2 Cooling arterias (Water)
1756 // UUxx Volumes for the services at the chambers (Air)
1757 // UMCM Readout MCMs (G10/Cu/Si)
1758 // UDCS DCSs boards (G10/Cu)
1759 // UTP1 Power bars (Cu)
1760 // UTCP Cooling pipes (Fe)
1761 // UTCH Cooling pipes (Water)
1762 // UTPL Power lines (Cu)
1763 // UTGD Gas distribution box (V2A)
1775 const Int_t kNparBox = 3;
1776 Float_t parBox[kNparBox];
1778 const Int_t kNparTube = 3;
1779 Float_t parTube[kNparTube];
1781 // Services inside the baby frame
1782 const Float_t kBBMdz = 223.0;
1783 const Float_t kBBSdz = 8.5;
1785 // Services inside the back frame
1786 const Float_t kBFMdz = 118.0;
1787 const Float_t kBFSdz = 8.5;
1789 // The rotation matrices
1790 const Int_t kNmatrix = 10;
1791 Int_t matrix[kNmatrix];
1792 gMC->Matrix(matrix[0], 100.0, 0.0, 90.0, 90.0, 10.0, 0.0); // rotation around y-axis
1793 gMC->Matrix(matrix[1], 80.0, 0.0, 90.0, 90.0, 10.0, 180.0); // rotation around y-axis
1794 gMC->Matrix(matrix[2], 0.0, 0.0, 90.0, 90.0, 90.0, 0.0);
1795 gMC->Matrix(matrix[3], 180.0, 0.0, 90.0, 90.0, 90.0, 180.0);
1796 gMC->Matrix(matrix[4], 90.0, 0.0, 0.0, 0.0, 90.0, 90.0);
1797 gMC->Matrix(matrix[5], 100.0, 0.0, 90.0, 270.0, 10.0, 0.0);
1798 gMC->Matrix(matrix[6], 80.0, 0.0, 90.0, 270.0, 10.0, 180.0);
1799 gMC->Matrix(matrix[7], 90.0, 10.0, 90.0, 100.0, 0.0, 0.0); // rotation around z-axis
1800 gMC->Matrix(matrix[8], 90.0, 350.0, 90.0, 80.0, 0.0, 0.0); // rotation around z-axis
1801 gMC->Matrix(matrix[9], 90.0, 90.0, 90.0, 180.0, 0.0, 0.0); // rotation around z-axis
1804 // The cooling arterias
1807 // Width of the cooling arterias
1808 const Float_t kCOLwid = 0.8;
1809 // Height of the cooling arterias
1810 const Float_t kCOLhgt = 6.5;
1811 // Positioning of the cooling
1812 const Float_t kCOLposx = 1.0;
1813 const Float_t kCOLposz = -1.2;
1814 // Thickness of the walls of the cooling arterias
1815 const Float_t kCOLthk = 0.1;
1816 const Int_t kNparCOL = 3;
1817 Float_t parCOL[kNparCOL];
1821 gMC->Gsvolu("UTC1","BOX ",idtmed[1308-1],parCOL,0);
1822 gMC->Gsvolu("UTC3","BOX ",idtmed[1308-1],parCOL,0);
1823 parCOL[0] = kCOLwid/2.0 - kCOLthk;
1825 parCOL[2] = kCOLhgt/2.0 - kCOLthk;
1826 gMC->Gsvolu("UTC2","BOX ",idtmed[1314-1],parCOL,kNparCOL);
1827 gMC->Gsvolu("UTC4","BOX ",idtmed[1314-1],parCOL,kNparCOL);
1832 gMC->Gspos("UTC2",1,"UTC1", xpos,ypos,zpos,0,"ONLY");
1833 gMC->Gspos("UTC4",1,"UTC3", xpos,ypos,zpos,0,"ONLY");
1835 for (ilayer = 1; ilayer < kNlayer; ilayer++) {
1837 // Along the chambers
1838 xpos = fCwidth[ilayer]/2.0 + kCOLwid/2.0 + kCOLposx;
1840 zpos = fgkVrocsm + fgkSMpltT - fgkCalZpos
1841 + kCOLhgt/2.0 - fgkSheight/2.0 + kCOLposz
1842 + ilayer * (fgkCH + fgkVspace);
1843 parCOL[0] = kCOLwid /2.0;
1844 parCOL[1] = fgkSlength/2.0;
1845 parCOL[2] = kCOLhgt /2.0;
1846 gMC->Gsposp("UTC1",ilayer ,"UTI1", xpos,ypos,zpos
1847 ,matrix[0],"ONLY",parCOL,kNparCOL);
1848 gMC->Gsposp("UTC1",ilayer+ kNlayer,"UTI1",-xpos,ypos,zpos
1849 ,matrix[1],"ONLY",parCOL,kNparCOL);
1850 gMC->Gsposp("UTC1",ilayer+6*kNlayer,"UTI2", xpos,ypos,zpos
1851 ,matrix[0],"ONLY",parCOL,kNparCOL);
1852 gMC->Gsposp("UTC1",ilayer+7*kNlayer,"UTI2",-xpos,ypos,zpos
1853 ,matrix[1],"ONLY",parCOL,kNparCOL);
1854 gMC->Gsposp("UTC1",ilayer+8*kNlayer ,"UTI3", xpos,ypos,zpos
1855 ,matrix[0],"ONLY",parCOL,kNparCOL);
1856 gMC->Gsposp("UTC1",ilayer+9*kNlayer,"UTI3",-xpos,ypos,zpos
1857 ,matrix[1],"ONLY",parCOL,kNparCOL);
1859 // Front of supermodules
1860 xpos = fCwidth[ilayer]/2.0 + kCOLwid/2.0 + kCOLposx;
1862 zpos = fgkVrocsm + fgkSMpltT - fgkCalZpos
1863 + kCOLhgt/2.0 - fgkSheight/2.0 + kCOLposz
1864 + ilayer * (fgkCH + fgkVspace);
1865 parCOL[0] = kCOLwid /2.0;
1866 parCOL[1] = fgkFlength/2.0;
1867 parCOL[2] = kCOLhgt /2.0;
1868 gMC->Gsposp("UTC3",ilayer+2*kNlayer,"UTF1", xpos,ypos,zpos
1869 ,matrix[0],"ONLY",parCOL,kNparCOL);
1870 gMC->Gsposp("UTC3",ilayer+3*kNlayer,"UTF1",-xpos,ypos,zpos
1871 ,matrix[1],"ONLY",parCOL,kNparCOL);
1872 gMC->Gsposp("UTC3",ilayer+4*kNlayer,"UTF2", xpos,ypos,zpos
1873 ,matrix[0],"ONLY",parCOL,kNparCOL);
1874 gMC->Gsposp("UTC3",ilayer+5*kNlayer,"UTF2",-xpos,ypos,zpos
1875 ,matrix[1],"ONLY",parCOL,kNparCOL);
1879 for (ilayer = 1; ilayer < kNlayer; ilayer++) {
1882 xpos = fCwidth[ilayer]/2.0 + kCOLwid/2.0 + kCOLposx - 2.5;
1883 ypos = kBBSdz/2.0 - kBBMdz/2.0;
1884 zpos = fgkVrocsm + fgkSMpltT - fgkCalZpos
1885 + kCOLhgt/2.0 - fgkSheight/2.0 + kCOLposz
1886 + ilayer * (fgkCH + fgkVspace);
1887 parCOL[0] = kCOLwid/2.0;
1888 parCOL[1] = kBBSdz /2.0;
1889 parCOL[2] = kCOLhgt/2.0;
1890 gMC->Gsposp("UTC3",ilayer+6*kNlayer,"BBTRD", xpos, ypos, zpos
1891 ,matrix[0],"ONLY",parCOL,kNparCOL);
1892 gMC->Gsposp("UTC3",ilayer+7*kNlayer,"BBTRD",-xpos, ypos, zpos
1893 ,matrix[1],"ONLY",parCOL,kNparCOL);
1897 for (ilayer = 1; ilayer < kNlayer; ilayer++) {
1900 xpos = fCwidth[ilayer]/2.0 + kCOLwid/2.0 + kCOLposx - 0.3;
1901 ypos = -kBFSdz/2.0 + kBFMdz/2.0;
1902 zpos = fgkVrocsm + fgkSMpltT - fgkCalZpos
1903 + kCOLhgt/2.0 - fgkSheight/2.0 + kCOLposz
1904 + ilayer * (fgkCH + fgkVspace);
1905 parCOL[0] = kCOLwid/2.0;
1906 parCOL[1] = kBFSdz /2.0;
1907 parCOL[2] = kCOLhgt/2.0;
1908 gMC->Gsposp("UTC3",ilayer+6*kNlayer,"BFTRD", xpos,ypos,zpos
1909 ,matrix[0],"ONLY",parCOL,kNparCOL);
1910 gMC->Gsposp("UTC3",ilayer+7*kNlayer,"BFTRD",-xpos,ypos,zpos
1911 ,matrix[1],"ONLY",parCOL,kNparCOL);
1915 // The upper most layer
1916 // Along the chambers
1917 xpos = fCwidth[5]/2.0 - kCOLhgt/2.0 - 1.3;
1919 zpos = fgkSheight/2.0 - fgkSMpltT - 0.4 - kCOLwid/2.0;
1920 parCOL[0] = kCOLwid /2.0;
1921 parCOL[1] = fgkSlength/2.0;
1922 parCOL[2] = kCOLhgt /2.0;
1923 gMC->Gsposp("UTC1",6 ,"UTI1", xpos,ypos,zpos
1924 ,matrix[3],"ONLY",parCOL,kNparCOL);
1925 gMC->Gsposp("UTC1",6+ kNlayer,"UTI1",-xpos,ypos,zpos
1926 ,matrix[3],"ONLY",parCOL,kNparCOL);
1927 gMC->Gsposp("UTC1",6+6*kNlayer,"UTI2", xpos,ypos,zpos
1928 ,matrix[3],"ONLY",parCOL,kNparCOL);
1929 gMC->Gsposp("UTC1",6+7*kNlayer,"UTI2",-xpos,ypos,zpos
1930 ,matrix[3],"ONLY",parCOL,kNparCOL);
1931 gMC->Gsposp("UTC1",6+8*kNlayer,"UTI3", xpos,ypos,zpos
1932 ,matrix[3],"ONLY",parCOL,kNparCOL);
1933 gMC->Gsposp("UTC1",6+9*kNlayer,"UTI3",-xpos,ypos,zpos
1934 ,matrix[3],"ONLY",parCOL,kNparCOL);
1935 // Front of supermodules
1936 xpos = fCwidth[5]/2.0 - kCOLhgt/2.0 - 1.3;
1938 zpos = fgkSheight/2.0 - fgkSMpltT - 0.4 - kCOLwid/2.0;
1939 parCOL[0] = kCOLwid /2.0;
1940 parCOL[1] = fgkFlength/2.0;
1941 parCOL[2] = kCOLhgt /2.0;
1942 gMC->Gsposp("UTC3",6+2*kNlayer,"UTF1", xpos,ypos,zpos
1943 ,matrix[3],"ONLY",parCOL,kNparCOL);
1944 gMC->Gsposp("UTC3",6+3*kNlayer,"UTF1",-xpos,ypos,zpos
1945 ,matrix[3],"ONLY",parCOL,kNparCOL);
1946 gMC->Gsposp("UTC3",6+4*kNlayer,"UTF2", xpos,ypos,zpos
1947 ,matrix[3],"ONLY",parCOL,kNparCOL);
1948 gMC->Gsposp("UTC3",6+5*kNlayer,"UTF2",-xpos,ypos,zpos
1949 ,matrix[3],"ONLY",parCOL,kNparCOL);
1951 xpos = fCwidth[5]/2.0 - kCOLhgt/2.0 - 3.1;
1952 ypos = kBBSdz/2.0 - kBBMdz/2.0;
1953 zpos = fgkSheight/2.0 - fgkSMpltT - 0.4 - kCOLwid/2.0;
1954 parCOL[0] = kCOLwid/2.0;
1955 parCOL[1] = kBBSdz /2.0;
1956 parCOL[2] = kCOLhgt/2.0;
1957 gMC->Gsposp("UTC3",6+6*kNlayer,"BBTRD", xpos, ypos, zpos
1958 ,matrix[3],"ONLY",parCOL,kNparCOL);
1959 gMC->Gsposp("UTC3",6+7*kNlayer,"BBTRD",-xpos, ypos, zpos
1960 ,matrix[3],"ONLY",parCOL,kNparCOL);
1962 xpos = fCwidth[5]/2.0 - kCOLhgt/2.0 - 1.3;
1963 ypos = -kBFSdz/2.0 + kBFMdz/2.0;
1964 zpos = fgkSheight/2.0 - fgkSMpltT - 0.4 - kCOLwid/2.0;
1965 parCOL[0] = kCOLwid/2.0;
1966 parCOL[1] = kBFSdz /2.0;
1967 parCOL[2] = kCOLhgt/2.0;
1968 gMC->Gsposp("UTC3",6+6*kNlayer,"BFTRD", xpos,ypos,zpos
1969 ,matrix[3],"ONLY",parCOL,kNparCOL);
1970 gMC->Gsposp("UTC3",6+7*kNlayer,"BFTRD",-xpos,ypos,zpos
1971 ,matrix[3],"ONLY",parCOL,kNparCOL);
1974 // The power bus bars
1977 const Float_t kPWRwid = 0.6;
1978 // Increase the height of the power bus bars to take into
1979 // account the material of additional cables, etc.
1980 const Float_t kPWRhgtA = 5.0 + 0.2;
1981 const Float_t kPWRhgtB = 5.0;
1982 const Float_t kPWRposx = 2.0;
1983 const Float_t kPWRposz = 0.1;
1984 const Int_t kNparPWR = 3;
1985 Float_t parPWR[kNparPWR];
1989 gMC->Gsvolu("UTP1","BOX ",idtmed[1325-1],parPWR,0);
1990 gMC->Gsvolu("UTP3","BOX ",idtmed[1325-1],parPWR,0);
1992 for (ilayer = 1; ilayer < kNlayer; ilayer++) {
1994 // Along the chambers
1995 xpos = fCwidth[ilayer]/2.0 + kPWRwid/2.0 + kPWRposx;
1997 zpos = fgkVrocsm + fgkSMpltT - fgkCalZpos
1998 + kPWRhgtA/2.0 - fgkSheight/2.0 + kPWRposz
1999 + ilayer * (fgkCH + fgkVspace);
2000 parPWR[0] = kPWRwid /2.0;
2001 parPWR[1] = fgkSlength/2.0;
2002 parPWR[2] = kPWRhgtA /2.0;
2003 gMC->Gsposp("UTP1",ilayer ,"UTI1", xpos,ypos,zpos
2004 ,matrix[0],"ONLY",parPWR,kNparPWR);
2005 gMC->Gsposp("UTP1",ilayer+ kNlayer,"UTI1",-xpos,ypos,zpos
2006 ,matrix[1],"ONLY",parPWR,kNparPWR);
2007 gMC->Gsposp("UTP1",ilayer+6*kNlayer,"UTI2", xpos,ypos,zpos
2008 ,matrix[0],"ONLY",parPWR,kNparPWR);
2009 gMC->Gsposp("UTP1",ilayer+7*kNlayer,"UTI2",-xpos,ypos,zpos
2010 ,matrix[1],"ONLY",parPWR,kNparPWR);
2011 gMC->Gsposp("UTP1",ilayer+8*kNlayer,"UTI3", xpos,ypos,zpos
2012 ,matrix[0],"ONLY",parPWR,kNparPWR);
2013 gMC->Gsposp("UTP1",ilayer+9*kNlayer,"UTI3",-xpos,ypos,zpos
2014 ,matrix[1],"ONLY",parPWR,kNparPWR);
2016 // Front of supermodule
2017 xpos = fCwidth[ilayer]/2.0 + kPWRwid/2.0 + kPWRposx;
2019 zpos = fgkVrocsm + fgkSMpltT - fgkCalZpos
2020 + kPWRhgtA/2.0 - fgkSheight/2.0 + kPWRposz
2021 + ilayer * (fgkCH + fgkVspace);
2022 parPWR[0] = kPWRwid /2.0;
2023 parPWR[1] = fgkFlength/2.0;
2024 parPWR[2] = kPWRhgtA /2.0;
2025 gMC->Gsposp("UTP3",ilayer+2*kNlayer,"UTF1", xpos,ypos,zpos
2026 ,matrix[0],"ONLY",parPWR,kNparPWR);
2027 gMC->Gsposp("UTP3",ilayer+3*kNlayer,"UTF1",-xpos,ypos,zpos
2028 ,matrix[1],"ONLY",parPWR,kNparPWR);
2029 gMC->Gsposp("UTP3",ilayer+4*kNlayer,"UTF2", xpos,ypos,zpos
2030 ,matrix[0],"ONLY",parPWR,kNparPWR);
2031 gMC->Gsposp("UTP3",ilayer+5*kNlayer,"UTF2",-xpos,ypos,zpos
2032 ,matrix[1],"ONLY",parPWR,kNparPWR);
2036 for (ilayer = 1; ilayer < kNlayer; ilayer++) {
2039 xpos = fCwidth[ilayer]/2.0 + kPWRwid/2.0 + kPWRposx - 2.5;
2040 ypos = kBBSdz/2.0 - kBBMdz/2.0;
2041 zpos = fgkVrocsm + fgkSMpltT - fgkCalZpos
2042 + kPWRhgtB/2.0 - fgkSheight/2.0 + kPWRposz
2043 + ilayer * (fgkCH + fgkVspace);
2044 parPWR[0] = kPWRwid /2.0;
2045 parPWR[1] = kBBSdz /2.0;
2046 parPWR[2] = kPWRhgtB/2.0;
2047 gMC->Gsposp("UTP3",ilayer+6*kNlayer,"BBTRD", xpos, ypos, zpos
2048 ,matrix[0],"ONLY",parPWR,kNparPWR);
2049 gMC->Gsposp("UTP3",ilayer+7*kNlayer,"BBTRD",-xpos, ypos, zpos
2050 ,matrix[1],"ONLY",parPWR,kNparPWR);
2054 for (ilayer = 1; ilayer < kNlayer; ilayer++) {
2057 xpos = fCwidth[ilayer]/2.0 + kPWRwid/2.0 + kPWRposx - 0.3;
2058 ypos = -kBFSdz/2.0 + kBFMdz/2.0;
2059 zpos = fgkVrocsm + fgkSMpltT - fgkCalZpos
2060 + kPWRhgtB/2.0 - fgkSheight/2.0 + kPWRposz
2061 + ilayer * (fgkCH + fgkVspace);
2062 parPWR[0] = kPWRwid /2.0;
2063 parPWR[1] = kBFSdz /2.0;
2064 parPWR[2] = kPWRhgtB/2.0;
2065 gMC->Gsposp("UTP3",ilayer+8*kNlayer,"BFTRD", xpos,ypos,zpos
2066 ,matrix[0],"ONLY",parPWR,kNparPWR);
2067 gMC->Gsposp("UTP3",ilayer+9*kNlayer,"BFTRD",-xpos,ypos,zpos
2068 ,matrix[1],"ONLY",parPWR,kNparPWR);
2072 // The upper most layer
2073 // Along the chambers
2074 xpos = fCwidth[5]/2.0 + kPWRhgtB/2.0 - 1.3;
2076 zpos = fgkSheight/2.0 - fgkSMpltT - 0.6 - kPWRwid/2.0;
2077 parPWR[0] = kPWRwid /2.0;
2078 parPWR[1] = fgkSlength/2.0;
2079 parPWR[2] = kPWRhgtB /2.0 ;
2080 gMC->Gsposp("UTP1",6 ,"UTI1", xpos,ypos,zpos
2081 ,matrix[3],"ONLY",parPWR,kNparPWR);
2082 gMC->Gsposp("UTP1",6+ kNlayer,"UTI1",-xpos,ypos,zpos
2083 ,matrix[3],"ONLY",parPWR,kNparPWR);
2084 gMC->Gsposp("UTP1",6+6*kNlayer,"UTI2", xpos,ypos,zpos
2085 ,matrix[3],"ONLY",parPWR,kNparPWR);
2086 gMC->Gsposp("UTP1",6+7*kNlayer,"UTI2",-xpos,ypos,zpos
2087 ,matrix[3],"ONLY",parPWR,kNparPWR);
2088 gMC->Gsposp("UTP1",6+8*kNlayer,"UTI3", xpos,ypos,zpos
2089 ,matrix[3],"ONLY",parPWR,kNparPWR);
2090 gMC->Gsposp("UTP1",6+9*kNlayer,"UTI3",-xpos,ypos,zpos
2091 ,matrix[3],"ONLY",parPWR,kNparPWR);
2092 // Front of supermodules
2093 xpos = fCwidth[5]/2.0 + kPWRhgtB/2.0 - 1.3;
2095 zpos = fgkSheight/2.0 - fgkSMpltT - 0.6 - kPWRwid/2.0;
2096 parPWR[0] = kPWRwid /2.0;
2097 parPWR[1] = fgkFlength/2.0;
2098 parPWR[2] = kPWRhgtB /2.0;
2099 gMC->Gsposp("UTP3",6+2*kNlayer,"UTF1", xpos,ypos,zpos
2100 ,matrix[3],"ONLY",parPWR,kNparPWR);
2101 gMC->Gsposp("UTP3",6+3*kNlayer,"UTF1",-xpos,ypos,zpos
2102 ,matrix[3],"ONLY",parPWR,kNparPWR);
2103 gMC->Gsposp("UTP3",6+4*kNlayer,"UTF2", xpos,ypos,zpos
2104 ,matrix[3],"ONLY",parPWR,kNparPWR);
2105 gMC->Gsposp("UTP3",6+5*kNlayer,"UTF2",-xpos,ypos,zpos
2106 ,matrix[3],"ONLY",parPWR,kNparPWR);
2108 xpos = fCwidth[5]/2.0 + kPWRhgtB/2.0 - 3.0;
2109 ypos = kBBSdz/2.0 - kBBMdz/2.0;
2110 zpos = fgkSheight/2.0 - fgkSMpltT - 0.6 - kPWRwid/2.0;
2111 parPWR[0] = kPWRwid /2.0;
2112 parPWR[1] = kBBSdz /2.0;
2113 parPWR[2] = kPWRhgtB/2.0;
2114 gMC->Gsposp("UTP3",6+6*kNlayer,"BBTRD", xpos, ypos, zpos
2115 ,matrix[3],"ONLY",parPWR,kNparPWR);
2116 gMC->Gsposp("UTP3",6+7*kNlayer,"BBTRD",-xpos, ypos, zpos
2117 ,matrix[3],"ONLY",parPWR,kNparPWR);
2119 xpos = fCwidth[5]/2.0 + kPWRhgtB/2.0 - 1.3;
2120 ypos = -kBFSdz/2.0 + kBFMdz/2.0;
2121 zpos = fgkSheight/2.0 - fgkSMpltT - 0.6 - kPWRwid/2.0;
2122 parPWR[0] = kPWRwid /2.0;
2123 parPWR[1] = kBFSdz /2.0;
2124 parPWR[2] = kPWRhgtB/2.0;
2125 gMC->Gsposp("UTP3",6+8*kNlayer,"BFTRD", xpos,ypos,zpos
2126 ,matrix[3],"ONLY",parPWR,kNparPWR);
2127 gMC->Gsposp("UTP3",6+9*kNlayer,"BFTRD",-xpos,ypos,zpos
2128 ,matrix[3],"ONLY",parPWR,kNparPWR);
2131 // The gas tubes connecting the chambers in the super modules with holes
2132 // Material: Stainless steel
2136 parTube[1] = 2.2/2.0;
2137 parTube[2] = fClength[5][2]/2.0 - fgkHspace/2.0;
2138 gMC->Gsvolu("UTG1","TUBE",idtmed[1308-1],parTube,kNparTube);
2140 parTube[1] = 2.1/2.0;
2141 parTube[2] = fClength[5][2]/2.0 - fgkHspace/2.0;
2142 gMC->Gsvolu("UTG2","TUBE",idtmed[1309-1],parTube,kNparTube);
2146 gMC->Gspos("UTG2",1,"UTG1",xpos,ypos,zpos,0,"ONLY");
2147 for (ilayer = 0; ilayer < kNlayer; ilayer++) {
2148 xpos = fCwidth[ilayer]/2.0 + kCOLwid/2.0 - 1.5;
2150 zpos = fgkVrocsm + fgkSMpltT + kCOLhgt/2.0 - fgkSheight/2.0 + 5.0
2151 + ilayer * (fgkCH + fgkVspace);
2152 gMC->Gspos("UTG1",1+ilayer,"UTI3", xpos, ypos, zpos,matrix[4],"ONLY");
2153 gMC->Gspos("UTG1",7+ilayer,"UTI3",-xpos, ypos, zpos,matrix[4],"ONLY");
2157 // The volumes for the services at the chambers
2160 const Int_t kNparServ = 3;
2161 Float_t parServ[kNparServ];
2163 for (istack = 0; istack < kNstack; istack++) {
2164 for (ilayer = 0; ilayer < kNlayer; ilayer++) {
2166 Int_t iDet = GetDetectorSec(ilayer,istack);
2168 sprintf(cTagV,"UU%02d",iDet);
2169 parServ[0] = fCwidth[ilayer] /2.0;
2170 parServ[1] = fClength[ilayer][istack]/2.0 - fgkHspace/2.0;
2171 parServ[2] = fgkCsvH /2.0;
2172 gMC->Gsvolu(cTagV,"BOX",idtmed[1302-1],parServ,kNparServ);
2178 // The cooling pipes inside the service volumes
2181 // The cooling pipes
2185 gMC->Gsvolu("UTCP","TUBE",idtmed[1324-1],parTube,0);
2186 // The cooling water
2188 parTube[1] = 0.2/2.0;
2190 gMC->Gsvolu("UTCH","TUBE",idtmed[1314-1],parTube,kNparTube);
2191 // Water inside the cooling pipe
2195 gMC->Gspos("UTCH",1,"UTCP",xpos,ypos,zpos,0,"ONLY");
2197 // Position the cooling pipes in the mother volume
2198 for (istack = 0; istack < kNstack; istack++) {
2199 for (ilayer = 0; ilayer < kNlayer; ilayer++) {
2200 Int_t iDet = GetDetectorSec(ilayer,istack);
2201 Int_t iCopy = GetDetector(ilayer,istack,0) * 100;
2202 Int_t nMCMrow = GetRowMax(ilayer,istack,0);
2203 Float_t ySize = (GetChamberLength(ilayer,istack) - 2.0*fgkRpadW)
2204 / ((Float_t) nMCMrow);
2205 sprintf(cTagV,"UU%02d",iDet);
2206 for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
2208 ypos = (0.5 + iMCMrow) * ySize
2209 - fClength[ilayer][istack]/2.0 + fgkHspace/2.0;
2210 zpos = 0.0 + 0.742/2.0;
2211 // The cooling pipes
2213 parTube[1] = 0.3/2.0; // Thickness of the cooling pipes
2214 parTube[2] = fCwidth[ilayer]/2.0;
2215 gMC->Gsposp("UTCP",iCopy+iMCMrow,cTagV,xpos,ypos,zpos
2216 ,matrix[2],"ONLY",parTube,kNparTube);
2225 // The copper power lines
2229 gMC->Gsvolu("UTPL","TUBE",idtmed[1305-1],parTube,0);
2231 // Position the power lines in the mother volume
2232 for (istack = 0; istack < kNstack; istack++) {
2233 for (ilayer = 0; ilayer < kNlayer; ilayer++) {
2234 Int_t iDet = GetDetectorSec(ilayer,istack);
2235 Int_t iCopy = GetDetector(ilayer,istack,0) * 100;
2236 Int_t nMCMrow = GetRowMax(ilayer,istack,0);
2237 Float_t ySize = (GetChamberLength(ilayer,istack) - 2.0*fgkRpadW)
2238 / ((Float_t) nMCMrow);
2239 sprintf(cTagV,"UU%02d",iDet);
2240 for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
2242 ypos = (0.5 + iMCMrow) * ySize - 1.0
2243 - fClength[ilayer][istack]/2.0 + fgkHspace/2.0;
2244 zpos = -0.4 + 0.742/2.0;
2246 parTube[1] = 0.2/2.0; // Thickness of the power lines
2247 parTube[2] = fCwidth[ilayer]/2.0;
2248 gMC->Gsposp("UTPL",iCopy+iMCMrow,cTagV,xpos,ypos,zpos
2249 ,matrix[2],"ONLY",parTube,kNparTube);
2258 const Float_t kMCMx = 3.0;
2259 const Float_t kMCMy = 3.0;
2260 const Float_t kMCMz = 0.3;
2262 const Float_t kMCMpcTh = 0.1;
2263 const Float_t kMCMcuTh = 0.0025;
2264 const Float_t kMCMsiTh = 0.03;
2265 const Float_t kMCMcoTh = 0.04;
2267 // The mother volume for the MCMs (air)
2268 const Int_t kNparMCM = 3;
2269 Float_t parMCM[kNparMCM];
2270 parMCM[0] = kMCMx /2.0;
2271 parMCM[1] = kMCMy /2.0;
2272 parMCM[2] = kMCMz /2.0;
2273 gMC->Gsvolu("UMCM","BOX",idtmed[1302-1],parMCM,kNparMCM);
2275 // The MCM carrier G10 layer
2276 parMCM[0] = kMCMx /2.0;
2277 parMCM[1] = kMCMy /2.0;
2278 parMCM[2] = kMCMpcTh/2.0;
2279 gMC->Gsvolu("UMC1","BOX",idtmed[1319-1],parMCM,kNparMCM);
2280 // The MCM carrier Cu layer
2281 parMCM[0] = kMCMx /2.0;
2282 parMCM[1] = kMCMy /2.0;
2283 parMCM[2] = kMCMcuTh/2.0;
2284 gMC->Gsvolu("UMC2","BOX",idtmed[1318-1],parMCM,kNparMCM);
2285 // The silicon of the chips
2286 parMCM[0] = kMCMx /2.0;
2287 parMCM[1] = kMCMy /2.0;
2288 parMCM[2] = kMCMsiTh/2.0;
2289 gMC->Gsvolu("UMC3","BOX",idtmed[1320-1],parMCM,kNparMCM);
2290 // The aluminum of the cooling plates
2291 parMCM[0] = kMCMx /2.0;
2292 parMCM[1] = kMCMy /2.0;
2293 parMCM[2] = kMCMcoTh/2.0;
2294 gMC->Gsvolu("UMC4","BOX",idtmed[1324-1],parMCM,kNparMCM);
2296 // Put the MCM material inside the MCM mother volume
2299 zpos = -kMCMz /2.0 + kMCMpcTh/2.0;
2300 gMC->Gspos("UMC1",1,"UMCM",xpos,ypos,zpos,0,"ONLY");
2301 zpos += kMCMpcTh/2.0 + kMCMcuTh/2.0;
2302 gMC->Gspos("UMC2",1,"UMCM",xpos,ypos,zpos,0,"ONLY");
2303 zpos += kMCMcuTh/2.0 + kMCMsiTh/2.0;
2304 gMC->Gspos("UMC3",1,"UMCM",xpos,ypos,zpos,0,"ONLY");
2305 zpos += kMCMsiTh/2.0 + kMCMcoTh/2.0;
2306 gMC->Gspos("UMC4",1,"UMCM",xpos,ypos,zpos,0,"ONLY");
2308 // Position the MCMs in the mother volume
2309 for (istack = 0; istack < kNstack; istack++) {
2310 for (ilayer = 0; ilayer < kNlayer; ilayer++) {
2311 Int_t iDet = GetDetectorSec(ilayer,istack);
2312 Int_t iCopy = GetDetector(ilayer,istack,0) * 1000;
2313 Int_t nMCMrow = GetRowMax(ilayer,istack,0);
2314 Float_t ySize = (GetChamberLength(ilayer,istack) - 2.0*fgkRpadW)
2315 / ((Float_t) nMCMrow);
2317 Float_t xSize = (GetChamberWidth(ilayer) - 2.0*fgkCpadW)
2318 / ((Float_t) nMCMcol + 6); // Introduce 6 gaps
2319 Int_t iMCM[8] = { 1, 2, 3, 5, 8, 9, 10, 12 }; // 0..7 MCM + 6 gap structure
2320 sprintf(cTagV,"UU%02d",iDet);
2321 for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
2322 for (Int_t iMCMcol = 0; iMCMcol < nMCMcol; iMCMcol++) {
2323 xpos = (0.5 + iMCM[iMCMcol]) * xSize + 1.0
2324 - fCwidth[ilayer]/2.0;
2325 ypos = (0.5 + iMCMrow) * ySize + 1.0
2326 - fClength[ilayer][istack]/2.0 + fgkHspace/2.0;
2327 zpos = -0.4 + 0.742/2.0;
2328 gMC->Gspos("UMCM",iCopy+iMCMrow*10+iMCMcol,cTagV
2329 ,xpos,ypos,zpos,0,"ONLY");
2330 // Add two additional smaller cooling pipes on top of the MCMs
2331 // to mimic the meandering structure
2332 xpos = (0.5 + iMCM[iMCMcol]) * xSize + 1.0
2333 - fCwidth[ilayer]/2.0;
2334 ypos = (0.5 + iMCMrow) * ySize
2335 - fClength[ilayer][istack]/2.0 + fgkHspace/2.0;
2336 zpos = 0.0 + 0.742/2.0;
2338 parTube[1] = 0.3/2.0; // Thickness of the cooling pipes
2339 parTube[2] = kMCMx/2.0;
2340 gMC->Gsposp("UTCP",iCopy+iMCMrow*10+iMCMcol+ 50,cTagV
2342 ,matrix[2],"ONLY",parTube,kNparTube);
2343 gMC->Gsposp("UTCP",iCopy+iMCMrow*10+iMCMcol+500,cTagV
2345 ,matrix[2],"ONLY",parTube,kNparTube);
2357 const Float_t kDCSx = 9.0;
2358 const Float_t kDCSy = 14.5;
2359 const Float_t kDCSz = 0.3;
2361 const Float_t kDCSpcTh = 0.15;
2362 const Float_t kDCScuTh = 0.01;
2363 const Float_t kDCScoTh = 0.04;
2365 // The mother volume for the DCSs (air)
2366 const Int_t kNparDCS = 3;
2367 Float_t parDCS[kNparDCS];
2368 parDCS[0] = kDCSx /2.0;
2369 parDCS[1] = kDCSy /2.0;
2370 parDCS[2] = kDCSz /2.0;
2371 gMC->Gsvolu("UDCS","BOX",idtmed[1302-1],parDCS,kNparDCS);
2373 // The DCS carrier G10 layer
2374 parDCS[0] = kDCSx /2.0;
2375 parDCS[1] = kDCSy /2.0;
2376 parDCS[2] = kDCSpcTh/2.0;
2377 gMC->Gsvolu("UDC1","BOX",idtmed[1319-1],parDCS,kNparDCS);
2378 // The DCS carrier Cu layer
2379 parDCS[0] = kDCSx /2.0;
2380 parDCS[1] = kDCSy /2.0;
2381 parDCS[2] = kDCScuTh/2.0;
2382 gMC->Gsvolu("UDC2","BOX",idtmed[1318-1],parDCS,kNparDCS);
2383 // The aluminum of the cooling plates
2384 parDCS[0] = 5.0 /2.0;
2385 parDCS[1] = 5.0 /2.0;
2386 parDCS[2] = kDCScoTh/2.0;
2387 gMC->Gsvolu("UDC3","BOX",idtmed[1324-1],parDCS,kNparDCS);
2389 // Put the DCS material inside the DCS mother volume
2392 zpos = -kDCSz /2.0 + kDCSpcTh/2.0;
2393 gMC->Gspos("UDC1",1,"UDCS",xpos,ypos,zpos,0,"ONLY");
2394 zpos += kDCSpcTh/2.0 + kDCScuTh/2.0;
2395 gMC->Gspos("UDC2",1,"UDCS",xpos,ypos,zpos,0,"ONLY");
2396 zpos += kDCScuTh/2.0 + kDCScoTh/2.0;
2397 gMC->Gspos("UDC3",1,"UDCS",xpos,ypos,zpos,0,"ONLY");
2399 // Put the DCS board in the chamber services mother volume
2400 for (istack = 0; istack < kNstack; istack++) {
2401 for (ilayer = 0; ilayer < kNlayer; ilayer++) {
2402 Int_t iDet = GetDetectorSec(ilayer,istack);
2403 Int_t iCopy = iDet + 1;
2404 xpos = fCwidth[ilayer]/2.0 - 1.9 * (GetChamberLength(ilayer,istack) - 2.0*fgkRpadW)
2405 / ((Float_t) GetRowMax(ilayer,istack,0));
2406 ypos = 0.05 * fClength[ilayer][istack];
2407 zpos = kDCSz/2.0 - fgkCsvH/2.0;
2408 sprintf(cTagV,"UU%02d",iDet);
2409 gMC->Gspos("UDCS",iCopy,cTagV,xpos,ypos,zpos,0,"ONLY");
2417 const Float_t kORIx = 4.2;
2418 const Float_t kORIy = 13.5;
2419 const Float_t kORIz = 0.3;
2421 const Float_t kORIpcTh = 0.15;
2422 const Float_t kORIcuTh = 0.01;
2423 const Float_t kORIcoTh = 0.04;
2425 // The mother volume for the ORIs (air)
2426 const Int_t kNparORI = 3;
2427 Float_t parORI[kNparORI];
2428 parORI[0] = kORIx /2.0;
2429 parORI[1] = kORIy /2.0;
2430 parORI[2] = kORIz /2.0;
2431 gMC->Gsvolu("UORI","BOX",idtmed[1302-1],parORI,kNparORI);
2433 // The ORI carrier G10 layer
2434 parORI[0] = kORIx /2.0;
2435 parORI[1] = kORIy /2.0;
2436 parORI[2] = kORIpcTh/2.0;
2437 gMC->Gsvolu("UOR1","BOX",idtmed[1319-1],parORI,kNparORI);
2438 // The ORI carrier Cu layer
2439 parORI[0] = kORIx /2.0;
2440 parORI[1] = kORIy /2.0;
2441 parORI[2] = kORIcuTh/2.0;
2442 gMC->Gsvolu("UOR2","BOX",idtmed[1318-1],parORI,kNparORI);
2443 // The aluminum of the cooling plates
2444 parORI[0] = kORIx /2.0;
2445 parORI[1] = kORIy /2.0;
2446 parORI[2] = kORIcoTh/2.0;
2447 gMC->Gsvolu("UOR3","BOX",idtmed[1324-1],parORI,kNparORI);
2449 // Put the ORI material inside the ORI mother volume
2452 zpos = -kORIz /2.0 + kORIpcTh/2.0;
2453 gMC->Gspos("UOR1",1,"UORI",xpos,ypos,zpos,0,"ONLY");
2454 zpos += kORIpcTh/2.0 + kORIcuTh/2.0;
2455 gMC->Gspos("UOR2",1,"UORI",xpos,ypos,zpos,0,"ONLY");
2456 zpos += kORIcuTh/2.0 + kORIcoTh/2.0;
2457 gMC->Gspos("UOR3",1,"UORI",xpos,ypos,zpos,0,"ONLY");
2459 // Put the ORI board in the chamber services mother volume
2460 for (istack = 0; istack < kNstack; istack++) {
2461 for (ilayer = 0; ilayer < kNlayer; ilayer++) {
2462 Int_t iDet = GetDetectorSec(ilayer,istack);
2463 Int_t iCopy = iDet + 1;
2464 xpos = fCwidth[ilayer]/2.0 - 1.92 * (GetChamberLength(ilayer,istack) - 2.0*fgkRpadW)
2465 / ((Float_t) GetRowMax(ilayer,istack,0));
2467 zpos = kORIz/2.0 - fgkCsvH/2.0;
2468 sprintf(cTagV,"UU%02d",iDet);
2469 gMC->Gspos("UORI",iCopy ,cTagV,xpos,ypos,zpos,0,"ONLY");
2470 xpos = -fCwidth[ilayer]/2.0 + 3.8 * (GetChamberLength(ilayer,istack) - 2.0*fgkRpadW)
2471 / ((Float_t) GetRowMax(ilayer,istack,0));
2473 zpos = kORIz/2.0 - fgkCsvH/2.0;
2474 sprintf(cTagV,"UU%02d",iDet);
2475 gMC->Gspos("UORI",iCopy+kNdet,cTagV,xpos,ypos,zpos,0,"ONLY");
2480 // Services in front of the super module
2483 // Gas in-/outlet pipes (INOX)
2487 gMC->Gsvolu("UTG3","TUBE",idtmed[1308-1],parTube,0);
2488 // The gas inside the in-/outlet pipes (Xe)
2490 parTube[1] = 1.2/2.0;
2492 gMC->Gsvolu("UTG4","TUBE",idtmed[1309-1],parTube,kNparTube);
2496 gMC->Gspos("UTG4",1,"UTG3",xpos,ypos,zpos,0,"ONLY");
2497 for (ilayer = 0; ilayer < kNlayer-1; ilayer++) {
2499 ypos = fClength[ilayer][2]/2.0
2500 + fClength[ilayer][1]
2501 + fClength[ilayer][0];
2502 zpos = 9.0 - fgkSheight/2.0
2503 + ilayer * (fgkCH + fgkVspace);
2505 parTube[1] = 1.5/2.0;
2506 parTube[2] = fCwidth[ilayer]/2.0 - 2.5;
2507 gMC->Gsposp("UTG3",ilayer+1 ,"UTI1", xpos, ypos, zpos
2508 ,matrix[2],"ONLY",parTube,kNparTube);
2509 gMC->Gsposp("UTG3",ilayer+1+1*kNlayer,"UTI1", xpos,-ypos, zpos
2510 ,matrix[2],"ONLY",parTube,kNparTube);
2511 gMC->Gsposp("UTG3",ilayer+1+2*kNlayer,"UTI2", xpos, ypos, zpos
2512 ,matrix[2],"ONLY",parTube,kNparTube);
2513 gMC->Gsposp("UTG3",ilayer+1+3*kNlayer,"UTI2", xpos,-ypos, zpos
2514 ,matrix[2],"ONLY",parTube,kNparTube);
2515 gMC->Gsposp("UTG3",ilayer+1+4*kNlayer,"UTI3", xpos, ypos, zpos
2516 ,matrix[2],"ONLY",parTube,kNparTube);
2517 gMC->Gsposp("UTG3",ilayer+1+5*kNlayer,"UTI3", xpos,-ypos, zpos
2518 ,matrix[2],"ONLY",parTube,kNparTube);
2521 // Gas distribution box
2522 parBox[0] = 14.50/2.0;
2523 parBox[1] = 4.52/2.0;
2524 parBox[2] = 5.00/2.0;
2525 gMC->Gsvolu("UTGD","BOX ",idtmed[1308-1],parBox,kNparBox);
2526 parBox[0] = 14.50/2.0;
2527 parBox[1] = 4.00/2.0;
2528 parBox[2] = 4.40/2.0;
2529 gMC->Gsvolu("UTGI","BOX ",idtmed[1309-1],parBox,kNparBox);
2531 parTube[1] = 4.0/2.0;
2532 parTube[2] = 8.0/2.0;
2533 gMC->Gsvolu("UTGT","TUBE",idtmed[1308-1],parTube,kNparTube);
2535 parTube[1] = 3.4/2.0;
2536 parTube[2] = 8.0/2.0;
2537 gMC->Gsvolu("UTGG","TUBE",idtmed[1309-1],parTube,kNparTube);
2541 gMC->Gspos("UTGI",1,"UTGD",xpos,ypos,zpos, 0,"ONLY");
2542 gMC->Gspos("UTGG",1,"UTGT",xpos,ypos,zpos, 0,"ONLY");
2546 gMC->Gspos("UTGD",1,"UTF1",xpos,ypos,zpos, 0,"ONLY");
2550 gMC->Gspos("UTGT",1,"UTF1",xpos,ypos,zpos, 0,"ONLY");
2554 gMC->Gspos("UTGT",3,"UTF1",xpos,ypos,zpos,matrix[2],"ONLY");
2558 gMC->Gspos("UTGT",5,"UTF1",xpos,ypos,zpos,matrix[2],"ONLY");
2560 // Cooling manifolds
2561 parBox[0] = 5.0/2.0;
2562 parBox[1] = 23.0/2.0;
2563 parBox[2] = 70.0/2.0;
2564 gMC->Gsvolu("UTCM","BOX ",idtmed[1302-1],parBox,kNparBox);
2565 parBox[0] = 5.0/2.0;
2566 parBox[1] = 5.0/2.0;
2567 parBox[2] = 70.0/2.0;
2568 gMC->Gsvolu("UTCA","BOX ",idtmed[1308-1],parBox,kNparBox);
2569 parBox[0] = 5.0/2.0 - 0.3;
2570 parBox[1] = 5.0/2.0 - 0.3;
2571 parBox[2] = 70.0/2.0 - 0.3;
2572 gMC->Gsvolu("UTCW","BOX ",idtmed[1314-1],parBox,kNparBox);
2576 gMC->Gspos("UTCW",1,"UTCA", xpos, ypos, zpos, 0,"ONLY");
2578 ypos = 5.0/2.0 - 23.0/2.0;
2580 gMC->Gspos("UTCA",1,"UTCM", xpos, ypos, zpos, 0,"ONLY");
2582 parTube[1] = 3.0/2.0;
2583 parTube[2] = 18.0/2.0;
2584 gMC->Gsvolu("UTCO","TUBE",idtmed[1308-1],parTube,kNparTube);
2586 parTube[1] = 3.0/2.0 - 0.3;
2587 parTube[2] = 18.0/2.0;
2588 gMC->Gsvolu("UTCL","TUBE",idtmed[1314-1],parTube,kNparTube);
2592 gMC->Gspos("UTCL",1,"UTCO", xpos, ypos, zpos, 0,"ONLY");
2595 zpos = -70.0/2.0 + 7.0;
2596 gMC->Gspos("UTCO",1,"UTCM", xpos, ypos, zpos,matrix[4],"ONLY");
2598 gMC->Gspos("UTCO",2,"UTCM", xpos, ypos, zpos,matrix[4],"ONLY");
2600 gMC->Gspos("UTCO",3,"UTCM", xpos, ypos, zpos,matrix[4],"ONLY");
2602 gMC->Gspos("UTCO",4,"UTCM", xpos, ypos, zpos,matrix[4],"ONLY");
2604 gMC->Gspos("UTCO",5,"UTCM", xpos, ypos, zpos,matrix[4],"ONLY");
2606 gMC->Gspos("UTCO",6,"UTCM", xpos, ypos, zpos,matrix[4],"ONLY");
2608 gMC->Gspos("UTCO",7,"UTCM", xpos, ypos, zpos,matrix[4],"ONLY");
2610 gMC->Gspos("UTCO",8,"UTCM", xpos, ypos, zpos,matrix[4],"ONLY");
2613 ypos = fgkFlength/2.0 - 23.0/2.0;
2615 gMC->Gspos("UTCM",1,"UTF1", xpos, ypos, zpos,matrix[0],"ONLY");
2616 gMC->Gspos("UTCM",2,"UTF1",-xpos, ypos, zpos,matrix[1],"ONLY");
2617 gMC->Gspos("UTCM",3,"UTF2", xpos,-ypos, zpos,matrix[5],"ONLY");
2618 gMC->Gspos("UTCM",4,"UTF2",-xpos,-ypos, zpos,matrix[6],"ONLY");
2620 // Power connection boards (Cu)
2621 parBox[0] = 0.5/2.0;
2622 parBox[1] = 15.0/2.0;
2623 parBox[2] = 7.0/2.0;
2624 gMC->Gsvolu("UTPC","BOX ",idtmed[1325-1],parBox,kNparBox);
2625 for (ilayer = 0; ilayer < kNlayer-1; ilayer++) {
2626 xpos = fCwidth[ilayer]/2.0 + kPWRwid/2.0;
2628 zpos = fgkVrocsm + fgkSMpltT + kPWRhgtA/2.0 - fgkSheight/2.0 + kPWRposz
2629 + (ilayer+1) * (fgkCH + fgkVspace);
2630 gMC->Gspos("UTPC",ilayer ,"UTF1", xpos,ypos,zpos,matrix[0],"ONLY");
2631 gMC->Gspos("UTPC",ilayer+kNlayer,"UTF1",-xpos,ypos,zpos,matrix[1],"ONLY");
2633 xpos = fCwidth[5]/2.0 + kPWRhgtA/2.0 - 2.0;
2635 zpos = fgkSheight/2.0 - fgkSMpltT - 2.0;
2636 gMC->Gspos("UTPC",5 ,"UTF1", xpos,ypos,zpos,matrix[3],"ONLY");
2637 gMC->Gspos("UTPC",5+kNlayer,"UTF1",-xpos,ypos,zpos,matrix[3],"ONLY");
2639 // Power connection panel (Al)
2640 parBox[0] = 60.0/2.0;
2641 parBox[1] = 10.0/2.0;
2642 parBox[2] = 3.0/2.0;
2643 gMC->Gsvolu("UTPP","BOX ",idtmed[1301-1],parBox,kNparBox);
2647 gMC->Gspos("UTPP",1,"UTF1", xpos,ypos,zpos,0,"ONLY");
2650 // Electronics boxes
2654 parBox[0] = 60.0/2.0;
2655 parBox[1] = 10.0/2.0;
2656 parBox[2] = 6.0/2.0;
2657 gMC->Gsvolu("UTE1","BOX ",idtmed[1308-1],parBox,kNparBox);
2659 parBox[0] = parBox[0] - 0.5;
2660 parBox[1] = parBox[1] - 0.5;
2661 parBox[2] = parBox[2] - 0.5;
2662 gMC->Gsvolu("UTE2","BOX ",idtmed[1302-1],parBox,kNparBox);
2666 gMC->Gspos("UTE2",1,"UTE1",xpos,ypos,zpos,0,"ONLY");
2668 ypos = fgkSlength/2.0 - 10.0/2.0 - 3.0;
2669 zpos = -fgkSheight/2.0 + 6.0/2.0 + 1.0;
2670 gMC->Gspos("UTE1",1,"UTI1", xpos,ypos,zpos,0,"ONLY");
2671 gMC->Gspos("UTE1",2,"UTI2", xpos,ypos,zpos,0,"ONLY");
2672 gMC->Gspos("UTE1",3,"UTI3", xpos,ypos,zpos,0,"ONLY");
2675 parBox[0] = 50.0/2.0;
2676 parBox[1] = 15.0/2.0;
2677 parBox[2] = 20.0/2.0;
2678 gMC->Gsvolu("UTE3","BOX ",idtmed[1308-1],parBox,kNparBox);
2680 parBox[0] = parBox[0] - 0.5;
2681 parBox[1] = parBox[1] - 0.5;
2682 parBox[2] = parBox[2] - 0.5;
2683 gMC->Gsvolu("UTE4","BOX ",idtmed[1302-1],parBox,kNparBox);
2687 gMC->Gspos("UTE4",1,"UTE3",xpos,ypos,zpos,0,"ONLY");
2689 ypos = -fgkSlength/2.0 + 15.0/2.0 + 3.0;
2690 zpos = -fgkSheight/2.0 + 20.0/2.0 + 1.0;
2691 gMC->Gspos("UTE3",1,"UTI1", xpos,ypos,zpos,0,"ONLY");
2692 gMC->Gspos("UTE3",2,"UTI2", xpos,ypos,zpos,0,"ONLY");
2693 gMC->Gspos("UTE3",3,"UTI3", xpos,ypos,zpos,0,"ONLY");
2696 parBox[0] = 20.0/2.0;
2697 parBox[1] = 7.0/2.0;
2698 parBox[2] = 20.0/2.0;
2699 gMC->Gsvolu("UTE5","BOX ",idtmed[1308-1],parBox,kNparBox);
2701 parBox[0] = parBox[0] - 0.5;
2702 parBox[1] = parBox[1] - 0.5;
2703 parBox[2] = parBox[2] - 0.5;
2704 gMC->Gsvolu("UTE6","BOX ",idtmed[1302-1],parBox,kNparBox);
2708 gMC->Gspos("UTE6",1,"UTE5",xpos,ypos,zpos,0,"ONLY");
2710 ypos = -fgkSlength/2.0 + 7.0/2.0 + 3.0;
2712 gMC->Gspos("UTE5",1,"UTI1", xpos,ypos,zpos,0,"ONLY");
2713 gMC->Gspos("UTE5",2,"UTI2", xpos,ypos,zpos,0,"ONLY");
2714 gMC->Gspos("UTE5",3,"UTI3", xpos,ypos,zpos,0,"ONLY");
2716 gMC->Gspos("UTE5",4,"UTI1", xpos,ypos,zpos,0,"ONLY");
2717 gMC->Gspos("UTE5",5,"UTI2", xpos,ypos,zpos,0,"ONLY");
2718 gMC->Gspos("UTE5",6,"UTI3", xpos,ypos,zpos,0,"ONLY");
2722 //_____________________________________________________________________________
2723 void AliTRDgeometry::AssembleChamber(Int_t ilayer, Int_t istack)
2726 // Group volumes UA, UD, UF, UU into an assembly that defines the
2727 // alignable volume of a single readout chamber
2733 Double_t xpos = 0.0;
2734 Double_t ypos = 0.0;
2735 Double_t zpos = 0.0;
2737 Int_t idet = GetDetectorSec(ilayer,istack);
2739 // Create the assembly for a given ROC
2740 sprintf(cTagM,"UT%02d",idet);
2741 TGeoVolume *roc = new TGeoVolumeAssembly(cTagM);
2743 // Add the lower part of the chamber (aluminum frame),
2744 // including radiator and drift region
2747 zpos = fgkCraH/2.0 + fgkCdrH/2.0 - fgkCHsv/2.0;
2748 sprintf(cTagV,"UA%02d",idet);
2749 TGeoVolume *rocA = gGeoManager->GetVolume(cTagV);
2750 roc->AddNode(rocA,1,new TGeoTranslation(xpos,ypos,zpos));
2752 // Add the additional aluminum ledges
2753 xpos = fCwidth[ilayer]/2.0 + fgkCalWmod/2.0;
2755 zpos = fgkCraH + fgkCdrH - fgkCalZpos - fgkCalHmod/2.0 - fgkCHsv/2.0;
2756 sprintf(cTagV,"UZ%02d",idet);
2757 TGeoVolume *rocZ = gGeoManager->GetVolume(cTagV);
2758 roc->AddNode(rocZ,1,new TGeoTranslation( xpos,ypos,zpos));
2759 roc->AddNode(rocZ,2,new TGeoTranslation(-xpos,ypos,zpos));
2761 // Add the additional wacosit ledges
2762 xpos = fCwidth[ilayer]/2.0 + fgkCwsW/2.0;
2764 zpos = fgkCraH + fgkCdrH - fgkCwsH/2.0 - fgkCHsv/2.0;
2765 sprintf(cTagV,"UP%02d",idet);
2766 TGeoVolume *rocP = gGeoManager->GetVolume(cTagV);
2767 roc->AddNode(rocP,1,new TGeoTranslation( xpos,ypos,zpos));
2768 roc->AddNode(rocP,2,new TGeoTranslation(-xpos,ypos,zpos));
2770 // Add the middle part of the chamber (G10 frame),
2771 // including amplification region
2774 zpos = fgkCamH/2.0 + fgkCraH + fgkCdrH - fgkCHsv/2.0;
2775 sprintf(cTagV,"UD%02d",idet);
2776 TGeoVolume *rocD = gGeoManager->GetVolume(cTagV);
2777 roc->AddNode(rocD,1,new TGeoTranslation(xpos,ypos,zpos));
2779 // Add the upper part of the chamber (aluminum frame),
2780 // including back panel and FEE
2783 zpos = fgkCroH/2.0 + fgkCamH + fgkCraH + fgkCdrH - fgkCHsv/2.0;
2784 sprintf(cTagV,"UF%02d",idet);
2785 TGeoVolume *rocF = gGeoManager->GetVolume(cTagV);
2786 roc->AddNode(rocF,1,new TGeoTranslation(xpos,ypos,zpos));
2788 // Add the volume with services on top of the back panel
2791 zpos = fgkCsvH/2.0 + fgkCroH + fgkCamH + fgkCraH + fgkCdrH - fgkCHsv/2.0;
2792 sprintf(cTagV,"UU%02d",idet);
2793 TGeoVolume *rocU = gGeoManager->GetVolume(cTagV);
2794 roc->AddNode(rocU,1,new TGeoTranslation(xpos,ypos,zpos));
2796 // Place the ROC assembly into the super modules
2799 ypos = fClength[ilayer][0] + fClength[ilayer][1] + fClength[ilayer][2]/2.0;
2800 for (Int_t ic = 0; ic < istack; ic++) {
2801 ypos -= fClength[ilayer][ic];
2803 ypos -= fClength[ilayer][istack]/2.0;
2804 zpos = fgkVrocsm + fgkSMpltT + fgkCHsv/2.0 - fgkSheight/2.0
2805 + ilayer * (fgkCH + fgkVspace);
2806 TGeoVolume *sm1 = gGeoManager->GetVolume("UTI1");
2807 TGeoVolume *sm2 = gGeoManager->GetVolume("UTI2");
2808 TGeoVolume *sm3 = gGeoManager->GetVolume("UTI3");
2809 sm1->AddNode(roc,1,new TGeoTranslation(xpos,ypos,zpos));
2810 sm2->AddNode(roc,1,new TGeoTranslation(xpos,ypos,zpos));
2813 sm3->AddNode(roc,1,new TGeoTranslation(xpos,ypos,zpos));
2818 //_____________________________________________________________________________
2819 Bool_t AliTRDgeometry::RotateBack(Int_t det
2820 , const Double_t * const loc
2821 , Double_t *glb) const
2824 // Rotates a chambers to transform the corresponding local frame
2825 // coordinates <loc> into the coordinates of the ALICE restframe <glb>.
2828 Int_t sector = GetSector(det);
2830 glb[0] = loc[0] * fRotB11[sector] - loc[1] * fRotB12[sector];
2831 glb[1] = loc[0] * fRotB21[sector] + loc[1] * fRotB22[sector];
2838 //_____________________________________________________________________________
2839 Int_t AliTRDgeometry::GetDetectorSec(Int_t layer, Int_t stack)
2842 // Convert plane / stack into detector number for one single sector
2845 return (layer + stack * fgkNlayer);
2849 //_____________________________________________________________________________
2850 Int_t AliTRDgeometry::GetDetector(Int_t layer, Int_t stack, Int_t sector)
2853 // Convert layer / stack / sector into detector number
2856 return (layer + stack * fgkNlayer + sector * fgkNlayer * fgkNstack);
2860 //_____________________________________________________________________________
2861 Int_t AliTRDgeometry::GetLayer(Int_t det)
2864 // Reconstruct the layer number from the detector number
2867 return ((Int_t) (det % fgkNlayer));
2871 //_____________________________________________________________________________
2872 Int_t AliTRDgeometry::GetStack(Int_t det)
2875 // Reconstruct the stack number from the detector number
2878 return ((Int_t) (det % (fgkNlayer * fgkNstack)) / fgkNlayer);
2882 //_____________________________________________________________________________
2883 Int_t AliTRDgeometry::GetStack(Double_t z, Int_t layer)
2886 // Reconstruct the chamber number from the z position and layer number
2888 // The return function has to be protected for positiveness !!
2892 (layer >= fgkNlayer)) return -1;
2894 Int_t istck = fgkNstack;
2900 if (istck < 0) break;
2901 AliTRDpadPlane *pp = GetPadPlane(layer,istck);
2902 zmax = pp->GetRow0();
2903 Int_t nrows = pp->GetNrows();
2904 zmin = zmax - 2 * pp->GetLengthOPad()
2905 - (nrows-2) * pp->GetLengthIPad()
2906 - (nrows-1) * pp->GetRowSpacing();
2907 } while((z < zmin) || (z > zmax));
2913 //_____________________________________________________________________________
2914 Int_t AliTRDgeometry::GetSector(Int_t det)
2917 // Reconstruct the sector number from the detector number
2920 return ((Int_t) (det / (fgkNlayer * fgkNstack)));
2924 //_____________________________________________________________________________
2925 AliTRDpadPlane *AliTRDgeometry::GetPadPlane(Int_t layer, Int_t stack)
2928 // Returns the pad plane for a given plane <pl> and stack <st> number
2931 if (!fPadPlaneArray) {
2932 CreatePadPlaneArray();
2935 Int_t ipp = GetDetectorSec(layer,stack);
2936 return ((AliTRDpadPlane *) fPadPlaneArray->At(ipp));
2940 //_____________________________________________________________________________
2941 Int_t AliTRDgeometry::GetRowMax(Int_t layer, Int_t stack, Int_t /*sector*/)
2944 // Returns the number of rows on the pad plane
2947 return GetPadPlane(layer,stack)->GetNrows();
2951 //_____________________________________________________________________________
2952 Int_t AliTRDgeometry::GetColMax(Int_t layer)
2955 // Returns the number of rows on the pad plane
2958 return GetPadPlane(layer,0)->GetNcols();
2962 //_____________________________________________________________________________
2963 Double_t AliTRDgeometry::GetRow0(Int_t layer, Int_t stack, Int_t /*sector*/)
2966 // Returns the position of the border of the first pad in a row
2969 return GetPadPlane(layer,stack)->GetRow0();
2973 //_____________________________________________________________________________
2974 Double_t AliTRDgeometry::GetCol0(Int_t layer)
2977 // Returns the position of the border of the first pad in a column
2980 return GetPadPlane(layer,0)->GetCol0();
2984 //_____________________________________________________________________________
2985 Bool_t AliTRDgeometry::CreateClusterMatrixArray()
2988 // Create the matrices to transform cluster coordinates from the
2989 // local chamber system to the tracking coordinate system
2997 TString vpStr = "ALIC_1/B077_1/BSEGMO";
2998 TString vpApp1 = "_1/BTRD";
2999 TString vpApp2 = "_1";
3000 TString vpApp3a = "/UTR1_1/UTS1_1/UTI1_1";
3001 TString vpApp3b = "/UTR2_1/UTS2_1/UTI2_1";
3002 TString vpApp3c = "/UTR3_1/UTS3_1/UTI3_1";
3004 fClusterMatrixArray = new TObjArray(kNdet);
3005 AliAlignObjParams o;
3007 for (Int_t iLayer = AliGeomManager::kTRD1; iLayer <= AliGeomManager::kTRD6; iLayer++) {
3008 for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer); iModule++) {
3010 Int_t isector = iModule/Nstack();
3011 Int_t istack = iModule%Nstack();
3012 Int_t iLayerTRD = iLayer - AliGeomManager::kTRD1;
3013 Int_t lid = GetDetector(iLayerTRD,istack,isector);
3015 // Check for disabled supermodules
3037 if (!gGeoManager->CheckPath(volPath)) {
3041 // Check for holes in from of PHOS
3042 if (((isector == 13) || (isector == 14) || (isector == 15)) &&
3047 UShort_t volid = AliGeomManager::LayerToVolUID(iLayer,iModule);
3048 const char *symname = AliGeomManager::SymName(volid);
3049 TGeoPNEntry *pne = gGeoManager->GetAlignableEntry(symname);
3050 const char *path = symname;
3052 path = pne->GetTitle();
3057 if (!strstr(path,"ALIC")) {
3058 AliDebug(1,Form("Not a valid path: %s\n",path));
3061 if (!gGeoManager->cd(path)) {
3062 AliError(Form("Cannot go to path: %s\n",path));
3065 TGeoHMatrix *m = gGeoManager->GetCurrentMatrix();
3067 TGeoRotation mchange;
3068 mchange.RotateY(90);
3069 mchange.RotateX(90);
3072 // Cluster transformation matrix
3074 TGeoHMatrix rotMatrix(mchange.Inverse());
3075 rotMatrix.MultiplyLeft(m);
3076 Double_t sectorAngle = 20.0 * (isector % 18) + 10.0;
3077 TGeoHMatrix rotSector;
3078 rotSector.RotateZ(sectorAngle);
3079 rotMatrix.MultiplyLeft(&rotSector.Inverse());
3081 fClusterMatrixArray->AddAt(new TGeoHMatrix(rotMatrix),lid);
3090 //_____________________________________________________________________________
3091 Bool_t AliTRDgeometry::ChamberInGeometry(Int_t det)
3094 // Checks whether the given detector is part of the current geometry
3097 if (!fClusterMatrixArray) {
3098 CreateClusterMatrixArray();
3101 if (!GetClusterMatrix(det)) {
3110 //_____________________________________________________________________________
3111 Bool_t AliTRDgeometry::IsHole(Int_t /*la*/, Int_t st, Int_t se) const
3114 // Checks for holes in front of PHOS
3117 if (((se == 13) || (se == 14) || (se == 15)) &&
3126 //_____________________________________________________________________________
3127 Bool_t AliTRDgeometry::IsOnBoundary(Int_t det, Float_t y, Float_t z, Float_t eps) const
3130 // Checks whether position is at the boundary of the sensitive volume
3133 Int_t ly = GetLayer(det);
3135 (ly >= fgkNlayer)) return kTRUE;
3137 Int_t stk = GetStack(det);
3139 (stk >= fgkNstack)) return kTRUE;
3141 AliTRDpadPlane *pp = (AliTRDpadPlane*) fPadPlaneArray->At(GetDetectorSec(ly, stk));
3142 if(!pp) return kTRUE;
3144 Double_t max = pp->GetRow0();
3145 Int_t n = pp->GetNrows();
3146 Double_t min = max - 2 * pp->GetLengthOPad()
3147 - (n-2) * pp->GetLengthIPad()
3148 - (n-1) * pp->GetRowSpacing();
3149 if(z < min+eps || z > max-eps){
3150 //printf("z : min[%7.2f (%7.2f)] %7.2f max[(%7.2f) %7.2f]\n", min, min+eps, z, max-eps, max);
3153 min = pp->GetCol0();
3155 max = min +2 * pp->GetWidthOPad()
3156 + (n-2) * pp->GetWidthIPad()
3157 + (n-1) * pp->GetColSpacing();
3158 if(y < min+eps || y > max-eps){
3159 //printf("y : min[%7.2f (%7.2f)] %7.2f max[(%7.2f) %7.2f]\n", min, min+eps, y, max-eps, max);