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