AliAnalysisTaskMuonPerformance.h

Go to the documentation of this file.

#ifndef ALIANALYSISTASKMUONPERFORMANCE_H
#define ALIANALYSISTASKMUONPERFORMANCE_H

//  Author D.Stocco and P.Pillot, Subatech, Nantes


#include "AliAnalysisTaskSE.h"
#include "AliLog.h"

class TObjArray;
class TH1;
class TH2;
class TGraphAsymmErrors;
class TGraphErrors;
class TCanvas;
class AliMUONRecoParam;
class AliCFContainer;
class AliMCParticle;
class AliESDMuonTrack;
class AliCFEffGrid;

class AliAnalysisTaskMuonPerformance : public AliAnalysisTaskSE {
 public:
  AliAnalysisTaskMuonPerformance();
  AliAnalysisTaskMuonPerformance(const char *name);
  virtual ~AliAnalysisTaskMuonPerformance();
  
  void SetDefaultStorage(const char* ocdbPath) { fDefaultStorage = ocdbPath; }
  
  void SetAlignStorage(const char* ocdbPath) { fAlignOCDBpath = ocdbPath; }
  
  void SetRecoParamStorage(const char* ocdbPath) { fRecoParamOCDBpath = ocdbPath; }
  
  // Set the binning to be used to study the detector resolution versus momentum
  void SetPBins(Int_t nBins, Double_t min, Double_t max);
  
  void CorrectClusterResForSystematics(Bool_t flag = kTRUE) { fCorrectForSystematics = flag; }
  
  void FitClusterResiduals(Bool_t flag = kTRUE) { fFitResiduals = flag; }
  
  void EnforceTrackingCriteria(Bool_t flag = kTRUE) { fEnforceTrkCriteria = flag; }
  
  void UseMCKinematics(Bool_t flag = kTRUE) { fUseMCKinematics = flag; }
  
  void SetMCTrigLevelFromMatchTrk(Bool_t flag = kTRUE) { fMCTrigLevelFromMatchTrk = flag; }
  
  virtual void   UserCreateOutputObjects();
  virtual void   UserExec(Option_t *option);
  virtual void   Terminate(Option_t *option);
  virtual void   NotifyRun();
  
  enum {
    kVarPt,         
    kVarEta,        
    kVarPhi,        
    kVarThetaZones, 
    kVarCharge,     
    kVarHasTracker, 
    kVarTrigger,    
    kVarMotherType, 
    kVarMatchMC,    
    kVarMCTrigger,  
    kVarCent,       
    kVarDupliTrg,   
    kNvars          
  };
  
  enum {
    kStepReconstructed, 
    kStepGeneratedMC,   
    kNsteps             
  };
  
 private:
  
  AliAnalysisTaskMuonPerformance(const AliAnalysisTaskMuonPerformance&);
  AliAnalysisTaskMuonPerformance& operator=(const AliAnalysisTaskMuonPerformance&);
  
  Bool_t  GetEfficiency(AliCFEffGrid* efficiency, Double_t& calcEff, Double_t& calcEffErr);
  Int_t   RecoTrackMother(AliMCParticle* mcParticle);
  Float_t GetBinThetaAbsEnd(Float_t RAtAbsEnd, Bool_t isTheta = kFALSE);
  void    FillContainerInfoReco(Double_t* containerInput, AliESDMuonTrack* esdTrack, Bool_t isValid, Int_t mcID);
  void    FillContainerInfoMC(Double_t* containerInput, AliMCParticle* mcPart);
  
  void    FitLandauGausResVsP(TH2* h, const char* fitting, TGraphAsymmErrors* gMean, TGraphAsymmErrors* gMostProb, TGraphAsymmErrors* gSigma);
  void    FitGausResVsMom(TH2* h, const Double_t mean0, const Double_t sigma0, const char* fitting, TGraphAsymmErrors* gMean, TGraphAsymmErrors* gSigma);
  void    FitPDCAVsMom(TH2* h, const char* fitting, TGraphAsymmErrors* gMean, TGraphAsymmErrors* gSigma);
  void    FitClusterResidual(TH1* h, Int_t i, Double_t& sigma, TGraphErrors* gMean, TGraphErrors* gSigma);
  
  TCanvas* DrawVsAng(const char* name, const char* title, TH1* h1, TH2* h2);
  TCanvas* DrawVsPos(const char* name, const char* title, TH2* h1, TH2* h2, TH2* h3);
  TCanvas* DrawFitLandauGausResPVsP(const char* name, const char* title, TH2* h, const Int_t nBins, const char* fitting);
  TCanvas* DrawResPVsP(const char* name, const char* title, TH2* h, const Int_t nBins);
  
  void Zoom(TH1* h, Double_t fractionCut = 0.01);
  
  void FillEffHistos(AliCFEffGrid* efficiency, const char* suffix, TObjArray* list);
  
  enum {
    kNoMatchTrig,  
    kOtherTrig,    
    kAllPtTrig,    
    kLowPtTrig,    
    kHighPtTrig,   
    kNtrigCuts     
  };
  
  enum {
    kCharmMu,       
    kBeautyMu,      
    kPrimaryMu,     
    kSecondaryMu,   
    kRecoHadron,    
    kUnknownPart,   
    kNtrackSources  
  };
  
  enum {
    kNoMatch,     
    kTrackerOnly, 
    kMatchedSame, 
    kMatchedDiff, 
    kTriggerOnly, 
    kNMatchMC     
  };
  
  // Histograms for trigger resolution
  enum {
    kResTrigX11,                          
    kResTrigY11,                          
    kResTrigSlopeY                        
  };
  
  // Histograms for tracker resolution
  enum {
    kResPAtVtx,                           
    kResPAtVtxVsP,                        
    kResPAtVtxVsPIn23deg,                 
    kResPAtVtxVsPIn310deg,                
    kResPAtVtxVsPIn02degMC,               
    kResPAtVtxVsPosAbsEndIn02degMC,       
    kResPAtVtxVsPosAbsEndIn23degMC,       
    kResPAtVtxVsPosAbsEndIn310degMC,      
    kResPAtVtxVsAngleAtAbsEnd,            
    kResPAtVtxVsMCAngle,                  
    kResPAtVtxVsAngleAtAbsEndVsP,         
    kResPtAtVtxVsPt,                      
    
    kResPAt1stCl,                         
    kResPAt1stClVsP,                      
    kResPtAt1stClVsPt,                    
    
    kResSlopeXAtVtx,                      
    kResSlopeYAtVtx,                      
    kResSlopeXAtVtxVsP,                   
    kResSlopeYAtVtxVsP,                   
    kResSlopeXAtVtxVsPosAbsEndIn02degMC,  
    kResSlopeYAtVtxVsPosAbsEndIn02degMC,  
    kResSlopeXAtVtxVsPosAbsEndIn23degMC,  
    kResSlopeYAtVtxVsPosAbsEndIn23degMC,  
    kResSlopeXAtVtxVsPosAbsEndIn310degMC, 
    kResSlopeYAtVtxVsPosAbsEndIn310degMC, 
    kResSlopeXAtVtxVsAngleAtAbsEnd,       
    kResSlopeYAtVtxVsAngleAtAbsEnd,       
    kResSlopeXAtVtxVsMCAngle,             
    kResSlopeYAtVtxVsMCAngle,             
    
    kResSlopeXAt1stCl,                    
    kResSlopeYAt1stCl,                    
    kResSlopeXAt1stClVsP,                 
    kResSlopeYAt1stClVsP,                 
    
    kResEtaAtVtx,                         
    kResEtaAtVtxVsP,                      
    kResEtaAtVtxVsPosAbsEndIn02degMC,     
    kResEtaAtVtxVsPosAbsEndIn23degMC,     
    kResEtaAtVtxVsPosAbsEndIn310degMC,    
    kResEtaAtVtxVsAngleAtAbsEnd,          
    kResEtaAtVtxVsMCAngle,                
    
    kResPhiAtVtx,                         
    kResPhiAtVtxVsP,                      
    kResPhiAtVtxVsPosAbsEndIn02degMC,     
    kResPhiAtVtxVsPosAbsEndIn23degMC,     
    kResPhiAtVtxVsPosAbsEndIn310degMC,    
    kResPhiAtVtxVsAngleAtAbsEnd,          
    kResPhiAtVtxVsMCAngle,                
    
    kPDCA,                                
    kPDCAVsPIn23deg,                      
    kPDCAVsPIn310deg,                     
    kPDCAVsPosAbsEndIn02degMC,            
    kPDCAVsPosAbsEndIn23degMC,            
    kPDCAVsPosAbsEndIn310degMC,           
    kPDCAVsAngleAtAbsEnd,                 
    kPDCAVsMCAngle,                       
    
    kPMCSAngVsPIn23deg,                   
    kPMCSAngVsPIn310deg,                  
    
    kResClXVsCh,                          
    kResClYVsCh,                          
    kResClXVsDE,                          
    kResClYVsDE                           
  };
  
  // Graphs and canvases for momentum resolution at vertex
  enum {
    kMeanResPAtVtxVsP,                    
    kMostProbResPAtVtxVsP,                
    kSigmaResPAtVtxVsP,                   
    kcResPAtVtx,                          
    kcResPAtVtxMC,                        
    kcResPAtVtxVsPosAbsEndMC,             
    kcResPAtVtxVsPIn23deg,                
    kcResPAtVtxVsPIn310deg,               
    kcResPAtVtxVsPIn02degMC               
  };
  
  // Graphs for momentum resolution at first cluster
  enum {
    kMeanResPAt1stClVsP,                  
    kSigmaResPAt1stClVsP                  
  };
  
  // Graphs and canvases for slope resolution at vertex
  enum {
    kMeanResSlopeXAtVtxVsP,               
    kMeanResSlopeYAtVtxVsP,               
    kSigmaResSlopeXAtVtxVsP,              
    kSigmaResSlopeYAtVtxVsP,              
    kcResSlopeXAtVtx,                     
    kcResSlopeYAtVtx,                     
    kcResSlopeXAtVtxMC,                   
    kcResSlopeYAtVtxMC,                   
    kcResSlopeXAtVtxVsPosAbsEndMC,        
    kcResSlopeYAtVtxVsPosAbsEndMC         
  };
  
  // Graphs for slope resolution at first cluster
  enum {
    kMeanResSlopeXAt1stClVsP,             
    kMeanResSlopeYAt1stClVsP,             
    kSigmaResSlopeXAt1stClVsP,            
    kSigmaResSlopeYAt1stClVsP             
  };
  
  // Graphs and canvases for eta resolution at vertex
  enum {
    kMeanResEtaAtVtxVsP,                  
    kSigmaResEtaAtVtxVsP,                 
    kcResEtaAtVtx,                        
    kcResEtaAtVtxMC,                      
    kcResEtaAtVtxVsPosAbsEndMC            
  };
  
  // Graphs and canvases for phi resolution at vertex
  enum {
    kMeanResPhiAtVtxVsP,                  
    kSigmaResPhiAtVtxVsP,                 
    kcResPhiAtVtx,                        
    kcResPhiAtVtxMC,                      
    kcResPhiAtVtxVsPosAbsEndMC            
  };
  
  // Graphs and cavases for DCA resolution and MCS dispersion
  enum {
    kMeanPDCAVsPIn23deg,                  
    kSigmaPDCAVsPIn23deg,                 
    kMeanPDCAVsPIn310deg,                 
    kSigmaPDCAVsPIn310deg,                
    kMeanPMCSAngVsPIn23deg,               
    kSigmaPMCSAngVsPIn23deg,              
    kMeanPMCSAngVsPIn310deg,              
    kSigmaPMCSAngVsPIn310deg,             
    kcPDCA,                               
    kcPDCAMC,                             
    kcPDCAVsPosAbsEndMC                   
  };
  
  // Graphs for cluster resolution
  enum {
    kMeanResClXVsCh,                      
    kMeanResClYVsCh,                      
    kSigmaResClXVsCh,                     
    kSigmaResClYVsCh,                     
    kMeanResClXVsDE,                      
    kMeanResClYVsDE,                      
    kSigmaResClXVsDE,                     
    kSigmaResClYVsDE                      
  };
  
  TString  fDefaultStorage;          
  TString  fAlignOCDBpath;           
  TString  fRecoParamOCDBpath;       
  Int_t    fNPBins;                  
  Double_t fPRange[2];               
  Bool_t   fCorrectForSystematics;   
  Bool_t   fFitResiduals;            
  Bool_t   fEnforceTrkCriteria;      
  Bool_t   fUseMCKinematics;         
  Bool_t   fMCTrigLevelFromMatchTrk; 
  UInt_t   fRequestedStationMask;    
  Bool_t   fRequest2ChInSameSt45;    
  Double_t fSigmaCutTrig;            
  Double_t fClusterMaxRes[2];        
  Int_t    fNDE;                     
  Int_t    fDEIndices[1100];         
  Int_t    fDEIds[200];              
  
  AliCFContainer* fCFContainer; 
  TObjArray* fEfficiencyList;   
  TObjArray* fTriggerList;      
  TObjArray* fTrackerList;      
  TObjArray* fPAtVtxList;       
  TObjArray* fSlopeAtVtxList;   
  TObjArray* fEtaAtVtxList;     
  TObjArray* fPhiAtVtxList;     
  TObjArray* fPAt1stClList;     
  TObjArray* fSlopeAt1stClList; 
  TObjArray* fDCAList;          
  TObjArray* fClusterList;      
  
  ClassDef(AliAnalysisTaskMuonPerformance, 3); // Muon performance analysis
};

inline void AliAnalysisTaskMuonPerformance::SetPBins(Int_t nBins, Double_t pMin, Double_t pMax)
{
  if (nBins > 0) fNPBins = nBins;
  else AliError("Incorrect number of momentum bins");
  if (pMin >= 0. && pMax > pMin) {
    fPRange[0] = pMin;
    fPRange[1] = pMax;
  } else AliError("Incorrect momentum range");
}


#endif