AliCFTaskVertexingHFCutVarFDSub.h

Go to the documentation of this file.

#ifndef ALICFTASKVERTEXINGHFCUTVARFDSUB_H
#define ALICFTASKVERTEXINGHFCUTVARFDSUB_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.                  *
 **************************************************************************/

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

#include "THnSparse.h"
#include "TH1F.h"
#include "TProfile.h"

#include "AliAnalysisTaskSE.h"
#include "AliCFVertexingHF3Prong.h"
#include "AliCFVertexingHFLctoV0bachelor.h"

class AliCFManager;
class AliRDHFCuts;
class AliHFsubtractBFDcuts;
class TH1F;

class AliCFTaskVertexingHFCutVarFDSub: public AliAnalysisTaskSE {
public:

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

  enum {
    kSnail = 0,    
    kCheetah = 1   
  };

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

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

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

  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;}


  // CORRECTION FRAMEWORK RELATED FUNCTIONS
  void           SetCFManager(AliCFManager* io) {fCFManager = io;}   
  AliCFManager * GetCFManager()                 {return fCFManager;} 

  // Setters (and getters) for the config macro
  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;}
  void     SetUseMotherPtWeight(Bool_t useMotherPtWeight){fUseMotherPtWeight=useMotherPtWeight;}
  Bool_t   GetUseMotherPtWeight() const {return fUseMotherPtWeight;}
  Double_t GetWeight(Float_t pt);
  Double_t dNdptFit(Float_t pt, Double_t* par);
  Double_t GetPtWeightFromHistogram(Float_t pt);
  Double_t GetMotherPtWeightFromHistogram(Float_t motherPt);
  Double_t GetMotherPtFromRecoDecay(AliAODRecoDecayHF* charmCandidate, TClonesArray* mcArray);

  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; }
  Bool_t   GetUseNchTrackletsWeight() const {return fUseTrackletsWeight;}

  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 SetPtWeightsFromFONLL276overLHC12a17a();
  void SetPtWeightsFromDataPbPb276overLHC12a17a();
  void SetPtWeightsFromFONLL276overLHC12a17b();
  void SetPtWeightsFromFONLL276andBAMPSoverLHC12a17b();
  void SetPtWeightsFromFONLL276overLHC10f6a();
  void SetPtWeightsFromFONLL7overLHC10f6a();
  void SetPtWeightsFromFONLL7overLHC12a12();
  void SetPtWeightsFromFONLL7overLHC12a12bis();
  void SetPtWeightsFromFONLL7overLHC13e2fix();
  void SetPtWeightsFromFONLL5overLHC10f6a();
  void SetPtWeightsFromFONLL5overLHC13d3();
  void SetMotherPtWeightsFromFONLL5overLHC13d3();

  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;

protected:
  AliCFManager   *fCFManager;   
  TH1I *fHistEventsProcessed;   
  THnSparse* fCorrelation;      
  TList  *fListProfiles; 
  Int_t fCountMC;               
  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;             
  Bool_t fUseMotherPtWeight;     
  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* fHistoMotherPtWeight; 
  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;   
  Float_t fCutOnMomConservation; 
  AliHFsubtractBFDcuts* fObjSpr; 
  THnSparseF* fTHnAnalysis;   
  THnSparseF* fTHnGenerator;  
  TH1F* fhBptCutVar;          
  TH1F* fhBquarkPt;           
  TH1F* fhCquarkPt;           
  TList* fListBdecays;        
  TList* fQAHists;            

  ClassDef(AliCFTaskVertexingHFCutVarFDSub,10); 
};

#endif