AliAnalysisVertexingHF.h

Go to the documentation of this file.

#ifndef ALIANALYSISVERTEXINGHF_H
#define ALIANALYSISVERTEXINGHF_H
/* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

/* $Id$ */

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

#include <TNamed.h>
#include <TList.h>

#include "AliAnalysisFilter.h"
#include "AliESDtrackCuts.h"

class AliPIDResponse;
class AliESDVertex;
class AliAODRecoDecay;
class AliAODRecoDecayHF;
class AliAODRecoDecayHF2Prong;
class AliAODRecoDecayHF3Prong;
class AliAODRecoDecayHF4Prong;
class AliAODRecoCascadeHF;
class AliAnalysisFilter;
class AliRDHFCuts;
class AliRDHFCutsD0toKpi;
class AliRDHFCutsJpsitoee;
class AliRDHFCutsDplustoK0spi;
class AliRDHFCutsDplustoKpipi;
class AliRDHFCutsDstoK0sK;
class AliRDHFCutsDstoKKpi;
class AliRDHFCutsLctopKpi;
class AliRDHFCutsLctoV0;
class AliRDHFCutsD0toKpipipi;
class AliRDHFCutsDStartoKpipi;
class AliESDtrack;
class AliVEvent;
class AliAODVertex;
class AliVertexerTracks;
class AliESDv0;
class AliAODv0;

//-----------------------------------------------------------------------------
class AliAnalysisVertexingHF : public TNamed {
 public:
  //
  AliAnalysisVertexingHF();
  AliAnalysisVertexingHF(const AliAnalysisVertexingHF& source);
  AliAnalysisVertexingHF& operator=(const AliAnalysisVertexingHF& source);
  virtual ~AliAnalysisVertexingHF();

  void FindCandidates(AliVEvent *event,
          TClonesArray *aodVerticesHFTClArr,
          TClonesArray *aodD0toKpiTClArr,
          TClonesArray *aodJPSItoEleTClArr,
          TClonesArray *aodCharm3ProngTClArr,
          TClonesArray *aodCharm4ProngTClArr,
          TClonesArray *aodDstarTClArr,
          TClonesArray *aodCascadesTClArr,
          TClonesArray *aodLikeSign2ProngTClArr,
          TClonesArray *aodLikeSign3ProngTClArr);

  TList* FillListOfCuts();
  void FixReferences(AliAODEvent *aod);
  Bool_t FillRecoCand(AliVEvent *event,AliAODRecoDecayHF3Prong *rd3);
  Bool_t FillRecoCand(AliVEvent *event,AliAODRecoDecayHF2Prong *rd2);
  Bool_t FillRecoCasc(AliVEvent *event,AliAODRecoCascadeHF *rc,Bool_t isDStar,Bool_t recoSecVtx=kFALSE);
  Bool_t RecoSecondaryVertexForCascades(AliVEvent *event, AliAODRecoCascadeHF *rc);
  void PrintStatus() const;
  void SetSecVtxWithKF() { fSecVtxWithKF=kTRUE; }
  void SetD0toKpiOn() { fD0toKpi=kTRUE; }
  void SetD0toKpiOff() { fD0toKpi=kFALSE; }
  void SetJPSItoEleOn() { fJPSItoEle=kTRUE; }
  void SetJPSItoEleOff() { fJPSItoEle=kFALSE; }
  void Set3ProngOn() { f3Prong=kTRUE; }
  void Set3ProngOff() { f3Prong=kFALSE; }
  void Set4ProngOn() { f4Prong=kTRUE; }
  void Set4ProngOff() { f4Prong=kFALSE; }
  void SetDstarOn() { fDstar=kTRUE; }
  void SetDstarOff() { fDstar=kFALSE; }
  void SetCascadesOn() { fCascades=kTRUE; }
  void SetCascadesOff() { fCascades=kFALSE; }
  void SetLikeSignOn() { fLikeSign=kTRUE; }
  void SetLikeSignOff() {fLikeSign=kFALSE; fLikeSign3prong=kFALSE;}
  void SetLikeSign3prongOn() { fLikeSign=kTRUE; fLikeSign3prong=kTRUE; }
  void SetLikeSign3prongOff() { fLikeSign3prong=kFALSE; }
  void SetMixEventOn() { fMixEvent=kTRUE; }
  void SetMixEventOff() { fMixEvent=kFALSE; }
  void SetInputAOD() { fInputAOD=kTRUE; }
  void SetMakeReducedRHF(Bool_t makeredAOD=kFALSE) { fMakeReducedRHF=makeredAOD; }
  Bool_t GetD0toKpi() const { return fD0toKpi; }
  Bool_t GetJPSItoEle() const { return fJPSItoEle; }
  Bool_t Get3Prong() const { return f3Prong; }
  Bool_t Get4Prong() const { return f4Prong; }
  Bool_t GetDstar()  const { return fDstar; }
  Bool_t GetCascades() const { return fCascades; }
  Bool_t GetLikeSign() const { return fLikeSign; }
  Bool_t GetLikeSign3prong() const { return fLikeSign3prong; }
  Bool_t GetMixEvent() const { return fMixEvent; }
  Bool_t GetInputAOD() const { return fInputAOD; }
  Bool_t GetRecoPrimVtxSkippingTrks() const {return fRecoPrimVtxSkippingTrks;}
  Bool_t GetRmTrksFromPrimVtx() const {return fRmTrksFromPrimVtx;}
  Bool_t GetMakeReducedRHF() const {return fMakeReducedRHF;}
  void SetFindVertexForDstar(Bool_t vtx=kTRUE) { fFindVertexForDstar=vtx; }
  void SetFindVertexForCascades(Bool_t vtx=kTRUE) { fFindVertexForCascades=vtx; }

  void  SetV0TypeForCascadeVertex(Int_t type) {fV0TypeForCascadeVertex = type;}
  Int_t GetV0TypeForCascadeVertex()           { return fV0TypeForCascadeVertex;}

  void SetRecoPrimVtxSkippingTrks()
    { fRecoPrimVtxSkippingTrks=kTRUE; fRmTrksFromPrimVtx=kFALSE;}
  void UnsetRecoPrimVtxSkippingTrks()
    { fRecoPrimVtxSkippingTrks=kFALSE; fRmTrksFromPrimVtx=kFALSE;}
  void SetRmTrksFromPrimVtx()
    {fRmTrksFromPrimVtx=kTRUE; fRecoPrimVtxSkippingTrks=kFALSE; }
  void SetTrackFilter(AliAnalysisFilter* trackF) {
    TList *l = (TList*)trackF->GetCuts();
    AliESDtrackCuts *tcuts = (AliESDtrackCuts*)l->FindObject("AliESDtrackCuts");
    if(tcuts->GetFlagCutTOFdistance()) tcuts->SetFlagCutTOFdistance(kFALSE);
    fTrackFilter = trackF;
  }
  void SetTrackFilter2prongPbCentral(Float_t maxPercentile, AliAnalysisFilter* trackF) {
    TList *l = (TList*)trackF->GetCuts();
    AliESDtrackCuts *tcuts = (AliESDtrackCuts*)l->FindObject("AliESDtrackCuts");
    if(tcuts->GetFlagCutTOFdistance()) tcuts->SetFlagCutTOFdistance(kFALSE);
    fTrackFilter2prongCentral = trackF;
    fMaxCentPercentileForTightCuts=maxPercentile;
  }
  void SetTrackFilter3prongPbCentral(Float_t maxPercentile, AliAnalysisFilter* trackF) {
    TList *l = (TList*)trackF->GetCuts();
    AliESDtrackCuts *tcuts = (AliESDtrackCuts*)l->FindObject("AliESDtrackCuts");
    if(tcuts->GetFlagCutTOFdistance()) tcuts->SetFlagCutTOFdistance(kFALSE);
    fTrackFilter3prongCentral = trackF;
    fMaxCentPercentileForTightCuts=maxPercentile;
  }
  void SetTrackFilterSoftPi(AliAnalysisFilter* trackF) {
    TList *l = (TList*)trackF->GetCuts();
    AliESDtrackCuts *tcuts = (AliESDtrackCuts*)l->FindObject("AliESDtrackCuts");
    if(tcuts->GetFlagCutTOFdistance()) tcuts->SetFlagCutTOFdistance(kFALSE);
    fTrackFilterSoftPi = trackF;
  }
  void SetTrackFilterBachelor(AliAnalysisFilter* trackF) {
    TList *l = (TList*)trackF->GetCuts();
    AliESDtrackCuts *tcuts = (AliESDtrackCuts*)l->FindObject("AliESDtrackCuts");
    if(tcuts->GetFlagCutTOFdistance()) tcuts->SetFlagCutTOFdistance(kFALSE);
    fTrackFilterBachelor = trackF;
  }
  AliAnalysisFilter* GetTrackFilter() const { return fTrackFilter; }
  AliAnalysisFilter* GetTrackFilterSoftPi() const { return fTrackFilterSoftPi; }
  void SetCutsD0toKpi(AliRDHFCutsD0toKpi* cuts) { fCutsD0toKpi = cuts; }
  AliRDHFCutsD0toKpi* GetCutsD0toKpi() const { return fCutsD0toKpi; }
  void SetCutsJpsitoee(AliRDHFCutsJpsitoee* cuts) { fCutsJpsitoee = cuts; }
  AliRDHFCutsJpsitoee* GetCutsJpsitoee() const { return fCutsJpsitoee; }
  void SetCutsDplustoK0spi(AliRDHFCutsDplustoK0spi* cuts) { fCutsDplustoK0spi = cuts; }
  AliRDHFCutsDplustoK0spi* GetCutsDplustoK0spi() const { return fCutsDplustoK0spi; }
  void SetCutsDplustoKpipi(AliRDHFCutsDplustoKpipi* cuts) { fCutsDplustoKpipi = cuts; }
  AliRDHFCutsDplustoKpipi* GetCutsDplustoKpipi() const { return fCutsDplustoKpipi; }
  void SetCutsDstoK0sK(AliRDHFCutsDstoK0sK* cuts) { fCutsDstoK0sK = cuts; }
  AliRDHFCutsDstoK0sK* GetCutsDstoK0sK() const { return fCutsDstoK0sK; }
  void SetCutsDstoKKpi(AliRDHFCutsDstoKKpi* cuts) { fCutsDstoKKpi = cuts; }
  AliRDHFCutsDstoKKpi* GetCutsDstoKKpi() const { return fCutsDstoKKpi; }
  void SetCutsLctopKpi(AliRDHFCutsLctopKpi* cuts) { fCutsLctopKpi = cuts; }
  AliRDHFCutsLctopKpi* GetCutsLctopKpi() const { return fCutsLctopKpi; }
  void SetCutsLctoV0(AliRDHFCutsLctoV0* cuts) { fCutsLctoV0 = cuts; }
  AliRDHFCutsLctoV0* GetCutsLctoV0() const { return fCutsLctoV0; }
  void SetCutsD0toKpipipi(AliRDHFCutsD0toKpipipi* cuts) { fCutsD0toKpipipi = cuts; }
  AliRDHFCutsD0toKpipipi* GetCutsD0toKpipipi() const { return fCutsD0toKpipipi; }
  void SetCutsDStartoKpipi(AliRDHFCutsDStartoKpipi* cuts) { fCutsDStartoKpipi = cuts; }
  AliRDHFCutsDStartoKpipi* GetCutsDStartoKpipi() const { return fCutsDStartoKpipi; }
  void SetMassCutBeforeVertexing(Bool_t flag) { fMassCutBeforeVertexing=flag; }

  void SetMasses();
  Bool_t CheckCutsConsistency();

  void SetUseTPCPID(Bool_t opt=kTRUE){fUseTPCPID=opt;}
  void SetUseTOFPID(Bool_t opt=kTRUE){fUseTOFPID=opt;}
  void SetUseTPCPIDOnlyIfNoTOF(Bool_t opt=kTRUE){fUseTPCPIDOnlyIfNoTOF=opt;}
  void SetMaxMomForTPCPid(Double_t mom){fMaxMomForTPCPid=mom;}
  void SetUsePidTag(Bool_t opt=kTRUE){fUsePidTag=opt;}
  void SetnSigmaTPCforPionSel(Double_t nsl, Double_t nsh){
    fnSigmaTPCPionLow=nsl; fnSigmaTPCPionHi=nsh;}
  void SetnSigmaTOFforPionSel(Double_t nsl, Double_t nsh){
    fnSigmaTOFPionLow=nsl; fnSigmaTOFPionHi=nsh;}
  void SetnSigmaTPCforKaonSel(Double_t nsl, Double_t nsh){
    fnSigmaTPCKaonLow=nsl; fnSigmaTPCKaonHi=nsh;}
  void SetnSigmaTOFforKaonSel(Double_t nsl, Double_t nsh){
    fnSigmaTOFKaonLow=nsl; fnSigmaTOFKaonHi=nsh;}
  void SetnSigmaTPCforProtonSel(Double_t nsl, Double_t nsh){
    fnSigmaTPCProtonLow=nsl; fnSigmaTPCProtonHi=nsh;}
  void SetnSigmaTOFforProtonSel(Double_t nsl, Double_t nsh){
    fnSigmaTOFProtonLow=nsl; fnSigmaTOFProtonHi=nsh;}

  void SetUseKaonPIDfor3Prong(Bool_t opt=kTRUE){fUseKaonPIDfor3Prong=opt;}
  void SetNotUseProtonPIDforLambdaC(){fUsePIDforLc=0;}
  void SetUseProtonPIDforLambdaC(){fUsePIDforLc=1;}
  void SetUseProtonAndPionPIDforLambdaC(){fUsePIDforLc=2;}
  void SetUseKaonPIDforDs(Bool_t opt=kTRUE){fUseKaonPIDforDs=opt;}

  void SetNotUseProtonPIDforLambdaC2V0(){fUsePIDforLc2V0=kFALSE;} //clm
  void SetUseProtonPIDforLambdaC2V0(){fUsePIDforLc2V0=kTRUE;}     //clm



  void GetnSigmaTOFforPionSel(Double_t& minnsigma, Double_t& maxnsigma) const {
    minnsigma=fnSigmaTOFPionLow;maxnsigma=fnSigmaTOFPionHi;
  }
  void GetnSigmaTPCforPionSel(Double_t& minnsigma, Double_t& maxnsigma) const {
    minnsigma=fnSigmaTPCPionLow;maxnsigma=fnSigmaTPCPionHi;
  }
  void GetnSigmaTOFforKaonSel(Double_t& minnsigma, Double_t& maxnsigma) const {
    minnsigma=fnSigmaTOFKaonLow;maxnsigma=fnSigmaTOFKaonHi;
  }
  void GetnSigmaTPCforKaonSel(Double_t& minnsigma, Double_t& maxnsigma) const {
    minnsigma=fnSigmaTPCKaonLow;maxnsigma=fnSigmaTPCKaonHi;
  }
  void GetnSigmaTOFforProtonSel(Double_t& minnsigma, Double_t& maxnsigma) const {
    minnsigma=fnSigmaTOFProtonLow;maxnsigma=fnSigmaTOFProtonHi;
  }
  void GetnSigmaTPCforProtonSel(Double_t& minnsigma, Double_t& maxnsigma) const {
    minnsigma=fnSigmaTPCProtonLow;maxnsigma=fnSigmaTPCProtonHi;
  }

  Bool_t GetUseTPCPID() const {return fUseTPCPID;}
  Bool_t GetUseTOFPID() const {return fUseTOFPID;}
  Bool_t GetUseTPCPIDOnlyIfNoTOF() const {return fUseTPCPIDOnlyIfNoTOF;}
  Double_t GetMaxMomForTPCPid() const {return fMaxMomForTPCPid;}

  Bool_t GetUseKaonPIDfor3Prong() const {return fUseKaonPIDfor3Prong;}
  Int_t GetUseProtonPIDforLambdaC() const {return fUsePIDforLc;}
  Bool_t GetUseKaonPIDforDs() const {return fUseKaonPIDforDs;}
  Bool_t GetUseProtonPIDforLambdaC2V0() const {return fUsePIDforLc2V0;}

  void SetPidResponse(AliPIDResponse* p){fPidResponse=p;}

  //
 private:
  //
  enum { kBitDispl = 0, kBitSoftPi = 1, kBit3Prong = 2, kBitPionCompat = 3, kBitKaonCompat = 4, kBitProtonCompat = 5, kBitBachelor = 6};

  Bool_t fInputAOD; 
  Int_t fAODMapSize; 
  Int_t *fAODMap; //[fAODMapSize] map between index and ID for AOD tracks

  AliVertexerTracks* fVertexerTracks; 
  Double_t fBzkG; 

  Bool_t fSecVtxWithKF; 

  Bool_t fRecoPrimVtxSkippingTrks; 
  Bool_t fRmTrksFromPrimVtx; 

  AliESDVertex *fV1; 

  Bool_t fD0toKpi;   
  Bool_t fJPSItoEle; 
  Bool_t f3Prong;    
  Bool_t f4Prong;    
  Bool_t fDstar;     
  Bool_t fCascades;  
  Bool_t fLikeSign;  
  Bool_t fLikeSign3prong;  
  Bool_t fMixEvent; 

  AliPIDResponse* fPidResponse; 
  Bool_t fUseKaonPIDfor3Prong;  
  Int_t  fUsePIDforLc;          
  Bool_t fUsePIDforLc2V0;       
  Bool_t fUseKaonPIDforDs;      
  Bool_t fUseTPCPID;            
  Bool_t fUseTOFPID;            
  Bool_t fUseTPCPIDOnlyIfNoTOF; 
  Double_t fMaxMomForTPCPid;    
  Bool_t fUsePidTag;            
  Double_t fnSigmaTPCPionLow;   
  Double_t fnSigmaTPCPionHi;    
  Double_t fnSigmaTOFPionLow;   
  Double_t fnSigmaTOFPionHi;    
  Double_t fnSigmaTPCKaonLow;   
  Double_t fnSigmaTPCKaonHi;    
  Double_t fnSigmaTOFKaonLow;   
  Double_t fnSigmaTOFKaonHi;    
  Double_t fnSigmaTPCProtonLow; 
  Double_t fnSigmaTPCProtonHi;  
  Double_t fnSigmaTOFProtonLow; 
  Double_t fnSigmaTOFProtonHi;  

  Float_t fMaxCentPercentileForTightCuts; 

  // single-track cuts
  AliAnalysisFilter *fTrackFilter; 
  AliAnalysisFilter *fTrackFilter2prongCentral; 
  AliAnalysisFilter *fTrackFilter3prongCentral; 
  AliAnalysisFilter *fTrackFilterSoftPi; 
  AliAnalysisFilter *fTrackFilterBachelor; 
  // candidates cuts
  AliRDHFCutsD0toKpi *fCutsD0toKpi; 
  AliRDHFCutsJpsitoee *fCutsJpsitoee; 
  AliRDHFCutsDplustoK0spi *fCutsDplustoK0spi; 
  AliRDHFCutsDplustoKpipi *fCutsDplustoKpipi; 
  AliRDHFCutsDstoK0sK *fCutsDstoK0sK; 
  AliRDHFCutsDstoKKpi *fCutsDstoKKpi; 
  AliRDHFCutsLctopKpi *fCutsLctopKpi; 
  AliRDHFCutsLctoV0 *fCutsLctoV0; 
  AliRDHFCutsD0toKpipipi *fCutsD0toKpipipi; 
  AliRDHFCutsDStartoKpipi *fCutsDStartoKpipi; 

  TList *fListOfCuts;    
  Bool_t fFindVertexForDstar; 
  Bool_t fFindVertexForCascades;  
  Int_t  fV0TypeForCascadeVertex;  
  Bool_t fMassCutBeforeVertexing; 
  // dummies for invariant mass calculation
  AliAODRecoDecay *fMassCalc2; 
  AliAODRecoDecay *fMassCalc3; 
  AliAODRecoDecay *fMassCalc4; 
  Bool_t fOKInvMassD0; 
  Bool_t fOKInvMassJpsi; 
  Bool_t fOKInvMassDplus; 
  Bool_t fOKInvMassDs; 
  Bool_t fOKInvMassLc; 
  Bool_t fOKInvMassDstar; 
  Bool_t fOKInvMassD0to4p; 
  Bool_t fOKInvMassLctoV0; 

  Int_t  fnTrksTotal;
  Int_t  fnSeleTrksTotal;
  Bool_t fMakeReducedRHF;// switch the reduction of dAOD size on/off

  Double_t fMassDzero;
  Double_t fMassDplus;
  Double_t fMassDs;
  Double_t fMassLambdaC;
  Double_t fMassDstar;
  Double_t fMassJpsi;


  //
  void AddRefs(AliAODVertex *v,AliAODRecoDecayHF *rd,const AliVEvent *event,
         const TObjArray *trkArray) const;
  void AddDaughterRefs(AliAODVertex *v,const AliVEvent *event,
           const TObjArray *trkArray) const;
  AliAODRecoDecayHF2Prong* Make2Prong(TObjArray *twoTrackArray1,AliVEvent *event,
              AliAODVertex *secVert,Double_t dcap1n1,
              Bool_t &okD0,Bool_t &okJPSI,Bool_t &okD0fromDstar, Bool_t refill=kFALSE, AliAODRecoDecayHF2Prong *rd=0x0);
  AliAODRecoDecayHF3Prong* Make3Prong(TObjArray *threeTrackArray,AliVEvent *event,
              AliAODVertex *secVert,
              Double_t dispersion,
              const AliAODVertex *vertexp1n1,
              const AliAODVertex *vertexp2n1,
              Double_t dcap1n1,Double_t dcap2n1,Double_t dcap1p2,
              Bool_t useForLc, Bool_t useForDs,
              Bool_t &ok3Prong);
  AliAODRecoDecayHF3Prong* Make3Prong(TObjArray *threeTrackArray,AliVEvent *event,
                                      AliAODVertex *secVert,
                                      Double_t dispersion,
                                      Double32_t dist12,
                                      Double32_t dist23,
                                      Double_t dcap1n1,Double_t dcap2n1,Double_t dcap1p2,
                                      AliAODRecoDecayHF3Prong *rd);
  AliAODRecoDecayHF4Prong* Make4Prong(TObjArray *fourTrackArray,AliVEvent *event,
                                      AliAODVertex *secVert,
                                      const AliAODVertex *vertexp1n1,
                                      const AliAODVertex *vertexp1n1p2,
                                      Double_t dcap1n1,Double_t dcap1n2,
                                      Double_t dcap2n1,Double_t dcap2n2,
                                      Bool_t &ok4Prong);
  AliAODRecoCascadeHF* MakeCascade(TObjArray *twoTrackArray,AliVEvent *event,
           AliAODVertex *secVert,
           AliAODRecoDecayHF2Prong *rd2Prong,
           Double_t dca,
           Bool_t &okDstar);
  AliAODRecoCascadeHF* MakeCascade(TObjArray *twoTrackArray,AliVEvent *event,
           AliAODVertex *secVert,
           AliAODv0 *v0,
           Double_t dca,
           Bool_t &okCascades);

  void MapAODtracks(AliVEvent *aod);
  AliAODVertex* PrimaryVertex(const TObjArray *trkArray=0x0,AliVEvent *event=0x0) const;
  AliAODVertex* ReconstructSecondaryVertex(TObjArray *trkArray,Double_t &dispersion,Bool_t useTRefArray=kTRUE) const;

  Bool_t SelectInvMassAndPt3prong(Double_t *px,Double_t *py,Double_t *pz, Int_t pidLcStatus=3);
  Bool_t SelectInvMassAndPt4prong(Double_t *px,Double_t *py,Double_t *pz);
  Bool_t SelectInvMassAndPtD0Kpi(Double_t *px,Double_t *py,Double_t *pz);
  Bool_t SelectInvMassAndPtJpsiee(Double_t *px,Double_t *py,Double_t *pz);
  Bool_t SelectInvMassAndPtDstarD0pi(Double_t *px,Double_t *py,Double_t *pz);
  Bool_t SelectInvMassAndPtCascade(Double_t *px,Double_t *py,Double_t *pz);

  Bool_t SelectInvMassAndPt3prong(TObjArray *trkArray);
  Bool_t SelectInvMassAndPt4prong(TObjArray *trkArray);
  Bool_t SelectInvMassAndPtDstarD0pi(TObjArray *trkArray);

  void   SelectTracksAndCopyVertex(const AliVEvent *event,Int_t trkEntries,
           TObjArray &seleTrksArray,
           TObjArray &tracksAtVertex,
           Int_t &nSeleTrks,
           UChar_t *seleFlags,Int_t *evtNumber);
  void SetParametersAtVertex(AliESDtrack* esdt, const AliExternalTrackParam* extpar) const;

  Bool_t SingleTrkCuts(AliESDtrack *trk,Float_t centralityperc, Bool_t &okDisplaced,Bool_t &okSoftPi, Bool_t &ok3prong, Bool_t &okBachelor) const;

  void   SetSelectionBitForPID(AliRDHFCuts *cuts,AliAODRecoDecayHF *rd,Int_t bit);

  AliAODv0* TransformESDv0toAODv0(AliESDv0 *esdv0,
          TObjArray *twoTrackArrayV0);

  ClassDef(AliAnalysisVertexingHF,27);  // Reconstruction of HF decay candidates
};

#endif