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