TRD/AliTRDgeometryFull.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /*
  17 $Log$
  18 Revision 1.12  2003/09/18 09:06:07  cblume
  19 Geometry update, Removal of compiler warnings
  20
  21 Revision 1.10  2002/11/21 22:38:47  alibrary
  22 Removing AliMC and AliMCProcess
  23
  24 Revision 1.9  2002/10/31 17:45:35  cblume
  25 New chamber geometry
  26
  27 Revision 1.8  2002/02/11 14:21:16  cblume
  28 Update of the geometry. Get rid of MANY
  29
  30 Revision 1.7  2001/05/11 07:56:12  hristov
  31 Consistent declarations needed on Alpha
  32
  33 Revision 1.6  2001/02/14 18:22:26  cblume
  34 Change in the geometry of the padplane
  35
  36 Revision 1.5  2000/11/01 14:53:21  cblume
  37 Merge with TRD-develop
  38
  39 Revision 1.1.4.6  2000/10/15 23:40:01  cblume
  40 Remove AliTRDconst
  41
  42 Revision 1.1.4.5  2000/10/06 16:49:46  cblume
  43 Made Getters const
  44
  45 Revision 1.1.4.4  2000/10/04 16:34:58  cblume
  46 Replace include files by forward declarations
  47
  48 Revision 1.1.4.3  2000/09/22 14:43:41  cblume
  49 Allow the pad/timebin-dimensions to be changed after initialization
  50
  51 Revision 1.4  2000/10/02 21:28:19  fca
  52 Removal of useless dependecies via forward declarations
  53
  54 Revision 1.3  2000/06/08 18:32:58  cblume
  55 Make code compliant to coding conventions
  56
  57 Revision 1.2  2000/05/08 16:17:27  cblume
  58 Merge TRD-develop
  59
  60 Revision 1.1.4.2  2000/05/08 14:46:44  cblume
  61 Include options SetPHOShole() and SetRICHhole()
  62
  63 Revision 1.1.4.1  2000/04/27 12:46:04  cblume
  64 Corrected bug in full geometry
  65
  66 Revision 1.1  2000/02/28 19:01:15  cblume
  67 Add new TRD classes
  68
  69 */
  70
  71 ///////////////////////////////////////////////////////////////////////////////
  72 //                                                                           //
  73 //  TRD geometry for the spaceframe without holes                            //
  74 //                                                                           //
  75 ///////////////////////////////////////////////////////////////////////////////
  76
  77 #include "TVirtualMC.h"
  78
  79 #include "AliTRDgeometryFull.h"
  80 #include "AliTRDparameter.h"
  81
  82 ClassImp(AliTRDgeometryFull)
  83
  84 //_____________________________________________________________________________
  85 AliTRDgeometryFull::AliTRDgeometryFull():AliTRDgeometry()
  86 {
  87   //
  88   // AliTRDgeometryFull default constructor
  89   //
  90
  91   Init();
  92
  93 }
  94
  95 //_____________________________________________________________________________
  96 AliTRDgeometryFull::~AliTRDgeometryFull()
  97 {
  98   //
  99   // AliTRDgeometryFull destructor
 100   //
 101
 102 }
 103
 104 //_____________________________________________________________________________
 105 void AliTRDgeometryFull::Init()
 106 {
 107   //
 108   // Initializes the geometry parameter
 109   //
 110
 111   Int_t icham;
 112   Int_t iplan;
 113
 114   fPHOShole = kFALSE;
 115   fRICHhole = kFALSE;
 116
 117   // The outer lengths of the chambers for the sectors with holes for the PHOS
 118   Float_t lengthPH[kNplan][kNcham] = { { 124.0, 117.0,   0.0, 117.0, 124.0 }
 119                                      , { 131.0, 124.0,   0.0, 124.0, 131.0 }
 120                                      , { 138.0, 131.0,   0.0, 131.0, 138.0 }
 121                                      , { 145.0, 138.0,   0.0, 138.0, 145.0 }
 122                                      , { 147.0, 140.0,   0.0, 140.0, 147.0 }
 123                                      , { 147.0, 140.0,   0.0, 140.0, 147.0 } };
 124
 125   // The outer lengths of the chambers for the sectors with holes for the RICH
 126   Float_t lengthRH[kNplan][kNcham] = { {  87.5,   0.0,   0.0,   0.0,  87.5 }
 127                                      , { 101.5,   0.0,   0.0,   0.0, 101.5 }
 128                                      , { 115.5,   0.0,   0.0,   0.0, 115.5 }
 129                                      , { 129.5,   0.0,   0.0,   0.0, 129.5 }
 130                                      , { 133.5,   0.0,   0.0,   0.0, 133.5 }
 131                                      , { 133.5,   0.0,   0.0,   0.0, 133.5 } };
 132
 133   for (icham = 0; icham < kNcham; icham++) {
 134     for (iplan = 0; iplan < kNplan; iplan++) {
 135       fClengthPH[iplan][icham] = lengthPH[iplan][icham];
 136       fClengthRH[iplan][icham] = lengthRH[iplan][icham];
 137     }
 138   }
 139
 140 }
 141
 142 //_____________________________________________________________________________
 143 void AliTRDgeometryFull::CreateGeometry(Int_t *idtmed)
 144 {
 145   //
 146   // Create the TRD geometry without hole
 147   //
 148   //
 149   // Names of the TRD volumina (xx = detector number):
 150   //
 151   //      Lower part of the readout chambers (gas volume + radiator)
 152   //
 153   //        UAxx    Aluminum frames             (Al)
 154   //        UBxx    G10 frames                  (C)
 155   //        UCxx    Inner volumes               (Air)
 156   //
 157   //      Upper part of the readout chambers (readout plane + fee)
 158   //
 159   //        UDxx    G10 frames                  (C)
 160   //        UExx    Inner volumes of the G10    (Air)
 161   //        UFxx    Aluminum frames             (Al)
 162   //        UGxx    Inner volumes of the Al     (Air)
 163   //
 164   //      Inner material layers
 165   //
 166   //        UHxx    Radiator                    (Rohacell)
 167   //        UIxx    Entrance window             (Mylar)
 168   //        UJxx    Drift volume                (Xe/CO2)
 169   //        UKxx    Amplification volume        (Xe/CO2)
 170   //        ULxx    Pad plane                   (Cu)
 171   //        UMxx    Support structure           (Rohacell)
 172   //
 173
 174   const Int_t kNdet    = kNplan * kNcham;
 175
 176   const Int_t kNparTrd = 4;
 177   const Int_t kNparCha = 3;
 178
 179   Float_t xpos, ypos, zpos;
 180
 181   Float_t parTrd[kNparTrd];
 182   Float_t parCha[kNparCha];
 183
 184   Char_t  cTagV[5];
 185   Char_t  cTagM[5];
 186
 187   AliTRDgeometry::CreateGeometry(idtmed);
 188
 189   // The TRD mother volume for one sector (Air), full length in z-direction
 190   // Provides material for side plates of super module
 191   parTrd[0] = fgkSwidth1/2.;
 192   parTrd[1] = fgkSwidth2/2.;
 193   parTrd[2] = fgkSlenTR1/2.;
 194   parTrd[3] = fgkSheight/2.;
 195   gMC->Gsvolu("UTR1","TRD1",idtmed[1302-1],parTrd,kNparTrd);
 196   // The TRD mother volume for one sector (Al), leaving hole for PHOS
 197   if (fPHOShole) {
 198     gMC->Gsvolu("UTR2","TRD1",idtmed[1302-1],parTrd,kNparTrd);
 199   }
 200   // The TRD mother volume for one sector (Al), leaving hole for RICH
 201   if (fRICHhole) {
 202     gMC->Gsvolu("UTR3","TRD1",idtmed[1302-1],parTrd,kNparTrd);
 203   }
 204
 205   //
 206   // The side plates of the super module (Al)
 207   parTrd[0] = fgkSwidth1/2. - fgkSMgapT;
 208   parTrd[1] = fgkSwidth2/2. - fgkSMgapT;
 209   parTrd[2] = fgkSlenTR1/2.;
 210   parTrd[3] = fgkSheight/2.;
 211   gMC->Gsvolu("UTS1","TRD1",idtmed[1301-1],parTrd,kNparTrd);
 212   // The TRD mother volume for one sector (Al), leaving hole for PHOS
 213   if (fPHOShole) {
 214     gMC->Gsvolu("UTS2","TRD1",idtmed[1301-1],parTrd,kNparTrd);
 215   }
 216   // The TRD mother volume for one sector (Al), leaving hole for RICH
 217   if (fRICHhole) {
 218     gMC->Gsvolu("UTS3","TRD1",idtmed[1301-1],parTrd,kNparTrd);
 219   }
 220
 221   // The inner part of the TRD mother volume for one sector (Air),
 222   // full length in z-direction
 223   parTrd[0] = fgkSwidth1/2. - fgkSMgapT - fgkSMpltT;
 224   parTrd[1] = fgkSwidth2/2. - fgkSMgapT - fgkSMpltT;
 225   parTrd[2] = fgkSlenTR1/2.;
 226   parTrd[3] = fgkSheight/2.;
 227   gMC->Gsvolu("UTI1","TRD1",idtmed[1302-1],parTrd,kNparTrd);
 228   // The TRD mother volume for one sector (Air), leaving hole for PHOS
 229   if (fPHOShole) {
 230     gMC->Gsvolu("UTI2","TRD1",idtmed[1302-1],parTrd,kNparTrd);
 231   }
 232   // The TRD mother volume for one sector (Air), leaving hole for RICH
 233   if (fRICHhole) {
 234     gMC->Gsvolu("UTI3","TRD1",idtmed[1302-1],parTrd,kNparTrd);
 235   }
 236
 237   for (Int_t icham = 0; icham < kNcham; icham++) {
 238     for (Int_t iplan = 0; iplan < kNplan; iplan++) {
 239
 240       Int_t iDet = GetDetectorSec(iplan,icham);
 241
 242       // The lower part of the readout chambers (gas volume + radiator)
 243       // The aluminum frames
 244       sprintf(cTagV,"UA%02d",iDet);
 245       parCha[0] = fCwidth[iplan]/2.;
 246       parCha[1] = fClength[iplan][icham]/2. - fgkHspace/2.;
 247       parCha[2] = fgkCraH/2. + fgkCdrH/2.;
 248       gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parCha,kNparCha);
 249       // The G10 frames
 250       sprintf(cTagV,"UB%02d",iDet);
 251       parCha[0] = fCwidth[iplan]/2. - fgkCalT;
 252       parCha[1] = -1.;
 253       parCha[2] = -1.;
 254       gMC->Gsvolu(cTagV,"BOX ",idtmed[1307-1],parCha,kNparCha);
 255       // The inner part (air)
 256       sprintf(cTagV,"UC%02d",iDet);
 257       parCha[0] = fCwidth[iplan]/2. - fgkCalT - fgkCclsT;
 258       parCha[1] = fClength[iplan][icham]/2. - fgkHspace/2.- fgkCclfT;
 259       parCha[2] = -1.;
 260       gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
 261       if (fPHOShole) {
 262         if (fClengthPH[iplan][icham] > 0.0) {
 263           // The aluminum frames
 264           sprintf(cTagV,"UA%02d",iDet+kNdet);
 265           parCha[0] = fCwidth[iplan]/2.;
 266           parCha[1] = fClengthPH[iplan][icham]/2. - fgkHspace/2.;
 267           parCha[2] = fgkCraH/2. + fgkCdrH/2.;
 268           gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parCha,kNparCha);
 269           // The G10 frames
 270           sprintf(cTagV,"UB%02d",iDet+kNdet);
 271           parCha[0] = fCwidth[iplan]/2. - fgkCalT;
 272           parCha[1] = -1.;
 273           parCha[2] = -1.;
 274           gMC->Gsvolu(cTagV,"BOX ",idtmed[1307-1],parCha,kNparCha);
 275           // The inner part (air)
 276           sprintf(cTagV,"UC%02d",iDet+kNdet);
 277           parCha[0] = fCwidth[iplan]/2. - fgkCalT - fgkCclsT;
 278           parCha[1] = fClengthPH[iplan][icham]/2. - fgkHspace/2.- fgkCclfT;
 279           parCha[2] = -1.;
 280           gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
 281         }
 282       }
 283       if (fRICHhole) {
 284         if (fClengthRH[iplan][icham] > 0.0) {
 285           // The aluminum frames
 286           sprintf(cTagV,"UA%02d",iDet+2*kNdet);
 287           parCha[0] = fCwidth[iplan]/2.;
 288           parCha[1] = fClengthRH[iplan][icham]/2. - fgkHspace/2.;
 289           parCha[2] = fgkCraH/2. + fgkCdrH/2.;
 290           gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parCha,kNparCha);
 291           // The G10 frames
 292           sprintf(cTagV,"UB%02d",iDet+2*kNdet);
 293           parCha[0] = fCwidth[iplan]/2. - fgkCalT;
 294           parCha[1] = -1.;
 295           parCha[2] = -1.;
 296           gMC->Gsvolu(cTagV,"BOX ",idtmed[1307-1],parCha,kNparCha);
 297           // The inner part (air)
 298           sprintf(cTagV,"UC%02d",iDet+2*kNdet);
 299           parCha[0] = fCwidth[iplan]/2. - fgkCalT - fgkCclsT;
 300           parCha[1] = fClengthRH[iplan][icham]/2. - fgkHspace/2.- fgkCclfT;
 301           parCha[2] = -1.;
 302           gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
 303         }
 304       }
 305
 306       // The upper part of the readout chambers (readout plane)
 307       // The G10 frames
 308       sprintf(cTagV,"UD%02d",iDet);
 309       parCha[0] = fCwidth[iplan]/2. + fgkCroW;
 310       parCha[1] = fClength[iplan][icham]/2. - fgkHspace/2.;
 311       parCha[2] = fgkCamH/2.;
 312       gMC->Gsvolu(cTagV,"BOX ",idtmed[1307-1],parCha,kNparCha);
 313       // The inner part of the G10 frame (air)
 314       sprintf(cTagV,"UE%02d",iDet);
 315       parCha[0] = fCwidth[iplan]/2. + fgkCroW - fgkCcuT;
 316       parCha[1] = fClength[iplan][icham]/2. - fgkHspace/2.- fgkCcuT;
 317       parCha[2] = -1.;
 318       gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
 319       // The aluminum frames
 320       sprintf(cTagV,"UF%02d",iDet);
 321       parCha[0] = fCwidth[iplan]/2. + fgkCroW;
 322       parCha[1] = fClength[iplan][icham]/2. - fgkHspace/2.;
 323       parCha[2] = fgkCroH/2.;
 324       gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parCha,kNparCha);
 325       // The inner part of the aluminum frames
 326       sprintf(cTagV,"UG%02d",iDet);
 327       parCha[0] = fCwidth[iplan]/2. + fgkCroW - fgkCauT;
 328       parCha[1] = fClength[iplan][icham]/2. - fgkHspace/2.- fgkCauT;
 329       parCha[2] = -1.;
 330       gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
 331       if (fPHOShole) {
 332         if (fClengthPH[iplan][icham] > 0.0) {
 333           sprintf(cTagV,"UD%02d",iDet+kNdet);
 334           parCha[0] = fCwidth[iplan]/2. + fgkCroW;
 335           parCha[1] = fClengthPH[iplan][icham]/2. - fgkHspace/2.;
 336           parCha[2] = fgkCamH/2.;
 337           gMC->Gsvolu(cTagV,"BOX ",idtmed[1307-1],parCha,kNparCha);
 338           // The inner part of the G10 frame (air)
 339           sprintf(cTagV,"UE%02d",iDet+kNdet);
 340           parCha[0] = fCwidth[iplan]/2. + fgkCroW - fgkCcuT;
 341           parCha[1] = fClengthPH[iplan][icham]/2. - fgkHspace/2.- fgkCcuT;
 342           parCha[2] = -1.;
 343           gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
 344           // The aluminum frames
 345           sprintf(cTagV,"UF%02d",iDet+kNdet);
 346           parCha[0] = fCwidth[iplan]/2. + fgkCroW;
 347           parCha[1] = fClengthPH[iplan][icham]/2. - fgkHspace/2.;
 348           parCha[2] = fgkCroH/2.;
 349           gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parCha,kNparCha);
 350           // The inner part of the aluminum frames
 351           sprintf(cTagV,"UG%02d",iDet+kNdet);
 352           parCha[0] = fCwidth[iplan]/2. + fgkCroW - fgkCauT;
 353           parCha[1] = fClengthPH[iplan][icham]/2. - fgkHspace/2.- fgkCauT;
 354           parCha[2] = -1.;
 355           gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
 356         }
 357       }
 358       if (fRICHhole) {
 359         if (fClengthRH[iplan][icham] > 0.0) {
 360           sprintf(cTagV,"UD%02d",iDet+2*kNdet);
 361           parCha[0] = fCwidth[iplan]/2. + fgkCroW;
 362           parCha[1] = fClengthRH[iplan][icham]/2. - fgkHspace/2.;
 363           parCha[2] = fgkCamH/2.;
 364           gMC->Gsvolu(cTagV,"BOX ",idtmed[1307-1],parCha,kNparCha);
 365           // The inner part of the G10 frame (air)
 366           sprintf(cTagV,"UE%02d",iDet+2*kNdet);
 367           parCha[0] = fCwidth[iplan]/2. + fgkCroW - fgkCcuT;
 368           parCha[1] = fClengthRH[iplan][icham]/2. - fgkHspace/2.- fgkCcuT;
 369           parCha[2] = -1.;
 370           gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
 371           // The aluminum frames
 372           sprintf(cTagV,"UF%02d",iDet+2*kNdet);
 373           parCha[0] = fCwidth[iplan]/2. + fgkCroW;
 374           parCha[1] = fClengthRH[iplan][icham]/2. - fgkHspace/2.;
 375           parCha[2] = fgkCroH/2.;
 376           gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parCha,kNparCha);
 377           // The inner part of the aluminum frames
 378           sprintf(cTagV,"UG%02d",iDet+2*kNdet);
 379           parCha[0] = fCwidth[iplan]/2. + fgkCroW - fgkCauT;
 380           parCha[1] = fClengthRH[iplan][icham]/2. - fgkHspace/2.- fgkCauT;
 381           parCha[2] = -1.;
 382           gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
 383         }
 384       }
 385
 386       // The material layers inside the chambers
 387       parCha[0] = -1.;
 388       parCha[1] = -1.;
 389       // Rohacell layer (radiator)
 390       parCha[2] = fgkRaThick/2;
 391       sprintf(cTagV,"UH%02d",iDet);
 392       gMC->Gsvolu(cTagV,"BOX ",idtmed[1315-1],parCha,kNparCha);
 393       // Mylar layer (entrance window + HV cathode)
 394       parCha[2] = fgkMyThick/2;
 395       sprintf(cTagV,"UI%02d",iDet);
 396       gMC->Gsvolu(cTagV,"BOX ",idtmed[1308-1],parCha,kNparCha);
 397       // Xe/Isobutane layer (drift volume)
 398       parCha[2] = fgkDrThick/2.;
 399       sprintf(cTagV,"UJ%02d",iDet);
 400       gMC->Gsvolu(cTagV,"BOX ",idtmed[1309-1],parCha,kNparCha);
 401       // Xe/Isobutane layer (amplification volume)
 402       parCha[2] = fgkAmThick/2.;
 403       sprintf(cTagV,"UK%02d",iDet);
 404       gMC->Gsvolu(cTagV,"BOX ",idtmed[1309-1],parCha,kNparCha);
 405       // Cu layer (pad plane)
 406       parCha[2] = fgkCuThick/2;
 407       sprintf(cTagV,"UL%02d",iDet);
 408       gMC->Gsvolu(cTagV,"BOX ",idtmed[1305-1],parCha,kNparCha);
 409       // G10 layer (support structure / honeycomb)
 410       parCha[2] = fgkSuThick/2;
 411       sprintf(cTagV,"UM%02d",iDet);
 412       gMC->Gsvolu(cTagV,"BOX ",idtmed[1313-1],parCha,kNparCha);
 413       if (fPHOShole) {
 414         if (fClengthPH[iplan][icham] > 0.0) {
 415           // Rohacell layer (radiator)
 416           parCha[2] = fgkRaThick/2;
 417           sprintf(cTagV,"UH%02d",iDet+kNdet);
 418           gMC->Gsvolu(cTagV,"BOX ",idtmed[1315-1],parCha,kNparCha);
 419           // Mylar layer (entrance window + HV cathode)
 420           parCha[2] = fgkMyThick/2;
 421           sprintf(cTagV,"UI%02d",iDet+kNdet);
 422           gMC->Gsvolu(cTagV,"BOX ",idtmed[1308-1],parCha,kNparCha);
 423           // Xe/Isobutane layer (drift volume)
 424           parCha[2] = fgkDrThick/2.;
 425           sprintf(cTagV,"UJ%02d",iDet+kNdet);
 426           gMC->Gsvolu(cTagV,"BOX ",idtmed[1309-1],parCha,kNparCha);
 427           // Xe/Isobutane layer (amplification volume)
 428           parCha[2] = fgkAmThick/2.;
 429           sprintf(cTagV,"UK%02d",iDet+kNdet);
 430           gMC->Gsvolu(cTagV,"BOX ",idtmed[1309-1],parCha,kNparCha);
 431           // Cu layer (pad plane)
 432           parCha[2] = fgkCuThick/2;
 433           sprintf(cTagV,"UL%02d",iDet+kNdet);
 434           gMC->Gsvolu(cTagV,"BOX ",idtmed[1305-1],parCha,kNparCha);
 435           // G10 layer (support structure / honeycomb)
 436           parCha[2] = fgkSuThick/2;
 437           sprintf(cTagV,"UM%02d",iDet+kNdet);
 438           gMC->Gsvolu(cTagV,"BOX ",idtmed[1313-1],parCha,kNparCha);
 439         }
 440       }
 441       if (fRICHhole) {
 442         if (fClengthRH[iplan][icham] > 0.0) {
 443           // Rohacell layer (radiator)
 444           parCha[2] = fgkRaThick/2;
 445           sprintf(cTagV,"UH%02d",iDet+2*kNdet);
 446           gMC->Gsvolu(cTagV,"BOX ",idtmed[1315-1],parCha,kNparCha);
 447           // Mylar layer (entrance window + HV cathode)
 448           parCha[2] = fgkMyThick/2;
 449           sprintf(cTagV,"UI%02d",iDet+2*kNdet);
 450           gMC->Gsvolu(cTagV,"BOX ",idtmed[1308-1],parCha,kNparCha);
 451           // Xe/Isobutane layer (drift volume)
 452           parCha[2] = fgkDrThick/2.;
 453           sprintf(cTagV,"UJ%02d",iDet+2*kNdet);
 454           gMC->Gsvolu(cTagV,"BOX ",idtmed[1309-1],parCha,kNparCha);
 455           // Xe/Isobutane layer (amplification volume)
 456           parCha[2] = fgkAmThick/2.;
 457           sprintf(cTagV,"UK%02d",iDet+2*kNdet);
 458           gMC->Gsvolu(cTagV,"BOX ",idtmed[1309-1],parCha,kNparCha);
 459           // Cu layer (pad plane)
 460           parCha[2] = fgkCuThick/2;
 461           sprintf(cTagV,"UL%02d",iDet+2*kNdet);
 462           gMC->Gsvolu(cTagV,"BOX ",idtmed[1305-1],parCha,kNparCha);
 463           // G10 layer (support structure / honeycomb)
 464           parCha[2] = fgkSuThick/2;
 465           sprintf(cTagV,"UM%02d",iDet+2*kNdet);
 466           gMC->Gsvolu(cTagV,"BOX ",idtmed[1313-1],parCha,kNparCha);
 467         }
 468       }
 469
 470       // Position the layers in the chambers
 471       xpos = 0;
 472       ypos = 0;
 473       // Lower part
 474       // Rohacell layer (radiator)
 475       zpos = fgkRaZpos;
 476       sprintf(cTagV,"UH%02d",iDet);
 477       sprintf(cTagM,"UC%02d",iDet);
 478       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 479       // Mylar layer (entrance window + HV cathode)
 480       zpos = fgkMyZpos;
 481       sprintf(cTagV,"UI%02d",iDet);
 482       sprintf(cTagM,"UC%02d",iDet);
 483       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 484       // Xe/Isobutane layer (drift volume)
 485       zpos = fgkDrZpos;
 486       sprintf(cTagV,"UJ%02d",iDet);
 487       sprintf(cTagM,"UC%02d",iDet);
 488       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 489       // Upper part
 490       // Xe/Isobutane layer (amplification volume)
 491       zpos = fgkAmZpos;
 492       sprintf(cTagV,"UK%02d",iDet);
 493       sprintf(cTagM,"UE%02d",iDet);
 494       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 495       // Readout part
 496       // Cu layer (pad plane)
 497       zpos = fgkCuZpos;
 498       sprintf(cTagV,"UL%02d",iDet);
 499       sprintf(cTagM,"UG%02d",iDet);
 500       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 501       // G10 layer (support structure)
 502       zpos = fgkSuZpos;
 503       sprintf(cTagV,"UM%02d",iDet);
 504       sprintf(cTagM,"UG%02d",iDet);
 505       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 506       if (fPHOShole) {
 507         if (fClengthPH[iplan][icham] > 0.0) {
 508           // Lower part
 509           // Rohacell layer (radiator)
 510           zpos = fgkRaZpos;
 511           sprintf(cTagV,"UH%02d",iDet+kNdet);
 512           sprintf(cTagM,"UC%02d",iDet+kNdet);
 513           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 514           // Mylar layer (entrance window + HV cathode)
 515           zpos = fgkMyZpos;
 516           sprintf(cTagV,"UI%02d",iDet+kNdet);
 517           sprintf(cTagM,"UC%02d",iDet+kNdet);
 518           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 519           // Xe/Isobutane layer (drift volume)
 520           zpos = fgkDrZpos;
 521           sprintf(cTagV,"UJ%02d",iDet+kNdet);
 522           sprintf(cTagM,"UC%02d",iDet+kNdet);
 523           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 524           // Upper part
 525           // Xe/Isobutane layer (amplification volume)
 526           zpos = fgkAmZpos;
 527           sprintf(cTagV,"UK%02d",iDet+kNdet);
 528           sprintf(cTagM,"UE%02d",iDet+kNdet);
 529           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 530           // Readout part
 531           // Cu layer (pad plane)
 532           zpos = fgkCuZpos;
 533           sprintf(cTagV,"UL%02d",iDet+kNdet);
 534           sprintf(cTagM,"UG%02d",iDet+kNdet);
 535           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 536           // G10 layer (support structure)
 537           zpos = fgkSuZpos;
 538           sprintf(cTagV,"UM%02d",iDet+kNdet);
 539           sprintf(cTagM,"UG%02d",iDet+kNdet);
 540           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 541         }
 542       }
 543       if (fRICHhole) {
 544         if (fClengthRH[iplan][icham] > 0.0) {
 545           // Lower part
 546           // Rohacell layer (radiator)
 547           zpos = fgkRaZpos;
 548           sprintf(cTagV,"UH%02d",iDet+2*kNdet);
 549           sprintf(cTagM,"UC%02d",iDet+2*kNdet);
 550           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 551           // Mylar layer (entrance window + HV cathode)
 552           zpos = fgkMyZpos;
 553           sprintf(cTagV,"UI%02d",iDet+2*kNdet);
 554           sprintf(cTagM,"UC%02d",iDet+2*kNdet);
 555           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 556           // Xe/Isobutane layer (drift volume)
 557           zpos = fgkDrZpos;
 558           sprintf(cTagV,"UJ%02d",iDet+2*kNdet);
 559           sprintf(cTagM,"UC%02d",iDet+2*kNdet);
 560           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 561           // Upper part
 562           // Xe/Isobutane layer (amplification volume)
 563           zpos = fgkAmZpos;
 564           sprintf(cTagV,"UK%02d",iDet+2*kNdet);
 565           sprintf(cTagM,"UE%02d",iDet+2*kNdet);
 566           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 567           // Readout part
 568           // Cu layer (pad plane)
 569           zpos = fgkCuZpos;
 570           sprintf(cTagV,"UL%02d",iDet+2*kNdet);
 571           sprintf(cTagM,"UG%02d",iDet+2*kNdet);
 572           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 573           // G10 layer (support structure)
 574           zpos = fgkSuZpos;
 575           sprintf(cTagV,"UM%02d",iDet+2*kNdet);
 576           sprintf(cTagM,"UG%02d",iDet+2*kNdet);
 577           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 578         }
 579       }
 580
 581       // Position the inner volumes of the chambers in the frames
 582       xpos      = 0.0;
 583       ypos      = 0.0;
 584       zpos      = 0.0;
 585       // The inside of the lower G10 frame
 586       sprintf(cTagV,"UC%02d",iDet);
 587       sprintf(cTagM,"UB%02d",iDet);
 588       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 589       // The lower G10 frame inside the aluminum frame
 590       sprintf(cTagV,"UB%02d",iDet);
 591       sprintf(cTagM,"UA%02d",iDet);
 592       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 593       // The inside of the upper G10 frame
 594       sprintf(cTagV,"UE%02d",iDet);
 595       sprintf(cTagM,"UD%02d",iDet);
 596       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 597       // The inside of the upper aluminum frame
 598       sprintf(cTagV,"UG%02d",iDet);
 599       sprintf(cTagM,"UF%02d",iDet);
 600       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 601       if (fPHOShole) {
 602         if (fClengthPH[iplan][icham] > 0.0) {
 603           // The inside of the lower G10 frame
 604           sprintf(cTagV,"UC%02d",iDet+kNdet);
 605           sprintf(cTagM,"UB%02d",iDet+kNdet);
 606           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 607           // The lower G10 frame inside the aluminum frame
 608           sprintf(cTagV,"UB%02d",iDet+kNdet);
 609           sprintf(cTagM,"UA%02d",iDet+kNdet);
 610           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 611           // The inside of the upper G10 frame
 612           sprintf(cTagV,"UE%02d",iDet+kNdet);
 613           sprintf(cTagM,"UD%02d",iDet+kNdet);
 614           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 615           // The inside of the upper aluminum frame
 616           sprintf(cTagV,"UG%02d",iDet+kNdet);
 617           sprintf(cTagM,"UF%02d",iDet+kNdet);
 618           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 619         }
 620       }
 621       if (fRICHhole) {
 622         if (fClengthRH[iplan][icham] > 0.0) {
 623           // The inside of the lower G10 frame
 624           sprintf(cTagV,"UC%02d",iDet+2*kNdet);
 625           sprintf(cTagM,"UB%02d",iDet+2*kNdet);
 626           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 627           // The lower G10 frame inside the aluminum frame
 628           sprintf(cTagV,"UB%02d",iDet+2*kNdet);
 629           sprintf(cTagM,"UA%02d",iDet+2*kNdet);
 630           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 631           // The inside of the upper G10 frame
 632           sprintf(cTagV,"UE%02d",iDet+2*kNdet);
 633           sprintf(cTagM,"UD%02d",iDet+2*kNdet);
 634           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 635           // The inside of the upper aluminum frame
 636           sprintf(cTagV,"UG%02d",iDet+2*kNdet);
 637           sprintf(cTagM,"UF%02d",iDet+2*kNdet);
 638           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 639         }
 640       }
 641
 642       // Position the frames of the chambers in the TRD mother volume
 643       xpos  = 0.;
 644       ypos  = - fClength[iplan][0] - fClength[iplan][1] - fClength[iplan][2]/2.;
 645       for (Int_t ic = 0; ic < icham; ic++) {
 646         ypos += fClength[iplan][ic];
 647       }
 648       ypos += fClength[iplan][icham]/2.;
 649       zpos  = fgkCraH/2. + fgkCdrH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
 650       // The lower aluminum frame, radiator + drift region
 651       sprintf(cTagV,"UA%02d",iDet);
 652       gMC->Gspos(cTagV,1,"UTI1",xpos,ypos,zpos,0,"ONLY");
 653       // The upper G10 frame, amplification region
 654       sprintf(cTagV,"UD%02d",iDet);
 655       zpos += fgkCamH/2. + fgkCraH/2. + fgkCdrH/2.;
 656       gMC->Gspos(cTagV,1,"UTI1",xpos,ypos,zpos,0,"ONLY");
 657       // The upper aluminum frame
 658       sprintf(cTagV,"UF%02d",iDet);
 659       zpos += fgkCroH/2. + fgkCamH/2.;
 660       gMC->Gspos(cTagV,1,"UTI1",xpos,ypos,zpos,0,"ONLY");
 661       if (fPHOShole) {
 662         if (fClengthPH[iplan][icham] > 0.0) {
 663           xpos  = 0.;
 664           ypos  = - fClength[iplan][0] - fClength[iplan][1] - fClength[iplan][2]/2.;
 665           for (Int_t ic = 0; ic < icham; ic++) {
 666             ypos += fClength[iplan][ic];
 667           }
 668           if (icham > 2) {
 669             ypos += fClength[iplan][icham];
 670             ypos -= fClengthPH[iplan][icham]/2.;
 671           }
 672           else {
 673             ypos += fClengthPH[iplan][icham]/2.;
 674           }
 675           zpos  = fgkCraH/2. + fgkCdrH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
 676           // The lower aluminum frame, radiator + drift region
 677           sprintf(cTagV,"UA%02d",iDet+kNdet);
 678           gMC->Gspos(cTagV,1,"UTI2",xpos,ypos,zpos,0,"ONLY");
 679           // The upper G10 frame, amplification region
 680           sprintf(cTagV,"UD%02d",iDet+kNdet);
 681           zpos += fgkCamH/2. + fgkCraH/2. + fgkCdrH/2.;
 682           gMC->Gspos(cTagV,1,"UTI2",xpos,ypos,zpos,0,"ONLY");
 683           // The upper aluminum frame
 684           sprintf(cTagV,"UF%02d",iDet+kNdet);
 685           zpos += fgkCroH/2. + fgkCamH/2.;
 686           gMC->Gspos(cTagV,1,"UTI2",xpos,ypos,zpos,0,"ONLY");
 687         }
 688       }
 689       if (fRICHhole) {
 690         if (fClengthRH[iplan][icham] > 0.0) {
 691           xpos  = 0.;
 692           ypos  = - fClength[iplan][0] - fClength[iplan][1] - fClength[iplan][2]/2.;
 693           for (Int_t ic = 0; ic < icham; ic++) {
 694             ypos += fClength[iplan][ic];
 695           }
 696           if (icham > 2) {
 697             ypos += fClength[iplan][icham];
 698             ypos -= fClengthRH[iplan][icham]/2.;
 699           }
 700           else {
 701             ypos += fClengthRH[iplan][icham]/2.;
 702           }
 703           zpos  = fgkCraH/2. + fgkCdrH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
 704           // The lower aluminum frame, radiator + drift region
 705           sprintf(cTagV,"UA%02d",iDet+2*kNdet);
 706           gMC->Gspos(cTagV,1,"UTI3",xpos,ypos,zpos,0,"ONLY");
 707           // The upper G10 frame, amplification region
 708           sprintf(cTagV,"UD%02d",iDet+2*kNdet);
 709           zpos += fgkCamH/2. + fgkCraH/2. + fgkCdrH/2.;
 710           gMC->Gspos(cTagV,1,"UTI3",xpos,ypos,zpos,0,"ONLY");
 711           // The upper aluminum frame
 712           sprintf(cTagV,"UF%02d",iDet+2*kNdet);
 713           zpos += fgkCroH/2. + fgkCamH/2.;
 714           gMC->Gspos(cTagV,1,"UTI3",xpos,ypos,zpos,0,"ONLY");
 715         }
 716       }
 717
 718     }
 719   }
 720
 721   xpos = 0.;
 722   ypos = 0.;
 723   zpos = 0.;
 724   gMC->Gspos("UTI1",1,"UTS1",xpos,ypos,zpos,0,"ONLY");
 725   if (fPHOShole) {
 726     gMC->Gspos("UTI2",2,"UTS2",xpos,ypos,zpos,0,"ONLY");
 727   }
 728   if (fRICHhole) {
 729     gMC->Gspos("UTI3",3,"UTS3",xpos,ypos,zpos,0,"ONLY");
 730   }
 731
 732   xpos = 0.;
 733   ypos = 0.;
 734   zpos = 0.;
 735   gMC->Gspos("UTS1",1,"UTR1",xpos,ypos,zpos,0,"ONLY");
 736   if (fPHOShole) {
 737     gMC->Gspos("UTS2",2,"UTR2",xpos,ypos,zpos,0,"ONLY");
 738   }
 739   if (fRICHhole) {
 740     gMC->Gspos("UTS3",3,"UTR3",xpos,ypos,zpos,0,"ONLY");
 741   }
 742
 743   xpos = 0.;
 744   ypos = 0.;
 745   zpos = 0.;
 746   gMC->Gspos("UTR1",1,"BTR1",xpos,ypos,zpos,0,"ONLY");
 747   if (fPHOShole) {
 748     gMC->Gspos("UTR2",2,"BTR2",xpos,ypos,zpos,0,"ONLY");
 749   }
 750   else {
 751     gMC->Gspos("UTR1",2,"BTR2",xpos,ypos,zpos,0,"ONLY");
 752   }
 753   if (fRICHhole) {
 754     gMC->Gspos("UTR3",3,"BTR3",xpos,ypos,zpos,0,"ONLY");
 755   }
 756   else {
 757     gMC->Gspos("UTR1",3,"BTR3",xpos,ypos,zpos,0,"ONLY");
 758   }
 759
 760   // Create the volumes of the super module frame
 761   CreateFrame(idtmed);
 762
 763   // Create the volumes of the services
 764   CreateServices(idtmed);
 765
 766 }
 767
 768 //_____________________________________________________________________________
 769 void AliTRDgeometryFull::CreateFrame(Int_t *idtmed)
 770 {
 771   //
 772   // Create the geometry of the frame of the supermodule
 773   //
 774   // Names of the TRD services volumina
 775   //
 776   //        USRL    Support rails for the chambers (Al)
 777   //        USxx    Support cross bars between the chambers (Al)
 778   //
 779
 780   Int_t   iplan = 0;
 781
 782   Float_t xpos  = 0.0;
 783   Float_t ypos  = 0.0;
 784   Float_t zpos  = 0.0;
 785
 786   Char_t  cTagV[5];
 787
 788   //
 789   // The chamber support rails
 790   //
 791
 792   const Float_t kSRLwid  = 2.0;
 793   const Float_t kSRLhgt  = 2.3;
 794   const Float_t kSRLdst  = 0.6;
 795   const Int_t   kNparSRL = 3;
 796   Float_t parSRL[kNparSRL];
 797   parSRL[0] = kSRLwid/2.;
 798   parSRL[1] = fgkSlenTR1/2.;
 799   parSRL[2] = kSRLhgt/2.;
 800   gMC->Gsvolu("USRL","BOX ",idtmed[1301-1],parSRL,kNparSRL);
 801
 802   xpos  = 0.0;
 803   ypos  = 0.0;
 804   zpos  = 0.0;
 805   for (iplan = 0; iplan < kNplan; iplan++) {
 806
 807     xpos  = fCwidth[iplan]/2. + kSRLwid/2. + kSRLdst;
 808     ypos  = 0.0;
 809     zpos  = fgkCraH + fgkCdrH - fgkSheight/2. - kSRLhgt/2.
 810           + iplan * (fgkCH + fgkVspace);
 811     gMC->Gspos("USRL",iplan+1         ,"UTI1", xpos,ypos,zpos,0,"ONLY");
 812     gMC->Gspos("USRL",iplan+1+  kNplan,"UTI1",-xpos,ypos,zpos,0,"ONLY");
 813     if (fPHOShole) {
 814       gMC->Gspos("USRL",iplan+1+2*kNplan,"UTI2", xpos,ypos,zpos,0,"ONLY");
 815       gMC->Gspos("USRL",iplan+1+3*kNplan,"UTI2",-xpos,ypos,zpos,0,"ONLY");
 816     }
 817     if (fRICHhole) {
 818       gMC->Gspos("USRL",iplan+1+4*kNplan,"UTI3", xpos,ypos,zpos,0,"ONLY");
 819       gMC->Gspos("USRL",iplan+1+5*kNplan,"UTI3",-xpos,ypos,zpos,0,"ONLY");
 820     }
 821
 822   }
 823
 824   //
 825   // The cross bars between the chambers
 826   //
 827
 828   const Float_t kSCBwid  = 1.0;
 829   const Int_t   kNparSCB = 3;
 830   Float_t parSCB[kNparSCB];
 831   parSCB[1] = kSCBwid/2.;
 832   parSCB[2] = fgkCH/2.;
 833
 834   xpos  = 0.0;
 835   ypos  = 0.0;
 836   zpos  = 0.0;
 837   for (iplan = 0; iplan < kNplan; iplan++) {
 838
 839     parSCB[0] = fCwidth[iplan]/2. + kSRLdst/2.;
 840
 841     sprintf(cTagV,"US0%01d",iplan);
 842     gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
 843     xpos  = 0.0;
 844     ypos  =   fgkSlenTR1/2. - kSCBwid/2.;
 845     zpos  = fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
 846     gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
 847     if (fPHOShole) {
 848       gMC->Gspos(cTagV,2,"UTI2", xpos,ypos,zpos,0,"ONLY");
 849     }
 850     if (fRICHhole) {
 851       gMC->Gspos(cTagV,3,"UTI3", xpos,ypos,zpos,0,"ONLY");
 852     }
 853
 854     sprintf(cTagV,"US1%01d",iplan);
 855     gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
 856     xpos  = 0.0;
 857     ypos  = fClength[iplan][2]/2. + fClength[iplan][1];
 858     zpos  = fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
 859     gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
 860     if (fPHOShole) {
 861       gMC->Gspos(cTagV,2,"UTI2", xpos,ypos,zpos,0,"ONLY");
 862     }
 863     if (fRICHhole) {
 864       ypos += fClength[iplan][0] - fClengthRH[iplan][0];
 865       gMC->Gspos(cTagV,3,"UTI3", xpos,ypos,zpos,0,"ONLY");
 866     }
 867
 868     sprintf(cTagV,"US2%01d",iplan);
 869     gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
 870     xpos  = 0.0;
 871     ypos  = fClength[iplan][2]/2.;
 872     zpos  = fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
 873     gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
 874     if (fPHOShole) {
 875       ypos += fClength[iplan][1] - fClengthPH[iplan][1];
 876       gMC->Gspos(cTagV,2,"UTI2", xpos,ypos,zpos,0,"ONLY");
 877     }
 878
 879     sprintf(cTagV,"US3%01d",iplan);
 880     gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
 881     xpos  = 0.0;
 882     ypos  = - fClength[iplan][2]/2.;
 883     zpos  = fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
 884     gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
 885     if (fPHOShole) {
 886       ypos -= fClength[iplan][3] - fClengthPH[iplan][3];
 887       gMC->Gspos(cTagV,2,"UTI2", xpos,ypos,zpos,0,"ONLY");
 888     }
 889
 890     sprintf(cTagV,"US4%01d",iplan);
 891     gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
 892     xpos  = 0.0;
 893     ypos  = - fClength[iplan][2]/2. - fClength[iplan][1];
 894     zpos  = fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
 895     gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
 896     if (fPHOShole) {
 897       gMC->Gspos(cTagV,2,"UTI2", xpos,ypos,zpos,0,"ONLY");
 898     }
 899     if (fRICHhole) {
 900       ypos -= fClength[iplan][4] - fClengthRH[iplan][4];
 901       gMC->Gspos(cTagV,3,"UTI3", xpos,ypos,zpos,0,"ONLY");
 902     }
 903
 904     sprintf(cTagV,"US5%01d",iplan);
 905     gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
 906     xpos  = 0.0;
 907     ypos  = - fgkSlenTR1/2. + kSCBwid/2.;
 908     zpos  = fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
 909     gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
 910     if (fPHOShole) {
 911       gMC->Gspos(cTagV,2,"UTI2", xpos,ypos,zpos,0,"ONLY");
 912     }
 913     if (fRICHhole) {
 914       gMC->Gspos(cTagV,3,"UTI3", xpos,ypos,zpos,0,"ONLY");
 915     }
 916
 917   }
 918
 919 }
 920
 921 //_____________________________________________________________________________
 922 void AliTRDgeometryFull::CreateServices(Int_t *idtmed)
 923 {
 924   //
 925   // Create the geometry of the services
 926   //
 927   // Names of the TRD services volumina
 928   //
 929   //        UTCL    Cooling arterias (Al)
 930   //        UTCW    Cooling arterias (Water)
 931   //        UUxx    Volumes for the services at the chambers (Air)
 932   //        UTPW    Power bars       (Cu)
 933   //        UTCP    Cooling pipes    (Al)
 934   //        UTCH    Cooling pipes    (Water)
 935   //        UTPL    Power lines      (Cu)
 936   //        UMCM    Readout MCMs     (G10/Cu/Si)
 937   //
 938
 939   const Int_t kNdet = kNplan * kNcham;
 940
 941   Int_t   iplan = 0;
 942   Int_t   icham = 0;
 943
 944   Float_t xpos  = 0.0;
 945   Float_t ypos  = 0.0;
 946   Float_t zpos  = 0.0;
 947
 948   Char_t  cTagV[5];
 949
 950   // The rotation matrices
 951   const Int_t kNmatrix = 3;
 952   Int_t   matrix[kNmatrix];
 953   gMC->Matrix(matrix[0],100.0,  0.0, 90.0, 90.0, 10.0,  0.0);
 954   gMC->Matrix(matrix[1], 80.0,  0.0, 90.0, 90.0, 10.0,180.0);
 955   gMC->Matrix(matrix[2],  0.0,  0.0, 90.0, 90.0, 90.0,  0.0);
 956
 957   AliTRDparameter *parameter = new AliTRDparameter("par","TRD parameter");
 958
 959   //
 960   // The cooling arterias
 961   //
 962
 963   // Width of the cooling arterias
 964   const Float_t kCOLwid  =  0.5;
 965   // Height of the cooling arterias
 966   const Float_t kCOLhgt  =  5.5;
 967   // Positioning of the cooling
 968   const Float_t kCOLposx =  1.6;
 969   const Float_t kCOLposz = -0.2;
 970   // Thickness of the walls of the cooling arterias
 971   const Float_t kCOLthk  =  0.1;
 972   const Int_t   kNparCOL = 3;
 973   Float_t parCOL[kNparCOL];
 974   parCOL[0]  = kCOLwid/2.;
 975   parCOL[1]  = fgkSlenTR1/2.;
 976   parCOL[2]  = kCOLhgt/2.;
 977   gMC->Gsvolu("UTCL","BOX ",idtmed[1324-1],parCOL,kNparCOL);
 978   parCOL[0] -= kCOLthk;
 979   parCOL[1]  = fgkSlenTR1/2.;
 980   parCOL[2] -= kCOLthk;
 981   gMC->Gsvolu("UTCW","BOX ",idtmed[1314-1],parCOL,kNparCOL);
 982
 983   xpos  = 0.0;
 984   ypos  = 0.0;
 985   zpos  = 0.0;
 986   gMC->Gspos("UTCW",1,"UTCL", xpos,ypos,zpos,0,"ONLY");
 987
 988   for (iplan = 1; iplan < kNplan; iplan++) {
 989
 990     xpos  = fCwidth[iplan]/2. + kCOLwid/2. + kCOLposx;
 991     ypos  = 0.0;
 992     zpos  = kCOLhgt/2. - fgkSheight/2. + kCOLposz + iplan * (fgkCH + fgkVspace);
 993     gMC->Gspos("UTCL",iplan+1         ,"UTI1", xpos,ypos,zpos,matrix[0],"ONLY");
 994     gMC->Gspos("UTCL",iplan+1+  kNplan,"UTI1",-xpos,ypos,zpos,matrix[1],"ONLY");
 995     if (fPHOShole) {
 996       gMC->Gspos("UTCL",iplan+1+2*kNplan,"UTI2", xpos,ypos,zpos,matrix[0],"ONLY");
 997       gMC->Gspos("UTCL",iplan+1+3*kNplan,"UTI2",-xpos,ypos,zpos,matrix[1],"ONLY");
 998     }
 999     if (fRICHhole) {
1000       gMC->Gspos("UTCL",iplan+1+4*kNplan,"UTI3", xpos,ypos,zpos,matrix[0],"ONLY");
1001       gMC->Gspos("UTCL",iplan+1+5*kNplan,"UTI3",-xpos,ypos,zpos,matrix[1],"ONLY");
1002     }
1003
1004   }
1005
1006   //
1007   // The power bars
1008   //
1009
1010   const Float_t kPWRwid  =  0.6;
1011   const Float_t kPWRhgt  =  4.5;
1012   const Float_t kPWRposx =  1.05;
1013   const Float_t kPWRposz =  0.9;
1014   const Int_t   kNparPWR = 3;
1015   Float_t parPWR[kNparPWR];
1016   parPWR[0] = kPWRwid/2.;
1017   parPWR[1] = fgkSlenTR1/2.;
1018   parPWR[2] = kPWRhgt/2.;
1019   gMC->Gsvolu("UTPW","BOX ",idtmed[1325-1],parPWR,kNparPWR);
1020
1021   for (iplan = 1; iplan < kNplan; iplan++) {
1022
1023     xpos  = fCwidth[iplan]/2. + kPWRwid/2. + kPWRposx;
1024     ypos  = 0.0;
1025     zpos  = kPWRhgt/2. - fgkSheight/2. + kPWRposz + iplan * (fgkCH + fgkVspace);
1026     gMC->Gspos("UTPW",iplan+1         ,"UTI1", xpos,ypos,zpos,matrix[0],"ONLY");
1027     gMC->Gspos("UTPW",iplan+1+  kNplan,"UTI1",-xpos,ypos,zpos,matrix[1],"ONLY");
1028     if (fPHOShole) {
1029       gMC->Gspos("UTPW",iplan+1+2*kNplan,"UTI2", xpos,ypos,zpos,matrix[0],"ONLY");
1030       gMC->Gspos("UTPW",iplan+1+3*kNplan,"UTI2",-xpos,ypos,zpos,matrix[1],"ONLY");
1031     }
1032     if (fRICHhole) {
1033       gMC->Gspos("UTPW",iplan+1+4*kNplan,"UTI3", xpos,ypos,zpos,matrix[0],"ONLY");
1034       gMC->Gspos("UTPW",iplan+1+5*kNplan,"UTI3",-xpos,ypos,zpos,matrix[1],"ONLY");
1035     }
1036
1037   }
1038
1039   //
1040   // The volumes for the services at the chambers
1041   //
1042
1043   const Int_t kNparServ = 3;
1044   Float_t parServ[kNparServ];
1045
1046   for (icham = 0; icham < kNcham; icham++) {
1047     //for (iplan = 0; iplan < kNplan; iplan++) {
1048     // Take out upper plane until TRD mothervolume is adjusted
1049     for (iplan = 0; iplan < kNplan-1; iplan++) {
1050
1051       Int_t iDet = GetDetectorSec(iplan,icham);
1052
1053       sprintf(cTagV,"UU%02d",iDet);
1054       parServ[0] = fCwidth[iplan]/2.;
1055       parServ[1] = fClength[iplan][icham]/2. - fgkHspace/2.;
1056       parServ[2] = fgkVspace/2.;
1057       gMC->Gsvolu(cTagV,"BOX",idtmed[1302-1],parServ,kNparServ);
1058       xpos  = 0.;
1059       ypos  = - fClength[iplan][0] - fClength[iplan][1] - fClength[iplan][2]/2.;
1060       for (Int_t ic = 0; ic < icham; ic++) {
1061         ypos += fClength[iplan][ic];
1062       }
1063       ypos += fClength[iplan][icham]/2.;
1064       zpos  = fgkCH + fgkVspace/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
1065       gMC->Gspos(cTagV,1,"UTI1",xpos,ypos,zpos,0,"ONLY");
1066
1067       if (fPHOShole) {
1068         if (fClengthPH[iplan][icham] > 0.0) {
1069           sprintf(cTagV,"UU%02d",iDet+kNdet);
1070           parServ[0] = fCwidth[iplan]/2.;
1071           parServ[1] = fClengthPH[iplan][icham]/2. - fgkHspace/2.;
1072           parServ[2] = fgkVspace/2.;
1073           gMC->Gsvolu(cTagV,"BOX",idtmed[1302-1],parServ,kNparServ);
1074           xpos  = 0.;
1075           ypos  = - fClength[iplan][0] - fClength[iplan][1] - fClength[iplan][2]/2.;
1076           for (Int_t ic = 0; ic < icham; ic++) {
1077             ypos += fClength[iplan][ic];
1078           }
1079           if (icham > 2) {
1080             ypos += fClength[iplan][icham];
1081             ypos -= fClengthPH[iplan][icham]/2.;
1082           }
1083           else {
1084             ypos += fClengthPH[iplan][icham]/2.;
1085           }
1086           zpos  = fgkCH + fgkVspace/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
1087           gMC->Gspos(cTagV,1,"UTI2",xpos,ypos,zpos,0,"ONLY");
1088         }
1089       }
1090
1091       if (fRICHhole) {
1092         if (fClengthRH[iplan][icham] > 0.0) {
1093           sprintf(cTagV,"UU%02d",iDet+2*kNdet);
1094           parServ[0] = fCwidth[iplan]/2.;
1095           parServ[1] = fClengthRH[iplan][icham]/2. - fgkHspace/2.;
1096           parServ[2] = fgkVspace/2.;
1097           gMC->Gsvolu(cTagV,"BOX",idtmed[1302-1],parServ,kNparServ);
1098           xpos  = 0.;
1099           ypos  = - fClength[iplan][0] - fClength[iplan][1] - fClength[iplan][2]/2.;
1100           for (Int_t ic = 0; ic < icham; ic++) {
1101             ypos += fClength[iplan][ic];
1102           }
1103           if (icham > 2) {
1104             ypos += fClength[iplan][icham];
1105             ypos -= fClengthRH[iplan][icham]/2.;
1106           }
1107           else {
1108             ypos += fClengthRH[iplan][icham]/2.;
1109           }
1110           zpos  = fgkCH + fgkVspace/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
1111           gMC->Gspos(cTagV,1,"UTI3",xpos,ypos,zpos,0,"ONLY");
1112         }
1113       }
1114
1115     }
1116   }
1117
1118   //
1119   // The cooling pipes inside the service volumes
1120   //
1121
1122   const Int_t kNparTube = 3;
1123   Float_t parTube[kNparTube];
1124   // The aluminum pipe for the cooling
1125   parTube[0] = 0.0;
1126   parTube[1] = 0.0;
1127   parTube[2] = 0.0;
1128   gMC->Gsvolu("UTCP","TUBE",idtmed[1324-1],parTube,0);
1129   // The cooling water
1130   parTube[0] =  0.0;
1131   parTube[1] =  0.2/2.;
1132   parTube[2] = -1.;
1133   gMC->Gsvolu("UTCH","TUBE",idtmed[1314-1],parTube,kNparTube);
1134   // Water inside the cooling pipe
1135   xpos = 0.0;
1136   ypos = 0.0;
1137   zpos = 0.0;
1138   gMC->Gspos("UTCH",1,"UTCP",xpos,ypos,zpos,0,"ONLY");
1139
1140   // Position the cooling pipes in the mother volume
1141   const Int_t kNpar = 3;
1142   Float_t par[kNpar];
1143   for (icham = 0; icham < kNcham;   icham++) {
1144     //for (iplan = 0; iplan < kNplan; iplan++) {
1145     // Take out upper plane until TRD mothervolume is adjusted
1146     for (iplan = 0; iplan < kNplan-1; iplan++) {
1147       Int_t   iDet    = GetDetectorSec(iplan,icham);
1148       Int_t   iCopy   = GetDetector(iplan,icham,0) * 100;
1149       Int_t   nMCMrow = parameter->GetRowMax(iplan,icham,0);
1150       Float_t ySize   = (GetChamberLength(iplan,icham) - 2.*fgkRpadW)
1151                       / ((Float_t) nMCMrow);
1152       sprintf(cTagV,"UU%02d",iDet);
1153       for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
1154         xpos   = 0.0;
1155         ypos   = (0.5 + iMCMrow) * ySize - 1.9
1156                - fClength[iplan][icham]/2. + fgkHspace/2.;
1157         zpos   = 0.0;
1158         par[0] = 0.0;
1159         par[1] = 0.3/2.; // Thickness of the cooling pipes
1160         par[2] = fCwidth[iplan]/2.;
1161         gMC->Gsposp("UTCP",iCopy+iMCMrow,cTagV,xpos,ypos,zpos
1162                           ,matrix[2],"ONLY",par,kNpar);
1163       }
1164       if (fPHOShole) {
1165         sprintf(cTagV,"UU%02d",iDet+kNdet);
1166         for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
1167           xpos   = 0.0;
1168           ypos   = (0.5 + iMCMrow) * ySize - 1.9
1169                  - fClengthPH[iplan][icham]/2. + fgkHspace/2.;
1170           zpos   = 0.0;
1171           if (ypos < (fClengthPH[iplan][icham]/2. - fgkHspace/2.)) {
1172             par[0] = 0.0;
1173             par[1] = 0.3/2.; // Thickness of the cooling pipes
1174             par[2] = fCwidth[iplan]/2.;
1175             gMC->Gsposp("UTCP",iCopy+iMCMrow+nMCMrow,cTagV,xpos,ypos,zpos
1176                               ,matrix[2],"ONLY",par,kNpar);
1177           }
1178         }
1179       }
1180       if (fRICHhole) {
1181         sprintf(cTagV,"UU%02d",iDet+2*kNdet);
1182         for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
1183           xpos   = 0.0;
1184           ypos   = (0.5 + iMCMrow) * ySize - 1.9
1185                  - fClengthRH[iplan][icham]/2. + fgkHspace/2.;
1186           zpos   = 0.0;
1187           if (ypos < (fClengthRH[iplan][icham]/2. - fgkHspace/2.)) {
1188             par[0] = 0.0;
1189             par[1] = 0.3/2.; // Thickness of the cooling pipes
1190             par[2] = fCwidth[iplan]/2.;
1191             gMC->Gsposp("UTCP",iCopy+iMCMrow+2*nMCMrow,cTagV,xpos,ypos,zpos
1192                               ,matrix[2],"ONLY",par,kNpar);
1193           }
1194         }
1195       }
1196     }
1197   }
1198
1199   //
1200   // The power lines
1201   //
1202
1203   // The copper power lines
1204   parTube[0] = 0.0;
1205   parTube[1] = 0.0;
1206   parTube[2] = 0.0;
1207   gMC->Gsvolu("UTPL","TUBE",idtmed[1305-1],parTube,0);
1208
1209   // Position the power lines in the mother volume
1210   for (icham = 0; icham < kNcham;   icham++) {
1211     //for (iplan = 0; iplan < kNplan; iplan++) {
1212     // Take out upper plane until TRD mothervolume is adjusted
1213     for (iplan = 0; iplan < kNplan-1; iplan++) {
1214       Int_t   iDet    = GetDetectorSec(iplan,icham);
1215       Int_t   iCopy   = GetDetector(iplan,icham,0) * 100;
1216       Int_t   nMCMrow = parameter->GetRowMax(iplan,icham,0);
1217       Float_t ySize   = (GetChamberLength(iplan,icham) - 2.*fgkRpadW)
1218                       / ((Float_t) nMCMrow);
1219       sprintf(cTagV,"UU%02d",iDet);
1220       for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
1221         xpos   = 0.0;
1222         ypos   = (0.5 + iMCMrow) * ySize - 1.0
1223                - fClength[iplan][icham]/2. + fgkHspace/2.;
1224         zpos   = -0.4;
1225         par[0] = 0.0;
1226         par[1] = 0.2/2.; // Thickness of the power lines
1227         par[2] = fCwidth[iplan]/2.;
1228         gMC->Gsposp("UTPL",iCopy+iMCMrow,cTagV,xpos,ypos,zpos
1229                           ,matrix[2],"ONLY",par,kNpar);
1230       }
1231       if (fPHOShole) {
1232         sprintf(cTagV,"UU%02d",iDet+kNdet);
1233         for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
1234           xpos   = 0.0;
1235           ypos   = (0.5 + iMCMrow) * ySize - 1.0
1236                  - fClengthPH[iplan][icham]/2. + fgkHspace/2.;
1237           zpos   = -0.4;
1238           if (ypos < (fClengthPH[iplan][icham]/2. - fgkHspace/2.)) {
1239             par[0] = 0.0;
1240             par[1] = 0.2/2.; // Thickness of the power lines
1241             par[2] = fCwidth[iplan]/2.;
1242             gMC->Gsposp("UTPL",iCopy+iMCMrow+nMCMrow,cTagV,xpos,ypos,zpos
1243                               ,matrix[2],"ONLY",par,kNpar);
1244           }
1245         }
1246       }
1247       if (fRICHhole) {
1248         sprintf(cTagV,"UU%02d",iDet+2*kNdet);
1249         for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
1250           xpos   = 0.0;
1251           ypos   = (0.5 + iMCMrow) * ySize - 1.0
1252                  - fClengthRH[iplan][icham]/2. + fgkHspace/2.;
1253           zpos   = -0.4;
1254           if (ypos < (fClengthRH[iplan][icham]/2. - fgkHspace/2.)) {
1255             par[0] = 0.0;
1256             par[1] = 0.2/2.; // Thickness of the power lines
1257             par[2] = fCwidth[iplan]/2.;
1258             gMC->Gsposp("UTPL",iCopy+iMCMrow+2*nMCMrow,cTagV,xpos,ypos,zpos
1259                               ,matrix[2],"ONLY",par,kNpar);
1260           }
1261         }
1262       }
1263     }
1264   }
1265
1266   //
1267   // The MCMs
1268   //
1269
1270   // The mother volume for the MCMs (air)
1271   const Int_t kNparMCM = 3;
1272   Float_t parMCM[kNparMCM];
1273   parMCM[0] = 3.0/2.;
1274   parMCM[1] = 3.0/2.;
1275   parMCM[2] = 0.14/2.;
1276   gMC->Gsvolu("UMCM","BOX",idtmed[1302-1],parMCM,kNparMCM);
1277
1278   // The MCM carrier G10 layer
1279   parMCM[0] = 3.0/2.;
1280   parMCM[1] = 3.0/2.;
1281   parMCM[2] = 0.1/2.;
1282   gMC->Gsvolu("UMC1","BOX",idtmed[1319-1],parMCM,kNparMCM);
1283   // The MCM carrier Cu layer
1284   parMCM[0] = 3.0/2.;
1285   parMCM[1] = 3.0/2.;
1286   parMCM[2] = 0.0162/2.;
1287   gMC->Gsvolu("UMC2","BOX",idtmed[1318-1],parMCM,kNparMCM);
1288   // The silicon of the chips
1289   parMCM[0] = 3.0/2.;
1290   parMCM[1] = 3.0/2.;
1291   parMCM[2] = 0.003/2.;
1292   gMC->Gsvolu("UMC3","BOX",idtmed[1320-1],parMCM,kNparMCM);
1293
1294   // Put the MCM material inside the MCM mother volume
1295   xpos  =  0.0;
1296   ypos  =  0.0;
1297   zpos  = -0.07      + 0.1/2.;
1298   gMC->Gspos("UMC1",1,"UMCM",xpos,ypos,zpos,0,"ONLY");
1299   zpos +=  0.1/2.    + 0.0162/2.;
1300   gMC->Gspos("UMC2",1,"UMCM",xpos,ypos,zpos,0,"ONLY");
1301   zpos +=  0.00162/2 + 0.003/2.;
1302   gMC->Gspos("UMC3",1,"UMCM",xpos,ypos,zpos,0,"ONLY");
1303
1304   // Position the MCMs in the mother volume
1305   for (icham = 0; icham < kNcham;   icham++) {
1306     //for (iplan = 0; iplan < kNplan; iplan++) {
1307     // Take out upper plane until TRD mothervolume is adjusted
1308     for (iplan = 0; iplan < kNplan-1; iplan++) {
1309       Int_t   iDet    = GetDetectorSec(iplan,icham);
1310       Int_t   iCopy   = GetDetector(iplan,icham,0) * 1000;
1311       Int_t   nMCMrow = parameter->GetRowMax(iplan,icham,0);
1312       Float_t ySize   = (GetChamberLength(iplan,icham) - 2.*fgkRpadW)
1313                       / ((Float_t) nMCMrow);
1314       Int_t   nMCMcol = 8;
1315       Float_t xSize   = (GetChamberWidth(iplan) - 2.* fgkCpadW)
1316                       / ((Float_t) nMCMcol);
1317       sprintf(cTagV,"UU%02d",iDet);
1318       for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
1319         for (Int_t iMCMcol = 0; iMCMcol < nMCMcol; iMCMcol++) {
1320           xpos   = (0.5 + iMCMcol) * xSize + 1.0
1321                  - fCwidth[iplan]/2.;
1322           ypos   = (0.5 + iMCMrow) * ySize + 1.0
1323                  - fClength[iplan][icham]/2. + fgkHspace/2.;
1324           zpos   = -0.4;
1325           par[0] = 0.0;
1326           par[1] = 0.2/2.; // Thickness of the power lines
1327           par[2] = fCwidth[iplan]/2.;
1328           gMC->Gspos("UMCM",iCopy+iMCMrow*10+iMCMcol,cTagV
1329                            ,xpos,ypos,zpos,0,"ONLY");
1330         }
1331       }
1332       if (fPHOShole) {
1333         sprintf(cTagV,"UU%02d",iDet+kNdet);
1334         for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
1335           for (Int_t iMCMcol = 0; iMCMcol < nMCMcol; iMCMcol++) {
1336             xpos   = (0.5 + iMCMcol) * xSize + 1.0
1337                    - fCwidth[iplan]/2.;
1338             ypos   = (0.5 + iMCMrow) * ySize + 1.0
1339                    - fClengthPH[iplan][icham]/2. + fgkHspace/2.;
1340             zpos   = -0.4;
1341             if (ypos < (fClengthPH[iplan][icham]/2. - fgkHspace/2.)) {
1342               par[0] = 0.0;
1343               par[1] = 0.2/2.; // Thickness of the power lines
1344               par[2] = fCwidth[iplan]/2.;
1345               gMC->Gspos("UMCM",iCopy+iMCMrow*10+iMCMcol+10*nMCMrow,cTagV
1346                                ,xpos,ypos,zpos,0,"ONLY");
1347             }
1348           }
1349         }
1350       }
1351       if (fPHOShole) {
1352         sprintf(cTagV,"UU%02d",iDet+2*kNdet);
1353         for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
1354           for (Int_t iMCMcol = 0; iMCMcol < nMCMcol; iMCMcol++) {
1355             xpos   = (0.5 + iMCMcol) * xSize + 1.0
1356                    - fCwidth[iplan]/2.;
1357             ypos   = (0.5 + iMCMrow) * ySize + 1.0
1358                    - fClengthRH[iplan][icham]/2. + fgkHspace/2.;
1359             zpos   = -0.4;
1360             if (ypos < (fClengthRH[iplan][icham]/2. - fgkHspace/2.)) {
1361               par[0] = 0.0;
1362               par[1] = 0.2/2.; // Thickness of the power lines
1363               par[2] = fCwidth[iplan]/2.;
1364               gMC->Gspos("UMCM",iCopy+iMCMrow*10+iMCMcol+20*nMCMrow,cTagV
1365                                ,xpos,ypos,zpos,0,"ONLY");
1366             }
1367           }
1368         }
1369       }
1370
1371     }
1372   }
1373
1374   delete parameter;
1375
1376 }
1377
1378 //_____________________________________________________________________________
1379 void AliTRDgeometryFull::SetOldGeometry()
1380 {
1381   //
1382   // Use the old chamber lengths
1383   //
1384
1385   Int_t icham;
1386   Int_t iplan;
1387
1388   AliTRDgeometry::SetOldGeometry();
1389
1390   Float_t lengthPH[kNplan][kNcham] = { { 123.5, 116.5,   0.0, 116.5, 123.5 }
1391                                      , { 131.0, 124.0,   0.0, 124.0, 131.0 }
1392                                      , { 134.5, 131.5,   0.0, 131.5, 134.5 }
1393                                      , { 142.0, 139.0,   0.0, 139.0, 142.0 }
1394                                      , { 142.0, 146.0,   0.0, 146.0, 142.0 }
1395                                      , { 134.5, 153.5,   0.0, 153.5, 134.5 } };
1396
1397   Float_t lengthRH[kNplan][kNcham] = { {  86.5,   0.0,   0.0,   0.0,  86.5 }
1398                                      , { 101.5,   0.0,   0.0,   0.0, 101.5 }
1399                                      , { 112.5,   0.0,   0.0,   0.0, 112.5 }
1400                                      , { 127.5,   0.0,   0.0,   0.0, 127.5 }
1401                                      , { 134.5,   0.0,   0.0,   0.0, 134.5 }
1402                                      , { 134.5,   0.0,   0.0,   0.0, 134.5 } };
1403
1404   for (icham = 0; icham < kNcham; icham++) {
1405     for (iplan = 0; iplan < kNplan; iplan++) {
1406       fClengthPH[iplan][icham] = lengthPH[iplan][icham];
1407       fClengthRH[iplan][icham] = lengthRH[iplan][icham];
1408     }
1409   }
1410
1411 }