AliAnaPhoton.h

Go to the documentation of this file.

#ifndef ALIANAPHOTON_H
#define ALIANAPHOTON_H

/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice     */

//_________________________________________________________________________

// --- ROOT system ---
class TH2F ;
class TH1F;
class TObjString;
class TList ;

// --- ANALYSIS system ---
#include "AliAnaCaloTrackCorrBaseClass.h"

class AliAnaPhoton : public AliAnaCaloTrackCorrBaseClass {

 public:
    
  AliAnaPhoton() ;
    
  virtual ~AliAnaPhoton() { ; }
  
  //---------------------------------------
  // General analysis frame methods
  //---------------------------------------
  
  TObjString * GetAnalysisCuts();
  
  TList      * GetCreateOutputObjects();
  
  void         Init();

  void         InitParameters();

  void         MakeAnalysisFillAOD()  ;

  void         MakeAnalysisFillHistograms() ; 
  
  void         Print(const Option_t * opt)const;
    
  
  // Analysis methods
  
  Bool_t       ClusterSelected(AliVCluster* cl, Int_t nlm) ;
  
  void         FillAcceptanceHistograms();
  
  void         FillShowerShapeHistograms( AliVCluster* cluster, Int_t mcTag, 
                                         Float_t maxCellEFraction, Int_t & largeTimeInside) ;
  
  void         SwitchOnFillShowerShapeHistograms()    { fFillSSHistograms      = kTRUE  ; }
  void         SwitchOffFillShowerShapeHistograms()   { fFillSSHistograms      = kFALSE ; }  

  void         SwitchOnFillEMCALRegionSSHistograms()  { fFillEMCALRegionSSHistograms = kTRUE  ; }
  void         SwitchOffFillEMCALRegionSSHistograms() { fFillEMCALRegionSSHistograms = kFALSE ; }  

  void         SwitchOnFillConversionVertexHistograms()  { fFillConversionVertexHisto = kTRUE  ; }
  void         SwitchOffFillConversionVertexHistograms() { fFillConversionVertexHisto = kFALSE ; }  
  
  void         SwitchOnOnlySimpleSSHistoFill()        { fFillOnlySimpleSSHisto = kTRUE  ; }
  void         SwitchOffOnlySimpleHistoFill()         { fFillOnlySimpleSSHisto = kFALSE ; }
  
  void         FillTrackMatchingResidualHistograms(AliVCluster* calo, Int_t cut);
  
  void         SwitchOnTMHistoFill()                  { fFillTMHisto           = kTRUE  ; }
  void         SwitchOffTMHistoFill()                 { fFillTMHisto           = kFALSE ; }

  void         FillPileUpHistograms(AliVCluster* cluster, AliVCaloCells *cells, Int_t absIdMax) ;
 
  void         SetConstantTimeShift(Float_t shift)    { fConstantTimeShift     = shift  ; }
  
  // Analysis parameters setters getters
    
  // ** Cluster selection methods **
  
  void         SetMinDistanceToBadChannel(Float_t m1, Float_t m2, Float_t m3) {
                fMinDist = m1; fMinDist2 = m2; fMinDist3 = m3; }

  void         SetTimeCut(Double_t min, Double_t max) { fTimeCutMin = min; 
                                                        fTimeCutMax = max          ; }
  Double_t     GetTimeCutMin()                  const { return fTimeCutMin         ; }
  Double_t     GetTimeCutMax()                  const { return fTimeCutMax         ; }  
  
  void         SetNCellCut(Int_t n)                   { fNCellsCut = n             ; }
  Double_t     GetNCellCut()                    const { return fNCellsCut          ; }
  
  void         SetNLMCut(Int_t min, Int_t max)        { fNLMCutMin = min; 
    fNLMCutMax = max                ; }
  Int_t        GetNLMCutMin()                   const { return fNLMCutMin          ; }
  Int_t        GetNLMCutMax()                   const { return fNLMCutMax          ; }  
  
  Bool_t       IsTrackMatchRejectionOn()        const { return fRejectTrackMatch   ; }
  void         SwitchOnTrackMatchRejection()          { fRejectTrackMatch = kTRUE  ; }
  void         SwitchOffTrackMatchRejection()         { fRejectTrackMatch = kFALSE ; }  

  void         SwitchOnAcceptanceHistoPerEBin()         { fFillEBinAcceptanceHisto = kTRUE  ; }
  void         SwitchOffAcceptanceHistoPerEBin()        { fFillEBinAcceptanceHisto = kFALSE ; }
  
  void         SetNEBinCuts(Int_t nb)           { fNEBinCuts = nb            ; }
  void         SetEBinCutsAt(Int_t i, Float_t va) { if(i < 15) fEBinCuts[i] = va ; }
  
  void         FillNOriginHistograms(Int_t n)         { fNOriginHistograms = n ; 
    if(n > fgkNmcTypes    ) fNOriginHistograms  = fgkNmcTypes     ; }
  void         FillNPrimaryHistograms(Int_t n)        { fNPrimaryHistograms= n ;
    if(n > fgkNmcPrimTypes) fNPrimaryHistograms = fgkNmcPrimTypes ; }

  enum mcTypes    { kmcPhoton     =  0,    kmcPi0Decay = 1,       kmcEtaDecay      = 2,  kmcOtherDecay = 3,
                    kmcPi0        =  4,    kmcEta      = 5,       kmcElectron      = 6,
                    kmcConversion =  7,    kmcOther    = 8,       kmcAntiNeutron   = 9,
                    kmcAntiProton = 10,    kmcNeutron  = 11,      kmcProton        = 12, kmcChPion = 13, 
                    kmcPrompt     = 14,    kmcFragmentation = 15,
                    kmcISR        = 16,    kmcString   = 17  };

  static const Int_t fgkNmcTypes = 18;

  enum mcPTypes   { kmcPPhoton = 0,       kmcPPi0Decay      = 1,  kmcPEtaDecay = 2,     kmcPOtherDecay = 3,
                    kmcPPrompt = 4,       kmcPFragmentation = 5,  kmcPISR      = 6 };
  
  static const Int_t fgkNmcPrimTypes = 7;
  
  enum mcssTypes  { kmcssPhoton = 0,      kmcssOther = 1,       kmcssPi0 = 2,
                    kmcssEta = 3,         kmcssConversion = 4,  kmcssElectron = 5       };  
  
  static const Int_t fgkNssTypes = 6 ;
  
  private:
 
  Float_t  fMinDist ;                               
  Float_t  fMinDist2;                               
  Float_t  fMinDist3;                               
    
  Bool_t   fRejectTrackMatch ;                      
    
  Bool_t   fFillTMHisto;                            
    
  Double_t fTimeCutMin  ;                           
  Double_t fTimeCutMax  ;                           
    
  Int_t    fNCellsCut ;                             
    
  Int_t    fNLMCutMin  ;                            
  Int_t    fNLMCutMax  ;                            
    
  Bool_t   fFillSSHistograms ;                      

  Bool_t   fFillEMCALRegionSSHistograms ;           
    
  Bool_t   fFillConversionVertexHisto   ;           
  
  Bool_t   fFillOnlySimpleSSHisto;                  
    
  Int_t    fNOriginHistograms;                      
  Int_t    fNPrimaryHistograms;                     
  
  TLorentzVector fMomentum;                         
  TLorentzVector fPrimaryMom;                       
  TVector3       fProdVertex;                       
  
  Float_t  fConstantTimeShift;                      
  
  Bool_t   fFillEBinAcceptanceHisto;                
  Float_t  fEBinCuts[15] ;                          
  Int_t    fNEBinCuts;                              

  
  //
  // Histograms
  //
    
  TH1F * fhClusterCutsE [10];                       
  TH1F * fhClusterCutsPt[10];                       
  TH2F * fhNCellsE;                                 
  TH2F * fhCellsE;                                  
  TH2F * fhMaxCellDiffClusterE;                     
  TH2F * fhTimePt;                                  
  TH2F * fhEtaPhi  ;                                
  
  TH1F * fhEPhoton    ;                             
  TH1F * fhPtPhoton   ;                             
  TH2F * fhPhiPhoton  ;                             
  TH2F * fhEtaPhoton  ;                             
  TH2F * fhEtaPhiPhoton  ;                          
  TH2F * fhEtaPhi05Photon  ;                        

  TH2F * fhPtCentralityPhoton    ;                  
  TH2F * fhPtEventPlanePhoton    ;                  
  
  // Shower shape
  TH2F * fhNLocMax;                                 

  TH2F * fhDispE;                                   
  TH2F * fhLam0E;                                   
  TH2F * fhLam0Pt;                                  
  TH2F * fhLam1E;                                   

  TH2F * fhDispETRD;                                
  TH2F * fhLam0ETRD;                                
  TH2F * fhLam0PtTRD;                               
  TH2F * fhLam1ETRD;                                

  TH2F * fhDispETM;                                 
  TH2F * fhLam0ETM;                                 
  TH2F * fhLam0PtTM;                                
  TH2F * fhLam1ETM;                                 
  
  TH2F * fhDispETMTRD;                              
  TH2F * fhLam0ETMTRD;                              
  TH2F * fhLam0PtTMTRD;                             
  TH2F * fhLam1ETMTRD;                              
  
  TH2F * fhNCellsLam0LowE;                          
  TH2F * fhNCellsLam1LowE;                          
  TH2F * fhNCellsDispLowE;                          
  TH2F * fhNCellsLam0HighE;                         
  TH2F * fhNCellsLam1HighE;                         
  TH2F * fhNCellsDispHighE;                         
  
  TH2F * fhEtaLam0LowE;                             
  TH2F * fhPhiLam0LowE;                             
  TH2F * fhEtaLam0HighE;                            
  TH2F * fhPhiLam0HighE;                            
  TH2F * fhLam0DispLowE;                            
  TH2F * fhLam0DispHighE;                           
  TH2F * fhLam1Lam0LowE;                            
  TH2F * fhLam1Lam0HighE;                           
  TH2F * fhDispLam1LowE;                            
  TH2F * fhDispLam1HighE;                           
    
  TH2F * fhDispEtaE ;                               
  TH2F * fhDispPhiE ;                               
  TH2F * fhSumEtaE ;                                
  TH2F * fhSumPhiE ;                                
  TH2F * fhSumEtaPhiE ;                             
  TH2F * fhDispEtaPhiDiffE ;                        
  TH2F * fhSphericityE ;                            
  TH2F * fhDispSumEtaDiffE ;                        
  TH2F * fhDispSumPhiDiffE ;                        
  TH2F * fhDispEtaDispPhi[7] ;                      
  TH2F * fhLambda0DispEta[7] ;                      
  TH2F * fhLambda0DispPhi[7] ;                      
  
  // Fill MC dependent histograms, Origin of this cluster is ...

  TH2F * fhMCDeltaE [fgkNmcTypes];                  
  TH2F * fhMCDeltaPt[fgkNmcTypes];                  
  TH2F * fhMC2E     [fgkNmcTypes];                  
  TH2F * fhMC2Pt    [fgkNmcTypes];                  
  
  TH1F * fhMCE  [fgkNmcTypes];                      
  TH1F * fhMCPt [fgkNmcTypes];                      
  TH2F * fhMCPhi[fgkNmcTypes];                      
  TH2F * fhMCEta[fgkNmcTypes];                      

  TH1F * fhEPrimMC  [fgkNmcPrimTypes];              
  TH1F * fhPtPrimMC [fgkNmcPrimTypes];              
  TH2F * fhPhiPrimMC[fgkNmcPrimTypes];              
  TH2F * fhYPrimMC  [fgkNmcPrimTypes];              
  TH2F * fhEtaPrimMC[fgkNmcPrimTypes];              
  
  TH1F * fhEPrimMCAcc  [fgkNmcPrimTypes];           
  TH1F * fhPtPrimMCAcc [fgkNmcPrimTypes];           
  TH2F * fhPhiPrimMCAcc[fgkNmcPrimTypes];           
  TH2F * fhEtaPrimMCAcc[fgkNmcPrimTypes];           
  TH2F * fhYPrimMCAcc  [fgkNmcPrimTypes];           
  
  // Shower Shape MC
    
  TH2F * fhMCELambda0   [fgkNssTypes] ;             
  TH2F * fhMCPtLambda0  [fgkNssTypes] ;             
  TH2F * fhMCELambda1   [fgkNssTypes] ;             
  TH2F * fhMCEDispersion[fgkNssTypes] ;             
  
  TH2F * fhMCPhotonELambda0NoOverlap ;              
  TH2F * fhMCPhotonELambda0TwoOverlap ;             
  TH2F * fhMCPhotonELambda0NOverlap ;               
  
  TH2F * fhMCLambda0vsClusterMaxCellDiffE0[fgkNssTypes]; 
  TH2F * fhMCLambda0vsClusterMaxCellDiffE2[fgkNssTypes]; 
  TH2F * fhMCLambda0vsClusterMaxCellDiffE6[fgkNssTypes]; 
  TH2F * fhMCNCellsvsClusterMaxCellDiffE0 [fgkNssTypes]; 
  TH2F * fhMCNCellsvsClusterMaxCellDiffE2 [fgkNssTypes]; 
  TH2F * fhMCNCellsvsClusterMaxCellDiffE6 [fgkNssTypes]; 
  TH2F * fhMCNCellsE            [fgkNssTypes];           
  TH2F * fhMCMaxCellDiffClusterE[fgkNssTypes];           

  TH2F * fhMCEDispEta       [fgkNssTypes] ;              
  TH2F * fhMCEDispPhi       [fgkNssTypes] ;              
  TH2F * fhMCESumEtaPhi     [fgkNssTypes] ;              
  TH2F * fhMCEDispEtaPhiDiff[fgkNssTypes] ;              
  TH2F * fhMCESphericity    [fgkNssTypes] ;              
  TH2F * fhMCDispEtaDispPhi [7][fgkNssTypes] ;           
  TH2F * fhMCLambda0DispEta [7][fgkNssTypes] ;           
  TH2F * fhMCLambda0DispPhi [7][fgkNssTypes] ;           

  //Embedding
  TH2F * fhEmbeddedSignalFractionEnergy ;           
  
  TH2F * fhEmbedPhotonELambda0FullSignal ;          
  TH2F * fhEmbedPhotonELambda0MostlySignal ;        
  TH2F * fhEmbedPhotonELambda0MostlyBkg ;           
  TH2F * fhEmbedPhotonELambda0FullBkg ;             
  
  TH2F * fhEmbedPi0ELambda0FullSignal ;             
  TH2F * fhEmbedPi0ELambda0MostlySignal ;           
  TH2F * fhEmbedPi0ELambda0MostlyBkg ;              
  TH2F * fhEmbedPi0ELambda0FullBkg ;                
  
  // Track Matching
    
  TH2F * fhTrackMatchedDEta[2]           ;          
  TH2F * fhTrackMatchedDPhi[2]           ;          
  TH2F * fhTrackMatchedDEtaDPhi[2]       ;          
  
  TH2F * fhTrackMatchedDEtaPos[2]        ;          
  TH2F * fhTrackMatchedDPhiPos[2]        ;          
  TH2F * fhTrackMatchedDEtaDPhiPos[2]    ;          
  
  TH2F * fhTrackMatchedDEtaNeg[2]        ;          
  TH2F * fhTrackMatchedDPhiNeg[2]        ;          
  TH2F * fhTrackMatchedDEtaDPhiNeg[2]    ;          
  
  TH2F * fhTrackMatchedDEtaTRD[2]        ;          
  TH2F * fhTrackMatchedDPhiTRD[2]        ;          
  
  TH2F * fhTrackMatchedDEtaMCOverlap[2]  ;          
  TH2F * fhTrackMatchedDPhiMCOverlap[2]  ;          
  TH2F * fhTrackMatchedDEtaMCNoOverlap[2];          
  TH2F * fhTrackMatchedDPhiMCNoOverlap[2];          
  TH2F * fhTrackMatchedDEtaMCConversion[2];         
  TH2F * fhTrackMatchedDPhiMCConversion[2];         
  
  TH2F * fhTrackMatchedMCParticle[2];               
  TH2F * fhdEdx[2];                                 
  TH2F * fhEOverP[2];                               
  TH2F * fhEOverPTRD[2];                            

  // Pile-up
    
  TH1F * fhPtPhotonPileUp[7];                       
  TH2F * fhClusterTimeDiffPhotonPileUp[7];          
  TH2F * fhTimePtPhotonNoCut;                       
  TH2F * fhTimePtPhotonSPD;                         
  TH2F * fhTimeNPileUpVertSPD;                      
  TH2F * fhTimeNPileUpVertTrack;                    

  TH2F * fhPtPhotonNPileUpSPDVtx;                   
  TH2F * fhPtPhotonNPileUpTrkVtx;                   
  TH2F * fhPtPhotonNPileUpSPDVtxTimeCut;            
  TH2F * fhPtPhotonNPileUpTrkVtxTimeCut;            
  TH2F * fhPtPhotonNPileUpSPDVtxTimeCut2;           
  TH2F * fhPtPhotonNPileUpTrkVtxTimeCut2;           
  
  TH2F * fhEClusterSM ;                             
  TH2F * fhEPhotonSM  ;                             
  TH2F * fhPtClusterSM;                             
  TH2F * fhPtPhotonSM ;                             
  
  TH2F * fhMCConversionVertex;                      
  TH2F * fhMCConversionVertexTRD;                   
  TH2F * fhMCConversionLambda0Rcut[6];              
  TH2F * fhMCConversionLambda0RcutTRD[6];           
  TH2F * fhMCConversionLambda1Rcut[6];              
  TH2F * fhMCConversionLambda1RcutTRD[6];           

//TH2F * fhLam0EMCALRegion   [4][3];                //!<! Cluster lambda0 vs  E, in different EMCal regions
//TH2F * fhLam0EMCALRegionTRD[4][3];                //!<! Cluster lambda0 vs  E, in different EMCal regions, SM covered by TRD
//TH2F * fhLam0EMCALRegionMCConvRcut   [4][3][6];   //!<! Cluster lambda0 vs  E, in different EMCal regions, MC photon conversions, depending on conversion vertex
//TH2F * fhLam0EMCALRegionTRDMCConvRcut[4][3][6];   //!<! Cluster lambda0 vs  E, in different EMCal regions, SM covered by TRD,  MC photon conversions, depending on conversion vertex
  
  TH2F * fhLam0EMCALRegionPerSM[4][3][20];          
  TH2F * fhLam1EMCALRegionPerSM[4][3][20];          
  
  //
  // Clusters within a shower shape bin, 2 bins [0.23,0.26] (photon) and [0.3,0.4] (tail), if cell weight > 0
  //
  TH2F * fhLam1Lam0BinPerSM                [2][20]; 
  TH2F * fhTimeLam0BinPerSM                [2][20]; 
  TH2F * fhTimeLam0BinPerSMWeighted        [2][20]; 
  TH2F * fhDTimeLam0BinPerSM               [2][20]; 
  TH2F * fhDTimeLam0BinPerSMWeighted       [2][20]; 
  TH2F * fhCellClusterEFracLam0BinPerSM    [2][20]; 
//TH2F * fhCellClusterEFracLam0BinPerSMWeighted[2][20]; //!<! Cell E / Cluster E vs cluster pT, not maximum cluster cell, in a l0 bin per SM, log weight  
  TH2F * fhCellClusterELam0BinPerSM        [2][20]; 
  TH2F * fhCellClusterELam0BinPerSMWeighted[2][20]; 

  // plus different Pt bins 2-3,3-4,4-5,5-6,6-8,8-10,10-12
  TH2F * fhEtaPhiLam0BinPtBin              [2][7] ; 
  TH2F * fhColRowLam0BinPtBin              [2][7] ; 
  TH2F * fhColRowLam0BinPtBinWeighted      [2][7] ; 
  TH2F * fhCellClusterIndexEAndTime        [2][7] ; 
  TH2F * fhCellClusterEAndTime             [2][7] ; 
  TH2F * fhCellClusterEFracAndTime         [2][7] ; 

//  // Shared clusters
//  TH2F * fhLam0PerSMShared                   [12] ; //!<! Cluster lambda0 vs  Pt, for shared clusters, EMCal
//  TH2F * fhLam1PerSMShared                   [12] ; //!<! Cluster lambda1 vs  Pt, for shared clusters, EMCal
//  TH2F * fhTimeLam0BinPerSMShared         [2][12] ; //!<! Cell time, not maximum cluster cell, in a l0 bin per SM, shared SM
//  
//  TH2F * fhEtaPhiLam0BinPtBinSMShared      [2][7] ; //!<! Cluster eta/phi in a l0 bin, different Pt bins, SM shared clusters
//  TH2F * fhColRowLam0BinPtBinSMShared      [2][7] ; //!<! Cell hits, not maximum cluster cell, in a l0 bin, different Pt bins 
  
  // Cells with large time
  TH2F * fhEtaPhiLargeTimeInClusterCell    [2][7] ; 
  TH2F * fhColRowLam0BinPtBinLargeTime     [2][7] ; 
  TH2F * fhCellClusterEFracLam0BinPerSMLargeTime [2][20]; 
  TH2F * fhCellClusterEFracLam0BinPerSMLargeTimeTotal[2][20]; 
  TH2F * fhCellClusterELam0BinPerSMLargeTime     [2][20]; 
  TH2F * fhCellClusterIndexELam0BinPerSMLargeTime[2][20]; 
  TH2F * fhNCellsWithLargeTimeInCluster    [2][20]; 
  
  TH2F * fhLam0PerSM                         [20] ; 
  TH2F * fhLam1PerSM                         [20] ; 
  TH2F * fhLam0PerSMLargeTimeInClusterCell   [20] ; 
  TH2F * fhLam1PerSMLargeTimeInClusterCell   [20] ; 
  TH2F * fhLam0PerNLargeTimeInClusterCell     [5] ; 
  TH2F * fhLam1PerNLargeTimeInClusterCell     [5] ; 
//TH2F * fhLam0PerSMSPDPileUp                [20] ; //!<! Cluster lambda0 vs  Pt, when event tagged as pile-up by SPD, in different SM
//TH2F * fhLam1PerSMSPDPileUp                [20] ; //!<! Cluster lambda0 vs  Pt, when event tagged as pile-up by SPD, in different SM  
  
  TH2F *  fhEBinClusterEtaPhi[14] ;                 
  TH2F *  fhEBinClusterColRow[14] ;                 
  TH2F *  fhEBinClusterEtaPhiPID[14] ;              
  TH2F *  fhEBinClusterColRowPID[14] ;              

  
  AliAnaPhoton(              const AliAnaPhoton & g) ;
    
  AliAnaPhoton & operator = (const AliAnaPhoton & g) ;
  
  ClassDef(AliAnaPhoton,43) ;

} ;
 
#endif//ALIANAPHOTON_H