AliAnalysisTaskCombinHF.h

Go to the documentation of this file.

#ifndef ALIANALYSISTASKCOMBINHF_H
#define ALIANALYSISTASKCOMBINHF_H

/* Copyright(c) 1998-2018, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

/* $Id: $ */


#include <TH1F.h>
#include <TH3F.h>
#include <TObjString.h>
#include <THnSparse.h>
#include "AliAnalysisTaskSE.h"
#include "AliAODTrack.h"
#include "AliNormalizationCounter.h"
#include "AliRDHFCuts.h"

class AliAnalysisTaskCombinHF : public AliAnalysisTaskSE
{
public:
  
  AliAnalysisTaskCombinHF();
  AliAnalysisTaskCombinHF(Int_t meson, AliRDHFCuts* analysiscuts);
  virtual ~AliAnalysisTaskCombinHF();
  
  virtual void UserCreateOutputObjects();
  virtual void Init(){};
  virtual void LocalInit() {Init();}
  virtual void UserExec(Option_t *option);
  virtual void Terminate(Option_t *option);
  virtual void FinishTaskOutput();
  
  void SetReadMC(Bool_t read){fReadMC=read;}

  void SetEventMixingWithCuts(Double_t maxDeltaVz, Double_t maxDeltaMult){
    fDoEventMixing=2; fMaxzVertDistForMix=maxDeltaVz; fMaxMultDiffForMix=maxDeltaMult;
  }
  void SetEventMixingWithPools(){fDoEventMixing=1;}
  void SetEventMixingOff(){fDoEventMixing=0;}
  void SetNumberOfEventsForMixing(Int_t minn){fNumberOfEventsForMixing=minn;}

  void ConfigureZVertPools(Int_t nPools, Double_t*  zVertLimits);
  void ConfigureMultiplicityPools(Int_t nPools, Double_t*  multLimits);
  void SetGoUpToQuark(Bool_t opt){fGoUpToQuark=opt;}
  void SetKeepNegIDtracks(Bool_t nid){fKeepNegID=nid;}//set it to kTRUE only if you know what you are doing
  void SetTrackCuts(AliESDtrackCuts* cuts){
    if(fTrackCutsAll) delete fTrackCutsAll;
    fTrackCutsAll=new AliESDtrackCuts(*cuts);
  }
  void SetPionTrackCuts(AliESDtrackCuts* cuts){
    if(fTrackCutsPion) delete fTrackCutsPion;
    fTrackCutsPion=new AliESDtrackCuts(*cuts);
  }
  void SetKaonTrackCuts(AliESDtrackCuts* cuts){
    if(fTrackCutsKaon) delete fTrackCutsKaon;
    fTrackCutsKaon=new AliESDtrackCuts(*cuts);
  }
  void SetCutOnCosThetaStar(Double_t cut){
    if(cut>0 && cut<1) fApplyCutCosThetaStar=kTRUE;
    else fApplyCutCosThetaStar=kFALSE;
    fCutCosThetaStar=cut;
  }
  void SetCutOnKKInvMass(Double_t cut){
    fPhiMassCut=cut;
  }
  void SetCutOnCos3PiKPhiRFrame(Double_t cut){
    fCutCos3PiKPhiRFrame=cut;
  }
  void SetCutCosPiDsLabFrame(Double_t cut){
    fCutCosPiDsLabFrame=cut;
  }
  void SetPIDHF(AliAODPidHF* pid){
    if(fPidHF) delete fPidHF;
    fPidHF=new AliAODPidHF(*pid);
  }
  void SetRDHFCuts(AliRDHFCuts* cuts){
    fAnalysisCuts=cuts;
  }
  void SetFilterMask(UInt_t mask=16){fFilterMask=mask;}
  void SetAnalysisLevel(Int_t level){fFullAnalysis=level;}
  void ConfigureRotation(Int_t n, Double_t phimin, Double_t phimax){
    fNRotations=n;
    fMinAngleForRot=phimin;
    fMaxAngleForRot=phimax;
  }
  void ConfigureRotation3rdProng(Int_t n, Double_t phimin, Double_t phimax){
    fNRotations3=n;
    fMinAngleForRot3=phimin;
    fMaxAngleForRot3=phimax;
  }
  void SetMassWindow(Double_t minMass, Double_t maxMass){fMinMass=minMass; fMaxMass=maxMass;}
  void SetMaxPt(Double_t maxPt){fMaxPt=maxPt;}
  void SetPtBinWidth(Double_t binw){fPtBinWidth=binw;}
  void SetEtaAccCut(Double_t etacut){fEtaAccCut=etacut;}
  void SetPtAccCut(Double_t ptcut){fPtAccCut=ptcut;}
  void SetMultiplicityRange(Double_t mmin=-0.5, Double_t mmax=199.5){
    fMinMultiplicity=mmin;
    fMaxMultiplicity=mmax;
  }

  void SetPIDstrategy(Int_t strat){fPIDstrategy=strat;}
  void SetMaxPforIDPion(Double_t maxpIdPion){fmaxPforIDPion=maxpIdPion;}
  void SetMaxPforIDKaon(Double_t maxpIdKaon){fmaxPforIDKaon=maxpIdKaon;}
  void SetPIDselCaseZero(Int_t strat){fPIDselCaseZero=strat;}
  void SetBayesThres(Double_t thresKaon, Double_t thresPion){
    fBayesThresKaon=thresKaon;
    fBayesThresPion=thresPion;
  }
  
  Bool_t IsTrackSelected(AliAODTrack* track);
  Bool_t IsKaon(AliAODTrack* track);
  Bool_t IsPion(AliAODTrack* track);
  Bool_t SelectAODTrack(AliAODTrack *track, AliESDtrackCuts *cuts);
  
  Bool_t FillHistos(Int_t pdgD,Int_t nProngs, AliAODRecoDecay* tmpRD, Double_t* px, Double_t* py, Double_t* pz, UInt_t *pdgdau, TClonesArray *arrayMC, Int_t* dgLabels);
  void FillLSHistos(Int_t pdgD,Int_t nProngs, AliAODRecoDecay* tmpRD, Double_t* px, Double_t* py, Double_t* pz, UInt_t *pdgdau, Int_t charge);
  void FillMEHistos(Int_t pdgD,Int_t nProngs, AliAODRecoDecay* tmpRD, Double_t* px, Double_t* py, Double_t* pz, UInt_t *pdgdau);
  void FillMEHistosLS(Int_t pdgD,Int_t nProngs, AliAODRecoDecay* tmpRD, Double_t* px, Double_t* py, Double_t* pz, UInt_t *pdgdau, Int_t charge);
  void FillGenHistos(TClonesArray* arrayMC, Bool_t isEvSel);
  Bool_t CheckAcceptance(TClonesArray* arrayMC, Int_t nProng, Int_t *labDau); 
  Int_t GetPoolIndex(Double_t zvert, Double_t mult);
  void ResetPool(Int_t poolIndex);
  void DoMixingWithPools(Int_t poolIndex);
  void DoMixingWithCuts();
  Bool_t CanBeMixed(Double_t zv1, Double_t zv2, Double_t mult1, Double_t mult2);
  enum EMesonSpecies {kDzero, kDplus, kDstar, kDs};
  enum EPrompFd {kNone,kPrompt,kFeeddown,kBoth};
  enum EPIDstrategy {knSigma, kBayesianMaxProb, kBayesianThres};
  
private:
  
  AliAnalysisTaskCombinHF(const AliAnalysisTaskCombinHF &source);
  AliAnalysisTaskCombinHF& operator=(const AliAnalysisTaskCombinHF& source);
  Double_t ComputeInvMassKK(AliAODTrack* tr1, AliAODTrack* tr2) const;
  Double_t ComputeInvMassKK(TLorentzVector* tr1, TLorentzVector* tr2) const;
  Double_t CosPiKPhiRFrame(TLorentzVector* dauK1, TLorentzVector* dauK2, TLorentzVector* daupi) const;
  Double_t CosPiDsLabFrame(TLorentzVector* dauK1, TLorentzVector* dauK2, TLorentzVector* daupi) const;

  TList   *fOutput; 
  TH1F *fHistNEvents;         
  TH2F *fHistEventMultZv;       
  TH2F *fHistEventMultZvEvSel;  
  TH1F *fHistTrackStatus;     
  TH3F* fHistTrackEtaMultZv;  // track distribution vs. era z vertex and mult
  TH1F *fHistCheckOrigin;     
  TH1F *fHistCheckDecChan;    
  TH1F *fHistCheckDecChanAcc; 
  TH3F *fPtVsYVsMultGenPrompt;         
  TH3F *fPtVsYVsMultGenLargeAccPrompt; 
  TH3F *fPtVsYVsMultGenLimAccPrompt;   
  TH3F *fPtVsYVsMultGenAccPrompt;      
  TH3F *fPtVsYVsMultGenAccEvSelPrompt; 
  TH3F *fPtVsYVsMultRecoPrompt;        
  TH3F *fPtVsYVsMultGenFeeddw;         
  TH3F *fPtVsYVsMultGenLargeAccFeeddw; 
  TH3F *fPtVsYVsMultGenLimAccFeeddw;   
  TH3F *fPtVsYVsMultGenAccFeeddw;      
  TH3F *fPtVsYVsMultGenAccEvSelFeeddw; 
  TH3F *fPtVsYVsMultRecoFeeddw;        
  TH3F *fMassVsPtVsY;     
  TH3F *fMassVsPtVsYRot;   
  TH3F *fMassVsPtVsYLSpp;  
  TH3F *fMassVsPtVsYLSmm;  
  TH3F *fMassVsPtVsYSig;   
  TH3F *fMassVsPtVsYRefl;  
  TH3F *fMassVsPtVsYBkg;   
  TH1F *fNSelected;        
  TH1F *fNormRotated;      
  TH1F *fDeltaMass;        
  THnSparse *fDeltaMassFullAnalysis; 
  TH3F *fMassVsPtVsYME;   
  TH3F *fMassVsPtVsYMELSpp;   
  TH3F *fMassVsPtVsYMELSmm;   
  TH2F* fEventsPerPool;   
  TH2F* fMixingsPerPool;    
  UInt_t fFilterMask; 
  AliESDtrackCuts* fTrackCutsAll; 
  AliESDtrackCuts* fTrackCutsPion; 
  AliESDtrackCuts* fTrackCutsKaon; 
  Bool_t fApplyCutCosThetaStar; 
  Double_t fCutCosThetaStar;    
  Double_t fPhiMassCut;   
  Double_t fCutCos3PiKPhiRFrame; // cut on the Ds decay angles
  Double_t fCutCosPiDsLabFrame;  // cut on the Ds decay angles
  AliAODPidHF* fPidHF; 
  AliRDHFCuts *fAnalysisCuts; 
  
  Double_t fMinMass; 
  Double_t fMaxMass; 
  Double_t fMaxPt;   
  Double_t fPtBinWidth; 
  Double_t fEtaAccCut; 
  Double_t fPtAccCut; 
  
  Int_t fNRotations; 
  Double_t fMinAngleForRot; 
  Double_t fMaxAngleForRot; 
  Int_t fNRotations3; 
  Double_t fMinAngleForRot3; 
  Double_t fMaxAngleForRot3; 
  
  AliNormalizationCounter *fCounter;
  
  Int_t fMeson;          
  Bool_t  fReadMC;       
  Bool_t fGoUpToQuark;   
  Int_t fFullAnalysis;   
  
  Int_t    fPIDstrategy;   
  Double_t fmaxPforIDPion; 
  Double_t fmaxPforIDKaon; 
  Bool_t   fKeepNegID;    
  Int_t    fPIDselCaseZero;  
  Double_t fBayesThresKaon;  
  Double_t fBayesThresPion;  

  Int_t fDoEventMixing; 
  Int_t  fNumberOfEventsForMixing; 
  Double_t fMaxzVertDistForMix; 
  Double_t fMaxMultDiffForMix; 
  Int_t fNzVertPools; 
  Int_t fNzVertPoolsLimSize; 
  Double_t* fzVertPoolLims; //[fNzVertPoolsLimSize] limits of the pools in zVertex
  Int_t fNMultPools; 
  Int_t fNMultPoolsLimSize; 
  Double_t* fMultPoolLims; //[fNMultPoolsLimSize] limits of the pools in multiplicity
  Int_t  fNOfPools; 
  TTree** fEventBuffer;   
  TObjString* fEventInfo;  
  Double_t fVtxZ;         
  Double_t fMultiplicity; 
  Double_t fMinMultiplicity;  
  Double_t fMaxMultiplicity; 
  TObjArray* fKaonTracks; 
  TObjArray* fPionTracks; 

  ClassDef(AliAnalysisTaskCombinHF,15); 
};

#endif