TRD/AliTRDgeometry.cxx

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