From 3244eeed363ff2c0d1d14c20f087a48b937676fc Mon Sep 17 00:00:00 2001 From: dainese Date: Thu, 3 May 2007 16:16:13 +0000 Subject: [PATCH] new classes for open heavy flavour decay candidates --- PWG3/AliAODRecoDecayHF.cxx | 127 +++++++++++++++++++ PWG3/AliAODRecoDecayHF.h | 79 ++++++++++++ PWG3/AliAODRecoDecayHF2Prong.cxx | 204 +++++++++++++++++++++++++++++++ PWG3/AliAODRecoDecayHF2Prong.h | 75 ++++++++++++ PWG3/AliAODRecoDecayHF3Prong.cxx | 175 ++++++++++++++++++++++++++ PWG3/AliAODRecoDecayHF3Prong.h | 72 +++++++++++ PWG3/AliAODRecoDecayHF4Prong.cxx | 180 +++++++++++++++++++++++++++ PWG3/AliAODRecoDecayHF4Prong.h | 73 +++++++++++ 8 files changed, 985 insertions(+) create mode 100644 PWG3/AliAODRecoDecayHF.cxx create mode 100644 PWG3/AliAODRecoDecayHF.h create mode 100644 PWG3/AliAODRecoDecayHF2Prong.cxx create mode 100644 PWG3/AliAODRecoDecayHF2Prong.h create mode 100644 PWG3/AliAODRecoDecayHF3Prong.cxx create mode 100644 PWG3/AliAODRecoDecayHF3Prong.h create mode 100644 PWG3/AliAODRecoDecayHF4Prong.cxx create mode 100644 PWG3/AliAODRecoDecayHF4Prong.h diff --git a/PWG3/AliAODRecoDecayHF.cxx b/PWG3/AliAODRecoDecayHF.cxx new file mode 100644 index 00000000000..4c27ac4159e --- /dev/null +++ b/PWG3/AliAODRecoDecayHF.cxx @@ -0,0 +1,127 @@ +/************************************************************************** + * Copyright(c) 1998-2006, 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. * + **************************************************************************/ + +///////////////////////////////////////////////////////////// +// +// Base class for AOD reconstructed heavy-flavour decay +// +// Author: A.Dainese, andrea.dainese@lnl.infn.it +///////////////////////////////////////////////////////////// + +#include +#include +#include "AliAODRecoDecay.h" +#include "AliAODRecoDecayHF.h" + +ClassImp(AliAODRecoDecayHF) + +//-------------------------------------------------------------------------- +AliAODRecoDecayHF::AliAODRecoDecayHF() : + AliAODRecoDecay(), + fOwnPrimaryVtx(0x0), + fd0err(0x0) +{ + // + // Default Constructor + // +} +//-------------------------------------------------------------------------- +AliAODRecoDecayHF::AliAODRecoDecayHF(AliAODVertex *vtx2,Int_t nprongs,Short_t charge, + Double_t *px,Double_t *py,Double_t *pz, + Double_t *d0,Double_t *d0err) : + AliAODRecoDecay(vtx2,nprongs,charge,px,py,pz,d0), + fOwnPrimaryVtx(0x0), + fd0err(0x0) +{ + // + // Constructor with AliAODVertex for decay vertex + // + fd0err = new Double_t[GetNProngs()]; + for(Int_t i=0; i0) { + fd0err = new Double_t[GetNProngs()]; + memcpy(fd0err,source.fd0err,GetNProngs()*sizeof(Double_t)); + } +} +//-------------------------------------------------------------------------- +AliAODRecoDecayHF &AliAODRecoDecayHF::operator=(const AliAODRecoDecayHF &source) +{ + // + // assignment operator + // + if(&source == this) return *this; + fOwnPrimaryVtx = source.fOwnPrimaryVtx; + fSecondaryVtx = source.fSecondaryVtx; + fNProngs = source.fNProngs; + fNDCA = source.fNDCA; + fNPID = source.fNPID; + fEventNumber = source.fEventNumber; + fRunNumber = source.fRunNumber; + if(source.GetNProngs()>0) { + fd0 = new Double_t[GetNProngs()]; + fd0err = new Double_t[GetNProngs()]; + memcpy(fd0,source.fd0,GetNProngs()*sizeof(Double_t)); + memcpy(fd0err,source.fd0err,GetNProngs()*sizeof(Double_t)); + if(source.fPx) { + fPx = new Double_t[GetNProngs()]; + fPy = new Double_t[GetNProngs()]; + fPz = new Double_t[GetNProngs()]; + memcpy(fPx,source.fPx,GetNProngs()*sizeof(Double_t)); + memcpy(fPy,source.fPy,GetNProngs()*sizeof(Double_t)); + memcpy(fPz,source.fPz,GetNProngs()*sizeof(Double_t)); + } + if(source.fPID) { + fPID = new Double_t[5*GetNProngs()]; + memcpy(fPID,source.fPID,GetNProngs()*sizeof(Double_t)); + } + if(source.fDCA) { + fDCA = new Float_t[GetNProngs()*(GetNProngs()-1)/2]; + memcpy(fDCA,source.fDCA,(GetNProngs()*(GetNProngs()-1)/2)*sizeof(Float_t)); + } + } + return *this; +} +//-------------------------------------------------------------------------- +AliAODRecoDecayHF::~AliAODRecoDecayHF() { + // + // Default Destructor + // + if(fOwnPrimaryVtx) delete fOwnPrimaryVtx; + if(fd0err) delete [] fd0err; +} +//--------------------------------------------------------------------------- diff --git a/PWG3/AliAODRecoDecayHF.h b/PWG3/AliAODRecoDecayHF.h new file mode 100644 index 00000000000..f9c05f64653 --- /dev/null +++ b/PWG3/AliAODRecoDecayHF.h @@ -0,0 +1,79 @@ +#ifndef ALIAODRECODECAYHF_H +#define ALIAODRECODECAYHF_H +/* Copyright(c) 1998-2006, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + +//*********************************************************** +// Class AliAODRecoDecayHF +// base class for AOD reconstructed heavy-flavour decays +// Author: A.Dainese, andrea.dainese@lnl.infn.it +//*********************************************************** + +#include "AliAODRecoDecay.h" + +class AliAODRecoDecayHF : public AliAODRecoDecay { + + public: + + AliAODRecoDecayHF(); + AliAODRecoDecayHF(AliAODVertex *vtx2,Int_t nprongs,Short_t charge, + Double_t *px,Double_t *py,Double_t *pz, + Double_t *d0,Double_t *d0err); + AliAODRecoDecayHF(AliAODVertex *vtx2,Int_t nprongs,Short_t charge, + Double_t *d0,Double_t *d0err); + virtual ~AliAODRecoDecayHF(); + + AliAODRecoDecayHF(const AliAODRecoDecayHF& source); + AliAODRecoDecayHF& operator=(const AliAODRecoDecayHF& source); + + + // primary vertex + void SetOwnPrimaryVtx(AliAODVertex *vtx2) {fOwnPrimaryVtx = vtx2;} + void CheckOwnPrimaryVtx() const + {if(!fOwnPrimaryVtx) printf("fOwnPrimaryVtx not set"); return;} + AliAODVertex* GetOwnPrimaryVtx() const {return fOwnPrimaryVtx;} + void GetOwnPrimaryVtx(Double_t vtx[3]) const + {CheckOwnPrimaryVtx();fOwnPrimaryVtx->GetPosition(vtx);} + + // kinematics & topology + Double_t DecayLength() const + {CheckOwnPrimaryVtx();return AliAODRecoDecay::DecayLength(fOwnPrimaryVtx);} + Double_t DecayLengthError() const + {CheckOwnPrimaryVtx();return AliAODRecoDecay::DecayLengthError(fOwnPrimaryVtx);} + Double_t NormalizedDecayLength() const + {CheckOwnPrimaryVtx();return AliAODRecoDecay::NormalizedDecayLength(fOwnPrimaryVtx);} + Double_t DecayLengthXY() const + {CheckOwnPrimaryVtx();return AliAODRecoDecay::DecayLengthXY(fOwnPrimaryVtx);} + Double_t DecayLengthXYError() const + {CheckOwnPrimaryVtx();return AliAODRecoDecay::DecayLengthXYError(fOwnPrimaryVtx);} + Double_t NormalizedDecayLengthXY() const + {CheckOwnPrimaryVtx();return AliAODRecoDecay::NormalizedDecayLengthXY(fOwnPrimaryVtx);} + Double_t Ct(UInt_t pdg) const + {CheckOwnPrimaryVtx();return AliAODRecoDecay::Ct(pdg,fOwnPrimaryVtx);} + Double_t CosPointingAngle() const + {CheckOwnPrimaryVtx();return AliAODRecoDecay::CosPointingAngle(fOwnPrimaryVtx);} + Double_t CosPointingAngleXY() const + {CheckOwnPrimaryVtx();return AliAODRecoDecay::CosPointingAngleXY(fOwnPrimaryVtx);} + Double_t ImpParXY() const + {CheckOwnPrimaryVtx();return AliAODRecoDecay::ImpParXY(fOwnPrimaryVtx);} + Double_t QtProngFlightLine(Int_t ip) const + {CheckOwnPrimaryVtx();return AliAODRecoDecay::QtProngFlightLine(ip,fOwnPrimaryVtx);} + Double_t QlProngFlightLine(Int_t ip) const + {CheckOwnPrimaryVtx();return AliAODRecoDecay::QlProngFlightLine(ip,fOwnPrimaryVtx);} + + // prongs + Double_t Getd0errProng(Int_t ip) const {return fd0err[ip];} + Double_t Normalizedd0Prong(Int_t ip) const + {return Getd0Prong(ip)/Getd0errProng(ip);} + + + protected: + + AliAODVertex *fOwnPrimaryVtx; // primary vertex for this candidate + Double_t *fd0err; //[fNProngs] error on prongs rphi impact param [cm] + + ClassDef(AliAODRecoDecayHF,1) // base class for AOD reconstructed + // heavy-flavour decays +}; + +#endif diff --git a/PWG3/AliAODRecoDecayHF2Prong.cxx b/PWG3/AliAODRecoDecayHF2Prong.cxx new file mode 100644 index 00000000000..799625ba581 --- /dev/null +++ b/PWG3/AliAODRecoDecayHF2Prong.cxx @@ -0,0 +1,204 @@ +/************************************************************************** + * Copyright(c) 1998-2006, 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. * + **************************************************************************/ + +///////////////////////////////////////////////////////////// +// +// Base class for AOD reconstructed heavy-flavour 2-prong decay +// +// Author: A.Dainese, andrea.dainese@lnl.infn.it +///////////////////////////////////////////////////////////// + +#include +#include "AliAODRecoDecayHF.h" +#include "AliAODRecoDecayHF2Prong.h" + +ClassImp(AliAODRecoDecayHF2Prong) + +//-------------------------------------------------------------------------- +AliAODRecoDecayHF2Prong::AliAODRecoDecayHF2Prong() : + AliAODRecoDecayHF() +{ + // + // Default Constructor + // +} +//-------------------------------------------------------------------------- +AliAODRecoDecayHF2Prong::AliAODRecoDecayHF2Prong(AliAODVertex *vtx2, + Double_t *px,Double_t *py,Double_t *pz, + Double_t *d0,Double_t *d0err,Float_t dca) : + AliAODRecoDecayHF(vtx2,2,0,px,py,pz,d0,d0err) +{ + // + // Constructor with AliAODVertex for decay vertex + // + SetDCA(dca); +} +//-------------------------------------------------------------------------- +AliAODRecoDecayHF2Prong::AliAODRecoDecayHF2Prong(AliAODVertex *vtx2, + Double_t *d0,Double_t *d0err,Float_t dca) : + AliAODRecoDecayHF(vtx2,2,0,d0,d0err) +{ + // + // Constructor with AliAODVertex for decay vertex and without prongs momenta + // + SetDCA(dca); +} +//-------------------------------------------------------------------------- +AliAODRecoDecayHF2Prong::AliAODRecoDecayHF2Prong(const AliAODRecoDecayHF2Prong &source) : + AliAODRecoDecayHF(source) +{ + // + // Copy constructor + // +} +//-------------------------------------------------------------------------- +AliAODRecoDecayHF2Prong &AliAODRecoDecayHF2Prong::operator=(const AliAODRecoDecayHF2Prong &source) +{ + // + // assignment operator + // + if(&source == this) return *this; + fOwnPrimaryVtx = source.fOwnPrimaryVtx; + fSecondaryVtx = source.fSecondaryVtx; + fCharge = source.fCharge; + fNProngs = source.fNProngs; + fNDCA = source.fNDCA; + fNPID = source.fNPID; + fEventNumber = source.fEventNumber; + fRunNumber = source.fRunNumber; + if(source.GetNProngs()>0) { + fd0 = new Double_t[GetNProngs()]; + fd0err = new Double_t[GetNProngs()]; + memcpy(fd0,source.fd0,GetNProngs()*sizeof(Double_t)); + memcpy(fd0err,source.fd0err,GetNProngs()*sizeof(Double_t)); + if(source.fPx) { + fPx = new Double_t[GetNProngs()]; + fPy = new Double_t[GetNProngs()]; + fPz = new Double_t[GetNProngs()]; + memcpy(fPx,source.fPx,GetNProngs()*sizeof(Double_t)); + memcpy(fPy,source.fPy,GetNProngs()*sizeof(Double_t)); + memcpy(fPz,source.fPz,GetNProngs()*sizeof(Double_t)); + } + if(source.fPID) { + fPID = new Double_t[5*GetNProngs()]; + memcpy(fPID,source.fPID,GetNProngs()*sizeof(Double_t)); + } + if(source.fDCA) { + fDCA = new Float_t[GetNProngs()*(GetNProngs()-1)/2]; + memcpy(fDCA,source.fDCA,(GetNProngs()*(GetNProngs()-1)/2)*sizeof(Float_t)); + } + } + return *this; +} +//-------------------------------------------------------------------------- +Bool_t AliAODRecoDecayHF2Prong::SelectD0(const Double_t *cuts,Int_t &okD0,Int_t &okD0bar) + const { +// +// This function compares the D0 with a set of cuts: +// +// cuts[0] = inv. mass half width [GeV] +// cuts[1] = dca [cm] +// cuts[2] = cosThetaStar +// cuts[3] = pTK [GeV/c] +// cuts[4] = pTPi [GeV/c] +// cuts[5] = d0K [cm] upper limit! +// cuts[6] = d0Pi [cm] upper limit! +// cuts[7] = d0d0 [cm^2] +// cuts[8] = cosThetaPoint +// +// If the D0/D0bar doesn't pass the cuts it sets the weights to 0 +// If neither D0 nor D0bar pass the cuts return kFALSE +// + Double_t mD0,mD0bar,ctsD0,ctsD0bar; + okD0=1; okD0bar=1; + + Double_t mD0PDG = TDatabasePDG::Instance()->GetParticle(421)->Mass(); + + if(PtProng(1) < cuts[3] || PtProng(0) < cuts[4]) okD0 = 0; + if(PtProng(0) < cuts[3] || PtProng(1) < cuts[4]) okD0bar = 0; + if(!okD0 && !okD0bar) return kFALSE; + + if(TMath::Abs(Getd0Prong(1)) > cuts[5] || + TMath::Abs(Getd0Prong(0)) > cuts[6]) okD0 = 0; + if(TMath::Abs(Getd0Prong(0)) > cuts[6] || + TMath::Abs(Getd0Prong(1)) > cuts[5]) okD0bar = 0; + if(!okD0 && !okD0bar) return kFALSE; + + if(GetDCA() > cuts[1]) { okD0 = okD0bar = 0; return kFALSE; } + + InvMassD0(mD0,mD0bar); + if(TMath::Abs(mD0-mD0PDG) > cuts[0]) okD0 = 0; + if(TMath::Abs(mD0bar-mD0PDG) > cuts[0]) okD0bar = 0; + if(!okD0 && !okD0bar) return kFALSE; + + CosThetaStarD0(ctsD0,ctsD0bar); + if(TMath::Abs(ctsD0) > cuts[2]) okD0 = 0; + if(TMath::Abs(ctsD0bar) > cuts[2]) okD0bar = 0; + if(!okD0 && !okD0bar) return kFALSE; + + if(Prodd0d0() > cuts[7]) { okD0 = okD0bar = 0; return kFALSE; } + + if(CosPointingAngle() < cuts[8]) { okD0 = okD0bar = 0; return kFALSE; } + + return kTRUE; +} +//----------------------------------------------------------------------------- +Bool_t AliAODRecoDecayHF2Prong::SelectBtoJPSI(const Double_t *cuts,Int_t &okB) + const { +// +// This function compares the Secondary JPSI candidates with a set of cuts: +// +// cuts[0] = inv. mass half width [GeV] +// cuts[1] = dca [cm] +// cuts[2] = cosThetaStar (negative electron) +// cuts[3] = pTP [GeV/c] +// cuts[4] = pTN [GeV/c] +// cuts[5] = d0P [cm] upper limit! +// cuts[6] = d0N [cm] upper limit! +// cuts[7] = d0d0 [cm^2] +// cuts[8] = cosThetaPoint +// +// If the candidate doesn't pass the cuts it sets the weight to 0 +// and return kFALSE +// + Double_t mJPsi,ctsJPsi; + okB=1; + + Double_t mJPSIPDG = TDatabasePDG::Instance()->GetParticle(443)->Mass(); + + if(PtProng(1) < cuts[3] || PtProng(0) < cuts[4]) okB = 0; + if(!okB) return kFALSE; + + if(TMath::Abs(Getd0Prong(1)) > cuts[5] || + TMath::Abs(Getd0Prong(0)) > cuts[6]) okB = 0; + if(!okB) return kFALSE; + + if(GetDCA() > cuts[1]) { okB = 0; return kFALSE; } + + mJPsi=InvMassJPSIee(); + if(TMath::Abs(mJPsi-mJPSIPDG) > cuts[0]) okB = 0; + if(!okB) return kFALSE; + + ctsJPsi=CosThetaStarJPSI(); + if(TMath::Abs(ctsJPsi) > cuts[2]) okB = 0; + if(!okB) return kFALSE; + + if(Prodd0d0() > cuts[7]) { okB = 0; return kFALSE; } + + if(CosPointingAngle() < cuts[8]) { okB = 0; return kFALSE; } + + return kTRUE; +} +//----------------------------------------------------------------------------- diff --git a/PWG3/AliAODRecoDecayHF2Prong.h b/PWG3/AliAODRecoDecayHF2Prong.h new file mode 100644 index 00000000000..60d556a3a7e --- /dev/null +++ b/PWG3/AliAODRecoDecayHF2Prong.h @@ -0,0 +1,75 @@ +#ifndef ALIAODRECODECAYHF2PRONG_H +#define ALIAODRECODECAYHF2PRONG_H +/* Copyright(c) 1998-2006, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + +//*********************************************************** +// Class AliAODRecoDecayHF2Prong +// base class for AOD reconstructed 2-prong heavy-flavour decays +// (D0->Kpi, J/psi->ee, ...) +// Author: A.Dainese, andrea.dainese@lnl.infn.it +// G.E.Bruno, giuseppe.bruno@ba.infn.it +//*********************************************************** + +#include "AliAODRecoDecay.h" +#include "AliAODRecoDecayHF.h" + +class AliAODRecoDecayHF2Prong : public AliAODRecoDecayHF { + + public: + + AliAODRecoDecayHF2Prong(); + AliAODRecoDecayHF2Prong(AliAODVertex *vtx2, + Double_t *px,Double_t *py,Double_t *pz, + Double_t *d0,Double_t *d0err,Float_t dca); + AliAODRecoDecayHF2Prong(AliAODVertex *vtx2, + Double_t *d0,Double_t *d0err,Float_t dca); + AliAODRecoDecayHF2Prong(const AliAODRecoDecayHF2Prong& source); + AliAODRecoDecayHF2Prong& operator=(const AliAODRecoDecayHF2Prong& source); + + virtual ~AliAODRecoDecayHF2Prong() {} + + Double_t Prodd0d0() const {return AliAODRecoDecay::Prodd0d0(0,1);} + + // D0->Kpi + Double_t ED0() const {return E(421);} + Double_t YD0() const {return Y(421);} + + Double_t CtD0() const {return Ct(421);} + Double_t CtD0(Double_t point[3]) const {return AliAODRecoDecay::Ct(421,point);} + Double_t CtD0(AliAODVertex *vtx1) const {return AliAODRecoDecay::Ct(421,vtx1);} + + Double_t CosThetaStarD0() const {return CosThetaStar(1,421,211,321);} // angle of K + Double_t CosThetaStarD0bar() const {return CosThetaStar(0,421,321,211);} // angle of K + void CosThetaStarD0(Double_t &ctsD0,Double_t &ctsD0bar) const + {ctsD0=CosThetaStarD0();ctsD0bar=CosThetaStarD0bar();return;} + + Double_t InvMassD0() const {UInt_t pdg[2]={211,321};return InvMass(2,pdg);} + Double_t InvMassD0bar() const {UInt_t pdg[2]={321,211};return InvMass(2,pdg);} + void InvMassD0(Double_t &mD0,Double_t &mD0bar) const + {mD0=InvMassD0();mD0bar=InvMassD0bar();return;} + + Bool_t SelectD0(const Double_t* cuts,Int_t &okD0,Int_t &okD0bar) const; + + // Jpsi (from B) -> ee + Double_t EJPSI() const {return E(443);} + Double_t YJPSI() const {return Y(443);} + + Double_t CtJPSI() const {return Ct(443);} + Double_t CtJPSI(Double_t point[3]) const {return AliAODRecoDecay::Ct(443,point);} + Double_t CtJPSI(AliAODVertex *vtx1) const {return AliAODRecoDecay::Ct(443,vtx1);} + + Double_t CosThetaStarJPSI() const {return CosThetaStar(1,443,11,11);} // angle of e- + + Double_t InvMassJPSIee() const {UInt_t pdg[2]={11,11};return InvMass(2,pdg);} + + Bool_t SelectBtoJPSI(const Double_t* cuts,Int_t &okB) const; + + + private: + + ClassDef(AliAODRecoDecayHF2Prong,1) // base class for AOD reconstructed + // heavy-flavour 2-prong decays +}; + +#endif diff --git a/PWG3/AliAODRecoDecayHF3Prong.cxx b/PWG3/AliAODRecoDecayHF3Prong.cxx new file mode 100644 index 00000000000..67f54f1da4a --- /dev/null +++ b/PWG3/AliAODRecoDecayHF3Prong.cxx @@ -0,0 +1,175 @@ +/************************************************************************** + * Copyright(c) 1998-2006, 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. * + **************************************************************************/ + +///////////////////////////////////////////////////////////// +// +// Base class for AOD reconstructed heavy-flavour 3-prong decay +// +// Author: E.Bruna bruna@to.infn.it, F.Prino prino@to.infn.it +///////////////////////////////////////////////////////////// + +#include +#include "AliAODRecoDecayHF.h" +#include "AliAODRecoDecayHF3Prong.h" + +ClassImp(AliAODRecoDecayHF3Prong) + +//-------------------------------------------------------------------------- +AliAODRecoDecayHF3Prong::AliAODRecoDecayHF3Prong() : + AliAODRecoDecayHF(), + fSigmaVert(0), + fDist12toPrim(0), + fDist23toPrim(0) +{ + // + // Default Constructor + // +} +//-------------------------------------------------------------------------- +AliAODRecoDecayHF3Prong::AliAODRecoDecayHF3Prong(AliAODVertex *vtx2, + Double_t *px,Double_t *py,Double_t *pz, + Double_t *d0,Double_t *d0err, + Double_t *dca, Double_t sigvert, + Double_t dist12,Double_t dist23,Short_t charge) : + AliAODRecoDecayHF(vtx2,3,charge,px,py,pz,d0,d0err), + fSigmaVert(sigvert), + fDist12toPrim(dist12), + fDist23toPrim(dist23) +{ + // + // Constructor with AliAODVertex for decay vertex + // + Float_t dcafloat[3]; + for(Int_t i=0;i<3;i++)dcafloat[i]=dca[i]; + SetDCAs(3,dcafloat); +} +//-------------------------------------------------------------------------- +AliAODRecoDecayHF3Prong::AliAODRecoDecayHF3Prong(AliAODVertex *vtx2, + Double_t *d0,Double_t *d0err, + Double_t *dca, Double_t sigvert, + Double_t dist12,Double_t dist23, Short_t charge) : + AliAODRecoDecayHF(vtx2,3,charge,d0,d0err), + fSigmaVert(sigvert), + fDist12toPrim(dist12), + fDist23toPrim(dist23) +{ + // + // Constructor with AliAODVertex for decay vertex and without prongs momenta + // + Float_t dcafloat[3]; + for(Int_t i=0;i<3;i++)dcafloat[i]=dca[i]; + SetDCAs(3,dcafloat); +} +//-------------------------------------------------------------------------- +AliAODRecoDecayHF3Prong::AliAODRecoDecayHF3Prong(const AliAODRecoDecayHF3Prong &source) : + AliAODRecoDecayHF(source), + fSigmaVert(source.fSigmaVert), + fDist12toPrim(source.fDist12toPrim), + fDist23toPrim(source.fDist23toPrim) +{ + // + // Copy constructor + // +} +//-------------------------------------------------------------------------- +AliAODRecoDecayHF3Prong &AliAODRecoDecayHF3Prong::operator=(const AliAODRecoDecayHF3Prong &source) +{ + // + // assignment operator + // + if(&source == this) return *this; + fOwnPrimaryVtx = source.fOwnPrimaryVtx; + fSecondaryVtx = source.fSecondaryVtx; + fCharge = source.fCharge; + fNProngs = source.fNProngs; + fNDCA = source.fNDCA; + fNPID = source.fNPID; + fEventNumber = source.fEventNumber; + fRunNumber = source.fRunNumber; + fDist12toPrim= source.fDist12toPrim; + fDist23toPrim= source.fDist23toPrim; + fSigmaVert= source.fSigmaVert; + if(source.GetNProngs()>0) { + fd0 = new Double_t[GetNProngs()]; + fd0err = new Double_t[GetNProngs()]; + memcpy(fd0,source.fd0,GetNProngs()*sizeof(Double_t)); + memcpy(fd0err,source.fd0err,GetNProngs()*sizeof(Double_t)); + if(source.fPx) { + fPx = new Double_t[GetNProngs()]; + fPy = new Double_t[GetNProngs()]; + fPz = new Double_t[GetNProngs()]; + memcpy(fPx,source.fPx,GetNProngs()*sizeof(Double_t)); + memcpy(fPy,source.fPy,GetNProngs()*sizeof(Double_t)); + memcpy(fPz,source.fPz,GetNProngs()*sizeof(Double_t)); + } + if(source.fPID) { + fPID = new Double_t[5*GetNProngs()]; + memcpy(fPID,source.fPID,GetNProngs()*sizeof(Double_t)); + } + if(source.fDCA) { + fDCA = new Float_t[GetNProngs()*(GetNProngs()-1)/2]; + memcpy(fDCA,source.fDCA,(GetNProngs()*(GetNProngs()-1)/2)*sizeof(Float_t)); + } + } + return *this; +} +//-------------------------------------------------------------------------- +Bool_t AliAODRecoDecayHF3Prong::SelectDplus(const Double_t *cuts) + const { +// +// This function compares the Dplus with a set of cuts: +// +// cuts[0] = inv. mass half width [GeV] +// cuts[1] = pTK [GeV/c] +// cuts[2] = pTPi [GeV/c] +// cuts[3] = d0K [cm] lower limit! +// cuts[4] = d0Pi [cm] lower limit! +// cuts[5] = dist12 (cm) +// cuts[6] = sigmavert (cm) +// cuts[7] = dist prim-sec (cm) +// cuts[8] = pM=Max{pT1,pT2,pT3} (GeV/c) +// cuts[9] = cosThetaPoint +// cuts[10] = Sum d0^2 (cm^2) +// cuts[11] = dca cut (cm) +// +// If candidate Dplus does not pass the cuts return kFALSE +// + + Double_t mDplusPDG = TDatabasePDG::Instance()->GetParticle(411)->Mass(); + Double_t mDplus=InvMassDplus(); + if(TMath::Abs(mDplus-mDplusPDG)>cuts[0])return kFALSE; + //single track + if(TMath::Abs(PtProng(1)) < cuts[1] || TMath::Abs(Getd0Prong(1))0 && GetDCA(i)>cuts[11])return kFALSE; + + //2track cuts + if(fDist12toPrimcuts[6])return kFALSE; + + if(DecayLength()Kpipi, Ds->KKpi ...) +// Author: E.Bruna bruna@to.infn.it, F.Prino prino@to.infn.it +//*********************************************************** + +#include "AliAODRecoDecay.h" +#include "AliAODRecoDecayHF.h" + +class AliAODRecoDecayHF3Prong : public AliAODRecoDecayHF { + + public: + + AliAODRecoDecayHF3Prong(); + AliAODRecoDecayHF3Prong(AliAODVertex *vtx2, + Double_t *px,Double_t *py,Double_t *pz, + Double_t *d0,Double_t *d0err, + Double_t *dca, Double_t sigvert, + Double_t dist12,Double_t dist23,Short_t charge); + AliAODRecoDecayHF3Prong(AliAODVertex *vtx2, + Double_t *d0,Double_t *d0err, + Double_t *dca, Double_t sigvert, + Double_t dist12,Double_t dist23, Short_t charge); + + AliAODRecoDecayHF3Prong(const AliAODRecoDecayHF3Prong& source); + AliAODRecoDecayHF3Prong& operator=(const AliAODRecoDecayHF3Prong& source); + + virtual ~AliAODRecoDecayHF3Prong() {} + + void GetDCAs(Float_t dca[3]) const + {for(Int_t i=0;i<3;i++) dca[i]=GetDCA(i);} + + + // D+->Kpipi + Double_t EDplus() const {return E(411);} + Double_t YDplus() const {return Y(411);} + Double_t CtDplus() const {return Ct(411);} + Double_t CtDplus(Double_t point[3]) const {return AliAODRecoDecay::Ct(411,point);} + Double_t CtDplus(AliAODVertex *vtx1) const {return AliAODRecoDecay::Ct(411,vtx1);} + Double_t InvMassDplus() const {UInt_t pdg[3]={211,321,211};return InvMass(3,pdg);} + Bool_t SelectDplus(const Double_t* cuts) const; + + // Ds+->KKpi + Double_t EDs() const {return E(431);} + Double_t YDs() const {return Y(431);} + Double_t CtDs() const {return Ct(431);} + Double_t CtDs(Double_t point[3]) const {return AliAODRecoDecay::Ct(431,point);} + Double_t CtDs(AliAODVertex *vtx1) const {return AliAODRecoDecay::Ct(431,vtx1);} + Double_t InvMassDsKKpi() const {UInt_t pdg[3]={321,321,211};return InvMass(3,pdg);} + Double_t InvMassDspiKK() const {UInt_t pdg[3]={211,321,321};return InvMass(3,pdg);} + Bool_t SelectDs(const Double_t* cuts,Int_t &okDsKKpi,Int_t &okDspiKK) + const;//to be implemented + + private: + + Double_t fSigmaVert; // track dispersion around the secondary vertex + Double_t fDist12toPrim; //distance prim vert - 2 opposite sign track vertex + Double_t fDist23toPrim; //distance prim vert - 2 opposite sign track vertex + + + + ClassDef(AliAODRecoDecayHF3Prong,1) // base class for AOD reconstructed + // heavy-flavour 3-prong decays +}; + +#endif diff --git a/PWG3/AliAODRecoDecayHF4Prong.cxx b/PWG3/AliAODRecoDecayHF4Prong.cxx new file mode 100644 index 00000000000..11e6261c269 --- /dev/null +++ b/PWG3/AliAODRecoDecayHF4Prong.cxx @@ -0,0 +1,180 @@ +/************************************************************************** + * Copyright(c) 1998-2006, 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. * + **************************************************************************/ + +///////////////////////////////////////////////////////////// +// +// Base class for AOD reconstructed heavy-flavour 4-prong decay +// +// Authors: G.E.Bruno Giuseppe.Bruno@to.infn.it, R.Romita Rossella.Romita@ba.infn.it +///////////////////////////////////////////////////////////// + +#include +#include "AliAODRecoDecayHF.h" +#include "AliAODRecoDecayHF4Prong.h" +#include "TRandom.h" // for the time being + +ClassImp(AliAODRecoDecayHF4Prong) + +//-------------------------------------------------------------------------- +AliAODRecoDecayHF4Prong::AliAODRecoDecayHF4Prong() : + AliAODRecoDecayHF(), + //fSigmaVert(0), + fDist12toPrim(0), + fDist23toPrim(0), + fDist14toPrim(0), + fDist34toPrim(0) +{ + // + // Default Constructor + // +} +//-------------------------------------------------------------------------- +AliAODRecoDecayHF4Prong::AliAODRecoDecayHF4Prong(AliAODVertex *vtx2, + Double_t *px,Double_t *py,Double_t *pz, + Double_t *d0,Double_t *d0err, + Double_t *dca, //Double_t sigvert, + Double_t dist12,Double_t dist23, + Double_t dist14,Double_t dist34, + Short_t charge) : + AliAODRecoDecayHF(vtx2,4,charge,px,py,pz,d0,d0err), + // fSigmaVert(sigvert), + fDist12toPrim(dist12), + fDist23toPrim(dist23), + fDist14toPrim(dist14), + fDist34toPrim(dist34) +{ + // + // Constructor with AliAODVertex for decay vertex + // + Float_t dcafloat[6]; + for(Int_t i=0;i<6;i++) dcafloat[i]=dca[i]; + SetDCAs(6,dcafloat); +} +//-------------------------------------------------------------------------- +AliAODRecoDecayHF4Prong::AliAODRecoDecayHF4Prong(AliAODVertex *vtx2, + Double_t *d0,Double_t *d0err, + Double_t *dca, //Double_t sigvert, + Double_t dist12,Double_t dist23, + Double_t dist14,Double_t dist34, + Short_t charge) : + AliAODRecoDecayHF(vtx2,4,charge,d0,d0err), + //fSigmaVert(sigvert), + fDist12toPrim(dist12), + fDist23toPrim(dist23), + fDist14toPrim(dist14), + fDist34toPrim(dist34) +{ + // + // Constructor with AliAODVertex for decay vertex and without prongs momenta + // + Float_t dcafloat[6]; + for(Int_t i=0;i<6;i++) dcafloat[i]=dca[i]; + SetDCAs(6,dcafloat); +} +//-------------------------------------------------------------------------- +AliAODRecoDecayHF4Prong::AliAODRecoDecayHF4Prong(const AliAODRecoDecayHF4Prong &source) : + AliAODRecoDecayHF(source), + //fSigmaVert(source.fSigmaVert), + fDist12toPrim(source.fDist12toPrim), + fDist23toPrim(source.fDist23toPrim), + fDist14toPrim(source.fDist14toPrim), + fDist34toPrim(source.fDist34toPrim) +{ + // + // Copy constructor + // +} +//-------------------------------------------------------------------------- +AliAODRecoDecayHF4Prong &AliAODRecoDecayHF4Prong::operator=(const AliAODRecoDecayHF4Prong &source) +{ + // + // assignment operator + // + if(&source == this) return *this; + fOwnPrimaryVtx = source.fOwnPrimaryVtx; + fSecondaryVtx = source.fSecondaryVtx; + fCharge = source.fCharge; + fNProngs = source.fNProngs; + fNDCA = source.fNDCA; + fNPID = source.fNPID; + fEventNumber = source.fEventNumber; + fRunNumber = source.fRunNumber; + fDist12toPrim= source.fDist12toPrim; + fDist23toPrim= source.fDist23toPrim; + fDist14toPrim= source.fDist14toPrim; + fDist34toPrim= source.fDist34toPrim; + //fSigmaVert= source.fSigmaVert; + if(source.GetNProngs()>0) { + fd0 = new Double_t[GetNProngs()]; + fd0err = new Double_t[GetNProngs()]; + memcpy(fd0,source.fd0,GetNProngs()*sizeof(Double_t)); + memcpy(fd0err,source.fd0err,GetNProngs()*sizeof(Double_t)); + if(source.fPx) { + fPx = new Double_t[GetNProngs()]; + fPy = new Double_t[GetNProngs()]; + fPz = new Double_t[GetNProngs()]; + memcpy(fPx,source.fPx,GetNProngs()*sizeof(Double_t)); + memcpy(fPy,source.fPy,GetNProngs()*sizeof(Double_t)); + memcpy(fPz,source.fPz,GetNProngs()*sizeof(Double_t)); + } + if(source.fPID) { + fPID = new Double_t[5*GetNProngs()]; + memcpy(fPID,source.fPID,GetNProngs()*sizeof(Double_t)); + } + if(source.fDCA) { + fDCA = new Float_t[GetNProngs()*(GetNProngs()-1)/2]; + memcpy(fDCA,source.fDCA,(GetNProngs()*(GetNProngs()-1)/2)*sizeof(Float_t)); + } + } + return *this; +} +//-------------------------------------------------------------------------- +Bool_t AliAODRecoDecayHF4Prong::SelectD0(const Double_t *cuts,Int_t &okD0,Int_t &okD0bar) + const { +// +// This function compares the D0 with a set of cuts: +// +// to be implemented +// +// cuts[1] = ... +// cuts[2] = ... +// cuts[3] = ... +// cuts[4] = ... +// +// If candidate D0 does not pass the cuts return kFALSE +// + + Double_t mD0PDG = TDatabasePDG::Instance()->GetParticle(421)->Mass(); + Double_t mD0=InvMassD0(); + if(TMath::Abs(mD0-mD0PDG)>cuts[0]) return kFALSE; + + //single track + //if(TMath::Abs(PtProng(2)) < cuts[2] || TMath::Abs(Getd0Prong(2))0 && GetDCA(i)>cuts[11])return kFALSE; + + //2track cuts + //if(fDist12toPrimcuts[6])return kFALSE; + + //if(DecayLength()Kpipipi, etc...) +// Authors: G.E.Bruno Giuseppe.Bruno@ba.infn.it, R.Romita Rossella.Romita@ba.infn.it +//*********************************************************** + +#include "AliAODRecoDecay.h" +#include "AliAODRecoDecayHF.h" + +class AliAODRecoDecayHF4Prong : public AliAODRecoDecayHF { + + public: + + AliAODRecoDecayHF4Prong(); + AliAODRecoDecayHF4Prong(AliAODVertex *vtx2, + Double_t *px,Double_t *py,Double_t *pz, + Double_t *d0,Double_t *d0err, + Double_t *dca, //Double_t sigvert, + Double_t dist12,Double_t dist23, + Double_t dist14,Double_t dist34, + Short_t charge); + AliAODRecoDecayHF4Prong(AliAODVertex *vtx2, + Double_t *d0,Double_t *d0err, + Double_t *dca, //Double_t sigvert, + Double_t dist12,Double_t dist23, + Double_t dist14,Double_t dist34, + Short_t charge); + + AliAODRecoDecayHF4Prong(const AliAODRecoDecayHF4Prong& source); + AliAODRecoDecayHF4Prong& operator=(const AliAODRecoDecayHF4Prong& source); + + virtual ~AliAODRecoDecayHF4Prong() {} + + void GetDCAs(Float_t dca[6]) const + {for(Int_t i=0;i<6;i++) dca[i]=GetDCA(i);} // convention:fDCA[0]=p0p1,fDCA[1]=p0p2,fDCA[2]=p0p3,fDCA[3]=p1p2... + + + // D0->pi+K- pipi and D0bar->K+pi- pipi (in the order given) + Double_t ED0() const {return E(421);} + Double_t YD0() const {return Y(421);} + Double_t CtD0() const {return Ct(421);} + Double_t CtD0(Double_t point[3]) const {return AliAODRecoDecay::Ct(421,point);} + Double_t CtD0(AliAODVertex *vtx1) const {return AliAODRecoDecay::Ct(421,vtx1);} + Double_t InvMassRho() const {return InvMass2Prongs(2,3,211,211);} + Double_t InvMassD0() const {UInt_t pdg[4]={211,321,211,211};return InvMass(4,pdg);} + Double_t InvMassD0bar() const {UInt_t pdg[4]={321,211,211,211};return InvMass(4,pdg);} + void InvMassD0(Double_t &mD0,Double_t &mD0bar) const + {mD0=InvMassD0();mD0bar=InvMassD0bar();return;} + + + Bool_t SelectD0(const Double_t* cuts,Int_t &okD0,Int_t &okD0bar) const; + + + private: + + //Double_t fSigmaVert; // track dispersion around the secondary vertex + Double_t fDist12toPrim; //distance prim vert - 2 opposite sign track vertex + Double_t fDist23toPrim; //distance prim vert - 2 opposite sign track vertex + Double_t fDist14toPrim; //distance prim vert - 2 opposite sign track vertex + Double_t fDist34toPrim; //distance prim vert - 2 opposite sign track vertex + //Double_t fDist123toPrim; //distance + + ClassDef(AliAODRecoDecayHF4Prong,1) // base class for AOD reconstructed + // heavy-flavour 3-prong decays +}; + +#endif -- 2.43.0