AliCFTaskVertexingHF.h

Go to the documentation of this file.

#ifndef ALICFTASKVERTEXINGHF_H
#define ALICFTASKVERTEXINGHF_H
/**************************************************************************
 * Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------


#include "AliAnalysisTaskSE.h"
#include "AliCFVertexingHF2Prong.h"
#include "AliCFVertexingHF3Prong.h"
#include "AliCFVertexingHFLctoV0bachelor.h"
#include "AliCFVertexingHF.h"
#include <TH1F.h>
#include <TProfile.h>

class TH1I;
class TParticle ;
class TFile ;
class TClonesArray ;
class AliCFManager;
class AliAODRecoDecay;
class AliAODRecoDecayHF2Prong;
class AliAODMCParticle;
class THnSparse;
class TF1;
class AliRDHFCuts;
class AliCFVertexingHF2Prong;
class AliCFVertexingHF3Prong;

class AliCFTaskVertexingHF: public AliAnalysisTaskSE {
 public:

  enum {
    kStepGeneratedLimAcc = 0,
    kStepGenerated       = 1,
    kStepAcceptance      = 2,
    kStepVertex          = 3,
    kStepRefit           = 4,
    kStepReconstructed   = 5,
    kStepRecoAcceptance  = 6,
    kStepRecoITSClusters = 7,
    kStepRecoPPR         = 8,
    kStepRecoPID         = 9,
    kStepGenLimAccNoAcc  = 10
  };

  enum {
    kSnail = 0,    
    kCheetah = 1,   
    kFalcon = 2,   
    kESE = 3   
  };

  enum {
    kAll = 0,   
    kNonResonant = 1, 
    kL1520 = 2,  
    kKstar = 3,  
    kDelta = 4   
  };

  enum { kNtrk10=0, kNtrk10to16=1, kVZERO=2 }; 

  AliCFTaskVertexingHF();
  AliCFTaskVertexingHF(const Char_t* name, AliRDHFCuts* cuts, TF1* func = 0x0);
  AliCFTaskVertexingHF& operator= (const AliCFTaskVertexingHF& c);
  AliCFTaskVertexingHF(const AliCFTaskVertexingHF& c);
  virtual ~AliCFTaskVertexingHF();

  void     UserCreateOutputObjects();
  void     UserExec(Option_t *option);
  void     Init();
  void     LocalInit() {Init();}
  void     Terminate(Option_t *);

  void     SetCorrelationMatrix(THnSparse* h) {fCorrelation=h;}
  void     SetAcceptanceUnf(Bool_t AcceptanceUnf) {fAcceptanceUnf = AcceptanceUnf;}
  Bool_t   GetAcceptanceUnf() const {return fAcceptanceUnf;}


  void           SetCFManager(AliCFManager* io) {fCFManager = io;}   
  AliCFManager * GetCFManager()                 {return fCFManager;} 

  void    SetFillFromGenerated(Bool_t flag) {fFillFromGenerated = flag;}
  Bool_t  GetFillFromGenerated() const {return fFillFromGenerated;}
  void    SetDecayChannel (Int_t decayChannel) {fDecayChannel = decayChannel;}
  Int_t   GetDecayChannel () {return fDecayChannel;}
  void     SetUseWeight(Bool_t useWeight){fUseWeight=useWeight;}
  Bool_t   GetUseWeight() const {return fUseWeight;}
  Double_t GetWeight(Float_t pt);
  Double_t dNdptFit(Float_t pt, Double_t* par);
  Double_t GetPtWeightFromHistogram(Float_t pt);

  void SetUseFlatPtWeight(Bool_t useWeight){fUseFlatPtWeight=useWeight; fUseWeight=useWeight;}
  Bool_t GetUseFlatPtWeight() const {return fUseFlatPtWeight;}
  void SetUseZWeight(Bool_t useWeight){fUseZWeight=useWeight;}
  Bool_t GetUseZWeight() const {return fUseZWeight;}
  Double_t GetZWeight(Float_t z, Int_t runnumber);
  Double_t DodzFit(Float_t z, Double_t* par);

  void SetUseNchWeight(Bool_t useWeight){fUseNchWeight=useWeight;}
  Bool_t GetUseNchWeight() const {return fUseNchWeight;}
  void SetMCNchHisto(TH1F* h){
    if(fHistoMCNch) delete fHistoMCNch;
    fHistoMCNch=new TH1F(*h);
  }
  void CreateMeasuredNchHisto();
  void SetMeasuredNchHisto(TH1F* h){
    if(fHistoMeasNch) delete fHistoMeasNch;
    fHistoMeasNch=new TH1F(*h);
  }
  Double_t GetNchWeight(Int_t nch);
  void SetMultiplicityEstimator(Int_t value){ fMultiplicityEstimator=value; }
  Int_t GetMultiplicityEstimator(){ return fMultiplicityEstimator; }
  void SetIsPPData(Bool_t flag){ fIsPPData = flag; }
  void SetIsPPbData(Bool_t flag){ fIsPPbData = flag; }

  void SetUseNchTrackletsWeight(Bool_t useWeight = kTRUE) { fUseNchWeight=useWeight; fUseTrackletsWeight=useWeight; fUseMultRatioAsWeight=useWeight; }
  Bool_t GetUseNchTrackletsWeight() const {return fUseTrackletsWeight;}
  void SetUseRatioMultiplicityDistributionsAsWeight(Bool_t flag=kTRUE){ fUseMultRatioAsWeight=flag; }
  Bool_t GetUseRatioMultiplicityDistributionsAsWeight() const {return fUseMultRatioAsWeight;}

  void SetUseZvtxCorrectedNtrkEstimator(Bool_t flag) { fZvtxCorrectedNtrkEstimator=flag; }
  Bool_t GetUseZvtxCorrectedNtrkEstimator() { return fZvtxCorrectedNtrkEstimator; }
  void SetMultiplVsZProfileLHC10b(TProfile* hprof){
    if(fMultEstimatorAvg[0]) delete fMultEstimatorAvg[0];
    fMultEstimatorAvg[0]=new TProfile(*hprof);
  }
  void SetMultiplVsZProfileLHC10c(TProfile* hprof){
    if(fMultEstimatorAvg[1]) delete fMultEstimatorAvg[1];
    fMultEstimatorAvg[1]=new TProfile(*hprof);
  }
  void SetMultiplVsZProfileLHC10d(TProfile* hprof){
    if(fMultEstimatorAvg[2]) delete fMultEstimatorAvg[2];
    fMultEstimatorAvg[2]=new TProfile(*hprof);
  }
  void SetMultiplVsZProfileLHC10e(TProfile* hprof){
    if(fMultEstimatorAvg[3]) delete fMultEstimatorAvg[3];
    fMultEstimatorAvg[3]=new TProfile(*hprof);
  }

  void SetMultiplVsZProfileLHC13b(TProfile* hprof){
    if(fMultEstimatorAvg[0]) delete fMultEstimatorAvg[0];
    fMultEstimatorAvg[0]=new TProfile(*hprof);
  }
  void SetMultiplVsZProfileLHC13c(TProfile* hprof){
    if(fMultEstimatorAvg[1]) delete fMultEstimatorAvg[1];
    fMultEstimatorAvg[1]=new TProfile(*hprof);
  }


  TProfile* GetEstimatorHistogram(const AliVEvent* event);
  void SetReferenceMultiplcity(Double_t rmu){fRefMult=rmu;}

  void   SetDselection(UShort_t originDselection) {fOriginDselection=originDselection;}
  UShort_t GetDselection (){return fOriginDselection;}
  void SetSign(Char_t isSign) {fSign = isSign;}
  Char_t GetSign() {return fSign;}

  void SetCentralitySelection(Bool_t centSelec = kTRUE) {fCentralitySelection = centSelec;}
  Bool_t GetCentralitySelection() {return fCentralitySelection;}

  void SetFakeSelection(Int_t fakeSel = 0) {fFakeSelection=fakeSel;}
  Int_t GetFakeSelection(){return fFakeSelection;}

  void SetRejectCandidateIfNotFromQuark(Bool_t opt){fRejectIfNoQuark=opt;}
  Bool_t GetRejectCandidateIfNotFromQuark(){return fRejectIfNoQuark;}

  void SetUseMCVertex(Bool_t opt){fUseMCVertex=opt;}
  Bool_t GetUseMCVertex(){return fUseMCVertex;}


  void SetKeepDsViaPhi(){fDsOption=1;}
  void SetKeepDsViaK0star(){fDsOption=2;}
  void SetKeepAllDs(){fDsOption=3;}
  void SetCountAllDs(){fGenDsOption=AliCFVertexingHF3Prong::kCountAllDsKKpi;}
  void SetCountDsViaPhi(){fGenDsOption=AliCFVertexingHF3Prong::kCountPhipi;}
  void SetCountDsViaK0star(){fGenDsOption=AliCFVertexingHF3Prong::kCountK0stK;}
  void SetCountResonantDs(){fGenDsOption=AliCFVertexingHF3Prong::kCountResonant;}
  void SetCountNonResonantDs(){fGenDsOption=AliCFVertexingHF3Prong::kCountNonResonant;}

  Bool_t ProcessDs(Int_t returnCodeDs) const;

  void SetConfiguration(Int_t configuration) {(configuration == kSnail) ? Printf("Slow configuration chosen, all variables will be used!") : Printf("Fast configuration chosen, all variablesOnly pt, y, phi, ct, fake, z_vtx, centrality and multiplicity will be used!"); fConfiguration = configuration;}
  Int_t GetConfiguration() const {return fConfiguration;}

  void SetWeightFunction(TF1* func) {fFuncWeight = func;}
  TF1* GetWeightFunction() const {return fFuncWeight;}
  void SetWeightHistogram(TH1F* histo) {
    if(fHistoPtWeight) delete fHistoPtWeight;
    fHistoPtWeight=new TH1F(*histo);
  }
  TH1F* GetWeightHistogram() const {return (TH1F*)fHistoPtWeight;}

  void SetPtWeightsFromFONLL276overLHC12a17a();
  void SetPtWeightsFromDataPbPb276overLHC12a17a();
  void SetPtWeightsFromFONLL276overLHC12a17b();
  void SetPtWeightsFromFONLL276andBAMPSoverLHC12a17b();
  void SetPtWeightsFromFONLL276overLHC10f6a();
  void SetPtWeightsFromFONLL7overLHC10f6a();
  void SetPtWeightsFromFONLL7overLHC12a12();
  void SetPtWeightsFromFONLL7overLHC12a12bis();
  void SetPtWeightsFromFONLL7overLHC13e2fix();
  void SetPtWeightsFromFONLL5overLHC10f6a();
  void SetPtWeightsFromFONLL5overLHC13d3();
  void SetPtWeightsFromFONLL5overLHC13d3Lc();
  void SetPtWeightsFromFONLL7overLHC11b2Lc();
  void SetPtWeightsFromFONLL7overLHC10f7aLc();
  void SetPtWeightsFromFONLL8overLHC15l2a2();
  void SetPtWeightsFromFONLL13overLHC17c3a12();

  void SetPtWeightsFromFONLL5anddataoverLHC16i2a();
  void SetPtWeightsFromFONLL5andLBToverLHC16i2a();
  void SetPtWeightsFromFONLL5overLHC16i2abc();
  void SetPtWeightsFromFONLL5andBAMPSoverLHC16i2abc();
  void SetPtWeightsFromFONLL5andTAMUoverLHC16i2abc();
  void SetPtWeightsFromD0Cent080dataoverLHC16i2abc();
  void SetPtWeightsFromD0Cent080dataModOhoverLHC16i2abc();
  void SetPtWeightsFromD0Cent080dataModMartinezoverLHC16i2abc();
  void SetPtWeightsFromFONLL5overLHC16i6a();
  void SetPtWeightsFromFONLL5andDplusdataoverLHC16i2a();
  void SetPtWeightsFromFONLL5overLHC18a4a2();
  
  void SetResonantDecay(UInt_t resonantDecay) {fResonantDecay = resonantDecay;}
  UInt_t GetResonantDecay() const {return fResonantDecay;}

  void SetKeepLctoK0Sp() {fLctoV0bachelorOption=1;}
  void SetKeepLctoLambdaBarpi() {fLctoV0bachelorOption=2;}
  void SetKeepLctoLambdapi() {fLctoV0bachelorOption=4;}
  void SetKeepLctoV0bachelor() {fLctoV0bachelorOption=7;}

  void SetCountLctoK0Sp(){fGenLctoV0bachelorOption=AliCFVertexingHFLctoV0bachelor::kCountK0Sp;}
  void SetCountLctoLambdapi(){fGenLctoV0bachelorOption=AliCFVertexingHFLctoV0bachelor::kCountLambdapi;}

  void SetUseSelectionBit(Bool_t flag) { fUseSelectionBit=flag; }
  Bool_t GetUseSelectionBit() const { return fUseSelectionBit; }

  Bool_t ProcessLctoV0Bachelor(Int_t returnCodeDs) const;

  void SetUseAdditionalCuts(Bool_t flag) { fDecayChannel == 22 ? fUseAdditionalCuts = flag : fUseAdditionalCuts = kFALSE;}
  Bool_t GetUseAdditionalCuts() const { return fUseAdditionalCuts; }
  void SetUseCutsForTMVA(Bool_t useCutsForTMVA) { fDecayChannel == 22 ? fUseCutsForTMVA = useCutsForTMVA : fUseAdditionalCuts = kFALSE;}
  Bool_t GetUseCutsForTMVA() const {return fUseCutsForTMVA;}

  void SetUseCascadeTaskForLctoV0bachelor(Bool_t useCascadeTaskForLctoV0bachelor) {fUseCascadeTaskForLctoV0bachelor = useCascadeTaskForLctoV0bachelor;}
  Bool_t GetUseCascadeTaskForLctoV0bachelor() const {return fUseCascadeTaskForLctoV0bachelor;}

  void SetFillMinimumSteps(Bool_t FillMinimumSteps) {fFillMinimumSteps = FillMinimumSteps;}
  Bool_t GetFillMinimumSteps() const {return fFillMinimumSteps;}

  void SetCutOnMomConservation(Float_t cut) {fCutOnMomConservation = cut;}
  Bool_t GetCutOnMomConservation() const {return fCutOnMomConservation;}

  Double_t ComputeTPCq2(AliAODEvent* aod, AliAODMCHeader* mcHeader, Double_t etamin, Double_t etamax, Double_t ptmin, Double_t ptmax) const;

 protected:
  AliCFManager   *fCFManager;   
  TH1I *fHistEventsProcessed;   
  THnSparse* fCorrelation;      
  TList  *fListProfiles; //list of profile histos for z-vtx correction
  Int_t fCountMC;               
  Int_t fCountGenLimAcc;        
  Int_t fCountGenLimAccNoAcc;   
  Int_t fCountAcc;              
  Int_t fCountVertex;       
  Int_t fCountRefit;        
  Int_t fCountReco;             
  Int_t fCountRecoAcc;          
  Int_t fCountRecoITSClusters;  
  Int_t fCountRecoPPR;          
  Int_t fCountRecoPID;          
  Int_t fEvents;                
  Int_t fDecayChannel;          
  Bool_t fFillFromGenerated;    
  UShort_t fOriginDselection;      
  Bool_t fAcceptanceUnf;        
  AliRDHFCuts* fCuts;            
  Bool_t fUseWeight;             
  Double_t fWeight;              
  Bool_t fUseFlatPtWeight;       
  Bool_t fUseZWeight;           
  Bool_t fUseNchWeight;         
  Bool_t fUseTrackletsWeight;   
  Bool_t fUseMultRatioAsWeight; 
  Int_t fNvar;                  
  TString fPartName;    
  TString fDauNames;    
  Char_t fSign;                 
  Bool_t fCentralitySelection;  
  Int_t  fFakeSelection;  
  Bool_t fRejectIfNoQuark;  
  Bool_t fUseMCVertex;  
  Int_t  fDsOption;     
  Int_t  fGenDsOption;     
  Int_t fConfiguration; 
  TF1* fFuncWeight;     
  TH1F* fHistoPtWeight; 
  TH1F* fHistoMeasNch;  
  TH1F* fHistoMCNch;  
  UInt_t fResonantDecay;  
  Int_t fLctoV0bachelorOption; 
  Int_t fGenLctoV0bachelorOption; 
  Bool_t fUseSelectionBit;     
  UInt_t fPDGcode; 

  Int_t fMultiplicityEstimator; 
  TProfile* fMultEstimatorAvg[4]; 
  Double_t fRefMult;   
  Bool_t fZvtxCorrectedNtrkEstimator; 
  Bool_t fIsPPData; 
  Bool_t fIsPPbData; 
  Bool_t fUseAdditionalCuts;  
  Bool_t fUseCutsForTMVA;     
  Bool_t fUseCascadeTaskForLctoV0bachelor;   
  Bool_t fFillMinimumSteps;   
  Float_t fCutOnMomConservation; 

  ClassDef(AliCFTaskVertexingHF,26); 
};

#endif