TRD/AliTRDgeometry.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 /* $Id$ */
  17
  18 ///////////////////////////////////////////////////////////////////////////////
  19 //                                                                           //
  20 //  TRD geometry class                                                       //
  21 //                                                                           //
  22 ///////////////////////////////////////////////////////////////////////////////
  23
  24 #include <TGeoManager.h>
  25 #include <TGeoPhysicalNode.h>
  26 #include <TGeoMatrix.h>
  27
  28 #include "AliLog.h"
  29 #include "AliRunLoader.h"
  30 #include "AliAlignObj.h"
  31 #include "AliAlignObjParams.h"
  32 #include "AliRun.h"
  33
  34 #include "AliTRD.h"
  35 #include "AliTRDcalibDB.h"
  36 #include "AliTRDgeometry.h"
  37 #include "AliTRDpadPlane.h"
  38 #include "AliTRDCommonParam.h"
  39
  40 ClassImp(AliTRDgeometry)
  41
  42 //_____________________________________________________________________________
  43
  44   //
  45   // The geometry constants
  46   //
  47   const Int_t    AliTRDgeometry::fgkNsector   = kNsector;
  48   const Int_t    AliTRDgeometry::fgkNlayer    = kNlayer;
  49   const Int_t    AliTRDgeometry::fgkNstack    = kNstack;
  50   const Int_t    AliTRDgeometry::fgkNdet      = kNdet;
  51
  52   //
  53   // Dimensions of the detector
  54   //
  55
  56   // Total length of the TRD mother volume
  57   const Float_t  AliTRDgeometry::fgkTlength   = 751.0;
  58
  59   // Parameter of the super module mother volumes
  60   const Float_t  AliTRDgeometry::fgkSheight   =  77.9;
  61   const Float_t  AliTRDgeometry::fgkSwidth1   =  94.881;
  62   const Float_t  AliTRDgeometry::fgkSwidth2   = 122.353;
  63   const Float_t  AliTRDgeometry::fgkSlength   = 702.0;
  64
  65   // Length of the additional space in front of the supermodule
  66   // used for services
  67   const Float_t  AliTRDgeometry::fgkFlength   = (AliTRDgeometry::fgkTlength
  68                                                - AliTRDgeometry::fgkSlength) / 2.0;
  69
  70   // The super module side plates
  71   const Float_t  AliTRDgeometry::fgkSMpltT    =   0.2;
  72
  73   // Height of different chamber parts
  74   // Radiator
  75   const Float_t  AliTRDgeometry::fgkCraH      =   4.8;
  76   // Drift region
  77   const Float_t  AliTRDgeometry::fgkCdrH      =   3.0;
  78   // Amplification region
  79   const Float_t  AliTRDgeometry::fgkCamH      =   0.7;
  80   // Readout
  81   const Float_t  AliTRDgeometry::fgkCroH      =   2.316;
  82   // Total height
  83   const Float_t  AliTRDgeometry::fgkCH        = AliTRDgeometry::fgkCraH
  84                                               + AliTRDgeometry::fgkCdrH
  85                                               + AliTRDgeometry::fgkCamH
  86                                               + AliTRDgeometry::fgkCroH;
  87
  88   // Vertical spacing of the chambers
  89   const Float_t  AliTRDgeometry::fgkVspace    =   1.784;
  90   // Horizontal spacing of the chambers
  91   const Float_t  AliTRDgeometry::fgkHspace    =   2.0;
  92   // Radial distance of the first ROC to the outer plates of the SM
  93   const Float_t  AliTRDgeometry::fgkVrocsm    =   1.2;
  94
  95   // Thicknesses of different parts of the chamber frame
  96   // Lower aluminum frame
  97   const Float_t  AliTRDgeometry::fgkCalT      =   0.4;
  98   // Lower Wacosit frame sides
  99   const Float_t  AliTRDgeometry::fgkCclsT     =   0.21;
 100   // Lower Wacosit frame front
 101   const Float_t  AliTRDgeometry::fgkCclfT     =   1.0;
 102   // Thickness of glue around radiator
 103   const Float_t  AliTRDgeometry::fgkCglT      =   0.25;
 104   // Upper Wacosit frame
 105   const Float_t  AliTRDgeometry::fgkCcuT      =   0.9;
 106   // Al frame of back panel
 107   const Float_t  AliTRDgeometry::fgkCauT      =   1.5;
 108   // Additional Al of the lower chamber frame
 109   const Float_t  AliTRDgeometry::fgkCalW      =   1.11;
 110
 111   // Additional width of the readout chamber frames
 112   const Float_t  AliTRDgeometry::fgkCroW      =   0.9;
 113
 114   // Difference of outer chamber width and pad plane width
 115   const Float_t  AliTRDgeometry::fgkCpadW     =   0.0;
 116   const Float_t  AliTRDgeometry::fgkRpadW     =   1.0;
 117
 118   //
 119   // Thickness of the the material layers
 120   //
 121   const Float_t  AliTRDgeometry::fgkMyThick   = 0.005;
 122   const Float_t  AliTRDgeometry::fgkRaThick   = 0.3233;
 123   const Float_t  AliTRDgeometry::fgkDrThick   = AliTRDgeometry::fgkCdrH;
 124   const Float_t  AliTRDgeometry::fgkAmThick   = AliTRDgeometry::fgkCamH;
 125   const Float_t  AliTRDgeometry::fgkXeThick   = AliTRDgeometry::fgkDrThick
 126                                               + AliTRDgeometry::fgkAmThick;
 127   const Float_t  AliTRDgeometry::fgkWrThick   = 0.0002;
 128   const Float_t  AliTRDgeometry::fgkCuThick   = 0.0072;
 129   const Float_t  AliTRDgeometry::fgkGlThick   = 0.05;
 130   const Float_t  AliTRDgeometry::fgkSuThick   = 0.0919;
 131   const Float_t  AliTRDgeometry::fgkRcThick   = 0.0058;
 132   const Float_t  AliTRDgeometry::fgkRpThick   = 0.0632;
 133   const Float_t  AliTRDgeometry::fgkRoThick   = 0.0028;
 134
 135   //
 136   // Position of the material layers
 137   //
 138   const Float_t  AliTRDgeometry::fgkRaZpos    =  0.0;
 139   const Float_t  AliTRDgeometry::fgkDrZpos    =  2.4;
 140   const Float_t  AliTRDgeometry::fgkAmZpos    =  0.0;
 141   const Float_t  AliTRDgeometry::fgkWrZpos    =  0.0;
 142   const Float_t  AliTRDgeometry::fgkCuZpos    = -0.9995;
 143   const Float_t  AliTRDgeometry::fgkGlZpos    = -0.5;
 144   const Float_t  AliTRDgeometry::fgkSuZpos    =  0.0;
 145   const Float_t  AliTRDgeometry::fgkRcZpos    =  1.04;
 146   const Float_t  AliTRDgeometry::fgkRpZpos    =  1.0;
 147   const Float_t  AliTRDgeometry::fgkRoZpos    =  1.05;
 148
 149   const Int_t    AliTRDgeometry::fgkMCMmax    = 16;
 150   const Int_t    AliTRDgeometry::fgkMCMrow    = 4;
 151   const Int_t    AliTRDgeometry::fgkROBmaxC0  = 6;
 152   const Int_t    AliTRDgeometry::fgkROBmaxC1  = 8;
 153   const Int_t    AliTRDgeometry::fgkADCmax    = 21;
 154   const Int_t    AliTRDgeometry::fgkTBmax     = 60;
 155   const Int_t    AliTRDgeometry::fgkPadmax    = 18;
 156   const Int_t    AliTRDgeometry::fgkColmax    = 144;
 157   const Int_t    AliTRDgeometry::fgkRowmaxC0  = 12;
 158   const Int_t    AliTRDgeometry::fgkRowmaxC1  = 16;
 159
 160   const Double_t AliTRDgeometry::fgkTime0Base = 300.65;
 161   const Float_t  AliTRDgeometry::fgkTime0[6]  = { fgkTime0Base + 0 * (Cheight() + Cspace())
 162                                                 , fgkTime0Base + 1 * (Cheight() + Cspace())
 163                                                 , fgkTime0Base + 2 * (Cheight() + Cspace())
 164                                                 , fgkTime0Base + 3 * (Cheight() + Cspace())
 165                                                 , fgkTime0Base + 4 * (Cheight() + Cspace())
 166                                                 , fgkTime0Base + 5 * (Cheight() + Cspace())};
 167
 168 //_____________________________________________________________________________
 169 AliTRDgeometry::AliTRDgeometry()
 170   :AliGeometry()
 171   ,fClusterMatrixArray(0)
 172   ,fPadPlaneArray(0)
 173 {
 174   //
 175   // AliTRDgeometry default constructor
 176   //
 177
 178   Init();
 179
 180 }
 181
 182 //_____________________________________________________________________________
 183 AliTRDgeometry::AliTRDgeometry(const AliTRDgeometry &g)
 184   :AliGeometry(g)
 185   ,fClusterMatrixArray(0)
 186   ,fPadPlaneArray(0)
 187 {
 188   //
 189   // AliTRDgeometry copy constructor
 190   //
 191
 192   Init();
 193
 194 }
 195
 196 //_____________________________________________________________________________
 197 AliTRDgeometry::~AliTRDgeometry()
 198 {
 199   //
 200   // AliTRDgeometry destructor
 201   //
 202
 203   if (fClusterMatrixArray) {
 204     fClusterMatrixArray->Delete();
 205     delete fClusterMatrixArray;
 206     fClusterMatrixArray = 0;
 207   }
 208
 209   if (fPadPlaneArray) {
 210     fPadPlaneArray->Delete();
 211     delete fPadPlaneArray;
 212     fPadPlaneArray = 0;
 213   }
 214
 215 }
 216
 217 //_____________________________________________________________________________
 218 AliTRDgeometry &AliTRDgeometry::operator=(const AliTRDgeometry &g)
 219 {
 220   //
 221   // Assignment operator
 222   //
 223
 224   if (this != &g) {
 225     Init();
 226   }
 227
 228   return *this;
 229
 230 }
 231
 232 //_____________________________________________________________________________
 233 void AliTRDgeometry::Init()
 234 {
 235   //
 236   // Initializes the geometry parameter
 237   //
 238
 239   Int_t istack;
 240   Int_t ilayer;
 241   Int_t isector;
 242
 243   // The outer width of the chambers
 244   fCwidth[0] =  90.4;
 245   fCwidth[1] =  94.8;
 246   fCwidth[2] =  99.3;
 247   fCwidth[3] = 103.7;
 248   fCwidth[4] = 108.1;
 249   fCwidth[5] = 112.6;
 250
 251   // The outer lengths of the chambers
 252   // Includes the spacings between the chambers!
 253   Float_t length[kNlayer][kNstack]   = { { 124.0, 124.0, 110.0, 124.0, 124.0 }
 254                                        , { 124.0, 124.0, 110.0, 124.0, 124.0 }
 255                                        , { 131.0, 131.0, 110.0, 131.0, 131.0 }
 256                                        , { 138.0, 138.0, 110.0, 138.0, 138.0 }
 257                                        , { 145.0, 145.0, 110.0, 145.0, 145.0 }
 258                                        , { 147.0, 147.0, 110.0, 147.0, 147.0 } };
 259
 260   for (istack = 0; istack < kNstack; istack++) {
 261     for (ilayer = 0; ilayer < kNlayer; ilayer++) {
 262       fClength[ilayer][istack] = length[ilayer][istack];
 263     }
 264   }
 265
 266   // The rotation matrix elements
 267   Float_t phi = 0.0;
 268   for (isector = 0; isector < fgkNsector; isector++) {
 269     phi = 2.0 * TMath::Pi() /  (Float_t) fgkNsector * ((Float_t) isector + 0.5);
 270     fRotB11[isector] = TMath::Cos(phi);
 271     fRotB12[isector] = TMath::Sin(phi);
 272     fRotB21[isector] = TMath::Sin(phi);
 273     fRotB22[isector] = TMath::Cos(phi);
 274   }
 275
 276 }
 277
 278 //_____________________________________________________________________________
 279 void AliTRDgeometry::SetSMstatus(Int_t sm, Char_t status)
 280 {
 281   //
 282   // Switch on/off supermodules in the geometry
 283   //
 284
 285   AliTRDCommonParam::Instance()->SetSMstatus(sm,status);
 286
 287 }
 288
 289 //_____________________________________________________________________________
 290 Char_t AliTRDgeometry::GetSMstatus(Int_t sm) const
 291 {
 292   //
 293   // Get the supermodule status
 294   //
 295
 296   return AliTRDCommonParam::Instance()->GetSMstatus(sm);
 297
 298 }
 299
 300 //_____________________________________________________________________________
 301 void AliTRDgeometry::CreatePadPlaneArray()
 302 {
 303   //
 304   // Creates the array of AliTRDpadPlane objects
 305   //
 306
 307   if (fPadPlaneArray) {
 308     fPadPlaneArray->Delete();
 309     delete fPadPlaneArray;
 310   }
 311
 312   fPadPlaneArray = new TObjArray(fgkNlayer * fgkNstack);
 313   for (Int_t ilayer = 0; ilayer < fgkNlayer; ilayer++) {
 314     for (Int_t istack = 0; istack < fgkNstack; istack++) {
 315       Int_t ipp = GetDetectorSec(ilayer,istack);
 316       fPadPlaneArray->AddAt(CreatePadPlane(ilayer,istack),ipp);
 317     }
 318   }
 319
 320 }
 321
 322 //_____________________________________________________________________________
 323 AliTRDpadPlane *AliTRDgeometry::CreatePadPlane(Int_t ilayer, Int_t istack)
 324 {
 325   //
 326   // Creates an AliTRDpadPlane object
 327   //
 328
 329   AliTRDpadPlane *padPlane = new AliTRDpadPlane();
 330
 331   padPlane->SetLayer(ilayer);
 332   padPlane->SetStack(istack);
 333
 334   padPlane->SetRowSpacing(0.0);
 335   padPlane->SetColSpacing(0.0);
 336
 337   padPlane->SetLengthRim(1.0);
 338   padPlane->SetWidthRim(0.5);
 339
 340   padPlane->SetNcols(144);
 341
 342   //
 343   // The pad plane parameter
 344   //
 345   switch (ilayer) {
 346   case 0:
 347     if (istack == 2) {
 348       // L0C0 type
 349       padPlane->SetNrows(12);
 350       padPlane->SetLength(108.0);
 351       padPlane->SetWidth(92.2);
 352       padPlane->SetLengthOPad(8.0);
 353       padPlane->SetWidthOPad(0.515);
 354       padPlane->SetLengthIPad(9.0);
 355       padPlane->SetWidthIPad(0.635);
 356       padPlane->SetTiltingAngle(2.0);
 357     }
 358     else {
 359       // L0C1 type
 360       padPlane->SetNrows(16);
 361       padPlane->SetLength(122.0);
 362       padPlane->SetWidth(92.2);
 363       padPlane->SetLengthOPad(7.5);
 364       padPlane->SetWidthOPad(0.515);
 365       padPlane->SetLengthIPad(7.5);
 366       padPlane->SetWidthIPad(0.635);
 367       padPlane->SetTiltingAngle(2.0);
 368     }
 369     break;
 370   case 1:
 371     if (istack == 2) {
 372       // L1C0 type
 373       padPlane->SetNrows(12);
 374       padPlane->SetLength(108.0);
 375       padPlane->SetWidth(96.6);
 376       padPlane->SetLengthOPad(8.0);
 377       padPlane->SetWidthOPad(0.585);
 378       padPlane->SetLengthIPad(9.0);
 379       padPlane->SetWidthIPad(0.665);
 380       padPlane->SetTiltingAngle(-2.0);
 381     }
 382     else {
 383       // L1C1 type
 384       padPlane->SetNrows(16);
 385       padPlane->SetLength(122.0);
 386       padPlane->SetWidth(96.6);
 387       padPlane->SetLengthOPad(7.5);
 388       padPlane->SetWidthOPad(0.585);
 389       padPlane->SetLengthIPad(7.5);
 390       padPlane->SetWidthIPad(0.665);
 391       padPlane->SetTiltingAngle(-2.0);
 392     }
 393     break;
 394   case 2:
 395     if (istack == 2) {
 396       // L2C0 type
 397       padPlane->SetNrows(12);
 398       padPlane->SetLength(108.0);
 399       padPlane->SetWidth(101.1);
 400       padPlane->SetLengthOPad(8.0);
 401       padPlane->SetWidthOPad(0.705);
 402       padPlane->SetLengthIPad(9.0);
 403       padPlane->SetWidthIPad(0.695);
 404       padPlane->SetTiltingAngle(2.0);
 405     }
 406     else {
 407       // L2C1 type
 408       padPlane->SetNrows(16);
 409       padPlane->SetLength(129.0);
 410       padPlane->SetWidth(101.1);
 411       padPlane->SetLengthOPad(7.5);
 412       padPlane->SetWidthOPad(0.705);
 413       padPlane->SetLengthIPad(8.0);
 414       padPlane->SetWidthIPad(0.695);
 415       padPlane->SetTiltingAngle(2.0);
 416     }
 417     break;
 418   case 3:
 419     if (istack == 2) {
 420       // L3C0 type
 421       padPlane->SetNrows(12);
 422       padPlane->SetLength(108.0);
 423       padPlane->SetWidth(105.5);
 424       padPlane->SetLengthOPad(8.0);
 425       padPlane->SetWidthOPad(0.775);
 426       padPlane->SetLengthIPad(9.0);
 427       padPlane->SetWidthIPad(0.725);
 428       padPlane->SetTiltingAngle(-2.0);
 429     }
 430     else {
 431       // L3C1 type
 432       padPlane->SetNrows(16);
 433       padPlane->SetLength(136.0);
 434       padPlane->SetWidth(105.5);
 435       padPlane->SetLengthOPad(7.5);
 436       padPlane->SetWidthOPad(0.775);
 437       padPlane->SetLengthIPad(8.5);
 438       padPlane->SetWidthIPad(0.725);
 439       padPlane->SetTiltingAngle(-2.0);
 440     }
 441     break;
 442   case 4:
 443     if (istack == 2) {
 444       // L4C0 type
 445       padPlane->SetNrows(12);
 446       padPlane->SetLength(108.0);
 447       padPlane->SetWidth(109.9);
 448       padPlane->SetLengthOPad(8.0);
 449       padPlane->SetWidthOPad(0.845);
 450       padPlane->SetLengthIPad(9.0);
 451       padPlane->SetWidthIPad(0.755);
 452       padPlane->SetTiltingAngle(2.0);
 453     }
 454     else {
 455       // L4C1 type
 456       padPlane->SetNrows(16);
 457       padPlane->SetLength(143.0);
 458       padPlane->SetWidth(109.9);
 459       padPlane->SetLengthOPad(7.5);
 460       padPlane->SetWidthOPad(0.845);
 461       padPlane->SetLengthIPad(9.0);
 462       padPlane->SetWidthIPad(0.755);
 463       padPlane->SetTiltingAngle(2.0);
 464     }
 465     break;
 466   case 5:
 467     if (istack == 2) {
 468       // L5C0 type
 469       padPlane->SetNrows(12);
 470       padPlane->SetLength(108.0);
 471       padPlane->SetWidth(114.4);
 472       padPlane->SetLengthOPad(8.0);
 473       padPlane->SetWidthOPad(0.965);
 474       padPlane->SetLengthIPad(9.0);
 475       padPlane->SetWidthIPad(0.785);
 476       padPlane->SetTiltingAngle(-2.0);
 477     }
 478     else {
 479       // L5C1 type
 480       padPlane->SetNrows(16);
 481       padPlane->SetLength(145.0);
 482       padPlane->SetWidth(114.4);
 483       padPlane->SetLengthOPad(8.5);
 484       padPlane->SetWidthOPad(0.965);
 485       padPlane->SetLengthIPad(9.0);
 486       padPlane->SetWidthIPad(0.785);
 487       padPlane->SetTiltingAngle(-2.0);
 488     }
 489     break;
 490   };
 491
 492   //
 493   // The positions of the borders of the pads
 494   //
 495   // Row direction
 496   //
 497   Double_t row = fClength[ilayer][istack] / 2.0
 498                - fgkRpadW
 499                - padPlane->GetLengthRim();
 500   for (Int_t ir = 0; ir < padPlane->GetNrows(); ir++) {
 501     padPlane->SetPadRow(ir,row);
 502     row -= padPlane->GetRowSpacing();
 503     if (ir == 0) {
 504       row -= padPlane->GetLengthOPad();
 505     }
 506     else {
 507       row -= padPlane->GetLengthIPad();
 508     }
 509   }
 510   //
 511   // Column direction
 512   //
 513   Double_t col = - fCwidth[ilayer] / 2.0
 514                  - fgkCroW
 515                  + padPlane->GetWidthRim();
 516   for (Int_t ic = 0; ic < padPlane->GetNcols(); ic++) {
 517     padPlane->SetPadCol(ic,col);
 518     col += padPlane->GetColSpacing();
 519     if (ic == 0) {
 520       col += padPlane->GetWidthOPad();
 521     }
 522     else {
 523       col += padPlane->GetWidthIPad();
 524     }
 525   }
 526   // Calculate the offset to translate from the local ROC system into
 527   // the local supermodule system, which is used for clusters
 528   Double_t rowTmp = fClength[ilayer][0]
 529                   + fClength[ilayer][1]
 530                   + fClength[ilayer][2] / 2.0;
 531   for (Int_t jstack = 0; jstack < istack; jstack++) {
 532     rowTmp -= fClength[ilayer][jstack];
 533   }
 534   padPlane->SetPadRowSMOffset(rowTmp - fClength[ilayer][istack]/2.0);
 535
 536   return padPlane;
 537
 538 }
 539
 540 //_____________________________________________________________________________
 541 void AliTRDgeometry::CreateGeometry(Int_t *idtmed)
 542 {
 543   //
 544   // Create the TRD geometry without hole
 545   //
 546   //
 547   // Names of the TRD volumina (xx = detector number):
 548   //
 549   //      Volume (Air) wrapping the readout chamber components
 550   //        UTxx    includes: UAxx, UDxx, UFxx, UUxx
 551   //
 552   //      Volume (Air) wrapping the services (fee + cooling)
 553   //        UUxx    the services volume has been reduced by 7.42 mm
 554   //                in order to allow shifts in radial direction
 555   //
 556   //      Lower part of the readout chambers (drift volume + radiator)
 557   //
 558   //        UAxx    Aluminum frames                 (Al)
 559   //        UBxx    Wacosit frames                  (C)
 560   //        UXxx    Glue around radiator            (Epoxy)
 561   //        UCxx    Inner volumes                   (Air)
 562   //        UZxx    Additional aluminum ledges      (Al)
 563   //
 564   //      Upper part of the readout chambers (readout plane + fee)
 565   //
 566   //        UDxx    Wacosit frames of amp. region   (C)
 567   //        UExx    Inner volumes of the frame      (Air)
 568   //        UFxx    Aluminum frame of back panel    (Al)
 569   //        UGxx    Inner volumes of the back panel (Air)
 570   //
 571   //      Inner material layers
 572   //
 573   //        UHxx    Radiator                        (Rohacell)
 574   //        UJxx    Drift volume                    (Xe/CO2)
 575   //        UKxx    Amplification volume            (Xe/CO2)
 576   //        UWxx    Wire plane                      (Cu)
 577   //        ULxx    Pad plane                       (Cu)
 578   //        UYxx    Glue layer                      (Epoxy)
 579   //        UMxx    Support structure               (Rohacell)
 580   //        UNxx    ROB base material               (C)
 581   //        UOxx    ROB copper                      (Cu)
 582   //        UVxx    ROB other materials             (Cu)
 583   //
 584
 585   const Int_t kNparTrd = 4;
 586   const Int_t kNparCha = 3;
 587
 588   Float_t xpos;
 589   Float_t ypos;
 590   Float_t zpos;
 591
 592   Float_t parTrd[kNparTrd];
 593   Float_t parCha[kNparCha];
 594
 595   Char_t  cTagV[6];
 596   Char_t  cTagM[5];
 597
 598   // There are three TRD volumes for the supermodules in order to accomodate
 599   // the different arrangements in front of PHOS
 600   // UTR1: Default supermodule
 601   // UTR2: Supermodule in front of PHOS with double carbon cover
 602   // UTR3: As UTR2, but w/o middle stack
 603   //
 604   // The mother volume for one sector (Air), full length in z-direction
 605   // Provides material for side plates of super module
 606   parTrd[0] = fgkSwidth1/2.0;
 607   parTrd[1] = fgkSwidth2/2.0;
 608   parTrd[2] = fgkSlength/2.0;
 609   parTrd[3] = fgkSheight/2.0;
 610   gMC->Gsvolu("UTR1","TRD1",idtmed[1302-1],parTrd,kNparTrd);
 611   gMC->Gsvolu("UTR2","TRD1",idtmed[1302-1],parTrd,kNparTrd);
 612   gMC->Gsvolu("UTR3","TRD1",idtmed[1302-1],parTrd,kNparTrd);
 613   // The outer aluminum plates of the super module (Al)
 614   parTrd[0] = fgkSwidth1/2.0;
 615   parTrd[1] = fgkSwidth2/2.0;
 616   parTrd[2] = fgkSlength/2.0;
 617   parTrd[3] = fgkSheight/2.0;
 618   gMC->Gsvolu("UTS1","TRD1",idtmed[1301-1],parTrd,kNparTrd);
 619   gMC->Gsvolu("UTS2","TRD1",idtmed[1301-1],parTrd,kNparTrd);
 620   gMC->Gsvolu("UTS3","TRD1",idtmed[1301-1],parTrd,kNparTrd);
 621   // The inner part of the TRD mother volume for one sector (Air),
 622   // full length in z-direction
 623   parTrd[0] = fgkSwidth1/2.0 - fgkSMpltT;
 624   parTrd[1] = fgkSwidth2/2.0 - fgkSMpltT;
 625   parTrd[2] = fgkSlength/2.0;
 626   parTrd[3] = fgkSheight/2.0 - fgkSMpltT;
 627   gMC->Gsvolu("UTI1","TRD1",idtmed[1302-1],parTrd,kNparTrd);
 628   gMC->Gsvolu("UTI2","TRD1",idtmed[1302-1],parTrd,kNparTrd);
 629   gMC->Gsvolu("UTI3","TRD1",idtmed[1302-1],parTrd,kNparTrd);
 630
 631   // The inner part of the TRD mother volume for services in front
 632   // of the supermodules  (Air),
 633   parTrd[0] = fgkSwidth1/2.0;
 634   parTrd[1] = fgkSwidth2/2.0;
 635   parTrd[2] = fgkFlength/2.0;
 636   parTrd[3] = fgkSheight/2.0;
 637   gMC->Gsvolu("UTF1","TRD1",idtmed[1302-1],parTrd,kNparTrd);
 638   gMC->Gsvolu("UTF2","TRD1",idtmed[1302-1],parTrd,kNparTrd);
 639
 640   for (Int_t istack = 0; istack < kNstack; istack++) {
 641     for (Int_t ilayer = 0; ilayer < kNlayer; ilayer++) {
 642
 643       Int_t iDet = GetDetectorSec(ilayer,istack);
 644
 645       // The lower part of the readout chambers (drift volume + radiator)
 646       // The aluminum frames
 647       sprintf(cTagV,"UA%02d",iDet);
 648       parCha[0] = fCwidth[ilayer]/2.0;
 649       parCha[1] = fClength[ilayer][istack]/2.0 - fgkHspace/2.0;
 650       parCha[2] = fgkCraH/2.0 + fgkCdrH/2.0;
 651       fChamberUAboxd[iDet][0] = parCha[0];
 652       fChamberUAboxd[iDet][1] = parCha[1];
 653       fChamberUAboxd[iDet][2] = parCha[2];
 654       gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parCha,kNparCha);
 655       // The additional aluminum on the frames
 656       // This part has not the correct postion but is just supposed to
 657       // represent the missing material. The correct form of the L-shaped
 658       // profile would not fit into the alignable volume.
 659       sprintf(cTagV,"UZ%02d",iDet);
 660       parCha[0] = fgkCroW/2.0;
 661       parCha[1] = fClength[ilayer][istack]/2.0 - fgkHspace/2.0;
 662       parCha[2] = fgkCalW/2.0;
 663       fChamberUAboxd[iDet][0] = fChamberUAboxd[iDet][0] + fgkCroW;
 664       gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parCha,kNparCha);
 665       // The Wacosit frames
 666       sprintf(cTagV,"UB%02d",iDet);
 667       parCha[0] = fCwidth[ilayer]/2.0 - fgkCalT;
 668       parCha[1] = -1.0;
 669       parCha[2] = -1.0;
 670       gMC->Gsvolu(cTagV,"BOX ",idtmed[1307-1],parCha,kNparCha);
 671       // The glue around the radiator
 672       sprintf(cTagV,"UX%02d",iDet);
 673       parCha[0] = fCwidth[ilayer]/2.0 - fgkCalT - fgkCclsT;
 674       parCha[1] = fClength[ilayer][istack]/2.0 - fgkHspace/2.0 - fgkCclfT;
 675       parCha[2] = fgkCraH/2.0;
 676       gMC->Gsvolu(cTagV,"BOX ",idtmed[1311-1],parCha,kNparCha);
 677       // The inner part of radiator (air)
 678       sprintf(cTagV,"UC%02d",iDet);
 679       parCha[0] = fCwidth[ilayer]/2.0 - fgkCalT - fgkCclsT - fgkCglT;
 680       parCha[1] = fClength[ilayer][istack]/2.0 - fgkHspace/2.0 - fgkCclfT - fgkCglT;
 681       parCha[2] = -1.0;
 682       gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
 683
 684       // The upper part of the readout chambers (amplification volume)
 685       // The Wacosit frames
 686       sprintf(cTagV,"UD%02d",iDet);
 687       parCha[0] = fCwidth[ilayer]/2.0 + fgkCroW;
 688       parCha[1] = fClength[ilayer][istack]/2.0 - fgkHspace/2.0;
 689       parCha[2] = fgkCamH/2.0;
 690       fChamberUDboxd[iDet][0] = parCha[0];
 691       fChamberUDboxd[iDet][1] = parCha[1];
 692       fChamberUDboxd[iDet][2] = parCha[2];
 693       gMC->Gsvolu(cTagV,"BOX ",idtmed[1307-1],parCha,kNparCha);
 694       // The inner part of the Wacosit frame (air)
 695       sprintf(cTagV,"UE%02d",iDet);
 696       parCha[0] = fCwidth[ilayer]/2.0 + fgkCroW - fgkCcuT;
 697       parCha[1] = fClength[ilayer][istack]/2.0 - fgkHspace/2.0 - fgkCcuT;
 698       parCha[2] = -1.;
 699       gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
 700
 701       // The support structure (pad plane, back panel, readout boards)
 702       // The aluminum frames
 703       sprintf(cTagV,"UF%02d",iDet);
 704       parCha[0] = fCwidth[ilayer]/2.0 + fgkCroW;
 705       parCha[1] = fClength[ilayer][istack]/2.0 - fgkHspace/2.0;
 706       parCha[2] = fgkCroH/2.0;
 707       fChamberUFboxd[iDet][0] = parCha[0];
 708       fChamberUFboxd[iDet][1] = parCha[1];
 709       fChamberUFboxd[iDet][2] = parCha[2];
 710       gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parCha,kNparCha);
 711       // The inner part of the aluminum frames
 712       sprintf(cTagV,"UG%02d",iDet);
 713       parCha[0] = fCwidth[ilayer]/2.0 + fgkCroW - fgkCauT;
 714       parCha[1] = fClength[ilayer][istack]/2.0 - fgkHspace/2.0 - fgkCauT;
 715       parCha[2] = -1.0;
 716       gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
 717
 718       // The material layers inside the chambers
 719       // Rohacell layer (radiator)
 720       parCha[0] = -1.0;
 721       parCha[1] = -1.0;
 722       parCha[2] = fgkRaThick/2.0;
 723       sprintf(cTagV,"UH%02d",iDet);
 724       gMC->Gsvolu(cTagV,"BOX ",idtmed[1315-1],parCha,kNparCha);
 725       // Xe/Isobutane layer (drift volume)
 726       parCha[0] = fCwidth[ilayer]/2.0 - fgkCalT - fgkCclsT;
 727       parCha[1] = fClength[ilayer][istack]/2.0 - fgkHspace/2.0 - fgkCclfT;
 728       parCha[2] = fgkDrThick/2.0;
 729       sprintf(cTagV,"UJ%02d",iDet);
 730       gMC->Gsvolu(cTagV,"BOX ",idtmed[1309-1],parCha,kNparCha);
 731       // Xe/Isobutane layer (amplification volume)
 732       parCha[0] = -1.0;
 733       parCha[1] = -1.0;
 734       parCha[2] = fgkAmThick/2.0;
 735       sprintf(cTagV,"UK%02d",iDet);
 736       gMC->Gsvolu(cTagV,"BOX ",idtmed[1309-1],parCha,kNparCha);
 737       // Cu layer (wire plane)
 738       parCha[0] = -1.0;
 739       parCha[1] = -1.0;
 740       parCha[2] = fgkWrThick/2.0;
 741       sprintf(cTagV,"UW%02d",iDet);
 742       gMC->Gsvolu(cTagV,"BOX ",idtmed[1303-1],parCha,kNparCha);
 743       // Cu layer (pad plane)
 744       parCha[0] = -1.0;
 745       parCha[1] = -1.0;
 746       parCha[2] = fgkCuThick/2.0;
 747       sprintf(cTagV,"UL%02d",iDet);
 748       gMC->Gsvolu(cTagV,"BOX ",idtmed[1305-1],parCha,kNparCha);
 749       // Epoxy layer (glue)
 750       parCha[0] = -1.0;
 751       parCha[1] = -1.0;
 752       parCha[2] = fgkGlThick/2.0;
 753       sprintf(cTagV,"UY%02d",iDet);
 754       gMC->Gsvolu(cTagV,"BOX ",idtmed[1311-1],parCha,kNparCha);
 755       // G10 layer (support structure / honeycomb)
 756       parCha[0] = -1.0;
 757       parCha[1] = -1.0;
 758       parCha[2] = fgkSuThick/2.0;
 759       sprintf(cTagV,"UM%02d",iDet);
 760       gMC->Gsvolu(cTagV,"BOX ",idtmed[1310-1],parCha,kNparCha);
 761       // G10 layer (PCB readout board)
 762       parCha[0] = -1.0;
 763       parCha[1] = -1.0;
 764       parCha[2] = fgkRpThick/2;
 765       sprintf(cTagV,"UN%02d",iDet);
 766       gMC->Gsvolu(cTagV,"BOX ",idtmed[1313-1],parCha,kNparCha);
 767       // Cu layer (traces in readout board)
 768       parCha[0] = -1.0;
 769       parCha[1] = -1.0;
 770       parCha[2] = fgkRcThick/2.0;
 771       sprintf(cTagV,"UO%02d",iDet);
 772       gMC->Gsvolu(cTagV,"BOX ",idtmed[1306-1],parCha,kNparCha);
 773       // Cu layer (other material on in readout board)
 774       parCha[0] = -1.0;
 775       parCha[1] = -1.0;
 776       parCha[2] = fgkRoThick/2.0;
 777       sprintf(cTagV,"UV%02d",iDet);
 778       gMC->Gsvolu(cTagV,"BOX ",idtmed[1304-1],parCha,kNparCha);
 779
 780       // Position the layers in the chambers
 781       xpos = 0.0;
 782       ypos = 0.0;
 783       // Lower part
 784       // Rohacell layer (radiator)
 785       zpos = fgkRaZpos;
 786       sprintf(cTagV,"UH%02d",iDet);
 787       sprintf(cTagM,"UC%02d",iDet);
 788       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 789       // Xe/Isobutane layer (drift volume)
 790       zpos = fgkDrZpos;
 791       sprintf(cTagV,"UJ%02d",iDet);
 792       sprintf(cTagM,"UB%02d",iDet);
 793       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 794       // Upper part
 795       // Xe/Isobutane layer (amplification volume)
 796       zpos = fgkAmZpos;
 797       sprintf(cTagV,"UK%02d",iDet);
 798       sprintf(cTagM,"UE%02d",iDet);
 799       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 800       // Cu layer (wire plane inside amplification volume)
 801       zpos = fgkWrZpos;
 802       sprintf(cTagV,"UW%02d",iDet);
 803       sprintf(cTagM,"UK%02d",iDet);
 804       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 805       // Readout part + support plane
 806       // Cu layer (pad plane)
 807       zpos = fgkCuZpos;
 808       sprintf(cTagV,"UL%02d",iDet);
 809       sprintf(cTagM,"UG%02d",iDet);
 810       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 811       // Epoxy layer (glue)
 812       zpos = fgkGlZpos;
 813       sprintf(cTagV,"UY%02d",iDet);
 814       sprintf(cTagM,"UG%02d",iDet);
 815       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 816       // G10 layer (support structure)
 817       zpos = fgkSuZpos;
 818       sprintf(cTagV,"UM%02d",iDet);
 819       sprintf(cTagM,"UG%02d",iDet);
 820       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 821       // G10 layer (PCB readout board)
 822       zpos = fgkRpZpos;
 823       sprintf(cTagV,"UN%02d",iDet);
 824       sprintf(cTagM,"UG%02d",iDet);
 825       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 826       // Cu layer (traces in readout board)
 827       zpos = fgkRcZpos;
 828       sprintf(cTagV,"UO%02d",iDet);
 829       sprintf(cTagM,"UG%02d",iDet);
 830       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 831       // Cu layer (other materials on readout board)
 832       zpos = fgkRoZpos;
 833       sprintf(cTagV,"UV%02d",iDet);
 834       sprintf(cTagM,"UG%02d",iDet);
 835       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 836
 837       // Position the inner volumes of the chambers in the frames
 838       xpos = 0.0;
 839       ypos = 0.0;
 840       // The inner part of the radiator
 841       zpos = 0.0;
 842       sprintf(cTagV,"UC%02d",iDet);
 843       sprintf(cTagM,"UX%02d",iDet);
 844       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 845       // The glue around the radiator
 846       zpos = fgkCraH/2.0 - fgkCdrH/2.0 - fgkCraH/2.0;
 847       sprintf(cTagV,"UX%02d",iDet);
 848       sprintf(cTagM,"UB%02d",iDet);
 849       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 850       // The lower Wacosit frame inside the aluminum frame
 851       zpos = 0.0;
 852       sprintf(cTagV,"UB%02d",iDet);
 853       sprintf(cTagM,"UA%02d",iDet);
 854       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 855       // The inside of the upper Wacosit frame
 856       zpos = 0.0;
 857       sprintf(cTagV,"UE%02d",iDet);
 858       sprintf(cTagM,"UD%02d",iDet);
 859       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 860       // The inside of the upper aluminum frame
 861       zpos = 0.0;
 862       sprintf(cTagV,"UG%02d",iDet);
 863       sprintf(cTagM,"UF%02d",iDet);
 864       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 865
 866       // Position the frames of the chambers in the TRD mother volume
 867       xpos  = 0.0;
 868       ypos  = fClength[ilayer][0] + fClength[ilayer][1] + fClength[ilayer][2]/2.0;
 869       for (Int_t ic = 0; ic < istack; ic++) {
 870         ypos -= fClength[ilayer][ic];
 871       }
 872       ypos -= fClength[ilayer][istack]/2.0;
 873       zpos  = fgkVrocsm + fgkSMpltT + fgkCraH/2.0 + fgkCdrH/2.0 - fgkSheight/2.0
 874             + ilayer * (fgkCH + fgkVspace);
 875       // The lower aluminum frame, radiator + drift region
 876       sprintf(cTagV,"UA%02d",iDet);
 877       fChamberUAorig[iDet][0] = xpos;
 878       fChamberUAorig[iDet][1] = ypos;
 879       fChamberUAorig[iDet][2] = zpos;
 880       // The upper G10 frame, amplification region
 881       sprintf(cTagV,"UD%02d",iDet);
 882       zpos += fgkCamH/2.0 + fgkCraH/2.0 + fgkCdrH/2.0;
 883       fChamberUDorig[iDet][0] = xpos;
 884       fChamberUDorig[iDet][1] = ypos;
 885       fChamberUDorig[iDet][2] = zpos;
 886       // The upper aluminum frame
 887       sprintf(cTagV,"UF%02d",iDet);
 888       zpos += fgkCroH/2.0 + fgkCamH/2.0;
 889       fChamberUForig[iDet][0] = xpos;
 890       fChamberUForig[iDet][1] = ypos;
 891       fChamberUForig[iDet][2] = zpos;
 892
 893     }
 894   }
 895
 896   // Create the volumes of the super module frame
 897   CreateFrame(idtmed);
 898
 899   // Create the volumes of the services
 900   CreateServices(idtmed);
 901
 902   for (Int_t istack = 0; istack < kNstack; istack++) {
 903     for (Int_t ilayer = 0; ilayer < kNlayer; ilayer++) {
 904       GroupChamber(ilayer,istack,idtmed);
 905     }
 906   }
 907
 908   xpos = 0.0;
 909   ypos = 0.0;
 910   zpos = 0.0;
 911   gMC->Gspos("UTI1",1,"UTS1",xpos,ypos,zpos,0,"ONLY");
 912   gMC->Gspos("UTI2",1,"UTS2",xpos,ypos,zpos,0,"ONLY");
 913   gMC->Gspos("UTI3",1,"UTS3",xpos,ypos,zpos,0,"ONLY");
 914
 915   xpos = 0.0;
 916   ypos = 0.0;
 917   zpos = 0.0;
 918   gMC->Gspos("UTS1",1,"UTR1",xpos,ypos,zpos,0,"ONLY");
 919   gMC->Gspos("UTS2",1,"UTR2",xpos,ypos,zpos,0,"ONLY");
 920   gMC->Gspos("UTS3",1,"UTR3",xpos,ypos,zpos,0,"ONLY");
 921
 922   // Put the TRD volumes into the space frame mother volumes
 923   // if enabled via status flag
 924   xpos = 0.0;
 925   ypos = 0.0;
 926   zpos = 0.0;
 927   for (Int_t isector = 0; isector < kNsector; isector++) {
 928     if (GetSMstatus(isector)) {
 929       sprintf(cTagV,"BTRD%d",isector);
 930       switch (isector) {
 931       case 13:
 932       case 14:
 933       case 15:
 934         // Double carbon, w/o middle stack
 935         gMC->Gspos("UTR3",1,cTagV,xpos,ypos,zpos,0,"ONLY");
 936         break;
 937       case 11:
 938       case 12:
 939         // Double carbon, all stacks
 940         gMC->Gspos("UTR2",1,cTagV,xpos,ypos,zpos,0,"ONLY");
 941         break;
 942       default:
 943         // Standard supermodule
 944         gMC->Gspos("UTR1",1,cTagV,xpos,ypos,zpos,0,"ONLY");
 945       };
 946     }
 947   }
 948
 949   // Put the TRD volumes into the space frame mother volumes
 950   // if enabled via status flag
 951   xpos = 0.0;
 952   ypos = 0.5*fgkSlength + 0.5*fgkFlength;
 953   zpos = 0.0;
 954   for (Int_t isector = 0; isector < kNsector; isector++) {
 955     if (GetSMstatus(isector)) {
 956       sprintf(cTagV,"BTRD%d",isector);
 957       gMC->Gspos("UTF1",1,cTagV,xpos, ypos,zpos,0,"ONLY");
 958       gMC->Gspos("UTF2",1,cTagV,xpos,-ypos,zpos,0,"ONLY");
 959     }
 960   }
 961
 962 }
 963
 964 //_____________________________________________________________________________
 965 void AliTRDgeometry::CreateFrame(Int_t *idtmed)
 966 {
 967   //
 968   // Create the geometry of the frame of the supermodule
 969   //
 970   // Names of the TRD services volumina
 971   //
 972   //        USRL    Support rails for the chambers (Al)
 973   //        USxx    Support cross bars between the chambers (Al)
 974   //        USHx    Horizontal connection between the cross bars (Al)
 975   //        USLx    Long corner ledges (Al)
 976   //
 977
 978   Int_t   ilayer = 0;
 979
 980   Float_t xpos  = 0.0;
 981   Float_t ypos  = 0.0;
 982   Float_t zpos  = 0.0;
 983
 984   Char_t  cTagV[5];
 985   Char_t  cTagM[5];
 986
 987   const Int_t kNparTRD = 4;
 988   Float_t parTRD[kNparTRD];
 989   const Int_t kNparBOX = 3;
 990   Float_t parBOX[kNparBOX];
 991   const Int_t kNparTRP = 11;
 992   Float_t parTRP[kNparTRP];
 993
 994   // The rotation matrices
 995   const Int_t kNmatrix = 6;
 996   Int_t   matrix[kNmatrix];
 997   gMC->Matrix(matrix[0], 100.0,   0.0,  90.0,  90.0,  10.0,   0.0);
 998   gMC->Matrix(matrix[1],  80.0,   0.0,  90.0,  90.0,  10.0, 180.0);
 999   gMC->Matrix(matrix[2],  90.0,   0.0,   0.0,   0.0,  90.0,  90.0);
1000   gMC->Matrix(matrix[3],  90.0, 180.0,   0.0, 180.0,  90.0,  90.0);
1001   gMC->Matrix(matrix[4], 170.0,   0.0,  80.0,   0.0,  90.0,  90.0);
1002   gMC->Matrix(matrix[5], 170.0, 180.0,  80.0, 180.0,  90.0,  90.0);
1003   gMC->Matrix(matrix[6], 180.0, 180.0,  90.0, 180.0,  90.0,  90.0);
1004
1005   //
1006   // The carbon inserts in the top/bottom aluminum plates
1007   //
1008
1009   const Int_t kNparCrb = 3;
1010   Float_t parCrb[kNparCrb];
1011   parCrb[0] = 0.0;
1012   parCrb[1] = 0.0;
1013   parCrb[2] = 0.0;
1014   gMC->Gsvolu("USCR","BOX ",idtmed[1307-1],parCrb,0);
1015   // Bottom 1 (all sectors)
1016   parCrb[0] =  77.49/2.0;
1017   parCrb[1] = 104.60/2.0;
1018   parCrb[2] = fgkSMpltT/2.0;
1019   xpos      =   0.0;
1020   ypos      =   0.0;
1021   zpos      = fgkSMpltT/2.0 - fgkSheight/2.0;
1022   gMC->Gsposp("USCR", 1,"UTS1", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1023   gMC->Gsposp("USCR", 2,"UTS2", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1024   gMC->Gsposp("USCR", 3,"UTS3", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1025   // Bottom 2 (all sectors)
1026   parCrb[0] =  77.49/2.0;
1027   parCrb[1] =  55.80/2.0;
1028   parCrb[2] = fgkSMpltT/2.0;
1029   xpos      =   0.0;
1030   ypos      =  85.6;
1031   zpos      = fgkSMpltT/2.0 - fgkSheight/2.0;
1032   gMC->Gsposp("USCR", 4,"UTS1", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1033   gMC->Gsposp("USCR", 5,"UTS2", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1034   gMC->Gsposp("USCR", 6,"UTS3", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1035   gMC->Gsposp("USCR", 7,"UTS1", xpos,-ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1036   gMC->Gsposp("USCR", 8,"UTS2", xpos,-ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1037   gMC->Gsposp("USCR", 9,"UTS3", xpos,-ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1038   // Bottom 3 (all sectors)
1039   parCrb[0] =  77.49/2.0;
1040   parCrb[1] =  56.00/2.0;
1041   parCrb[2] = fgkSMpltT/2.0;
1042   xpos      =   0.0;
1043   ypos      = 148.5;
1044   zpos      = fgkSMpltT/2.0 - fgkSheight/2.0;
1045   gMC->Gsposp("USCR",10,"UTS1", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1046   gMC->Gsposp("USCR",11,"UTS2", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1047   gMC->Gsposp("USCR",12,"UTS3", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1048   gMC->Gsposp("USCR",13,"UTS1", xpos,-ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1049   gMC->Gsposp("USCR",14,"UTS2", xpos,-ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1050   gMC->Gsposp("USCR",15,"UTS3", xpos,-ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1051   // Bottom 4 (all sectors)
1052   parCrb[0] =  77.49/2.0;
1053   parCrb[1] = 118.00/2.0;
1054   parCrb[2] = fgkSMpltT/2.0;
1055   xpos      =   0.0;
1056   ypos      = 240.5;
1057   zpos      = fgkSMpltT/2.0 - fgkSheight/2.0;
1058   gMC->Gsposp("USCR",16,"UTS1", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1059   gMC->Gsposp("USCR",17,"UTS2", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1060   gMC->Gsposp("USCR",18,"UTS3", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1061   gMC->Gsposp("USCR",19,"UTS1", xpos,-ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1062   gMC->Gsposp("USCR",20,"UTS2", xpos,-ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1063   gMC->Gsposp("USCR",21,"UTS3", xpos,-ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1064   // Top 1 (only in front of PHOS)
1065   parCrb[0] = 111.48/2.0;
1066   parCrb[1] = 105.00/2.0;
1067   parCrb[2] = fgkSMpltT/2.0;
1068   xpos      =   0.0;
1069   ypos      =   0.0;
1070   zpos      = fgkSMpltT/2.0 - fgkSheight/2.0;
1071   gMC->Gsposp("USCR",22,"UTS2", xpos, ypos,-zpos,0,"ONLY",parCrb,kNparCrb);
1072   gMC->Gsposp("USCR",23,"UTS3", xpos, ypos,-zpos,0,"ONLY",parCrb,kNparCrb);
1073   // Top 2 (only in front of PHOS)
1074   parCrb[0] = 111.48/2.0;
1075   parCrb[1] =  56.00/2.0;
1076   parCrb[2] = fgkSMpltT/2.0;
1077   xpos      =   0.0;
1078   ypos      =  85.5;
1079   zpos      = fgkSMpltT/2.0 - fgkSheight/2.0;
1080   gMC->Gsposp("USCR",24,"UTS2", xpos, ypos,-zpos,0,"ONLY",parCrb,kNparCrb);
1081   gMC->Gsposp("USCR",25,"UTS3", xpos, ypos,-zpos,0,"ONLY",parCrb,kNparCrb);
1082   gMC->Gsposp("USCR",26,"UTS2", xpos,-ypos,-zpos,0,"ONLY",parCrb,kNparCrb);
1083   gMC->Gsposp("USCR",27,"UTS3", xpos,-ypos,-zpos,0,"ONLY",parCrb,kNparCrb);
1084
1085   //
1086   // The chamber support rails
1087   //
1088
1089   const Float_t kSRLwid  = 2.00;
1090   const Float_t kSRLhgt  = 2.3;
1091   const Float_t kSRLdst  = 1.0;
1092   const Int_t   kNparSRL = 3;
1093   Float_t parSRL[kNparSRL];
1094   parSRL[0] = kSRLwid   /2.0;
1095   parSRL[1] = fgkSlength/2.0;
1096   parSRL[2] = kSRLhgt   /2.0;
1097   gMC->Gsvolu("USRL","BOX ",idtmed[1301-1],parSRL,kNparSRL);
1098
1099   xpos  = 0.0;
1100   ypos  = 0.0;
1101   zpos  = 0.0;
1102   for (ilayer = 0; ilayer < kNlayer; ilayer++) {
1103     xpos  = fCwidth[ilayer]/2.0 + kSRLwid/2.0 + kSRLdst;
1104     ypos  = 0.0;
1105     zpos  = fgkVrocsm + fgkSMpltT + fgkCraH + fgkCdrH + fgkCamH
1106           - fgkSheight/2.0
1107           + ilayer * (fgkCH + fgkVspace);
1108     gMC->Gspos("USRL",ilayer+1          ,"UTI1", xpos,ypos,zpos,0,"ONLY");
1109     gMC->Gspos("USRL",ilayer+1+  kNlayer,"UTI1",-xpos,ypos,zpos,0,"ONLY");
1110     gMC->Gspos("USRL",ilayer+1+2*kNlayer,"UTI2", xpos,ypos,zpos,0,"ONLY");
1111     gMC->Gspos("USRL",ilayer+1+3*kNlayer,"UTI2",-xpos,ypos,zpos,0,"ONLY");
1112     gMC->Gspos("USRL",ilayer+1+4*kNlayer,"UTI3", xpos,ypos,zpos,0,"ONLY");
1113     gMC->Gspos("USRL",ilayer+1+5*kNlayer,"UTI3",-xpos,ypos,zpos,0,"ONLY");
1114   }
1115
1116   //
1117   // The cross bars between the chambers
1118   //
1119
1120   const Float_t kSCBwid  = 1.0;
1121   const Float_t kSCBthk  = 2.0;
1122   const Float_t kSCHhgt  = 0.3;
1123
1124   const Int_t   kNparSCB = 3;
1125   Float_t parSCB[kNparSCB];
1126   parSCB[1] = kSCBwid/2.0;
1127   parSCB[2] = fgkCH  /2.0 + fgkVspace/2.0 - kSCHhgt;
1128
1129   const Int_t   kNparSCI = 3;
1130   Float_t parSCI[kNparSCI];
1131   parSCI[1] = -1;
1132
1133   xpos  = 0.0;
1134   ypos  = 0.0;
1135   zpos  = 0.0;
1136   for (ilayer = 0; ilayer < kNlayer; ilayer++) {
1137
1138     // The aluminum of the cross bars
1139     parSCB[0] = fCwidth[ilayer]/2.0 + kSRLdst/2.0;
1140     sprintf(cTagV,"USF%01d",ilayer);
1141     gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
1142
1143     // The empty regions in the cross bars
1144     Float_t thkSCB = kSCBthk;
1145     if (ilayer < 2) {
1146       thkSCB *= 1.5;
1147     }
1148     parSCI[2] = parSCB[2] - thkSCB;
1149     parSCI[0] = parSCB[0]/4.0 - kSCBthk;
1150     sprintf(cTagV,"USI%01d",ilayer);
1151     gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parSCI,kNparSCI);
1152
1153     sprintf(cTagV,"USI%01d",ilayer);
1154     sprintf(cTagM,"USF%01d",ilayer);
1155     ypos  = 0.0;
1156     zpos  = 0.0;
1157     xpos  =   parSCI[0] + thkSCB/2.0;
1158     gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
1159     xpos  = - parSCI[0] - thkSCB/2.0;
1160     gMC->Gspos(cTagV,2,cTagM,xpos,ypos,zpos,0,"ONLY");
1161     xpos  =   3.0 * parSCI[0] + 1.5 * thkSCB;
1162     gMC->Gspos(cTagV,3,cTagM,xpos,ypos,zpos,0,"ONLY");
1163     xpos  = - 3.0 * parSCI[0] - 1.5 * thkSCB;
1164     gMC->Gspos(cTagV,4,cTagM,xpos,ypos,zpos,0,"ONLY");
1165
1166     sprintf(cTagV,"USF%01d",ilayer);
1167     xpos  = 0.0;
1168     zpos  = fgkVrocsm + fgkSMpltT + parSCB[2] - fgkSheight/2.0
1169           + ilayer * (fgkCH + fgkVspace);
1170
1171     ypos  =   fClength[ilayer][2]/2.0 + fClength[ilayer][1];
1172     gMC->Gspos(cTagV, 1,"UTI1", xpos,ypos,zpos,0,"ONLY");
1173     gMC->Gspos(cTagV, 3,"UTI2", xpos,ypos,zpos,0,"ONLY");
1174     gMC->Gspos(cTagV, 5,"UTI3", xpos,ypos,zpos,0,"ONLY");
1175
1176     ypos  = - fClength[ilayer][2]/2.0 - fClength[ilayer][1];
1177     gMC->Gspos(cTagV, 2,"UTI1", xpos,ypos,zpos,0,"ONLY");
1178     gMC->Gspos(cTagV, 4,"UTI2", xpos,ypos,zpos,0,"ONLY");
1179     gMC->Gspos(cTagV, 6,"UTI3", xpos,ypos,zpos,0,"ONLY");
1180
1181   }
1182
1183   //
1184   // The horizontal connections between the cross bars
1185   //
1186
1187   const Int_t   kNparSCH = 3;
1188   Float_t parSCH[kNparSCH];
1189
1190   for (ilayer = 1; ilayer < kNlayer-1; ilayer++) {
1191
1192     parSCH[0] = fCwidth[ilayer]/2.0;
1193     parSCH[1] = (fClength[ilayer+1][2]/2.0 + fClength[ilayer+1][1]
1194                - fClength[ilayer  ][2]/2.0 - fClength[ilayer  ][1])/2.0;
1195     parSCH[2] = kSCHhgt/2.0;
1196
1197     sprintf(cTagV,"USH%01d",ilayer);
1198     gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCH,kNparSCH);
1199     xpos  = 0.0;
1200     ypos  = fClength[ilayer][2]/2.0 + fClength[ilayer][1] + parSCH[1];
1201     zpos  = fgkVrocsm + fgkSMpltT - kSCHhgt/2.0 - fgkSheight/2.0
1202           + (ilayer+1) * (fgkCH + fgkVspace);
1203     gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
1204     gMC->Gspos(cTagV,3,"UTI2", xpos,ypos,zpos,0,"ONLY");
1205     gMC->Gspos(cTagV,5,"UTI3", xpos,ypos,zpos,0,"ONLY");
1206     ypos  = -ypos;
1207     gMC->Gspos(cTagV,2,"UTI1", xpos,ypos,zpos,0,"ONLY");
1208     gMC->Gspos(cTagV,4,"UTI2", xpos,ypos,zpos,0,"ONLY");
1209     gMC->Gspos(cTagV,6,"UTI3", xpos,ypos,zpos,0,"ONLY");
1210
1211   }
1212
1213   //
1214   // The aymmetric flat frame in the middle
1215   //
1216
1217   // The envelope volume (aluminum)
1218   parTRD[0]  =  87.60/2.0;
1219   parTRD[1]  = 114.00/2.0;
1220   parTRD[2]  =   1.20/2.0;
1221   parTRD[3]  =  71.30/2.0;
1222   gMC->Gsvolu("USDB","TRD1",idtmed[1301-1],parTRD,kNparTRD);
1223   // Empty spaces (air)
1224   parTRP[ 0] =   1.20/2.0;
1225   parTRP[ 1] =   0.0;
1226   parTRP[ 2] =   0.0;
1227   parTRP[ 3] =  27.00/2.0;
1228   parTRP[ 4] =  50.60/2.0;
1229   parTRP[ 5] =   5.00/2.0;
1230   parTRP[ 6] =   3.5;
1231   parTRP[ 7] =  27.00/2.0;
1232   parTRP[ 8] =  50.60/2.0;
1233   parTRP[ 9] =   5.00/2.0;
1234   parTRP[10] =   3.5;
1235   gMC->Gsvolu("USD1","TRAP",idtmed[1302-1],parTRP,kNparTRP);
1236   xpos       =  18.0;
1237   ypos       =   0.0;
1238   zpos       =   27.00/2.0 - 71.3/2.0;
1239   gMC->Gspos("USD1",1,"USDB", xpos, ypos, zpos,matrix[2],"ONLY");
1240   // Empty spaces (air)
1241   parTRP[ 0] =   1.20/2.0;
1242   parTRP[ 1] =   0.0;
1243   parTRP[ 2] =   0.0;
1244   parTRP[ 3] =  33.00/2.0;
1245   parTRP[ 4] =   5.00/2.0;
1246   parTRP[ 5] =  62.10/2.0;
1247   parTRP[ 6] =   3.5;
1248   parTRP[ 7] =  33.00/2.0;
1249   parTRP[ 8] =   5.00/2.0;
1250   parTRP[ 9] =  62.10/2.0;
1251   parTRP[10] =   3.5;
1252   gMC->Gsvolu("USD2","TRAP",idtmed[1302-1],parTRP,kNparTRP);
1253   xpos       =  21.0;
1254   ypos       =   0.0;
1255   zpos       =  71.3/2.0 - 33.0/2.0;
1256   gMC->Gspos("USD2",1,"USDB", xpos, ypos, zpos,matrix[2],"ONLY");
1257   // Empty spaces (air)
1258   parBOX[ 0] =  22.50/2.0;
1259   parBOX[ 1] =   1.20/2.0;
1260   parBOX[ 2] =  70.50/2.0;
1261   gMC->Gsvolu("USD3","BOX ",idtmed[1302-1],parBOX,kNparBOX);
1262   xpos       = -25.75;
1263   ypos       =   0.0;
1264   zpos       =   0.4;
1265   gMC->Gspos("USD3",1,"USDB", xpos, ypos, zpos,        0,"ONLY");
1266   // Empty spaces (air)
1267   parTRP[ 0] =   1.20/2.0;
1268   parTRP[ 1] =   0.0;
1269   parTRP[ 2] =   0.0;
1270   parTRP[ 3] =  25.50/2.0;
1271   parTRP[ 4] =   5.00/2.0;
1272   parTRP[ 5] =  65.00/2.0;
1273   parTRP[ 6] =  -1.0;
1274   parTRP[ 7] =  25.50/2.0;
1275   parTRP[ 8] =   5.00/2.0;
1276   parTRP[ 9] =  65.00/2.0;
1277   parTRP[10] =  -1.0;
1278   gMC->Gsvolu("USD4","TRAP",idtmed[1302-1],parTRP,kNparTRP);
1279   xpos       =   2.0;
1280   ypos       =   0.0;
1281   zpos       =  -1.6;
1282   gMC->Gspos("USD4",1,"USDB", xpos, ypos, zpos,matrix[6],"ONLY");
1283   // Empty spaces (air)
1284   parTRP[ 0] =   1.20/2.0;
1285   parTRP[ 1] =   0.0;
1286   parTRP[ 2] =   0.0;
1287   parTRP[ 3] =  23.50/2.0;
1288   parTRP[ 4] =  63.50/2.0;
1289   parTRP[ 5] =   5.00/2.0;
1290   parTRP[ 6] =  16.0;
1291   parTRP[ 7] =  23.50/2.0;
1292   parTRP[ 8] =  63.50/2.0;
1293   parTRP[ 9] =   5.00/2.0;
1294   parTRP[10] =  16.0;
1295   gMC->Gsvolu("USD5","TRAP",idtmed[1302-1],parTRP,kNparTRP);
1296   xpos       =  36.5;
1297   ypos       =   0.0;
1298   zpos       =  -1.5;
1299   gMC->Gspos("USD5",1,"USDB", xpos, ypos, zpos,matrix[5],"ONLY");
1300   // Empty spaces (air)
1301   parTRP[ 0] =   1.20/2.0;
1302   parTRP[ 1] =   0.0;
1303   parTRP[ 2] =   0.0;
1304   parTRP[ 3] =  70.50/2.0;
1305   parTRP[ 4] =   4.50/2.0;
1306   parTRP[ 5] =  16.50/2.0;
1307   parTRP[ 6] =  -5.0;
1308   parTRP[ 7] =  70.50/2.0;
1309   parTRP[ 8] =   4.50/2.0;
1310   parTRP[ 9] =  16.50/2.0;
1311   parTRP[10] =  -5.0;
1312   gMC->Gsvolu("USD6","TRAP",idtmed[1302-1],parTRP,kNparTRP);
1313   xpos       = -43.7;
1314   ypos       =   0.0;
1315   zpos       =   0.4;
1316   gMC->Gspos("USD6",1,"USDB", xpos, ypos, zpos,matrix[2],"ONLY");
1317   xpos       =   0.0;
1318   ypos       =   fClength[5][2]/2.0;
1319   zpos       =   0.04;
1320   gMC->Gspos("USDB",1,"UTI1", xpos, ypos, zpos,        0,"ONLY");
1321   gMC->Gspos("USDB",2,"UTI1", xpos,-ypos, zpos,        0,"ONLY");
1322   gMC->Gspos("USDB",3,"UTI2", xpos, ypos, zpos,        0,"ONLY");
1323   gMC->Gspos("USDB",4,"UTI2", xpos,-ypos, zpos,        0,"ONLY");
1324   gMC->Gspos("USDB",5,"UTI3", xpos, ypos, zpos,        0,"ONLY");
1325   gMC->Gspos("USDB",6,"UTI3", xpos,-ypos, zpos,        0,"ONLY");
1326   // Upper bar (aluminum)
1327   parBOX[0] = 95.00/2.0;
1328   parBOX[1] =  1.20/2.0;
1329   parBOX[2] =  3.00/2.0;
1330   gMC->Gsvolu("USD7","BOX ",idtmed[1301-1],parBOX,kNparBOX);
1331   xpos       =   0.0;
1332   ypos       =   fClength[5][2]/2.0;
1333   zpos       =   fgkSheight/2.0 - fgkSMpltT  - 3.00/2.0;
1334   gMC->Gspos("USD7",1,"UTI1", xpos, ypos, zpos,        0,"ONLY");
1335   gMC->Gspos("USD7",2,"UTI1", xpos,-ypos, zpos,        0,"ONLY");
1336   gMC->Gspos("USD7",3,"UTI2", xpos, ypos, zpos,        0,"ONLY");
1337   gMC->Gspos("USD7",4,"UTI2", xpos,-ypos, zpos,        0,"ONLY");
1338   gMC->Gspos("USD7",5,"UTI3", xpos, ypos, zpos,        0,"ONLY");
1339   gMC->Gspos("USD7",6,"UTI3", xpos,-ypos, zpos,        0,"ONLY");
1340   // Lower bar (aluminum)
1341   parBOX[0] = 90.22/2.0;
1342   parBOX[1] =  1.20/2.0;
1343   parBOX[2] =  1.74/2.0;
1344   gMC->Gsvolu("USD8","BOX ",idtmed[1301-1],parBOX,kNparBOX);
1345   xpos       =   0.0;
1346   ypos       =   fClength[5][2]/2.0 - 0.1;
1347   zpos       =  -fgkSheight/2.0 + fgkSMpltT + 2.27;
1348   gMC->Gspos("USD8",1,"UTI1", xpos, ypos, zpos,        0,"ONLY");
1349   gMC->Gspos("USD8",2,"UTI1", xpos,-ypos, zpos,        0,"ONLY");
1350   gMC->Gspos("USD8",3,"UTI2", xpos, ypos, zpos,        0,"ONLY");
1351   gMC->Gspos("USD8",4,"UTI2", xpos,-ypos, zpos,        0,"ONLY");
1352   gMC->Gspos("USD8",5,"UTI3", xpos, ypos, zpos,        0,"ONLY");
1353   gMC->Gspos("USD8",6,"UTI3", xpos,-ypos, zpos,        0,"ONLY");
1354   // Lower bar (aluminum)
1355   parBOX[0] = 82.60/2.0;
1356   parBOX[1] =  1.20/2.0;
1357   parBOX[2] =  1.40/2.0;
1358   gMC->Gsvolu("USD9","BOX ",idtmed[1301-1],parBOX,kNparBOX);
1359   xpos       =   0.0;
1360   ypos       =   fClength[5][2]/2.0;
1361   zpos       =  -fgkSheight/2.0 + fgkSMpltT + 1.40/2.0;
1362   gMC->Gspos("USD9",1,"UTI1", xpos, ypos, zpos,        0,"ONLY");
1363   gMC->Gspos("USD9",2,"UTI1", xpos,-ypos, zpos,        0,"ONLY");
1364   gMC->Gspos("USD9",3,"UTI2", xpos, ypos, zpos,        0,"ONLY");
1365   gMC->Gspos("USD9",4,"UTI2", xpos,-ypos, zpos,        0,"ONLY");
1366   gMC->Gspos("USD9",5,"UTI3", xpos, ypos, zpos,        0,"ONLY");
1367   gMC->Gspos("USD9",6,"UTI3", xpos,-ypos, zpos,        0,"ONLY");
1368   // Front sheet (aluminum)
1369   parTRP[ 0] =   0.10/2.0;
1370   parTRP[ 1] =   0.0;
1371   parTRP[ 2] =   0.0;
1372   parTRP[ 3] =  74.50/2.0;
1373   parTRP[ 4] =  31.70/2.0;
1374   parTRP[ 5] =  44.00/2.0;
1375   parTRP[ 6] =  -5.0;
1376   parTRP[ 7] =  74.50/2.0;
1377   parTRP[ 8] =  31.70/2.0;
1378   parTRP[ 9] =  44.00/2.0;
1379   parTRP[10] =  -5.0;
1380   gMC->Gsvolu("USDF","TRAP",idtmed[1302-1],parTRP,kNparTRP);
1381   xpos       = -32.0;
1382   ypos       =   fClength[5][2]/2.0 + 1.20/2.0 + 0.10/2.0;
1383   zpos       =   0.0;
1384   gMC->Gspos("USDF",1,"UTI1", xpos, ypos, zpos,matrix[2],"ONLY");
1385   gMC->Gspos("USDF",2,"UTI1", xpos,-ypos, zpos,matrix[2],"ONLY");
1386   gMC->Gspos("USDF",3,"UTI2", xpos, ypos, zpos,matrix[2],"ONLY");
1387   gMC->Gspos("USDF",4,"UTI2", xpos,-ypos, zpos,matrix[2],"ONLY");
1388   gMC->Gspos("USDF",5,"UTI3", xpos, ypos, zpos,matrix[2],"ONLY");
1389   gMC->Gspos("USDF",6,"UTI3", xpos,-ypos, zpos,matrix[2],"ONLY");
1390
1391   //
1392   // The flat frame in front of the chambers
1393   //
1394
1395   // The envelope volume (aluminum)
1396   parTRD[0]  =  90.00/2.0 - 0.1;
1397   parTRD[1]  = 114.00/2.0 - 0.1;
1398   parTRD[2]  =   1.50/2.0;
1399   parTRD[3]  =  70.30/2.0;
1400   gMC->Gsvolu("USCB","TRD1",idtmed[1301-1],parTRD,kNparTRD);
1401   // Empty spaces (air)
1402   parTRD[0]  =  87.00/2.0;
1403   parTRD[1]  =  10.00/2.0;
1404   parTRD[2]  =   1.50/2.0;
1405   parTRD[3]  =  26.35/2.0;
1406   gMC->Gsvolu("USC1","TRD1",idtmed[1302-1],parTRD,kNparTRD);
1407   xpos       =  0.0;
1408   ypos       =  0.0;
1409   zpos       = 26.35/2.0 - 70.3/2.0;
1410   gMC->Gspos("USC1",1,"USCB",xpos,ypos,zpos,0,"ONLY");
1411   // Empty spaces (air)
1412   parTRD[0]  =  10.00/2.0;
1413   parTRD[1]  = 111.00/2.0;
1414   parTRD[2]  =   1.50/2.0;
1415   parTRD[3]  =  35.05/2.0;
1416   gMC->Gsvolu("USC2","TRD1",idtmed[1302-1],parTRD,kNparTRD);
1417   xpos       =  0.0;
1418   ypos       =  0.0;
1419   zpos       = 70.3/2.0 - 35.05/2.0;
1420   gMC->Gspos("USC2",1,"USCB",xpos,ypos,zpos,0,"ONLY");
1421   // Empty spaces (air)
1422   parTRP[ 0] =   1.50/2.0;
1423   parTRP[ 1] =   0.0;
1424   parTRP[ 2] =   0.0;
1425   parTRP[ 3] =  37.60/2.0;
1426   parTRP[ 4] =  63.90/2.0;
1427   parTRP[ 5] =   8.86/2.0;
1428   parTRP[ 6] =  16.0;
1429   parTRP[ 7] =  37.60/2.0;
1430   parTRP[ 8] =  63.90/2.0;
1431   parTRP[ 9] =   8.86/2.0;
1432   parTRP[10] =  16.0;
1433   gMC->Gsvolu("USC3","TRAP",idtmed[1302-1],parTRP,kNparTRP);
1434   xpos       = -30.5;
1435   ypos       =   0.0;
1436   zpos       =  -2.0;
1437   gMC->Gspos("USC3",1,"USCB", xpos, ypos, zpos,matrix[4],"ONLY");
1438   gMC->Gspos("USC3",2,"USCB",-xpos, ypos, zpos,matrix[5],"ONLY");
1439   xpos       =   0.0;
1440   ypos       =   fClength[5][2]/2.0 + fClength[5][1] + fClength[5][0];
1441   zpos       =   0.0;
1442   gMC->Gspos("USCB",1,"UTI1", xpos, ypos, zpos,        0,"ONLY");
1443   gMC->Gspos("USCB",2,"UTI1", xpos,-ypos, zpos,        0,"ONLY");
1444   gMC->Gspos("USCB",3,"UTI2", xpos, ypos, zpos,        0,"ONLY");
1445   gMC->Gspos("USCB",4,"UTI2", xpos,-ypos, zpos,        0,"ONLY");
1446   gMC->Gspos("USCB",5,"UTI3", xpos, ypos, zpos,        0,"ONLY");
1447   gMC->Gspos("USCB",6,"UTI3", xpos,-ypos, zpos,        0,"ONLY");
1448   // Upper bar (aluminum)
1449   parBOX[0] = 95.00/2.0;
1450   parBOX[1] =  1.50/2.0;
1451   parBOX[2] =  3.00/2.0;
1452   gMC->Gsvolu("USC4","BOX ",idtmed[1301-1],parBOX,kNparBOX);
1453   xpos       =   0.0;
1454   ypos       =   fClength[5][2]/2.0 + fClength[5][1] + fClength[5][0];
1455   zpos       =   fgkSheight/2.0 - fgkSMpltT - 3.00/2.0;
1456   gMC->Gspos("USC4",1,"UTI1", xpos, ypos, zpos,        0,"ONLY");
1457   gMC->Gspos("USC4",2,"UTI1", xpos,-ypos, zpos,        0,"ONLY");
1458   gMC->Gspos("USC4",3,"UTI2", xpos, ypos, zpos,        0,"ONLY");
1459   gMC->Gspos("USC4",4,"UTI2", xpos,-ypos, zpos,        0,"ONLY");
1460   gMC->Gspos("USC4",5,"UTI3", xpos, ypos, zpos,        0,"ONLY");
1461   gMC->Gspos("USC4",6,"UTI3", xpos,-ypos, zpos,        0,"ONLY");
1462   // Lower bar (aluminum)
1463   parBOX[0] = 90.22/2.0;
1464   parBOX[1] =  1.50/2.0;
1465   parBOX[2] =  2.00/2.0;
1466   gMC->Gsvolu("USC5","BOX ",idtmed[1301-1],parBOX,kNparBOX);
1467   xpos       =   0.0;
1468   ypos       =   fClength[5][2]/2.0 + fClength[5][1] + fClength[5][0];
1469   zpos       =  -fgkSheight/2.0 + fgkSMpltT + 2.60;
1470   gMC->Gspos("USC5",1,"UTI1", xpos, ypos, zpos,        0,"ONLY");
1471   gMC->Gspos("USC5",2,"UTI1", xpos,-ypos, zpos,        0,"ONLY");
1472   gMC->Gspos("USC5",3,"UTI2", xpos, ypos, zpos,        0,"ONLY");
1473   gMC->Gspos("USC5",4,"UTI2", xpos,-ypos, zpos,        0,"ONLY");
1474   gMC->Gspos("USC5",5,"UTI3", xpos, ypos, zpos,        0,"ONLY");
1475   gMC->Gspos("USC5",6,"UTI3", xpos,-ypos, zpos,        0,"ONLY");
1476   // Lower bar (aluminum)
1477   parBOX[0] = 82.60/2.0;
1478   parBOX[1] =  1.50/2.0;
1479   parBOX[2] =  1.60/2.0;
1480   gMC->Gsvolu("USC6","BOX ",idtmed[1301-1],parBOX,kNparBOX);
1481   xpos       =   0.0;
1482   ypos       =   fClength[5][2]/2.0 + fClength[5][1] + fClength[5][0];
1483   zpos       =  -fgkSheight/2.0 + fgkSMpltT + 1.60/2.0;
1484   gMC->Gspos("USC6",1,"UTI1", xpos, ypos, zpos,        0,"ONLY");
1485   gMC->Gspos("USC6",2,"UTI1", xpos,-ypos, zpos,        0,"ONLY");
1486   gMC->Gspos("USC6",3,"UTI2", xpos, ypos, zpos,        0,"ONLY");
1487   gMC->Gspos("USC6",4,"UTI2", xpos,-ypos, zpos,        0,"ONLY");
1488   gMC->Gspos("USC6",5,"UTI3", xpos, ypos, zpos,        0,"ONLY");
1489   gMC->Gspos("USC6",6,"UTI3", xpos,-ypos, zpos,        0,"ONLY");
1490
1491   //
1492   // The long corner ledges
1493   //
1494
1495   const Int_t   kNparSCL  =  3;
1496   Float_t parSCL[kNparSCL];
1497   const Int_t   kNparSCLb = 11;
1498   Float_t parSCLb[kNparSCLb];
1499
1500   // Upper ledges
1501   // Thickness of the corner ledges
1502   const Float_t kSCLthkUa  =  0.6;
1503   const Float_t kSCLthkUb  =  0.6;
1504   // Width of the corner ledges
1505   const Float_t kSCLwidUa  =  3.2;
1506   const Float_t kSCLwidUb  =  4.8;
1507   // Position of the corner ledges
1508   const Float_t kSCLposxUa = 0.7;
1509   const Float_t kSCLposxUb = 3.3;
1510   const Float_t kSCLposzUa = 1.65;
1511   const Float_t kSCLposzUb = 0.3;
1512   // Vertical
1513   parSCL[0]  = kSCLthkUa /2.0;
1514   parSCL[1]  = fgkSlength/2.0;
1515   parSCL[2]  = kSCLwidUa /2.0;
1516   gMC->Gsvolu("USL1","BOX ",idtmed[1301-1],parSCL,kNparSCL);
1517   xpos  =   fgkSwidth2/2.0 - fgkSMpltT - kSCLposxUa;
1518   ypos  =   0.0;
1519   zpos  =   fgkSheight/2.0 - fgkSMpltT - kSCLposzUa;
1520   gMC->Gspos("USL1",1,"UTI1", xpos,ypos,zpos,matrix[0],"ONLY");
1521   xpos  = -xpos;
1522   gMC->Gspos("USL1",2,"UTI1", xpos,ypos,zpos,matrix[1],"ONLY");
1523   // Horizontal
1524   parSCL[0]  = kSCLwidUb /2.0;
1525   parSCL[1]  = fgkSlength/2.0;
1526   parSCL[2]  = kSCLthkUb /2.0;
1527   gMC->Gsvolu("USL2","BOX ",idtmed[1301-1],parSCL,kNparSCL);
1528   xpos  =   fgkSwidth2/2.0 - fgkSMpltT - kSCLposxUb;
1529   ypos  =   0.0;
1530   zpos  =   fgkSheight/2.0 - fgkSMpltT - kSCLposzUb;
1531   gMC->Gspos("USL2",1,"UTI1", xpos,ypos,zpos,        0,"ONLY");
1532   gMC->Gspos("USL2",3,"UTI2", xpos,ypos,zpos,        0,"ONLY");
1533   gMC->Gspos("USL2",5,"UTI3", xpos,ypos,zpos,        0,"ONLY");
1534   xpos  = -xpos;
1535   gMC->Gspos("USL2",2,"UTI1", xpos,ypos,zpos,        0,"ONLY");
1536   gMC->Gspos("USL2",4,"UTI2", xpos,ypos,zpos,        0,"ONLY");
1537   gMC->Gspos("USL2",6,"UTI3", xpos,ypos,zpos,        0,"ONLY");
1538
1539   // Lower ledges
1540   // Thickness of the corner ledges
1541   const Float_t kSCLthkLa  =  2.464;
1542   const Float_t kSCLthkLb  =  1.0;
1543   // Width of the corner ledges
1544   const Float_t kSCLwidLa  =  8.5;
1545   const Float_t kSCLwidLb  =  3.3;
1546   // Position of the corner ledges
1547   const Float_t kSCLposxLa =  0.15;
1548   const Float_t kSCLposxLb =  2.7;
1549   const Float_t kSCLposzLa = -4.25;
1550   const Float_t kSCLposzLb = -0.5;
1551   // Vertical
1552   // Trapezoidal shape
1553   parSCLb[ 0] = fgkSlength/2.0;
1554   parSCLb[ 1] = 0.0;
1555   parSCLb[ 2] = 0.0;
1556   parSCLb[ 3] = kSCLwidLa /2.0;
1557   parSCLb[ 4] = kSCLthkLb /2.0;
1558   parSCLb[ 5] = kSCLthkLa /2.0;
1559   parSCLb[ 6] = 5.0;
1560   parSCLb[ 7] = kSCLwidLa /2.0;
1561   parSCLb[ 8] = kSCLthkLb /2.0;
1562   parSCLb[ 9] = kSCLthkLa /2.0;
1563   parSCLb[10] = 5.0;
1564   gMC->Gsvolu("USL3","TRAP",idtmed[1301-1],parSCLb,kNparSCLb);
1565   xpos  =   fgkSwidth1/2.0 - fgkSMpltT - kSCLposxLa;
1566   ypos  =   0.0;
1567   zpos  = - fgkSheight/2.0 + fgkSMpltT - kSCLposzLa;
1568   gMC->Gspos("USL3",1,"UTI1", xpos,ypos,zpos,matrix[2],"ONLY");
1569   gMC->Gspos("USL3",3,"UTI2", xpos,ypos,zpos,matrix[2],"ONLY");
1570   gMC->Gspos("USL3",5,"UTI3", xpos,ypos,zpos,matrix[2],"ONLY");
1571   xpos  = -xpos;
1572   gMC->Gspos("USL3",2,"UTI1", xpos,ypos,zpos,matrix[3],"ONLY");
1573   gMC->Gspos("USL3",4,"UTI2", xpos,ypos,zpos,matrix[3],"ONLY");
1574   gMC->Gspos("USL3",6,"UTI3", xpos,ypos,zpos,matrix[3],"ONLY");
1575   // Horizontal
1576   parSCL[0]  = kSCLwidLb /2.0;
1577   parSCL[1]  = fgkSlength/2.0;
1578   parSCL[2]  = kSCLthkLb /2.0;
1579   gMC->Gsvolu("USL4","BOX ",idtmed[1301-1],parSCL,kNparSCL);
1580   xpos  =   fgkSwidth1/2.0 - fgkSMpltT - kSCLposxLb;
1581   ypos  =   0.0;
1582   zpos  = - fgkSheight/2.0 + fgkSMpltT - kSCLposzLb;
1583   gMC->Gspos("USL4",1,"UTI1", xpos,ypos,zpos,        0,"ONLY");
1584   gMC->Gspos("USL4",3,"UTI2", xpos,ypos,zpos,        0,"ONLY");
1585   gMC->Gspos("USL4",5,"UTI3", xpos,ypos,zpos,        0,"ONLY");
1586   xpos  = -xpos;
1587   gMC->Gspos("USL4",2,"UTI1", xpos,ypos,zpos,        0,"ONLY");
1588   gMC->Gspos("USL4",4,"UTI2", xpos,ypos,zpos,        0,"ONLY");
1589   gMC->Gspos("USL4",6,"UTI3", xpos,ypos,zpos,        0,"ONLY");
1590
1591   //
1592   // Aluminum plates in the front part of the super modules
1593   //
1594
1595   const Int_t kNparTrd = 4;
1596   Float_t parTrd[kNparTrd];
1597   parTrd[0] = fgkSwidth1/2.0 - 2.5;
1598   parTrd[1] = fgkSwidth2/2.0 - 2.5;
1599   parTrd[2] = fgkSMpltT /2.0;
1600   parTrd[3] = fgkSheight/2.0 - 1.0;
1601   gMC->Gsvolu("UTA1","TRD1",idtmed[1301-1],parTrd,kNparTrd);
1602   xpos      =  0.0;
1603   ypos      =  fgkSMpltT/2.0 - fgkFlength/2.0;
1604   zpos      = -0.5;
1605   gMC->Gspos("UTA1",1,"UTF1",xpos, ypos,zpos,        0,"ONLY");
1606   gMC->Gspos("UTA1",2,"UTF2",xpos,-ypos,zpos,        0,"ONLY");
1607
1608   const Int_t kNparPlt = 3;
1609   Float_t parPlt[kNparPlt];
1610   parPlt[0] =  0.0;
1611   parPlt[1] =  0.0;
1612   parPlt[2] =  0.0;
1613   gMC->Gsvolu("UTA2","BOX ",idtmed[1301-1],parPlt,0);
1614   xpos      =  0.0;
1615   ypos      =  0.0;
1616   zpos      =  fgkSheight/2.0 - fgkSMpltT/2.0;
1617   parPlt[0] = fgkSwidth2/2.0 - 0.2;
1618   parPlt[1] = fgkFlength/2.0;
1619   parPlt[2] = fgkSMpltT /2.0;
1620   gMC->Gsposp("UTA2",1,"UTF2",xpos,ypos,zpos
1621                     ,        0,"ONLY",parPlt,kNparPlt);
1622   xpos      = (fgkSwidth1 + fgkSwidth2)/4.0 - fgkSMpltT/2.0 - 0.0016;
1623   ypos      =  0.0;
1624   zpos      =  0.0;
1625   parPlt[0] = fgkSMpltT /2.0;
1626   parPlt[1] = fgkFlength/2.0;
1627   parPlt[2] = fgkSheight/2.0;
1628   gMC->Gsposp("UTA2",2,"UTF2", xpos,ypos,zpos
1629                     ,matrix[0],"ONLY",parPlt,kNparPlt);
1630   gMC->Gsposp("UTA2",3,"UTF2",-xpos,ypos,zpos
1631                     ,matrix[1],"ONLY",parPlt,kNparPlt);
1632
1633   // Additional aluminum bar
1634   parBOX[0] = 80.0/2.0;
1635   parBOX[1] =  1.0/2.0;
1636   parBOX[2] = 10.0/2.0;
1637   gMC->Gsvolu("UTA3","BOX ",idtmed[1301-1],parBOX,kNparBOX);
1638   xpos      =  0.0;
1639   ypos      =  1.0/2.0 + fgkSMpltT - fgkFlength/2.0;
1640   zpos      =  fgkSheight/2.0 - 1.5 - 10.0/2.0;
1641   gMC->Gspos("UTA3",1,"UTF1", xpos, ypos, zpos,        0,"ONLY");
1642   gMC->Gspos("UTA3",2,"UTF2", xpos,-ypos, zpos,        0,"ONLY");
1643
1644 }
1645
1646 //_____________________________________________________________________________
1647 void AliTRDgeometry::CreateServices(Int_t *idtmed)
1648 {
1649   //
1650   // Create the geometry of the services
1651   //
1652   // Names of the TRD services volumina
1653   //
1654   //        UTC1    Cooling arterias (Al)
1655   //        UTC2    Cooling arterias (Water)
1656   //        UUxx    Volumes for the services at the chambers (Air)
1657   //        UTP1    Power bars       (Cu)
1658   //        UTCP    Cooling pipes    (Fe)
1659   //        UTCH    Cooling pipes    (Water)
1660   //        UTPL    Power lines      (Cu)
1661   //        UMCM    Readout MCMs     (G10/Cu/Si)
1662   //        UTGD    Gas distribution box (V2A)
1663   //
1664
1665   Int_t   ilayer = 0;
1666   Int_t   istack = 0;
1667
1668   Float_t xpos  = 0.0;
1669   Float_t ypos  = 0.0;
1670   Float_t zpos  = 0.0;
1671
1672   Char_t  cTagV[5];
1673
1674   const Int_t kNparBox  = 3;
1675   Float_t parBox[kNparBox];
1676
1677   const Int_t kNparTube = 3;
1678   Float_t parTube[kNparTube];
1679
1680   // Services inside the baby frame
1681   const Float_t kBBMdz = 223.0;
1682   const Float_t kBBSdz =   8.5;
1683
1684   // Services inside the back frame
1685   const Float_t kBFMdz = 118.0;
1686   const Float_t kBFSdz =   8.5;
1687
1688   // The rotation matrices
1689   const Int_t kNmatrix = 10;
1690   Int_t   matrix[kNmatrix];
1691   gMC->Matrix(matrix[0], 100.0,   0.0,  90.0,  90.0,  10.0,   0.0); // rotation around y-axis
1692   gMC->Matrix(matrix[1],  80.0,   0.0,  90.0,  90.0,  10.0, 180.0); // rotation around y-axis
1693   gMC->Matrix(matrix[2],   0.0,   0.0,  90.0,  90.0,  90.0,   0.0);
1694   gMC->Matrix(matrix[3], 180.0,   0.0,  90.0,  90.0,  90.0, 180.0);
1695   gMC->Matrix(matrix[4],  90.0,   0.0,   0.0,   0.0,  90.0,  90.0);
1696   gMC->Matrix(matrix[5], 100.0,   0.0,  90.0, 270.0,  10.0,   0.0);
1697   gMC->Matrix(matrix[6],  80.0,   0.0,  90.0, 270.0,  10.0, 180.0);
1698   gMC->Matrix(matrix[7],  90.0,  10.0,  90.0, 100.0,   0.0,   0.0); // rotation around z-axis
1699   gMC->Matrix(matrix[8],  90.0, 350.0,  90.0,  80.0,   0.0,   0.0); // rotation around z-axis
1700   gMC->Matrix(matrix[9],  90.0,  90.0,  90.0, 180.0,   0.0,   0.0); // rotation around z-axis
1701
1702   //
1703   // The cooling arterias
1704   //
1705
1706   // Width of the cooling arterias
1707   const Float_t kCOLwid  =  0.8;
1708   // Height of the cooling arterias
1709   const Float_t kCOLhgt  =  6.5;
1710   // Positioning of the cooling
1711   const Float_t kCOLposx =  1.8;
1712   const Float_t kCOLposz = -0.1;
1713   // Thickness of the walls of the cooling arterias
1714   const Float_t kCOLthk  =  0.1;
1715   const Int_t   kNparCOL =  3;
1716   Float_t parCOL[kNparCOL];
1717   parCOL[0] = 0.0;
1718   parCOL[1] = 0.0;
1719   parCOL[2] = 0.0;
1720   gMC->Gsvolu("UTC1","BOX ",idtmed[1308-1],parCOL,0);
1721   gMC->Gsvolu("UTC3","BOX ",idtmed[1308-1],parCOL,0);
1722   parCOL[0] =  kCOLwid/2.0 - kCOLthk;
1723   parCOL[1] = -1.0;
1724   parCOL[2] =  kCOLhgt/2.0 - kCOLthk;
1725   gMC->Gsvolu("UTC2","BOX ",idtmed[1314-1],parCOL,kNparCOL);
1726   gMC->Gsvolu("UTC4","BOX ",idtmed[1314-1],parCOL,kNparCOL);
1727
1728   xpos  = 0.0;
1729   ypos  = 0.0;
1730   zpos  = 0.0;
1731   gMC->Gspos("UTC2",1,"UTC1", xpos,ypos,zpos,0,"ONLY");
1732   gMC->Gspos("UTC4",1,"UTC3", xpos,ypos,zpos,0,"ONLY");
1733
1734   for (ilayer = 1; ilayer < kNlayer; ilayer++) {
1735
1736     // Along the chambers
1737     xpos      = fCwidth[ilayer]/2.0 + kCOLwid/2.0 + kCOLposx;
1738     ypos      = 0.0;
1739     zpos      = fgkVrocsm + fgkSMpltT + kCOLhgt/2.0 - fgkSheight/2.0 + kCOLposz
1740               + ilayer * (fgkCH + fgkVspace);
1741     parCOL[0] = kCOLwid   /2.0;
1742     parCOL[1] = fgkSlength/2.0;
1743     parCOL[2] = kCOLhgt   /2.0;
1744     gMC->Gsposp("UTC1",ilayer          ,"UTI1", xpos,ypos,zpos
1745                       ,matrix[0],"ONLY",parCOL,kNparCOL);
1746     gMC->Gsposp("UTC1",ilayer+  kNlayer,"UTI1",-xpos,ypos,zpos
1747                       ,matrix[1],"ONLY",parCOL,kNparCOL);
1748     gMC->Gsposp("UTC1",ilayer+6*kNlayer,"UTI2", xpos,ypos,zpos
1749                       ,matrix[0],"ONLY",parCOL,kNparCOL);
1750     gMC->Gsposp("UTC1",ilayer+7*kNlayer,"UTI2",-xpos,ypos,zpos
1751                       ,matrix[1],"ONLY",parCOL,kNparCOL);
1752     gMC->Gsposp("UTC1",ilayer+8*kNlayer ,"UTI3", xpos,ypos,zpos
1753                       ,matrix[0],"ONLY",parCOL,kNparCOL);
1754     gMC->Gsposp("UTC1",ilayer+9*kNlayer,"UTI3",-xpos,ypos,zpos
1755                       ,matrix[1],"ONLY",parCOL,kNparCOL);
1756
1757     // Front of supermodules
1758     xpos      = fCwidth[ilayer]/2.0 + kCOLwid/2.0 + kCOLposx;
1759     ypos      = 0.0;
1760     zpos      = fgkVrocsm + fgkSMpltT + kCOLhgt/2.0 - fgkSheight/2.0 + kCOLposz
1761               + ilayer * (fgkCH + fgkVspace);
1762     parCOL[0] = kCOLwid   /2.0;
1763     parCOL[1] = fgkFlength/2.0;
1764     parCOL[2] = kCOLhgt   /2.0;
1765     gMC->Gsposp("UTC3",ilayer+2*kNlayer,"UTF1", xpos,ypos,zpos
1766                       ,matrix[0],"ONLY",parCOL,kNparCOL);
1767     gMC->Gsposp("UTC3",ilayer+3*kNlayer,"UTF1",-xpos,ypos,zpos
1768                       ,matrix[1],"ONLY",parCOL,kNparCOL);
1769     gMC->Gsposp("UTC3",ilayer+4*kNlayer,"UTF2", xpos,ypos,zpos
1770                       ,matrix[0],"ONLY",parCOL,kNparCOL);
1771     gMC->Gsposp("UTC3",ilayer+5*kNlayer,"UTF2",-xpos,ypos,zpos
1772                       ,matrix[1],"ONLY",parCOL,kNparCOL);
1773
1774   }
1775
1776   for (ilayer = 1; ilayer < kNlayer; ilayer++) {
1777
1778     // In baby frame
1779     xpos      = fCwidth[ilayer]/2.0 + kCOLwid/2.0 - 1.04;
1780     ypos      = kBBSdz/2.0 - kBBMdz/2.0;
1781     zpos      = fgkVrocsm + fgkSMpltT + kCOLhgt/2.0 - fgkSheight/2.0 + kCOLposz
1782               + ilayer * (fgkCH + fgkVspace);
1783     parCOL[0] = kCOLwid/2.0;
1784     parCOL[1] = kBBSdz /2.0;
1785     parCOL[2] = kCOLhgt/2.0;
1786     gMC->Gsposp("UTC3",ilayer+6*kNlayer,"BBTRD", xpos, ypos, zpos
1787                       ,matrix[0],"ONLY",parCOL,kNparCOL);
1788     gMC->Gsposp("UTC3",ilayer+7*kNlayer,"BBTRD",-xpos, ypos, zpos
1789                       ,matrix[1],"ONLY",parCOL,kNparCOL);
1790
1791   }
1792
1793   for (ilayer = 1; ilayer < kNlayer; ilayer++) {
1794
1795     // In back frame
1796     xpos      = fCwidth[ilayer]/2.0 + kCOLwid/2.0 + kCOLposx;
1797     ypos      = -kBFSdz/2.0 + kBFMdz/2.0;
1798     zpos      = fgkVrocsm + fgkSMpltT + kCOLhgt/2.0 - fgkSheight/2.0 + kCOLposz
1799               + ilayer * (fgkCH + fgkVspace);
1800     parCOL[0] = kCOLwid/2.0;
1801     parCOL[1] = kBFSdz /2.0;
1802     parCOL[2] = kCOLhgt/2.0;
1803     gMC->Gsposp("UTC3",ilayer+6*kNlayer,"BFTRD", xpos,ypos,zpos
1804                       ,matrix[0],"ONLY",parCOL,kNparCOL);
1805     gMC->Gsposp("UTC3",ilayer+7*kNlayer,"BFTRD",-xpos,ypos,zpos
1806                       ,matrix[1],"ONLY",parCOL,kNparCOL);
1807
1808   }
1809
1810   // The upper most layer (reaching into TOF acceptance)
1811   // Along the chambers
1812   xpos      = fCwidth[5]/2.0 - kCOLhgt/2.0 - 1.3;
1813   ypos      = 0.0;
1814   zpos      = fgkSheight/2.0 - fgkSMpltT - 0.4 - kCOLwid/2.0;
1815   parCOL[0] = kCOLwid   /2.0;
1816   parCOL[1] = fgkSlength/2.0;
1817   parCOL[2] = kCOLhgt   /2.0;
1818   gMC->Gsposp("UTC1",6          ,"UTI1", xpos,ypos,zpos
1819                     ,matrix[3],"ONLY",parCOL,kNparCOL);
1820   gMC->Gsposp("UTC1",6+  kNlayer,"UTI1",-xpos,ypos,zpos
1821                     ,matrix[3],"ONLY",parCOL,kNparCOL);
1822   gMC->Gsposp("UTC1",6+6*kNlayer,"UTI2", xpos,ypos,zpos
1823                     ,matrix[3],"ONLY",parCOL,kNparCOL);
1824   gMC->Gsposp("UTC1",6+7*kNlayer,"UTI2",-xpos,ypos,zpos
1825                     ,matrix[3],"ONLY",parCOL,kNparCOL);
1826   gMC->Gsposp("UTC1",6+8*kNlayer,"UTI3", xpos,ypos,zpos
1827                     ,matrix[3],"ONLY",parCOL,kNparCOL);
1828   gMC->Gsposp("UTC1",6+9*kNlayer,"UTI3",-xpos,ypos,zpos
1829                     ,matrix[3],"ONLY",parCOL,kNparCOL);
1830   // Front of supermodules
1831   xpos      = fCwidth[5]/2.0 - kCOLhgt/2.0 - 1.3;
1832   ypos      = 0.0;
1833   zpos      = fgkSheight/2.0 - fgkSMpltT - 0.4 - kCOLwid/2.0;
1834   parCOL[0] = kCOLwid   /2.0;
1835   parCOL[1] = fgkFlength/2.0;
1836   parCOL[2] = kCOLhgt   /2.0;
1837   gMC->Gsposp("UTC3",6+2*kNlayer,"UTF1", xpos,ypos,zpos
1838                     ,matrix[3],"ONLY",parCOL,kNparCOL);
1839   gMC->Gsposp("UTC3",6+3*kNlayer,"UTF1",-xpos,ypos,zpos
1840                     ,matrix[3],"ONLY",parCOL,kNparCOL);
1841   gMC->Gsposp("UTC3",6+4*kNlayer,"UTF2", xpos,ypos,zpos
1842                     ,matrix[3],"ONLY",parCOL,kNparCOL);
1843   gMC->Gsposp("UTC3",6+5*kNlayer,"UTF2",-xpos,ypos,zpos
1844                     ,matrix[3],"ONLY",parCOL,kNparCOL);
1845   // In baby frame
1846   xpos      = fCwidth[5]/2.0 - kCOLhgt/2.0 - 3.1;
1847   ypos      = kBBSdz/2.0 - kBBMdz/2.0;
1848   zpos      = fgkSheight/2.0 - fgkSMpltT - 0.4 - kCOLwid/2.0;
1849   parCOL[0] = kCOLwid/2.0;
1850   parCOL[1] = kBBSdz /2.0;
1851   parCOL[2] = kCOLhgt/2.0;
1852   gMC->Gsposp("UTC3",6+6*kNlayer,"BBTRD", xpos, ypos, zpos
1853                     ,matrix[3],"ONLY",parCOL,kNparCOL);
1854   gMC->Gsposp("UTC3",6+7*kNlayer,"BBTRD",-xpos, ypos, zpos
1855                     ,matrix[3],"ONLY",parCOL,kNparCOL);
1856   // In back frame
1857   xpos      = fCwidth[5]/2.0 - kCOLhgt/2.0 - 1.3;
1858   ypos      = -kBFSdz/2.0 + kBFMdz/2.0;
1859   zpos      = fgkSheight/2.0 - fgkSMpltT - 0.4 - kCOLwid/2.0;
1860   parCOL[0] = kCOLwid/2.0;
1861   parCOL[1] = kBFSdz /2.0;
1862   parCOL[2] = kCOLhgt/2.0;
1863   gMC->Gsposp("UTC3",6+6*kNlayer,"BFTRD", xpos,ypos,zpos
1864                     ,matrix[3],"ONLY",parCOL,kNparCOL);
1865   gMC->Gsposp("UTC3",6+7*kNlayer,"BFTRD",-xpos,ypos,zpos
1866                     ,matrix[3],"ONLY",parCOL,kNparCOL);
1867
1868   //
1869   // The power bars
1870   //
1871
1872   const Float_t kPWRwid  =  0.6;
1873   const Float_t kPWRhgt  =  5.0;
1874   const Float_t kPWRposx =  1.4;
1875   const Float_t kPWRposz =  1.9;
1876   const Int_t   kNparPWR =  3;
1877   Float_t parPWR[kNparPWR];
1878   parPWR[0] = 0.0;
1879   parPWR[1] = 0.0;
1880   parPWR[2] = 0.0;
1881   gMC->Gsvolu("UTP1","BOX ",idtmed[1325-1],parPWR,0);
1882   gMC->Gsvolu("UTP3","BOX ",idtmed[1325-1],parPWR,0);
1883
1884   for (ilayer = 1; ilayer < kNlayer; ilayer++) {
1885
1886     // Along the chambers
1887     xpos      = fCwidth[ilayer]/2.0 + kPWRwid/2.0 + kPWRposx;
1888     ypos      = 0.0;
1889     zpos      = fgkVrocsm + fgkSMpltT + kPWRhgt/2.0 - fgkSheight/2.0 + kPWRposz
1890               + ilayer * (fgkCH + fgkVspace);
1891     parPWR[0] = kPWRwid   /2.0;
1892     parPWR[1] = fgkSlength/2.0;
1893     parPWR[2] = kPWRhgt   /2.0;
1894     gMC->Gsposp("UTP1",ilayer          ,"UTI1", xpos,ypos,zpos
1895                       ,matrix[0],"ONLY",parPWR,kNparPWR);
1896     gMC->Gsposp("UTP1",ilayer+  kNlayer,"UTI1",-xpos,ypos,zpos
1897                       ,matrix[1],"ONLY",parPWR,kNparPWR);
1898     gMC->Gsposp("UTP1",ilayer+6*kNlayer,"UTI2", xpos,ypos,zpos
1899                       ,matrix[0],"ONLY",parPWR,kNparPWR);
1900     gMC->Gsposp("UTP1",ilayer+7*kNlayer,"UTI2",-xpos,ypos,zpos
1901                       ,matrix[1],"ONLY",parPWR,kNparPWR);
1902     gMC->Gsposp("UTP1",ilayer+8*kNlayer,"UTI3", xpos,ypos,zpos
1903                       ,matrix[0],"ONLY",parPWR,kNparPWR);
1904     gMC->Gsposp("UTP1",ilayer+9*kNlayer,"UTI3",-xpos,ypos,zpos
1905                       ,matrix[1],"ONLY",parPWR,kNparPWR);
1906
1907     // Front of supermodule
1908     xpos      = fCwidth[ilayer]/2.0 + kPWRwid/2.0 + kPWRposx;
1909     ypos      = 0.0;
1910     zpos      = fgkVrocsm + fgkSMpltT + kPWRhgt/2.0 - fgkSheight/2.0 + kPWRposz
1911               + ilayer * (fgkCH + fgkVspace);
1912     parPWR[0] = kPWRwid   /2.0;
1913     parPWR[1] = fgkFlength/2.0;
1914     parPWR[2] = kPWRhgt   /2.0;
1915     gMC->Gsposp("UTP3",ilayer+2*kNlayer,"UTF1", xpos,ypos,zpos
1916                       ,matrix[0],"ONLY",parPWR,kNparPWR);
1917     gMC->Gsposp("UTP3",ilayer+3*kNlayer,"UTF1",-xpos,ypos,zpos
1918                       ,matrix[1],"ONLY",parPWR,kNparPWR);
1919     gMC->Gsposp("UTP3",ilayer+4*kNlayer,"UTF2", xpos,ypos,zpos
1920                       ,matrix[0],"ONLY",parPWR,kNparPWR);
1921     gMC->Gsposp("UTP3",ilayer+5*kNlayer,"UTF2",-xpos,ypos,zpos
1922                       ,matrix[1],"ONLY",parPWR,kNparPWR);
1923
1924   }
1925
1926   for (ilayer = 1; ilayer < kNlayer; ilayer++) {
1927
1928     // In baby frame
1929     xpos      = fCwidth[ilayer]/2.0 + kPWRwid/2.0;
1930     ypos      = kBBSdz/2.0 - kBBMdz/2.0;
1931     zpos      = fgkVrocsm + fgkSMpltT + kPWRhgt/2.0 - fgkSheight/2.0 + kPWRposz
1932               + ilayer * (fgkCH + fgkVspace);
1933     parPWR[0] = kPWRwid/2.0;
1934     parPWR[1] = kBBSdz /2.0;
1935     parPWR[2] = kPWRhgt/2.0;
1936     gMC->Gsposp("UTP3",ilayer+6*kNlayer,"BBTRD", xpos, ypos, zpos
1937                       ,matrix[0],"ONLY",parPWR,kNparPWR);
1938     gMC->Gsposp("UTP3",ilayer+7*kNlayer,"BBTRD",-xpos, ypos, zpos
1939                       ,matrix[1],"ONLY",parPWR,kNparPWR);
1940
1941   }
1942
1943   for (ilayer = 1; ilayer < kNlayer; ilayer++) {
1944
1945     // In back frame
1946     xpos      = fCwidth[ilayer]/2.0 + kPWRwid/2.0 + kPWRposx;
1947     ypos      = -kBFSdz/2.0 + kBFMdz/2.0;
1948     zpos      = fgkVrocsm + fgkSMpltT + kPWRhgt/2.0 - fgkSheight/2.0 + kPWRposz
1949               + ilayer * (fgkCH + fgkVspace);
1950     parPWR[0] = kPWRwid/2.0;
1951     parPWR[1] = kBFSdz /2.0;
1952     parPWR[2] = kPWRhgt/2.0;
1953     gMC->Gsposp("UTP3",ilayer+8*kNlayer,"BFTRD", xpos,ypos,zpos
1954                       ,matrix[0],"ONLY",parPWR,kNparPWR);
1955     gMC->Gsposp("UTP3",ilayer+9*kNlayer,"BFTRD",-xpos,ypos,zpos
1956                       ,matrix[1],"ONLY",parPWR,kNparPWR);
1957
1958   }
1959
1960   // The upper most layer
1961   // Along the chambers
1962   xpos      = fCwidth[5]/2.0 + kPWRhgt/2.0 - 1.3;
1963   ypos      = 0.0;
1964   zpos      = fgkSheight/2.0 - fgkSMpltT - 0.6 - kPWRwid/2.0;
1965   parPWR[0] = kPWRwid   /2.0;
1966   parPWR[1] = fgkSlength/2.0;
1967   parPWR[2] = kPWRhgt   /2.0;
1968   gMC->Gsposp("UTP1",6          ,"UTI1", xpos,ypos,zpos
1969                     ,matrix[3],"ONLY",parPWR,kNparPWR);
1970   gMC->Gsposp("UTP1",6+  kNlayer,"UTI1",-xpos,ypos,zpos
1971                     ,matrix[3],"ONLY",parPWR,kNparPWR);
1972   gMC->Gsposp("UTP1",6+6*kNlayer,"UTI2", xpos,ypos,zpos
1973                     ,matrix[3],"ONLY",parPWR,kNparPWR);
1974   gMC->Gsposp("UTP1",6+7*kNlayer,"UTI2",-xpos,ypos,zpos
1975                     ,matrix[3],"ONLY",parPWR,kNparPWR);
1976   gMC->Gsposp("UTP1",6+8*kNlayer,"UTI3", xpos,ypos,zpos
1977                     ,matrix[3],"ONLY",parPWR,kNparPWR);
1978   gMC->Gsposp("UTP1",6+9*kNlayer,"UTI3",-xpos,ypos,zpos
1979                     ,matrix[3],"ONLY",parPWR,kNparPWR);
1980   // Front of supermodules
1981   xpos      = fCwidth[5]/2.0 + kPWRhgt/2.0 - 1.3;
1982   ypos      = 0.0;
1983   zpos      = fgkSheight/2.0 - fgkSMpltT - 0.6 - kPWRwid/2.0;
1984   parPWR[0] = kPWRwid   /2.0;
1985   parPWR[1] = fgkFlength/2.0;
1986   parPWR[2] = kPWRhgt   /2.0;
1987   gMC->Gsposp("UTP3",6+2*kNlayer,"UTF1", xpos,ypos,zpos
1988                     ,matrix[3],"ONLY",parPWR,kNparPWR);
1989   gMC->Gsposp("UTP3",6+3*kNlayer,"UTF1",-xpos,ypos,zpos
1990                     ,matrix[3],"ONLY",parPWR,kNparPWR);
1991   gMC->Gsposp("UTP3",6+4*kNlayer,"UTF2", xpos,ypos,zpos
1992                     ,matrix[3],"ONLY",parPWR,kNparPWR);
1993   gMC->Gsposp("UTP3",6+5*kNlayer,"UTF2",-xpos,ypos,zpos
1994                     ,matrix[3],"ONLY",parPWR,kNparPWR);
1995   // In baby frame
1996   xpos      = fCwidth[5]/2.0 + kPWRhgt/2.0 - 3.0;
1997   ypos      = kBBSdz/2.0 - kBBMdz/2.0;
1998   zpos      = fgkSheight/2.0 - fgkSMpltT - 0.6 - kPWRwid/2.0;
1999   parPWR[0] = kPWRwid/2.0;
2000   parPWR[1] = kBBSdz /2.0;
2001   parPWR[2] = kPWRhgt/2.0;
2002   gMC->Gsposp("UTP3",6+6*kNlayer,"BBTRD", xpos, ypos, zpos
2003                     ,matrix[3],"ONLY",parPWR,kNparPWR);
2004   gMC->Gsposp("UTP3",6+7*kNlayer,"BBTRD",-xpos, ypos, zpos
2005                     ,matrix[3],"ONLY",parPWR,kNparPWR);
2006   // In back frame
2007   xpos      = fCwidth[5]/2.0 + kPWRhgt/2.0 - 1.3;
2008   ypos      = -kBFSdz/2.0 + kBFMdz/2.0;
2009   zpos      = fgkSheight/2.0 - fgkSMpltT - 0.6 - kPWRwid/2.0;
2010   parPWR[0] = kPWRwid/2.0;
2011   parPWR[1] = kBFSdz /2.0;
2012   parPWR[2] = kPWRhgt/2.0;
2013   gMC->Gsposp("UTP3",6+8*kNlayer,"BFTRD", xpos,ypos,zpos
2014                     ,matrix[3],"ONLY",parPWR,kNparPWR);
2015   gMC->Gsposp("UTP3",6+9*kNlayer,"BFTRD",-xpos,ypos,zpos
2016                     ,matrix[3],"ONLY",parPWR,kNparPWR);
2017
2018   //
2019   // The gas tubes connecting the chambers in the super modules with holes
2020   // Material: Stainless steel
2021   //
2022
2023   parTube[0] = 0.0;
2024   parTube[1] = 2.2/2.0;
2025   parTube[2] = fClength[5][2]/2.0 - fgkHspace/2.0;
2026   gMC->Gsvolu("UTG1","TUBE",idtmed[1308-1],parTube,kNparTube);
2027   parTube[0] = 0.0;
2028   parTube[1] = 2.1/2.0;
2029   parTube[2] = fClength[5][2]/2.0 - fgkHspace/2.0;
2030   gMC->Gsvolu("UTG2","TUBE",idtmed[1309-1],parTube,kNparTube);
2031   xpos  = 0.0;
2032   ypos  = 0.0;
2033   zpos  = 0.0;
2034   gMC->Gspos("UTG2",1,"UTG1",xpos,ypos,zpos,0,"ONLY");
2035   for (ilayer = 0; ilayer < kNlayer; ilayer++) {
2036     xpos      = fCwidth[ilayer]/2.0 + kCOLwid/2.0 - 1.5;
2037     ypos      = 0.0;
2038     zpos      = fgkVrocsm + fgkSMpltT + kCOLhgt/2.0 - fgkSheight/2.0 + 5.0
2039               + ilayer * (fgkCH + fgkVspace);
2040     gMC->Gspos("UTG1",1+ilayer,"UTI3", xpos, ypos, zpos,matrix[4],"ONLY");
2041     gMC->Gspos("UTG1",7+ilayer,"UTI3",-xpos, ypos, zpos,matrix[4],"ONLY");
2042   }
2043
2044   //
2045   // The volumes for the services at the chambers
2046   //
2047
2048   const Int_t kNparServ = 3;
2049   Float_t parServ[kNparServ];
2050
2051   for (istack = 0; istack < kNstack; istack++) {
2052     for (ilayer = 0; ilayer < kNlayer; ilayer++) {
2053
2054       Int_t iDet = GetDetectorSec(ilayer,istack);
2055
2056       sprintf(cTagV,"UU%02d",iDet);
2057       parServ[0] = fCwidth[ilayer]         /2.0;
2058       parServ[1] = fClength[ilayer][istack]/2.0 - fgkHspace/2.0;
2059       parServ[2] = fgkVspace               /2.0 - 0.742/2.0;
2060       fChamberUUboxd[iDet][0] = parServ[0];
2061       fChamberUUboxd[iDet][1] = parServ[1];
2062       fChamberUUboxd[iDet][2] = parServ[2];
2063       gMC->Gsvolu(cTagV,"BOX",idtmed[1302-1],parServ,kNparServ);
2064
2065       xpos  = 0.0;
2066       ypos  = fClength[ilayer][0] + fClength[ilayer][1] + fClength[ilayer][2]/2.0;
2067       for (Int_t ic = 0; ic < istack; ic++) {
2068         ypos -= fClength[ilayer][ic];
2069       }
2070       ypos -= fClength[ilayer][istack]/2.0;
2071       zpos  = fgkVrocsm + fgkSMpltT + fgkCH + fgkVspace/2.0 - fgkSheight/2.0
2072             + ilayer * (fgkCH + fgkVspace);
2073       zpos -= 0.742/2.0;
2074       fChamberUUorig[iDet][0] = xpos;
2075       fChamberUUorig[iDet][1] = ypos;
2076       fChamberUUorig[iDet][2] = zpos;
2077
2078     }
2079   }
2080
2081   //
2082   // The cooling pipes inside the service volumes
2083   //
2084
2085   // The cooling pipes
2086   parTube[0] =  0.0;
2087   parTube[1] =  0.0;
2088   parTube[2] =  0.0;
2089   gMC->Gsvolu("UTCP","TUBE",idtmed[1324-1],parTube,0);
2090   // The cooling water
2091   parTube[0] =  0.0;
2092   parTube[1] =  0.2/2.0;
2093   parTube[2] = -1.0;
2094   gMC->Gsvolu("UTCH","TUBE",idtmed[1314-1],parTube,kNparTube);
2095   // Water inside the cooling pipe
2096   xpos = 0.0;
2097   ypos = 0.0;
2098   zpos = 0.0;
2099   gMC->Gspos("UTCH",1,"UTCP",xpos,ypos,zpos,0,"ONLY");
2100
2101   // Position the cooling pipes in the mother volume
2102   for (istack = 0; istack < kNstack; istack++) {
2103     for (ilayer = 0; ilayer < kNlayer; ilayer++) {
2104       Int_t   iDet    = GetDetectorSec(ilayer,istack);
2105       Int_t   iCopy   = GetDetector(ilayer,istack,0) * 100;
2106       Int_t   nMCMrow = GetRowMax(ilayer,istack,0);
2107       Float_t ySize   = (GetChamberLength(ilayer,istack) - 2.0*fgkRpadW)
2108                       / ((Float_t) nMCMrow);
2109       sprintf(cTagV,"UU%02d",iDet);
2110       for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
2111         xpos   = 0.0;
2112         ypos   = (0.5 + iMCMrow) * ySize - 1.9
2113                - fClength[ilayer][istack]/2.0 + fgkHspace/2.0;
2114         zpos   = 0.0 + 0.742/2.0;
2115         // The cooling pipes
2116         parTube[0] = 0.0;
2117         parTube[1] = 0.3/2.0; // Thickness of the cooling pipes
2118         parTube[2] = fCwidth[ilayer]/2.0;
2119         gMC->Gsposp("UTCP",iCopy+iMCMrow,cTagV,xpos,ypos,zpos
2120                           ,matrix[2],"ONLY",parTube,kNparTube);
2121       }
2122     }
2123   }
2124
2125   //
2126   // The power lines
2127   //
2128
2129   // The copper power lines
2130   parTube[0] = 0.0;
2131   parTube[1] = 0.0;
2132   parTube[2] = 0.0;
2133   gMC->Gsvolu("UTPL","TUBE",idtmed[1305-1],parTube,0);
2134
2135   // Position the power lines in the mother volume
2136   for (istack = 0; istack < kNstack; istack++) {
2137     for (ilayer = 0; ilayer < kNlayer; ilayer++) {
2138       Int_t   iDet    = GetDetectorSec(ilayer,istack);
2139       Int_t   iCopy   = GetDetector(ilayer,istack,0) * 100;
2140       Int_t   nMCMrow = GetRowMax(ilayer,istack,0);
2141       Float_t ySize   = (GetChamberLength(ilayer,istack) - 2.0*fgkRpadW)
2142                       / ((Float_t) nMCMrow);
2143       sprintf(cTagV,"UU%02d",iDet);
2144       for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
2145         xpos       = 0.0;
2146         ypos       = (0.5 + iMCMrow) * ySize - 1.0
2147                    - fClength[ilayer][istack]/2.0 + fgkHspace/2.0;
2148         zpos       = -0.4 + 0.742/2.0;
2149         parTube[0] = 0.0;
2150         parTube[1] = 0.2/2.0; // Thickness of the power lines
2151         parTube[2] = fCwidth[ilayer]/2.0;
2152         gMC->Gsposp("UTPL",iCopy+iMCMrow,cTagV,xpos,ypos,zpos
2153                           ,matrix[2],"ONLY",parTube,kNparTube);
2154       }
2155     }
2156   }
2157
2158   //
2159   // The MCMs
2160   //
2161
2162   const Float_t kMCMx    = 3.0;
2163   const Float_t kMCMy    = 3.0;
2164   const Float_t kMCMz    = 0.3;
2165
2166   const Float_t kMCMpcTh = 0.1;
2167   const Float_t kMCMcuTh = 0.0025;
2168   const Float_t kMCMsiTh = 0.03;
2169   const Float_t kMCMcoTh = 0.04;
2170
2171   // The mother volume for the MCMs (air)
2172   const Int_t kNparMCM = 3;
2173   Float_t parMCM[kNparMCM];
2174   parMCM[0] = kMCMx   /2.0;
2175   parMCM[1] = kMCMy   /2.0;
2176   parMCM[2] = kMCMz   /2.0;
2177   gMC->Gsvolu("UMCM","BOX",idtmed[1302-1],parMCM,kNparMCM);
2178
2179   // The MCM carrier G10 layer
2180   parMCM[0] = kMCMx   /2.0;
2181   parMCM[1] = kMCMy   /2.0;
2182   parMCM[2] = kMCMpcTh/2.0;
2183   gMC->Gsvolu("UMC1","BOX",idtmed[1319-1],parMCM,kNparMCM);
2184   // The MCM carrier Cu layer
2185   parMCM[0] = kMCMx   /2.0;
2186   parMCM[1] = kMCMy   /2.0;
2187   parMCM[2] = kMCMcuTh/2.0;
2188   gMC->Gsvolu("UMC2","BOX",idtmed[1318-1],parMCM,kNparMCM);
2189   // The silicon of the chips
2190   parMCM[0] = kMCMx   /2.0;
2191   parMCM[1] = kMCMy   /2.0;
2192   parMCM[2] = kMCMsiTh/2.0;
2193   gMC->Gsvolu("UMC3","BOX",idtmed[1320-1],parMCM,kNparMCM);
2194   // The aluminum of the cooling plates
2195   parMCM[0] = kMCMx   /2.0;
2196   parMCM[1] = kMCMy   /2.0;
2197   parMCM[2] = kMCMcoTh/2.0;
2198   gMC->Gsvolu("UMC4","BOX",idtmed[1324-1],parMCM,kNparMCM);
2199
2200   // Put the MCM material inside the MCM mother volume
2201   xpos  =  0.0;
2202   ypos  =  0.0;
2203   zpos  = -kMCMz   /2.0 + kMCMpcTh/2.0;
2204   gMC->Gspos("UMC1",1,"UMCM",xpos,ypos,zpos,0,"ONLY");
2205   zpos +=  kMCMpcTh/2.0 + kMCMcuTh/2.0;
2206   gMC->Gspos("UMC2",1,"UMCM",xpos,ypos,zpos,0,"ONLY");
2207   zpos +=  kMCMcuTh/2.0 + kMCMsiTh/2.0;
2208   gMC->Gspos("UMC3",1,"UMCM",xpos,ypos,zpos,0,"ONLY");
2209   zpos +=  kMCMsiTh/2.0 + kMCMcoTh/2.0;
2210   gMC->Gspos("UMC4",1,"UMCM",xpos,ypos,zpos,0,"ONLY");
2211
2212   // Position the MCMs in the mother volume
2213   for (istack = 0; istack < kNstack; istack++) {
2214     for (ilayer = 0; ilayer < kNlayer; ilayer++) {
2215       Int_t   iDet    = GetDetectorSec(ilayer,istack);
2216       Int_t   iCopy   = GetDetector(ilayer,istack,0) * 1000;
2217       Int_t   nMCMrow = GetRowMax(ilayer,istack,0);
2218       Float_t ySize   = (GetChamberLength(ilayer,istack) - 2.0*fgkRpadW)
2219                       / ((Float_t) nMCMrow);
2220       Int_t   nMCMcol = 8;
2221       Float_t xSize   = (GetChamberWidth(ilayer)         - 2.0*fgkCpadW)
2222                       / ((Float_t) nMCMcol + 6);             // Introduce 6 gaps
2223       Int_t   iMCM[8] = {  1,  2,  3,  5,  8,  9, 10, 12 };  // 0..7 MCM + 6 gap structure
2224       sprintf(cTagV,"UU%02d",iDet);
2225       for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
2226         for (Int_t iMCMcol = 0; iMCMcol < nMCMcol; iMCMcol++) {
2227           xpos      = (0.5 + iMCM[iMCMcol]) * xSize + 1.0
2228                     - fCwidth[ilayer]/2.0;
2229           ypos      = (0.5 + iMCMrow) * ySize + 1.0
2230                     - fClength[ilayer][istack]/2.0 + fgkHspace/2.0;
2231           zpos      = -0.4 + 0.742/2.0;
2232           gMC->Gspos("UMCM",iCopy+iMCMrow*10+iMCMcol,cTagV
2233                            ,xpos,ypos,zpos,0,"ONLY");
2234         }
2235       }
2236
2237     }
2238   }
2239
2240   //
2241   // Services in front of the super module
2242   //
2243
2244   // Gas in-/outlet pipes (INOX)
2245   parTube[0] = 0.0;
2246   parTube[1] = 0.0;
2247   parTube[2] = 0.0;
2248   gMC->Gsvolu("UTG3","TUBE",idtmed[1308-1],parTube,0);
2249   // The gas inside the in-/outlet pipes (Xe)
2250   parTube[0] =  0.0;
2251   parTube[1] =  1.2/2.0;
2252   parTube[2] = -1.0;
2253   gMC->Gsvolu("UTG4","TUBE",idtmed[1309-1],parTube,kNparTube);
2254   xpos = 0.0;
2255   ypos = 0.0;
2256   zpos = 0.0;
2257   gMC->Gspos("UTG4",1,"UTG3",xpos,ypos,zpos,0,"ONLY");
2258   for (ilayer = 0; ilayer < kNlayer-1; ilayer++) {
2259     xpos       = 0.0;
2260     ypos       = fClength[ilayer][2]/2.0
2261                + fClength[ilayer][1]
2262                + fClength[ilayer][0];
2263     zpos       = 9.0 - fgkSheight/2.0
2264                + ilayer * (fgkCH + fgkVspace);
2265     parTube[0] = 0.0;
2266     parTube[1] = 1.5/2.0;
2267     parTube[2] = fCwidth[ilayer]/2.0 - 2.5;
2268     gMC->Gsposp("UTG3",ilayer+1          ,"UTI1", xpos, ypos, zpos
2269                       ,matrix[2],"ONLY",parTube,kNparTube);
2270     gMC->Gsposp("UTG3",ilayer+1+1*kNlayer,"UTI1", xpos,-ypos, zpos
2271                       ,matrix[2],"ONLY",parTube,kNparTube);
2272     gMC->Gsposp("UTG3",ilayer+1+2*kNlayer,"UTI2", xpos, ypos, zpos
2273                       ,matrix[2],"ONLY",parTube,kNparTube);
2274     gMC->Gsposp("UTG3",ilayer+1+3*kNlayer,"UTI2", xpos,-ypos, zpos
2275                       ,matrix[2],"ONLY",parTube,kNparTube);
2276     gMC->Gsposp("UTG3",ilayer+1+4*kNlayer,"UTI3", xpos, ypos, zpos
2277                       ,matrix[2],"ONLY",parTube,kNparTube);
2278     gMC->Gsposp("UTG3",ilayer+1+5*kNlayer,"UTI3", xpos,-ypos, zpos
2279                       ,matrix[2],"ONLY",parTube,kNparTube);
2280   }
2281
2282   // Gas distribution box
2283   parBox[0] = 14.50/2.0;
2284   parBox[1] =  4.52/2.0;
2285   parBox[2] =  5.00/2.0;
2286   gMC->Gsvolu("UTGD","BOX ",idtmed[1308-1],parBox,kNparBox);
2287   parBox[0] = 14.50/2.0;
2288   parBox[1] =  4.00/2.0;
2289   parBox[2] =  4.40/2.0;
2290   gMC->Gsvolu("UTGI","BOX ",idtmed[1309-1],parBox,kNparBox);
2291   parTube[0] = 0.0;
2292   parTube[1] = 4.0/2.0;
2293   parTube[2] = 8.0/2.0;
2294   gMC->Gsvolu("UTGT","TUBE",idtmed[1308-1],parTube,kNparTube);
2295   parTube[0] = 0.0;
2296   parTube[1] = 3.4/2.0;
2297   parTube[2] = 8.0/2.0;
2298   gMC->Gsvolu("UTGG","TUBE",idtmed[1309-1],parTube,kNparTube);
2299   xpos = 0.0;
2300   ypos = 0.0;
2301   zpos = 0.0;
2302   gMC->Gspos("UTGI",1,"UTGD",xpos,ypos,zpos,        0,"ONLY");
2303   gMC->Gspos("UTGG",1,"UTGT",xpos,ypos,zpos,        0,"ONLY");
2304   xpos = 0.0;
2305   ypos = 0.0;
2306   zpos = 0.0;
2307   gMC->Gspos("UTGD",1,"UTF1",xpos,ypos,zpos,        0,"ONLY");
2308   xpos =  -3.0;
2309   ypos =   0.0;
2310   zpos =   6.5;
2311   gMC->Gspos("UTGT",1,"UTF1",xpos,ypos,zpos,        0,"ONLY");
2312   xpos = -11.25;
2313   ypos =   0.0;
2314   zpos =   0.5;
2315   gMC->Gspos("UTGT",3,"UTF1",xpos,ypos,zpos,matrix[2],"ONLY");
2316   xpos =  11.25;
2317   ypos =   0.0;
2318   zpos =   0.5;
2319   gMC->Gspos("UTGT",5,"UTF1",xpos,ypos,zpos,matrix[2],"ONLY");
2320
2321   // Cooling manifolds
2322   parBox[0]  =  5.0/2.0;
2323   parBox[1]  = 23.0/2.0;
2324   parBox[2]  = 70.0/2.0;
2325   gMC->Gsvolu("UTCM","BOX ",idtmed[1302-1],parBox,kNparBox);
2326   parBox[0]  =  5.0/2.0;
2327   parBox[1]  =  5.0/2.0;
2328   parBox[2]  = 70.0/2.0;
2329   gMC->Gsvolu("UTCA","BOX ",idtmed[1308-1],parBox,kNparBox);
2330   parBox[0]  =  5.0/2.0 - 0.3;
2331   parBox[1]  =  5.0/2.0 - 0.3;
2332   parBox[2]  = 70.0/2.0 - 0.3;
2333   gMC->Gsvolu("UTCW","BOX ",idtmed[1314-1],parBox,kNparBox);
2334   xpos       =  0.0;
2335   ypos       =  0.0;
2336   zpos       =  0.0;
2337   gMC->Gspos("UTCW",1,"UTCA", xpos, ypos, zpos,        0,"ONLY");
2338   xpos       =  0.0;
2339   ypos       =  5.0/2.0 - 23.0/2.0;
2340   zpos       =  0.0;
2341   gMC->Gspos("UTCA",1,"UTCM", xpos, ypos, zpos,        0,"ONLY");
2342   parTube[0] =  0.0;
2343   parTube[1] =  3.0/2.0;
2344   parTube[2] = 18.0/2.0;
2345   gMC->Gsvolu("UTCO","TUBE",idtmed[1308-1],parTube,kNparTube);
2346   parTube[0] =  0.0;
2347   parTube[1] =  3.0/2.0 - 0.3;
2348   parTube[2] = 18.0/2.0;
2349   gMC->Gsvolu("UTCL","TUBE",idtmed[1314-1],parTube,kNparTube);
2350   xpos       =  0.0;
2351   ypos       =  0.0;
2352   zpos       =  0.0;
2353   gMC->Gspos("UTCL",1,"UTCO", xpos, ypos, zpos,        0,"ONLY");
2354   xpos       =  0.0;
2355   ypos       =  2.5;
2356   zpos       = -70.0/2.0 + 7.0;
2357   gMC->Gspos("UTCO",1,"UTCM", xpos, ypos, zpos,matrix[4],"ONLY");
2358   zpos      +=  7.0;
2359   gMC->Gspos("UTCO",2,"UTCM", xpos, ypos, zpos,matrix[4],"ONLY");
2360   zpos      +=  7.0;
2361   gMC->Gspos("UTCO",3,"UTCM", xpos, ypos, zpos,matrix[4],"ONLY");
2362   zpos      +=  7.0;
2363   gMC->Gspos("UTCO",4,"UTCM", xpos, ypos, zpos,matrix[4],"ONLY");
2364   zpos      +=  7.0;
2365   gMC->Gspos("UTCO",5,"UTCM", xpos, ypos, zpos,matrix[4],"ONLY");
2366   zpos      +=  7.0;
2367   gMC->Gspos("UTCO",6,"UTCM", xpos, ypos, zpos,matrix[4],"ONLY");
2368   zpos      +=  7.0;
2369   gMC->Gspos("UTCO",7,"UTCM", xpos, ypos, zpos,matrix[4],"ONLY");
2370   zpos      +=  7.0;
2371   gMC->Gspos("UTCO",8,"UTCM", xpos, ypos, zpos,matrix[4],"ONLY");
2372
2373   xpos = 40.0;
2374   ypos =  fgkFlength/2.0 - 23.0/2.0;
2375   zpos =  0.0;
2376   gMC->Gspos("UTCM",1,"UTF1", xpos, ypos, zpos,matrix[0],"ONLY");
2377   gMC->Gspos("UTCM",2,"UTF1",-xpos, ypos, zpos,matrix[1],"ONLY");
2378   gMC->Gspos("UTCM",3,"UTF2", xpos,-ypos, zpos,matrix[5],"ONLY");
2379   gMC->Gspos("UTCM",4,"UTF2",-xpos,-ypos, zpos,matrix[6],"ONLY");
2380
2381   // Power connection boards (Cu)
2382   parBox[0] =  0.5/2.0;
2383   parBox[1] = 15.0/2.0;
2384   parBox[2] =  7.0/2.0;
2385   gMC->Gsvolu("UTPC","BOX ",idtmed[1325-1],parBox,kNparBox);
2386   for (ilayer = 0; ilayer < kNlayer-1; ilayer++) {
2387     xpos      = fCwidth[ilayer]/2.0 + kPWRwid/2.0;
2388     ypos      = 0.0;
2389     zpos      = fgkVrocsm + fgkSMpltT + kPWRhgt/2.0 - fgkSheight/2.0 + kPWRposz
2390               + (ilayer+1) * (fgkCH + fgkVspace);
2391     gMC->Gspos("UTPC",ilayer        ,"UTF1", xpos,ypos,zpos,matrix[0],"ONLY");
2392     gMC->Gspos("UTPC",ilayer+kNlayer,"UTF1",-xpos,ypos,zpos,matrix[1],"ONLY");
2393   }
2394   xpos      = fCwidth[5]/2.0 + kPWRhgt/2.0 - 2.0;
2395   ypos      = 0.0;
2396   zpos      = fgkSheight/2.0 - fgkSMpltT - 2.0;
2397   gMC->Gspos("UTPC",5        ,"UTF1", xpos,ypos,zpos,matrix[3],"ONLY");
2398   gMC->Gspos("UTPC",5+kNlayer,"UTF1",-xpos,ypos,zpos,matrix[3],"ONLY");
2399
2400   // Power connection panel (Al)
2401   parBox[0] = 60.0/2.0;
2402   parBox[1] = 10.0/2.0;
2403   parBox[2] =  3.0/2.0;
2404   gMC->Gsvolu("UTPP","BOX ",idtmed[1301-1],parBox,kNparBox);
2405   xpos      =  0.0;
2406   ypos      =  0.0;
2407   zpos      = 18.0;
2408   gMC->Gspos("UTPP",1,"UTF1", xpos,ypos,zpos,0,"ONLY");
2409
2410   //
2411   // Electronics boxes
2412   //
2413
2414   // Casing (INOX)
2415   parBox[0] = 60.0/2.0;
2416   parBox[1] = 10.0/2.0;
2417   parBox[2] =  6.0/2.0;
2418   gMC->Gsvolu("UTE1","BOX ",idtmed[1308-1],parBox,kNparBox);
2419   // Interior (air)
2420   parBox[0] = parBox[0] - 0.5;
2421   parBox[1] = parBox[1] - 0.5;
2422   parBox[2] = parBox[2] - 0.5;
2423   gMC->Gsvolu("UTE2","BOX ",idtmed[1302-1],parBox,kNparBox);
2424   xpos      = 0.0;
2425   ypos      = 0.0;
2426   zpos      = 0.0;
2427   gMC->Gspos("UTE2",1,"UTE1",xpos,ypos,zpos,0,"ONLY");
2428   xpos      = 0.0;
2429   ypos      =  fgkSlength/2.0 - 10.0/2.0 - 3.0;
2430   zpos      = -fgkSheight/2.0 +  6.0/2.0 + 1.0;
2431   gMC->Gspos("UTE1",1,"UTI1", xpos,ypos,zpos,0,"ONLY");
2432   gMC->Gspos("UTE1",2,"UTI2", xpos,ypos,zpos,0,"ONLY");
2433   gMC->Gspos("UTE1",3,"UTI3", xpos,ypos,zpos,0,"ONLY");
2434
2435   // Casing (INOX)
2436   parBox[0] = 50.0/2.0;
2437   parBox[1] = 15.0/2.0;
2438   parBox[2] = 20.0/2.0;
2439   gMC->Gsvolu("UTE3","BOX ",idtmed[1308-1],parBox,kNparBox);
2440   // Interior (air)
2441   parBox[0] = parBox[0] - 0.5;
2442   parBox[1] = parBox[1] - 0.5;
2443   parBox[2] = parBox[2] - 0.5;
2444   gMC->Gsvolu("UTE4","BOX ",idtmed[1302-1],parBox,kNparBox);
2445   xpos      = 0.0;
2446   ypos      = 0.0;
2447   zpos      = 0.0;
2448   gMC->Gspos("UTE4",1,"UTE3",xpos,ypos,zpos,0,"ONLY");
2449   xpos      = 0.0;
2450   ypos      = -fgkSlength/2.0 + 15.0/2.0 + 3.0;
2451   zpos      = -fgkSheight/2.0 + 20.0/2.0 + 1.0;
2452   gMC->Gspos("UTE3",1,"UTI1", xpos,ypos,zpos,0,"ONLY");
2453   gMC->Gspos("UTE3",2,"UTI2", xpos,ypos,zpos,0,"ONLY");
2454   gMC->Gspos("UTE3",3,"UTI3", xpos,ypos,zpos,0,"ONLY");
2455
2456   // Casing (INOX)
2457   parBox[0] = 20.0/2.0;
2458   parBox[1] =  7.0/2.0;
2459   parBox[2] = 20.0/2.0;
2460   gMC->Gsvolu("UTE5","BOX ",idtmed[1308-1],parBox,kNparBox);
2461   // Interior (air)
2462   parBox[0] = parBox[0] - 0.5;
2463   parBox[1] = parBox[1] - 0.5;
2464   parBox[2] = parBox[2] - 0.5;
2465   gMC->Gsvolu("UTE6","BOX ",idtmed[1302-1],parBox,kNparBox);
2466   xpos      = 0.0;
2467   ypos      = 0.0;
2468   zpos      = 0.0;
2469   gMC->Gspos("UTE6",1,"UTE5",xpos,ypos,zpos,0,"ONLY");
2470   xpos      = 20.0;
2471   ypos      = -fgkSlength/2.0 +  7.0/2.0 + 3.0;
2472   zpos      = 0.0;
2473   gMC->Gspos("UTE5",1,"UTI1", xpos,ypos,zpos,0,"ONLY");
2474   gMC->Gspos("UTE5",2,"UTI2", xpos,ypos,zpos,0,"ONLY");
2475   gMC->Gspos("UTE5",3,"UTI3", xpos,ypos,zpos,0,"ONLY");
2476   xpos      = -xpos;
2477   gMC->Gspos("UTE5",4,"UTI1", xpos,ypos,zpos,0,"ONLY");
2478   gMC->Gspos("UTE5",5,"UTI2", xpos,ypos,zpos,0,"ONLY");
2479   gMC->Gspos("UTE5",6,"UTI3", xpos,ypos,zpos,0,"ONLY");
2480
2481 }
2482
2483 //_____________________________________________________________________________
2484 void AliTRDgeometry::GroupChamber(Int_t ilayer, Int_t istack, Int_t *idtmed)
2485 {
2486   //
2487   // Group volumes UA, UD, UF, UU in a single chamber (Air)
2488   // UA, UD, UF, UU are boxes
2489   // UT will be a box
2490   //
2491
2492   const Int_t kNparCha = 3;
2493
2494   Int_t iDet = GetDetectorSec(ilayer,istack);
2495
2496   Float_t xyzMin[3];
2497   Float_t xyzMax[3];
2498   Float_t xyzOrig[3];
2499   Float_t xyzBoxd[3];
2500
2501   Char_t  cTagV[5];
2502   Char_t  cTagM[5];
2503
2504   for (Int_t i = 0; i < 3; i++) {
2505     xyzMin[i] = +9999.0;
2506     xyzMax[i] = -9999.0;
2507   }
2508
2509   for (Int_t i = 0; i < 3; i++) {
2510
2511     xyzMin[i] = TMath::Min(xyzMin[i],fChamberUAorig[iDet][i]-fChamberUAboxd[iDet][i]);
2512     xyzMax[i] = TMath::Max(xyzMax[i],fChamberUAorig[iDet][i]+fChamberUAboxd[iDet][i]);
2513
2514     xyzMin[i] = TMath::Min(xyzMin[i],fChamberUDorig[iDet][i]-fChamberUDboxd[iDet][i]);
2515     xyzMax[i] = TMath::Max(xyzMax[i],fChamberUDorig[iDet][i]+fChamberUDboxd[iDet][i]);
2516
2517     xyzMin[i] = TMath::Min(xyzMin[i],fChamberUForig[iDet][i]-fChamberUFboxd[iDet][i]);
2518     xyzMax[i] = TMath::Max(xyzMax[i],fChamberUForig[iDet][i]+fChamberUFboxd[iDet][i]);
2519
2520     xyzMin[i] = TMath::Min(xyzMin[i],fChamberUUorig[iDet][i]-fChamberUUboxd[iDet][i]);
2521     xyzMax[i] = TMath::Max(xyzMax[i],fChamberUUorig[iDet][i]+fChamberUUboxd[iDet][i]);
2522
2523     xyzOrig[i] = 0.5*(xyzMax[i]+xyzMin[i]);
2524     xyzBoxd[i] = 0.5*(xyzMax[i]-xyzMin[i]);
2525
2526   }
2527
2528   sprintf(cTagM,"UT%02d",iDet);
2529   gMC->Gsvolu(cTagM,"BOX ",idtmed[1302-1],xyzBoxd,kNparCha);
2530
2531   sprintf(cTagV,"UA%02d",iDet);
2532   gMC->Gspos(cTagV,1,cTagM
2533             ,fChamberUAorig[iDet][0]-xyzOrig[0]
2534             ,fChamberUAorig[iDet][1]-xyzOrig[1]
2535             ,fChamberUAorig[iDet][2]-xyzOrig[2]
2536             ,0,"ONLY");
2537
2538   sprintf(cTagV,"UZ%02d",iDet);
2539   gMC->Gspos(cTagV,1,cTagM
2540             ,fChamberUAorig[iDet][0]-xyzOrig[0] + fChamberUAboxd[iDet][0] - fgkCroW/2.0
2541             ,fChamberUAorig[iDet][1]-xyzOrig[1]
2542             ,fChamberUAorig[iDet][2]-xyzOrig[2] + fgkCraH/2.0 + fgkCdrH/2.0 - fgkCalW/2.0
2543             ,0,"ONLY");
2544   gMC->Gspos(cTagV,2,cTagM
2545             ,fChamberUAorig[iDet][0]-xyzOrig[0] - fChamberUAboxd[iDet][0] + fgkCroW/2.0
2546             ,fChamberUAorig[iDet][1]-xyzOrig[1]
2547             ,fChamberUAorig[iDet][2]-xyzOrig[2] + fgkCraH/2.0 + fgkCdrH/2.0 - fgkCalW/2.0
2548             ,0,"ONLY");
2549
2550   sprintf(cTagV,"UD%02d",iDet);
2551   gMC->Gspos(cTagV,1,cTagM
2552             ,fChamberUDorig[iDet][0]-xyzOrig[0]
2553             ,fChamberUDorig[iDet][1]-xyzOrig[1]
2554             ,fChamberUDorig[iDet][2]-xyzOrig[2]
2555             ,0,"ONLY");
2556
2557   sprintf(cTagV,"UF%02d",iDet);
2558   gMC->Gspos(cTagV,1,cTagM
2559             ,fChamberUForig[iDet][0]-xyzOrig[0]
2560             ,fChamberUForig[iDet][1]-xyzOrig[1]
2561             ,fChamberUForig[iDet][2]-xyzOrig[2]
2562             ,0,"ONLY");
2563
2564   sprintf(cTagV,"UU%02d",iDet);
2565   gMC->Gspos(cTagV,1,cTagM
2566             ,fChamberUUorig[iDet][0]-xyzOrig[0]
2567             ,fChamberUUorig[iDet][1]-xyzOrig[1]
2568             ,fChamberUUorig[iDet][2]-xyzOrig[2]
2569             ,0,"ONLY");
2570
2571   sprintf(cTagV,"UT%02d",iDet);
2572   gMC->Gspos(cTagV,1,"UTI1"
2573             ,xyzOrig[0]
2574             ,xyzOrig[1]
2575             ,xyzOrig[2]
2576             ,0,"ONLY");
2577   gMC->Gspos(cTagV,1,"UTI2"
2578             ,xyzOrig[0]
2579             ,xyzOrig[1]
2580             ,xyzOrig[2]
2581             ,0,"ONLY");
2582   if (istack != 2) {
2583     // W/o middle stack
2584     gMC->Gspos(cTagV,1,"UTI3"
2585               ,xyzOrig[0]
2586               ,xyzOrig[1]
2587               ,xyzOrig[2]
2588               ,0,"ONLY");
2589   }
2590
2591 }
2592
2593 //_____________________________________________________________________________
2594 Bool_t AliTRDgeometry::RotateBack(Int_t det, Double_t *loc, Double_t *glb) const
2595 {
2596   //
2597   // Rotates a chambers to transform the corresponding local frame
2598   // coordinates <loc> into the coordinates of the ALICE restframe <glb>.
2599   //
2600
2601   Int_t sector = GetSector(det);
2602
2603   glb[0] = loc[0] * fRotB11[sector] - loc[1] * fRotB12[sector];
2604   glb[1] = loc[0] * fRotB21[sector] + loc[1] * fRotB22[sector];
2605   glb[2] = loc[2];
2606
2607   return kTRUE;
2608
2609 }
2610
2611 //_____________________________________________________________________________
2612 Int_t AliTRDgeometry::GetDetectorSec(Int_t layer, Int_t stack)
2613 {
2614   //
2615   // Convert plane / stack into detector number for one single sector
2616   //
2617
2618   return (layer + stack * fgkNlayer);
2619
2620 }
2621
2622 //_____________________________________________________________________________
2623 Int_t AliTRDgeometry::GetDetector(Int_t layer, Int_t stack, Int_t sector)
2624 {
2625   //
2626   // Convert layer / stack / sector into detector number
2627   //
2628
2629   return (layer + stack * fgkNlayer + sector * fgkNlayer * fgkNstack);
2630
2631 }
2632
2633 //_____________________________________________________________________________
2634 Int_t AliTRDgeometry::GetLayer(Int_t det)
2635 {
2636   //
2637   // Reconstruct the layer number from the detector number
2638   //
2639
2640   return ((Int_t) (det % fgkNlayer));
2641
2642 }
2643
2644 //_____________________________________________________________________________
2645 Int_t AliTRDgeometry::GetStack(Int_t det) const
2646 {
2647   //
2648   // Reconstruct the stack number from the detector number
2649   //
2650
2651   return ((Int_t) (det % (fgkNlayer * fgkNstack)) / fgkNlayer);
2652
2653 }
2654
2655 //_____________________________________________________________________________
2656 Int_t AliTRDgeometry::GetStack(Double_t z, Int_t layer)
2657 {
2658   //
2659   // Reconstruct the chamber number from the z position and layer number
2660   //
2661   // The return function has to be protected for positiveness !!
2662   //
2663
2664   if ((layer <          0) ||
2665       (layer >= fgkNlayer)) return -1;
2666
2667   Int_t    istck = fgkNstack;
2668   Double_t zmin;
2669   Double_t zmax;
2670
2671   do {
2672     istck--;
2673     if (istck < 0) break;
2674     AliTRDpadPlane *pp = GetPadPlane(layer,istck);
2675     zmax  = pp->GetRow0();
2676     Int_t nrows = pp->GetNrows();
2677     zmin = zmax -         2 * pp->GetLengthOPad()
2678                 - (nrows-2) * pp->GetLengthIPad()
2679                 - (nrows-1) * pp->GetRowSpacing();
2680   } while((z < zmin) || (z > zmax));
2681
2682   return istck;
2683
2684 }
2685
2686 //_____________________________________________________________________________
2687 Int_t AliTRDgeometry::GetSector(Int_t det) const
2688 {
2689   //
2690   // Reconstruct the sector number from the detector number
2691   //
2692
2693   return ((Int_t) (det / (fgkNlayer * fgkNstack)));
2694
2695 }
2696
2697 //_____________________________________________________________________________
2698 AliTRDpadPlane *AliTRDgeometry::GetPadPlane(Int_t layer, Int_t stack)
2699 {
2700   //
2701   // Returns the pad plane for a given plane <pl> and stack <st> number
2702   //
2703
2704   if (!fPadPlaneArray) {
2705     CreatePadPlaneArray();
2706   }
2707
2708   Int_t ipp = GetDetectorSec(layer,stack);
2709   return ((AliTRDpadPlane *) fPadPlaneArray->At(ipp));
2710
2711 }
2712
2713 //_____________________________________________________________________________
2714 Int_t AliTRDgeometry::GetRowMax(Int_t layer, Int_t stack, Int_t /*sector*/)
2715 {
2716   //
2717   // Returns the number of rows on the pad plane
2718   //
2719
2720   return GetPadPlane(layer,stack)->GetNrows();
2721
2722 }
2723
2724 //_____________________________________________________________________________
2725 Int_t AliTRDgeometry::GetColMax(Int_t layer)
2726 {
2727   //
2728   // Returns the number of rows on the pad plane
2729   //
2730
2731   return GetPadPlane(layer,0)->GetNcols();
2732
2733 }
2734
2735 //_____________________________________________________________________________
2736 Double_t AliTRDgeometry::GetRow0(Int_t layer, Int_t stack, Int_t /*sector*/)
2737 {
2738   //
2739   // Returns the position of the border of the first pad in a row
2740   //
2741
2742   return GetPadPlane(layer,stack)->GetRow0();
2743
2744 }
2745
2746 //_____________________________________________________________________________
2747 Double_t AliTRDgeometry::GetCol0(Int_t layer)
2748 {
2749   //
2750   // Returns the position of the border of the first pad in a column
2751   //
2752
2753   return GetPadPlane(layer,0)->GetCol0();
2754
2755 }
2756
2757 //_____________________________________________________________________________
2758 Bool_t AliTRDgeometry::CreateClusterMatrixArray()
2759 {
2760   //
2761   // Create the matrices to transform cluster coordinates from the
2762   // local chamber system to the tracking coordinate system
2763   //
2764
2765   if (!gGeoManager) {
2766     return kFALSE;
2767   }
2768
2769   fClusterMatrixArray = new TObjArray(kNdet);
2770   AliAlignObjParams o;
2771
2772   for (Int_t iLayer = AliGeomManager::kTRD1; iLayer <= AliGeomManager::kTRD6; iLayer++) {
2773     for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer); iModule++) {
2774
2775       Int_t        isector   = iModule/Nstack();
2776       Int_t        istack    = iModule%Nstack();
2777       Int_t        iLayerTRD = iLayer - AliGeomManager::kTRD1;
2778       Int_t        lid       = GetDetector(iLayerTRD,istack,isector);
2779
2780       // Taking holes into account
2781       if (((isector == 13) || (isector == 14) || (isector == 15)) &&
2782           (istack == 2)) continue;
2783
2784       // Taking disabled supermodules into account
2785       if (!GetSMstatus(isector)) continue;
2786
2787       UShort_t     volid   = AliGeomManager::LayerToVolUID(iLayer,iModule);
2788       const char  *symname = AliGeomManager::SymName(volid);
2789       TGeoPNEntry *pne     = gGeoManager->GetAlignableEntry(symname);
2790       const char  *path    = symname;
2791       if (pne) {
2792         path = pne->GetTitle();
2793       }
2794       else {
2795         continue;
2796       }
2797       if (!strstr(path,"ALIC")) {
2798         AliDebug(1,Form("Not a valid path: %s\n",path));
2799         continue;
2800       }
2801       if (!gGeoManager->cd(path)) {
2802         AliError(Form("Cannot go to path: %s\n",path));
2803         continue;
2804       }
2805       TGeoHMatrix *m         = gGeoManager->GetCurrentMatrix();
2806
2807       TGeoRotation mchange;
2808       mchange.RotateY(90);
2809       mchange.RotateX(90);
2810
2811       //
2812       // Cluster transformation matrix
2813       //
2814       TGeoHMatrix  rotMatrix(mchange.Inverse());
2815       rotMatrix.MultiplyLeft(m);
2816       Double_t sectorAngle = 20.0 * (isector % 18) + 10.0;
2817       TGeoHMatrix  rotSector;
2818       rotSector.RotateZ(sectorAngle);
2819       rotMatrix.MultiplyLeft(&rotSector.Inverse());
2820
2821       fClusterMatrixArray->AddAt(new TGeoHMatrix(rotMatrix),lid);
2822
2823     }
2824   }
2825
2826   return kTRUE;
2827
2828 }
2829
2830 //_____________________________________________________________________________
2831 Bool_t AliTRDgeometry::ChamberInGeometry(Int_t det)
2832 {
2833   //
2834   // Checks whether the given detector is part of the current geometry
2835   //
2836
2837   if (!fClusterMatrixArray) {
2838     CreateClusterMatrixArray();
2839   }
2840
2841   if (!GetClusterMatrix(det)) {
2842     return kFALSE;
2843   }
2844   else {
2845     return kTRUE;
2846   }
2847
2848 }