EMCAL/AliEMCALGeometry.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 // Geometry class  for EMCAL : singleton
  20 // EMCAL consists of layers of scintillator and lead
  21 // Places the the Barrel Geometry of The EMCAL at Midrapidity
  22 // between 80 and 180(or 190) degrees of Phi and
  23 // -0.7 to 0.7 in eta
  24 // Number of Modules and Layers may be controlled by
  25 // the name of the instance defined
  26 //     EMCAL geometry tree:
  27 //     EMCAL -> superModule -> module -> tower(cell)
  28 //     Indexes
  29 //     absId -> nSupMod     -> nModule -> (nIphi,nIeta)
  30 //
  31 //*-- Author: Sahal Yacoob (LBL / UCT)
  32 //     and  : Yves Schutz (SUBATECH)
  33 //     and  : Jennifer Klay (LBL)
  34 //     SHASHLYK : Aleksei Pavlinov (WSU)
  35 //
  36
  37 #include <assert.h>
  38
  39 // --- AliRoot header files ---
  40 #include <Riostream.h>
  41 #include <TBrowser.h>
  42 #include <TClonesArray.h>
  43 #include <TGeoManager.h>
  44 #include <TGeoMatrix.h>
  45 #include <TGeoNode.h>
  46 #include <TMatrixD.h>
  47 #include <TObjArray.h>
  48 #include <TObjString.h>
  49 #include <TVector3.h>
  50
  51 // -- ALICE Headers.
  52 #include "AliLog.h"
  53
  54 // --- EMCAL headers
  55 #include "AliEMCALGeometry.h"
  56 #include "AliEMCALShishKebabTrd1Module.h"
  57 #include "AliEMCALRecPoint.h"
  58 #include "AliEMCALDigit.h"
  59 #include "AliEMCALHistoUtilities.h"
  60
  61 ClassImp(AliEMCALGeometry)
  62
  63 // these initialisations are needed for a singleton
  64 AliEMCALGeometry  *AliEMCALGeometry::fgGeom      = 0;
  65 Bool_t             AliEMCALGeometry::fgInit      = kFALSE;
  66 Char_t*            AliEMCALGeometry::fgDefaultGeometryName = "SHISH_77_TRD1_2X2_FINAL_110DEG";
  67 //
  68 // Usage:
  69 //        You can create the AliEMCALGeometry object independently from anything.
  70 //        You have to use just the correct name of geometry. If name is empty string the
  71 //        default name of geometry will be used.
  72 //
  73 //  AliEMCALGeometry* g = AliEMCALGeometry::GetInstance(name,title); // first time
  74 //  ..
  75 //  g = AliEMCALGeometry::GetInstance();                             // after first time
  76 //
  77
  78 AliEMCALGeometry::AliEMCALGeometry()
  79   : AliGeometry(),
  80     fGeoName(0),fArrayOpts(0),fAlFrontThick(0.),fECPbRadThickness(0.),fECScintThick(0.),
  81     fNECLayers(0),fArm1PhiMin(0.),fArm1PhiMax(0.),fArm1EtaMin(0.),fArm1EtaMax(0.),fIPDistance(0.),
  82     fShellThickness(0.),fZLength(0.),fGap2Active(0.),fNZ(0),fNPhi(0),fSampling(0.),fNumberOfSuperModules(0),
  83     fSteelFrontThick(0.),fFrontSteelStrip(0.),fLateralSteelStrip(0.),fPassiveScintThick(0.),fPhiModuleSize(0.),
  84     fEtaModuleSize(0.),fPhiTileSize(0.),fEtaTileSize(0.),fLongModuleSize(0.),fNPhiSuperModule(0),fNPHIdiv(0),fNETAdiv(0),
  85     fNCells(0),fNCellsInSupMod(0),fNCellsInModule(0),fNTRU(0),fNTRUEta(0),fNTRUPhi(0),fTrd1Angle(0.),f2Trd1Dx2(0.),
  86     fPhiGapForSM(0.),fKey110DEG(0),fPhiBoundariesOfSM(0), fPhiCentersOfSM(0),fEtaMaxOfTRD1(0),
  87     fTrd2AngleY(0.),f2Trd2Dy2(0.),fEmptySpace(0.),fTubsR(0.),fTubsTurnAngle(0.),fCentersOfCellsEtaDir(0),
  88     fCentersOfCellsXDir(0),fCentersOfCellsPhiDir(0),fEtaCentersOfCells(0),fPhiCentersOfCells(0),
  89     fShishKebabTrd1Modules(0), fNAdditionalOpts(0),
  90     fILOSS(-1), fIHADR(-1)
  91 {
  92   // default ctor only for internal usage (singleton)
  93   // must be kept public for root persistency purposes, but should never be called by the outside world
  94   //  CreateListOfTrd1Modules();
  95   AliDebug(2, "AliEMCALGeometry : default ctor ");
  96 }
  97 //______________________________________________________________________
  98 AliEMCALGeometry::AliEMCALGeometry(const Text_t* name, const Text_t* title)
  99   : AliGeometry(name, title),
 100     fGeoName(0),fArrayOpts(0),fAlFrontThick(0.),fECPbRadThickness(0.),fECScintThick(0.),
 101     fNECLayers(0),fArm1PhiMin(0.),fArm1PhiMax(0.),fArm1EtaMin(0.),fArm1EtaMax(0.),fIPDistance(0.),
 102     fShellThickness(0.),fZLength(0.),fGap2Active(0.),fNZ(0),fNPhi(0),fSampling(0.),fNumberOfSuperModules(0),
 103     fSteelFrontThick(0.),fFrontSteelStrip(0.),fLateralSteelStrip(0.),fPassiveScintThick(0.),fPhiModuleSize(0.),
 104     fEtaModuleSize(0.),fPhiTileSize(0.),fEtaTileSize(0.),fLongModuleSize(0.),fNPhiSuperModule(0),fNPHIdiv(0),fNETAdiv(0),
 105     fNCells(0),fNCellsInSupMod(0),fNCellsInModule(0),fNTRU(0),fNTRUEta(0),fNTRUPhi(0),fTrd1Angle(0.),f2Trd1Dx2(0.),
 106     fPhiGapForSM(0.),fKey110DEG(0),fPhiBoundariesOfSM(0), fPhiCentersOfSM(0), fEtaMaxOfTRD1(0),
 107     fTrd2AngleY(0.),f2Trd2Dy2(0.),fEmptySpace(0.),fTubsR(0.),fTubsTurnAngle(0.),fCentersOfCellsEtaDir(0),
 108     fCentersOfCellsXDir(0),fCentersOfCellsPhiDir(0),fEtaCentersOfCells(0),fPhiCentersOfCells(0),
 109     fShishKebabTrd1Modules(0),fNAdditionalOpts(0),
 110     fILOSS(-1), fIHADR(-1)
 111 {
 112   // ctor only for internal usage (singleton)
 113   AliDebug(2, Form("AliEMCALGeometry(%s,%s) ", name,title));
 114
 115   Init();
 116
 117   CreateListOfTrd1Modules();
 118
 119   if (AliDebugLevel()>=2) {
 120     PrintGeometry();
 121   }
 122
 123 }
 124 //______________________________________________________________________
 125 AliEMCALGeometry::AliEMCALGeometry(const AliEMCALGeometry& geom)
 126   : AliGeometry(geom),
 127     fGeoName(geom.fGeoName),
 128     fArrayOpts(geom.fArrayOpts),
 129     fAlFrontThick(geom.fAlFrontThick),
 130     fECPbRadThickness(geom.fECPbRadThickness),
 131     fECScintThick(geom.fECScintThick),
 132     fNECLayers(geom.fNECLayers),
 133     fArm1PhiMin(geom.fArm1PhiMin),
 134     fArm1PhiMax(geom.fArm1PhiMax),
 135     fArm1EtaMin(geom.fArm1EtaMin),
 136     fArm1EtaMax(geom.fArm1EtaMax),
 137     fIPDistance(geom.fIPDistance),
 138     fShellThickness(geom.fShellThickness),
 139     fZLength(geom.fZLength),
 140     fGap2Active(geom.fGap2Active),
 141     fNZ(geom.fNZ),
 142     fNPhi(geom.fNPhi),
 143     fSampling(geom.fSampling),
 144     fNumberOfSuperModules(geom.fNumberOfSuperModules),
 145     fSteelFrontThick(geom.fSteelFrontThick),
 146     fFrontSteelStrip(geom.fFrontSteelStrip),
 147     fLateralSteelStrip(geom.fLateralSteelStrip),
 148     fPassiveScintThick(geom.fPassiveScintThick),
 149     fPhiModuleSize(geom.fPhiModuleSize),
 150     fEtaModuleSize(geom.fEtaModuleSize),
 151     fPhiTileSize(geom.fPhiTileSize),
 152     fEtaTileSize(geom.fEtaTileSize),
 153     fLongModuleSize(geom.fLongModuleSize),
 154     fNPhiSuperModule(geom.fNPhiSuperModule),
 155     fNPHIdiv(geom.fNPHIdiv),
 156     fNETAdiv(geom.fNETAdiv),
 157     fNCells(geom.fNCells),
 158     fNCellsInSupMod(geom.fNCellsInSupMod),
 159     fNCellsInModule(geom.fNCellsInModule),
 160     fNTRU(geom.fNTRU),
 161     fNTRUEta(geom.fNTRUEta),
 162     fNTRUPhi(geom.fNTRUPhi),
 163     fTrd1Angle(geom.fTrd1Angle),
 164     f2Trd1Dx2(geom.f2Trd1Dx2),
 165     fPhiGapForSM(geom.fPhiGapForSM),
 166     fKey110DEG(geom.fKey110DEG),
 167     fPhiBoundariesOfSM(geom.fPhiBoundariesOfSM),
 168     fPhiCentersOfSM(geom.fPhiCentersOfSM),
 169     fEtaMaxOfTRD1(geom.fEtaMaxOfTRD1),
 170     fTrd2AngleY(geom.fTrd2AngleY),
 171     f2Trd2Dy2(geom.f2Trd2Dy2),
 172     fEmptySpace(geom.fEmptySpace),
 173     fTubsR(geom.fTubsR),
 174     fTubsTurnAngle(geom.fTubsTurnAngle),
 175     fCentersOfCellsEtaDir(geom.fCentersOfCellsEtaDir),
 176     fCentersOfCellsXDir(geom.fCentersOfCellsXDir),
 177     fCentersOfCellsPhiDir(geom.fCentersOfCellsPhiDir),
 178     fEtaCentersOfCells(geom.fEtaCentersOfCells),
 179     fPhiCentersOfCells(geom.fPhiCentersOfCells),
 180     fShishKebabTrd1Modules(geom.fShishKebabTrd1Modules),
 181     fNAdditionalOpts(geom.fNAdditionalOpts),
 182     fILOSS(geom.fILOSS), fIHADR(geom.fIHADR)
 183 {
 184   //copy ctor
 185 }
 186
 187 //______________________________________________________________________
 188 AliEMCALGeometry::~AliEMCALGeometry(void){
 189     // dtor
 190 }
 191 //______________________________________________________________________
 192 void AliEMCALGeometry::Init(void){
 193   // Initializes the EMCAL parameters
 194   // naming convention : GUV_WX_N_ gives the composition of a tower
 195   // WX inform about the composition of the EM calorimeter section:
 196   //   thickness in mm of Pb radiator (W) and of scintillator (X), and number of scintillator layers (N)
 197   // New geometry: EMCAL_55_25
 198   // 24-aug-04 for shish-kebab
 199   // SHISH_25 or SHISH_62
 200   // 11-oct-05   - correction for pre final design
 201   // Feb 06,2006 - decrease the weight of EMCAL
 202   //
 203   // Oct 30,2006 - SHISH_TRD1_CURRENT_1X1, SHISH_TRD1_CURRENT_2X2 or SHISH_TRD1_CURRENT_3X3;
 204   //
 205
 206   fAdditionalOpts[0] = "nl=";       // number of sampling layers (fNECLayers)
 207   fAdditionalOpts[1] = "pbTh=";     // cm, Thickness of the Pb   (fECPbRadThick)
 208   fAdditionalOpts[2] = "scTh=";     // cm, Thickness of the Sc    (fECScintThick)
 209   fAdditionalOpts[3] = "latSS=";    // cm, Thickness of lateral steel strip (fLateralSteelStrip)
 210   fAdditionalOpts[4] = "allILOSS="; // = 0,1,2,3,4 (4 - energy loss without fluctuation)
 211   fAdditionalOpts[5] = "allIHADR="; // = 0,1,2 (0 - no hadronic interaction)
 212
 213   fNAdditionalOpts = sizeof(fAdditionalOpts) / sizeof(char*);
 214
 215   fgInit = kFALSE; // Assume failed until proven otherwise.
 216   fGeoName   = GetName();
 217   fGeoName.ToUpper();
 218   fKey110DEG = 0;
 219   if(fGeoName.Contains("110DEG") || fGeoName.Contains("CURRENT")) fKey110DEG = 1; // for GetAbsCellId
 220   fShishKebabTrd1Modules = 0;
 221   fTrd2AngleY = f2Trd2Dy2 = fEmptySpace = fTubsR = fTubsTurnAngle = 0;
 222
 223   fNZ             = 114;        // granularity along Z (eta)
 224   fNPhi           = 168;        // granularity in phi (azimuth)
 225   fArm1PhiMin     = 80.0;       // degrees, Starting EMCAL Phi position
 226   fArm1PhiMax     = 190.0;      // degrees, Ending EMCAL Phi position
 227   fArm1EtaMin     = -0.7;       // pseudorapidity, Starting EMCAL Eta position
 228   fArm1EtaMax     = +0.7;       // pseudorapidity, Ending EMCAL Eta position
 229   fIPDistance     = 454.0;      // cm, Radial distance to inner surface of EMCAL
 230   fPhiGapForSM    = 0.;         // cm, only for final TRD1 geometry
 231   for(int i=0; i<12; i++) fMatrixOfSM[i] = 0;
 232
 233   // geometry
 234   if(fGeoName.Contains("SHISH")){ // Only shahslyk now
 235     // 7-sep-05; integration issue
 236     fArm1PhiMin     = 80.0;     // 60  -> 80
 237     fArm1PhiMax     = 180.0;    // 180 -> 190
 238
 239     fNumberOfSuperModules = 10; // 12 = 6 * 2 (6 in phi, 2 in Z);
 240     fSteelFrontThick = 2.54;    //  9-sep-04
 241     fIPDistance      = 460.0;
 242     fFrontSteelStrip = fPassiveScintThick = 0.0; // 13-may-05
 243     fLateralSteelStrip = 0.025; // before MAY 2005
 244     fPhiModuleSize   = fEtaModuleSize   = 11.4;
 245     fPhiTileSize = fEtaTileSize      = 5.52; // (11.4-5.52*2)/2. = 0.18 cm (wall thickness)
 246     fNPhi            = 14;
 247     fNZ              = 30;
 248     fAlFrontThick    = fGap2Active = 0;
 249     fNPHIdiv = fNETAdiv = 2;
 250
 251     fNECLayers       = 62;
 252     fECScintThick    = fECPbRadThickness = 0.2;
 253     fSampling        = 1.;  // 30-aug-04 - should be calculated
 254     if(fGeoName.Contains("TWIST")) { // all about EMCAL module
 255       fNZ             = 27;  // 16-sep-04
 256     } else if(fGeoName.Contains("TRD")) {
 257       fIPDistance      = 428.0;  //  11-may-05
 258       fSteelFrontThick = 0.0;    // 3.17 -> 0.0; 28-mar-05 : no stell plate
 259       fNPhi            = 12;
 260       fSampling       = 12.327;
 261       fPhiModuleSize = fEtaModuleSize = 12.26;
 262       fNZ            = 26;     // 11-oct-04
 263       fTrd1Angle     = 1.3;    // in degree
 264 // 18-nov-04; 1./0.08112=12.327
 265 // http://pdsfweb01.nersc.gov/~pavlinov/ALICE/SHISHKEBAB/RES/linearityAndResolutionForTRD1.html
 266       if(fGeoName.Contains("TRD1")) {       // 30-jan-05
 267         // for final design
 268         fPhiGapForSM    = 2.;         // cm, only for final TRD1 geometry
 269         if(fGeoName.Contains("MAY05") || fGeoName.Contains("WSUC") || fGeoName.Contains("FINAL") || fGeoName.Contains("CURRENT")){
 270           fNumberOfSuperModules = 12; // 20-may-05
 271           if(fGeoName.Contains("WSUC")) fNumberOfSuperModules = 1; // 27-may-05
 272           fNECLayers     = 77;       // (13-may-05 from V.Petrov)
 273           fPhiModuleSize = 12.5;     // 20-may-05 - rectangular shape
 274           fEtaModuleSize = 11.9;
 275           fECScintThick  = fECPbRadThickness = 0.16;// (13-may-05 from V.Petrov)
 276           fFrontSteelStrip   = 0.025;// 0.025cm = 0.25mm  (13-may-05 from V.Petrov)
 277           fLateralSteelStrip = 0.01; // 0.01cm  = 0.1mm   (13-may-05 from V.Petrov) - was 0.025
 278           fPassiveScintThick = 0.8;  // 0.8cm   = 8mm     (13-may-05 from V.Petrov)
 279           fNZ                = 24;
 280           fTrd1Angle         = 1.5;  // 1.3 or 1.5
 281
 282           if(fGeoName.Contains("FINAL") || fGeoName.Contains("CURRENT")) { // 9-sep-05
 283             fNumberOfSuperModules = 10;
 284             if(GetKey110DEG()) {
 285               fNumberOfSuperModules = 12;// last two modules have size 10 degree in phi (180<phi<190)
 286               fArm1PhiMax = 200.0;       // for XEN1 and turn angle of super modules
 287             }
 288             if(fGeoName.Contains("FINAL")) {
 289               fPhiModuleSize = 12.26 - fPhiGapForSM / Float_t(fNPhi); // first assumption
 290             } else if(fGeoName.Contains("CURRENT")) {
 291               fECScintThick      = 0.176; // 10% of weight reduction
 292               fECPbRadThickness  = 0.144; //
 293               fLateralSteelStrip = 0.015; // 0.015cm  = 0.15mm (Oct 30, from Fred)
 294               fPhiModuleSize     = 12.00;
 295               fPhiGapForSM       = (12.26 - fPhiModuleSize)*fNPhi; // have to check
 296             }
 297             fEtaModuleSize = fPhiModuleSize;
 298             if(fGeoName.Contains("HUGE")) fNECLayers *= 3; // 28-oct-05 for analysing leakage
 299           }
 300         }
 301       } else if(fGeoName.Contains("TRD2")) {       // 30-jan-05
 302         fSteelFrontThick = 0.0;         // 11-mar-05
 303         fIPDistance+= fSteelFrontThick; // 1-feb-05 - compensate absence of steel plate
 304         fTrd1Angle  = 1.64;             // 1.3->1.64
 305         fTrd2AngleY = fTrd1Angle;       //  symmetric case now
 306         fEmptySpace    = 0.2; // 2 mm
 307         fTubsR         = fIPDistance; // 31-jan-05 - as for Fred case
 308
 309         fPhiModuleSize  = fTubsR*2.*TMath::Tan(fTrd2AngleY*TMath::DegToRad()/2.);
 310         fPhiModuleSize -= fEmptySpace/2.; // 11-mar-05
 311         fEtaModuleSize  = fPhiModuleSize; // 20-may-05
 312         fTubsTurnAngle  = 3.;
 313       }
 314       fNPHIdiv = fNETAdiv  = 2;   // 13-oct-04 - division again
 315       if(fGeoName.Contains("3X3")) {   // 23-nov-04
 316         fNPHIdiv = fNETAdiv  = 3;
 317       } else if(fGeoName.Contains("4X4")) {
 318         fNPHIdiv = fNETAdiv  = 4;
 319       } else if(fGeoName.Contains("1X1")) {
 320         fNPHIdiv = fNETAdiv  = 1;
 321       }
 322     }
 323     if(fGeoName.Contains("25")){
 324       fNECLayers     = 25;
 325       fECScintThick  = fECPbRadThickness = 0.5;
 326     }
 327     if(fGeoName.Contains("WSUC")){ // 18-may-05 - about common structure
 328       fShellThickness = 30.; // should be change
 329       fNPhi = fNZ = 4;
 330     }
 331
 332     CheckAdditionalOptions();
 333     DefineSamplingFraction();
 334
 335     fPhiTileSize = fPhiModuleSize/double(fNPHIdiv) - fLateralSteelStrip; // 13-may-05
 336     fEtaTileSize = fEtaModuleSize/double(fNETAdiv) - fLateralSteelStrip; // 13-may-05
 337
 338     // constant for transition absid <--> indexes
 339     fNCellsInModule  = fNPHIdiv*fNETAdiv;
 340     fNCellsInSupMod = fNCellsInModule*fNPhi*fNZ;
 341     fNCells         = fNCellsInSupMod*fNumberOfSuperModules;
 342     if(GetKey110DEG()) fNCells -= fNCellsInSupMod;
 343
 344     fLongModuleSize = fNECLayers*(fECScintThick + fECPbRadThickness);
 345     if(fGeoName.Contains("MAY05")) fLongModuleSize += (fFrontSteelStrip + fPassiveScintThick);
 346
 347     // 30-sep-04
 348     if(fGeoName.Contains("TRD")) {
 349       f2Trd1Dx2 = fEtaModuleSize + 2.*fLongModuleSize*TMath::Tan(fTrd1Angle*TMath::DegToRad()/2.);
 350       if(fGeoName.Contains("TRD2")) {  // 27-jan-05
 351         f2Trd2Dy2 = fPhiModuleSize + 2.*fLongModuleSize*TMath::Tan(fTrd2AngleY*TMath::DegToRad()/2.);
 352       }
 353     }
 354   } else Fatal("Init", "%s is an undefined geometry!", fGeoName.Data()) ;
 355
 356   fNPhiSuperModule = fNumberOfSuperModules/2;
 357   if(fNPhiSuperModule<1) fNPhiSuperModule = 1;
 358
 359   fShellThickness = fAlFrontThick + fGap2Active + fNECLayers*GetECScintThick()+(fNECLayers-1)*GetECPbRadThick();
 360   if(fGeoName.Contains("SHISH")) {
 361     fShellThickness = fSteelFrontThick + fLongModuleSize;
 362     if(fGeoName.Contains("TWIST")) { // 13-sep-04
 363       fShellThickness  = TMath::Sqrt(fLongModuleSize*fLongModuleSize + fPhiModuleSize*fEtaModuleSize);
 364       fShellThickness += fSteelFrontThick;
 365     } else if(fGeoName.Contains("TRD")) { // 1-oct-04
 366       fShellThickness  = TMath::Sqrt(fLongModuleSize*fLongModuleSize + f2Trd1Dx2*f2Trd1Dx2);
 367       fShellThickness += fSteelFrontThick;
 368       // Local coordinates
 369       fParSM[0] = GetShellThickness()/2.;
 370       fParSM[1] = GetPhiModuleSize() * GetNPhi()/2.;
 371       fParSM[2] = 350./2.;
 372     }
 373   }
 374
 375   fZLength        = 2.*ZFromEtaR(fIPDistance+fShellThickness,fArm1EtaMax); // Z coverage
 376   fEnvelop[0]     = fIPDistance; // mother volume inner radius
 377   fEnvelop[1]     = fIPDistance + fShellThickness; // mother volume outer r.
 378   fEnvelop[2]     = 1.00001*fZLength; // add some padding for mother volume.
 379
 380   fNumberOfSuperModules = 12;
 381
 382   // SM phi boundaries - (0,1),(2,3) .. (10,11) - has the same boundaries; Nov 7, 2006
 383   fPhiBoundariesOfSM.Set(fNumberOfSuperModules);
 384   fPhiCentersOfSM.Set(fNumberOfSuperModules/2);
 385   fPhiBoundariesOfSM[0] = TMath::PiOver2() - TMath::ATan2(fParSM[1] , fIPDistance); // 1th and 2th modules)
 386   fPhiBoundariesOfSM[1] = TMath::PiOver2() + TMath::ATan2(fParSM[1] , fIPDistance);
 387   fPhiCentersOfSM[0]     = TMath::PiOver2();
 388   for(int i=1; i<=4; i++) { // from 2th ro 9th
 389     fPhiBoundariesOfSM[2*i]   = fPhiBoundariesOfSM[0] + 20.*TMath::DegToRad()*i;
 390     fPhiBoundariesOfSM[2*i+1] = fPhiBoundariesOfSM[1] + 20.*TMath::DegToRad()*i;
 391     fPhiCentersOfSM[i]         = fPhiCentersOfSM[0]     + 20.*TMath::DegToRad()*i;
 392   }
 393   fPhiBoundariesOfSM[11] = 190.*TMath::DegToRad();
 394   fPhiBoundariesOfSM[10] = fPhiBoundariesOfSM[11] - TMath::ATan2((fParSM[1]) , fIPDistance);
 395   fPhiCentersOfSM[5]      = (fPhiBoundariesOfSM[10]+fPhiBoundariesOfSM[11])/2.;
 396
 397   //TRU parameters. These parameters values are not the final ones.
 398   fNTRU    = 3 ;
 399   fNTRUEta = 3 ;
 400   fNTRUPhi = 1 ;
 401
 402       // Define TGeoMatrix of SM - Jan 19, 2007 (just fro TRD1)
 403   if(fGeoName.Contains("TRD1")) { // copy code from  AliEMCALv0::CreateSmod()
 404     int nphism  = GetNumberOfSuperModules()/2;
 405     double dphi = (GetArm1PhiMax() - GetArm1PhiMin())/nphism;
 406     double rpos = (GetEnvelop(0) + GetEnvelop(1))/2.;
 407     double phi, phiRad, xpos, ypos, zpos;
 408     for(int i=0; i<nphism; i++){
 409        phi    = GetArm1PhiMin() + dphi*(2*i+1)/2.; // phi= 90, 110, 130, 150, 170, 190
 410        phiRad = phi*TMath::Pi()/180.;
 411        xpos = rpos * TMath::Cos(phiRad);
 412        ypos = rpos * TMath::Sin(phiRad);
 413        zpos = fParSM[2];
 414        if(i==5) {
 415          xpos += (fParSM[1]/2. * TMath::Sin(phiRad));
 416          ypos -= (fParSM[1]/2. * TMath::Cos(phiRad));
 417        }
 418        // pozitive z
 419        int ind = 2*i;
 420        TGeoRotation *geoRot0 = new TGeoRotation("geoRot0", 90.0, phi, 90.0, 90.0+phi, 0.0, 0.0);
 421        fMatrixOfSM[ind] = new TGeoCombiTrans(Form("EmcalSM%2.2i",ind),
 422                                                  xpos,ypos, zpos, geoRot0);
 423        // negaive z
 424        ind++;
 425        double phiy = 90. + phi + 180.;
 426        if(phiy>=360.) phiy -= 360.;
 427        TGeoRotation *geoRot1 = new TGeoRotation("geoRot1", 90.0, phi, 90.0, phiy, 180.0, 0.0);
 428        fMatrixOfSM[ind] = new TGeoCombiTrans(Form("EmcalSM%2.2i",ind),
 429                                            xpos,ypos,-zpos, geoRot1);
 430     } // for
 431   }
 432   fgInit = kTRUE;
 433   AliInfo(" is ended");
 434 }
 435
 436 void AliEMCALGeometry::PrintGeometry()
 437 {
 438   // Separate routine is callable from broswer; Nov 7,2006
 439   printf("\nInit: geometry of EMCAL named %s :\n", fGeoName.Data());
 440   if(fArrayOpts) {
 441     for(Int_t i=0; i<fArrayOpts->GetEntries(); i++){
 442       TObjString *o = (TObjString*)fArrayOpts->At(i);
 443       printf(" %i : %s \n", i, o->String().Data());
 444     }
 445   }
 446   printf("Granularity: %d in eta and %d in phi\n", GetNZ(), GetNPhi()) ;
 447   printf("Layout: phi = (%7.1f, %7.1f), eta = (%5.2f, %5.2f), IP = %7.2f -> for EMCAL envelope only\n",
 448            GetArm1PhiMin(), GetArm1PhiMax(),GetArm1EtaMin(), GetArm1EtaMax(), GetIPDistance() );
 449
 450   printf( "               ECAL      : %d x (%f cm Pb, %f cm Sc) \n",
 451   GetNECLayers(), GetECPbRadThick(), GetECScintThick() ) ;
 452   printf("                fSampling %5.2f \n",  fSampling );
 453   if(fGeoName.Contains("SHISH")){
 454     printf(" fIPDistance       %6.3f cm \n", fIPDistance);
 455     if(fSteelFrontThick>0.)
 456     printf(" fSteelFrontThick  %6.3f cm \n", fSteelFrontThick);
 457     printf(" fNPhi %i   |  fNZ %i \n", fNPhi, fNZ);
 458     printf(" fNCellsInModule %i : fNCellsInSupMod %i : fNCells %i\n",fNCellsInModule, fNCellsInSupMod, fNCells);
 459     if(fGeoName.Contains("MAY05")){
 460       printf(" fFrontSteelStrip         %6.4f cm (thickness of front steel strip)\n",
 461       fFrontSteelStrip);
 462       printf(" fLateralSteelStrip       %6.4f cm (thickness of lateral steel strip)\n",
 463       fLateralSteelStrip);
 464       printf(" fPassiveScintThick  %6.4f cm (thickness of front passive Sc tile)\n",
 465       fPassiveScintThick);
 466     }
 467     printf(" X:Y module size     %6.3f , %6.3f cm \n", fPhiModuleSize, fEtaModuleSize);
 468     printf(" X:Y   tile size     %6.3f , %6.3f cm \n", fPhiTileSize, fEtaTileSize);
 469     printf(" #of sampling layers %i(fNECLayers) \n", fNECLayers);
 470     printf(" fLongModuleSize     %6.3f cm \n", fLongModuleSize);
 471     printf(" #supermodule in phi direction %i \n", fNPhiSuperModule );
 472   }
 473   printf(" fILOSS %i : fIHADR %i \n", fILOSS, fIHADR);
 474   if(fGeoName.Contains("TRD")) {
 475     printf(" fTrd1Angle %7.4f\n", fTrd1Angle);
 476     printf(" f2Trd1Dx2  %7.4f\n",  f2Trd1Dx2);
 477     if(fGeoName.Contains("TRD2")) {
 478       printf(" fTrd2AngleY     %7.4f\n", fTrd2AngleY);
 479       printf(" f2Trd2Dy2       %7.4f\n", f2Trd2Dy2);
 480       printf(" fTubsR          %7.2f cm\n", fTubsR);
 481       printf(" fTubsTurnAngle  %7.4f\n", fTubsTurnAngle);
 482       printf(" fEmptySpace     %7.4f cm\n", fEmptySpace);
 483     } else if(fGeoName.Contains("TRD1")){
 484       printf("SM dimensions(TRD1) : dx %7.2f dy %7.2f dz %7.2f (SMOD, BOX)\n",
 485       fParSM[0],fParSM[1],fParSM[2]);
 486       printf(" fPhiGapForSM  %7.4f cm (%7.4f <- phi size in degree)\n",
 487       fPhiGapForSM, TMath::ATan2(fPhiGapForSM,fIPDistance)*TMath::RadToDeg());
 488       if(GetKey110DEG()) printf(" Last two modules have size 10 degree in  phi (180<phi<190)\n");
 489       printf(" phi SM boundaries \n");
 490       for(int i=0; i<fPhiBoundariesOfSM.GetSize()/2.; i++) {
 491         printf(" %i : %7.5f(%7.2f) -> %7.5f(%7.2f) : center %7.5f(%7.2f) \n", i,
 492         fPhiBoundariesOfSM[2*i], fPhiBoundariesOfSM[2*i]*TMath::RadToDeg(),
 493                fPhiBoundariesOfSM[2*i+1], fPhiBoundariesOfSM[2*i+1]*TMath::RadToDeg(),
 494                fPhiCentersOfSM[i], fPhiCentersOfSM[i]*TMath::RadToDeg());
 495       }
 496       printf(" fShishKebabTrd1Modules has %i modules : max eta %5.4f \n",
 497                fShishKebabTrd1Modules->GetSize(),fEtaMaxOfTRD1);
 498
 499       printf("\n Cells grid in eta directions : size %i\n", fCentersOfCellsEtaDir.GetSize());
 500       for(Int_t i=0; i<fCentersOfCellsEtaDir.GetSize(); i++) {
 501         printf(" ind %2.2i : z %8.3f : x %8.3f \n", i,
 502                fCentersOfCellsEtaDir.At(i),fCentersOfCellsXDir.At(i));
 503         int ind=0; // Nov 21,2006
 504         for(Int_t iphi=0; iphi<fCentersOfCellsPhiDir.GetSize(); iphi++) {
 505           ind = iphi*fCentersOfCellsEtaDir.GetSize() + i;
 506           printf("%6.4f ", fEtaCentersOfCells[ind]);
 507           if((iphi+1)%12 == 0) printf("\n");
 508         }
 509         printf("\n");
 510
 511       }
 512       printf(" Matrix transformation\n");
 513       for(Int_t i=0; i<12; i++) {
 514         TGeoMatrix *m = fMatrixOfSM[i];
 515         if(m==0) continue;
 516         const double *xyz = m->GetTranslation();
 517         printf(" %2.2i %s %s x %7.2f y %7.2f z %7.2f\n",
 518                i, m->GetName(), m->ClassName(), xyz[0],xyz[1],xyz[2]);
 519       }
 520
 521       printf("\n Cells grid in phi directions : size %i\n", fCentersOfCellsPhiDir.GetSize());
 522       for(Int_t i=0; i<fCentersOfCellsPhiDir.GetSize(); i++) {
 523         double phi=fPhiCentersOfCells.At(i);
 524         printf(" ind %2.2i : y %8.3f : phi %7.5f(%6.2f) \n", i, fCentersOfCellsPhiDir.At(i),
 525                phi, phi*TMath::RadToDeg());
 526       }
 527     }
 528   }
 529   cout<<endl;
 530 }
 531
 532 void AliEMCALGeometry::PrintCellIndexes(Int_t absId, int pri, char *tit)
 533 {
 534   // Service methods
 535   Int_t nSupMod, nModule, nIphi, nIeta;
 536   Int_t iphi, ieta;
 537   TVector3 vg;
 538
 539   GetCellIndex(absId,  nSupMod, nModule, nIphi, nIeta);
 540   printf(" %s | absId : %i -> nSupMod %i nModule %i nIphi %i nIeta %i \n", tit, absId,  nSupMod, nModule, nIphi, nIeta);
 541   if(pri>0) {
 542     GetCellPhiEtaIndexInSModule(nSupMod,nModule,nIphi,nIeta, iphi,ieta);
 543     printf(" local SM index : iphi %i : ieta %i \n", iphi,ieta);
 544     GetGlobal(absId, vg);
 545     printf(" vglob : mag %7.2f : perp %7.2f : z %7.2f : eta %6.4f : phi %6.4f(%6.2f) \n",
 546            vg.Mag(), vg.Perp(), vg.Z(), vg.Eta(), vg.Phi(), vg.Phi()*TMath::RadToDeg());
 547   }
 548 }
 549
 550 //______________________________________________________________________
 551 void AliEMCALGeometry::CheckAdditionalOptions()
 552 {
 553   // Feb 06,2006
 554   // Additional options that
 555   // can be used to select
 556   // the specific geometry of
 557   // EMCAL to run
 558   // Dec 27,2006
 559   // adeed allILOSS= and allIHADR= for MIP investigation
 560   fArrayOpts = new TObjArray;
 561   Int_t nopt = AliEMCALHistoUtilities::ParseString(fGeoName, *fArrayOpts);
 562   if(nopt==1) { // no aditional option(s)
 563     fArrayOpts->Delete();
 564     delete fArrayOpts;
 565     fArrayOpts = 0;
 566     return;
 567   }
 568   for(Int_t i=1; i<nopt; i++){
 569     TObjString *o = (TObjString*)fArrayOpts->At(i);
 570
 571     TString addOpt = o->String();
 572     Int_t indj=-1;
 573     for(Int_t j=0; j<fNAdditionalOpts; j++) {
 574       TString opt = fAdditionalOpts[j];
 575       if(addOpt.Contains(opt,TString::kIgnoreCase)) {
 576           indj = j;
 577         break;
 578       }
 579     }
 580     if(indj<0) {
 581       AliDebug(2,Form("<E> option |%s| unavailable : ** look to the file AliEMCALGeometry.h **\n",
 582                       addOpt.Data()));
 583       assert(0);
 584     } else {
 585       AliDebug(2,Form("<I> option |%s| is valid : number %i : |%s|\n",
 586                       addOpt.Data(), indj, fAdditionalOpts[indj]));
 587       if       (addOpt.Contains("NL=",TString::kIgnoreCase))   {// number of sampling layers
 588         sscanf(addOpt.Data(),"NL=%i", &fNECLayers);
 589         AliDebug(2,Form(" fNECLayers %i (new) \n", fNECLayers));
 590       } else if(addOpt.Contains("PBTH=",TString::kIgnoreCase)) {//Thickness of the Pb(fECPbRadThicknes)
 591         sscanf(addOpt.Data(),"PBTH=%f", &fECPbRadThickness);
 592       } else if(addOpt.Contains("SCTH=",TString::kIgnoreCase)) {//Thickness of the Sc(fECScintThick)
 593         sscanf(addOpt.Data(),"SCTH=%f", &fECScintThick);
 594       } else if(addOpt.Contains("LATSS=",TString::kIgnoreCase)) {// Thickness of lateral steel strip (fLateralSteelStrip)
 595         sscanf(addOpt.Data(),"LATSS=%f", &fLateralSteelStrip);
 596         AliDebug(2,Form(" fLateralSteelStrip %f (new) \n", fLateralSteelStrip));
 597       } else if(addOpt.Contains("ILOSS=",TString::kIgnoreCase)) {// As in Geant
 598         sscanf(addOpt.Data(),"ALLILOSS=%i", &fILOSS);
 599         AliDebug(2,Form(" fILOSS %i \n", fILOSS));
 600       } else if(addOpt.Contains("IHADR=",TString::kIgnoreCase)) {// As in Geant
 601         sscanf(addOpt.Data(),"ALLIHADR=%i", &fIHADR);
 602         AliDebug(2,Form(" fIHADR %i \n", fIHADR));
 603       }
 604     }
 605   }
 606 }
 607
 608 void AliEMCALGeometry::DefineSamplingFraction()
 609 {
 610   // Jun 05,2006
 611   // Look http://rhic.physics.wayne.edu/~pavlinov/ALICE/SHISHKEBAB/RES/linearityAndResolutionForTRD1.html
 612   // Keep for compatibilty
 613   //
 614   if(fNECLayers == 69) {        // 10% layer reduction
 615     fSampling = 12.55;
 616   } else if(fNECLayers == 61) { // 20% layer reduction
 617     fSampling = 12.80;
 618   } else if(fNECLayers == 77) {
 619     if       (fECScintThick>0.175 && fECScintThick<0.177) { // 10% Pb thicknes reduction
 620       fSampling = 10.5; // fECScintThick = 0.176, fECPbRadThickness=0.144;
 621     } else if(fECScintThick>0.191 && fECScintThick<0.193) { // 20% Pb thicknes reduction
 622       fSampling = 8.93; // fECScintThick = 0.192, fECPbRadThickness=0.128;
 623     }
 624   }
 625 }
 626
 627 //____________________________________________________________________________
 628 void AliEMCALGeometry::FillTRU(const TClonesArray * digits, TClonesArray * ampmatrix, TClonesArray * timeRmatrix) {
 629
 630
 631 //  Orders digits ampitudes list in fNTRU TRUs (384 cells) per supermodule.
 632 //  Each TRU is a TMatrixD, and they are kept in TClonesArrays. The number of
 633 //  TRU in phi is fNTRUPhi, and the number of TRU in eta is fNTRUEta.
 634 //  Last 2 modules are half size in Phi, I considered that the number of TRU
 635 //  is maintained for the last modules but decision not taken. If different,
 636 //  then this must be changed.
 637
 638
 639   //Check data members
 640
 641   if(fNTRUEta*fNTRUPhi != fNTRU)
 642     Error("FillTRU"," Wrong number of TRUS per Eta or Phi");
 643
 644   //Initilize and declare variables
 645   //List of TRU matrices initialized to 0.
 646   Int_t nCellsPhi  = fNPhi*2/fNTRUPhi;
 647   Int_t nCellsPhi2 = fNPhi/fNTRUPhi; //HalfSize modules
 648   Int_t nCellsEta  = fNZ*2/fNTRUEta;
 649   Int_t id      = -1;
 650   Float_t amp   = -1;
 651   Float_t timeR = -1;
 652   Int_t iSupMod = -1;
 653   Int_t nModule  = -1;
 654   Int_t nIphi   = -1;
 655   Int_t nIeta   = -1;
 656   Int_t iphi    = -1;
 657   Int_t ieta    = -1;
 658
 659   //List of TRU matrices initialized to 0.
 660   for(Int_t k = 0; k < fNTRU*fNumberOfSuperModules; k++){
 661     TMatrixD  * amptrus   = new TMatrixD(nCellsPhi,nCellsEta) ;
 662     TMatrixD  * timeRtrus = new TMatrixD(nCellsPhi,nCellsEta) ;
 663     for(Int_t i = 0; i < nCellsPhi; i++){
 664       for(Int_t j = 0; j < nCellsEta; j++){
 665         (*amptrus)(i,j) = 0.0;
 666         (*timeRtrus)(i,j) = 0.0;
 667       }
 668     }
 669     new((*ampmatrix)[k])   TMatrixD(*amptrus) ;
 670     new((*timeRmatrix)[k]) TMatrixD(*timeRtrus) ;
 671   }
 672
 673   AliEMCALDigit * dig ;
 674
 675   //Digits loop to fill TRU matrices with amplitudes.
 676   for(Int_t idig = 0 ; idig < digits->GetEntriesFast() ; idig++){
 677
 678     dig = dynamic_cast<AliEMCALDigit *>(digits->At(idig)) ;
 679     amp    = dig->GetAmp() ;   // Energy of the digit (arbitrary units)
 680     id     = dig->GetId() ;    // Id label of the cell
 681     timeR  = dig->GetTimeR() ; // Earliest time of the digit
 682
 683     //Get eta and phi cell position in supermodule
 684     Bool_t bCell = GetCellIndex(id, iSupMod, nModule, nIphi, nIeta) ;
 685     if(!bCell)
 686       Error("FillTRU","Wrong cell id number") ;
 687
 688     GetCellPhiEtaIndexInSModule(iSupMod,nModule,nIphi, nIeta,iphi,ieta);
 689
 690     //Check to which TRU in the supermodule belongs the cell.
 691     //Supermodules are divided in a TRU matrix of dimension
 692     //(fNTRUPhi,fNTRUEta).
 693     //Each TRU is a cell matrix of dimension (nCellsPhi,nCellsEta)
 694
 695     //First calculate the row and column in the supermodule
 696     //of the TRU to which the cell belongs.
 697     Int_t col   = ieta/nCellsEta;
 698     Int_t row   = iphi/nCellsPhi;
 699     if(iSupMod > 9)
 700       row   = iphi/nCellsPhi2;
 701     //Calculate label number of the TRU
 702     Int_t itru  = row + col*fNTRUPhi + iSupMod*fNTRU ;
 703
 704     //Fill TRU matrix with cell values
 705     TMatrixD * amptrus   = dynamic_cast<TMatrixD *>(ampmatrix->At(itru)) ;
 706     TMatrixD * timeRtrus = dynamic_cast<TMatrixD *>(timeRmatrix->At(itru)) ;
 707
 708     //Calculate row and column of the cell inside the TRU with number itru
 709     Int_t irow = iphi - row *  nCellsPhi;
 710     if(iSupMod > 9)
 711       irow = iphi - row *  nCellsPhi2;
 712     Int_t icol = ieta - col *  nCellsEta;
 713
 714     (*amptrus)(irow,icol) = amp ;
 715     (*timeRtrus)(irow,icol) = timeR ;
 716
 717   }
 718 }
 719
 720 //______________________________________________________________________
 721 void AliEMCALGeometry::GetCellPhiEtaIndexInSModuleFromTRUIndex(const Int_t itru, const Int_t iphitru, const Int_t ietatru, Int_t &iphiSM, Int_t &ietaSM) const
 722 {
 723
 724   // This method transforms the (eta,phi) index of cells in a
 725   // TRU matrix into Super Module (eta,phi) index.
 726
 727   // Calculate in which row and column where the TRU are
 728   // ordered in the SM
 729
 730   Int_t col = itru/ fNTRUPhi ;
 731   Int_t row = itru - col*fNTRUPhi ;
 732
 733   //Calculate the (eta,phi) index in SM
 734   Int_t nCellsPhi = fNPhi*2/fNTRUPhi;
 735   Int_t nCellsEta = fNZ*2/fNTRUEta;
 736
 737   iphiSM = nCellsPhi*row + iphitru  ;
 738   ietaSM = nCellsEta*col + ietatru  ;
 739 }
 740
 741 //______________________________________________________________________
 742 AliEMCALGeometry *  AliEMCALGeometry::GetInstance(){
 743   // Returns the pointer of the unique instance
 744
 745   AliEMCALGeometry * rv = static_cast<AliEMCALGeometry *>( fgGeom );
 746   return rv;
 747 }
 748
 749 //______________________________________________________________________
 750 AliEMCALGeometry* AliEMCALGeometry::GetInstance(const Text_t* name,
 751                                                 const Text_t* title){
 752     // Returns the pointer of the unique instance
 753
 754     AliEMCALGeometry * rv = 0;
 755     if ( fgGeom == 0 ) {
 756       if ( strcmp(name,"") == 0 ) { // get default geometry
 757          fgGeom = new AliEMCALGeometry(fgDefaultGeometryName, title);
 758       } else {
 759          fgGeom = new AliEMCALGeometry(name, title);
 760       }  // end if strcmp(name,"")
 761       if ( fgInit ) rv = (AliEMCALGeometry * ) fgGeom;
 762       else {
 763          rv = 0;
 764          delete fgGeom;
 765          fgGeom = 0;
 766       } // end if fgInit
 767     }else{
 768         if ( strcmp(fgGeom->GetName(), name) != 0) {
 769           printf("\ncurrent geometry is %s : ", fgGeom->GetName());
 770           printf(" you cannot call %s ", name);
 771         }else{
 772           rv = (AliEMCALGeometry *) fgGeom;
 773         } // end
 774     }  // end if fgGeom
 775     return rv;
 776 }
 777
 778 Bool_t AliEMCALGeometry::IsInEMCAL(Double_t x, Double_t y, Double_t z) const {
 779   // Checks whether point is inside the EMCal volume, used in AliEMCALv*.cxx
 780   //
 781   // Code uses cylindrical approximation made of inner radius (for speed)
 782   //
 783   // Points behind EMCAl, i.e. R > outer radius, but eta, phi in acceptance
 784   // are considered to inside
 785
 786   Double_t r=sqrt(x*x+y*y);
 787
 788   if ( r > fEnvelop[0] ) {
 789      Double_t theta;
 790      theta  =    TMath::ATan2(r,z);
 791      Double_t eta;
 792      if(theta == 0)
 793        eta = 9999;
 794      else
 795        eta    =   -TMath::Log(TMath::Tan(theta/2.));
 796      if (eta < fArm1EtaMin || eta > fArm1EtaMax)
 797        return 0;
 798
 799      Double_t phi = TMath::ATan2(y,x) * 180./TMath::Pi();
 800      if (phi > fArm1PhiMin && phi < fArm1PhiMax)
 801        return 1;
 802   }
 803   return 0;
 804 }
 805 // ==
 806
 807 //
 808 // == Shish-kebab cases ==
 809 //
 810 Int_t AliEMCALGeometry::GetAbsCellId(Int_t nSupMod, Int_t nModule, Int_t nIphi, Int_t nIeta) const
 811 {
 812   // 27-aug-04;
 813   // corr. 21-sep-04;
 814   //       13-oct-05; 110 degree case
 815   // May 31, 2006; ALICE numbering scheme:
 816   // 0 <= nSupMod < fNumberOfSuperModules
 817   // 0 <= nModule  < fNPHI * fNZ ( fNPHI * fNZ/2 for fKey110DEG=1)
 818   // 0 <= nIphi   < fNPHIdiv
 819   // 0 <= nIeta   < fNETAdiv
 820   // 0 <= absid   < fNCells
 821   static Int_t id=0; // have to change from 0 to fNCells-1
 822   if(fKey110DEG == 1 && nSupMod >= 10) { // 110 degree case; last two supermodules
 823     id  = fNCellsInSupMod*10 + (fNCellsInSupMod/2)*(nSupMod-10);
 824   } else {
 825     id  = fNCellsInSupMod*nSupMod;
 826   }
 827   id += fNCellsInModule *nModule;
 828   id += fNPHIdiv *nIphi;
 829   id += nIeta;
 830   if(id<0 || id >= fNCells) {
 831 //     printf(" wrong numerations !!\n");
 832 //     printf("    id      %6i(will be force to -1)\n", id);
 833 //     printf("    fNCells %6i\n", fNCells);
 834 //     printf("    nSupMod %6i\n", nSupMod);
 835 //     printf("    nModule  %6i\n", nModule);
 836 //     printf("    nIphi   %6i\n", nIphi);
 837 //     printf("    nIeta   %6i\n", nIeta);
 838     id = -TMath::Abs(id); // if negative something wrong
 839   }
 840   return id;
 841 }
 842
 843 Bool_t  AliEMCALGeometry::CheckAbsCellId(Int_t absId) const
 844 {
 845   // May 31, 2006; only trd1 now
 846   if(absId<0 || absId >= fNCells) return kFALSE;
 847   else                            return kTRUE;
 848 }
 849
 850 Bool_t AliEMCALGeometry::GetCellIndex(Int_t absId,Int_t &nSupMod,Int_t &nModule,Int_t &nIphi,Int_t &nIeta) const
 851 {
 852   // 21-sep-04; 19-oct-05;
 853   // May 31, 2006; ALICE numbering scheme:
 854   //
 855   // In:
 856   // absId   - cell is as in Geant,     0<= absId   < fNCells;
 857   // Out:
 858   // nSupMod - super module(SM) number, 0<= nSupMod < fNumberOfSuperModules;
 859   // nModule  - module number in SM,     0<= nModule  < fNCellsInSupMod/fNCellsInSupMod or(/2) for tow last SM (10th and 11th);
 860   // nIphi   - cell number in phi driection inside module; 0<= nIphi < fNPHIdiv;
 861   // nIeta   - cell number in eta driection inside module; 0<= nIeta < fNETAdiv;
 862   //
 863   static Int_t tmp=0, sm10=0;
 864   if(!CheckAbsCellId(absId)) return kFALSE;
 865
 866   sm10 = fNCellsInSupMod*10;
 867   if(fKey110DEG == 1 && absId >= sm10) { // 110 degree case; last two supermodules
 868     nSupMod = (absId-sm10) / (fNCellsInSupMod/2) + 10;
 869     tmp     = (absId-sm10) % (fNCellsInSupMod/2);
 870   } else {
 871     nSupMod = absId / fNCellsInSupMod;
 872     tmp     = absId % fNCellsInSupMod;
 873   }
 874
 875   nModule  = tmp / fNCellsInModule;
 876   tmp     = tmp % fNCellsInModule;
 877   nIphi   = tmp / fNPHIdiv;
 878   nIeta   = tmp % fNPHIdiv;
 879
 880   return kTRUE;
 881 }
 882
 883 void AliEMCALGeometry::GetModulePhiEtaIndexInSModule(Int_t nSupMod, Int_t nModule,  int &iphim, int &ietam) const
 884 {
 885   // added nSupMod; - 19-oct-05 !
 886   // Alice numbering scheme        - Jun 01,2006
 887   // ietam, iphi - indexes of module in two dimensional grid of SM
 888   // ietam - have to change from 0 to fNZ-1
 889   // iphim - have to change from 0 to nphi-1 (fNPhi-1 or fNPhi/2-1)
 890   static Int_t nphi;
 891
 892   if(fKey110DEG == 1 && nSupMod>=10) nphi = fNPhi/2;
 893   else                               nphi = fNPhi;
 894
 895   ietam = nModule/nphi;
 896   iphim = nModule%nphi;
 897 }
 898
 899 void AliEMCALGeometry::GetCellPhiEtaIndexInSModule(Int_t nSupMod, Int_t nModule, Int_t nIphi, Int_t nIeta,
 900 int &iphi, int &ieta) const
 901 {
 902   //
 903   // Added nSupMod; Nov 25, 05
 904   // Alice numbering scheme  - Jun 01,2006
 905   // IN:
 906   // nSupMod - super module(SM) number, 0<= nSupMod < fNumberOfSuperModules;
 907   // nModule  - module number in SM,     0<= nModule  < fNCellsInSupMod/fNCellsInSupMod or(/2) for tow last SM (10th and 11th);
 908   // nIphi   - cell number in phi driection inside module; 0<= nIphi < fNPHIdiv;
 909   // nIeta   - cell number in eta driection inside module; 0<= nIeta < fNETAdiv;
 910   //
 911  // OUT:
 912   // ieta, iphi - indexes of cell(tower) in two dimensional grid of SM
 913   // ieta - have to change from 0 to (fNZ*fNETAdiv-1)
 914   // iphi - have to change from 0 to (fNPhi*fNPHIdiv-1 or fNPhi*fNPHIdiv/2-1)
 915   //
 916   static Int_t iphim, ietam;
 917
 918   GetModulePhiEtaIndexInSModule(nSupMod,nModule, iphim, ietam);
 919   //  ieta  = ietam*fNETAdiv + (1-nIeta); // x(module) = -z(SM)
 920   ieta  = ietam*fNETAdiv + (fNETAdiv - 1 - nIeta); // x(module) = -z(SM)
 921   iphi  = iphim*fNPHIdiv + nIphi;     // y(module) =  y(SM)
 922
 923   if(iphi<0 || ieta<0)
 924   AliDebug(1,Form(" nSupMod %i nModule %i nIphi %i nIeta %i => ieta %i iphi %i\n",
 925   nSupMod, nModule, nIphi, nIeta, ieta, iphi));
 926 }
 927
 928 Int_t  AliEMCALGeometry::GetSuperModuleNumber(Int_t absId)  const
 929 {
 930   // Return the number of the  supermodule given the absolute
 931   // ALICE numbering id
 932
 933   static Int_t nSupMod, nModule, nIphi, nIeta;
 934   GetCellIndex(absId, nSupMod, nModule, nIphi, nIeta);
 935   return nSupMod;
 936 }
 937
 938 void  AliEMCALGeometry::GetModuleIndexesFromCellIndexesInSModule(Int_t nSupMod, Int_t iphi, Int_t ieta,
 939                         Int_t &iphim, Int_t &ietam, Int_t &nModule) const
 940 {
 941   // Transition from cell indexes (ieta,iphi) to module indexes (ietam,iphim, nModule)
 942   static Int_t nphi;
 943   nphi  = GetNumberOfModuleInPhiDirection(nSupMod);
 944
 945   ietam  = ieta/fNETAdiv;
 946   iphim  = iphi/fNPHIdiv;
 947   nModule = ietam * nphi + iphim;
 948 }
 949
 950 Int_t  AliEMCALGeometry::GetAbsCellIdFromCellIndexes(Int_t nSupMod, Int_t iphi, Int_t ieta) const
 951 {
 952   // Transition from super module number(nSupMod) and cell indexes (ieta,iphi) to absId
 953   static Int_t ietam, iphim, nModule;
 954   static Int_t nIeta, nIphi; // cell indexes in module
 955
 956   GetModuleIndexesFromCellIndexesInSModule(nSupMod, iphi, ieta, ietam, iphim, nModule);
 957
 958   nIeta = ieta%fNETAdiv;
 959   nIeta = fNETAdiv - 1 - nIeta;
 960   nIphi = iphi%fNPHIdiv;
 961
 962   return GetAbsCellId(nSupMod, nModule, nIphi, nIeta);
 963 }
 964
 965
 966 // Methods for AliEMCALRecPoint - Feb 19, 2006
 967 Bool_t AliEMCALGeometry::RelPosCellInSModule(Int_t absId, Double_t &xr, Double_t &yr, Double_t &zr) const
 968 {
 969   // Look to see what the relative
 970   // position inside a given cell is
 971   // for a recpoint.
 972   // Alice numbering scheme - Jun 08, 2006
 973   // In:
 974   // absId   - cell is as in Geant,     0<= absId   < fNCells;
 975   // OUT:
 976   // xr,yr,zr - x,y,z coordinates of cell with absId inside SM
 977
 978   // Shift index taking into account the difference between standard SM
 979   // and SM of half size in phi direction
 980   const Int_t phiIndexShift = fCentersOfCellsPhiDir.GetSize()/4; // Nov 22, 2006; was 6 for cas 2X2
 981   static Int_t nSupMod, nModule, nIphi, nIeta, iphi, ieta;
 982   if(!CheckAbsCellId(absId)) return kFALSE;
 983
 984   GetCellIndex(absId, nSupMod, nModule, nIphi, nIeta);
 985   GetCellPhiEtaIndexInSModule(nSupMod,nModule,nIphi,nIeta, iphi, ieta);
 986
 987   xr = fCentersOfCellsXDir.At(ieta);
 988   zr = fCentersOfCellsEtaDir.At(ieta);
 989
 990   if(nSupMod<10) {
 991     yr = fCentersOfCellsPhiDir.At(iphi);
 992   } else {
 993     yr = fCentersOfCellsPhiDir.At(iphi + phiIndexShift);
 994   }
 995   AliDebug(1,Form("absId %i nSupMod %i iphi %i ieta %i xr %f yr %f zr %f ",absId,nSupMod,iphi,ieta,xr,yr,zr));
 996
 997   return kTRUE;
 998 }
 999
1000 Bool_t AliEMCALGeometry::RelPosCellInSModule(Int_t absId, Double_t loc[3]) const
1001 {
1002   // Alice numbering scheme - Jun 03, 2006
1003   loc[0] = loc[1] = loc[2]=0.0;
1004   if(RelPosCellInSModule(absId, loc[0],loc[1],loc[2])) {
1005     return kTRUE;
1006   }
1007   return kFALSE;
1008 }
1009
1010 Bool_t AliEMCALGeometry::RelPosCellInSModule(Int_t absId, TVector3 &vloc) const
1011 {
1012   static Double_t loc[3];
1013   if(RelPosCellInSModule(absId,loc)) {
1014     vloc.SetXYZ(loc[0], loc[1], loc[2]);
1015     return kTRUE;
1016   } else {
1017     vloc.SetXYZ(0,0,0);
1018     return kFALSE;
1019   }
1020   // Alice numbering scheme - Jun 03, 2006
1021 }
1022
1023 void AliEMCALGeometry::CreateListOfTrd1Modules()
1024 {
1025   // Generate the list of Trd1 modules
1026   // which will make up the EMCAL
1027   // geometry
1028
1029   AliDebug(2,Form(" AliEMCALGeometry::CreateListOfTrd1Modules() started "));
1030
1031   AliEMCALShishKebabTrd1Module *mod=0, *mTmp=0; // current module
1032   if(fShishKebabTrd1Modules == 0) {
1033     fShishKebabTrd1Modules = new TList;
1034     fShishKebabTrd1Modules->SetName("ListOfTRD1");
1035     for(int iz=0; iz< GetNZ(); iz++) {
1036       if(iz==0) {
1037         mod  = new AliEMCALShishKebabTrd1Module(TMath::Pi()/2.,this);
1038       } else {
1039         mTmp  = new AliEMCALShishKebabTrd1Module(*mod);
1040         mod   = mTmp;
1041       }
1042       fShishKebabTrd1Modules->Add(mod);
1043     }
1044   } else {
1045     AliDebug(2,Form(" Already exits : "));
1046   }
1047   mod = (AliEMCALShishKebabTrd1Module*)fShishKebabTrd1Modules->At(fShishKebabTrd1Modules->GetSize()-1);
1048   fEtaMaxOfTRD1 = mod->GetMaxEtaOfModule(0);
1049
1050   AliDebug(2,Form(" fShishKebabTrd1Modules has %i modules : max eta %5.4f \n",
1051                   fShishKebabTrd1Modules->GetSize(),fEtaMaxOfTRD1));
1052   // Feb 20,2006;
1053   // Jun 01, 2006 - ALICE numbering scheme
1054   // define grid for cells in eta(z) and x directions in local coordinates system of SM
1055   // Works just for 2x2 case only -- ?? start here
1056   //
1057   //
1058   // Define grid for cells in phi(y) direction in local coordinates system of SM
1059   // as for 2X2 as for 3X3 - Nov 8,2006
1060   //
1061   AliDebug(2,Form(" Cells grid in phi directions : size %i\n", fCentersOfCellsPhiDir.GetSize()));
1062   Int_t ind=0; // this is phi index
1063   Int_t iphi=0, ieta=0, nModule=0, iphiTemp;
1064   Double_t xr, zr, theta, phi, eta, r, x,y;
1065   TVector3 vglob;
1066   Double_t ytCenterModule, ytCenterCell;
1067
1068   fCentersOfCellsPhiDir.Set(fNPhi*fNPHIdiv);
1069   fPhiCentersOfCells.Set(fNPhi*fNPHIdiv);
1070
1071   Double_t R0 = GetIPDistance() + GetLongModuleSize()/2.;
1072   for(Int_t it=0; it<fNPhi; it++) { // cycle on modules
1073     ytCenterModule = -fParSM[1] + fPhiModuleSize*(2*it+1)/2;  // center of module
1074     for(Int_t ic=0; ic<fNPHIdiv; ic++) { // cycle on cells in module
1075       if(fNPHIdiv==2) {
1076         ytCenterCell = ytCenterModule + fPhiTileSize *(2*ic-1)/2.;
1077       } else if(fNPHIdiv==3){
1078         ytCenterCell = ytCenterModule + fPhiTileSize *(ic-1);
1079       } else if(fNPHIdiv==1){
1080         ytCenterCell = ytCenterModule;
1081       }
1082       fCentersOfCellsPhiDir.AddAt(ytCenterCell,ind);
1083       // Define grid on phi direction
1084       // Grid is not the same for different eta bin;
1085       // Effect is small but is still here
1086       phi = TMath::ATan2(ytCenterCell, R0);
1087       fPhiCentersOfCells.AddAt(phi, ind);
1088
1089       AliDebug(2,Form(" ind %2.2i : y %8.3f ", ind, fCentersOfCellsPhiDir.At(ind)));
1090       ind++;
1091     }
1092   }
1093
1094   fCentersOfCellsEtaDir.Set(fNZ *fNETAdiv);
1095   fCentersOfCellsXDir.Set(fNZ *fNETAdiv);
1096   fEtaCentersOfCells.Set(fNZ *fNETAdiv * fNPhi*fNPHIdiv);
1097   AliDebug(2,Form(" Cells grid in eta directions : size %i\n", fCentersOfCellsEtaDir.GetSize()));
1098   for(Int_t it=0; it<fNZ; it++) {
1099     AliEMCALShishKebabTrd1Module *trd1 = GetShishKebabModule(it);
1100     nModule = fNPhi*it;
1101     for(Int_t ic=0; ic<fNETAdiv; ic++) {
1102       if(fNPHIdiv==2) {
1103         trd1->GetCenterOfCellInLocalCoordinateofSM(ic, xr, zr);      // case of 2X2
1104         GetCellPhiEtaIndexInSModule(0, nModule, 0, ic, iphiTemp, ieta);
1105       } if(fNPHIdiv==3) {
1106         trd1->GetCenterOfCellInLocalCoordinateofSM_3X3(ic, xr, zr);  // case of 3X3
1107         GetCellPhiEtaIndexInSModule(0, nModule, 0, ic, iphiTemp, ieta);
1108       } if(fNPHIdiv==1) {
1109         trd1->GetCenterOfCellInLocalCoordinateofSM_1X1(xr, zr);      // case of 1X1
1110         GetCellPhiEtaIndexInSModule(0, nModule, 0, ic, iphiTemp, ieta);
1111       }
1112       fCentersOfCellsXDir.AddAt(float(xr) - fParSM[0],ieta);
1113       fCentersOfCellsEtaDir.AddAt(float(zr) - fParSM[2],ieta);
1114       // Define grid on eta direction for each bin in phi
1115       for(int iphi=0; iphi<fCentersOfCellsPhiDir.GetSize(); iphi++) {
1116         x = xr + trd1->GetRadius();
1117         y = fCentersOfCellsPhiDir[iphi];
1118         r = TMath::Sqrt(x*x + y*y + zr*zr);
1119         theta = TMath::ACos(zr/r);
1120         eta   = AliEMCALShishKebabTrd1Module::ThetaToEta(theta);
1121         //        ind   = ieta*fCentersOfCellsPhiDir.GetSize() + iphi;
1122         ind   = iphi*fCentersOfCellsEtaDir.GetSize() + ieta;
1123         fEtaCentersOfCells.AddAt(eta, ind);
1124       }
1125       //printf(" ieta %i : xr + trd1->GetRadius() %f : zr %f : eta %f \n", ieta, xr + trd1->GetRadius(), zr, eta);
1126     }
1127   }
1128   for(Int_t i=0; i<fCentersOfCellsEtaDir.GetSize(); i++) {
1129     AliDebug(2,Form(" ind %2.2i : z %8.3f : x %8.3f", i+1,
1130                     fCentersOfCellsEtaDir.At(i),fCentersOfCellsXDir.At(i)));
1131   }
1132
1133 }
1134
1135 void  AliEMCALGeometry::GetTransformationForSM()
1136 {
1137   //Uses the geometry manager to
1138   //load the transformation matrix
1139   //for the supermodules
1140   // Unused after 19 Jan, 2007 - keep for compatibility;
1141
1142   return;
1143   static Bool_t transInit=kFALSE;
1144   if(transInit) return;
1145
1146   int i=0;
1147   if(gGeoManager == 0) {
1148     Info("CreateTransformationForSM() "," Load geometry : TGeoManager::Import()");
1149     assert(0);
1150   }
1151   TGeoNode *tn = gGeoManager->GetTopNode();
1152   TGeoNode *node=0, *xen1 = 0;
1153   for(i=0; i<tn->GetNdaughters(); i++) {
1154     node = tn->GetDaughter(i);
1155     TString ns(node->GetName());
1156     if(ns.Contains(GetNameOfEMCALEnvelope())) {
1157       xen1 = node;
1158       break;
1159     }
1160   }
1161   if(!xen1) {
1162     Info("CreateTransformationForSM() "," geometry has not EMCAL envelope with name %s",
1163     GetNameOfEMCALEnvelope());
1164     assert(0);
1165   }
1166   printf(" i %i : EMCAL Envelope is %s : #SM %i \n", i, xen1->GetName(), xen1->GetNdaughters());
1167   for(i=0; i<xen1->GetNdaughters(); i++) {
1168     TGeoNodeMatrix *sm = (TGeoNodeMatrix*)xen1->GetDaughter(i);
1169     fMatrixOfSM[i] = sm->GetMatrix();
1170     //Compiler doesn't like this syntax...
1171     //    printf(" %i : matrix %x \n", i, fMatrixOfSM[i]);
1172   }
1173   transInit = kTRUE;
1174 }
1175
1176 void AliEMCALGeometry::GetGlobal(const Double_t *loc, Double_t *glob, int ind) const
1177 {
1178   // Figure out the global numbering
1179   // of a given supermodule from the
1180   // local numbering
1181   // Alice numbering - Jun 03,2006
1182   //  if(fMatrixOfSM[0] == 0) GetTransformationForSM();
1183
1184   if(ind>=0 && ind < GetNumberOfSuperModules()) {
1185     fMatrixOfSM[ind]->LocalToMaster(loc, glob);
1186   }
1187 }
1188
1189 void AliEMCALGeometry::GetGlobal(const TVector3 &vloc, TVector3 &vglob, int ind) const
1190 {
1191   //Figure out the global numbering
1192   //of a given supermodule from the
1193   //local numbering given a 3-vector location
1194
1195   static Double_t tglob[3], tloc[3];
1196   vloc.GetXYZ(tloc);
1197   GetGlobal(tloc, tglob, ind);
1198   vglob.SetXYZ(tglob[0], tglob[1], tglob[2]);
1199 }
1200
1201 void AliEMCALGeometry::GetGlobal(Int_t absId , double glob[3]) const
1202 {
1203   // Alice numbering scheme - Jun 03, 2006
1204   static Int_t nSupMod, nModule, nIphi, nIeta;
1205   static double loc[3];
1206
1207   glob[0]=glob[1]=glob[2]=0.0; // bad case
1208   if(RelPosCellInSModule(absId, loc)) {
1209     GetCellIndex(absId, nSupMod, nModule, nIphi, nIeta);
1210     fMatrixOfSM[nSupMod]->LocalToMaster(loc, glob);
1211   }
1212 }
1213
1214 void AliEMCALGeometry::GetGlobal(Int_t absId , TVector3 &vglob) const
1215 {
1216   // Alice numbering scheme - Jun 03, 2006
1217   static Double_t glob[3];
1218
1219   GetGlobal(absId, glob);
1220   vglob.SetXYZ(glob[0], glob[1], glob[2]);
1221
1222 }
1223
1224 void AliEMCALGeometry::GetGlobal(const AliRecPoint *rp, TVector3 &vglob) const
1225 {
1226   // Figure out the global numbering
1227   // of a given supermodule from the
1228   // local numbering for RecPoints
1229
1230   static TVector3 vloc;
1231   static Int_t nSupMod, nModule, nIphi, nIeta;
1232
1233   AliRecPoint *rpTmp = (AliRecPoint*)rp; // const_cast ??
1234   if(!rpTmp) return;
1235   AliEMCALRecPoint *rpEmc = (AliEMCALRecPoint*)rpTmp;
1236
1237   GetCellIndex(rpEmc->GetAbsId(0), nSupMod, nModule, nIphi, nIeta);
1238   rpTmp->GetLocalPosition(vloc);
1239   GetGlobal(vloc, vglob, nSupMod);
1240 }
1241
1242 void AliEMCALGeometry::EtaPhiFromIndex(Int_t absId,Double_t &eta,Double_t &phi) const
1243 {
1244   // Nov 16, 2006- float to double
1245   // version for TRD1 only
1246   static TVector3 vglob;
1247   GetGlobal(absId, vglob);
1248   eta = vglob.Eta();
1249   phi = vglob.Phi();
1250 }
1251
1252 void AliEMCALGeometry::EtaPhiFromIndex(Int_t absId,Float_t &eta,Float_t &phi) const
1253 {
1254   // Nov 16,2006 - should be discard in future
1255   static TVector3 vglob;
1256   GetGlobal(absId, vglob);
1257   eta = float(vglob.Eta());
1258   phi = float(vglob.Phi());
1259 }
1260
1261 Bool_t AliEMCALGeometry::GetPhiBoundariesOfSM(Int_t nSupMod, Double_t &phiMin, Double_t &phiMax) const
1262 {
1263   // 0<= nSupMod <=11; phi in rad
1264   static int i;
1265   if(nSupMod<0 || nSupMod >11) return kFALSE;
1266   i = nSupMod/2;
1267   phiMin = fPhiBoundariesOfSM[2*i];
1268   phiMax = fPhiBoundariesOfSM[2*i+1];
1269   return kTRUE;
1270 }
1271
1272 Bool_t AliEMCALGeometry::GetPhiBoundariesOfSMGap(Int_t nPhiSec, Double_t &phiMin, Double_t &phiMax) const
1273 {
1274   // 0<= nPhiSec <=4; phi in rad
1275   // 0;  gap boundaries between  0th&2th  | 1th&3th SM
1276   // 1;  gap boundaries between  2th&4th  | 3th&5th SM
1277   // 2;  gap boundaries between  4th&6th  | 5th&7th SM
1278   // 3;  gap boundaries between  6th&8th  | 7th&9th SM
1279   // 4;  gap boundaries between  8th&10th | 9th&11th SM
1280   if(nPhiSec<0 || nPhiSec >4) return kFALSE;
1281   phiMin = fPhiBoundariesOfSM[2*nPhiSec+1];
1282   phiMax = fPhiBoundariesOfSM[2*nPhiSec+2];
1283   return kTRUE;
1284 }
1285
1286 Bool_t AliEMCALGeometry::SuperModuleNumberFromEtaPhi(Double_t eta, Double_t phi, Int_t &nSupMod) const
1287 {
1288   // Return false if phi belongs a phi cracks between SM
1289
1290   static Int_t i;
1291
1292   if(TMath::Abs(eta) > fEtaMaxOfTRD1) return kFALSE;
1293
1294   phi = TVector2::Phi_0_2pi(phi); // move phi to (0,2pi) boundaries
1295   for(i=0; i<6; i++) {
1296     if(phi>=fPhiBoundariesOfSM[2*i] && phi<=fPhiBoundariesOfSM[2*i+1]) {
1297       nSupMod = 2*i;
1298       if(eta < 0.0) nSupMod++;
1299       AliDebug(1,Form("eta %f phi %f(%5.2f) : nSupMod %i : #bound %i", eta,phi,phi*TMath::RadToDeg(), nSupMod,i));
1300       return kTRUE;
1301     }
1302   }
1303   return kFALSE;
1304 }
1305
1306 Bool_t AliEMCALGeometry::GetAbsCellIdFromEtaPhi(Double_t eta, Double_t phi, Int_t &absId) const
1307 {
1308   // Nov 17,2006
1309   // stay here - phi problem as usual
1310   static Int_t nSupMod, i, ieta, iphi, etaShift, nphi;
1311   static Double_t absEta=0.0, d=0.0, dmin=0.0, phiLoc;
1312   absId = nSupMod = - 1;
1313   if(SuperModuleNumberFromEtaPhi(eta, phi, nSupMod)) {
1314     // phi index first
1315     phi    = TVector2::Phi_0_2pi(phi);
1316     phiLoc = phi - fPhiCentersOfSM[nSupMod/2];
1317     nphi   = fPhiCentersOfCells.GetSize();
1318     if(nSupMod>=10) {
1319       phiLoc = phi - 190.*TMath::DegToRad();
1320       nphi  /= 2;
1321     }
1322
1323     dmin   = TMath::Abs(fPhiCentersOfCells[0]-phiLoc);
1324     iphi   = 0;
1325     for(i=1; i<nphi; i++) {
1326       d = TMath::Abs(fPhiCentersOfCells[i] - phiLoc);
1327       if(d < dmin) {
1328         dmin = d;
1329         iphi = i;
1330       }
1331       //      printf(" i %i : d %f : dmin %f : fPhiCentersOfCells[i] %f \n", i, d, dmin, fPhiCentersOfCells[i]);
1332     }
1333     // odd SM are turned with respect of even SM - reverse indexes
1334     AliDebug(2,Form(" iphi %i : dmin %f (phi %f, phiLoc %f ) ", iphi, dmin, phi, phiLoc));
1335     // eta index
1336     absEta   = TMath::Abs(eta);
1337     etaShift = iphi*fCentersOfCellsEtaDir.GetSize();
1338     dmin     = TMath::Abs(fEtaCentersOfCells[etaShift]-absEta);
1339     ieta     = 0;
1340     for(i=1; i<fCentersOfCellsEtaDir.GetSize(); i++) {
1341       d = TMath::Abs(fEtaCentersOfCells[i+etaShift] - absEta);
1342       if(d < dmin) {
1343         dmin = d;
1344         ieta = i;
1345       }
1346     }
1347     AliDebug(2,Form(" ieta %i : dmin %f (eta=%f) : nSupMod %i ", ieta, dmin, eta, nSupMod));
1348
1349     if(eta<0) iphi = (nphi-1) - iphi;
1350     absId = GetAbsCellIdFromCellIndexes(nSupMod, iphi, ieta);
1351
1352     return kTRUE;
1353   }
1354   return kFALSE;
1355 }
1356
1357 AliEMCALShishKebabTrd1Module* AliEMCALGeometry::GetShishKebabModule(Int_t neta)
1358 {
1359   //This method was too long to be
1360   //included in the header file - the
1361   //rule checker complained about it's
1362   //length, so we move it here.  It returns the
1363   //shishkebabmodule at a given eta index point.
1364
1365   static AliEMCALShishKebabTrd1Module* trd1=0;
1366   if(fShishKebabTrd1Modules && neta>=0 && neta<fShishKebabTrd1Modules->GetSize()) {
1367     trd1 = (AliEMCALShishKebabTrd1Module*)fShishKebabTrd1Modules->At(neta);
1368   } else trd1 = 0;
1369   return trd1;
1370 }
1371
1372 void AliEMCALGeometry::Browse(TBrowser* b)
1373 {
1374   if(fShishKebabTrd1Modules) b->Add(fShishKebabTrd1Modules);
1375   for(int i=0; i<fNumberOfSuperModules; i++) {
1376     if(fMatrixOfSM[i])  b->Add(fMatrixOfSM[i]);
1377   }
1378 }
1379
1380 Bool_t AliEMCALGeometry::IsFolder() const
1381 {
1382   if(fShishKebabTrd1Modules) return kTRUE;
1383   else                       return kFALSE;
1384 }