AliAnalysisTaskVnV0.h

Go to the documentation of this file.

#ifndef ALIANALYSISTASKVNV0_H
#define ALIANALYSISTASKVNV0_H

// ROOT includes
#include <TObject.h>
#include <TClonesArray.h>
#include "TTree.h"
#include <TList.h>
#include <TProfile.h>

// AliRoot includes
#include <AliAnalysisTaskSE.h>
#include <AliAODEvent.h>
#include "AliFlowBayesianPID.h"
#include "AliFlowVZEROResults.h"
#include "AliFlowVZEROQA.h"

class TH2F;
class AliESDtrackCuts;
class TProfile2D;

class AliAnalysisTaskVnV0 : public AliAnalysisTaskSE {
 public:
  AliAnalysisTaskVnV0();
  AliAnalysisTaskVnV0(const char *name);

  virtual ~AliAnalysisTaskVnV0();

  virtual void   UserCreateOutputObjects();
  virtual void   UserExec(Option_t *option);
  virtual void   Terminate(Option_t *); 
  
  Double_t GetVtxCut() { return fVtxCut; }   
  Double_t GetEtaCut() { return fEtaCut; }     
  Double_t GetMinPt() { return fMinPt; }   

  virtual void  SetVtxCut(Double_t vtxCut){fVtxCut = vtxCut;}
  virtual void  SetEtaCut(Double_t etaCut){fEtaCut = etaCut;}
  virtual void  SetMinPt(Double_t value) {fMinPt = value;}   
  virtual void  SetMinDistV0(Double_t value){fMinDistV0=value;}
  virtual void  SetMaxDistV0(Double_t value){fMaxDistV0=value;}
  virtual void SetV2(Bool_t val){fV2 = val;};
  virtual void SetV3(Bool_t val){fV3 = val;};

  virtual void SetMC(Bool_t flag = kTRUE){fIsMC = flag;};
  virtual void SetQA(Bool_t flag = kTRUE){fQAsw = flag;};

  void OpenInfoCalbration(Int_t run);

  void SetFillDCAinfo(Bool_t flag=kTRUE){fFillDCA = flag;};

  void SetModulationDEDx(Bool_t flag=kTRUE){fModulationDEDx=flag;};

  void SetAfter2011(Bool_t stat=kTRUE){fIsAfter2011=stat;};
  Bool_t GetAfter2011() const {return fIsAfter2011;};

  void SetTPCclusterN(Int_t ncl){fNcluster=ncl;};
  static Bool_t IsPsiComputed(){return fgIsPsiComputed;};
  static Float_t GetPsi2V0A(){return fgPsi2v0a;};
  static Float_t GetPsi2V0C(){return fgPsi2v0c;};
  static Float_t GetPsi2TPC(){return fgPsi2tpc;};
  static Float_t GetPsi3V0A(){return fgPsi3v0a;};
  static Float_t GetPsi3V0C(){return fgPsi3v0c;};
  static Float_t GetPsi3TPC(){return fgPsi3tpc;};
  static Float_t GetPsi2V0AMC(){return fgPsi2v0aMC;};
  static Float_t GetPsi2V0CMC(){return fgPsi2v0cMC;};
  static Float_t GetPsi2TPCMC(){return fgPsi2tpcMC;};
  static Float_t GetPsi3V0AMC(){return fgPsi3v0aMC;};
  static Float_t GetPsi3V0CMC(){return fgPsi3v0cMC;};
  static Float_t GetPsi3TPCMC(){return fgPsi3tpcMC;};

 private:
  AliAnalysisTaskVnV0(const AliAnalysisTaskVnV0 &old); 
  AliAnalysisTaskVnV0& operator=(const AliAnalysisTaskVnV0 &source); 

  Int_t PassesAODCuts(AliAODv0 *myV0, AliAODEvent *tAOD,Int_t specie);

  static Bool_t fgIsPsiComputed; // flag which return if event was processed
  static Float_t fgPsi2v0a,fgPsi2v0c,fgPsi2tpc; // current Psi2
  static Float_t fgPsi3v0a,fgPsi3v0c,fgPsi3tpc; // current Psi3
  static Float_t fgPsi2v0aMC,fgPsi2v0cMC,fgPsi2tpcMC; // current Psi2
  static Float_t fgPsi3v0aMC,fgPsi3v0cMC,fgPsi3tpcMC; // current Psi3

  virtual Float_t GetVertex(AliAODEvent* aod) const;
  virtual void Analyze(AliAODEvent* aodEvent, Float_t v0Centr); 
  virtual void SelectK0s();

  Double_t     fVtxCut;             // Vtx cut on z position in cm
  Double_t     fEtaCut;             // Eta cut used to select particles
  Double_t     fMinPt;              // Min pt - for histogram limits
  Double_t     fMinDistV0;          // Minimal distance for V0s
  Double_t     fMaxDistV0;          // Maximal distance for V0s

  Bool_t fV2; // switch to set the armonics
  Bool_t fV3; // switch to set the armonics
  Bool_t fIsMC; // if MC
  Bool_t fQAsw;   // if QA
  Bool_t fIsAfter2011; // switch for 2011 and later runs

  static const Int_t nCentrBin = 9;          

  //
  // Cuts and options
  //

  Int_t fRun;                       

  Int_t fNcluster;           // Numer of TPC cluster required
  TList *fList;              
  TList *fList2;             
  TList *fList3;             
  TList *fList4;             
  //
  // Output objects
  TProfile *fMultV0;                
  Float_t fV0Cpol;          
  Float_t fV0Apol;          
  Float_t fMeanQ[nCentrBin][2][2];           
  Float_t fWidthQ[nCentrBin][2][2];          
  Float_t fMeanQv3[nCentrBin][2][2];         
  Float_t fWidthQv3[nCentrBin][2][2];        

  TProfile *fHResTPCv0A2;   
  TProfile *fHResTPCv0C2;   
  TProfile *fHResv0Cv0A2;   
  TProfile *fHResTPCv0A3;    
  TProfile *fHResTPCv0C3;   
  TProfile *fHResv0Cv0A3;   

  TH2F *fPhiRPv0A;          
  TH2F *fPhiRPv0C;          
  TH2F *fPhiRPv0Av3;      
  TH2F *fPhiRPv0Cv3;      

  AliFlowVZEROQA *fQA;            
  AliFlowVZEROQA *fQA2;           
  AliFlowVZEROQA *fQAv3;        
  AliFlowVZEROQA *fQA2v3;       

  AliFlowBayesianPID *fPID;            
 
  TTree *fTree;                        

  Float_t fCentrality;  
  Float_t evPlAngV0ACor2;   
  Float_t evPlAngV0CCor2;   
  Float_t evPlAng2;   
  Float_t evPlAngV0ACor3;   
  Float_t evPlAngV0CCor3;   
  Float_t evPlAng3;   

  AliFlowVZEROResults *fContAllChargesV0A; 
  AliFlowVZEROResults *fContAllChargesV0C; 
  AliFlowVZEROResults *fContAllChargesV0Av3; 
  AliFlowVZEROResults *fContAllChargesV0Cv3; 
  AliFlowVZEROResults *fContAllChargesMC; 

  // MC
  TProfile *fHResMA2;   
  TProfile *fHResMC2;   
  TProfile *fHResAC2;   
  TProfile *fHResMA3;    
  TProfile *fHResMC3;   
  TProfile *fHResAC3;   

  AliFlowVZEROResults *fContAllChargesMCA; 
  AliFlowVZEROResults *fContAllChargesMCC; 
  AliFlowVZEROResults *fContAllChargesMCAv3; 
  AliFlowVZEROResults *fContAllChargesMCCv3; 

  Bool_t fFillDCA; // require to fill also DCA info
  TH2D *fHdcaPt[nCentrBin][7]; 
  TH2D *fHdcaPtSec[nCentrBin][7]; 
  AliFlowVZEROResults *fContQApid; 

  Bool_t fModulationDEDx; //add a modulation on the dE/dx response w.r.t. EP (kFALSE default)

  Float_t fZvtx; 
  Int_t fNK0s; 
  Float_t fPhiK0s[1000]; 
  Float_t fPtK0s[1000];
  Int_t fNpiPos; 
  Int_t fNpiNeg; 
  Int_t fIPiPos[1000]; 
  Int_t fIPiNeg[1000]; 

  TH2D *fHKsPhi; 
  TH2D *fHKsPhiEP; 
  TH2D *fHK0sMass; 
  TH2D *fHK0sMass2; 
  TH2D *fHK0vsLambda; 
  TProfile2D *fHctauPtEP; 
  TH2F *fHctauAt1EP;    

  AliESDtrackCuts *fCutsDaughter; // daughter cut for K0s standard selection
  ClassDef(AliAnalysisTaskVnV0, 8);    //Analysis task v2 and v3 analysis on AOD
};

#endif