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