AliAnaPi0EbE.h

Go to the documentation of this file.

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

//_________________________________________________________________________




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

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

class AliAnaPi0EbE : public AliAnaCaloTrackCorrBaseClass {
  
public:
  
  AliAnaPi0EbE() ; // default ctor
    
  virtual ~AliAnaPi0EbE() { ; }
  
  TObjString *   GetAnalysisCuts();
  
  TList      *   GetCreateOutputObjects();
  
  Int_t          GetMCIndex(Int_t aodTag);
  
  void           Init();
  
  void           InitParameters();
  
  void           MakeAnalysisFillAOD()  ;
  
  void           MakeAnalysisFillHistograms() ;
  
  void           Print(const Option_t * opt) const;
  
  // Main
  
  void           FillEMCALBCHistograms(Float_t energy, Float_t eta, Float_t phi, Float_t time);
  
  void           FillPileUpHistograms(Float_t pt, Float_t time, AliVCluster * c) ;
  
  void           FillRejectedClusterHistograms(Int_t mctag, Int_t nMaxima);
  
  void           FillSelectedClusterHistograms(AliVCluster* cluster, Float_t pt,
                                               Int_t nLocMax,        Int_t tag,
                                               Float_t asy = 0);
  
  void           FillWeightHistograms(AliVCluster *clus);
  
  void           HasPairSameMCMother(Int_t label1 , Int_t label2,
                                     Int_t tag1   , Int_t tag2,
                                     Int_t & label, Int_t & tag);
  
  void           MakeInvMassInCalorimeter() ;
  
  void           MakeInvMassInCalorimeterAndCTS() ;
  
  void           MakeShowerShapeIdentification() ;
  
  // Setters Getters
  
  //
  //
  enum anaTypes
  {
      kIMCalo,        
      kSSCalo,        
      kIMCaloTracks   
  };
    
  anaTypes       GetAnalysisType()                     const { return fAnaType                 ; }
  void           SetAnalysisType(anaTypes ana)               { fAnaType = ana                  ; }
    
  //
  // Used by all analysis types
  //
  TString        GetInputAODGammaConvName()            const { return fInputAODGammaConvName   ; }
  void           SetInputAODGammaConvName(TString name)      { fInputAODGammaConvName = name   ; }

  void           SetNLMCut(Int_t min, Int_t max)             { fNLMCutMin = min;
                                                               fNLMCutMax = max                ; }
  Int_t          GetNLMCutMin()                        const { return fNLMCutMin               ; }
  Int_t          GetNLMCutMax()                        const { return fNLMCutMax               ; }

  void           SwitchOnAllNLMHistoFill()                   { fFillAllNLMHistograms   = kTRUE ; }
  void           SwitchOffAllNLMHistoFill()                  { fFillAllNLMHistograms   = kFALSE; }

  void           SwitchOnTMHistoFill()                       { fFillTMHisto           = kTRUE  ; }
  void           SwitchOffTMHistoFill()                      { fFillTMHisto           = kFALSE ; }
  
  void           SwitchOnSelectedClusterHistoFill()          { fFillSelectClHisto     = kTRUE  ; }
  void           SwitchOffSelectedClusterHistoFill()         { fFillSelectClHisto     = kFALSE ; }

  //
  // Only for invariant mass analysis
  //
  void           SetM02CutForInvMass(Float_t min=0, Float_t max=10)  
                                                             { fM02MinCutForIM         = min   ; 
                                                               fM02MaxCutForIM         = max   ; }

  void           SetR(Float_t r)                             { fR = r                          ; }
  void           SetIsolationCandidateMinPt(Float_t min)     { fIsoCandMinPt = min             ; }
  
  void           SwitchOnSelectIsolatedDecay()               { fSelectIsolatedDecay    = kTRUE ; }
  void           SwitchOffSelectIsolatedDecay()              { fSelectIsolatedDecay    = kFALSE; }
  
  void           SwitchOnSelectPairInIsolationCone()         { fSelectPairInIsoCone    = kTRUE ; }
  void           SwitchOffSelectPairInIsolationCone()        { fSelectPairInIsoCone    = kFALSE; }

  //
  // Only for pi0 SS identification case
  //
  void           SetMinDistanceToBadChannel(Float_t m1, Float_t m2, Float_t m3) 
                                                             { fMinDist  = m1 ; fMinDist2 = m2 ; 
                                                               fMinDist3 = m3                  ; }
  
  
  void           SetNLMMinEnergy(Int_t i, Float_t min)       { if (i < 3 && i >=0 ) fNLMECutMin[i]  = min   ; }
  Float_t        GetNLMMinEnergy(Int_t i) const              { if( i < 3 && i >=0 ) return fNLMECutMin[i]   ;  
                                                               else return 0 ; }
  
  void           SetTimeCut(Double_t min, Double_t max)      { fTimeCutMin = min;
                                                               fTimeCutMax = max               ; }
  Double_t       GetTimeCutMin()                       const { return fTimeCutMin              ; }
  Double_t       GetTimeCutMax()                       const { return fTimeCutMax              ; }
  
  Bool_t         IsTrackMatchRejectionOn()             const { return fRejectTrackMatch        ; }
  void           SwitchOnTrackMatchRejection()               { fRejectTrackMatch      = kTRUE  ; }
  void           SwitchOffTrackMatchRejection()              { fRejectTrackMatch      = kFALSE ; }
  
  void           SwitchOnFillWeightHistograms()              { fFillWeightHistograms  = kTRUE  ; }
  void           SwitchOffFillWeightHistograms()             { fFillWeightHistograms  = kFALSE ; }
  
  void           SwitchOnOnlySimpleSSHistoFill()             { fFillOnlySimpleSSHisto = kTRUE  ; }
  void           SwitchOffOnlySimpleHistoFill()              { fFillOnlySimpleSSHisto = kFALSE ; }
  
  void           SwitchOnFillEMCALBCHistograms()             { fFillEMCALBCHistograms = kTRUE  ; }
  void           SwitchOffFillEMCALBCHistograms()            { fFillEMCALBCHistograms = kFALSE ; }
  
  void           SwitchOnSplitClusterDistToBad()             { fCheckSplitDistToBad   = kTRUE  ; }
  void           SwitchOffSplitClusterDistToBad()            { fCheckSplitDistToBad   = kFALSE ; }
      
  
  enum mcTypes   { kmcPi0      = 0, kmcEta      = 1, kmcPhoton           = 2,
                   kmcPi0Decay = 3, kmcEtaDecay = 4, kmcOtherDecay       = 5,
                   kmcElectron = 6, kmcHadron   = 7                          } ;
  
  static const Int_t fgkNmcTypes = 8;
  
private:
  
  anaTypes       fAnaType;                                  
  
  Int_t          fNLMCutMin  ;                              
  Int_t          fNLMCutMax  ;                              
  Bool_t         fFillAllNLMHistograms;                     
  Bool_t         fFillTMHisto;                              
  Bool_t         fFillSelectClHisto;                        

  // Invariant mass analysis
  Float_t        fM02MaxCutForIM   ;                        
  Float_t        fM02MinCutForIM   ;                        
  Bool_t         fSelectIsolatedDecay;                      
  Bool_t         fSelectPairInIsoCone;                      
  Float_t        fR;                                        
  Float_t        fIsoCandMinPt;                             
  
  // Only for pi0 SS identification case, kSSCalo
  Float_t        fMinDist ;                                 
  Float_t        fMinDist2;                                 
  Float_t        fMinDist3;                                 
  Float_t        fNLMECutMin[3] ;                           
  Double_t       fTimeCutMin  ;                             
  Double_t       fTimeCutMax  ;                             
  Bool_t         fRejectTrackMatch ;                        
  Bool_t         fCheckSplitDistToBad;                      
  Bool_t         fFillWeightHistograms ;                    
  Bool_t         fFillOnlySimpleSSHisto;                    
  Bool_t         fFillEMCALBCHistograms;                    
  
  // Only for combination of calorimeter and conversion photons, kIMCaloTracks
  TString        fInputAODGammaConvName;                    
  
  TLorentzVector fMomentum;                                 
  TLorentzVector fMomentum1;                                
  TLorentzVector fMomentum2;                                
  TLorentzVector fMomentum12;                               
  TLorentzVector fPrimaryMom;                               
  TLorentzVector fGrandMotherMom;                           
  
  // Histograms
  
  TH1F         * fhPt  ;                                    
  TH1F         * fhE   ;                                    
  TH2F         * fhPtEta  ;                                 
  TH2F         * fhPtPhi  ;                                 
  TH2F         * fhEtaPhi  ;                                
  TH2F         * fhEtaPhiEMCALBC0  ;                        
  TH2F         * fhEtaPhiEMCALBC1  ;                        
  TH2F         * fhEtaPhiEMCALBCN  ;                        
  
  TH2F         * fhEtaPhiTriggerEMCALBC[11]  ;              
  TH2F         * fhTimeTriggerEMCALBC  [11]  ;              
  TH2F         * fhTimeTriggerEMCALBCPileUpSPD[11] ;        
  TH2F         * fhEtaPhiTriggerEMCALBCUM[11]  ;            
  TH2F         * fhTimeTriggerEMCALBCUM[11]  ;              
  
  TH2F         * fhTimeTriggerEMCALBC0UMReMatchOpenTime   ; 
  TH2F         * fhTimeTriggerEMCALBC0UMReMatchCheckNeigh ; 
  TH2F         * fhTimeTriggerEMCALBC0UMReMatchBoth       ; 
  
  TH2F         * fhPtCentrality ;                           
  TH2F         * fhPtEventPlane ;                           
  TH2F         * fhMCPtCentrality[fgkNmcTypes];             
  
  TH1F         * fhPtReject  ;                              
  TH1F         * fhEReject   ;                              
  TH2F         * fhPtEtaReject  ;                           
  TH2F         * fhPtPhiReject  ;                           
  TH2F         * fhEtaPhiReject  ;                          
  
  TH2F         * fhMass  ;                                  
  TH2F         * fhMassPt  ;                                
  TH2F         * fhMassPtMaxPair  ;                         
  TH2F         * fhMassPtMinPair  ;                         
  TH2F         * fhMassSplitPt  ;                           
  TH2F         * fhSelectedMass  ;                          
  TH2F         * fhSelectedMassPt  ;                        
  TH2F         * fhSelectedMassSplitPt  ;                   
  
  TH2F         * fhMassPtIsoRCut  ;                         
  
  TH2F         * fhMassPtLocMax[3] ;                        
  TH2F         * fhSelectedMassPtLocMax[3] ;                
  TH2F         * fhSelectedMassPtLocMaxSM[3][22];           
  TH2F         * fhMCSelectedMassPtLocMax[fgkNmcTypes][3] ; 
  
  TH2F         * fhSelectedLambda0PtLocMaxSM[3][22];        
  
  TH2F         * fhMassNoOverlap  ;                         
  TH2F         * fhMassPtNoOverlap  ;                       
  TH2F         * fhMassSplitPtNoOverlap  ;                  
  TH2F         * fhSelectedMassNoOverlap  ;                 
  TH2F         * fhSelectedMassPtNoOverlap  ;               
  TH2F         * fhSelectedMassSplitPtNoOverlap  ;          
    
  TH2F         * fhMCPi0PtRecoPtPrim;                       
  TH2F         * fhMCEtaPtRecoPtPrim;                       
  TH2F         * fhMCPi0PtRecoPtPrimNoOverlap;              
  TH2F         * fhMCEtaPtRecoPtPrimNoOverlap;              
  
  TH2F         * fhMCPi0SplitPtRecoPtPrim;                  
  TH2F         * fhMCEtaSplitPtRecoPtPrim;                  
  TH2F         * fhMCPi0SplitPtRecoPtPrimNoOverlap;         
  TH2F         * fhMCEtaSplitPtRecoPtPrimNoOverlap;         
  
  TH2F         * fhMCPi0SelectedPtRecoPtPrim;               
  TH2F         * fhMCEtaSelectedPtRecoPtPrim;               
  TH2F         * fhMCPi0SelectedPtRecoPtPrimNoOverlap;      
  TH2F         * fhMCEtaSelectedPtRecoPtPrimNoOverlap;      
  
  TH2F         * fhMCPi0SelectedSplitPtRecoPtPrim;          
  TH2F         * fhMCEtaSelectedSplitPtRecoPtPrim;          
  TH2F         * fhMCPi0SelectedSplitPtRecoPtPrimNoOverlap; 
  TH2F         * fhMCEtaSelectedSplitPtRecoPtPrimNoOverlap; 
  
  TH2F         * fhMCPi0PtRecoPtPrimLocMax[3];              
  TH2F         * fhMCEtaPtRecoPtPrimLocMax[3];              
  TH2F         * fhMCPi0SplitPtRecoPtPrimLocMax[3];         
  TH2F         * fhMCEtaSplitPtRecoPtPrimLocMax[3];         
  
  TH2F         * fhMCPi0SelectedPtRecoPtPrimLocMax[3];      
  TH2F         * fhMCEtaSelectedPtRecoPtPrimLocMax[3];      
  TH2F         * fhMCPi0SelectedSplitPtRecoPtPrimLocMax[3]; 
  TH2F         * fhMCEtaSelectedSplitPtRecoPtPrimLocMax[3]; 
  
  TH2F         * fhAsymmetry ;                              
  TH2F         * fhSelectedAsymmetry  ;                     
  TH1F         * fhSplitE  ;                                
  TH1F         * fhSplitPt  ;                               
  TH2F         * fhSplitPtEta  ;                            
  TH2F         * fhSplitPtPhi  ;                            
  TH2F         * fhNLocMaxSplitPt  ;                        
  
  TH1F         * fhPtDecay  ;                               
  
  TH2F         * fhPtDispersion ;                           
  TH2F         * fhPtLambda0 ;                              
  TH2F         * fhPtLambda0NoSplitCut ;                    
  TH2F         * fhPtLambda1 ;                              
  TH2F         * fhPtLambda0NoTRD ;                         
  TH2F         * fhPtLambda0FracMaxCellCut ;                
  TH2F         * fhPtFracMaxCell ;                          
  TH2F         * fhPtFracMaxCellNoTRD ;                     
  TH2F         * fhPtNCells;                                
  TH2F         * fhPtTime;                                  
  TH2F         * fhEPairDiffTime;                           
  
  TH2F         * fhPtDispEta ;                              
  TH2F         * fhPtDispPhi ;                              
  TH2F         * fhLambda0DispEta[7] ;                      
  TH2F         * fhLambda0DispPhi[7] ;                      
  TH2F         * fhPtSumEta ;                               
  TH2F         * fhPtSumPhi ;                               
  TH2F         * fhPtSumEtaPhi ;                            
  TH2F         * fhPtDispEtaPhiDiff ;                       
  TH2F         * fhPtSphericity ;                           
  TH2F         * fhDispEtaDispPhi[7] ;                      
  TH2F         * fhAsymmetryLambda0[7] ;                    
  TH2F         * fhAsymmetryDispEta[7] ;                    
  TH2F         * fhAsymmetryDispPhi[7] ;                    
  
  // MC histograms
  
  TH1F         * fhMCPtDecay            [fgkNmcTypes];      
  TH1F         * fhMCPtDecayLostPairPi0;                    
  TH1F         * fhMCPtDecayLostPairEta;                    
  TH2F         * fhMCPtLambda0          [fgkNmcTypes];      
  TH2F         * fhMCPtLambda1          [fgkNmcTypes];      
  TH2F         * fhMCPtDispersion       [fgkNmcTypes];      
  TH2F         * fhMCPtLambda0NoTRD     [fgkNmcTypes];      
  TH2F         * fhMCPtLambda0FracMaxCellCut[fgkNmcTypes];  
  TH2F         * fhMCPtFracMaxCell      [fgkNmcTypes];      
  TH2F         * fhMCPtDispEta          [fgkNmcTypes];      
  TH2F         * fhMCPtDispPhi          [fgkNmcTypes];      
  TH2F         * fhMCLambda0DispEta  [7][fgkNmcTypes];      
  TH2F         * fhMCLambda0DispPhi  [7][fgkNmcTypes];      
  TH2F         * fhMCPtSumEtaPhi        [fgkNmcTypes];      
  TH2F         * fhMCPtDispEtaPhiDiff   [fgkNmcTypes];      
  TH2F         * fhMCPtSphericity       [fgkNmcTypes];      
  TH2F         * fhMCDispEtaDispPhi  [7][fgkNmcTypes];      
  TH2F         * fhMCPtAsymmetry        [fgkNmcTypes];      
  TH2F         * fhMCAsymmetryLambda0[7][fgkNmcTypes];      
  TH2F         * fhMCAsymmetryDispEta[7][fgkNmcTypes];      
  TH2F         * fhMCAsymmetryDispPhi[7][fgkNmcTypes];      
  
  TH1F         * fhMCE                  [fgkNmcTypes];      
  TH1F         * fhMCPt                 [fgkNmcTypes];      
  TH2F         * fhMCPtPhi              [fgkNmcTypes];      
  TH2F         * fhMCPtEta              [fgkNmcTypes];      
  TH1F         * fhMCEReject            [fgkNmcTypes];      
  TH1F         * fhMCPtReject           [fgkNmcTypes];      
  
  TH1F         * fhMCSplitE             [fgkNmcTypes];      
  TH1F         * fhMCSplitPt            [fgkNmcTypes];      
  TH2F         * fhMCSplitPtPhi         [fgkNmcTypes];      
  TH2F         * fhMCSplitPtEta         [fgkNmcTypes];      
  TH2F         * fhMCNLocMaxSplitPt     [fgkNmcTypes];      
  
  TH2F         * fhMCMassPt             [fgkNmcTypes];      
  TH2F         * fhMCMassSplitPt        [fgkNmcTypes];      
  TH2F         * fhMCSelectedMassPt     [fgkNmcTypes];      
  TH2F         * fhMCSelectedMassSplitPt[fgkNmcTypes];      
  
  TH2F         * fhMCMassPtNoOverlap     [fgkNmcTypes];     
  TH2F         * fhMCMassSplitPtNoOverlap[fgkNmcTypes];     
  TH2F         * fhMCSelectedMassPtNoOverlap[fgkNmcTypes];  
  TH2F         * fhMCSelectedMassSplitPtNoOverlap[fgkNmcTypes]; 
  
  TH2F         * fhMCPi0PtGenRecoFraction;                  
  TH2F         * fhMCEtaPtGenRecoFraction;                  
  TH1F         * fhMCPi0DecayPt;                            
  TH2F         * fhMCPi0DecayPtFraction;                    
  TH1F         * fhMCEtaDecayPt;                            
  TH2F         * fhMCEtaDecayPtFraction;                    
  TH1F         * fhMCOtherDecayPt;                          
  
  TH2F         * fhMassPairMCPi0;                           
  TH2F         * fhMassPairMCEta;                           
  TH2F         * fhAnglePairMCPi0;                          
  TH2F         * fhAnglePairMCEta;                          
  
  TH2F         * fhMCPi0PtOrigin ;                          
  TH2F         * fhMCEtaPtOrigin ;                          
  TH2F         * fhMCNotResonancePi0PtOrigin ;              
  TH2F         * fhMCPi0PtStatus ;                          
  TH2F         * fhMCPi0ProdVertex;                         
  TH2F         * fhMCEtaProdVertex;                         
  
  // Weight studies
  
  TH2F         * fhECellClusterRatio;                       
  TH2F         * fhECellClusterLogRatio;                    
  TH2F         * fhEMaxCellClusterRatio;                    
  TH2F         * fhEMaxCellClusterLogRatio;                 
  TH2F         * fhLambda0ForW0[14];                        
  //TH2F         * fhLambda1ForW0[7];                       //!<! L1 for 7 defined w0= 3, 3.5 ... 6 for selected photons
  
  // Track Matching
  TH2F         * fhTrackMatchedDEta     ;                   
  TH2F         * fhTrackMatchedDPhi     ;                   
  TH2F         * fhTrackMatchedDEtaDPhi ;                   
  TH2F         * fhTrackMatchedDEtaPos  ;                   
  TH2F         * fhTrackMatchedDPhiPos  ;                   
  TH2F         * fhTrackMatchedDEtaDPhiPos ;                
  TH2F         * fhTrackMatchedDEtaNeg  ;                   
  TH2F         * fhTrackMatchedDPhiNeg  ;                   
  TH2F         * fhTrackMatchedDEtaDPhiNeg ;                
  
  TH2F         * fhTrackMatchedMCParticlePt;                
  TH2F         * fhTrackMatchedMCParticleDEta;              
  TH2F         * fhTrackMatchedMCParticleDPhi;              
  TH2F         * fhdEdx  ;                                  
  TH2F         * fhEOverP;                                  
  TH2F         * fhEOverPNoTRD;                             
  
  // Local maxima
  TH2F         * fhNLocMaxPt;                               
  TH2F         * fhNLocMaxPtSM[22] ;                        
  TH2F         * fhMCNLocMaxPt[fgkNmcTypes];                
  TH2F         * fhPtLambda0LocMax[3] ;                     
  TH2F         * fhMCPtLambda0LocMax[fgkNmcTypes][3];       
  TH2F         * fhPtLambda1LocMax[3] ;                     
  TH2F         * fhPtDispersionLocMax[3] ;                  
  TH2F         * fhPtDispEtaLocMax[3] ;                     
  TH2F         * fhPtDispPhiLocMax[3] ;                     
  TH2F         * fhPtSumEtaPhiLocMax[3] ;                   
  TH2F         * fhPtDispEtaPhiDiffLocMax[3];               
  TH2F         * fhPtSphericityLocMax[3] ;                  
  TH2F         * fhPtAsymmetryLocMax[3] ;                   
  
  TH2F         * fhMassPairLocMax[8];                       
  
  TH2F         * fhNLocMaxPtReject;                         
  TH2F         * fhMCNLocMaxPtReject[fgkNmcTypes];          
  
  // Pile-up
  TH1F         * fhPtPileUp[7];                             
  TH2F         * fhPtCellTimePileUp[7];                     
  TH2F         * fhPtTimeDiffPileUp[7];                     
  TH2F         * fhTimePtNoCut;                             
  TH2F         * fhTimePtSPD;                               
  TH2F         * fhTimePtSPDMulti;                          
  TH2F         * fhTimeNPileUpVertSPD;                      
  TH2F         * fhTimeNPileUpVertTrack;                    
  TH2F         * fhTimeNPileUpVertContributors;             
  TH2F         * fhTimePileUpMainVertexZDistance;           
  TH2F         * fhTimePileUpMainVertexZDiamond;            
  
  TH2F         * fhPtNPileUpSPDVtx;                         
  TH2F         * fhPtNPileUpTrkVtx;                         
  TH2F         * fhPtNPileUpSPDVtxTimeCut;                  
  TH2F         * fhPtNPileUpTrkVtxTimeCut;                  
  TH2F         * fhPtNPileUpSPDVtxTimeCut2;                 
  TH2F         * fhPtNPileUpTrkVtxTimeCut2;                 
  
  AliAnaPi0EbE(              const AliAnaPi0EbE & pi0ebe) ;
    
  AliAnaPi0EbE & operator = (const AliAnaPi0EbE & pi0ebe) ;
  
  ClassDef(AliAnaPi0EbE,42) ;

} ;

#endif //ALIANAPI0EBE_H