[u/mrichter/AliRoot.git] / PWGHF / vertexingHF / AliAnalysisVertexingHF.h

#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$ */ 

//-------------------------------------------------------------------------
//                      Class AliAnalysisVertexingHF
//            Reconstruction of heavy-flavour decay candidates
//      
//  Origin: E.Bruna, G.E.Bruno, A.Dainese, F.Prino, R.Romita, X.M.Zhang
//  Contact: andrea.dainese@pd.infn.it
//-------------------------------------------------------------------------

#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 AliRDHFCutsDplustoKpipi;
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);  
  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; }
  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;}
  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) {
    // switch off the TOF selection that cannot be applied with AODTracks 
    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) {
    // switch off the TOF selection that cannot be applied with AODTracks 
    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) {
    // switch off the TOF selection that cannot be applied with AODTracks 
    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) { 
    // switch off the TOF selection that cannot be applied with AODTracks 
    TList *l = (TList*)trackF->GetCuts();
    AliESDtrackCuts *tcuts = (AliESDtrackCuts*)l->FindObject("AliESDtrackCuts");
    if(tcuts->GetFlagCutTOFdistance()) tcuts->SetFlagCutTOFdistance(kFALSE);
    fTrackFilterSoftPi = 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 SetCutsDplustoKpipi(AliRDHFCutsDplustoKpipi* cuts) { fCutsDplustoKpipi = cuts; }
  AliRDHFCutsDplustoKpipi* GetCutsDplustoKpipi() const { return fCutsDplustoKpipi; }
  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 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};

  Bool_t fInputAOD; // input from AOD (kTRUE) or ESD (kFALSE) 
  Int_t fAODMapSize; // size of fAODMap 
  Int_t *fAODMap; //[fAODMapSize] map between index and ID for AOD tracks

  AliVertexerTracks* fVertexerTracks; // vertexer, to compute secondary vertices
  Double_t fBzkG; // z componenent of field in kG

  Bool_t fSecVtxWithKF; // if kTRUE use KF vertexer, else AliVertexerTracks

  Bool_t fRecoPrimVtxSkippingTrks; // flag for primary vertex reco on the fly
                                   // for each candidate, w/o its daughters
  Bool_t fRmTrksFromPrimVtx; // flag for fast removal of daughters from 
                             // the primary vertex

  AliESDVertex *fV1; // primary vertex

  // flag to enable candidates production
  Bool_t fD0toKpi;   // D0->Kpi 
  Bool_t fJPSItoEle; // Jpsi->ee
  Bool_t f3Prong;    // D+,Ds,Lc
  Bool_t f4Prong;    // D0->Kpipipi
  Bool_t fDstar;     // D*->D0pi
  Bool_t fCascades;  // cascades, Lc --> v0+track
  Bool_t fLikeSign;  // Like-sign pairs
  Bool_t fLikeSign3prong;  // Like-sign triplets
  Bool_t fMixEvent; // event mixing

  AliPIDResponse* fPidResponse; // PID response
  Bool_t fUseKaonPIDfor3Prong;  // Kaon PID usage for 3 prongs
  Int_t  fUsePIDforLc;          // PID for Lambdac: 0=no, 1=proton, 2=p and pi
  Bool_t fUsePIDforLc2V0;       // PID for Lambdac 2 V0: 0=no, 1=proton,
  Bool_t fUseKaonPIDforDs;      // Kaon PID usage for Ds
  Bool_t fUseTPCPID;            // switch use/not use TPC PID
  Bool_t fUseTOFPID;            // switch use/not use TOF PID
  Bool_t fUseTPCPIDOnlyIfNoTOF; // use TPC PID only for tracks that without TOF
  Double_t fMaxMomForTPCPid;    // upper momentum limit to apply TPC PID
  Double_t fnSigmaTPCPionLow;   //Low cut value on n. of sigmas for pi TPC PID
  Double_t fnSigmaTPCPionHi;    //High cut value on n. of sigmas for pi TPC PID
  Double_t fnSigmaTOFPionLow;   //Low cut value on n. of sigmas for pi TOF PID
  Double_t fnSigmaTOFPionHi;    //High cut value on n. of sigmas for pi TOF PID
  Double_t fnSigmaTPCKaonLow;   //Low cut value on n. of sigmas for K TPC PID
  Double_t fnSigmaTPCKaonHi;    //High cut value on n. of sigmas for K TPC PID
  Double_t fnSigmaTOFKaonLow;   //Low cut value on n. of sigmas for K TOF PID
  Double_t fnSigmaTOFKaonHi;    //High cut value on n. of sigmas for K TOF PID
  Double_t fnSigmaTPCProtonLow; //Low cut value on n. of sigmas for p TPC PID
  Double_t fnSigmaTPCProtonHi;  //High cut value on n. of sigmas for p TPC PID
  Double_t fnSigmaTOFProtonLow; //Low cut value on n. of sigmas for p TOF PID
  Double_t fnSigmaTOFProtonHi;  //High cut value on n. of sigmas for p TOF PID

  Float_t fMaxCentPercentileForTightCuts; //max. centrality percentile for using tight cuts

  // single-track cuts
  AliAnalysisFilter *fTrackFilter; //  Track Filter for displaced vertices
  AliAnalysisFilter *fTrackFilter2prongCentral; //  Track Filter for displaced vertices in PbPb central events (tighter cuts) for 2 prong (D0->Kpi)
  AliAnalysisFilter *fTrackFilter3prongCentral; //  Track Filter for displaced vertices in PbPb central events (tighter cuts) for 3 prong (D+, Ds, Lc)
  AliAnalysisFilter *fTrackFilterSoftPi; //  Track Filter for D* soft pion
  // candidates cuts
  AliRDHFCutsD0toKpi *fCutsD0toKpi; // D0->Kpi cuts
  AliRDHFCutsJpsitoee *fCutsJpsitoee; // J/psi->ee cuts
  AliRDHFCutsDplustoKpipi *fCutsDplustoKpipi; // D+->Kpipi cuts
  AliRDHFCutsDstoKKpi *fCutsDstoKKpi; // Ds->KKpi cuts
  AliRDHFCutsLctopKpi *fCutsLctopKpi; // Lc->pKpi cuts
  AliRDHFCutsLctoV0 *fCutsLctoV0; // Lc --> v0 + bachelor cuts
  AliRDHFCutsD0toKpipipi *fCutsD0toKpipipi; // D0->Kpipipi cuts
  AliRDHFCutsDStartoKpipi *fCutsDStartoKpipi; // Dstar->D0pi cuts

  TList *fListOfCuts;    // pointer to list of cuts for output file
  Bool_t fFindVertexForDstar; // reconstruct a secondary vertex or assume it's from the primary vertex
  Bool_t fFindVertexForCascades;  // reconstruct a secondary vertex or assume it's from the primary vertex
  Int_t  fV0TypeForCascadeVertex;  // Select which V0 type we want to use for the cascas
  Bool_t fMassCutBeforeVertexing; // to go faster in PbPb
  // dummies for invariant mass calculation
  AliAODRecoDecay *fMassCalc2; // for 2 prong
  AliAODRecoDecay *fMassCalc3; // for 3 prong
  AliAODRecoDecay *fMassCalc4; // for 4 prong
  Bool_t fOKInvMassD0; // pair fullfilling D0 inv mass selection
  Bool_t fOKInvMassJpsi; // pair fullfilling Jpsi inv mass selection
  Bool_t fOKInvMassDplus; // triplet fullfilling D+ inv mass selection
  Bool_t fOKInvMassDs; // triplet fullfilling Ds inv mass selection
  Bool_t fOKInvMassLc; // triplet fullfilling Lc inv mass selection
  Bool_t fOKInvMassDstar; // combination fullfilling D* inv mass selection
  Bool_t fOKInvMassD0to4p; // 4tracks fullfilling D0 inv mass selection
  Bool_t fOKInvMassLctoV0; // triplet fullfilling Lc inv mass selection

  Int_t fnTrksTotal;
  Int_t fnSeleTrksTotal;

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

  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) const;

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

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

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


#endif
Commit	Line	Data
c4cdf105	1	#ifndef ALIANALYSISVERTEXINGHF_H
c4cdf105	2	#define ALIANALYSISVERTEXINGHF_H
6a213b59	3	/* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5
27de2dfb	6	/* $Id$ */
27de2dfb	7
6a213b59	8	//-------------------------------------------------------------------------
	9	// Class AliAnalysisVertexingHF
	10	// Reconstruction of heavy-flavour decay candidates
	11	//
2ff20727	12	// Origin: E.Bruna, G.E.Bruno, A.Dainese, F.Prino, R.Romita, X.M.Zhang
a25935a9	13	// Contact: andrea.dainese@pd.infn.it
6a213b59	14	//-------------------------------------------------------------------------
	15
	16	#include <TNamed.h>
19ccb888	17	#include <TList.h>
	18
	19	#include "AliAnalysisFilter.h"
	20	#include "AliESDtrackCuts.h"
6a213b59	21
0602cf99	22	class AliPIDResponse;
c4cdf105	23	class AliESDVertex;
e0732246	24	class AliAODRecoDecay;
c4cdf105	25	class AliAODRecoDecayHF;
	26	class AliAODRecoDecayHF2Prong;
	27	class AliAODRecoDecayHF3Prong;
	28	class AliAODRecoDecayHF4Prong;
	29	class AliAODRecoCascadeHF;
	30	class AliAnalysisFilter;
939850df	31	class AliRDHFCuts;
f3014dc3	32	class AliRDHFCutsD0toKpi;
e3d40058	33	class AliRDHFCutsJpsitoee;
	34	class AliRDHFCutsDplustoKpipi;
	35	class AliRDHFCutsDstoKKpi;
	36	class AliRDHFCutsLctopKpi;
a07ad8e0	37	class AliRDHFCutsLctoV0;
e3d40058	38	class AliRDHFCutsD0toKpipipi;
da6fefc3	39	class AliRDHFCutsDStartoKpipi;
dcb444c9	40	class AliESDtrack;
	41	class AliVEvent;
	42	class AliAODVertex;
c7d3975b	43	class AliVertexerTracks;
a07ad8e0	44	class AliESDv0;
a07ad8e0	45	class AliAODv0;
dcb444c9	46
6a213b59	47	//-----------------------------------------------------------------------------
	48	class AliAnalysisVertexingHF : public TNamed {
	49	public:
	50	//
	51	AliAnalysisVertexingHF();
13977a79	52	AliAnalysisVertexingHF(const AliAnalysisVertexingHF& source);
13977a79	53	AliAnalysisVertexingHF& operator=(const AliAnalysisVertexingHF& source);
6a213b59	54	virtual ~AliAnalysisVertexingHF();
6a213b59	55
dcb444c9	56	void FindCandidates(AliVEvent *event,
	57	TClonesArray *aodVerticesHFTClArr,
	58	TClonesArray *aodD0toKpiTClArr,
	59	TClonesArray *aodJPSItoEleTClArr,
	60	TClonesArray *aodCharm3ProngTClArr,
2ff20727	61	TClonesArray *aodCharm4ProngTClArr,
dc963de9	62	TClonesArray *aodDstarTClArr,
a07ad8e0	63	TClonesArray *aodCascadesTClArr,
423fb9ae	64	TClonesArray *aodLikeSign2ProngTClArr,
423fb9ae	65	TClonesArray *aodLikeSign3ProngTClArr);
dcb444c9	66
a9b75906	67	TList* FillListOfCuts();
37fc73f1	68	void FixReferences(AliAODEvent *aod);
6a213b59	69	void PrintStatus() const;
b82f6d67	70	void SetSecVtxWithKF() { fSecVtxWithKF=kTRUE; }
6a213b59	71	void SetD0toKpiOn() { fD0toKpi=kTRUE; }
	72	void SetD0toKpiOff() { fD0toKpi=kFALSE; }
	73	void SetJPSItoEleOn() { fJPSItoEle=kTRUE; }
	74	void SetJPSItoEleOff() { fJPSItoEle=kFALSE; }
	75	void Set3ProngOn() { f3Prong=kTRUE; }
	76	void Set3ProngOff() { f3Prong=kFALSE; }
	77	void Set4ProngOn() { f4Prong=kTRUE; }
	78	void Set4ProngOff() { f4Prong=kFALSE; }
2ff20727	79	void SetDstarOn() { fDstar=kTRUE; }
2ff20727	80	void SetDstarOff() { fDstar=kFALSE; }
a07ad8e0	81	void SetCascadesOn() { fCascades=kTRUE; }
a07ad8e0	82	void SetCascadesOff() { fCascades=kFALSE; }
dc963de9	83	void SetLikeSignOn() { fLikeSign=kTRUE; }
1992284a	84	void SetLikeSignOff() {fLikeSign=kFALSE; fLikeSign3prong=kFALSE;}
	85	void SetLikeSign3prongOn() { fLikeSign=kTRUE; fLikeSign3prong=kTRUE; }
	86	void SetLikeSign3prongOff() { fLikeSign3prong=kFALSE; }
a25935a9	87	void SetMixEventOn() { fMixEvent=kTRUE; }
	88	void SetMixEventOff() { fMixEvent=kFALSE; }
	89	void SetInputAOD() { fInputAOD=kTRUE; }
c4cdf105	90	Bool_t GetD0toKpi() const { return fD0toKpi; }
	91	Bool_t GetJPSItoEle() const { return fJPSItoEle; }
	92	Bool_t Get3Prong() const { return f3Prong; }
	93	Bool_t Get4Prong() const { return f4Prong; }
	94	Bool_t GetDstar() const { return fDstar; }
a07ad8e0	95	Bool_t GetCascades() const { return fCascades; }
c4cdf105	96	Bool_t GetLikeSign() const { return fLikeSign; }
1992284a	97	Bool_t GetLikeSign3prong() const { return fLikeSign3prong; }
c4cdf105	98	Bool_t GetMixEvent() const { return fMixEvent; }
	99	Bool_t GetInputAOD() const { return fInputAOD; }
	100	Bool_t GetRecoPrimVtxSkippingTrks() const {return fRecoPrimVtxSkippingTrks;}
	101	Bool_t GetRmTrksFromPrimVtx() const {return fRmTrksFromPrimVtx;}
eee95e18	102	void SetFindVertexForDstar(Bool_t vtx=kTRUE) { fFindVertexForDstar=vtx; }
a07ad8e0	103	void SetFindVertexForCascades(Bool_t vtx=kTRUE) { fFindVertexForCascades=vtx; }
34595b3c	104
	105	void SetV0TypeForCascadeVertex(Int_t type) {fV0TypeForCascadeVertex = type;}
	106	Int_t GetV0TypeForCascadeVertex() { return fV0TypeForCascadeVertex;}
	107
6a213b59	108	void SetRecoPrimVtxSkippingTrks()
6a213b59	109	{ fRecoPrimVtxSkippingTrks=kTRUE; fRmTrksFromPrimVtx=kFALSE;}
a25935a9	110	void UnsetRecoPrimVtxSkippingTrks()
a25935a9	111	{ fRecoPrimVtxSkippingTrks=kFALSE; fRmTrksFromPrimVtx=kFALSE;}
6a213b59	112	void SetRmTrksFromPrimVtx()
6a213b59	113	{fRmTrksFromPrimVtx=kTRUE; fRecoPrimVtxSkippingTrks=kFALSE; }
19ccb888	114	void SetTrackFilter(AliAnalysisFilter* trackF) {
	115	// switch off the TOF selection that cannot be applied with AODTracks
	116	TList l = (TList)trackF->GetCuts();
	117	AliESDtrackCuts tcuts = (AliESDtrackCuts)l->FindObject("AliESDtrackCuts");
	118	if(tcuts->GetFlagCutTOFdistance()) tcuts->SetFlagCutTOFdistance(kFALSE);
	119	fTrackFilter = trackF;
	120	}
c7d3975b	121	void SetTrackFilter2prongPbCentral(Float_t maxPercentile, AliAnalysisFilter* trackF) {
	122	// switch off the TOF selection that cannot be applied with AODTracks
	123	TList l = (TList)trackF->GetCuts();
	124	AliESDtrackCuts tcuts = (AliESDtrackCuts)l->FindObject("AliESDtrackCuts");
	125	if(tcuts->GetFlagCutTOFdistance()) tcuts->SetFlagCutTOFdistance(kFALSE);
	126	fTrackFilter2prongCentral = trackF;
	127	fMaxCentPercentileForTightCuts=maxPercentile;
	128	}
	129	void SetTrackFilter3prongPbCentral(Float_t maxPercentile, AliAnalysisFilter* trackF) {
	130	// switch off the TOF selection that cannot be applied with AODTracks
	131	TList l = (TList)trackF->GetCuts();
	132	AliESDtrackCuts tcuts = (AliESDtrackCuts)l->FindObject("AliESDtrackCuts");
	133	if(tcuts->GetFlagCutTOFdistance()) tcuts->SetFlagCutTOFdistance(kFALSE);
	134	fTrackFilter3prongCentral = trackF;
	135	fMaxCentPercentileForTightCuts=maxPercentile;
	136	}
19ccb888	137	void SetTrackFilterSoftPi(AliAnalysisFilter* trackF) {
	138	// switch off the TOF selection that cannot be applied with AODTracks
	139	TList l = (TList)trackF->GetCuts();
	140	AliESDtrackCuts tcuts = (AliESDtrackCuts)l->FindObject("AliESDtrackCuts");
	141	if(tcuts->GetFlagCutTOFdistance()) tcuts->SetFlagCutTOFdistance(kFALSE);
	142	fTrackFilterSoftPi = trackF;
	143	}
dc963de9	144	AliAnalysisFilter* GetTrackFilter() const { return fTrackFilter; }
dc963de9	145	AliAnalysisFilter* GetTrackFilterSoftPi() const { return fTrackFilterSoftPi; }
f3014dc3	146	void SetCutsD0toKpi(AliRDHFCutsD0toKpi* cuts) { fCutsD0toKpi = cuts; }
f3014dc3	147	AliRDHFCutsD0toKpi* GetCutsD0toKpi() const { return fCutsD0toKpi; }
e3d40058	148	void SetCutsJpsitoee(AliRDHFCutsJpsitoee* cuts) { fCutsJpsitoee = cuts; }
	149	AliRDHFCutsJpsitoee* GetCutsJpsitoee() const { return fCutsJpsitoee; }
	150	void SetCutsDplustoKpipi(AliRDHFCutsDplustoKpipi* cuts) { fCutsDplustoKpipi = cuts; }
	151	AliRDHFCutsDplustoKpipi* GetCutsDplustoKpipi() const { return fCutsDplustoKpipi; }
	152	void SetCutsDstoKKpi(AliRDHFCutsDstoKKpi* cuts) { fCutsDstoKKpi = cuts; }
	153	AliRDHFCutsDstoKKpi* GetCutsDstoKKpi() const { return fCutsDstoKKpi; }
	154	void SetCutsLctopKpi(AliRDHFCutsLctopKpi* cuts) { fCutsLctopKpi = cuts; }
	155	AliRDHFCutsLctopKpi* GetCutsLctopKpi() const { return fCutsLctopKpi; }
a07ad8e0	156	void SetCutsLctoV0(AliRDHFCutsLctoV0* cuts) { fCutsLctoV0 = cuts; }
a07ad8e0	157	AliRDHFCutsLctoV0* GetCutsLctoV0() const { return fCutsLctoV0; }
e3d40058	158	void SetCutsD0toKpipipi(AliRDHFCutsD0toKpipipi* cuts) { fCutsD0toKpipipi = cuts; }
e3d40058	159	AliRDHFCutsD0toKpipipi* GetCutsD0toKpipipi() const { return fCutsD0toKpipipi; }
da6fefc3	160	void SetCutsDStartoKpipi(AliRDHFCutsDStartoKpipi* cuts) { fCutsDStartoKpipi = cuts; }
da6fefc3	161	AliRDHFCutsDStartoKpipi* GetCutsDStartoKpipi() const { return fCutsDStartoKpipi; }
e0732246	162	void SetMassCutBeforeVertexing(Bool_t flag) { fMassCutBeforeVertexing=flag; }
6ea608bf	163
c7d3975b	164	void SetMasses();
34595b3c	165	Bool_t CheckCutsConsistency();
34595b3c	166
fd0c688e	167	void SetUseTPCPID(Bool_t opt=kTRUE){fUseTPCPID=opt;}
	168	void SetUseTOFPID(Bool_t opt=kTRUE){fUseTOFPID=opt;}
	169	void SetUseTPCPIDOnlyIfNoTOF(Bool_t opt=kTRUE){fUseTPCPIDOnlyIfNoTOF=opt;}
	170	void SetMaxMomForTPCPid(Double_t mom){fMaxMomForTPCPid=mom;}
	171	void SetnSigmaTPCforPionSel(Double_t nsl, Double_t nsh){
	172	fnSigmaTPCPionLow=nsl; fnSigmaTPCPionHi=nsh;}
	173	void SetnSigmaTOFforPionSel(Double_t nsl, Double_t nsh){
	174	fnSigmaTOFPionLow=nsl; fnSigmaTOFPionHi=nsh;}
	175	void SetnSigmaTPCforKaonSel(Double_t nsl, Double_t nsh){
	176	fnSigmaTPCKaonLow=nsl; fnSigmaTPCKaonHi=nsh;}
0602cf99	177	void SetnSigmaTOFforKaonSel(Double_t nsl, Double_t nsh){
0602cf99	178	fnSigmaTOFKaonLow=nsl; fnSigmaTOFKaonHi=nsh;}
fd0c688e	179	void SetnSigmaTPCforProtonSel(Double_t nsl, Double_t nsh){
	180	fnSigmaTPCProtonLow=nsl; fnSigmaTPCProtonHi=nsh;}
	181	void SetnSigmaTOFforProtonSel(Double_t nsl, Double_t nsh){
	182	fnSigmaTOFProtonLow=nsl; fnSigmaTOFProtonHi=nsh;}
	183
	184	void SetUseKaonPIDfor3Prong(Bool_t opt=kTRUE){fUseKaonPIDfor3Prong=opt;}
	185	void SetNotUseProtonPIDforLambdaC(){fUsePIDforLc=0;}
	186	void SetUseProtonPIDforLambdaC(){fUsePIDforLc=1;}
	187	void SetUseProtonAndPionPIDforLambdaC(){fUsePIDforLc=2;}
	188	void SetUseKaonPIDforDs(Bool_t opt=kTRUE){fUseKaonPIDforDs=opt;}
	189
30bd7ffa	190	void SetNotUseProtonPIDforLambdaC2V0(){fUsePIDforLc2V0=kFALSE;} //clm
	191	void SetUseProtonPIDforLambdaC2V0(){fUsePIDforLc2V0=kTRUE;} //clm
	192
	193
	194
	195	void GetnSigmaTOFforPionSel(Double_t& minnsigma, Double_t& maxnsigma) const {
	196	minnsigma=fnSigmaTOFPionLow;maxnsigma=fnSigmaTOFPionHi;
	197	}
	198	void GetnSigmaTPCforPionSel(Double_t& minnsigma, Double_t& maxnsigma) const {
	199	minnsigma=fnSigmaTPCPionLow;maxnsigma=fnSigmaTPCPionHi;
	200	}
	201	void GetnSigmaTOFforKaonSel(Double_t& minnsigma, Double_t& maxnsigma) const {
	202	minnsigma=fnSigmaTOFKaonLow;maxnsigma=fnSigmaTOFKaonHi;
	203	}
	204	void GetnSigmaTPCforKaonSel(Double_t& minnsigma, Double_t& maxnsigma) const {
	205	minnsigma=fnSigmaTPCKaonLow;maxnsigma=fnSigmaTPCKaonHi;
	206	}
	207	void GetnSigmaTOFforProtonSel(Double_t& minnsigma, Double_t& maxnsigma) const {
	208	minnsigma=fnSigmaTOFProtonLow;maxnsigma=fnSigmaTOFProtonHi;
	209	}
	210	void GetnSigmaTPCforProtonSel(Double_t& minnsigma, Double_t& maxnsigma) const {
	211	minnsigma=fnSigmaTPCProtonLow;maxnsigma=fnSigmaTPCProtonHi;
	212	}
	213
	214	Bool_t GetUseTPCPID() const {return fUseTPCPID;}
	215	Bool_t GetUseTOFPID() const {return fUseTOFPID;}
	216	Bool_t GetUseTPCPIDOnlyIfNoTOF() const {return fUseTPCPIDOnlyIfNoTOF;}
	217	Double_t GetMaxMomForTPCPid() const {return fMaxMomForTPCPid;}
	218
	219	Bool_t GetUseKaonPIDfor3Prong() const {return fUseKaonPIDfor3Prong;}
	220	Int_t GetUseProtonPIDforLambdaC() const {return fUsePIDforLc;}
	221	Bool_t GetUseKaonPIDforDs() const {return fUseKaonPIDforDs;}
	222	Bool_t GetUseProtonPIDforLambdaC2V0() const {return fUsePIDforLc2V0;}
	223
0602cf99	224	void SetPidResponse(AliPIDResponse* p){fPidResponse=p;}
c7d3975b	225
6a213b59	226	//
	227	private:
	228	//
fd0c688e	229	enum { kBitDispl = 0, kBitSoftPi = 1, kBit3Prong = 2, kBitPionCompat = 3, kBitKaonCompat = 4, kBitProtonCompat = 5};
2ff20727	230
dcb444c9	231	Bool_t fInputAOD; // input from AOD (kTRUE) or ESD (kFALSE)
c8ab4e4f	232	Int_t fAODMapSize; // size of fAODMap
c8ab4e4f	233	Int_t *fAODMap; //[fAODMapSize] map between index and ID for AOD tracks
dcb444c9	234
c7d3975b	235	AliVertexerTracks* fVertexerTracks; // vertexer, to compute secondary vertices
b82f6d67	236	Double_t fBzkG; // z componenent of field in kG
	237
	238	Bool_t fSecVtxWithKF; // if kTRUE use KF vertexer, else AliVertexerTracks
	239
6a213b59	240	Bool_t fRecoPrimVtxSkippingTrks; // flag for primary vertex reco on the fly
	241	// for each candidate, w/o its daughters
	242	Bool_t fRmTrksFromPrimVtx; // flag for fast removal of daughters from
	243	// the primary vertex
	244
	245	AliESDVertex *fV1; // primary vertex
	246
6a213b59	247	// flag to enable candidates production
2ff20727	248	Bool_t fD0toKpi; // D0->Kpi
	249	Bool_t fJPSItoEle; // Jpsi->ee
	250	Bool_t f3Prong; // D+,Ds,Lc
	251	Bool_t f4Prong; // D0->Kpipipi
	252	Bool_t fDstar; // D*->D0pi
a07ad8e0	253	Bool_t fCascades; // cascades, Lc --> v0+track
dc963de9	254	Bool_t fLikeSign; // Like-sign pairs
1992284a	255	Bool_t fLikeSign3prong; // Like-sign triplets
a25935a9	256	Bool_t fMixEvent; // event mixing
6a213b59	257
0602cf99	258	AliPIDResponse* fPidResponse; // PID response
fd0c688e	259	Bool_t fUseKaonPIDfor3Prong; // Kaon PID usage for 3 prongs
fd0c688e	260	Int_t fUsePIDforLc; // PID for Lambdac: 0=no, 1=proton, 2=p and pi
30bd7ffa	261	Bool_t fUsePIDforLc2V0; // PID for Lambdac 2 V0: 0=no, 1=proton,
fd0c688e	262	Bool_t fUseKaonPIDforDs; // Kaon PID usage for Ds
	263	Bool_t fUseTPCPID; // switch use/not use TPC PID
	264	Bool_t fUseTOFPID; // switch use/not use TOF PID
	265	Bool_t fUseTPCPIDOnlyIfNoTOF; // use TPC PID only for tracks that without TOF
	266	Double_t fMaxMomForTPCPid; // upper momentum limit to apply TPC PID
	267	Double_t fnSigmaTPCPionLow; //Low cut value on n. of sigmas for pi TPC PID
	268	Double_t fnSigmaTPCPionHi; //High cut value on n. of sigmas for pi TPC PID
	269	Double_t fnSigmaTOFPionLow; //Low cut value on n. of sigmas for pi TOF PID
	270	Double_t fnSigmaTOFPionHi; //High cut value on n. of sigmas for pi TOF PID
	271	Double_t fnSigmaTPCKaonLow; //Low cut value on n. of sigmas for K TPC PID
	272	Double_t fnSigmaTPCKaonHi; //High cut value on n. of sigmas for K TPC PID
	273	Double_t fnSigmaTOFKaonLow; //Low cut value on n. of sigmas for K TOF PID
	274	Double_t fnSigmaTOFKaonHi; //High cut value on n. of sigmas for K TOF PID
	275	Double_t fnSigmaTPCProtonLow; //Low cut value on n. of sigmas for p TPC PID
	276	Double_t fnSigmaTPCProtonHi; //High cut value on n. of sigmas for p TPC PID
	277	Double_t fnSigmaTOFProtonLow; //Low cut value on n. of sigmas for p TOF PID
	278	Double_t fnSigmaTOFProtonHi; //High cut value on n. of sigmas for p TOF PID
0602cf99	279
c7d3975b	280	Float_t fMaxCentPercentileForTightCuts; //max. centrality percentile for using tight cuts
c7d3975b	281
6a213b59	282	// single-track cuts
2ff20727	283	AliAnalysisFilter *fTrackFilter; // Track Filter for displaced vertices
c7d3975b	284	AliAnalysisFilter *fTrackFilter2prongCentral; // Track Filter for displaced vertices in PbPb central events (tighter cuts) for 2 prong (D0->Kpi)
c7d3975b	285	AliAnalysisFilter *fTrackFilter3prongCentral; // Track Filter for displaced vertices in PbPb central events (tighter cuts) for 3 prong (D+, Ds, Lc)
2ff20727	286	AliAnalysisFilter fTrackFilterSoftPi; // Track Filter for D soft pion
6a213b59	287	// candidates cuts
f3014dc3	288	AliRDHFCutsD0toKpi *fCutsD0toKpi; // D0->Kpi cuts
e3d40058	289	AliRDHFCutsJpsitoee *fCutsJpsitoee; // J/psi->ee cuts
	290	AliRDHFCutsDplustoKpipi *fCutsDplustoKpipi; // D+->Kpipi cuts
	291	AliRDHFCutsDstoKKpi *fCutsDstoKKpi; // Ds->KKpi cuts
	292	AliRDHFCutsLctopKpi *fCutsLctopKpi; // Lc->pKpi cuts
a07ad8e0	293	AliRDHFCutsLctoV0 *fCutsLctoV0; // Lc --> v0 + bachelor cuts
e3d40058	294	AliRDHFCutsD0toKpipipi *fCutsD0toKpipipi; // D0->Kpipipi cuts
da6fefc3	295	AliRDHFCutsDStartoKpipi *fCutsDStartoKpipi; // Dstar->D0pi cuts
f3014dc3	296
a9b75906	297	TList *fListOfCuts; // pointer to list of cuts for output file
eee95e18	298	Bool_t fFindVertexForDstar; // reconstruct a secondary vertex or assume it's from the primary vertex
a07ad8e0	299	Bool_t fFindVertexForCascades; // reconstruct a secondary vertex or assume it's from the primary vertex
34595b3c	300	Int_t fV0TypeForCascadeVertex; // Select which V0 type we want to use for the cascas
e0732246	301	Bool_t fMassCutBeforeVertexing; // to go faster in PbPb
	302	// dummies for invariant mass calculation
	303	AliAODRecoDecay *fMassCalc2; // for 2 prong
	304	AliAODRecoDecay *fMassCalc3; // for 3 prong
	305	AliAODRecoDecay *fMassCalc4; // for 4 prong
c7d3975b	306	Bool_t fOKInvMassD0; // pair fullfilling D0 inv mass selection
	307	Bool_t fOKInvMassJpsi; // pair fullfilling Jpsi inv mass selection
	308	Bool_t fOKInvMassDplus; // triplet fullfilling D+ inv mass selection
	309	Bool_t fOKInvMassDs; // triplet fullfilling Ds inv mass selection
	310	Bool_t fOKInvMassLc; // triplet fullfilling Lc inv mass selection
	311	Bool_t fOKInvMassDstar; // combination fullfilling D* inv mass selection
	312	Bool_t fOKInvMassD0to4p; // 4tracks fullfilling D0 inv mass selection
	313	Bool_t fOKInvMassLctoV0; // triplet fullfilling Lc inv mass selection
5e938293	314
	315	Int_t fnTrksTotal;
	316	Int_t fnSeleTrksTotal;
	317
c7d3975b	318	Double_t fMassDzero;
	319	Double_t fMassDplus;
	320	Double_t fMassDs;
	321	Double_t fMassLambdaC;
	322	Double_t fMassDstar;
	323	Double_t fMassJpsi;
	324
	325
6a213b59	326	//
a9b75906	327	void AddRefs(AliAODVertex v,AliAODRecoDecayHF rd,const AliVEvent *event,
a9b75906	328	const TObjArray *trkArray) const;
c4cdf105	329	void AddDaughterRefs(AliAODVertex v,const AliVEvent event,
c4cdf105	330	const TObjArray *trkArray) const;
dcb444c9	331	AliAODRecoDecayHF2Prong* Make2Prong(TObjArray twoTrackArray1,AliVEvent event,
dcb444c9	332	AliAODVertex *secVert,Double_t dcap1n1,
c7d3975b	333	Bool_t &okD0,Bool_t &okJPSI,Bool_t &okD0fromDstar);
dcb444c9	334	AliAODRecoDecayHF3Prong* Make3Prong(TObjArray threeTrackArray,AliVEvent event,
	335	AliAODVertex *secVert,
	336	Double_t dispersion,
c4cdf105	337	const AliAODVertex *vertexp1n1,
c4cdf105	338	const AliAODVertex *vertexp2n1,
fd0c688e	339	Double_t dcap1n1,Double_t dcap2n1,Double_t dcap1p2,
fd0c688e	340	Bool_t useForLc, Bool_t useForDs,
c7d3975b	341	Bool_t &ok3Prong);
dcb444c9	342	AliAODRecoDecayHF4Prong* Make4Prong(TObjArray fourTrackArray,AliVEvent event,
721c0b8f	343	AliAODVertex *secVert,
c4cdf105	344	const AliAODVertex *vertexp1n1,
c4cdf105	345	const AliAODVertex *vertexp1n1p2,
721c0b8f	346	Double_t dcap1n1,Double_t dcap1n2,
721c0b8f	347	Double_t dcap2n1,Double_t dcap2n2,
c7d3975b	348	Bool_t &ok4Prong);
2ff20727	349	AliAODRecoCascadeHF* MakeCascade(TObjArray twoTrackArray,AliVEvent event,
	350	AliAODVertex *secVert,
	351	AliAODRecoDecayHF2Prong *rd2Prong,
	352	Double_t dca,
c7d3975b	353	Bool_t &okDstar);
a07ad8e0	354	AliAODRecoCascadeHF* MakeCascade(TObjArray twoTrackArray,AliVEvent event,
	355	AliAODVertex *secVert,
	356	AliAODv0 *v0,
	357	Double_t dca,
c7d3975b	358	Bool_t &okCascades);
dcb444c9	359
c4cdf105	360	AliAODVertex* PrimaryVertex(const TObjArray trkArray=0x0,AliVEvent event=0x0) const;
dcfa35b3	361	AliAODVertex* ReconstructSecondaryVertex(TObjArray *trkArray,Double_t &dispersion,Bool_t useTRefArray=kTRUE) const;
c7d3975b	362
fd0c688e	363	Bool_t SelectInvMassAndPt3prong(Double_t px,Double_t py,Double_t *pz, Int_t pidLcStatus=3);
c7d3975b	364	Bool_t SelectInvMassAndPt4prong(Double_t px,Double_t py,Double_t *pz);
	365	Bool_t SelectInvMassAndPtD0Kpi(Double_t px,Double_t py,Double_t *pz);
	366	Bool_t SelectInvMassAndPtJpsiee(Double_t px,Double_t py,Double_t *pz);
	367	Bool_t SelectInvMassAndPtDstarD0pi(Double_t px,Double_t py,Double_t *pz);
	368	Bool_t SelectInvMassAndPtCascade(Double_t px,Double_t py,Double_t *pz);
	369
	370	Bool_t SelectInvMassAndPt3prong(TObjArray *trkArray);
	371	Bool_t SelectInvMassAndPt4prong(TObjArray *trkArray);
	372	Bool_t SelectInvMassAndPtDstarD0pi(TObjArray *trkArray);
	373
e11ae259	374	void SelectTracksAndCopyVertex(const AliVEvent *event,Int_t trkEntries,
1992284a	375	TObjArray &seleTrksArray,
	376	TObjArray &tracksAtVertex,
	377	Int_t &nSeleTrks,
a25935a9	378	UChar_t seleFlags,Int_t evtNumber);
c3379416	379	void SetParametersAtVertex(AliESDtrack* esdt, const AliExternalTrackParam* extpar) const;
1992284a	380
c7d3975b	381	Bool_t SingleTrkCuts(AliESDtrack *trk,Float_t centralityperc, Bool_t &okDisplaced,Bool_t &okSoftPi, Bool_t &ok3prong) const;
a07ad8e0	382
c20e04a0	383	void SetSelectionBitForPID(AliRDHFCuts cuts,AliAODRecoDecayHF rd,Int_t bit);
939850df	384
a07ad8e0	385	AliAODv0* TransformESDv0toAODv0(AliESDv0 *esdv0,
	386	TObjArray *twoTrackArrayV0);
	387
6a213b59	388	//
30bd7ffa	389	ClassDef(AliAnalysisVertexingHF,24); // Reconstruction of HF decay candidates
6a213b59	390	};
	391
	392
	393	#endif
	394
	395
	396
	397
	398
	399
	400
	401