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
  25 #include <TError.h>
  26 #include <TGeoManager.h>
  27 #include <TGeoPhysicalNode.h>
  28 #include <TGeoMatrix.h>
  29
  30
  31 #include "AliRunLoader.h"
  32 #include "AliTRDgeometry.h"
  33 #include "AliTRDpadPlane.h"
  34
  35 #include "AliAlignObj.h"
  36 #include "AliAlignObjAngles.h"
  37
  38 #include "AliRun.h"
  39 #include "AliTRD.h"
  40 #include "AliTRDcalibDB.h"
  41 #include "AliTRDCommonParam.h"
  42
  43 ClassImp(AliTRDgeometry)
  44
  45 //_____________________________________________________________________________
  46
  47   //
  48   // The geometry constants
  49   //
  50   const Int_t   AliTRDgeometry::fgkNsect   = kNsect;
  51   const Int_t   AliTRDgeometry::fgkNplan   = kNplan;
  52   const Int_t   AliTRDgeometry::fgkNcham   = kNcham;
  53   const Int_t   AliTRDgeometry::fgkNdet    = kNdet;
  54
  55   //
  56   // Dimensions of the detector
  57   //
  58
  59   // Inner and outer radius of the mother volumes
  60   const Float_t AliTRDgeometry::fgkRmin    = 294.0;
  61   const Float_t AliTRDgeometry::fgkRmax    = 368.0;
  62
  63   // Upper and lower length of the mother volumes
  64   const Float_t AliTRDgeometry::fgkZmax1   = 378.35;
  65   const Float_t AliTRDgeometry::fgkZmax2   = 302.0;
  66
  67   // Parameter of the BTR mother volumes
  68   // CBL
  69   //const Float_t AliTRDgeometry::fgkSheight =  74.0;
  70   const Float_t AliTRDgeometry::fgkSheight =  74.86;
  71   const Float_t AliTRDgeometry::fgkSwidth1 =  99.613;
  72   // CBL
  73   //const Float_t AliTRDgeometry::fgkSwidth2 = 125.707;
  74   const Float_t AliTRDgeometry::fgkSwidth2 = 126.012;
  75   const Float_t AliTRDgeometry::fgkSlenTR1 = 751.0;
  76   const Float_t AliTRDgeometry::fgkSlenTR2 = 313.5;
  77   const Float_t AliTRDgeometry::fgkSlenTR3 = 159.5;
  78
  79   // The super module side plates
  80   const Float_t AliTRDgeometry::fgkSMpltT  =   0.2;
  81   const Float_t AliTRDgeometry::fgkSMgapT  =   0.5;
  82
  83   // Height of different chamber parts
  84   // Radiator
  85   const Float_t AliTRDgeometry::fgkCraH    =   4.8;
  86   // Drift region
  87   const Float_t AliTRDgeometry::fgkCdrH    =   3.0;
  88   // Amplification region
  89   const Float_t AliTRDgeometry::fgkCamH    =   0.7;
  90   // Readout
  91   const Float_t AliTRDgeometry::fgkCroH    =   2.316;
  92   // Total height
  93   const Float_t AliTRDgeometry::fgkCH      = AliTRDgeometry::fgkCraH
  94                                            + AliTRDgeometry::fgkCdrH
  95                                            + AliTRDgeometry::fgkCamH
  96                                            + AliTRDgeometry::fgkCroH;
  97
  98   // Vertical spacing of the chambers
  99   const Float_t AliTRDgeometry::fgkVspace  =   1.784;
 100
 101   // Horizontal spacing of the chambers
 102   const Float_t AliTRDgeometry::fgkHspace  =   2.0;
 103
 104   // Thicknesses of different parts of the chamber frame
 105   // Lower aluminum frame
 106   const Float_t AliTRDgeometry::fgkCalT    =   0.3;
 107   // Lower G10 frame sides
 108   const Float_t AliTRDgeometry::fgkCclsT   =   0.3;
 109   // Lower G10 frame front
 110   const Float_t AliTRDgeometry::fgkCclfT   =   1.0;
 111   // Upper G10 frame
 112   const Float_t AliTRDgeometry::fgkCcuT    =   0.9;
 113   // Upper Al frame
 114   const Float_t AliTRDgeometry::fgkCauT    =   1.5;
 115
 116   // Additional width of the readout chamber frames
 117   const Float_t AliTRDgeometry::fgkCroW    =   0.9;
 118
 119   // Difference of outer chamber width and pad plane width
 120   //const Float_t AliTRDgeometry::fgkCpadW   =   1.0;
 121   const Float_t AliTRDgeometry::fgkCpadW   =   0.0;
 122   const Float_t AliTRDgeometry::fgkRpadW   =   1.0;
 123
 124   //
 125   // Thickness of the the material layers
 126   //
 127   const Float_t AliTRDgeometry::fgkRaThick = 0.3646;
 128   const Float_t AliTRDgeometry::fgkMyThick = 0.005;
 129   const Float_t AliTRDgeometry::fgkDrThick = AliTRDgeometry::fgkCdrH;
 130   const Float_t AliTRDgeometry::fgkAmThick = AliTRDgeometry::fgkCamH;
 131   const Float_t AliTRDgeometry::fgkXeThick = AliTRDgeometry::fgkDrThick
 132                                            + AliTRDgeometry::fgkAmThick;
 133   const Float_t AliTRDgeometry::fgkCuThick = 0.001;
 134   const Float_t AliTRDgeometry::fgkSuThick = 0.06;
 135   const Float_t AliTRDgeometry::fgkFeThick = 0.0044;
 136   const Float_t AliTRDgeometry::fgkCoThick = 0.02;
 137   const Float_t AliTRDgeometry::fgkWaThick = 0.02;
 138
 139   //
 140   // Position of the material layers
 141   //
 142   const Float_t AliTRDgeometry::fgkRaZpos  = -1.50;
 143   const Float_t AliTRDgeometry::fgkMyZpos  =  0.895;
 144   const Float_t AliTRDgeometry::fgkDrZpos  =  2.4;
 145   const Float_t AliTRDgeometry::fgkAmZpos  =  0.0;
 146   const Float_t AliTRDgeometry::fgkCuZpos  = -0.9995;
 147   const Float_t AliTRDgeometry::fgkSuZpos  =  0.0000;
 148   const Float_t AliTRDgeometry::fgkFeZpos  =  0.0322;
 149   const Float_t AliTRDgeometry::fgkCoZpos  =  0.97;
 150   const Float_t AliTRDgeometry::fgkWaZpos  =  0.99;
 151
 152   const Double_t AliTRDgeometry::fgkTime0Base = Rmin() + CraHght() + CdrHght() + CamHght()/2.;
 153   const Float_t  AliTRDgeometry::fgkTime0[6]  = { fgkTime0Base + 0 * (Cheight() + Cspace()),
 154                                                   fgkTime0Base + 1 * (Cheight() + Cspace()),
 155                                                   fgkTime0Base + 2 * (Cheight() + Cspace()),
 156                                                   fgkTime0Base + 3 * (Cheight() + Cspace()),
 157                                                   fgkTime0Base + 4 * (Cheight() + Cspace()),
 158                                                   fgkTime0Base + 5 * (Cheight() + Cspace()) };
 159
 160 //_____________________________________________________________________________
 161 AliTRDgeometry::AliTRDgeometry():AliGeometry()
 162 {
 163   //
 164   // AliTRDgeometry default constructor
 165   //
 166
 167   fMatrixArray           = 0;
 168   fMatrixCorrectionArray = 0;
 169
 170   Init();
 171
 172 }
 173
 174 //_____________________________________________________________________________
 175 AliTRDgeometry::~AliTRDgeometry()
 176 {
 177   //
 178   // AliTRDgeometry destructor
 179   //
 180
 181   delete fMatrixArray;
 182   delete fMatrixCorrectionArray;
 183
 184 }
 185
 186 //_____________________________________________________________________________
 187 void AliTRDgeometry::Init()
 188 {
 189   //
 190   // Initializes the geometry parameter
 191   //
 192   // The maximum number of pads
 193   // and the position of pad 0,0,0
 194   //
 195   // chambers seen from the top:
 196   //     +----------------------------+
 197   //     |                            |
 198   //     |                            |      ^
 199   //     |                            |  rphi|
 200   //     |                            |      |
 201   //     |0                           |      |
 202   //     +----------------------------+      +------>
 203   //                                             z
 204   // chambers seen from the side:            ^
 205   //     +----------------------------+ drift|
 206   //     |0                           |      |
 207   //     |                            |      |
 208   //     +----------------------------+      +------>
 209   //                                             z
 210   //
 211   // IMPORTANT: time bin 0 is now the first one in the drift region
 212   // closest to the readout !!!
 213   //
 214
 215   Int_t icham;
 216   Int_t iplan;
 217   Int_t isect;
 218
 219   // The outer width of the chambers
 220   fCwidth[0] =  90.4;
 221   fCwidth[1] =  94.8;
 222   fCwidth[2] =  99.3;
 223   fCwidth[3] = 103.7;
 224   fCwidth[4] = 108.1;
 225   fCwidth[5] = 112.6;
 226
 227   // The outer lengths of the chambers
 228   // Includes the spacings between the chambers!
 229   Float_t length[kNplan][kNcham]   = { { 124.0, 124.0, 110.0, 124.0, 124.0 }
 230                                      , { 124.0, 124.0, 110.0, 124.0, 124.0 }
 231                                      , { 131.0, 131.0, 110.0, 131.0, 131.0 }
 232                                      , { 138.0, 138.0, 110.0, 138.0, 138.0 }
 233                                      , { 145.0, 145.0, 110.0, 145.0, 145.0 }
 234                                      , { 147.0, 147.0, 110.0, 147.0, 147.0 } };
 235
 236   for (icham = 0; icham < kNcham; icham++) {
 237     for (iplan = 0; iplan < kNplan; iplan++) {
 238       fClength[iplan][icham]   = length[iplan][icham];
 239     }
 240   }
 241
 242   // The rotation matrix elements
 243   Float_t phi = 0;
 244   for (isect = 0; isect < fgkNsect; isect++) {
 245     phi = -2.0 * TMath::Pi() /  (Float_t) fgkNsect * ((Float_t) isect + 0.5);
 246     fRotA11[isect] = TMath::Cos(phi);
 247     fRotA12[isect] = TMath::Sin(phi);
 248     fRotA21[isect] = TMath::Sin(phi);
 249     fRotA22[isect] = TMath::Cos(phi);
 250     phi = -1.0 * phi;
 251     fRotB11[isect] = TMath::Cos(phi);
 252     fRotB12[isect] = TMath::Sin(phi);
 253     fRotB21[isect] = TMath::Sin(phi);
 254     fRotB22[isect] = TMath::Cos(phi);
 255   }
 256
 257   for (isect = 0; isect < fgkNsect; isect++) {
 258     SetSMstatus(isect,1);
 259   }
 260
 261 }
 262
 263 //_____________________________________________________________________________
 264 void AliTRDgeometry::CreateGeometry(Int_t *idtmed)
 265 {
 266   //
 267   // Create the TRD geometry without hole
 268   //
 269   //
 270   // Names of the TRD volumina (xx = detector number):
 271   //
 272   //      Volume (Air) wrapping the readout chamber components
 273   //        UTxx    includes: UAxx, UDxx, UFxx, UUxx
 274   //      Obs:
 275   //        UUxx    the services volume has been reduced by 7.42 mm
 276   //                in order to allow shifts in radial direction
 277   //
 278   //      Lower part of the readout chambers (gas volume + radiator)
 279   //
 280   //        UAxx    Aluminum frames             (Al)
 281   //        UBxx    G10 frames                  (C)
 282   //        UCxx    Inner volumes               (Air)
 283   //
 284   //      Upper part of the readout chambers (readout plane + fee)
 285   //
 286   //        UDxx    G10 frames                  (C)
 287   //        UExx    Inner volumes of the G10    (Air)
 288   //        UFxx    Aluminum frames             (Al)
 289   //        UGxx    Inner volumes of the Al     (Air)
 290   //
 291   //      Inner material layers
 292   //
 293   //        UHxx    Radiator                    (Rohacell)
 294   //        UIxx    Entrance window             (Mylar)
 295   //        UJxx    Drift volume                (Xe/CO2)
 296   //        UKxx    Amplification volume        (Xe/CO2)
 297   //        ULxx    Pad plane                   (Cu)
 298   //        UMxx    Support structure           (Rohacell)
 299   //
 300
 301   const Int_t kNparTrd = 4;
 302   const Int_t kNparCha = 3;
 303
 304   Float_t xpos, ypos, zpos;
 305
 306   Float_t parTrd[kNparTrd];
 307   Float_t parCha[kNparCha];
 308
 309   Char_t  cTagV[6];
 310   Char_t  cTagM[5];
 311
 312   // The TRD mother volume for one sector (Air), full length in z-direction
 313   // Provides material for side plates of super module
 314   parTrd[0] = fgkSwidth1/2.;
 315   parTrd[1] = fgkSwidth2/2.;
 316   parTrd[2] = fgkSlenTR1/2.;
 317   parTrd[3] = fgkSheight/2.;
 318   gMC->Gsvolu("UTR1","TRD1",idtmed[1302-1],parTrd,kNparTrd);
 319
 320   //
 321   // The side plates of the super module (Al)
 322   parTrd[0] = fgkSwidth1/2. - fgkSMgapT;
 323   parTrd[1] = fgkSwidth2/2. - fgkSMgapT;
 324   parTrd[2] = fgkSlenTR1/2.;
 325   parTrd[3] = fgkSheight/2.;
 326   gMC->Gsvolu("UTS1","TRD1",idtmed[1301-1],parTrd,kNparTrd);
 327
 328   // The inner part of the TRD mother volume for one sector (Air),
 329   // full length in z-direction
 330   parTrd[0] = fgkSwidth1/2. - fgkSMgapT - fgkSMpltT;
 331   parTrd[1] = fgkSwidth2/2. - fgkSMgapT - fgkSMpltT;
 332   parTrd[2] = fgkSlenTR1/2.;
 333   parTrd[3] = fgkSheight/2.;
 334   gMC->Gsvolu("UTI1","TRD1",idtmed[1302-1],parTrd,kNparTrd);
 335
 336   for (Int_t icham = 0; icham < kNcham; icham++) {
 337     for (Int_t iplan = 0; iplan < kNplan; iplan++) {
 338
 339       Int_t iDet = GetDetectorSec(iplan,icham);
 340
 341       // The lower part of the readout chambers (gas volume + radiator)
 342       // The aluminum frames
 343       sprintf(cTagV,"UA%02d",iDet);
 344       parCha[0] = fCwidth[iplan]/2.;
 345       parCha[1] = fClength[iplan][icham]/2. - fgkHspace/2.;
 346       parCha[2] = fgkCraH/2. + fgkCdrH/2.;
 347       fChamberUAboxd[iDet][0] = parCha[0];
 348       fChamberUAboxd[iDet][1] = parCha[1];
 349       fChamberUAboxd[iDet][2] = parCha[2];
 350       gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parCha,kNparCha);
 351       // The G10 frames
 352       sprintf(cTagV,"UB%02d",iDet);
 353       parCha[0] = fCwidth[iplan]/2. - fgkCalT;
 354       parCha[1] = -1.;
 355       parCha[2] = -1.;
 356       gMC->Gsvolu(cTagV,"BOX ",idtmed[1307-1],parCha,kNparCha);
 357       // The inner part (air)
 358       sprintf(cTagV,"UC%02d",iDet);
 359       parCha[0] = fCwidth[iplan]/2. - fgkCalT - fgkCclsT;
 360       parCha[1] = fClength[iplan][icham]/2. - fgkHspace/2.- fgkCclfT;
 361       parCha[2] = -1.;
 362       gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
 363
 364       // The upper part of the readout chambers (readout plane)
 365       // The G10 frames
 366       sprintf(cTagV,"UD%02d",iDet);
 367       parCha[0] = fCwidth[iplan]/2. + fgkCroW;
 368       parCha[1] = fClength[iplan][icham]/2. - fgkHspace/2.;
 369       parCha[2] = fgkCamH/2.;
 370       fChamberUDboxd[iDet][0] = parCha[0];
 371       fChamberUDboxd[iDet][1] = parCha[1];
 372       fChamberUDboxd[iDet][2] = parCha[2];
 373       gMC->Gsvolu(cTagV,"BOX ",idtmed[1307-1],parCha,kNparCha);
 374       // The inner part of the G10 frame (air)
 375       sprintf(cTagV,"UE%02d",iDet);
 376       parCha[0] = fCwidth[iplan]/2. + fgkCroW - fgkCcuT;
 377       parCha[1] = fClength[iplan][icham]/2. - fgkHspace/2.- fgkCcuT;
 378       parCha[2] = -1.;
 379       gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
 380       // The aluminum frames
 381       sprintf(cTagV,"UF%02d",iDet);
 382       parCha[0] = fCwidth[iplan]/2. + fgkCroW;
 383       parCha[1] = fClength[iplan][icham]/2. - fgkHspace/2.;
 384       parCha[2] = fgkCroH/2.;
 385       fChamberUFboxd[iDet][0] = parCha[0];
 386       fChamberUFboxd[iDet][1] = parCha[1];
 387       fChamberUFboxd[iDet][2] = parCha[2];
 388       gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parCha,kNparCha);
 389       // The inner part of the aluminum frames
 390       sprintf(cTagV,"UG%02d",iDet);
 391       parCha[0] = fCwidth[iplan]/2. + fgkCroW - fgkCauT;
 392       parCha[1] = fClength[iplan][icham]/2. - fgkHspace/2.- fgkCauT;
 393       parCha[2] = -1.;
 394       gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
 395
 396       // The material layers inside the chambers
 397       parCha[0] = -1.;
 398       parCha[1] = -1.;
 399       // Rohacell layer (radiator)
 400       parCha[2] = fgkRaThick/2;
 401       sprintf(cTagV,"UH%02d",iDet);
 402       gMC->Gsvolu(cTagV,"BOX ",idtmed[1315-1],parCha,kNparCha);
 403       // Mylar layer (entrance window + HV cathode)
 404       parCha[2] = fgkMyThick/2;
 405       sprintf(cTagV,"UI%02d",iDet);
 406       gMC->Gsvolu(cTagV,"BOX ",idtmed[1308-1],parCha,kNparCha);
 407       // Xe/Isobutane layer (drift volume)
 408       parCha[2] = fgkDrThick/2.;
 409       sprintf(cTagV,"UJ%02d",iDet);
 410       gMC->Gsvolu(cTagV,"BOX ",idtmed[1309-1],parCha,kNparCha);
 411       // Xe/Isobutane layer (amplification volume)
 412       parCha[2] = fgkAmThick/2.;
 413       sprintf(cTagV,"UK%02d",iDet);
 414       gMC->Gsvolu(cTagV,"BOX ",idtmed[1309-1],parCha,kNparCha);
 415       // Cu layer (pad plane)
 416       parCha[2] = fgkCuThick/2;
 417       sprintf(cTagV,"UL%02d",iDet);
 418       gMC->Gsvolu(cTagV,"BOX ",idtmed[1305-1],parCha,kNparCha);
 419       // G10 layer (support structure / honeycomb)
 420       parCha[2] = fgkSuThick/2;
 421       sprintf(cTagV,"UM%02d",iDet);
 422       gMC->Gsvolu(cTagV,"BOX ",idtmed[1313-1],parCha,kNparCha);
 423
 424       // Position the layers in the chambers
 425       xpos = 0;
 426       ypos = 0;
 427       // Lower part
 428       // Rohacell layer (radiator)
 429       zpos = fgkRaZpos;
 430       sprintf(cTagV,"UH%02d",iDet);
 431       sprintf(cTagM,"UC%02d",iDet);
 432       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 433       // Mylar layer (entrance window + HV cathode)
 434       zpos = fgkMyZpos;
 435       sprintf(cTagV,"UI%02d",iDet);
 436       sprintf(cTagM,"UC%02d",iDet);
 437       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 438       // Xe/Isobutane layer (drift volume)
 439       zpos = fgkDrZpos;
 440       sprintf(cTagV,"UJ%02d",iDet);
 441       sprintf(cTagM,"UC%02d",iDet);
 442       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 443       // Upper part
 444       // Xe/Isobutane layer (amplification volume)
 445       zpos = fgkAmZpos;
 446       sprintf(cTagV,"UK%02d",iDet);
 447       sprintf(cTagM,"UE%02d",iDet);
 448       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 449       // Readout part
 450       // Cu layer (pad plane)
 451       zpos = fgkCuZpos;
 452       sprintf(cTagV,"UL%02d",iDet);
 453       sprintf(cTagM,"UG%02d",iDet);
 454       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 455       // G10 layer (support structure)
 456       zpos = fgkSuZpos;
 457       sprintf(cTagV,"UM%02d",iDet);
 458       sprintf(cTagM,"UG%02d",iDet);
 459       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 460
 461       // Position the inner volumes of the chambers in the frames
 462       xpos      = 0.0;
 463       ypos      = 0.0;
 464       zpos      = 0.0;
 465       // The inside of the lower G10 frame
 466       sprintf(cTagV,"UC%02d",iDet);
 467       sprintf(cTagM,"UB%02d",iDet);
 468       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 469       // The lower G10 frame inside the aluminum frame
 470       sprintf(cTagV,"UB%02d",iDet);
 471       sprintf(cTagM,"UA%02d",iDet);
 472       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 473       // The inside of the upper G10 frame
 474       sprintf(cTagV,"UE%02d",iDet);
 475       sprintf(cTagM,"UD%02d",iDet);
 476       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 477       // The inside of the upper aluminum frame
 478       sprintf(cTagV,"UG%02d",iDet);
 479       sprintf(cTagM,"UF%02d",iDet);
 480       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
 481
 482       // Position the frames of the chambers in the TRD mother volume
 483       xpos  = 0.;
 484       ypos  = - fClength[iplan][0] - fClength[iplan][1] - fClength[iplan][2]/2.;
 485       for (Int_t ic = 0; ic < icham; ic++) {
 486         ypos += fClength[iplan][ic];
 487       }
 488       ypos += fClength[iplan][icham]/2.;
 489       zpos  = fgkCraH/2. + fgkCdrH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
 490       // The lower aluminum frame, radiator + drift region
 491       sprintf(cTagV,"UA%02d",iDet);
 492       fChamberUAorig[iDet][0] = xpos;
 493       fChamberUAorig[iDet][1] = ypos;
 494       fChamberUAorig[iDet][2] = zpos;
 495       // The upper G10 frame, amplification region
 496       sprintf(cTagV,"UD%02d",iDet);
 497       zpos += fgkCamH/2. + fgkCraH/2. + fgkCdrH/2.;
 498       fChamberUDorig[iDet][0] = xpos;
 499       fChamberUDorig[iDet][1] = ypos;
 500       fChamberUDorig[iDet][2] = zpos;
 501       // The upper aluminum frame
 502       sprintf(cTagV,"UF%02d",iDet);
 503       zpos += fgkCroH/2. + fgkCamH/2.;
 504       fChamberUForig[iDet][0] = xpos;
 505       fChamberUForig[iDet][1] = ypos;
 506       fChamberUForig[iDet][2] = zpos;
 507
 508     }
 509   }
 510
 511   // Create the volumes of the super module frame
 512   CreateFrame(idtmed);
 513
 514   // Create the volumes of the services
 515   CreateServices(idtmed);
 516
 517   for (Int_t icham = 0; icham < kNcham; icham++) {
 518     for (Int_t iplan = 0; iplan < kNplan; iplan++) {
 519       GroupChamber(iplan,icham,idtmed);
 520     }
 521   }
 522
 523   xpos = 0.;
 524   ypos = 0.;
 525   zpos = 0.;
 526   gMC->Gspos("UTI1",1,"UTS1",xpos,ypos,zpos,0,"ONLY");
 527
 528   xpos = 0.;
 529   ypos = 0.;
 530   zpos = 0.;
 531   gMC->Gspos("UTS1",1,"UTR1",xpos,ypos,zpos,0,"ONLY");
 532
 533   // Put the TRD volumes into the space frame mother volumes
 534   // if enabled via status flag
 535   xpos = 0.;
 536   ypos = 0.;
 537   zpos = 0.;
 538   for (Int_t isect = 0; isect < kNsect; isect++) {
 539     if (fSMstatus[isect]) {
 540       sprintf(cTagV,"BTRD%d",isect);
 541       gMC->Gspos("UTR1",1,cTagV,xpos,ypos,zpos,0,"ONLY");
 542     }
 543   }
 544
 545 }
 546
 547 //_____________________________________________________________________________
 548 void AliTRDgeometry::CreateFrame(Int_t *idtmed)
 549 {
 550   //
 551   // Create the geometry of the frame of the supermodule
 552   //
 553   // Names of the TRD services volumina
 554   //
 555   //        USRL    Support rails for the chambers (Al)
 556   //        USxx    Support cross bars between the chambers (Al)
 557   //
 558
 559   Int_t   iplan = 0;
 560
 561   Float_t xpos  = 0.0;
 562   Float_t ypos  = 0.0;
 563   Float_t zpos  = 0.0;
 564
 565   Char_t  cTagV[5];
 566
 567   //
 568   // The chamber support rails
 569   //
 570
 571   const Float_t kSRLwid  = 2.0;
 572   const Float_t kSRLhgt  = 2.3;
 573   const Float_t kSRLdst  = 0.6;
 574   const Int_t   kNparSRL = 3;
 575   Float_t parSRL[kNparSRL];
 576   parSRL[0] = kSRLwid/2.;
 577   parSRL[1] = fgkSlenTR1/2.;
 578   parSRL[2] = kSRLhgt/2.;
 579   gMC->Gsvolu("USRL","BOX ",idtmed[1301-1],parSRL,kNparSRL);
 580
 581   xpos  = 0.0;
 582   ypos  = 0.0;
 583   zpos  = 0.0;
 584   for (iplan = 0; iplan < kNplan; iplan++) {
 585
 586     xpos  = fCwidth[iplan]/2. + kSRLwid/2. + kSRLdst;
 587     ypos  = 0.0;
 588     zpos  = fgkCraH + fgkCdrH - fgkSheight/2. - kSRLhgt/2.
 589           + iplan * (fgkCH + fgkVspace);
 590     gMC->Gspos("USRL",iplan+1         ,"UTI1", xpos,ypos,zpos,0,"ONLY");
 591     gMC->Gspos("USRL",iplan+1+  kNplan,"UTI1",-xpos,ypos,zpos,0,"ONLY");
 592
 593   }
 594
 595   //
 596   // The cross bars between the chambers
 597   //
 598
 599   const Float_t kSCBwid  = 1.0;
 600   const Int_t   kNparSCB = 3;
 601   Float_t parSCB[kNparSCB];
 602   parSCB[1] = kSCBwid/2.;
 603   parSCB[2] = fgkCH/2.;
 604
 605   xpos  = 0.0;
 606   ypos  = 0.0;
 607   zpos  = 0.0;
 608   for (iplan = 0; iplan < kNplan; iplan++) {
 609
 610     parSCB[0] = fCwidth[iplan]/2. + kSRLdst/2.;
 611
 612     sprintf(cTagV,"US0%01d",iplan);
 613     gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
 614     xpos  = 0.0;
 615     ypos  =   fgkSlenTR1/2. - kSCBwid/2.;
 616     zpos  = fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
 617     gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
 618
 619     sprintf(cTagV,"US1%01d",iplan);
 620     gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
 621     xpos  = 0.0;
 622     ypos  = fClength[iplan][2]/2. + fClength[iplan][1];
 623     zpos  = fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
 624     gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
 625
 626     sprintf(cTagV,"US2%01d",iplan);
 627     gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
 628     xpos  = 0.0;
 629     ypos  = fClength[iplan][2]/2.;
 630     zpos  = fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
 631     gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
 632
 633     sprintf(cTagV,"US3%01d",iplan);
 634     gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
 635     xpos  = 0.0;
 636     ypos  = - fClength[iplan][2]/2.;
 637     zpos  = fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
 638     gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
 639
 640     sprintf(cTagV,"US4%01d",iplan);
 641     gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
 642     xpos  = 0.0;
 643     ypos  = - fClength[iplan][2]/2. - fClength[iplan][1];
 644     zpos  = fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
 645     gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
 646
 647     sprintf(cTagV,"US5%01d",iplan);
 648     gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
 649     xpos  = 0.0;
 650     ypos  = - fgkSlenTR1/2. + kSCBwid/2.;
 651     zpos  = fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
 652     gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
 653
 654   }
 655
 656 }
 657
 658 //_____________________________________________________________________________
 659 void AliTRDgeometry::CreateServices(Int_t *idtmed)
 660 {
 661   //
 662   // Create the geometry of the services
 663   //
 664   // Names of the TRD services volumina
 665   //
 666   //        UTCL    Cooling arterias (Al)
 667   //        UTCW    Cooling arterias (Water)
 668   //        UUxx    Volumes for the services at the chambers (Air)
 669   //        UTPW    Power bars       (Cu)
 670   //        UTCP    Cooling pipes    (Al)
 671   //        UTCH    Cooling pipes    (Water)
 672   //        UTPL    Power lines      (Cu)
 673   //        UMCM    Readout MCMs     (G10/Cu/Si)
 674   //
 675
 676   Int_t   iplan = 0;
 677   Int_t   icham = 0;
 678
 679   Float_t xpos  = 0.0;
 680   Float_t ypos  = 0.0;
 681   Float_t zpos  = 0.0;
 682
 683   Char_t  cTagV[5];
 684
 685   // The rotation matrices
 686   const Int_t kNmatrix = 3;
 687   Int_t   matrix[kNmatrix];
 688   gMC->Matrix(matrix[0],100.0,  0.0, 90.0, 90.0, 10.0,  0.0);
 689   gMC->Matrix(matrix[1], 80.0,  0.0, 90.0, 90.0, 10.0,180.0);
 690   gMC->Matrix(matrix[2],  0.0,  0.0, 90.0, 90.0, 90.0,  0.0);
 691
 692   AliTRDCommonParam* commonParam = AliTRDCommonParam::Instance();
 693   if (!commonParam)
 694   {
 695     AliError("Could not get common params\n");
 696     return;
 697   }
 698
 699   //
 700   // The cooling arterias
 701   //
 702
 703   // Width of the cooling arterias
 704   const Float_t kCOLwid  =  0.5;
 705   // Height of the cooling arterias
 706   const Float_t kCOLhgt  =  5.5;
 707   // Positioning of the cooling
 708   const Float_t kCOLposx =  1.6;
 709   const Float_t kCOLposz = -0.2;
 710   // Thickness of the walls of the cooling arterias
 711   const Float_t kCOLthk  =  0.1;
 712   const Int_t   kNparCOL = 3;
 713   Float_t parCOL[kNparCOL];
 714   parCOL[0]  = kCOLwid/2.;
 715   parCOL[1]  = fgkSlenTR1/2.;
 716   parCOL[2]  = kCOLhgt/2.;
 717   gMC->Gsvolu("UTCL","BOX ",idtmed[1324-1],parCOL,kNparCOL);
 718   parCOL[0] -= kCOLthk;
 719   parCOL[1]  = fgkSlenTR1/2.;
 720   parCOL[2] -= kCOLthk;
 721   gMC->Gsvolu("UTCW","BOX ",idtmed[1314-1],parCOL,kNparCOL);
 722
 723   xpos  = 0.0;
 724   ypos  = 0.0;
 725   zpos  = 0.0;
 726   gMC->Gspos("UTCW",1,"UTCL", xpos,ypos,zpos,0,"ONLY");
 727
 728   for (iplan = 0; iplan < kNplan; iplan++) { // CHECK FOR OVERLAPS !!!
 729     //for (iplan = 1; iplan < kNplan; iplan++) {
 730
 731     xpos  = fCwidth[iplan]/2. + kCOLwid/2. + kCOLposx;
 732     ypos  = 0.0;
 733     zpos  = kCOLhgt/2. - fgkSheight/2. + kCOLposz + iplan * (fgkCH + fgkVspace);
 734     if (iplan == 0) zpos += 0.25;  // To avoid overlaps !
 735     gMC->Gspos("UTCL",iplan+1         ,"UTI1", xpos,ypos,zpos,matrix[0],"ONLY");
 736     gMC->Gspos("UTCL",iplan+1+  kNplan,"UTI1",-xpos,ypos,zpos,matrix[1],"ONLY");
 737
 738   }
 739
 740   //
 741   // The power bars
 742   //
 743
 744   const Float_t kPWRwid  =  0.6;
 745   const Float_t kPWRhgt  =  4.5;
 746   const Float_t kPWRposx =  1.05;
 747   const Float_t kPWRposz =  0.9;
 748   const Int_t   kNparPWR = 3;
 749   Float_t parPWR[kNparPWR];
 750   parPWR[0] = kPWRwid/2.;
 751   parPWR[1] = fgkSlenTR1/2.;
 752   parPWR[2] = kPWRhgt/2.;
 753   gMC->Gsvolu("UTPW","BOX ",idtmed[1325-1],parPWR,kNparPWR);
 754
 755   for (iplan = 0; iplan < kNplan; iplan++) { // CHECK FOR OVERLAPS !!!
 756     //for (iplan = 1; iplan < kNplan; iplan++) {
 757
 758     xpos  = fCwidth[iplan]/2. + kPWRwid/2. + kPWRposx;
 759     ypos  = 0.0;
 760     zpos  = kPWRhgt/2. - fgkSheight/2. + kPWRposz + iplan * (fgkCH + fgkVspace);
 761     gMC->Gspos("UTPW",iplan+1         ,"UTI1", xpos,ypos,zpos,matrix[0],"ONLY");
 762     gMC->Gspos("UTPW",iplan+1+  kNplan,"UTI1",-xpos,ypos,zpos,matrix[1],"ONLY");
 763
 764   }
 765
 766   //
 767   // The volumes for the services at the chambers
 768   //
 769
 770   const Int_t kNparServ = 3;
 771   Float_t parServ[kNparServ];
 772
 773   for (icham = 0; icham < kNcham; icham++) {
 774     for (iplan = 0; iplan < kNplan; iplan++) {
 775     // Take out upper plane until TRD mothervolume is adjusted
 776     //for (iplan = 0; iplan < kNplan-1; iplan++) {
 777
 778       Int_t iDet = GetDetectorSec(iplan,icham);
 779
 780       sprintf(cTagV,"UU%02d",iDet);
 781       parServ[0] = fCwidth[iplan]/2.;
 782       parServ[1] = fClength[iplan][icham]/2. - fgkHspace/2.;
 783       parServ[2] = fgkVspace/2. - 0.742/2.;
 784       fChamberUUboxd[iDet][0] = parServ[0];
 785       fChamberUUboxd[iDet][1] = parServ[1];
 786       fChamberUUboxd[iDet][2] = parServ[2];
 787
 788       gMC->Gsvolu(cTagV,"BOX",idtmed[1302-1],parServ,kNparServ);
 789       xpos  = 0.;
 790       ypos  = - fClength[iplan][0] - fClength[iplan][1] - fClength[iplan][2]/2.;
 791       for (Int_t ic = 0; ic < icham; ic++) {
 792         ypos += fClength[iplan][ic];
 793       }
 794       ypos += fClength[iplan][icham]/2.;
 795       zpos  = fgkCH + fgkVspace/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
 796       zpos -= 0.742/2.;
 797       fChamberUUorig[iDet][0] = xpos;
 798       fChamberUUorig[iDet][1] = ypos;
 799       fChamberUUorig[iDet][2] = zpos;
 800
 801     }
 802   }
 803
 804   //
 805   // The cooling pipes inside the service volumes
 806   //
 807
 808   const Int_t kNparTube = 3;
 809   Float_t parTube[kNparTube];
 810   // The aluminum pipe for the cooling
 811   parTube[0] = 0.0;
 812   parTube[1] = 0.0;
 813   parTube[2] = 0.0;
 814   gMC->Gsvolu("UTCP","TUBE",idtmed[1324-1],parTube,0);
 815   // The cooling water
 816   parTube[0] =  0.0;
 817   parTube[1] =  0.2/2.;
 818   parTube[2] = -1.;
 819   gMC->Gsvolu("UTCH","TUBE",idtmed[1314-1],parTube,kNparTube);
 820   // Water inside the cooling pipe
 821   xpos = 0.0;
 822   ypos = 0.0;
 823   zpos = 0.0;
 824   gMC->Gspos("UTCH",1,"UTCP",xpos,ypos,zpos,0,"ONLY");
 825
 826   // Position the cooling pipes in the mother volume
 827   const Int_t kNpar = 3;
 828   Float_t par[kNpar];
 829   for (icham = 0; icham < kNcham;   icham++) {
 830     for (iplan = 0; iplan < kNplan; iplan++) {
 831     // Take out upper plane until TRD mothervolume is adjusted
 832     //for (iplan = 0; iplan < kNplan-1; iplan++) {
 833       Int_t   iDet    = GetDetectorSec(iplan,icham);
 834       Int_t   iCopy   = GetDetector(iplan,icham,0) * 100;
 835       Int_t   nMCMrow = commonParam->GetRowMax(iplan,icham,0);
 836       Float_t ySize   = (GetChamberLength(iplan,icham) - 2.*fgkRpadW)
 837                       / ((Float_t) nMCMrow);
 838       sprintf(cTagV,"UU%02d",iDet);
 839       for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
 840         xpos   = 0.0;
 841         ypos   = (0.5 + iMCMrow) * ySize - 1.9
 842                - fClength[iplan][icham]/2. + fgkHspace/2.;
 843         zpos   = 0.0 + 0.742/2.;
 844         par[0] = 0.0;
 845         par[1] = 0.3/2.; // Thickness of the cooling pipes
 846         par[2] = fCwidth[iplan]/2.;
 847         gMC->Gsposp("UTCP",iCopy+iMCMrow,cTagV,xpos,ypos,zpos
 848                           ,matrix[2],"ONLY",par,kNpar);
 849       }
 850     }
 851   }
 852
 853   //
 854   // The power lines
 855   //
 856
 857   // The copper power lines
 858   parTube[0] = 0.0;
 859   parTube[1] = 0.0;
 860   parTube[2] = 0.0;
 861   gMC->Gsvolu("UTPL","TUBE",idtmed[1305-1],parTube,0);
 862
 863   // Position the power lines in the mother volume
 864   for (icham = 0; icham < kNcham;   icham++) {
 865     for (iplan = 0; iplan < kNplan; iplan++) {
 866     // Take out upper plane until TRD mothervolume is adjusted
 867     //for (iplan = 0; iplan < kNplan-1; iplan++) {
 868       Int_t   iDet    = GetDetectorSec(iplan,icham);
 869       Int_t   iCopy   = GetDetector(iplan,icham,0) * 100;
 870       Int_t   nMCMrow = commonParam->GetRowMax(iplan,icham,0);
 871       Float_t ySize   = (GetChamberLength(iplan,icham) - 2.*fgkRpadW)
 872                       / ((Float_t) nMCMrow);
 873       sprintf(cTagV,"UU%02d",iDet);
 874       for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
 875         xpos   = 0.0;
 876         ypos   = (0.5 + iMCMrow) * ySize - 1.0
 877                - fClength[iplan][icham]/2. + fgkHspace/2.;
 878         zpos   = -0.4 + 0.742/2.;
 879         par[0] = 0.0;
 880         par[1] = 0.2/2.; // Thickness of the power lines
 881         par[2] = fCwidth[iplan]/2.;
 882         gMC->Gsposp("UTPL",iCopy+iMCMrow,cTagV,xpos,ypos,zpos
 883                           ,matrix[2],"ONLY",par,kNpar);
 884       }
 885     }
 886   }
 887
 888   //
 889   // The MCMs
 890   //
 891
 892   // The mother volume for the MCMs (air)
 893   const Int_t kNparMCM = 3;
 894   Float_t parMCM[kNparMCM];
 895   parMCM[0] = 3.0/2.;
 896   parMCM[1] = 3.0/2.;
 897   parMCM[2] = 0.14/2.;
 898   gMC->Gsvolu("UMCM","BOX",idtmed[1302-1],parMCM,kNparMCM);
 899
 900   // The MCM carrier G10 layer
 901   parMCM[0] = 3.0/2.;
 902   parMCM[1] = 3.0/2.;
 903   parMCM[2] = 0.1/2.;
 904   gMC->Gsvolu("UMC1","BOX",idtmed[1319-1],parMCM,kNparMCM);
 905   // The MCM carrier Cu layer
 906   parMCM[0] = 3.0/2.;
 907   parMCM[1] = 3.0/2.;
 908   parMCM[2] = 0.0162/2.;
 909   gMC->Gsvolu("UMC2","BOX",idtmed[1318-1],parMCM,kNparMCM);
 910   // The silicon of the chips
 911   parMCM[0] = 3.0/2.;
 912   parMCM[1] = 3.0/2.;
 913   parMCM[2] = 0.003/2.;
 914   gMC->Gsvolu("UMC3","BOX",idtmed[1320-1],parMCM,kNparMCM);
 915
 916   // Put the MCM material inside the MCM mother volume
 917   xpos  =  0.0;
 918   ypos  =  0.0;
 919   zpos  = -0.07      + 0.1/2.;
 920   gMC->Gspos("UMC1",1,"UMCM",xpos,ypos,zpos,0,"ONLY");
 921   zpos +=  0.1/2.    + 0.0162/2.;
 922   gMC->Gspos("UMC2",1,"UMCM",xpos,ypos,zpos,0,"ONLY");
 923   zpos +=  0.00162/2 + 0.003/2.;
 924   gMC->Gspos("UMC3",1,"UMCM",xpos,ypos,zpos,0,"ONLY");
 925
 926   // Position the MCMs in the mother volume
 927   for (icham = 0; icham < kNcham;   icham++) {
 928     for (iplan = 0; iplan < kNplan; iplan++) {
 929     // Take out upper plane until TRD mothervolume is adjusted
 930     //for (iplan = 0; iplan < kNplan-1; iplan++) {
 931       Int_t   iDet    = GetDetectorSec(iplan,icham);
 932       Int_t   iCopy   = GetDetector(iplan,icham,0) * 1000;
 933       Int_t   nMCMrow = commonParam->GetRowMax(iplan,icham,0);
 934       Float_t ySize   = (GetChamberLength(iplan,icham) - 2.*fgkRpadW)
 935                       / ((Float_t) nMCMrow);
 936       Int_t   nMCMcol = 8;
 937       Float_t xSize   = (GetChamberWidth(iplan) - 2.* fgkCpadW)
 938                       / ((Float_t) nMCMcol);
 939       sprintf(cTagV,"UU%02d",iDet);
 940       for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
 941         for (Int_t iMCMcol = 0; iMCMcol < nMCMcol; iMCMcol++) {
 942           xpos   = (0.5 + iMCMcol) * xSize + 1.0
 943                  - fCwidth[iplan]/2.;
 944           ypos   = (0.5 + iMCMrow) * ySize + 1.0
 945                  - fClength[iplan][icham]/2. + fgkHspace/2.;
 946           zpos   = -0.4 + 0.742/2.;
 947           par[0] = 0.0;
 948           par[1] = 0.2/2.; // Thickness of the power lines
 949           par[2] = fCwidth[iplan]/2.;
 950           gMC->Gspos("UMCM",iCopy+iMCMrow*10+iMCMcol,cTagV
 951                            ,xpos,ypos,zpos,0,"ONLY");
 952         }
 953       }
 954
 955     }
 956   }
 957
 958 }
 959
 960 //_____________________________________________________________________________
 961 void AliTRDgeometry::GroupChamber(Int_t iplan, Int_t icham, Int_t *idtmed)
 962 {
 963   //
 964   // Group volumes UA, UD, UF, UU in a single chamber (Air)
 965   // UA, UD, UF, UU are boxes
 966   // UT will be a box
 967   //
 968   // ... for the moment there are no services (UU) for the upper plane !
 969   //
 970
 971   const Int_t kNparCha = 3;
 972
 973   Int_t iDet = GetDetectorSec(iplan,icham);
 974
 975   Float_t xyzMin[3];
 976   Float_t xyzMax[3];
 977   Float_t xyzOrig[3];
 978   Float_t xyzBoxd[3];
 979
 980   Char_t  cTagV[5];
 981   Char_t  cTagM[5];
 982
 983   for (Int_t i = 0; i < 3; i++) {
 984     xyzMin[i] = +9999; xyzMax[i] = -9999;
 985   }
 986
 987   for (Int_t i = 0; i < 3; i++) {
 988
 989     xyzMin[i] = TMath::Min(xyzMin[i],fChamberUAorig[iDet][i]-fChamberUAboxd[iDet][i]);
 990     xyzMax[i] = TMath::Max(xyzMax[i],fChamberUAorig[iDet][i]+fChamberUAboxd[iDet][i]);
 991
 992     xyzMin[i] = TMath::Min(xyzMin[i],fChamberUDorig[iDet][i]-fChamberUDboxd[iDet][i]);
 993     xyzMax[i] = TMath::Max(xyzMax[i],fChamberUDorig[iDet][i]+fChamberUDboxd[iDet][i]);
 994
 995     xyzMin[i] = TMath::Min(xyzMin[i],fChamberUForig[iDet][i]-fChamberUFboxd[iDet][i]);
 996     xyzMax[i] = TMath::Max(xyzMax[i],fChamberUForig[iDet][i]+fChamberUFboxd[iDet][i]);
 997
 998     // CBL
 999     //if (iplan < (kNplan-1)) {
1000       xyzMin[i] = TMath::Min(xyzMin[i],fChamberUUorig[iDet][i]-fChamberUUboxd[iDet][i]);
1001       xyzMax[i] = TMath::Max(xyzMax[i],fChamberUUorig[iDet][i]+fChamberUUboxd[iDet][i]);
1002       //}
1003
1004     xyzOrig[i] = 0.5*(xyzMax[i]+xyzMin[i]);
1005     xyzBoxd[i] = 0.5*(xyzMax[i]-xyzMin[i]);
1006
1007   }
1008
1009   sprintf(cTagM,"UT%02d",iDet);
1010
1011   gMC->Gsvolu(cTagM,"BOX ",idtmed[1302-1],xyzBoxd,kNparCha);
1012
1013   sprintf(cTagV,"UA%02d",iDet);
1014   gMC->Gspos(cTagV,1,cTagM,
1015              fChamberUAorig[iDet][0]-xyzOrig[0],
1016              fChamberUAorig[iDet][1]-xyzOrig[1],
1017              fChamberUAorig[iDet][2]-xyzOrig[2],
1018              0,"ONLY");
1019
1020   sprintf(cTagV,"UD%02d",iDet);
1021   gMC->Gspos(cTagV,1,cTagM,
1022              fChamberUDorig[iDet][0]-xyzOrig[0],
1023              fChamberUDorig[iDet][1]-xyzOrig[1],
1024              fChamberUDorig[iDet][2]-xyzOrig[2],
1025              0,"ONLY");
1026
1027   sprintf(cTagV,"UF%02d",iDet);
1028   gMC->Gspos(cTagV,1,cTagM,
1029              fChamberUForig[iDet][0]-xyzOrig[0],
1030              fChamberUForig[iDet][1]-xyzOrig[1],
1031              fChamberUForig[iDet][2]-xyzOrig[2],
1032              0,"ONLY");
1033
1034   // CBL
1035   //if (iplan < (kNplan-1)) {
1036     sprintf(cTagV,"UU%02d",iDet);
1037     gMC->Gspos(cTagV,1,cTagM,
1038                fChamberUUorig[iDet][0]-xyzOrig[0],
1039                fChamberUUorig[iDet][1]-xyzOrig[1],
1040                fChamberUUorig[iDet][2]-xyzOrig[2],
1041                0,"ONLY");
1042
1043     // }
1044
1045   sprintf(cTagV,"UT%02d",iDet);
1046   gMC->Gspos(cTagV,1,"UTI1",xyzOrig[0],xyzOrig[1],xyzOrig[2],0,"ONLY");
1047
1048 }
1049
1050 //_____________________________________________________________________________
1051 Bool_t AliTRDgeometry::Local2Global(Int_t idet, Double_t *local
1052                                    , Double_t *global) const
1053 {
1054   //
1055   // Converts local pad-coordinates (row,col,time) into
1056   // global ALICE reference frame coordinates (x,y,z)
1057   //
1058
1059   Int_t icham = GetChamber(idet);    // Chamber info (0-4)
1060   Int_t isect = GetSector(idet);     // Sector info  (0-17)
1061   Int_t iplan = GetPlane(idet);      // Plane info   (0-5)
1062
1063   return Local2Global(iplan,icham,isect,local,global);
1064
1065 }
1066
1067 //_____________________________________________________________________________
1068 Bool_t AliTRDgeometry::Local2Global(Int_t iplan, Int_t icham, Int_t isect
1069                                   , Double_t *local, Double_t *global) const
1070 {
1071   //
1072   // Converts local pad-coordinates (row,col,time) into
1073   // global ALICE reference frame coordinates (x,y,z)
1074   //
1075
1076   AliTRDCommonParam* commonParam = AliTRDCommonParam::Instance();
1077   if (!commonParam)
1078     return kFALSE;
1079
1080   AliTRDcalibDB* calibration = AliTRDcalibDB::Instance();
1081   if (!calibration)
1082     return kFALSE;
1083
1084   AliTRDpadPlane *padPlane = commonParam->GetPadPlane(iplan,icham);
1085
1086   // calculate (x,y,z) position in rotated chamber
1087   Int_t    row       = ((Int_t) local[0]);
1088   Int_t    col       = ((Int_t) local[1]);
1089   Float_t  timeSlice = local[2] + 0.5;
1090   Float_t  time0     = GetTime0(iplan);
1091
1092   Int_t idet = GetDetector(iplan, icham, isect);
1093
1094   Double_t  rot[3];
1095   rot[0] = time0 - (timeSlice - calibration->GetT0(idet, col, row))
1096       * calibration->GetVdrift(idet, col, row)/calibration->GetSamplingFrequency();
1097   rot[1] = padPlane->GetColPos(col) - 0.5 * padPlane->GetColSize(col);
1098   rot[2] = padPlane->GetRowPos(row) - 0.5 * padPlane->GetRowSize(row);
1099
1100   // Rotate back to original position
1101   return RotateBack(idet,rot,global);
1102
1103 }
1104
1105 //_____________________________________________________________________________
1106 Bool_t AliTRDgeometry::Global2Local(Int_t mode, Double_t *local, Double_t *global
1107                                   , Int_t* index) const
1108 {
1109   //
1110   // Converts local pad-coordinates (row,col,time) into
1111   // global ALICE reference frame coordinates (x,y,z)
1112   //
1113   // index[0] = plane number
1114   // index[1] = chamber number
1115   // index[2] = sector number
1116   //
1117   // mode=0  - local coordinate in y, z,             x - rotated global
1118   // mode=2  - local coordinate in pad, and pad row, x - rotated global
1119   //
1120
1121   Int_t idet = GetDetector(index[0],index[1],index[2]); // Detector number
1122   RotateBack(idet,global,local);
1123   if (mode == 0) return kTRUE;
1124
1125   return kTRUE;
1126
1127 }
1128
1129 //_____________________________________________________________________________
1130 Bool_t AliTRDgeometry::Global2Detector(Double_t global[3], Int_t index[3])
1131 {
1132   //
1133   //  Find detector for given global point - Ideal geometry
1134   //
1135   //
1136   // input    = global position
1137   // output   = index
1138   // index[0] = plane number
1139   // index[1] = chamber number
1140   // index[2] = sector number
1141   //
1142
1143   //
1144   // Find sector
1145   //
1146   Float_t fi = TMath::ATan2(global[1],global[0]);
1147   if (fi < 0) {
1148     fi += 2*TMath::Pi();
1149   }
1150   index[2] = fgkNsect - 1 - TMath::Nint((fi - GetAlpha()/2.)/GetAlpha());
1151
1152   //
1153   // Find plane
1154   //
1155   Float_t locx = global[0] * fRotA11[index[2]] + global[1] * fRotA12[index[2]];
1156   index[0] = 0;
1157   Float_t max = locx - GetTime0(0);
1158   for (Int_t iplane=1; iplane<fgkNplan;iplane++){
1159     Float_t dist = TMath::Abs(locx - GetTime0(iplane));
1160     if (dist < max){
1161       index[0] = iplane;
1162       max = dist;
1163     }
1164   }
1165
1166   //
1167   // Find chamber
1168   //
1169   if (TMath::Abs(global[2]) < 0.5*GetChamberLength(index[0],2)){
1170     index[1]=2;
1171   }
1172   else{
1173     Double_t localZ = global[2];
1174     if (global[2] > 0){
1175       localZ -= 0.5*(GetChamberLength(index[0],2)+GetChamberLength(index[0],1));
1176       index[1] = (TMath::Abs(localZ) < 0.5*GetChamberLength(index[0],3)) ? 1:0;
1177     }
1178     else{
1179       localZ += 0.5*(GetChamberLength(index[0],2)+GetChamberLength(index[0],3));
1180       index[1] = (TMath::Abs(localZ) < 0.5*GetChamberLength(index[0],1)) ? 3:4;
1181     }
1182   }
1183
1184   return kTRUE;
1185
1186 }
1187
1188 //_____________________________________________________________________________
1189 Bool_t AliTRDgeometry::Rotate(Int_t d, Double_t *pos, Double_t *rot) const
1190 {
1191   //
1192   // Rotates all chambers in the position of sector 0 and transforms
1193   // the coordinates in the ALICE restframe <pos> into the
1194   // corresponding local frame <rot>.
1195   //
1196
1197   Int_t sector = GetSector(d);
1198
1199   rot[0] =  pos[0] * fRotA11[sector] + pos[1] * fRotA12[sector];
1200   rot[1] = -pos[0] * fRotA21[sector] + pos[1] * fRotA22[sector];
1201   rot[2] =  pos[2];
1202
1203   return kTRUE;
1204
1205 }
1206
1207 //_____________________________________________________________________________
1208 Bool_t AliTRDgeometry::RotateBack(Int_t d, Double_t *rot, Double_t *pos) const
1209 {
1210   //
1211   // Rotates a chambers from the position of sector 0 into its
1212   // original position and transforms the corresponding local frame
1213   // coordinates <rot> into the coordinates of the ALICE restframe <pos>.
1214   //
1215
1216   Int_t sector = GetSector(d);
1217
1218   pos[0] =  rot[0] * fRotB11[sector] + rot[1] * fRotB12[sector];
1219   pos[1] = -rot[0] * fRotB21[sector] + rot[1] * fRotB22[sector];
1220   pos[2] =  rot[2];
1221
1222   return kTRUE;
1223
1224 }
1225
1226 //_____________________________________________________________________________
1227 Int_t AliTRDgeometry::GetDetectorSec(Int_t p, Int_t c)
1228 {
1229   //
1230   // Convert plane / chamber into detector number for one single sector
1231   //
1232
1233   return (p + c * fgkNplan);
1234
1235 }
1236
1237 //_____________________________________________________________________________
1238 Int_t AliTRDgeometry::GetDetector(Int_t p, Int_t c, Int_t s)
1239 {
1240   //
1241   // Convert plane / chamber / sector into detector number
1242   //
1243
1244   return (p + c * fgkNplan + s * fgkNplan * fgkNcham);
1245
1246 }
1247
1248 //_____________________________________________________________________________
1249 Int_t AliTRDgeometry::GetPlane(Int_t d) const
1250 {
1251   //
1252   // Reconstruct the plane number from the detector number
1253   //
1254
1255   return ((Int_t) (d % fgkNplan));
1256
1257 }
1258
1259 //_____________________________________________________________________________
1260 Int_t AliTRDgeometry::GetChamber(Int_t d) const
1261 {
1262   //
1263   // Reconstruct the chamber number from the detector number
1264   //
1265
1266   return ((Int_t) (d % (fgkNplan * fgkNcham)) / fgkNplan);
1267
1268 }
1269
1270 //_____________________________________________________________________________
1271 Int_t AliTRDgeometry::GetSector(Int_t d) const
1272 {
1273   //
1274   // Reconstruct the sector number from the detector number
1275   //
1276
1277   return ((Int_t) (d / (fgkNplan * fgkNcham)));
1278
1279 }
1280
1281 //_____________________________________________________________________________
1282 AliTRDgeometry* AliTRDgeometry::GetGeometry(AliRunLoader* runLoader)
1283 {
1284   //
1285   // load the geometry from the galice file
1286   //
1287
1288   if (!runLoader) runLoader = AliRunLoader::GetRunLoader();
1289   if (!runLoader) {
1290     ::Error("AliTRDgeometry::GetGeometry", "No run loader");
1291     return NULL;
1292   }
1293
1294   TDirectory* saveDir = gDirectory;
1295   runLoader->CdGAFile();
1296
1297   // Try from the galice.root file
1298   AliTRDgeometry* geom = (AliTRDgeometry*) gDirectory->Get("TRDgeometry");
1299
1300   if (!geom) {
1301     // It is not in the file, try to get it from gAlice,
1302     // which corresponds to the run loader
1303     AliTRD * trd = (AliTRD*)runLoader->GetAliRun()->GetDetector("TRD");
1304     geom = trd->GetGeometry();
1305   }
1306   if (!geom) ::Error("AliTRDgeometry::GetGeometry", "Geometry not found");
1307
1308   saveDir->cd();
1309   return geom;
1310
1311 }
1312
1313 //_____________________________________________________________________________
1314 Bool_t AliTRDgeometry::ReadGeoMatrices()
1315 {
1316   //
1317   // Read geo matrices from current gGeoManager for each TRD sector
1318   //
1319
1320   if (!gGeoManager) return kFALSE;
1321   fMatrixArray = new TObjArray(kNdet);
1322   fMatrixCorrectionArray = new TObjArray(kNdet);
1323   fMatrixGeo   = new TObjArray(kNdet);
1324   AliAlignObjAngles o;
1325
1326   for (Int_t iLayer = AliAlignObj::kTRD1; iLayer <= AliAlignObj::kTRD6; iLayer++) {
1327     for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer); iModule++) {
1328       UShort_t volid = AliAlignObj::LayerToVolUID(iLayer,iModule);
1329       const char *path = AliAlignObj::GetVolPath(volid);
1330       if (!gGeoManager->cd(path)) return kFALSE;
1331       TGeoHMatrix* m = gGeoManager->GetCurrentMatrix();
1332       Int_t     iLayerTRD    = iLayer-AliAlignObj::kTRD1;
1333       Int_t     isector      = Nsect()-1-(iModule/Ncham());
1334       Int_t     ichamber     = Ncham()-1-(iModule%Ncham());
1335       Int_t     lid          = GetDetector(iLayerTRD,ichamber,isector);
1336
1337       //
1338       // local geo system z-x-y  to x-y--z
1339       //
1340       fMatrixGeo->AddAt(new TGeoHMatrix(*m),lid);
1341
1342       TGeoRotation mchange;
1343       mchange.RotateY(90); mchange.RotateX(90);
1344
1345       TGeoHMatrix gMatrix(mchange.Inverse());
1346       gMatrix.MultiplyLeft(m);
1347       fMatrixArray->AddAt(new TGeoHMatrix(gMatrix),lid);
1348
1349       //
1350       //  Cluster transformation matrix
1351       //
1352       TGeoHMatrix  rotMatrix(mchange.Inverse());
1353       rotMatrix.MultiplyLeft(m);
1354       Double_t sectorAngle = 20.*(isector%18)+10;
1355       TGeoHMatrix  rotSector;
1356       rotSector.RotateZ(sectorAngle);
1357       rotMatrix.MultiplyLeft(&rotSector);
1358
1359       fMatrixCorrectionArray->AddAt(new TGeoHMatrix(rotMatrix),lid);
1360
1361     }
1362   }
1363
1364   return kTRUE;
1365
1366 }
1367