AliAnalysisTaskNucleiYield.h

Go to the documentation of this file.

#ifndef __AliAnalysisTaskNucleiYield__
#define __AliAnalysisTaskNucleiYield__

#include "AliAnalysisTaskSE.h"
#include <Rtypes.h>
#include <TString.h>
#include <TArrayF.h>
#include <TList.h>
#include <AliPIDResponse.h>
class TH2F;
class TH3F;
class AliFlowTrackCuts;
class AliAODTrack;
class AliVVertex;
class AliPIDResponse;

class AliAnalysisTaskNucleiYield : public AliAnalysisTaskSE {
public:
  AliAnalysisTaskNucleiYield(TString taskname = "NucleiYieldTask");
  virtual ~AliAnalysisTaskNucleiYield();

  void SetParticleType(AliPID::EParticleType part); 
  void SetPDG (int pdg) { fPDG = (pdg >= 0) ? pdg : -pdg; }
  void SetIsMC (bool isMc) { fIsMC = isMc; }
  void SetFillOnlyEventHistos (bool onlyEventHistos) { fFillOnlyEventHistos = onlyEventHistos; }
  
  void SetRequireITSrefit (bool refit = true) { fRequireITSrefit = refit; }
  void SetRequireTPCrefit (bool refit = true) { fRequireTPCrefit = refit; }  
  void SetRequireNoKinks (bool nokinks = true) { fRequireNoKinks = nokinks; }
  void SetRequireITSrecPoints (int rec = 4) { fRequireITSrecPoints = rec; }
  void SetRequireITSsignal (int sig = 3) { fRequireITSsignal = sig; }
  void SetRequireTPCrecPoints (int rec = 70) { fRequireITSrecPoints = rec; }
  void SetRequireTPCsignal (int sig = 70) { fRequireITSsignal = sig; }
  void SetRequireSDDrecPoints (int rec = 1) { fRequireSDDrecPoints = rec; }
  void SetRequireSPDrecPoints (int rec = 1) { fRequireSPDrecPoints = rec; }
  void SetEtaRange (float emin, float emax) { fRequireEtaMin = emin; fRequireEtaMax = emax; }
  void SetYRange (float ymin, float ymax) { fRequireYmin = ymin; fRequireYmax = ymax; }
  void SetRequireMaxChi2 (float maxChi2 = 4.f) { fRequireMaxChi2 = maxChi2; }
  void SetRequireMaxDCAxy (float maxDCA) { fRequireMaxDCAxy = maxDCA; }
  void SetRequireMaxDCAz (float maxDCA) { fRequireMaxDCAz = maxDCA; }
  void SetRequireTPCpidSigmas (float sig) { fRequireTPCpidSigmas = (sig > 0) ? sig : -sig; }
  void SetRequireITSpidSigmas (float sig) { fRequireITSpidSigmas = sig; }
  void SetRequireMinEnergyLoss (float ecut) { fRequireMinEnergyLoss = ecut; }
  void SetRequireMagneticField (int cut) { fRequireMagneticField = cut; }
  void SetRequireVetoSPD(bool veto) { fRequireVetoSPD = veto; }
  void SetEnablePerformancePlot(bool cut) { fEnablePerformance = cut; }
  void SetEnablePtCorrection(bool cut) { fEnablePtCorrection = cut; }
  
  void SetCentBins (Int_t nbins, Float_t *bins);
  void SetDCABins (Int_t nbins, Float_t min, Float_t max);
  void SetPtBins (Int_t nbins, Float_t *bins);
  void SetCustomTPCpid (Float_t *par, Float_t sigma);
  void SetTOFBins (Int_t nbins, Float_t min, Float_t max);
  void SetDCAzBins (Int_t nbins, Float_t limit);
  void SetFlatteningProbabilities (Int_t n, Float_t *probs) { fFlatteningProbs.Set(n,probs); }
  
  virtual void   UserCreateOutputObjects();
  virtual void   UserExec(Option_t *);
  virtual void   Terminate(Option_t *);
  
private:
  AliAnalysisTaskNucleiYield (const AliAnalysisTaskNucleiYield &source);
  AliAnalysisTaskNucleiYield &operator=(const AliAnalysisTaskNucleiYield &source);
  
  Bool_t AcceptTrack(AliAODTrack *t, Double_t dca[2]);
  Bool_t PassesPIDSelection(AliAODTrack *t);
  Float_t HasTOF(AliAODTrack *t);
  
  Bool_t Flatten(float cent);
  void PtCorrection(float &pt, bool positiveCharge);
  
  TList                *fList;                  
  Int_t                 fPDG;                   
  Float_t               fPDGMass;               
  Float_t               fPDGMassOverZ;          
  Bool_t                fIsMC;                  
  Bool_t                fFillOnlyEventHistos;   
  
  AliPIDResponse       *fPID;                   
  Float_t               fMagField;              
  AliVVertex           *fPrimaryVertex;         
  
  TList                 fMmc;                   
  TList                 fAmc;                   
  
  Float_t               fDCAzLimit;             
  Int_t                 fDCAzNbins;             
  
  TArrayF               fPtCorrectionA;         
  TArrayF               fPtCorrectionM;         
  
  Float_t               fTOFlowBoundary;        
  Float_t               fTOFhighBoundary;       
  Int_t                 fTOFnBins;              
  
  Bool_t                fEnablePerformance;     
  Bool_t                fEnablePtCorrection;    
  Bool_t                fRequireITSrefit;       
  Bool_t                fRequireTPCrefit;       
  Bool_t                fRequireNoKinks;        
  UShort_t              fRequireITSrecPoints;   
  UShort_t              fRequireITSsignal;      
  UShort_t              fRequireSDDrecPoints;   
  UShort_t              fRequireSPDrecPoints;   
  UShort_t              fRequireTPCrecPoints;   
  UShort_t              fRequireTPCsignal;      
  Float_t               fRequireEtaMin;         
  Float_t               fRequireEtaMax;         
  Float_t               fRequireYmin;           
  Float_t               fRequireYmax;           
  Float_t               fRequireMaxChi2;        
  Float_t               fRequireMaxDCAxy;       
  Float_t               fRequireMaxDCAz;        
  Float_t               fRequireTPCpidSigmas;   
  Float_t               fRequireITSpidSigmas;   
  Float_t               fRequireMinEnergyLoss;  
  Int_t                 fRequireMagneticField;  
  Bool_t                fRequireVetoSPD;        

  
  AliPID::EParticleType fParticle;              
  TArrayF               fCentBins;              
  TArrayF               fDCABins;               
  TArrayF               fPtBins;                
  TArrayF               fCustomTPCpid;          
  TArrayF               fFlatteningProbs;       
  
  // Event related histograms
  TH1F                 *fCentrality;            
  TH1F                 *fFlattenedCentrality;   
  TH1F                 *fCentralityClasses;     
  
  // MC only histograms
  TH1F                 *fProduction;            
  TH2F                 *fAITS_TPC;              
  TH2F                 *fAITS_TPC_TOF;          
  TH2F                 *fATotal;                
  TH2F                 *fAPtCorrection;         
  TH2F                 *fMITS_TPC;              
  TH2F                 *fMITS_TPC_TOF;          
  TH2F                 *fMTotal;                
  TH2F                 *fMPtCorrection;         
  TH3F                 *fMDCAPrimaryTPC;        
  TH3F                 *fMDCASecondaryTPC;      
  TH3F                 *fMDCAPrimaryTOF;        
  TH3F                 *fMDCASecondaryTOF;      
  
  // Data histograms
  TH3F                 *fATOFsignal;            
  TH2F                 *fATPCcounts;            
  TH3F                 *fATOFphiSignal;         
  TH2F                 *fATPCphiCounts;         
  TH2F                 *fATPCeLoss;             
  TH3F                 *fMDCAxyTPC;             
  TH3F                 *fMDCAzTPC;              
  TH3F                 *fMDCAxyTOF;             
  TH3F                 *fMDCAzTOF;              
  TH3F                 *fMTOFsignal;            
  TH2F                 *fMTPCcounts;            
  TH3F                 *fMTOFphiSignal;         
  TH2F                 *fMTPCphiCounts;         
  TH2F                 *fMTPCeLoss;             
  
  ClassDef(AliAnalysisTaskNucleiYield, 1);
};


#endif /* defined(__AliAnalysisTaskNucleiYield__) */