AliAnaClusterShapeCorrelStudies.h

Go to the documentation of this file.

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

//_________________________________________________________________________

// --- Root system ---
class TH3F;
class TH2F;
class TH1F;
class TObjString;
class TObjArray;

// --- Analysis system --- 
class AliVCaloCells;
class AliVCaloCluster;
class AliVTrack;

#include "AliAnaCaloTrackCorrBaseClass.h"
 
class AliAnaClusterShapeCorrelStudies : public AliAnaCaloTrackCorrBaseClass {
  
public:
    
  AliAnaClusterShapeCorrelStudies() ;
    
  virtual ~AliAnaClusterShapeCorrelStudies() { ; }
    
  // General methods
  
  TObjString * GetAnalysisCuts();

  TList      * GetCreateOutputObjects();
  
  void         Init();
  
  void         InitParameters();
    
  void         InitdEdXParameters();
  
  void         MakeAnalysisFillHistograms() ;
  
  void         Print(const Option_t * opt) const;
    
  // Main methods
            
  void         ClusterShapeHistograms(AliVCluster* cluster,  
                                      Int_t   absIdMax    , Double_t maxCellFraction, 
                                      Float_t eCrossFrac  , Float_t ampMax  , Double_t tmax, 
                                      Int_t   matchedPID  , Int_t    mcIndex, Int_t noverlaps);
  
  void         ClusterMatchedToTrackPID(AliVCluster *clus, Int_t & matchedPID);
  
  void         ClusterLoopHistograms();
      
  void         ChannelCorrelationInTCard(AliVCluster* clus, Bool_t matched, Int_t absIdMax, Float_t exoticity) ;
    
  Bool_t       IsGoodCluster(Int_t absIdMax, Float_t m02, Int_t nCellsPerCluster);

  void         WeightHistograms(AliVCluster *clus, Int_t mcTag);

  
  // Setters and getters
    
  Float_t      GetM02Min()               const  { return fM02Min   ; }
  void         SetM02Min(Float_t m02)           { fM02Min = m02    ; }

  void         SetM02LowBin(Float_t min, Float_t max)           
                                                { fM02LowBin[0] = min  ;  fM02LowBin[1]  = max ; }

  void         SetM02HighBin(Float_t min, Float_t max)           
                                                { fM02HighBin[0] = min ;  fM02HighBin[1] = max ; }
  
  Float_t      GetDistToBadMin()         const  { return fMinDistToBad ; }
  void         SetDistToBadMin(Float_t di)      { fMinDistToBad = di   ; }

  Int_t        GetNCellsPerClusterMin()  const  { return fNCellMin ; }
  void         SetNCellsPerClusterMin(Int_t n)  { fNCellMin = n    ; }

  Float_t      GetInvMassMinECut()       const  { return fInvMassMinECut     ; }
  void         SetInvMassMinECut(Float_t cut)   { fInvMassMinECut = cut      ; }

  Float_t      GetInvMassMaxECut()       const  { return fInvMassMaxECut     ; }
  void         SetInvMassMaxECut(Float_t cut)   { fInvMassMaxECut = cut      ; }

  Float_t      GetInvMassMinM02Cut()     const  { return fInvMassMinM02Cut   ; }
  void         SetInvMassMinM02Cut(Float_t cut) { fInvMassMinM02Cut = cut    ; }
  
  Float_t      GetInvMassMaxM02Cut()     const  { return fInvMassMaxM02Cut   ; }
  void         SetInvMassMaxM02Cut(Float_t cut) { fInvMassMaxM02Cut = cut    ; }
  
  Float_t      GetInvMassMaxOpenAngle()  const  { return fInvMassMaxOpenAngle; }
  void         SetInvMassMaxOpenAngle(Float_t c){ fInvMassMaxOpenAngle = c   ; }
  
  Float_t      GetInvMassMaxTimeDifference()  const   { return fInvMassMaxTimeDifference; }
  void         SetInvMassMaxTimeDifference(Float_t c) { fInvMassMaxTimeDifference = c   ; }  
      
  void         SetNEBinCuts(Int_t nb)           { fNEBinCuts = nb            ; }
  void         SetEBinCutsAt(Int_t i, Float_t va) { if(i < 15) fEBinCuts[i] = va ; }

  Float_t      GetEnergyMinShape()       const  { return fEMinShape      ; }
  void         SetEnergyMinShape(Float_t en)    { fEMinShape = en        ; }
  
  Float_t      GetEnergyMaxShape()       const  { return fEMaxShape      ; }
  void         SetEnergyMaxShape(Float_t en)    { fEMaxShape = en        ; }
  
  Int_t        GetNCellMinShape()        const  { return fNCellMinShape   ; }
  void         SetNCellMinShape(Int_t nc)       { fNCellMinShape = nc     ; }
  
  void         SetNCellBinLimits(Int_t nb)      { fNCellsBins = nb        ; }
  void         SetNCellBinLimitAt(Int_t i, Float_t va) { if(i < 5) fNCellsBinsLimits[i] = va ; }
  
  // Analysis switchs
  
  void SwitchOnStudyClusterShape()              { fStudyShape            = kTRUE  ; }
  void SwitchOffStudyClusterShape()             { fStudyShape            = kFALSE ; }

  void SwitchOnStudyClusterShapeParam()         { fStudyShapeParam       = kTRUE  ; }
  void SwitchOffStudyClusterShapeParam()        { fStudyShapeParam       = kFALSE ; }
  
  void SwitchOnStudyWeight()                    { fStudyWeight           = kTRUE  ; }
  void SwitchOffStudyWeight()                   { fStudyWeight           = kFALSE ; }
  
  void SwitchOnStudyTCardCorrelation()          { fStudyTCardCorrelation = kTRUE  ; }
  void SwitchOffStudyTCardCorrelation()         { fStudyTCardCorrelation = kFALSE ; }

  void SwitchOnStudyInvariantMass()             { fStudyInvMass          = kTRUE  ; }
  void SwitchOffStudyInvariantMass()            { fStudyInvMass          = kFALSE ; }
 
  void SwitchOnStudyExotic()                    { fStudyExotic           = kTRUE  ; }
  void SwitchOffStudyExotic()                   { fStudyExotic           = kFALSE ; }
  
  void SwitchOnStudyMatchedPID()                { fNMatchPIDCases        = 3      ; }
  void SwitchOffStudyMatchedPID()               { fNMatchPIDCases        = 1      ; }  
  
  void SwitchOnStudyColRowFromCellMax()         { fStudyColRowFromCellMax = kTRUE  ; }
  void SwitchOffStudyColRowFromCellMax()        { fStudyColRowFromCellMax = kFALSE ; }
  
  void SwitchOnStudyCellTime()                  { fStudyTimeCellHisto    = kTRUE  ; }
  void SwitchOffStudyCellTime()                 { fStudyTimeCellHisto    = kFALSE ; }
 
  void SwitchOnStudyEMCalModuleCells()          { fStudyModuleCells      = kTRUE  ; }
  void SwitchOffStudyEMCalModuleCells()         { fStudyModuleCells      = kFALSE ; }
  
  void SwitchOnFillNLocMaxHistograms()          { fFillNLocMaxHistos     = kTRUE  ; }
  void SwitchOffFillNLocMaxHistograms()         { fFillNLocMaxHistos     = kFALSE ; }
  
  void SetConstantTimeShift(Float_t shift)      { fConstantTimeShift     = shift  ; }
  
 private:
  
  //
  // Switches
  //
  Bool_t   fStudyShape;                         
  
  Bool_t   fStudyShapeParam;                    

  Bool_t   fStudyWeight;                        
 
  Bool_t   fStudyTCardCorrelation;              
  
  Bool_t   fStudyExotic;                        
  
  Bool_t   fStudyColRowFromCellMax;             

  Bool_t   fStudyInvMass;                       
  
  Bool_t   fStudyTimeCellHisto;                 
  
  Bool_t   fStudyModuleCells;                   
  
  Bool_t   fFillNLocMaxHistos;                  
  //
  // Cuts
  //
  Float_t  fM02Min;                             
  Int_t    fNCellMin;                           
  Float_t  fMinDistToBad;                       

  Float_t  fEBinCuts[15] ;                      
  Int_t    fNEBinCuts;                          
  
  Float_t  fM02LowBin [2];                      
  Float_t  fM02HighBin[2];                      

  Float_t  fEMinShape;                          
  Float_t  fEMaxShape;                          
  Int_t    fNCellMinShape;                      
  
  Int_t    fNCellsBins ;                        
  Int_t    fNCellsBinsLimits[5];                
  
  Int_t    fNMatchPIDCases;                     
  Int_t    fdEdXMinEle;                         
  Int_t    fdEdXMaxEle;                         
  Int_t    fdEdXMinHad;                         
  Int_t    fdEdXMaxHad;                         

  // Invariant mass analysis
  
  Float_t  fInvMassMinECut;                     
  Float_t  fInvMassMaxECut;                     
  Float_t  fInvMassMinM02Cut;                   
  Float_t  fInvMassMaxM02Cut;                   
  Float_t  fInvMassMaxOpenAngle;                
  Float_t  fInvMassMaxTimeDifference;           
  
  Float_t  fConstantTimeShift;                  
  
  // Temporal containers
  TLorentzVector fClusterMomentum;              
  TLorentzVector fClusterMomentum2;             
  
  AliVCaloCells * fCaloCellList;                
  TObjArray     * fCaloClusList;                
        
  //
  // T-Card correlation
  //
  
  TH2F *   fhEnergyTime1Cell[2];                            
  TH2F *   fhEnergyTMEtaResidual1Cell;                      
  TH2F *   fhEnergyTMPhiResidual1Cell;                      
  TH2F *   fhColRowExoticHighE1CellPosTime;                 
  TH2F *   fhColRowExoticHighE1CellNegTime;                 
  TH2F *   fhColRowExoticHighE1CellNulTime;                 
  TH2F *   fhColRowExoticLowE1Cell [2];                     
  TH2F *   fhColRowExoticHighE1Cell[2];                     

  TH2F *   fhEnergyTimeExotic[2];                           
  TH2F *   fhEnergyTMEtaResidualExotic;                     
  TH2F *   fhEnergyTMPhiResidualExotic;                     
  TH2F *   fhColRowExoticHighEPosTime;                      
  TH2F *   fhColRowExoticHighENegTime;                      
  TH2F *   fhColRowExoticHighENulTime;                      
  TH2F *   fhColRowExoticLowE [2];                          
  TH2F *   fhColRowExoticHighE[2];                          
  
  TH2F *   fhColRowExotic2ndCellDiffLowE [2];               
  TH2F *   fhColRowExotic2ndCellDiffHighE[2];               
  TH2F *   fhColRowExotic2ndCellSameLowE [2];               
  TH2F *   fhColRowExotic2ndCellSameHighE[2];               
  
  TH2F *   fhColRowHighEPosTime;                            
  TH2F *   fhColRowHighENegTime;                            
  TH2F *   fhColRowHighENulTime;                            
  
  TH2F *   fhColRowTCardCorrNoSelectionExoticLowE [2];      
  TH2F *   fhColRowTCardCorrNoSelectionExoticHighE[2];      
  
  TH2F *   fhColRowTCardCorrNoSelectionExotic2ndCellDiffLowE [2];
  TH2F *   fhColRowTCardCorrNoSelectionExotic2ndCellDiffHighE[2];
  TH2F *   fhColRowTCardCorrNoSelectionExotic2ndCellSameLowE [2];
  TH2F *   fhColRowTCardCorrNoSelectionExotic2ndCellSameHighE[2];
  
  TH2F *   fhColRowTCardCorrNoSelectionExotic2ndCellDiffNoSameLowE [2];
  TH2F *   fhColRowTCardCorrNoSelectionExotic2ndCellDiffNoSameHighE[2];
  TH2F *   fhColRowTCardCorrNoSelectionExotic2ndCellSameNoDiffLowE [2];
  TH2F *   fhColRowTCardCorrNoSelectionExotic2ndCellSameNoDiffHighE[2];
  
  TH2F *   fhColRowTCardCorrNoSelectionLowE[2];             
  TH2F *   fhColRowTCardCorrNoSelectionHighE[2];            
 
  TH2F *   fhEnergyTimeTCardCorrNoSelection1Cell[2];        
  TH2F *   fhEnergyTMEtaResidualTCardCorrNoSelection1Cell;  
  TH2F *   fhEnergyTMPhiResidualTCardCorrNoSelection1Cell;  
  TH2F *   fhEnergyTimeTCardCorrNoSelectionExotic[2];       
  TH2F *   fhEnergyTMEtaResidualTCardCorrNoSelectionExotic; 
  TH2F *   fhEnergyTMPhiResidualTCardCorrNoSelectionExotic; 
  
  TH2F *   fhTimeTCardCorrNoSelection[2];                   
  TH2F *   fhLambda0TCardCorrNoSelection[2];                
  TH2F *   fhLambda1TCardCorrNoSelection[2];                
  TH2F *   fhLambda0NLM1TCardCorrNoSelection[2];            
  TH2F *   fhLambda1NLM1TCardCorrNoSelection[2];            
  TH2F *   fhLambda0NLM2TCardCorrNoSelection[2];            
  TH2F *   fhLambda1NLM2TCardCorrNoSelection[2];            
  TH2F *   fhLambdaRTCardCorrNoSelection[2];                
  TH2F *   fhNLocMaxTCardCorrNoSelection[2];                
 
  TH2F *   fhEMaxRatNLM1TCardCorrNoSelection[2];            
  TH2F *   fhEMaxRatNLM2TCardCorrNoSelection[2];            
  TH2F *   fhEMaxRatNLM3TCardCorrNoSelection[2];            
  TH2F *   fhE2ndRatNLM1TCardCorrNoSelection[2];            
  TH2F *   fhE2ndRatNLM2TCardCorrNoSelection[2];            
  TH2F *   fhE2ndRatNLM3TCardCorrNoSelection[2];            
  TH2F *   fhE2ndEMaxRatNLM1TCardCorrNoSelection[2];        
  TH2F *   fhE2ndEMaxRatNLM2TCardCorrNoSelection[2];        
  TH2F *   fhE2ndEMaxRatNLM3TCardCorrNoSelection[2];        

  TH2F *   fhE2ndSameRatNLM1TCardCorrNoSelection[2];        
  TH2F *   fhE2ndSameRatNLM2TCardCorrNoSelection[2];        
  TH2F *   fhE2ndSameRatNLM3TCardCorrNoSelection[2];        
  TH2F *   fhE2ndSameEMaxRatNLM1TCardCorrNoSelection[2];    
  TH2F *   fhE2ndSameEMaxRatNLM2TCardCorrNoSelection[2];    
  TH2F *   fhE2ndSameEMaxRatNLM3TCardCorrNoSelection[2];    

  TH2F *   fhECellClusRatNLM1TCardCorrNoSelection[2];       
  TH2F *   fhECellClusRatNLM2TCardCorrNoSelection[2];       
  TH2F *   fhECellClusRatNLM3TCardCorrNoSelection[2];       
  TH2F *   fhECellWeightNLM1TCardCorrNoSelection[2];        
  TH2F *   fhECellWeightNLM2TCardCorrNoSelection[2];        
  TH2F *   fhECellWeightNLM3TCardCorrNoSelection[2];        
  TH2F *   fhLogECellNLM1TCardCorrNoSelection[2];           
  TH2F *   fhLogECellNLM2TCardCorrNoSelection[2];           
  TH2F *   fhLogECellNLM3TCardCorrNoSelection[2];           

  TH2F *   fhECellSameClusRatNLM1TCardCorrNoSelection[2];   
  TH2F *   fhECellSameClusRatNLM2TCardCorrNoSelection[2];   
  TH2F *   fhECellSameClusRatNLM3TCardCorrNoSelection[2];   
  TH2F *   fhECellSameWeightNLM1TCardCorrNoSelection[2];    
  TH2F *   fhECellSameWeightNLM2TCardCorrNoSelection[2];    
  TH2F *   fhECellSameWeightNLM3TCardCorrNoSelection[2];    
  TH2F *   fhLogECellSameNLM1TCardCorrNoSelection[2];       
  TH2F *   fhLogECellSameNLM2TCardCorrNoSelection[2];       
  TH2F *   fhLogECellSameNLM3TCardCorrNoSelection[2];       

  
  TH2F *   fhNCellsTCardCorrNoSelection[2];                 
  TH2F *   fhNCellsTCardCorrWithWeightNoSelection[2];       
  TH2F *   fhNCellsTCardCorrRatioWithWeightNoSelection[2];  
  TH2F *   fhExoticTCardCorrNoSelection[2];                 

//  TH2F *   fhLambda0TCardCorrelN[8][2];                     //!<! Cluster m02 vs E, max cell correlated with 0 to >6 cells in TCard                
//  TH2F *   fhNCellsTCardCorrelN [8][2];                     //!<! Cluster Ncells vs E, select cells with w > 0.01, max cell correlated with 0 to >6 cells in TCard
//  TH2F *   fhExoticTCardCorrelN [8][2];                     //!<! Cluster exoticity vs E, select cells with w > 0.01, max cell correlated with 0 to >6 cells in TCard
//  TH2F *   fhColRowTCardCorrelNLowE [8][2];                 //!<! Cluster max cell col vs row, E > 2 GeV select cells with w > 0.01, max cell correlated with 0 to >6 cells in TCard
//  TH2F *   fhColRowTCardCorrelNHighE[8][2];                 //!<! Cluster max cell col vs row, E > 8 GeV select cells with w > 0.01, max cell correlated with 0 to >6 cells in TCard
//  
//  TH2F *   fhLambda0TCardCorrelNAllSameTCard[8][2];         //!<! Cluster m02 vs E, max cell correlated with 0 to >6 cells in TCard                
//  TH2F *   fhNCellsTCardCorrelNAllSameTCard [8][2];         //!<! Cluster Ncells vs E, select cells with w > 0.01, max cell correlated with 0 to >6 cells in TCard
//  TH2F *   fhExoticTCardCorrelNAllSameTCard [8][2];         //!<! Cluster exoticity vs E, select cells with w > 0.01, max cell correlated with 0 to >6 cells in TCard
//  TH2F *   fhColRowTCardCorrelNAllSameTCardLowE [8][2];     //!<! Cluster max cell col vs row, E > 2 GeV select cells with w > 0.01, max cell correlated with 0 to >6 cells in TCard
//  TH2F *   fhColRowTCardCorrelNAllSameTCardHighE[8][2];     //!<! Cluster max cell col vs row, E > 8 GeV select cells with w > 0.01, max cell correlated with 0 to >6 cells in TCard
//  
//  TH2F *   fhLambda0TCardCorrelNExotic[8][2];               //!<! Cluster m02 vs E, max cell correlated with 0 to >6 cells in TCard, exoticity > 0.97                
//  TH2F *   fhNCellsTCardCorrelNExotic [8][2];               //!<! Cluster Ncells vs E, select cells with w > 0.01, max cell correlated with >6 cells in TCard, exoticity > 0.97
//  TH2F *   fhColRowTCardCorrelNLowEExotic [8][2];           //!<! Cluster max cell col vs row, E > 2 GeV select cells with w > 0.01, max cell correlated with 0 to >6 cells in TCard
//  TH2F *   fhColRowTCardCorrelNHighEExotic[8][2];           //!<! Cluster max cell col vs row, E > 8 GeV select cells with w > 0.01, max cell correlated with 0 to >6 cells in TCard
//
//  TH2F *   fhLambda0TCardCorrelNAllSameTCardExotic[8][2];   //!<! Cluster m02 vs E, max cell correlated with 0 to >6 cells in TCard, exoticity > 0.97                
//  TH2F *   fhNCellsTCardCorrelNAllSameTCardExotic [8][2];   //!<! Cluster Ncells vs E, select cells with w > 0.01, max cell correlated with 0 to >6 cells in TCard, exoticity > 0.97
// 
//  
//  TH2F *   fhLambda0TCardCorrel[7][2];                      //!<! Cluster m02 vs E, max cell correlated with different combinations of cells in TCard               
//  TH2F *   fhNCellsTCardCorrel [7][2];                      //!<! Cluster Ncells vs E, select cells with w > 0.01, max cell correlated with different combinations of cells in TCard, exoticity > 0.97  
//  TH2F *   fhExoticTCardCorrel [7][2];                      //!<! Cluster exoticity vs E, select cells with w > 0.01, max cell correlated with different combinations of cells in TCard, exoticity > 0.97  
//
//  TH2F *   fhLambda0TCardCorrelExotic[4][2];                //!<! Cluster m02 vs E, max cell correlated with different combinations of cells in TCard, exoticity > 0.97                
//  TH2F *   fhNCellsTCardCorrelExotic [4][2];                //!<! Cluster Ncells vs E, select cells with w > 0.01, max cell correlated with different combinations of cells in TCard, exoticity > 0.97 

  TH2F *   fhLambda0Exoticity[14][2];                       
  TH2F *   fhLambda1Exoticity[14][2];                       
  TH2F *   fhLambdaRExoticity[14][2];                       
  TH2F *   fhNCellsExoticity [14][2];                       
  TH2F *   fhTimeExoticity   [14][2];                       
  TH2F *   fhLambda0Lambda1  [14][2];                       

//  TH2F *   fhLambda0ExoticityAllSameTCard[14][2];           //!<! Cluster m02 vs exoticy, for different cluster energy bins, all cells in same TCard as leading               
//  TH2F *   fhLambda1ExoticityAllSameTCard[14][2];           //!<! Cluster m02 vs exoticy, for different cluster energy bins, all cells in same TCard as leading               
//  TH2F *   fhLambdaRExoticityAllSameTCard[14][2];           //!<! Cluster m02 vs exoticy, for different cluster energy bins, all cells in same TCard as leading               
//  TH2F *   fhNCellsExoticityAllSameTCard [14][2];           //!<! Cluster NCells vs exoticy, for different cluster energy bins, all cells in same TCard as leading 
//  TH2F *   fhLambda0Lambda1AllSameTCard  [14][2];           //!<! Cluster m02 vs m20,for different cluster energy bins, all cells in same TCard as leading               
//  
  TH2F *   fhNCellsTCardSameAndDiff      [14][2];           
  TH2F *   fhNCellsTCardSameAndDiffExotic[14][2];           

  TH2F *   fhTMPhiResidualExoticity[14];                    
  TH2F *   fhTMEtaResidualExoticity[14];                    
  TH2F *   fhTMPhiResidualExoticityLooseCut[14];            
  TH2F *   fhTMEtaResidualExoticityLooseCut[14];            
//  TH2F *   fhTMPhiResidualExoticityAllSameTCard[14];        //!<! Cluster-track matching residual in phi vs exoticity, all cells in same TCard as leading                
//  TH2F *   fhTMEtaResidualExoticityAllSameTCard[14];        //!<! Cluster-track matching residual in phi vs exoticity, all cells in same TCard as leading                

  TH2F *   fhLambda0TCardCorrelNCell[6][6][2];              
  TH2F *   fhLambda1TCardCorrelNCell[6][6][2];              
  TH2F *   fhLambda0NLM1TCardCorrelNCell[6][6][2];          
  TH2F *   fhLambda1NLM1TCardCorrelNCell[6][6][2];          
  TH2F *   fhLambda0NLM2TCardCorrelNCell[6][6][2];          
  TH2F *   fhLambda1NLM2TCardCorrelNCell[6][6][2];          
//TH2F *   fhLambdaRTCardCorrelNCell[6][6][2];              //!<! Cluster m20/m02 vs E, cluster contains 0 to more than 6 cells with w > 0.01 in same TCard or diff TCard            
  TH2F *   fhNLocMaxTCardCorrelNCell[6][6][2];              
  
  TH2F *   fhEMaxRatNLM1TCardCorrelNCell[6][6][2];          
  TH2F *   fhEMaxRatNLM2TCardCorrelNCell[6][6][2];          
  TH2F *   fhEMaxRatNLM3TCardCorrelNCell[6][6][2];          
  TH2F *   fhE2ndRatNLM1TCardCorrelNCell[6][6][2];          
  TH2F *   fhE2ndRatNLM2TCardCorrelNCell[6][6][2];          
  TH2F *   fhE2ndRatNLM3TCardCorrelNCell[6][6][2];          
  TH2F *   fhE2ndEMaxRatNLM1TCardCorrelNCell[6][6][2];      
  TH2F *   fhE2ndEMaxRatNLM2TCardCorrelNCell[6][6][2];      
  TH2F *   fhE2ndEMaxRatNLM3TCardCorrelNCell[6][6][2];      

  TH2F *   fhECellClusRatNLM1TCardCorrelNCell[6][6][2];     
  TH2F *   fhECellClusRatNLM2TCardCorrelNCell[6][6][2];     
  TH2F *   fhECellClusRatNLM3TCardCorrelNCell[6][6][2];     
  TH2F *   fhLogECellNLM1TCardCorrelNCell    [6][6][2];     
  TH2F *   fhLogECellNLM2TCardCorrelNCell    [6][6][2];     
  TH2F *   fhLogECellNLM3TCardCorrelNCell    [6][6][2];     
  TH2F *   fhECellWeightNLM1TCardCorrelNCell [6][6][2];     
  TH2F *   fhECellWeightNLM2TCardCorrelNCell [6][6][2];     
  TH2F *   fhECellWeightNLM3TCardCorrelNCell [6][6][2];     
  
  TH2F *   fhMassEClusTCardCorrelNCell[6][6][2];            
//TH2F *   fhMassEPairTCardCorrelNCell[6][6][2];            //!<! Cluster invariant mass vs E pair, one of clusters  0.1<m02<0.4 contains 0 to more than 6 cells with w > 0.01, in same TCard or diff TCard            
  TH2F *   fhExoticTCardCorrelNCell   [6][6][2];            
  TH2F *   fhTimeDiffTCardCorrelNCell   [6][6][2];          
  TH2F *   fhTimeDiffExoTCardCorrelNCell[6][6][2];          
  TH2F *   fhColRowTCardCorrelNCellLowE [6][6][2];          
  TH2F *   fhColRowTCardCorrelNCellHighE[6][6][2];          
  TH2F *   fhColRowTCardCorrelNCellExoticLowE [6][6][2];    
  TH2F *   fhColRowTCardCorrelNCellExoticHighE[6][6][2];    

  TH2F *   fhLambda0ExoticityPerNCell[6][6][2];             
  TH2F *   fhLambda1ExoticityPerNCell[6][6][2];             
//TH2F *   fhLambdaRExoticityPerNCell[6][6][2];             //!<! Cluster m20/m02 vs exoticy,for E > 8 and n cell bins with w>0.01, in same TCard or diff TCard              

  TH2F *   fhNCellsTCardSameAndDiffFraction      [2];       
  TH2F *   fhNCellsTCardSameAndDiffFractionExotic[2];       
  
//TH2F *   fhLambda0TCardCorrelNearRow[6][2];               //!<! Cluster m02 vs E, max cell correlated with different combinations of cells in TCard, one correl. cell is 1 row away               
//TH2F *   fhNCellsTCardCorrelNearRow [6][2];               //!<! Cluster Ncells vs E, select cells with w > 0.01, max cell correlated with different combinations of cells in TCard, one correl. cell is 1 row away 
//  
//TH2F *   fhLambda0TCardCorrel2ndMax[4][2];                //!<! Cluster m02 vs E, max cell correlated with different combinations of cells in TCard, 2nd max also in TCard               
//TH2F *   fhNCellsTCardCorrel2ndMax [4][2];                //!<! Cluster Ncells vs E, select cells with w > 0.01, max cell correlated with different combinations of cells in TCard, 2nd Max in TCard
//
//  TH2F *   fhLambda0TCardCorrelOtherTCard[7][2];            //!<! Cluster m02 vs E, max cell correlated with different combinations of cells in TCard               
//  TH2F *   fhNCellsTCardCorrelOtherTCard [7][2];            //!<! Cluster Ncells vs E, select cells with w > 0.01, max cell correlated with different combinations of cells in TCard
//  TH2F *   fhExoticTCardCorrelOtherTCard [7][2];            //!<! Cluster exoticity vs E, select cells with w > 0.01, max cell correlated with different combinations of cells in TCard
//  TH2F *   fhColRowTCardCorrelOtherTCardLowE [7][2];        //!<! Cluster max cell col vs row, E > 2 GeV select cells with w > 0.01, max cell correlated with different combinations of cells in TCard
//  TH2F *   fhColRowTCardCorrelOtherTCardHighE[7][2];        //!<! Cluster max cell col vs row, E > 8 GeV select cells with w > 0.01, max cell correlated with different combinations of cells in TCard

  TH2F *   fhTCardCorrECellMaxDiff[12][2];                  
  TH2F *   fhTCardCorrEClusterDiff[12][2];                  
//TH2F *   fhTCardCorrECellMaxRat [12][2];                  //!<! Secondary cell energy in cluster / cell max energy vs cluster energy, different secondary cell selections depending on TCard
//TH2F *   fhTCardCorrEClusterRat [12][2];                  //!<! Secondary cell energy in cluster / cluster energy - vs cluster energy, different secondary cell selections depending on TCard
  TH2F *   fhTCardCorrTCellMaxDiff[12][2];                  

  TH2F *   fhTCardCorrECellMaxDiffExo[12][2];               
  TH2F *   fhTCardCorrEClusterDiffExo[12][2];               
//TH2F *   fhTCardCorrECellMaxRatExo [12][2];               //!<! Secondary cell energy in cluster / cell max energy vs cluster energy, different secondary cell selections depending on TCard
//TH2F *   fhTCardCorrEClusterRatExo [12][2];               //!<! Secondary cell energy in cluster / cluster energy - vs cluster energy, different secondary cell selections depending on TCard
  TH2F *   fhTCardCorrTCellMaxDiffExo[12][2];               
  
  TH2F *   fhSameRowDiffColAndTCardCellsEnergyDiffClusterE   [2]; 
  TH2F *   fhSameRowDiffColAndTCardCellsTimeDiffClusterE     [2]; 
  TH2F *   fhSameRowDiffColAndTCardCellsEnergyDiffCellMaxE   [2]; 
  TH2F *   fhSameRowDiffColAndTCardCellsTimeDiffCellMaxE     [2]; 
  TH2F *   fhSameRowDiffColAndTCardCellsEnergyDiffClusterEExo[2]; 
  TH2F *   fhSameRowDiffColAndTCardCellsTimeDiffClusterEExo  [2]; 
  TH2F *   fhSameRowDiffColAndTCardCellsEnergyDiffCellMaxEExo[2]; 
  TH2F *   fhSameRowDiffColAndTCardCellsTimeDiffCellMaxEExo  [2]; 
  
  //
  // Cluster shape studies
  //
  
  // Asymmetry
  // for neutral, electrons and hadrons
  TH3F *   fhDeltaIEtaDeltaIPhi[3];             
  TH2F *   fhDeltaIA[3];                        
  TH3F *   fhDeltaIAM02[3];                     
  TH3F *   fhDeltaIAM20[3];                     
  TH3F *   fhDeltaIANCells[3] ;                 
  TH3F *   fhDeltaIAOrigin[3];                  
  
  TH3F *   fhDeltaIEtaDeltaIPhiTot[3];          
  TH2F *   fhDeltaIATot[3];                     
  TH3F *   fhDeltaIATotM02[3];                  
  TH3F *   fhDeltaIATotM20[3];                  
  TH3F *   fhDeltaIATotNCells[3] ;              
  TH3F *   fhDeltaIATotOrigin[3];               
  // Shower shape dependence 
  //
//TH3F *   fhCellTimeSpreadRespectToCellMaxM02;  //!<! Difference of the time of cell with maximum dep energy and the rest of cells
//TH3F *   fhClusterMaxCellCloseCellDiffM02;     //!<! Difference between max cell energy and cell energy of the same cluster
  TH3F *   fhClusterMaxCellCloseCellRatioM02;    
  TH3F *   fhClusterMaxCellECrossM02;            
 
  // for neutral, electrons and hadrons
  TH3F *   fhClusterTimeEnergyM02 [3];           
  TH3F *   fhClusterMaxCellDiffM02[3];           
  TH3F *   fhNCellsPerClusterM02  [3];           
  TH3F *   fhNCellsPerClusterM20  [3];           
  TH3F *   fhNCellsPerClusterNLM  [3];           

  TH3F *   fhNCellsPerClusterM02PerSMPerCol[20][2]; 
  TH3F *   fhNCellsPerClusterM20PerSMPerCol[20][2]; 
  TH3F *   fhNCellsPerClusterNLMPerSMPerCol[20][2]; 
  
  TH3F *   fhNCellsPerClusterMEta    [3];         
  TH3F *   fhNCellsPerClusterMPhi    [3];         
  TH3F *   fhNCellsPerClusterMEtaPhi [3];         
  TH3F *   fhNCellsPerClusterMEtaPhiA[3];         

  TH3F *   fhInvMassNCellSM;                      
  TH3F *   fhInvMassNCellSMSame;                  
  
  TH3F *   fhColRowM02;                           
  TH3F *   fhColRowM02NCellCut;                   
  
  TH2F *   fhOriginENoCut  [3];                   
  TH3F *   fhOriginM02NoCut[3];                   
  TH2F *   fhOriginE  [3];                        
  TH3F *   fhOriginM02[3];                        

  TH2F *   fhOriginENoCutOverlap  [3];            
  TH3F *   fhOriginM02NoCutOverlap[3];            
  TH2F *   fhOriginEOverlap  [3];                 
  TH3F *   fhOriginM02Overlap[3];                 
  
  TH3F *   fhSMM02NoCut[3];                       
  TH3F *   fhSMM02    [3];                        
  TH3F *   fhSMM20HighM02NoCut[3];                
  TH3F *   fhSMM20HighM02[3];                     
  TH3F *   fhSMM20LowM02NoCut[3];                 
  TH3F *   fhSMM20LowM02[3];                      
  TH3F *   fhSMNLocMax[3];                        
  TH3F *   fhSMNCell  [3];                        
  TH3F *   fhSMNCellLowM02[3];                    
  TH3F *   fhSMNCellHighM02[3];                   
  TH3F *   fhSMNCellM02[3];                       
  TH3F *   fhColM02   [3];                        
  TH3F *   fhRowM02   [3];                        
  
  TH3F *   fhSMMEtaNoCut    [3];                  
  TH3F *   fhSMMEta         [3];                  
  TH3F *   fhSMMPhiNoCut    [3];                  
  TH3F *   fhSMMPhi         [3];                  
  TH3F *   fhSMMEtaPhiNoCut [3];                  
  TH3F *   fhSMMEtaPhi      [3];                  
  TH3F *   fhSMMEtaPhiANoCut[3];                  
  TH3F *   fhSMMEtaPhiA     [3];                  
  
  TH3F *   fhEMaxCellTimeM02SM  ;                 
  TH3F *   fhEMaxCellTimeNCellSM;                 
  TH3F *   fhESecCellTimeNCellSM;                 

  // 8 < E < 12 GeV per SM, neutral
  TH3F *   fhNCellsPerClusterM02M20PerSM  [20];   
  TH3F *   fhNCellsPerClusterM02NLMPerSM  [20];   
  TH3F *   fhESecCellEMaxCellM02NCellPerSM[20];   
  TH3F *   fhESecCellEClusterM02NCellPerSM[20];   
//TH3F *   fhESecCellLogM02NCellPerSM     [20];   //!<! m02 vs SM number vs ncell vs log E cell 

  TH3F *   fhEMaxCellEClusterM02NCellPerSM[20];   
//TH3F *   fhEMaxCellLogM02NCellPerSM     [20];   //!<! m02 vs SM number vs ncell vs log E max cell 

  TH3F *   fhEMaxESecCellNCellLowM02PerSM [20];   
  TH3F *   fhEMaxECrossNCellLowM02PerSM   [20];   
  
  TH3F *   fhEMaxESecCellNCellHighM02PerSM[20];   
  TH3F *   fhEMaxECrossNCellHighM02PerSM  [20];   

  TH3F *   fhColRowFromCellMaxLowM02PerSM [20][2];
  TH3F *   fhColRowFromCellMaxHighM02PerSM[20][2];

  TH3F *   fhColRowFromCellMaxEMaxSecDiffLowM02PerSM [20][2][4];
  TH3F *   fhColRowFromCellMaxEMaxSecDiffHighM02PerSM[20][2][4];

  TH3F *   fhColRowFromCellMaxEMaxSecDiffFracLowM02PerSM [20][2][4];
  TH3F *   fhColRowFromCellMaxEMaxSecDiffFracHighM02PerSM[20][2][4];

  TH3F *   fhColRowFromCellMaxECellClusterRatLowM02PerSM [20][2][4];
  TH3F *   fhColRowFromCellMaxECellClusterRatHighM02PerSM[20][2][4];

  TH2F *   fhColRowFromCellMaxLowM02         [2]; 
  TH2F *   fhColRowFromCellMaxHighM02        [2]; 
 
  // EMCal module studies
  //
  TH3F *   fhSMNCellModuleMax;                  
  TH3F *   fhSMNCellModuleOut;                  
  TH3F *   fhSMNCellModuleOutModSame;           
  TH3F *   fhSMNCellModuleOutModDiff;           
  TH3F *   fhSMECellModuleMax;                  
  TH3F *   fhSMECellModuleMaxTot;               
  TH3F *   fhSMECellModuleOut;                  
  TH3F *   fhSMECellModuleOutModSame;           
  TH3F *   fhSMECellModuleOutModDiff;           
  
  TH3F *   fhSMNCellModuleMaxOutRat;            
  TH3F *   fhSMNCellModuleMaxOutModSameRat;     
  TH3F *   fhSMNCellModuleMaxOutModDiffRat;     
  TH3F *   fhSMECellModuleMaxRat ;              
  TH3F *   fhSMECellModuleMaxTotRat ;           
  TH3F *   fhSMECellModuleMaxTotRatClus ;       
  TH3F *   fhSMECellModuleMaxOutRat;            
  TH3F *   fhSMECellModuleMaxOutModSameRat;     
  TH3F *   fhSMECellModuleMaxOutModDiffRat;     
  
  TH3F *   fhSMNCellModuleMaxLowM02;            
  TH3F *   fhSMNCellModuleOutLowM02;            
  TH3F *   fhSMNCellModuleOutModSameLowM02;     
  TH3F *   fhSMNCellModuleOutModDiffLowM02;     
  TH3F *   fhSMECellModuleMaxLowM02;            
  TH3F *   fhSMECellModuleMaxTotLowM02;         
  TH3F *   fhSMECellModuleOutLowM02;            
  TH3F *   fhSMECellModuleOutModSameLowM02;     
  TH3F *   fhSMECellModuleOutModDiffLowM02;     
  
  TH3F *   fhSMNCellModuleMaxOutRatLowM02;      
  TH3F *   fhSMNCellModuleMaxOutModSameRatLowM02;
  TH3F *   fhSMNCellModuleMaxOutModDiffRatLowM02;
  TH3F *   fhSMECellModuleMaxRatLowM02 ;        
  TH3F *   fhSMECellModuleMaxTotRatLowM02 ;     
  TH3F *   fhSMECellModuleMaxTotRatClusLowM02 ; 
  TH3F *   fhSMECellModuleMaxOutRatLowM02;      
  TH3F *   fhSMECellModuleMaxOutModSameRatLowM02;
  TH3F *   fhSMECellModuleMaxOutModDiffRatLowM02;
  
  TH3F *   fhSMNCellModuleMaxHighM02;           
  TH3F *   fhSMNCellModuleOutHighM02;           
  TH3F *   fhSMNCellModuleOutModSameHighM02;    
  TH3F *   fhSMNCellModuleOutModDiffHighM02;    
  TH3F *   fhSMECellModuleMaxHighM02;           
  TH3F *   fhSMECellModuleMaxTotHighM02;        
  TH3F *   fhSMECellModuleOutHighM02;           
  TH3F *   fhSMECellModuleOutModSameHighM02;    
  TH3F *   fhSMECellModuleOutModDiffHighM02;    
  
  TH3F *   fhSMNCellModuleMaxOutRatHighM02;     
  TH3F *   fhSMNCellModuleMaxOutModSameRatHighM02;
  TH3F *   fhSMNCellModuleMaxOutModDiffRatHighM02;
  TH3F *   fhSMECellModuleMaxRatHighM02 ;       
  TH3F *   fhSMECellModuleMaxTotRatHighM02 ;    
  TH3F *   fhSMECellModuleMaxTotRatClusHighM02; 
  TH3F *   fhSMECellModuleMaxOutRatHighM02;     
  TH3F *   fhSMECellModuleMaxOutModSameRatHighM02;
  TH3F *   fhSMECellModuleMaxOutModDiffRatHighM02;
  
  TH3F *   fhSMEMaxEClusterRat;                 
  TH3F *   fhSMEMaxEClusterRatLowM02;           
  TH3F *   fhSMEMaxEClusterRatHighM02;          
  
  TH3F *   fhTCardChannelM02;                   
  TH3F *   fhTCardChannelM02NoCut;              
  TH3F *   fhTCardChannelNCellModMax;           
  TH3F *   fhTCardChannelNCell;                 
  
  // Weight studies
  //
  
  TH2F *   fhECellClusterRatio;                 
  TH2F *   fhECellClusterLogRatio;              
  TH2F *   fhEMaxCellClusterRatio;              
  TH2F *   fhEMaxCellClusterLogRatio;           
  
  TH2F *   fhLambda0ForW0AndCellCuts    [12][4][3]; 
  TH2F *   fhLambda0ForW0AndCellCutsEta0[12][4][3]; 
//TH2F *   fhLambda1ForW0AndCellCuts    [12][4][3]; //!<! L1 for different w0 and cell cuts
  
  TH2F *   fhLambda0ForW0MC[12][5];             
//TH2F *   fhLambda1ForW0MC[12][5];             //!<! L1 for different w0, depending on the particle of origin
  
  TH2F *   fhECellTotalRatio;                   
  TH2F *   fhECellTotalLogRatio;                
  TH2F **  fhECellTotalRatioMod;                
  TH2F **  fhECellTotalLogRatioMod;             
  
  AliAnaClusterShapeCorrelStudies & operator = (const AliAnaClusterShapeCorrelStudies & qa) ;
    
  AliAnaClusterShapeCorrelStudies(              const AliAnaClusterShapeCorrelStudies & qa) ;
  
  ClassDef(AliAnaClusterShapeCorrelStudies,8) ;

} ;

#endif //ALIANACLUSTERSHAPECORRELSTUDIES_H