AliEMCALRecPoint.h

Go to the documentation of this file.

#ifndef ALIEMCALRECPOINT_H
#define ALIEMCALRECPOINT_H
/* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */


// --- ROOT system ---
#include <TVector3.h>
class TGeoManager;
class TGeoPhysicalNode;
class TPad;
class TPaveText;
class TGraph;
class Riostream;

// --- AliRoot header files ---
#include "AliCluster.h"
class AliEMCALDigit;
class AliDigitNew;
class AliEMCALGeometry;
class AliEMCALHit;
class AliCaloCalibPedestal;

class AliEMCALRecPoint : public AliCluster 
{

 public:
  
  typedef TObjArray RecPointsList ; 

  AliEMCALRecPoint() ;                   // ctor         
  AliEMCALRecPoint(const char * opt) ;   // ctor 
  AliEMCALRecPoint(const AliEMCALRecPoint & rp);

  AliEMCALRecPoint& operator= (const AliEMCALRecPoint &rp);

  virtual ~AliEMCALRecPoint();

  virtual void    AddDigit(AliEMCALDigit & digit, const Float_t energy, const Bool_t shared); 
  virtual Int_t   Compare(const TObject * obj) const;  
  virtual void    Draw(Option_t * option="") ;

  virtual void    SetClusterType(Int_t ver) { fClusterType = ver ; }
  virtual Int_t   GetClusterType()    const { return fClusterType; }

  virtual void    EvalAll           (Float_t logWeight, TClonesArray * digits, const Bool_t justClusters);
  virtual void    EvalLocalPosition (Float_t logWeight, TClonesArray * digits);
  virtual void    EvalGlobalPosition(Float_t logWeight, TClonesArray * digits);

  virtual void    EvalPrimaries(TClonesArray * digits) ;
  virtual void    EvalParents  (TClonesArray * digits) ;

  void            EvalLocal2TrackingCSTransform();
  void            EvalLocalPositionFit(Double_t deff, Double_t w0, Double_t phiSlope,TClonesArray * digits);
  Bool_t          EvalLocalPosition2(TClonesArray *digits, TArrayD &ed);
  Bool_t          EvalLocalPositionFromDigits(const Double_t esum, const Double_t deff, const Double_t w0, 
                                              TClonesArray *digits, TArrayD &ed, TVector3 &locPos);
  Bool_t          EvalLocalPositionFromDigits(TClonesArray *digits, TArrayD &ed, TVector3 &locPos);
  static  void    GetDeffW0(const Double_t esum, Double_t &deff,  Double_t &w0);

  virtual void    GetGlobalPosition(TVector3 & gpos) const; // return global position (x, y, z) in ALICE
  virtual void    GetLocalPosition (TVector3 & lpos) const; // return local position  (x, y, z) in EMCAL SM
  
  virtual Int_t * GetPrimaries(Int_t & number)       const { number = fMulTrack  ; 
                                                             return fTracksList  ; }
  virtual Int_t * GetParents  (Int_t & number)       const { number = fMulParent ; 
                                                             return fParentsList ; }
  virtual Float_t * GetParentsDE()                   const { return fDEParentsList ; }

  virtual void    SetParents  (Int_t nParents, Int_t* parents) { // Needed in particular case in tender
    fMulParent = nParents;
    if(fParentsList) delete [] fParentsList ;
    fParentsList = parents ;                                   }

  virtual void    SetParentsDE (Float_t* parentsde) { // Needed in particular case in tender
    if(fDEParentsList) delete [] fDEParentsList ;
    fDEParentsList = parentsde ;                               }
  
  virtual Int_t   GetDigitsMultiplicity(void)  const { return fMulDigit    ; }
  Int_t           GetIndexInList()             const { return fIndexInList ; }
  virtual int *   GetDigitsList(void)          const { return fDigitsList  ; }
  virtual Float_t GetEnergy()                  const { return fAmp         ; }
  Float_t         GetCoreEnergy()              const { return fCoreEnergy  ; }
  virtual Float_t GetDispersion()              const { return fDispersion  ; }
  virtual void    GetElipsAxis(Float_t * lambda) const {lambda[0] = fLambda[0]; lambda[1] = fLambda[1];};
  Float_t *       GetEnergiesList()            const { return fEnergyList  ; } // gets the list of energies making this recpoint
  Double_t        GetPointEnergy()             const;                          // gets point energy (sum of energy list)
  Float_t         GetMaximalEnergy(void)       const ;                         // get the highest energy in the cluster
  Int_t           GetMaximalEnergyIndex(void)  const ;                         // get the index of highest energy digit
  Int_t           GetMaximumMultiplicity()     const { return fMaxDigit    ; } // gets the maximum number of digits allowed
  Int_t           GetMultiplicity(void)        const { return fMulDigit    ; } // gets the number of digits making this recpoint
  Int_t           GetMultiplicityAtLevel(Float_t level) const ;                // computes multiplicity of digits with 
  Int_t *         GetAbsId()                   const { return fAbsIdList   ; }
  Int_t           GetAbsId(Int_t i)            const { if(i>=0 && i<fMulDigit)
                                                        return fAbsIdList[i]; 
                                                        else return -1     ; }
  Int_t           GetAbsIdMaxDigit()           const { return GetAbsId(fDigitIndMax) ; }
  Int_t           GetIndMaxDigit()             const { return fDigitIndMax ; }
  void            SetIndMaxDigit(const Int_t ind)    { fDigitIndMax = ind  ; }
  void            SetIndexInList(Int_t val)          { fIndexInList = val  ; }

  virtual Int_t   GetSuperModuleNumber(void)   const { return fSuperModuleNumber;}

  // searches for the local maxima 
  // energy above relative level
  virtual Int_t   GetNumberOfLocalMax(Int_t nDigitMult,
                                      Float_t locMaxCut,TClonesArray * digits ) const ; 

  virtual Int_t   GetNumberOfLocalMax(AliEMCALDigit **  maxAt, Float_t * maxAtEnergy,
                                      Float_t locMaxCut,TClonesArray * digits ) const ; 

  Short_t         GetNExMax(void)              const { return fNExMax       ; }  
  void            SetNExMax(Int_t nmax=1)            { fNExMax = static_cast<Short_t>(nmax) ;}
  
  Int_t           GetPrimaryIndex()            const  ;
  
  Float_t         GetTime(void)                const { return  fTime        ; }
  
  Bool_t          SharedCluster(void)          const { return  fSharedCluster ; }
  void            SetSharedCluster(Bool_t s)         { fSharedCluster = s     ; }
  
  virtual Bool_t  IsEmc(void)                  const { return kTRUE         ; }
  virtual Bool_t  IsSortable()                 const { return kTRUE         ; }  
  virtual void    Paint(Option_t * option="");
  virtual void    Print(Option_t * option="") const ; 
  
  Double_t        TmaxInCm(const Double_t e=0.0, const Int_t key=0);

  Float_t         GetDistanceToBadTower() const {return fDistToBadTower;}
  void            EvalDistanceToBadChannels(AliCaloCalibPedestal* caloped);

protected:
    void           EvalCoreEnergy(Float_t logWeight, TClonesArray * digits) ;             
    virtual void   EvalDispersion(Float_t logWeight, TClonesArray * digits) ;  // computes the dispersion of the shower
    virtual void   EvalElipsAxis (Float_t logWeight, TClonesArray * digits );  // computes the axis of shower ellipsoide
    void           EvalTime( TClonesArray * digits );
    virtual Bool_t AreNeighbours(AliEMCALDigit * digit1, AliEMCALDigit * digit2 ) const;
    Float_t        ThetaToEta(Float_t arg) const;  //Converts Theta (Radians) to Eta(Radians)
    Float_t        EtaToTheta(Float_t arg) const;  //Converts Eta (Radians) to Theta(Radians)

private:

  AliEMCALGeometry* fGeomPtr;  
  
  Float_t  fAmp ;              
  Int_t    fIndexInList ;      
  
  TVector3 fGlobPos ;          
  TVector3 fLocPos ;           
  
  Int_t    fMaxDigit ;         
  Int_t    fMulDigit ;         
  Int_t    fMaxTrack ;         
  Int_t    fMulTrack ;         
  
  Int_t   *fDigitsList ;       //[fMulDigit] 
  
  Int_t   *fTracksList ;       //[fMulTrack] 
  
  Int_t    fClusterType;       
  Float_t  fCoreEnergy ;       
  
  Float_t  fLambda[2] ;        
  Float_t  fDispersion ;       
  
  Float_t *fEnergyList ;       //[fMulDigit] 
  
  Int_t   *fAbsIdList;         //[fMulDigit] 
  
  Float_t  fTime ;             
  Short_t  fNExMax ;           
  Float_t  fCoreRadius;        
  
  Float_t *fDETracksList ;     //[fMulTrack] 
  
  Int_t    fMulParent;         
  Int_t    fMaxParent;         
  
  Int_t   *fParentsList;       //[fMulParent]
  
  Float_t *fDEParentsList;     //[fMulParent]
  
  Int_t    fSuperModuleNumber; 
  Int_t    fDigitIndMax;       
  Float_t  fDistToBadTower;    
  Bool_t   fSharedCluster;     
  
  ClassDef(AliEMCALRecPoint,13) ;

};

#endif // AliEMCALRECPOINT_H