Added methods to retrieve various parameters
authorschutz <schutz@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 16 Jan 2002 04:10:24 +0000 (04:10 +0000)
committerschutz <schutz@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 16 Jan 2002 04:10:24 +0000 (04:10 +0000)
EMCAL/AliEMCALGeometry.cxx
EMCAL/AliEMCALGeometry.h

index 35b048e..d9fb705 100644 (file)
 #include <iostream.h>
 
 // --- AliRoot header files ---
-
-#include "AliEMCALGeometry.h"
+#include <TMath.h>
+// -- ALICE Headers.
 #include "AliConst.h"
+// --- EMCAL headers
+#include "AliEMCALGeometry.h"
 
 ClassImp(AliEMCALGeometry);
 
@@ -129,3 +131,201 @@ AliEMCALGeometry* AliEMCALGeometry::GetInstance(const Text_t* name,
     }  // end if fgGeom
     return rv; 
 }
+//______________________________________________________________________
+Int_t AliEMCALGeometry::TowerIndex(Int_t iz,Int_t iphi,Int_t ipre){
+    // Returns the tower index number from the based on the Z and Phi
+    // index numbers. There are 2 times the number of towers to separate
+    // out the full towsers from the pre-towsers.
+    // Inputs:
+    //   Int_t iz    // index allong z axis [1-fNZ]
+    //   Int_t iphi  // index allong phi axis [1-fNPhi]
+    //   Int_t ipre  // 0 = Full tower, 1 = Pre-shower tower only. [0,1]
+    // Outputs:
+    //   none.
+    // Returned
+    // Int_t the absoulute tower index. [1-2*fNZ*fNPhi]
+    Int_t index;
+
+    if((iz<=0 || iz>GetNZ()) || (iphi<=0 || iphi>GetNPhi()) ||
+       (ipre<0 || ipre>1) ){
+       cout << "inputs out of range iz=" << iz << "[1-" << GetNZ();
+       cout << "] iPhi=" << iphi << "[1-" << GetNPhi() << "] ipre=";
+       cout << ipre << "[0,1]. returning -1" << endl;
+       return -1;
+    } // end if
+    index = iphi + GetNPhi()*(iz-1) + ipre*(GetNPhi()*GetNZ());
+    return index;
+}
+//______________________________________________________________________
+void AliEMCALGeometry::TowerIndexes(Int_t index,Int_t &iz,Int_t &iphi,
+                                   Int_t &ipre){
+    // given the tower index number it returns the based on the Z and Phi
+    // index numbers and if it is for the full tower or the pre-tower number.
+    // There are 2 times the number of towers to separate
+    // out the full towsers from the pre-towsers.
+    // Inputs:
+    //   Int_t index // Tower index number [1-2*fNZ*fNPhi]
+    // Outputs:
+    //   Int_t iz    // index allong z axis [1-fNZ]
+    //   Int_t iphi  // index allong phi axis [1-fNPhi]
+    //   Int_t ipre  // 0 = Full tower, 1 = Pre-shower tower only. [0,1]
+    // Returned
+    //   none.
+    Int_t itowers;
+
+    itowers = GetNZ()*GetNPhi();
+    if(index<1 || index>2*itowers){
+       cout << "index=" << index <<" is out of range [1-";
+       cout << 2*itowers << "], returning -1 for all." << endl;
+       iz = -1; iphi = -1; ipre = -1;
+       return ;
+    } // end if
+    ipre = 0;
+    if(index>itowers){ // pre shower indexs
+       ipre = 1;
+       index = index - itowers;
+    } // end if
+    iz = 1+ (Int_t)(index/GetNPhi());
+    iphi = index - GetNPhi()*(iz-1);
+    return;
+}
+//______________________________________________________________________
+void AliEMCALGeometry::EtaPhiFromIndex(Int_t index,Float_t &eta,Float_t &phi){
+    // given the tower index number it returns the based on the eta and phi
+    // of the tower.
+    // Inputs:
+    //   Int_t index // Tower index number [1-2*fNZ*fNPhi]
+    // Outputs:
+    //   Float_t eta  // eta of center of tower in pseudorapidity
+    //   Float_t phi  // phi of center of tower in degrees
+    // Returned
+    //   none.
+    Int_t iz,iphi,ipre;
+    Double_t dz,dphi,zmax,z,phid,r;
+
+    TowerIndexes(index,iz,iphi,ipre);
+    zmax = (Double_t) GetZLength();
+    dz   = zmax/((Double_t)GetNZ());
+    r    = GetIPDistance();
+    z    = dz*((Double_t)iz - 0.5);  // iz range [1-fNZ].
+    eta  = -TMath::Log(TMath::Tan(0.5*TMath::ATan2(r,z)));
+    dphi = GetArm1PhiMax() - GetArm1PhiMin();  // in degrees.
+    phid = GetArm1PhiMin() + dphi*((Double_t)iphi -0.5);//iphi range [1-fNphi].
+    phi  = phid;
+}
+//______________________________________________________________________
+Int_t AliEMCALGeometry::TowerIndexFromEtaPhi(Float_t eta,Float_t phi){
+    // returns the tower index number based on the eta and phi of the tower.
+    // Inputs:
+    //   Float_t eta  // eta of center of tower in pseudorapidity
+    //   Float_t phi  // phi of center of tower in degrees
+    // Outputs:
+    //   none.
+    // Returned
+    //   Int_t index // Tower index number [1-fNZ*fNPhi]
+    Int_t iz,iphi;
+    Double_t z,zp,r,zl;
+
+    r = GetIPDistance();
+    z = 2.0*TMath::ATan(TMath::Exp(-eta));
+    z = TMath::Tan(z);
+    if(z!=0.0) z = r/z;
+    else z = 0.0;
+    zp = z;
+    zl = GetZLength();
+    z = 0.5*zl+z;
+    iz = (Int_t)(((Double_t)GetNZ())*z/zl);
+    if(iz<=0 || iz>GetNZ()){
+       cout << "z=" << zp << " is outside of EMCAL. r=" << r << " eta =";
+       cout << eta << " z length =" << zl ;
+       cout << " returning -1" << endl;
+       return -1;
+    } // end if
+    iphi =(Int_t)(((Double_t)GetNPhi())*((Double_t)phi)/
+                 ((Double_t)(GetArm1PhiMax() - GetArm1PhiMin())));
+    if(iphi<=0 || iphi>GetNPhi()){
+       cout << "phi=" << phi << " is outside of EMCAL. r=" << r;
+       cout << " Phimin=" << GetArm1PhiMin() << " PhiMax=" << GetArm1PhiMax();
+       cout << " returning -1" << endl;
+       return -1;
+    } // end if
+    return TowerIndex(iz,iphi,0);
+}
+//______________________________________________________________________
+Int_t AliEMCALGeometry::PreTowerIndexFromEtaPhi(Float_t eta,Float_t phi){
+    // returns the pretower index number based on the eta and phi of the tower.
+    // Inputs:
+    //   Float_t eta  // eta of center of tower in pseudorapidity
+    //   Float_t phi  // phi of center of tower in degrees
+    // Outputs:
+    //   none.
+    // Returned
+    //   Int_t index // PreTower index number [fNZ*fNPhi-2*fNZ*fNPhi]
+
+    return GetNZ()*GetNPhi()+TowerIndexFromEtaPhi(eta,phi);
+}
+//______________________________________________________________________
+Bool_t AliEMCALGeometry::AbsToRelNumbering(Int_t AbsId, Int_t *relid){
+    // Converts the absolute numbering into the following array/
+    //  relid[0] = EMCAL Module number 1:1 (EMCAL arm number)
+    //  relid[1] = 0  Not in Pre Shower layers
+    //           = -1 In Pre Shower
+    //  relid[2] = Row number inside EMCAL
+    //  relid[3] = Column number inside EMCAL
+    // Input:
+    //   Int_t AbsId // Tower index number [1-2*fNZ*fNPhi]
+    // Outputs:
+    //   Int_t *relid // array of 5. Discribed above.
+    Bool_t rv  = kTRUE ;
+    Int_t iz=0,iphi=0,ipre=0,index=AbsId;
+
+    TowerIndexes(index,iz,iphi,ipre);
+    relid[0] = 1;
+    relid[1] = 0;
+    if(ipre==1) relid[1] = -1;
+    relid[2] = iz;
+    relid[3] = iphi;
+
+    return rv;
+}
+//______________________________________________________________________
+void AliEMCALGeometry::RelPosInModule(const Int_t *relid,Float_t &theta,
+                                    Float_t &phi){
+    // Converts the relative numbering into the local PHOS-module (x, z)
+    // coordinates
+    Int_t iz   = relid[2]; // offset along x axis
+    Int_t iphi = relid[3]; // offset along z axis
+    Int_t ipre = relid[1]; // indecates -1 preshower, or 0 full tower.
+    Int_t index;
+    Float_t eta;
+
+    if(ipre==-1) ipre = 1;
+    index = TowerIndex(iz,iphi,ipre);
+    EtaPhiFromIndex(index,eta,phi);
+    theta = 180.*(2.0*TMath::ATan(TMath::Exp(-eta)))/TMath::Pi();
+
+    return;
+}
+//______________________________________________________________________
+/*
+Boot_t AliEMCALGeometry::AreNeighbours(Int_t index1,Int_t index2){
+    // Returns kTRUE if the two towers are neighbours or not, including
+    // diagonals. Both indexes are required to be either towers or preshower.
+    // Inputs:
+    //   Int_t index1  // index of tower 1
+    //   Int_t index2  // index of tower 2
+    // Outputs:
+    //   none.
+    // Returned
+    //   Boot_t kTRUE if the towers are neighbours otherwise false.
+    Boot_t anb = kFALSE;
+    Int_t iz1 = 0, iz2 = 0, iphi1 = 0, iphi2 = 0, ipre1 = 0, ipre2 = 0;
+
+    TowerIndexes(index1,iz1,iphi1,ipre1);
+    TowerIndexes(index2,iz2,iphi2,ipre2);
+    if(ipre1!=ipre2) return anb;
+    if((iz1>=iz2-1 && iz1<=iz2+1) && (iphi1>=iphi2-1 && iphi1<=iphi2+1))
+                                                                 anb = kTRUE;
+    return anb;
+}
+ */
index 06a1b69..b9bf971 100644 (file)
@@ -11,7 +11,7 @@
 //                  
 //*-- Author: Sahal Yacoob (LBL / UCT)
 //*--   and : Yves Schutz (Subatech)
-        
+
 #include <assert.h> 
 
 // --- ROOT system ---
 #include "TObjArray.h"
 #include "TVector3.h"
 
-//class TObjArray ;  
-//class TVector3; 
-//class TMatrix ; 
-
 // --- AliRoot header files ---
 
 #include "AliGeometry.h"
 
 
 class AliEMCALGeometry : public AliGeometry {
-
-public: 
-
-  AliEMCALGeometry() {
-    // default ctor 
-    // must be kept public for root persistency purposes, but should never be called by the outside world
-  } ;  
-
-  AliEMCALGeometry(const AliEMCALGeometry & geom) {
-    // cpy ctor requested by Coding Convention but not yet needed
-    assert(0==1) ;
-  } 
-  
-  virtual ~AliEMCALGeometry(void) ; 
-  static AliEMCALGeometry * GetInstance(const Text_t* name, const Text_t* title="") ; 
-  static AliEMCALGeometry * GetInstance() ; 
-
-  AliEMCALGeometry & operator = (const AliEMCALGeometry  & rvalue) const {
-    // assignement operator requested by coding convention but not needed
-    assert(0==1) ;
-    return *(GetInstance()) ; 
-  }
-  virtual void GetGlobal(const AliRecPoint *, TVector3 &, TMatrix &) const {}
-  virtual void GetGlobal(const AliRecPoint *, TVector3 &) const {}
-  // General
-
-  Bool_t  IsInitialized(void) const { return fgInit ; }  
-                                                                       
-  // Return EMCA geometrical parameters
-
-  // geometry
-  const Float_t GetAirGap() const { return fAirGap ; }
-  const Float_t GetArm1PhiMin() const { return fArm1PhiMin ; }
-  const Float_t GetArm1PhiMax() const { return fArm1PhiMax ; }
-  const Float_t GetIPDistance()   const { return  fIPDistance  ; } 
-  const Float_t GetEnvelop(Int_t index) const { return fEnvelop[index] ; }  
-  const Float_t GetShellThickness() const { return fShellThickness ; }
-  const Float_t GetZLength() const { return fZLength ; } 
-  const Float_t GetGap2Active() const {return  fGap2Active ; }
-  const Int_t   GetNLayers() const {return fNLayers ;}
-  const Int_t   GetNZ() const {return fNZ ;}
-  const Int_t   GetNPhi() const {return fNPhi ;}
-  
-protected:
-
-  AliEMCALGeometry(const Text_t* name, const Text_t* title="") : AliGeometry(name, title) { 
-    // ctor only for internal usage (singleton)
-    Init() ; 
-  }
-  void Init(void) ;            // initializes the parameters of EMCAL 
-
-private:
-
-  static AliEMCALGeometry * fgGeom ; // pointer to the unique instance of the singleton 
-  static Bool_t fgInit ;             // Tells if geometry has been succesfully set up 
-
-  // geometry
-  Float_t fAirGap ;                  // Distance between envelop and active material 
-  Float_t fArm1PhiMin ;              // Minimum angular position of EMCAL in Phi (degrees)
-  Float_t fArm1PhiMax ;              // Maximum angular position of EMCAL in Phi (degrees)
-
-// It is assumed that Arm1 and Arm2 have the same following parameters
-  Float_t fEnvelop[3] ;              // the GEANT TUB for the detector 
-  Float_t fIPDistance ;              // Distance of the inner surface to the interaction point
-  Float_t fShellThickness ;          // Total thickness in (x,y) direction
-  Float_t fZLength ;                 // Total length in z direction
-  Float_t fGap2Active ;              // Gap between the envelop and the active material
-  Int_t fNLayers ;                  // Number of layers of material in the R direction
-  Int_t fNZ ;                      // Number of Towers in the Z direction
-  Int_t fNPhi ;                    //Number of Towers in the Phi Direction
+ public:
+    AliEMCALGeometry() {
+       // default ctor,  must be kept public for root persistency purposes,
+       // but should never be called by the outside world
+    };
+    AliEMCALGeometry(const AliEMCALGeometry & geom) {
+       // cpy ctor requested by Coding Convention but not yet needed
+       assert(0==1);
+    };
+    virtual ~AliEMCALGeometry(void) ; 
+    static AliEMCALGeometry * GetInstance(const Text_t* name,
+                                         const Text_t* title="") ; 
+    static AliEMCALGeometry * GetInstance() ;
+    AliEMCALGeometry & operator = (const AliEMCALGeometry  & rvalue) const {
+       // assignement operator requested by coding convention but not needed
+       assert(0==1) ;
+       return *(GetInstance()) ; 
+    };
+    virtual void GetGlobal(const AliRecPoint *, TVector3 &, TMatrix &) const {}
+    virtual void GetGlobal(const AliRecPoint *, TVector3 &) const {}
+    // General
+    Bool_t  IsInitialized(void) const { return fgInit ; }
+    // Return EMCA geometrical parameters
+    // geometry
+    const Float_t GetAirGap() const { return fAirGap ; }
+    const Float_t GetArm1PhiMin() const { return fArm1PhiMin ; }
+    const Float_t GetArm1PhiMax() const { return fArm1PhiMax ; }
+    const Float_t GetIPDistance()   const { return  fIPDistance  ; } 
+    const Float_t GetEnvelop(Int_t index) const { return fEnvelop[index] ; }  
+    const Float_t GetShellThickness() const { return fShellThickness ; }
+    const Float_t GetZLength() const { return fZLength ; } 
+    const Float_t GetGap2Active() const {return  fGap2Active ; }
+    const Int_t   GetNLayers() const {return fNLayers ;}
+    const Int_t   GetNZ() const {return fNZ ;}
+    const Int_t   GetNPhi() const {return fNPhi ;}
+    Int_t TowerIndex(Int_t iz,Int_t iphi,Int_t ipre); // returns tower index
+    // returns tower indexs iz, iphi.
+    void TowerIndexes(Int_t index,Int_t &iz,Int_t &iphi,Int_t &ipre);
+    // for a given tower index it returns eta and phi of center of that tower.
+    void EtaPhiFromIndex(Int_t index,Float_t &eta,Float_t &phi);
+    // for a given eta and phi in the EMCAL it returns the tower index.
+    Int_t TowerIndexFromEtaPhi(Float_t eta,Float_t phi);
+    // for a given eta and phi in the EMCAL it returns the pretower index.
+    Int_t PreTowerIndexFromEtaPhi(Float_t eta,Float_t phi);
+    // Returns theta and phi (degree) for a given EMCAL cell indecated by relid
+    void RelPosInModule(const Int_t *relid,Float_t &theta,Float_t &phi);
+    // Returns an array indicating the Tower/preshower, iz, and iphi for a
+    // specific EMCAL indes.
+    Bool_t AbsToRelNumbering(Int_t AbsId, Int_t *relid);
+    /*
+    // Returns kTRUE if the two indexs are neighboring towers or preshowers.
+    Boot_t AliEMCALGeometry::AreNeighbours(Int_t index1,Int_t index2);
+ */
+
+ protected:
+    AliEMCALGeometry(const Text_t* name, const Text_t* title="") :
+       AliGeometry(name, title) { 
+       // ctor only for internal usage (singleton)
+       Init() ; 
+    };
+    void Init(void) ;            // initializes the parameters of EMCAL
+ private:
+    static AliEMCALGeometry * fgGeom ; // pointer to the unique instance
+                                       // of the singleton 
+    static Bool_t fgInit ;// Tells if geometry has been succesfully set up
+                          // geometry
+    Float_t fAirGap ; // Distance between envelop and active material 
+    Float_t fArm1PhiMin ; // Minimum angular position of EMCAL in Phi (degrees)
+    Float_t fArm1PhiMax ; // Maximum angular position of EMCAL in Phi (degrees)
+
+    // It is assumed that Arm1 and Arm2 have the same following parameters
+    Float_t fEnvelop[3] ;              // the GEANT TUB for the detector 
+    Float_t fIPDistance ; // Distance of the inner surface to the
+                          // interaction point
+    Float_t fShellThickness ;          // Total thickness in (x,y) direction
+    Float_t fZLength ;                 // Total length in z direction
+    Float_t fGap2Active ; // Gap between the envelop and the active material
+    Int_t fNLayers ; // Number of layers of material in the R direction
+    Int_t fNZ ;                      // Number of Towers in the Z direction
+    Int_t fNPhi ;                    //Number of Towers in the Phi Direction
  
-  ClassDef(AliEMCALGeometry,2)       // EMCAL geometry class 
+    ClassDef(AliEMCALGeometry,2)       // EMCAL geometry class 
 
 } ;
 
 #endif // AliEMCALGEOMETRY_H
+
+