PHOS/AliPHOSv0.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 /* $Id$ */
  16
  17 /* History of cvs commits:
  18  *
  19  * $Log$
  20  * Revision 1.91  2007/07/02 14:50:49  policheh
  21  * Tracking2LocalCS matrices corrected.
  22  *
  23  * Revision 1.90  2007/05/24 13:04:05  policheh
  24  * AddAlignableVolumes: local to tracking CS transformation matrices creates for each
  25  * PHOS supermodule
  26  *
  27  * Revision 1.89  2007/04/24 14:34:39  hristov
  28  * Additional protection: do not search for alignable object if the CPV is not in the geometry
  29  *
  30  * Revision 1.88  2007/04/19 15:28:30  kharlov
  31  * Modify strip unit geometry according to the final drawings (Timur)
  32  *
  33  * Revision 1.87  2007/04/01 07:37:10  kharlov
  34  * TGeo RS to Local RS transf matr added
  35  *
  36  * Revision 1.86  2007/03/06 06:55:46  kharlov
  37  * DP:Misalignment of CPV added
  38  *
  39  * Revision 1.85  2007/03/01 11:37:37  kharlov
  40  * Strip units changed from 8x1 to 8x2 (T.Pocheptsov)
  41  *
  42  * Revision 1.84  2006/12/20 16:56:43  kharlov
  43  * Optional geometry without CPV
  44  *
  45  * Revision 1.83  2006/11/14 17:11:15  hristov
  46  * Removing inheritances from TAttLine, TAttMarker and AliRndm in AliModule. The copy constructor and assignment operators are moved to the private part of the class and not implemented. The corresponding changes are propagated to the detectors
  47  *
  48  * Revision 1.82  2006/09/27 19:55:57  kharlov
  49  * Alignment object with symbolic volume names are introduced
  50  *
  51  * Revision 1.81  2006/03/04 20:25:56  kharlov
  52  * Set geom parameters from CDB
  53  *
  54  * Revision 1.80  2005/06/17 07:39:07  hristov
  55  * Removing GetDebug and SetDebug from AliRun and AliModule. Using AliLog for the messages
  56  *
  57  * Revision 1.79  2005/05/28 14:19:05  schutz
  58  * Compilation warnings fixed by T.P.
  59  *
  60  */
  61
  62 //_________________________________________________________________________
  63 // Implementation version v0 of PHOS Manager class
  64 // An object of this class does not produce hits nor digits
  65 // It is the one to use if you do not want to produce outputs in TREEH or TREED
  66 //
  67 //*-- Author: Yves Schutz (SUBATECH) & Dmitri Peressounko (RRC KI & SUBATECH)
  68
  69
  70 // --- ROOT system ---
  71
  72 #include <TBRIK.h>
  73 #include <TFolder.h>
  74 #include <TGeometry.h>
  75 #include <TNode.h>
  76 #include <TROOT.h>
  77 #include <TRandom.h>
  78 #include <TTRD1.h>
  79 #include <TTree.h>
  80 #include <TVirtualMC.h>
  81 #include <TGeoPhysicalNode.h>
  82 #include <TGeoManager.h>
  83 #include <TVector3.h>
  84
  85 // --- Standard library ---
  86
  87 #include <string.h>
  88 #include <stdlib.h>
  89
  90 // --- AliRoot header files ---
  91
  92 #include "AliConst.h"
  93 #include "AliPHOSGeometry.h"
  94 #include "AliPHOSLoader.h"
  95 #include "AliPHOSv0.h"
  96 #include "AliRun.h"
  97 #include "AliLog.h"
  98
  99 ClassImp(AliPHOSv0)
 100
 101 //____________________________________________________________________________
 102 AliPHOSv0::AliPHOSv0(const char *name, const char *title):
 103   AliPHOS(name,title)
 104 {
 105   // ctor : title is used to identify the layout
 106   GetGeometry() ;
 107 }
 108
 109 //____________________________________________________________________________
 110 void AliPHOSv0::BuildGeometry()
 111 {
 112   // Build the PHOS geometry for the ROOT display
 113   //BEGIN_HTML
 114   /*
 115     <H2>
 116      PHOS in ALICE displayed by root
 117     </H2>
 118     <UL>
 119     <LI> All Views
 120     <P>
 121     <CENTER>
 122     <IMG Align=BOTTOM ALT="All Views" SRC="../images/AliPHOSv0AllViews.gif">
 123     </CENTER></P></LI>
 124     <LI> Front View
 125     <P>
 126     <CENTER>
 127     <IMG Align=BOTTOM ALT="Front View" SRC="../images/AliPHOSv0FrontView.gif">
 128     </CENTER></P></LI>
 129      <LI> 3D View 1
 130     <P>
 131     <CENTER>
 132     <IMG Align=BOTTOM ALT="3D View 1" SRC="../images/AliPHOSv03DView1.gif">
 133     </CENTER></P></LI>
 134     <LI> 3D View 2
 135     <P>
 136     <CENTER>
 137     <IMG Align=BOTTOM ALT="3D View 2" SRC="../images/AliPHOSv03DView2.gif">
 138     </CENTER></P></LI>
 139     </UL>
 140   */
 141   //END_HTML
 142
 143   this->BuildGeometryforEMC() ;
 144   this->BuildGeometryforCPV() ;
 145
 146 }
 147
 148 //____________________________________________________________________________
 149 void AliPHOSv0:: BuildGeometryforEMC(void)
 150 {
 151   // Build the PHOS-EMC geometry for the ROOT display
 152
 153   const Int_t kColorPHOS = kRed ;
 154   const Int_t kColorXTAL = kBlue ;
 155
 156   Double_t const kRADDEG = 180.0 / TMath::Pi() ;
 157
 158   AliPHOSGeometry * geom = GetGeometry() ;
 159   AliPHOSEMCAGeometry * emcg = geom->GetEMCAGeometry() ;
 160   Float_t * boxparams = emcg->GetEMCParams() ;
 161
 162   new TTRD1("OuterBox", "PHOS box", "void",boxparams[0],boxparams[1],boxparams[2], boxparams[3] );
 163
 164
 165   // Crystals Box
 166
 167   Float_t * cribox = emcg->GetInnerThermoHalfSize() ;
 168   new TBRIK( "CrystalsBox", "PHOS crystals box", "void", cribox[0], cribox[2], cribox[1] ) ;
 169
 170   // position PHOS into ALICE
 171
 172   Float_t r = geom->GetIPtoOuterCoverDistance() + boxparams[3] ;
 173   Int_t number = 988 ;
 174   TNode * top = gAlice->GetGeometry()->GetNode("alice") ;
 175
 176   char * nodename = new char[20] ;
 177   char * rotname  = new char[20] ;
 178
 179   new TRotMatrix("cribox", "cribox", 90, 0, 90, 90, 0, 0);
 180
 181   for( Int_t i = 1; i <= geom->GetNModules(); i++ ) {
 182
 183     Float_t angle = geom->GetPHOSAngle(i) ;
 184     sprintf(rotname, "%s%d", "rot", number++) ;
 185     new TRotMatrix(rotname, rotname, 90, angle, 0,  0,  90,  270 + angle);
 186
 187     top->cd();
 188     sprintf(nodename,"%s%d", "Module", i) ;
 189     Float_t x =  r * TMath::Sin( angle / kRADDEG ) ;
 190     Float_t y = -r * TMath::Cos( angle / kRADDEG ) ;
 191     TNode * outerboxnode = new TNode(nodename, nodename, "OuterBox", x, y, 0, rotname ) ;
 192     outerboxnode->SetLineColor(kColorPHOS) ;
 193     fNodes->Add(outerboxnode) ;
 194     outerboxnode->cd() ;
 195
 196     Float_t z = -boxparams[3] - geom->GetIPtoOuterCoverDistance() +
 197                  cribox[1] +  geom->GetIPtoCrystalSurface() ;
 198     TNode * crystalsboxnode = new TNode(nodename, nodename, "CrystalsBox", 0, 0, z) ;
 199     crystalsboxnode->SetLineColor(kColorXTAL) ;
 200     fNodes->Add(crystalsboxnode) ;
 201   }
 202
 203   delete[] rotname ;
 204   delete[] nodename ;
 205 }
 206
 207
 208 //____________________________________________________________________________
 209 void AliPHOSv0:: BuildGeometryforCPV(void)
 210 {
 211   //  Build the PHOS-CPV geometry for the ROOT display
 212   //  Author: Yuri Kharlov 11 September 2000
 213   //
 214   //BEGIN_HTML
 215   /*
 216     <H2>
 217     CPV displayed by root
 218     </H2>
 219     <table width=700>
 220
 221     <tr>
 222          <td>CPV perspective view</td>
 223          <td>CPV front view      </td>
 224     </tr>
 225
 226     <tr>
 227          <td> <img height=300 width=290 src="../images/CPVRootPersp.gif"> </td>
 228          <td> <img height=300 width=290 src="../images/CPVRootFront.gif"> </td>
 229     </tr>
 230
 231     </table>
 232
 233   */
 234   //END_HTML
 235
 236   const Double_t kRADDEG         = 180.0 / TMath::Pi() ;
 237   const Int_t    kColorCPV       = kGreen ;
 238   const Int_t    kColorFrame     = kYellow ;
 239   const Int_t    kColorGassiplex = kRed;
 240   const Int_t    kColorPCB       = kCyan;
 241
 242   AliPHOSGeometry * geom = GetGeometry() ;
 243
 244   // Box for a full PHOS module
 245
 246   new TBRIK ("CPVBox", "CPV box", "void",                   geom->GetCPVBoxSize(0)/2,
 247                                                             geom->GetCPVBoxSize(1)/2,
 248                                                             geom->GetCPVBoxSize(2)/2 );
 249   new TBRIK ("CPVFrameLR", "CPV frame Left-Right", "void",  geom->GetCPVFrameSize(0)/2,
 250                                                             geom->GetCPVFrameSize(1)/2,
 251                                                             geom->GetCPVBoxSize(2)/2 );
 252   new TBRIK ("CPVFrameUD", "CPV frame Up-Down",    "void",  geom->GetCPVBoxSize(0)/2 - geom->GetCPVFrameSize(0),
 253                                                             geom->GetCPVFrameSize(1)/2,
 254                                                             geom->GetCPVFrameSize(2)/2);
 255   new TBRIK ("CPVPCB",    "CPV PCB",               "void",  geom->GetCPVActiveSize(0)/2,
 256                                                             geom->GetCPVTextoliteThickness()/2,
 257                                                             geom->GetCPVActiveSize(1)/2);
 258   new TBRIK ("CPVGassiplex", "CPV Gassiplex PCB",  "void",  geom->GetGassiplexChipSize(0)/2,
 259                                                             geom->GetGassiplexChipSize(1)/2,
 260                                                             geom->GetGassiplexChipSize(2)/2);
 261
 262   // position CPV into ALICE
 263
 264   char * nodename = new char[25] ;
 265   char * rotname  = new char[25] ;
 266
 267   Float_t r = geom->GetIPtoCPVDistance() + geom->GetCPVBoxSize(1) / 2.0 ;
 268   Int_t number = 988 ;
 269   TNode * top = gAlice->GetGeometry()->GetNode("alice") ;
 270
 271   Int_t lastModule = 0 ;
 272   lastModule = geom->GetNModules();
 273
 274   for( Int_t i = 1; i <= lastModule; i++ ) { // the number of PHOS modules
 275
 276     // One CPV module
 277
 278     Float_t angle = geom->GetPHOSAngle(i) ;
 279     sprintf(rotname, "%s%d", "rotg", number+i) ;
 280     new TRotMatrix(rotname, rotname, 90, angle, 90, 90 + angle, 0, 0);
 281     top->cd();
 282     sprintf(nodename, "%s%d", "CPVModule", i) ;
 283     Float_t x =  r * TMath::Sin( angle / kRADDEG ) ;
 284     Float_t y = -r * TMath::Cos( angle / kRADDEG ) ;
 285     Float_t z;
 286     TNode * cpvBoxNode = new TNode(nodename , nodename ,"CPVBox", x, y, 0, rotname ) ;
 287     cpvBoxNode->SetLineColor(kColorCPV) ;
 288     fNodes->Add(cpvBoxNode) ;
 289     cpvBoxNode->cd() ;
 290
 291     // inside each CPV box:
 292
 293     // Frame around CPV
 294     Int_t j;
 295     for (j=0; j<=1; j++) {
 296       sprintf(nodename, "CPVModule%d Frame%d", i, j+1) ;
 297       x = TMath::Sign(1,2*j-1) * (geom->GetCPVBoxSize(0) - geom->GetCPVFrameSize(0)) / 2;
 298       TNode * cpvFrameNode = new TNode(nodename , nodename ,"CPVFrameLR", x, 0, 0) ;
 299       cpvFrameNode->SetLineColor(kColorFrame) ;
 300       fNodes->Add(cpvFrameNode) ;
 301
 302       sprintf(nodename, "CPVModule%d Frame%d", i, j+3) ;
 303       z = TMath::Sign(1,2*j-1) * (geom->GetCPVBoxSize(2) - geom->GetCPVFrameSize(2)) / 2;
 304       cpvFrameNode = new TNode(nodename , nodename ,"CPVFrameUD", 0, 0, z) ;
 305       cpvFrameNode->SetLineColor(kColorFrame) ;
 306       fNodes->Add(cpvFrameNode) ;
 307     }
 308
 309     // 4 printed circuit boards
 310     for (j=0; j<4; j++) {
 311       sprintf(nodename, "CPVModule%d PCB%d", i, j+1) ;
 312       y = geom->GetCPVFrameSize(1) / 2 - geom->GetFTPosition(j) + geom->GetCPVTextoliteThickness()/2;
 313       TNode * cpvPCBNode = new TNode(nodename , nodename ,"CPVPCB", 0, y, 0) ;
 314       cpvPCBNode->SetLineColor(kColorPCB) ;
 315       fNodes->Add(cpvPCBNode) ;
 316     }
 317
 318     // Gassiplex chips
 319     Float_t xStep = geom->GetCPVActiveSize(0) / (geom->GetNumberOfCPVChipsPhi() + 1);
 320     Float_t zStep = geom->GetCPVActiveSize(1) / (geom->GetNumberOfCPVChipsZ()   + 1);
 321     y = geom->GetCPVFrameSize(1)/2           - geom->GetFTPosition(0) +
 322         geom->GetCPVTextoliteThickness() / 2 + geom->GetGassiplexChipSize(1) / 2 + 0.1;
 323     for (Int_t ix=0; ix<geom->GetNumberOfCPVChipsPhi(); ix++) {
 324       x = xStep * (ix+1) - geom->GetCPVActiveSize(0)/2;
 325       for (Int_t iz=0; iz<geom->GetNumberOfCPVChipsZ(); iz++) {
 326         z = zStep * (iz+1) - geom->GetCPVActiveSize(1)/2;
 327         sprintf(nodename, "CPVModule%d Chip(%dx%d)", i, ix+1,iz+1) ;
 328         TNode * cpvGassiplexNode = new TNode(nodename , nodename ,"CPVGassiplex", x, y, z) ;
 329         cpvGassiplexNode->SetLineColor(kColorGassiplex) ;
 330         fNodes->Add(cpvGassiplexNode) ;
 331       }
 332     }
 333
 334   } // PHOS modules
 335
 336   delete[] rotname ;
 337   delete[] nodename ;
 338 }
 339
 340 //____________________________________________________________________________
 341 void AliPHOSv0::CreateGeometry()
 342 {
 343   // Create the PHOS geometry for Geant
 344
 345   AliPHOSv0 *phostmp = dynamic_cast<AliPHOSv0*>(gAlice->GetModule("PHOS")) ;
 346
 347   if ( phostmp == NULL ) {
 348
 349     fprintf(stderr, "PHOS detector not found!\n") ;
 350     return;
 351
 352   }
 353
 354   AliPHOSGeometry * geom = GetGeometry() ;
 355
 356   // Get pointer to the array containing media indeces
 357   Int_t *idtmed = fIdtmed->GetArray() - 699 ;
 358
 359   // Create a PHOS module.
 360
 361   gMC->Gsvolu("PHOS", "TRD1", idtmed[798], geom->GetPHOSParams(), 4) ;
 362
 363   this->CreateGeometryforEMC() ;
 364
 365   if (strstr(fTitle.Data(),"noCPV") == 0)
 366     this->CreateGeometryforCPV() ;
 367
 368   this->CreateGeometryforSupport() ;
 369
 370   // --- Position  PHOS mdules in ALICE setup ---
 371
 372   Int_t idrotm[99] ;
 373   Int_t iXYZ,iAngle;
 374   for (Int_t iModule = 0; iModule < geom->GetNModules(); iModule++ ) {
 375
 376     Float_t angle[3][2];
 377     for (iXYZ=0; iXYZ<3; iXYZ++)
 378       for (iAngle=0; iAngle<2; iAngle++)
 379         angle[iXYZ][iAngle] = geom->GetModuleAngle(iModule,iXYZ, iAngle);
 380     AliMatrix(idrotm[iModule],
 381               angle[0][0],angle[0][1],
 382               angle[1][0],angle[1][1],
 383               angle[2][0],angle[2][1]) ;
 384
 385     Float_t pos[3];
 386     for (iXYZ=0; iXYZ<3; iXYZ++)
 387       pos[iXYZ] = geom->GetModuleCenter(iModule,iXYZ);
 388     gMC->Gspos("PHOS", iModule+1, "ALIC", pos[0], pos[1], pos[2],
 389                idrotm[iModule], "ONLY") ;
 390   }
 391
 392 }
 393
 394 //____________________________________________________________________________
 395 void AliPHOSv0::CreateGeometryforEMC()
 396 {
 397   // Create the PHOS-EMC geometry for GEANT
 398   // Author: Dmitri Peressounko August 2001
 399   // The used coordinate system:
 400   //   1. in Module: X along longer side, Y out of beam, Z along shorter side (along beam)
 401   //   2. In Strip the same: X along longer side, Y out of beam, Z along shorter side (along beam)
 402
 403
 404     //BEGIN_HTML
 405   /*
 406     <H2>
 407     Geant3 geometry tree of PHOS-EMC in ALICE
 408     </H2>
 409     <P><CENTER>
 410     <IMG Align=BOTTOM ALT="EMC geant tree" SRC="../images/EMCinAlice.gif">
 411     </CENTER><P>
 412   */
 413   //END_HTML
 414
 415   // Get pointer to the array containing media indexes
 416   Int_t *idtmed = fIdtmed->GetArray() - 699 ;
 417
 418   AliPHOSGeometry * geom = GetGeometry() ;
 419   AliPHOSEMCAGeometry * emcg = geom->GetEMCAGeometry() ;
 420
 421   // ======= Define the strip ===============
 422
 423   gMC->Gsvolu("PSTR", "BOX ", idtmed[716], emcg->GetStripHalfSize(), 3) ;  //Made of stell
 424
 425       // --- define steel volume (cell of the strip unit)
 426       gMC->Gsvolu("PCEL", "BOX ", idtmed[716], emcg->GetSteelCellHalfSize(), 3);
 427
 428       // --- define wrapped crystal and put it into steel cell
 429
 430       gMC->Gsvolu("PWRA", "BOX ", idtmed[702], emcg->GetWrappedHalfSize(), 3);
 431       Float_t * pin = emcg->GetAPDHalfSize() ;
 432       Float_t * preamp = emcg->GetPreampHalfSize() ;
 433       Float_t y = (emcg->GetAirGapLed()-2*pin[1]-2*preamp[1])/2;
 434       gMC->Gspos("PWRA", 1, "PCEL", 0.0, y, 0.0, 0, "ONLY") ;
 435
 436       // --- Define crystal and put it into wrapped crystall ---
 437       gMC->Gsvolu("PXTL", "BOX ", idtmed[699], emcg->GetCrystalHalfSize(), 3) ;
 438       gMC->Gspos("PXTL", 1, "PWRA", 0.0, 0.0, 0.0, 0, "ONLY") ;
 439
 440       // --- define APD/PIN preamp and put it into AirCell
 441
 442       gMC->Gsvolu("PPIN", "BOX ", idtmed[705], emcg->GetAPDHalfSize(), 3) ;
 443       Float_t * crystal = emcg->GetCrystalHalfSize() ;
 444       y = crystal[1] + emcg->GetAirGapLed() /2 - preamp[1];
 445       gMC->Gspos("PPIN", 1, "PCEL", 0.0, y, 0.0, 0, "ONLY") ;
 446
 447       gMC->Gsvolu("PREA", "BOX ", idtmed[711], emcg->GetPreampHalfSize(), 3) ;   // Here I assumed preamp
 448                                                                                  // as a printed Circuit
 449       y = crystal[1] + emcg->GetAirGapLed() /2 + pin[1]  ;                  // May it should be changed
 450       gMC->Gspos("PREA", 1, "PCEL", 0.0, y, 0.0, 0, "ONLY") ;                    // to ceramics?
 451
 452
 453       // --- Fill strip with wrapped cristals in steel cells
 454
 455       Float_t* splate = emcg->GetSupportPlateHalfSize();
 456       y = -splate[1] ;
 457       Float_t* acel = emcg->GetSteelCellHalfSize() ;
 458
 459       for(Int_t lev = 2, icel = 1; icel <= emcg->GetNCellsXInStrip()*emcg->GetNCellsZInStrip(); icel += 2, lev += 2){
 460          Float_t x = (2*(lev / 2) - 1 - emcg->GetNCellsXInStrip())* acel[0] ;
 461          Float_t z = acel[2];
 462          gMC->Gspos("PCEL", icel, "PSTR", x, y, +z, 0, "ONLY") ;
 463          gMC->Gspos("PCEL", icel + 1, "PSTR", x, y, -z, 0, "ONLY") ;
 464       }
 465
 466       // --- define the support plate, hole in it and position it in strip ----
 467       gMC->Gsvolu("PSUP", "BOX ", idtmed[701], emcg->GetSupportPlateHalfSize(), 3) ;
 468
 469       gMC->Gsvolu("PSHO", "BOX ", idtmed[798], emcg->GetSupportPlateInHalfSize(), 3) ;
 470       Float_t z = emcg->GetSupportPlateThickness()/2 ;
 471       gMC->Gspos("PSHO", 1, "PSUP", 0.0, 0.0, z, 0, "ONLY") ;
 472
 473       y = acel[1] ;
 474       gMC->Gspos("PSUP", 1, "PSTR", 0.0, y, 0.0, 0, "ONLY") ;
 475
 476
 477     // ========== Fill module with strips and put them into inner thermoinsulation=============
 478       gMC->Gsvolu("PTII", "BOX ", idtmed[706], emcg->GetInnerThermoHalfSize(), 3) ;
 479
 480       Float_t * inthermo = emcg->GetInnerThermoHalfSize() ;
 481       Float_t * strip = emcg->GetStripHalfSize() ;
 482       y = inthermo[1] - strip[1] ;
 483       Int_t irow;
 484       Int_t nr = 1 ;
 485       Int_t icol ;
 486
 487       for(irow = 0; irow < emcg->GetNStripX(); irow ++){
 488         Float_t x = (2*irow + 1 - emcg->GetNStripX())* strip[0] ;
 489         for(icol = 0; icol < emcg->GetNStripZ(); icol ++){
 490           z = (2*icol + 1 - emcg->GetNStripZ()) * strip[2] ;
 491           gMC->Gspos("PSTR", nr, "PTII", x, y, z, 0, "ONLY") ;
 492           nr++ ;
 493         }
 494       }
 495
 496
 497    // ------- define the air gap between thermoinsulation and cooler
 498       gMC->Gsvolu("PAGA", "BOX ", idtmed[798], emcg->GetAirGapHalfSize(), 3) ;
 499       Float_t * agap = emcg->GetAirGapHalfSize() ;
 500       y = agap[1] - inthermo[1]  ;
 501
 502       gMC->Gspos("PTII", 1, "PAGA", 0.0, y, 0.0, 0, "ONLY") ;
 503
 504
 505
 506    // ------- define the Al passive cooler
 507       gMC->Gsvolu("PCOR", "BOX ", idtmed[701], emcg->GetCoolerHalfSize(), 3) ;
 508       Float_t * cooler = emcg->GetCoolerHalfSize() ;
 509       y = cooler[1] - agap[1]  ;
 510
 511       gMC->Gspos("PAGA", 1, "PCOR", 0.0, y, 0.0, 0, "ONLY") ;
 512
 513    // ------- define the outer thermoinsulating cover
 514       gMC->Gsvolu("PTIO", "TRD1", idtmed[706], emcg->GetOuterThermoParams(), 4) ;
 515       Float_t * outparams = emcg->GetOuterThermoParams() ;
 516
 517       Int_t idrotm[99] ;
 518       AliMatrix(idrotm[1], 90.0, 0.0, 0.0, 0.0, 90.0, 270.0) ;
 519       // Frame in outer thermoinsulation and so on: z out of beam, y along beam, x across beam
 520
 521       z = outparams[3] - cooler[1] ;
 522       gMC->Gspos("PCOR", 1, "PTIO", 0., 0.0, z, idrotm[1], "ONLY") ;
 523
 524   // -------- Define the outer Aluminium cover -----
 525       gMC->Gsvolu("PCOL", "TRD1", idtmed[701], emcg->GetAlCoverParams(), 4) ;
 526       Float_t * covparams = emcg->GetAlCoverParams() ;
 527       z = covparams[3] - outparams[3] ;
 528       gMC->Gspos("PTIO", 1, "PCOL", 0., 0.0, z, 0, "ONLY") ;
 529
 530  // --------- Define front fiberglass cover -----------
 531       gMC->Gsvolu("PFGC", "BOX ", idtmed[717], emcg->GetFiberGlassHalfSize(), 3) ;
 532       z = - outparams[3] ;
 533       gMC->Gspos("PFGC", 1, "PCOL", 0., 0.0, z, 0, "ONLY") ;
 534
 535  //=============This is all with cold section==============
 536
 537
 538       //------ Warm Section --------------
 539       gMC->Gsvolu("PWAR", "BOX ", idtmed[701], emcg->GetWarmAlCoverHalfSize(), 3) ;
 540       Float_t * warmcov = emcg->GetWarmAlCoverHalfSize() ;
 541
 542       // --- Define the outer thermoinsulation ---
 543       gMC->Gsvolu("PWTI", "BOX ", idtmed[706], emcg->GetWarmThermoHalfSize(), 3) ;
 544       Float_t * warmthermo = emcg->GetWarmThermoHalfSize() ;
 545       z = -warmcov[2] + warmthermo[2] ;
 546
 547       gMC->Gspos("PWTI", 1, "PWAR", 0., 0.0, z, 0, "ONLY") ;
 548
 549       // --- Define cables area and put in it T-supports ----
 550       gMC->Gsvolu("PCA1", "BOX ", idtmed[718], emcg->GetTCables1HalfSize(), 3) ;
 551       Float_t * cbox = emcg->GetTCables1HalfSize() ;
 552
 553       gMC->Gsvolu("PBE1", "BOX ", idtmed[701], emcg->GetTSupport1HalfSize(), 3) ;
 554       Float_t * beams = emcg->GetTSupport1HalfSize() ;
 555       Int_t isup ;
 556       for(isup = 0; isup < emcg->GetNTSuppots(); isup++){
 557         Float_t x = -cbox[0] + beams[0] + (2*beams[0]+emcg->GetTSupportDist())*isup ;
 558         gMC->Gspos("PBE1", isup, "PCA1", x, 0.0, 0.0, 0, "ONLY") ;
 559       }
 560
 561       z = -warmthermo[2] + cbox[2] ;
 562       gMC->Gspos("PCA1", 1, "PWTI", 0.0, 0.0, z, 0, "ONLY") ;
 563
 564       gMC->Gsvolu("PCA2", "BOX ", idtmed[718], emcg->GetTCables2HalfSize(), 3) ;
 565       Float_t * cbox2 = emcg->GetTCables2HalfSize() ;
 566
 567       gMC->Gsvolu("PBE2", "BOX ", idtmed[701], emcg->GetTSupport2HalfSize(), 3) ;
 568       for(isup = 0; isup < emcg->GetNTSuppots(); isup++){
 569         Float_t x = -cbox[0] + beams[0] + (2*beams[0]+emcg->GetTSupportDist())*isup ;
 570         gMC->Gspos("PBE2", isup, "PCA2", x, 0.0, 0.0, 0, "ONLY") ;
 571       }
 572
 573       z = -warmthermo[2] + 2*cbox[2] + cbox2[2];
 574       gMC->Gspos("PCA2", 1, "PWTI", 0.0, 0.0, z, 0, "ONLY") ;
 575
 576
 577   // --- Define frame ---
 578       gMC->Gsvolu("PFRX", "BOX ", idtmed[716], emcg->GetFrameXHalfSize(), 3) ;
 579       Float_t * posit = emcg->GetFrameXPosition() ;
 580       gMC->Gspos("PFRX", 1, "PWTI", posit[0],  posit[1], posit[2], 0, "ONLY") ;
 581       gMC->Gspos("PFRX", 2, "PWTI", posit[0], -posit[1], posit[2], 0, "ONLY") ;
 582
 583       gMC->Gsvolu("PFRZ", "BOX ", idtmed[716], emcg->GetFrameZHalfSize(), 3) ;
 584       posit = emcg->GetFrameZPosition() ;
 585       gMC->Gspos("PFRZ", 1, "PWTI", posit[0], posit[1],  posit[2], 0, "ONLY") ;
 586       gMC->Gspos("PFRZ", 2, "PWTI", -posit[0], posit[1], posit[2], 0, "ONLY") ;
 587
 588  // --- Define Fiber Glass support ---
 589       gMC->Gsvolu("PFG1", "BOX ", idtmed[717], emcg->GetFGupXHalfSize(), 3) ;
 590       posit = emcg->GetFGupXPosition() ;
 591       gMC->Gspos("PFG1", 1, "PWTI", posit[0],  posit[1], posit[2], 0, "ONLY") ;
 592       gMC->Gspos("PFG1", 2, "PWTI", posit[0], -posit[1], posit[2], 0, "ONLY") ;
 593
 594       gMC->Gsvolu("PFG2", "BOX ", idtmed[717], emcg->GetFGupZHalfSize(), 3) ;
 595       posit = emcg->GetFGupZPosition() ;
 596       gMC->Gspos("PFG2", 1, "PWTI",  posit[0], posit[1], posit[2], 0, "ONLY") ;
 597       gMC->Gspos("PFG2", 2, "PWTI", -posit[0], posit[1], posit[2], 0, "ONLY") ;
 598
 599       gMC->Gsvolu("PFG3", "BOX ", idtmed[717], emcg->GetFGlowXHalfSize(), 3) ;
 600       posit = emcg->GetFGlowXPosition() ;
 601       gMC->Gspos("PFG3", 1, "PWTI", posit[0],  posit[1], posit[2], 0, "ONLY") ;
 602       gMC->Gspos("PFG3", 2, "PWTI", posit[0], -posit[1], posit[2], 0, "ONLY") ;
 603
 604       gMC->Gsvolu("PFG4", "BOX ", idtmed[717], emcg->GetFGlowZHalfSize(), 3) ;
 605       posit = emcg->GetFGlowZPosition() ;
 606       gMC->Gspos("PFG4", 1, "PWTI",  posit[0], posit[1], posit[2], 0, "ONLY") ;
 607       gMC->Gspos("PFG4", 2, "PWTI", -posit[0], posit[1], posit[2], 0, "ONLY") ;
 608
 609       // --- Define Air Gap for FEE electronics -----
 610
 611       gMC->Gsvolu("PAFE", "BOX ", idtmed[798], emcg->GetFEEAirHalfSize(), 3) ;
 612       posit = emcg->GetFEEAirPosition() ;
 613       gMC->Gspos("PAFE", 1, "PWTI",  posit[0], posit[1], posit[2], 0, "ONLY") ;
 614
 615       // Define the EMC module volume and combine Cool and Warm sections
 616
 617       gMC->Gsvolu("PEMC", "TRD1", idtmed[798], emcg->GetEMCParams(), 4) ;
 618
 619       z =  - warmcov[2] ;
 620       gMC->Gspos("PCOL", 1, "PEMC",  0., 0., z, 0, "ONLY") ;
 621       z = covparams[3] ;
 622       gMC->Gspos("PWAR", 1, "PEMC",  0., 0., z, 0, "ONLY") ;
 623
 624
 625       // Put created EMC geometry into PHOS volume
 626
 627       z = geom->GetCPVBoxSize(1) / 2. ;
 628       gMC->Gspos("PEMC", 1, "PHOS", 0., 0., z, 0, "ONLY") ;
 629
 630 }
 631
 632 //____________________________________________________________________________
 633 void AliPHOSv0::CreateGeometryforCPV()
 634 {
 635   // Create the PHOS-CPV geometry for GEANT
 636   // Author: Yuri Kharlov 11 September 2000
 637   //BEGIN_HTML
 638   /*
 639     <H2>
 640     Geant3 geometry of PHOS-CPV in ALICE
 641     </H2>
 642     <table width=700>
 643
 644     <tr>
 645          <td>CPV perspective view</td>
 646          <td>CPV front view      </td>
 647     </tr>
 648
 649     <tr>
 650          <td> <img height=300 width=290 src="../images/CPVallPersp.gif"> </td>
 651          <td> <img height=300 width=290 src="../images/CPVallFront.gif"> </td>
 652     </tr>
 653
 654     <tr>
 655          <td>One CPV module, perspective view                            </td>
 656          <td>One CPV module, front view (extended in vertical direction) </td>
 657     </tr>
 658
 659     <tr>
 660          <td><img height=300 width=290 src="../images/CPVmodulePers.gif"></td>
 661          <td><img height=300 width=290 src="../images/CPVmoduleSide.gif"></td>
 662     </tr>
 663
 664     </table>
 665
 666     <H2>
 667     Geant3 geometry tree of PHOS-CPV in ALICE
 668     </H2>
 669     <center>
 670     <img height=300 width=290 src="../images/CPVtree.gif">
 671     </center>
 672   */
 673   //END_HTML
 674
 675   Float_t par[3], x,y,z;
 676
 677   // Get pointer to the array containing media indexes
 678   Int_t *idtmed = fIdtmed->GetArray() - 699 ;
 679
 680   AliPHOSGeometry * geom = GetGeometry() ;
 681
 682   // The box containing all CPV for one PHOS module filled with air
 683   par[0] = geom->GetCPVBoxSize(0) / 2.0 ;
 684   par[1] = geom->GetCPVBoxSize(1) / 2.0 ;
 685   par[2] = geom->GetCPVBoxSize(2) / 2.0 ;
 686   gMC->Gsvolu("PCPV", "BOX ", idtmed[798], par, 3) ;
 687
 688   Float_t * emcParams = geom->GetEMCAGeometry()->GetEMCParams() ;
 689   z = - emcParams[3] ;
 690   Int_t rotm ;
 691   AliMatrix(rotm, 90.,0., 0., 0., 90., 90.) ;
 692
 693   gMC->Gspos("PCPV", 1, "PHOS", 0.0, 0.0, z, rotm, "ONLY") ;
 694
 695   // Gassiplex board
 696
 697   par[0] = geom->GetGassiplexChipSize(0)/2.;
 698   par[1] = geom->GetGassiplexChipSize(1)/2.;
 699   par[2] = geom->GetGassiplexChipSize(2)/2.;
 700   gMC->Gsvolu("PCPC","BOX ",idtmed[707],par,3);
 701
 702   // Cu+Ni foil covers Gassiplex board
 703
 704   par[1] = geom->GetCPVCuNiFoilThickness()/2;
 705   gMC->Gsvolu("PCPD","BOX ",idtmed[710],par,3);
 706   y      = -(geom->GetGassiplexChipSize(1)/2 - par[1]);
 707   gMC->Gspos("PCPD",1,"PCPC",0,y,0,0,"ONLY");
 708
 709   // Position of the chip inside CPV
 710
 711   Float_t xStep = geom->GetCPVActiveSize(0) / (geom->GetNumberOfCPVChipsPhi() + 1);
 712   Float_t zStep = geom->GetCPVActiveSize(1) / (geom->GetNumberOfCPVChipsZ()   + 1);
 713   Int_t   copy  = 0;
 714   y = geom->GetCPVFrameSize(1)/2           - geom->GetFTPosition(0) +
 715     geom->GetCPVTextoliteThickness() / 2 + geom->GetGassiplexChipSize(1) / 2 + 0.1;
 716   for (Int_t ix=0; ix<geom->GetNumberOfCPVChipsPhi(); ix++) {
 717     x = xStep * (ix+1) - geom->GetCPVActiveSize(0)/2;
 718     for (Int_t iz=0; iz<geom->GetNumberOfCPVChipsZ(); iz++) {
 719       copy++;
 720       z = zStep * (iz+1) - geom->GetCPVActiveSize(1)/2;
 721       gMC->Gspos("PCPC",copy,"PCPV",x,y,z,0,"ONLY");
 722     }
 723   }
 724
 725   // Foiled textolite (1 mm of textolite + 50 mkm of Cu + 6 mkm of Ni)
 726
 727   par[0] = geom->GetCPVActiveSize(0)        / 2;
 728   par[1] = geom->GetCPVTextoliteThickness() / 2;
 729   par[2] = geom->GetCPVActiveSize(1)        / 2;
 730   gMC->Gsvolu("PCPF","BOX ",idtmed[707],par,3);
 731
 732   // Argon gas volume
 733
 734   par[1] = (geom->GetFTPosition(2) - geom->GetFTPosition(1) - geom->GetCPVTextoliteThickness()) / 2;
 735   gMC->Gsvolu("PCPG","BOX ",idtmed[715],par,3);
 736
 737   for (Int_t i=0; i<4; i++) {
 738     y = geom->GetCPVFrameSize(1) / 2 - geom->GetFTPosition(i) + geom->GetCPVTextoliteThickness()/2;
 739     gMC->Gspos("PCPF",i+1,"PCPV",0,y,0,0,"ONLY");
 740     if(i==1){
 741       y-= (geom->GetFTPosition(2) - geom->GetFTPosition(1)) / 2;
 742       gMC->Gspos("PCPG",1,"PCPV ",0,y,0,0,"ONLY");
 743     }
 744   }
 745
 746   // Dummy sensitive plane in the middle of argone gas volume
 747
 748   par[1]=0.001;
 749   gMC->Gsvolu("PCPQ","BOX ",idtmed[715],par,3);
 750   gMC->Gspos ("PCPQ",1,"PCPG",0,0,0,0,"ONLY");
 751
 752   // Cu+Ni foil covers textolite
 753
 754   par[1] = geom->GetCPVCuNiFoilThickness() / 2;
 755   gMC->Gsvolu("PCP1","BOX ",idtmed[710],par,3);
 756   y = geom->GetCPVTextoliteThickness()/2 - par[1];
 757   gMC->Gspos ("PCP1",1,"PCPF",0,y,0,0,"ONLY");
 758
 759   // Aluminum frame around CPV
 760
 761   par[0] = geom->GetCPVFrameSize(0)/2;
 762   par[1] = geom->GetCPVFrameSize(1)/2;
 763   par[2] = geom->GetCPVBoxSize(2)  /2;
 764   gMC->Gsvolu("PCF1","BOX ",idtmed[701],par,3);
 765
 766   par[0] = geom->GetCPVBoxSize(0)/2 - geom->GetCPVFrameSize(0);
 767   par[1] = geom->GetCPVFrameSize(1)/2;
 768   par[2] = geom->GetCPVFrameSize(2)/2;
 769   gMC->Gsvolu("PCF2","BOX ",idtmed[701],par,3);
 770
 771   for (Int_t j=0; j<=1; j++) {
 772     x = TMath::Sign(1,2*j-1) * (geom->GetCPVBoxSize(0) - geom->GetCPVFrameSize(0)) / 2;
 773     gMC->Gspos("PCF1",j+1,"PCPV", x,0,0,0,"ONLY");
 774     z = TMath::Sign(1,2*j-1) * (geom->GetCPVBoxSize(2) - geom->GetCPVFrameSize(2)) / 2;
 775     gMC->Gspos("PCF2",j+1,"PCPV",0, 0,z,0,"ONLY");
 776   }
 777
 778 }
 779
 780
 781 //____________________________________________________________________________
 782 void AliPHOSv0::CreateGeometryforSupport()
 783 {
 784   // Create the PHOS' support geometry for GEANT
 785     //BEGIN_HTML
 786   /*
 787     <H2>
 788     Geant3 geometry of the PHOS's support
 789     </H2>
 790     <P><CENTER>
 791     <IMG Align=BOTTOM ALT="EMC geant tree" SRC="../images/PHOS_support.gif">
 792     </CENTER><P>
 793   */
 794   //END_HTML
 795
 796   Float_t par[5], x0,y0,z0 ;
 797   Int_t   i,j,copy;
 798
 799   // Get pointer to the array containing media indexes
 800   Int_t *idtmed = fIdtmed->GetArray() - 699 ;
 801
 802   AliPHOSGeometry * geom = GetGeometry() ;
 803
 804   // --- Dummy box containing two rails on which PHOS support moves
 805   // --- Put these rails to the bottom of the L3 magnet
 806
 807   par[0] =  geom->GetRailRoadSize(0) / 2.0 ;
 808   par[1] =  geom->GetRailRoadSize(1) / 2.0 ;
 809   par[2] =  geom->GetRailRoadSize(2) / 2.0 ;
 810   gMC->Gsvolu("PRRD", "BOX ", idtmed[798], par, 3) ;
 811
 812   y0     = -(geom->GetRailsDistanceFromIP() - geom->GetRailRoadSize(1) / 2.0) ;
 813   gMC->Gspos("PRRD", 1, "ALIC", 0.0, y0, 0.0, 0, "ONLY") ;
 814
 815   // --- Dummy box containing one rail
 816
 817   par[0] =  geom->GetRailOuterSize(0) / 2.0 ;
 818   par[1] =  geom->GetRailOuterSize(1) / 2.0 ;
 819   par[2] =  geom->GetRailOuterSize(2) / 2.0 ;
 820   gMC->Gsvolu("PRAI", "BOX ", idtmed[798], par, 3) ;
 821
 822   for (i=0; i<2; i++) {
 823     x0     = (2*i-1) * geom->GetDistanceBetwRails()  / 2.0 ;
 824     gMC->Gspos("PRAI", i, "PRRD", x0, 0.0, 0.0, 0, "ONLY") ;
 825   }
 826
 827   // --- Upper and bottom steel parts of the rail
 828
 829   par[0] =  geom->GetRailPart1(0) / 2.0 ;
 830   par[1] =  geom->GetRailPart1(1) / 2.0 ;
 831   par[2] =  geom->GetRailPart1(2) / 2.0 ;
 832   gMC->Gsvolu("PRP1", "BOX ", idtmed[716], par, 3) ;
 833
 834   y0     = - (geom->GetRailOuterSize(1) - geom->GetRailPart1(1))  / 2.0 ;
 835   gMC->Gspos("PRP1", 1, "PRAI", 0.0, y0, 0.0, 0, "ONLY") ;
 836   y0     =   (geom->GetRailOuterSize(1) - geom->GetRailPart1(1))  / 2.0 - geom->GetRailPart3(1);
 837   gMC->Gspos("PRP1", 2, "PRAI", 0.0, y0, 0.0, 0, "ONLY") ;
 838
 839   // --- The middle vertical steel parts of the rail
 840
 841   par[0] =  geom->GetRailPart2(0) / 2.0 ;
 842   par[1] =  geom->GetRailPart2(1) / 2.0 ;
 843   par[2] =  geom->GetRailPart2(2) / 2.0 ;
 844   gMC->Gsvolu("PRP2", "BOX ", idtmed[716], par, 3) ;
 845
 846   y0     =   - geom->GetRailPart3(1) / 2.0 ;
 847   gMC->Gspos("PRP2", 1, "PRAI", 0.0, y0, 0.0, 0, "ONLY") ;
 848
 849   // --- The most upper steel parts of the rail
 850
 851   par[0] =  geom->GetRailPart3(0) / 2.0 ;
 852   par[1] =  geom->GetRailPart3(1) / 2.0 ;
 853   par[2] =  geom->GetRailPart3(2) / 2.0 ;
 854   gMC->Gsvolu("PRP3", "BOX ", idtmed[716], par, 3) ;
 855
 856   y0     =   (geom->GetRailOuterSize(1) - geom->GetRailPart3(1))  / 2.0 ;
 857   gMC->Gspos("PRP3", 1, "PRAI", 0.0, y0, 0.0, 0, "ONLY") ;
 858
 859   // --- The wall of the cradle
 860   // --- The wall is empty: steel thin walls and air inside
 861
 862   par[1] =  TMath::Sqrt(TMath::Power((geom->GetIPtoCPVDistance() + geom->GetOuterBoxSize(3)),2) +
 863                         TMath::Power((geom->GetOuterBoxSize(1)/2),2))+10. ;
 864   par[0] =  par[1] - geom->GetCradleWall(1) ;
 865   par[2] =  geom->GetCradleWall(2) / 2.0 ;
 866   par[3] =  geom->GetCradleWall(3) ;
 867   par[4] =  geom->GetCradleWall(4) ;
 868   gMC->Gsvolu("PCRA", "TUBS", idtmed[716], par, 5) ;
 869
 870   par[0] +=  geom->GetCradleWallThickness() ;
 871   par[1] -=  geom->GetCradleWallThickness() ;
 872   par[2] -=  geom->GetCradleWallThickness() ;
 873   gMC->Gsvolu("PCRE", "TUBS", idtmed[798], par, 5) ;
 874   gMC->Gspos ("PCRE", 1, "PCRA", 0.0, 0.0, 0.0, 0, "ONLY") ;
 875
 876   for (i=0; i<2; i++) {
 877     z0 = (2*i-1) * (geom->GetOuterBoxSize(2) + geom->GetCradleWall(2) )/ 2.0  ;
 878         gMC->Gspos("PCRA", i, "ALIC", 0.0, 0.0, z0, 0, "ONLY") ;
 879   }
 880
 881   // --- The "wheels" of the cradle
 882
 883   par[0] = geom->GetCradleWheel(0) / 2;
 884   par[1] = geom->GetCradleWheel(1) / 2;
 885   par[2] = geom->GetCradleWheel(2) / 2;
 886   gMC->Gsvolu("PWHE", "BOX ", idtmed[716], par, 3) ;
 887
 888   y0 = -(geom->GetRailsDistanceFromIP() - geom->GetRailRoadSize(1) -
 889          geom->GetCradleWheel(1)/2) ;
 890   for (i=0; i<2; i++) {
 891     z0 = (2*i-1) * ((geom->GetOuterBoxSize(2) + geom->GetCradleWheel(2))/ 2.0 +
 892                     geom->GetCradleWall(2));
 893     for (j=0; j<2; j++) {
 894       copy = 2*i + j;
 895       x0 = (2*j-1) * geom->GetDistanceBetwRails()  / 2.0 ;
 896       gMC->Gspos("PWHE", copy, "ALIC", x0, y0, z0, 0, "ONLY") ;
 897     }
 898   }
 899
 900 }
 901
 902 //_____________________________________________________________________________
 903 void AliPHOSv0::AddAlignableVolumes() const
 904 {
 905   //
 906   // Create entries for alignable volumes associating the symbolic volume
 907   // name with the corresponding volume path. Needs to be syncronized with
 908   // eventual changes in the geometry
 909   // Alignable volumes are:
 910   // 1) PHOS modules as a whole
 911   // 2) Cradle
 912   // 3) Cradle wheels
 913   // 4) Strip units (group of 2x8 crystals)
 914
 915   TString volpath, symname;
 916
 917   // Alignable modules
 918   // Volume path /ALIC_1/PHOS_<i> => symbolic name /PHOS/Module<i>, <i>=1,2,3,4,5
 919
 920   TString physModulePath="/ALIC_1/PHOS_";
 921   TString symbModuleName="PHOS/Module";
 922   Int_t nModules = GetGeometry()->GetNModules();
 923
 924   for(Int_t iModule=1; iModule<=nModules; iModule++){
 925     volpath = physModulePath;
 926     volpath += iModule;
 927     volpath += "/PEMC_1/PCOL_1/PTIO_1/PCOR_1/PAGA_1/PTII_1";
 928
 929     symname = symbModuleName;
 930     symname += iModule;
 931     gGeoManager->SetAlignableEntry(symname.Data(),volpath.Data());
 932
 933     // Creates the Tracking to Local transformation matrix for PHOS modules
 934     TGeoPNEntry *alignableEntry = gGeoManager->GetAlignableEntry(symname.Data()) ;
 935     const char *path = alignableEntry->GetTitle();
 936     if (!gGeoManager->cd(path))
 937        AliFatal(Form("Volume path %s not valid!",path));
 938
 939     Float_t angle = GetGeometry()->GetPHOSAngle(iModule);
 940     TGeoHMatrix* globMatrix = gGeoManager->GetCurrentMatrix();
 941
 942     TGeoHMatrix *matTtoL = new TGeoHMatrix;
 943     matTtoL->RotateZ(-90.+angle);
 944     matTtoL->MultiplyLeft(&(globMatrix->Inverse()));
 945     alignableEntry->SetMatrix(matTtoL);
 946   }
 947
 948   //Aligning of CPV should be done for volume PCPV_1
 949   symbModuleName="PHOS/Module";
 950   for(Int_t iModule=1; iModule<=nModules; iModule++){
 951     volpath = physModulePath;
 952     volpath += iModule;
 953     volpath += "/PCPV_1";
 954     // Check the volume path
 955     if (!gGeoManager->CheckPath(volpath.Data())) {
 956       AliError(Form("Volume path %s not valid!",volpath.Data()));
 957       continue;
 958     }
 959
 960     symname = symbModuleName;
 961     symname += iModule;
 962     symname += "/CPV";
 963     gGeoManager->SetAlignableEntry(symname.Data(),volpath.Data());
 964
 965     // Creates the TGeo Local to Tracking transformation matrix ...
 966     TGeoPNEntry *alignableEntry = gGeoManager->GetAlignableEntry(symname.Data()) ;
 967     const char *path = alignableEntry->GetTitle();
 968     if (!gGeoManager->cd(path))
 969        AliFatal(Form("Volume path %s not valid!",path));
 970
 971     Float_t angle = GetGeometry()->GetPHOSAngle(iModule);
 972     TGeoHMatrix* globMatrix = gGeoManager->GetCurrentMatrix();
 973
 974     TGeoHMatrix *matTtoL = new TGeoHMatrix;
 975     matTtoL->RotateZ(-90.+angle);
 976     matTtoL->MultiplyLeft(&(globMatrix->Inverse()));
 977     alignableEntry->SetMatrix(matTtoL);
 978
 979   }
 980
 981
 982   // Alignable cradle walls
 983   // Volume path /ALIC_1/PCRA_<i> => symbolic name /PHOS/Cradle<i>, <i>=0,1
 984
 985   TString physCradlePath="/ALIC_1/PCRA_";
 986   TString symbCradleName="PHOS/Cradle";
 987   Int_t nCradles = 2;
 988
 989   for(Int_t iCradle=0; iCradle<nCradles; iCradle++){
 990     volpath = physCradlePath;
 991     volpath += iCradle;
 992     symname = symbCradleName;
 993     symname += iCradle;
 994     gGeoManager->SetAlignableEntry(symname.Data(),volpath.Data());
 995   }
 996
 997   // Alignable wheels
 998   // Volume path /ALIC_1/PWHE_<i> => symbolic name /PHOS/Wheel<i>, i=0,1,2,3
 999
1000   TString physWheelPath="/ALIC_1/PWHE_";
1001   TString symbWheelName="PHOS/Wheel";
1002   Int_t nWheels = 4;
1003
1004   for(Int_t iWheel=0; iWheel<nWheels; iWheel++){
1005     volpath = physWheelPath;
1006     volpath += iWheel;
1007     symname = symbWheelName;
1008     symname += iWheel;
1009     gGeoManager->SetAlignableEntry(symname.Data(),volpath.Data());
1010   }
1011
1012   //Physical strip path is a combination of: physModulePath + module number +
1013   //physStripPath + strip number == ALIC_1/PHOS_N/..../PSTR_M
1014   const Int_t nStripsX = GetGeometry()->GetEMCAGeometry()->GetNStripX();
1015   const Int_t nStripsZ = GetGeometry()->GetEMCAGeometry()->GetNStripZ();
1016   TString partialPhysStripName(100);
1017   TString fullPhysStripName(100);
1018   TString partialSymbStripName(100);
1019   TString fullSymbStripName(100);
1020
1021   for(Int_t module = 1; module <= nModules; ++module){
1022     partialPhysStripName  = physModulePath;
1023     partialPhysStripName += module;
1024     partialPhysStripName += "/PEMC_1/PCOL_1/PTIO_1/PCOR_1/PAGA_1/PTII_1/PSTR_";
1025
1026     partialSymbStripName  = symbModuleName;
1027     partialSymbStripName += module;
1028     partialSymbStripName += "/Strip_";
1029
1030     for(Int_t i = 0, ind1D = 1; i < nStripsX; ++i){//ind1D starts from 1 (PSTR_1...PSTR_224...)
1031       for(Int_t j = 0; j < nStripsZ; ++j, ++ind1D){
1032          fullPhysStripName = partialPhysStripName;
1033          fullPhysStripName += ind1D;
1034
1035          fullSymbStripName  = partialSymbStripName;
1036          fullSymbStripName += i;//ind1D;
1037          fullSymbStripName += '_';
1038          fullSymbStripName += j;
1039
1040          gGeoManager->SetAlignableEntry(fullSymbStripName.Data(), fullPhysStripName.Data());
1041
1042          // Creates the TGeo Local to Tracking transformation matrix ...
1043          TGeoPNEntry *alignableEntry = gGeoManager->GetAlignableEntry(fullSymbStripName.Data()) ;
1044          const char *path = alignableEntry->GetTitle();
1045          if (!gGeoManager->cd(path))
1046            AliFatal(Form("Volume path %s not valid!",path));
1047          TGeoHMatrix matLtoT = *gGeoManager->GetCurrentMatrix() ;
1048          Double_t refl[3]={-1.,-1.,-1.} ;
1049          matLtoT.SetScale(refl) ;
1050          TGeoHMatrix *matTtoL = new TGeoHMatrix(matLtoT.Inverse());
1051
1052          char phosPath[50] ;
1053          sprintf(phosPath,"/ALIC_1/PHOS_%d",module) ;
1054          if (!gGeoManager->cd(phosPath)){
1055             AliFatal("Geo manager can not find path \n");
1056          }
1057          TGeoHMatrix *mPHOS = gGeoManager->GetCurrentMatrix();
1058          if (mPHOS)
1059            matTtoL->Multiply(mPHOS);
1060          else{
1061            AliFatal("Geo matrixes are not loaded \n") ;
1062          }
1063          //Switch y<->z
1064          Double_t rot[9]={1.,0.,0.,  0.,1.,0., 0.,0.,1.} ;
1065          matTtoL->SetRotation(rot) ;
1066          alignableEntry->SetMatrix(matTtoL);
1067
1068 /*
1069   //Check poisition of corner cell of the strip
1070   AliPHOSGeometry * geom = AliPHOSGeometry::GetInstance() ;
1071   Int_t relid[4] ;
1072   relid[0] = module ;
1073   relid[1] = 0 ;
1074   Int_t iStrip=ind1D ;
1075   Int_t icell=1 ;
1076   Int_t raw = geom->GetEMCAGeometry()->GetNCellsXInStrip()*((iStrip-1)/geom->GetEMCAGeometry()->GetNStripZ()) +
1077                 1 + (icell-1)/geom->GetEMCAGeometry()->GetNCellsZInStrip() ;
1078   Int_t col = geom->GetEMCAGeometry()->GetNCellsZInStrip()*(1+(iStrip-1)%geom->GetEMCAGeometry()->GetNStripZ()) -
1079                 (icell-1)%geom->GetEMCAGeometry()->GetNCellsZInStrip() ;
1080   if(col==0) col=geom->GetNZ() ;
1081   relid[2] = raw ;
1082   relid[3] = col ;
1083   Float_t xG,zG ;
1084   geom->RelPosInModule(relid, xG, zG) ;
1085 printf("============\n") ;
1086 printf("Geometry: x=%f, z=%f \n",xG,zG) ;
1087   Int_t absid ;
1088   geom->RelToAbsNumbering(relid,absid) ;
1089   Double_t pos[3]= {-2.2*3.5,0.0,1.1}; //Position incide the strip (Y coordinalte is not important)
1090   Double_t posC[3]={0.0,0.0,0.}; //Global position
1091
1092   matTtoL->MasterToLocal(pos,posC);
1093 printf("Matrix:   x=%f, z=%f, y=%f \n",posC[0],posC[2],posC[1]) ;
1094 */
1095       }
1096     }
1097   }
1098 }
1099
1100 //____________________________________________________________________________
1101 Float_t AliPHOSv0::ZMin(void) const
1102 {
1103   // Overall dimension of the PHOS (min)
1104
1105   AliPHOSGeometry * geom = GetGeometry() ;
1106
1107   return -geom->GetOuterBoxSize(2)/2.;
1108 }
1109
1110 //____________________________________________________________________________
1111 Float_t AliPHOSv0::ZMax(void) const
1112 {
1113   // Overall dimension of the PHOS (max)
1114
1115   AliPHOSGeometry * geom = GetGeometry() ;
1116
1117   return  geom->GetOuterBoxSize(2)/2.;
1118 }
1119
1120 //____________________________________________________________________________
1121 void AliPHOSv0::Init(void)
1122 {
1123   // Just prints an information message
1124
1125   Int_t i;
1126
1127   if(AliLog::GetGlobalDebugLevel()>0) {
1128     TString st ;
1129     for(i=0;i<35;i++)
1130       st += "*";
1131     Info("Init", "%s", st.Data()) ;
1132     // Here the PHOS initialisation code (if any!)
1133
1134     AliPHOSGeometry * geom = GetGeometry() ;
1135
1136     if (geom!=0)
1137       Info("Init", "AliPHOS%s: PHOS geometry intialized for %s", Version().Data(), geom->GetName()) ;
1138     else
1139       Info("Init", "AliPHOS%s: PHOS geometry initialization failed !", Version().Data()) ;
1140
1141     Info("Init", "%s", st.Data()) ;
1142   }
1143 }