From c028b974d1b31bf2058cd020d5827f6abf6317c5 Mon Sep 17 00:00:00 2001 From: hristov Date: Fri, 7 Jul 2006 15:26:13 +0000 Subject: [PATCH] Updated version of the V0 and cascade classes (Boris, Renaud) --- ANALYSIS/ANALYSISLinkDef.h | 2 + ANALYSIS/AliAODevent.cxx | 108 ++++++++++++++++ ANALYSIS/AliAODevent.h | 51 ++++++++ ANALYSIS/AliAODv0.cxx | 113 +++++++++++++++-- ANALYSIS/AliAODv0.h | 76 +++++++++--- ANALYSIS/AliAODxi.cxx | 174 ++++++++++++++++++++++++++ ANALYSIS/AliAODxi.h | 230 +++++++++++++++++++++++++++++++++++ ANALYSIS/libANALYSIS.pkg | 4 +- STEER/AliCascadeVertexer.cxx | 81 ++++++------ STEER/AliESD.cxx | 42 +++++++ STEER/AliESD.h | 1 + STEER/AliESDcascade.cxx | 160 +++++++++++++++--------- STEER/AliESDcascade.h | 61 +++++----- STEER/AliESDv0.cxx | 89 +++++++++++++- STEER/AliESDv0.h | 44 ++++--- STEER/AliV0vertexer.cxx | 21 +--- 16 files changed, 1065 insertions(+), 192 deletions(-) create mode 100644 ANALYSIS/AliAODevent.cxx create mode 100644 ANALYSIS/AliAODevent.h create mode 100644 ANALYSIS/AliAODxi.cxx create mode 100644 ANALYSIS/AliAODxi.h diff --git a/ANALYSIS/ANALYSISLinkDef.h b/ANALYSIS/ANALYSISLinkDef.h index 2359005f8d3..65703105e6a 100644 --- a/ANALYSIS/ANALYSISLinkDef.h +++ b/ANALYSIS/ANALYSISLinkDef.h @@ -91,7 +91,9 @@ #pragma link C++ class AliAODOrPairCut+; #pragma link C++ class AliAODAndPairCut+; +#pragma link C++ class AliAODevent+; #pragma link C++ class AliAODv0+; +#pragma link C++ class AliAODxi+; #pragma link C++ class AliAnalysisEventCuts+; #pragma link C++ class AliAnalysisTrackCuts+; diff --git a/ANALYSIS/AliAODevent.cxx b/ANALYSIS/AliAODevent.cxx new file mode 100644 index 00000000000..be79ea1f9bd --- /dev/null +++ b/ANALYSIS/AliAODevent.cxx @@ -0,0 +1,108 @@ +/************************************************************************** + * Copyright(c) 1998-1999, 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. * + **************************************************************************/ + +//------------------------------------------------------------------------- +// Implementation of the Analysis Oriented Data (AOD) event summary +// Purpose : container of event important information for soft analysis +// Author : Renaud Vernet, IPHC, Strasbourg +//------------------------------------------------------------------------- + +#include "AliAODevent.h" +#include "AliESDVertex.h" +#include "AliESD.h" +#include "AliAODv0.h" +#include "AliAODxi.h" + +ClassImp(AliAODevent); + +AliAODevent::AliAODevent() { + fV0s = new TClonesArray("AliAODv0"); + fCascades = new TClonesArray("AliAODxi"); +} + +AliAODevent::~AliAODevent() { + delete fV0s; +} + +AliAODevent::AliAODevent(AliESD* e) { + fV0s = new TClonesArray("AliAODv0"); + fCascades = new TClonesArray("AliAODxi"); + fRunNumber = (UInt_t)e->GetRunNumber(); + fEventNumber = (UInt_t)e->GetEventNumber(); + fNumberOfTracks = (UInt_t)e->GetNumberOfTracks(); + + const AliESDVertex* V = e->GetVertex(); + fPrimVertexX = V->GetXv(); + fPrimVertexY = V->GetYv(); + fPrimVertexZ = V->GetZv(); + + for (Int_t i=0; iGetNumberOfV0s(); i++) { + AliAODv0* v=new AliAODv0(e->GetV0(i),e); + this->AddV0(v); + delete v; + } + + for (Int_t i=0; iGetNumberOfCascades(); i++) { + AliAODxi* c=new AliAODxi(e->GetCascade(i),e); + this->AddCascade(c); + delete c; + } +} + +AliAODevent::AliAODevent(const AliAODevent& aod) : + TObject(aod), + fV0s((TClonesArray*)aod.fV0s->Clone()), + fCascades((TClonesArray*)aod.fCascades->Clone()), + fPrimVertexX(aod.fPrimVertexX), + fPrimVertexY(aod.fPrimVertexY), + fPrimVertexZ(aod.fPrimVertexZ), + fRunNumber(aod.fRunNumber), + fEventNumber(aod.fEventNumber), + fNumberOfTracks(aod.fNumberOfTracks) +{ + //copy constructor +} + + +AliAODevent& AliAODevent::operator=(const AliAODevent& aod){ + // assignment operator + if(this!=&aod) { + fPrimVertexX = aod.fPrimVertexX; + fPrimVertexY = aod.fPrimVertexY; + fPrimVertexZ = aod.fPrimVertexZ; + fRunNumber = aod.fRunNumber; + fEventNumber = aod.fEventNumber; + fNumberOfTracks = aod.fNumberOfTracks; + + delete fV0s; + delete fCascades; + fV0s=(TClonesArray*)aod.fV0s->Clone(); + fCascades=(TClonesArray*)aod.fCascades->Clone(); + } + return *this; +} + + +void AliAODevent::AddV0(AliAODv0* v0) { + Int_t idx=fV0s->GetEntries(); + TClonesArray& arr=*fV0s; + new(arr[idx]) AliAODv0(*v0); +} + +void AliAODevent::AddCascade(AliAODxi* xi) { + Int_t idx=fCascades->GetEntries(); + TClonesArray& arr=*fCascades; + new(arr[idx]) AliAODxi(*xi); +} diff --git a/ANALYSIS/AliAODevent.h b/ANALYSIS/AliAODevent.h new file mode 100644 index 00000000000..90e89bd7a21 --- /dev/null +++ b/ANALYSIS/AliAODevent.h @@ -0,0 +1,51 @@ +#ifndef ALIAODEVENT_H +#define ALIAODEVENT_H + +#include +#include + +class AliESD; +class AliAODv0; +class AliAODxi; + +class AliAODevent : public TObject { + + private : + TClonesArray* fV0s; + TClonesArray* fCascades; + Double_t fPrimVertexX; // here put the whole AliESDVertex ? + Double_t fPrimVertexY; + Double_t fPrimVertexZ; + + UInt_t fRunNumber; + UInt_t fEventNumber; + UInt_t fNumberOfTracks; + + public : + AliAODevent(); + ~AliAODevent(); + AliAODevent(AliESD*); + AliAODevent(const AliAODevent&); + AliAODevent& operator=(const AliAODevent&); + + void AddV0(AliAODv0*); + void AddCascade(AliAODxi*); + inline TClonesArray* GetV0s() {return fV0s;} + inline TClonesArray* GetCascades() {return fCascades;} + inline AliAODv0* GetV0 (UInt_t idx) {return ((AliAODv0*)fV0s->UncheckedAt(idx));} + inline AliAODxi* GetCascade(UInt_t idx) {return ((AliAODxi*)fCascades->UncheckedAt(idx));} + + inline UInt_t GetNumberOfTracks() {return fNumberOfTracks;} + inline UInt_t GetNumberOfV0s() {return fV0s->GetEntries();} + inline UInt_t GetNumberOfCascades() {return fCascades->GetEntries();} + inline UInt_t GetRunNumber() {return fRunNumber;} + inline UInt_t GetEventNumber() {return fEventNumber;} + + inline Double_t GetPrimVertexX() {return fPrimVertexX;} + inline Double_t GetPrimVertexY() {return fPrimVertexY;} + inline Double_t GetPrimVertexZ() {return fPrimVertexZ;} + + ClassDef(AliAODevent,1); +}; + +#endif diff --git a/ANALYSIS/AliAODv0.cxx b/ANALYSIS/AliAODv0.cxx index 164628adcbd..42eae45b485 100644 --- a/ANALYSIS/AliAODv0.cxx +++ b/ANALYSIS/AliAODv0.cxx @@ -49,22 +49,119 @@ AliAODv0::AliAODv0() : TObject() { fKeyNeg = 999; fChi2 = 999; - fEvent = 0; } AliAODv0::AliAODv0(AliESDv0* rV0Vertex ,AliESD* rEvent){ this->Fill(rV0Vertex,rEvent); } +AliAODv0::AliAODv0(AliESDV0MI* rV0Vertex ,AliESD* rEvent){ + this->Fill(rV0Vertex,rEvent); +} + +AliAODv0::AliAODv0(const AliAODv0& rAliAODv0) : TObject(rAliAODv0) { + //-------------------------------------------------------------------- + // Copy constructor + //-------------------------------------------------------------------- + fDecayVertexV0X = rAliAODv0.fDecayVertexV0X; + fDecayVertexV0Y = rAliAODv0.fDecayVertexV0Y; + fDecayVertexV0Z = rAliAODv0.fDecayVertexV0Z; + fDcaV0Daughters = rAliAODv0.fDcaV0Daughters; + fDcaV0ToPrimVertex = rAliAODv0.fDcaV0ToPrimVertex ; + fDcaPosToPrimVertex = rAliAODv0.fDcaPosToPrimVertex; + fDcaNegToPrimVertex = rAliAODv0.fDcaNegToPrimVertex; + fMomPosX = rAliAODv0.fMomPosX; + fMomPosY = rAliAODv0.fMomPosY; + fMomPosZ = rAliAODv0.fMomPosZ; + fMomNegX = rAliAODv0.fMomNegX; + fMomNegY = rAliAODv0.fMomNegY; + fMomNegZ = rAliAODv0.fMomNegZ; + + fKeyNeg = rAliAODv0.fKeyNeg; + fKeyPos = rAliAODv0.fKeyPos; + + fChi2 = rAliAODv0.fChi2; +} + +AliAODv0& AliAODv0::operator=(const AliAODv0& rAliAODv0){ + //-------------------------------------------------------------------- + // Assignment overload + //-------------------------------------------------------------------- + this->fDecayVertexV0X = rAliAODv0.fDecayVertexV0X; + this->fDecayVertexV0Y = rAliAODv0.fDecayVertexV0Y; + this->fDecayVertexV0Z = rAliAODv0.fDecayVertexV0Z; + this->fDcaV0Daughters = rAliAODv0.fDcaV0Daughters; + this->fDcaV0ToPrimVertex = rAliAODv0.fDcaV0ToPrimVertex ; + this->fDcaPosToPrimVertex = rAliAODv0.fDcaPosToPrimVertex; + this->fDcaNegToPrimVertex = rAliAODv0.fDcaNegToPrimVertex; + this->fMomPosX = rAliAODv0.fMomPosX; + this->fMomPosY = rAliAODv0.fMomPosY; + this->fMomPosZ = rAliAODv0.fMomPosZ; + this->fMomNegX = rAliAODv0.fMomNegX; + this->fMomNegY = rAliAODv0.fMomNegY; + this->fMomNegZ = rAliAODv0.fMomNegZ; + + this->fKeyPos = rAliAODv0.fKeyPos; + this->fKeyNeg = rAliAODv0.fKeyNeg; + + this->fChi2 = rAliAODv0.fChi2; + return *this; +} + +AliAODv0::~AliAODv0(){ + //-------------------------------------------------------------------- + // Empty destructor + //-------------------------------------------------------------------- +} + + void AliAODv0::Fill(AliESDv0* rV0Vertex ,AliESD* rEvent){ // Fills the data memebers of the AOD - fEvent=rEvent; Double_t tDecayVertexV0[3]; rV0Vertex->GetXYZ(tDecayVertexV0[0],tDecayVertexV0[1],tDecayVertexV0[2]); fDecayVertexV0X = tDecayVertexV0[0]; fDecayVertexV0Y = tDecayVertexV0[1]; fDecayVertexV0Z = tDecayVertexV0[2]; - fDcaV0Daughters = rV0Vertex->GetDcaDaughters(); + fDcaV0Daughters = rV0Vertex->GetDcaV0Daughters(); + fDcaV0ToPrimVertex = rV0Vertex->GetD(); + + Double_t tMomPos[3]; rV0Vertex->GetPPxPyPz(tMomPos[0],tMomPos[1],tMomPos[2]); + fMomPosX = tMomPos[0]; + fMomPosY = tMomPos[1]; + fMomPosZ = tMomPos[2]; + + Double_t tMomNeg[3]; rV0Vertex->GetNPxPyPz(tMomNeg[0],tMomNeg[1],tMomNeg[2]); + fMomNegX = tMomNeg[0]; + fMomNegY = tMomNeg[1]; + fMomNegZ = tMomNeg[2]; + + fKeyPos = (UInt_t)TMath::Abs(rV0Vertex->GetPindex());// need to ask why Abs + fKeyNeg = (UInt_t)TMath::Abs(rV0Vertex->GetNindex()); + + AliESDtrack *pTrack=rEvent->GetTrack(fKeyPos); + AliESDtrack *nTrack=rEvent->GetTrack(fKeyNeg); + + Float_t tDcaPosToPrimVertex[2]; + if(pTrack) pTrack->GetImpactParameters(tDcaPosToPrimVertex[0],tDcaPosToPrimVertex[1]); + else { tDcaPosToPrimVertex[0]=999.; tDcaPosToPrimVertex[1]=999.;} + + fDcaPosToPrimVertex = TMath::Sqrt(tDcaPosToPrimVertex[0]*tDcaPosToPrimVertex[0]+tDcaPosToPrimVertex[1]*tDcaPosToPrimVertex[1]); + + Float_t tDcaNegToPrimVertex[2]; + if(nTrack) nTrack->GetImpactParameters(tDcaNegToPrimVertex[0],tDcaNegToPrimVertex[1]); + else { tDcaNegToPrimVertex[0]=999.; tDcaNegToPrimVertex[1]=999.;} + + fDcaNegToPrimVertex = TMath::Sqrt(tDcaNegToPrimVertex[0]*tDcaNegToPrimVertex[0]+tDcaNegToPrimVertex[1]*tDcaNegToPrimVertex[1]); +} + +void AliAODv0::Fill(AliESDV0MI* rV0Vertex ,AliESD* rEvent){ + // Fills the data members of the AOD + Double_t tDecayVertexV0[3]; rV0Vertex->GetXYZ(tDecayVertexV0[0],tDecayVertexV0[1],tDecayVertexV0[2]); + fDecayVertexV0X = tDecayVertexV0[0]; + fDecayVertexV0Y = tDecayVertexV0[1]; + fDecayVertexV0Z = tDecayVertexV0[2]; + + fDcaV0Daughters = rV0Vertex->GetDcaV0Daughters(); fDcaV0ToPrimVertex = rV0Vertex->GetD(); @@ -79,11 +176,11 @@ void AliAODv0::Fill(AliESDv0* rV0Vertex ,AliESD* rEvent){ fMomNegY = tMomNeg[1]; fMomNegZ = tMomNeg[2]; - fKeyPos = TMath::Abs(rV0Vertex->GetPindex());// need to ask why Abs - fKeyNeg = TMath::Abs(rV0Vertex->GetNindex()); + fKeyPos = (UInt_t)TMath::Abs(rV0Vertex->GetPindex());// need to check why Abs + fKeyNeg = (UInt_t)TMath::Abs(rV0Vertex->GetNindex()); - AliESDtrack *pTrack=fEvent->GetTrack(fKeyPos); - AliESDtrack *nTrack=fEvent->GetTrack(fKeyNeg); + AliESDtrack *pTrack=rEvent->GetTrack(fKeyPos); + AliESDtrack *nTrack=rEvent->GetTrack(fKeyNeg); Float_t tDcaPosToPrimVertex[2]; if(pTrack) pTrack->GetImpactParameters(tDcaPosToPrimVertex[0],tDcaPosToPrimVertex[1]); @@ -96,6 +193,8 @@ void AliAODv0::Fill(AliESDv0* rV0Vertex ,AliESD* rEvent){ else { tDcaNegToPrimVertex[0]=999.; tDcaNegToPrimVertex[1]=999.;} fDcaNegToPrimVertex = TMath::Sqrt(tDcaNegToPrimVertex[0]*tDcaNegToPrimVertex[0]+tDcaNegToPrimVertex[1]*tDcaNegToPrimVertex[1]); + + fChi2 = rV0Vertex->GetChi2V0(); } void AliAODv0::ResetV0(){ diff --git a/ANALYSIS/AliAODv0.h b/ANALYSIS/AliAODv0.h index 6a0ad43bf0b..230cd1f23eb 100644 --- a/ANALYSIS/AliAODv0.h +++ b/ANALYSIS/AliAODv0.h @@ -20,6 +20,7 @@ class AliESD; class AliESDVertex; class AliESDv0; +class AliESDV0MI; class AliESDtrack; @@ -28,19 +29,29 @@ class AliAODv0 : public TObject { public: AliAODv0(); AliAODv0(AliESDv0 *rV0Vertex, AliESD *rEvent); + AliAODv0(AliESDV0MI *rV0Vertex, AliESD *rEvent); + AliAODv0(const AliAODv0& rAliAODv0); + virtual ~AliAODv0(); + + AliAODv0& operator=(const AliAODv0& rAliAODv0); + void Fill(AliESDv0 *rV0Vertex, AliESD *rEvent); + void Fill(AliESDV0MI *rV0Vertex, AliESD *rEvent); void ResetV0(); Double_t DecayVertexV0X() const; Double_t DecayVertexV0Y() const; Double_t DecayVertexV0Z() const; - Double_t DecayLengthV0() const; + Double_t DecayLengthV0(double*) const; Double_t DcaV0Daughters() const; Double_t DcaV0ToPrimVertex() const; Double_t DcaPosToPrimVertex() const; Double_t DcaNegToPrimVertex() const; + Double_t CosPointAngle(Double_t&, Double_t&, Double_t&) const; + Double_t RadiusV0() const; + Double_t OpenAngleV0() const; Double_t MomPosX() const; Double_t MomPosY() const; @@ -77,6 +88,9 @@ public: Double_t MassK0Short() const; Double_t RapK0Short() const; Double_t RapLambda() const; + Double_t PseudoRapV0() const; + Double_t PseudoRapPos() const; + Double_t PseudoRapNeg() const; protected: @@ -94,11 +108,10 @@ protected: Double_t fMomNegY; // momemtum of neg daughter along Y Double_t fMomNegZ; // momemtum of neg daughter along Z - Int_t fKeyPos; // track key/index to pos daughter - Int_t fKeyNeg; // track key/index to neg daughter + UInt_t fKeyPos; // track key/index to pos daughter + UInt_t fKeyNeg; // track key/index to neg daughter Double_t fChi2; // main quality variable of V0 - AliESD *fEvent; // pointer to current event ClassDef(AliAODv0,1) }; @@ -107,15 +120,10 @@ inline Double_t AliAODv0::DecayVertexV0X() const {return fDecayVertexV0X;} inline Double_t AliAODv0::DecayVertexV0Y() const {return fDecayVertexV0Y;} inline Double_t AliAODv0::DecayVertexV0Z() const {return fDecayVertexV0Z;} -inline Double_t AliAODv0::DecayLengthV0() const { - if (fEvent&&fEvent->GetVertex()){ - Double_t tPrimaryVertexPosition[3]; - fEvent->GetVertex()->GetXYZ(tPrimaryVertexPosition); - return ::sqrt(::pow(DecayVertexV0X() - tPrimaryVertexPosition[0],2) + - ::pow(DecayVertexV0Y() - tPrimaryVertexPosition[1],2) + - ::pow(DecayVertexV0Z() - tPrimaryVertexPosition[2],2)); - } - return 0.; +inline Double_t AliAODv0::DecayLengthV0(double *tParentVertexPosition) const { + return ::sqrt(::pow(DecayVertexV0X() - tParentVertexPosition[0],2) + + ::pow(DecayVertexV0Y() - tParentVertexPosition[1],2) + + ::pow(DecayVertexV0Z() - tParentVertexPosition[2],2)); } inline Double_t AliAODv0::DcaV0Daughters() const {return fDcaV0Daughters;} @@ -135,6 +143,22 @@ inline Int_t AliAODv0::KeyNeg() const {return fKeyNeg;} inline Double_t AliAODv0::Chi2V0() const {return fChi2;} +inline Double_t AliAODv0::CosPointAngle(Double_t& refPointX, Double_t& refPointY, Double_t& refPointZ) const { + + Double_t deltaPos[3]; //vector between the reference point and the V0 vertex + deltaPos[0] = fDecayVertexV0X - refPointX; + deltaPos[1] = fDecayVertexV0Y - refPointY; + deltaPos[2] = fDecayVertexV0Z - refPointZ; + + Double_t deltaPos2 = deltaPos[0]*deltaPos[0] + deltaPos[1]*deltaPos[1] + deltaPos[2]*deltaPos[2]; + + Double_t cosinePointingAngle = (deltaPos[0]*MomV0X() + + deltaPos[1]*MomV0Y() + + deltaPos[2]*MomV0Z() ) / + TMath::Sqrt(Ptot2V0() * deltaPos2); + return cosinePointingAngle; +} + inline Double_t AliAODv0::MomV0X() const {return MomPosX()+MomNegX();} inline Double_t AliAODv0::MomV0Y() const {return MomPosY()+MomNegY();} inline Double_t AliAODv0::MomV0Z() const {return MomPosZ()+MomNegZ();} @@ -224,6 +248,30 @@ inline Double_t AliAODv0::RapLambda() const { return 0.5*::log((eLambda+mMomV0Z)/(eLambda-mMomV0Z)); } -#endif +inline Double_t AliAODv0::RadiusV0() const { + return ::sqrt( fDecayVertexV0X*fDecayVertexV0X + + fDecayVertexV0Y*fDecayVertexV0Y ); +} +inline Double_t AliAODv0::PseudoRapV0() const { + Double_t lTheta = ::acos( MomV0Z()/::sqrt(Ptot2V0()) ); + return ( -::log(TMath::Tan(lTheta/2.)) ); +} +inline Double_t AliAODv0::PseudoRapPos() const { + Double_t lTheta = ::acos( MomPosZ()/::sqrt(Ptot2Pos()) ); + return ( -::log(TMath::Tan(lTheta/2.)) ); +} + +inline Double_t AliAODv0::PseudoRapNeg() const { + Double_t lTheta = ::acos( MomNegZ()/::sqrt(Ptot2Neg()) ); + return ( -::log(TMath::Tan(lTheta/2.)) ); +} + +inline Double_t AliAODv0::OpenAngleV0() const { + Double_t lPtot1xPtot2 = fMomPosX*fMomNegX+fMomPosY*fMomNegY+fMomPosZ*fMomNegZ; + Double_t lPtot1Ptot2_2 = Ptot2Pos()*Ptot2Neg(); + return ::acos(lPtot1xPtot2/::sqrt(lPtot1Ptot2_2) ); +} + +#endif diff --git a/ANALYSIS/AliAODxi.cxx b/ANALYSIS/AliAODxi.cxx new file mode 100644 index 00000000000..1e1659d2314 --- /dev/null +++ b/ANALYSIS/AliAODxi.cxx @@ -0,0 +1,174 @@ +/************************************************************************** + * Copyright(c) 1998-1999, 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. * + **************************************************************************/ + +//------------------------------------------------------------------------- +// Implementation of the Analysis Oriented Data (AOD) Xi vertex class +// Origin: B.Hippolyte, IReS, hippolyt@in2p3.fr +// G.Van Buren, BNL, gene@bnl.gov (original STAR MuDsts) +// Purpose: Having observables for physics available for Xis +//------------------------------------------------------------------------- + +#include + +#include "AliESD.h" +#include "AliAODv0.h" +#include "AliAODxi.h" + +ClassImp(AliAODxi) + +AliAODxi::AliAODxi() : AliAODv0() { + //-------------------------------------------------------------------- + // Default constructor + //-------------------------------------------------------------------- + fCharge = 0; + fDecayVertexXiX = 999; + fDecayVertexXiY = 999; + fDecayVertexXiZ = 999; + fDcaXiDaughters = 999; + fDcaXiToPrimVertex = 999; + fDcaBachelorToPrimVertex = 999; + fMomBachelorX = 999; + fMomBachelorY = 999; + fMomBachelorZ = 999; + + fKeyBachelor = 999; + + fChi2Xi = 999; +} + +AliAODxi::AliAODxi(AliESDcascade* rXiVertex ,AliESD* rEvent){ + this->Fill(rXiVertex,rEvent); +} + +AliAODxi::AliAODxi(const AliAODxi &rAliAODxi) : AliAODv0(rAliAODxi){ + //-------------------------------------------------------------------- + // Copy constructor + //-------------------------------------------------------------------- + fDecayVertexXiX = rAliAODxi.fDecayVertexXiX; + fDecayVertexXiY = rAliAODxi.fDecayVertexXiY; + fDecayVertexXiZ = rAliAODxi.fDecayVertexXiZ; + fDcaXiDaughters = rAliAODxi.fDcaXiDaughters; + fDcaXiToPrimVertex = rAliAODxi.fDcaXiToPrimVertex ; + fDcaBachelorToPrimVertex = rAliAODxi.fDcaBachelorToPrimVertex; + fMomBachelorX = rAliAODxi.fMomBachelorX; + fMomBachelorY = rAliAODxi.fMomBachelorY; + fMomBachelorZ = rAliAODxi.fMomBachelorZ; + fKeyBachelor = rAliAODxi.fKeyBachelor; + fChi2Xi = rAliAODxi.fChi2Xi; +} + +AliAODxi& AliAODxi::operator=(const AliAODxi& rAliAODxi){ + //-------------------------------------------------------------------- + // Assignment overload + //-------------------------------------------------------------------- + AliAODv0::operator=(rAliAODxi); + this->fDecayVertexXiX = rAliAODxi.fDecayVertexXiX; + this->fDecayVertexXiY = rAliAODxi.fDecayVertexXiY; + this->fDecayVertexXiZ = rAliAODxi.fDecayVertexXiZ; + this->fDcaXiDaughters = rAliAODxi.fDcaXiDaughters; + this->fDcaXiToPrimVertex = rAliAODxi.fDcaXiToPrimVertex; + this->fDcaBachelorToPrimVertex = rAliAODxi.fDcaBachelorToPrimVertex; + this->fMomBachelorX = rAliAODxi.fMomBachelorX; + this->fMomBachelorY = rAliAODxi.fMomBachelorY; + this->fMomBachelorZ = rAliAODxi.fMomBachelorZ; + this->fKeyBachelor = rAliAODxi.fKeyBachelor; + this->fChi2Xi = rAliAODxi.fChi2Xi; + return *this; +} + +AliAODxi::~AliAODxi(){ + //-------------------------------------------------------------------- + // Empty destructor + //-------------------------------------------------------------------- +} + +void AliAODxi::Fill(AliESDcascade* rXiVertex ,AliESD* rEvent){ + // Fills the data memebers of the AOD + Double_t tDecayVertexXi[3]; rXiVertex->GetXYZcascade(tDecayVertexXi[0],tDecayVertexXi[1],tDecayVertexXi[2]); + fDecayVertexXiX = tDecayVertexXi[0]; + fDecayVertexXiY = tDecayVertexXi[1]; + fDecayVertexXiZ = tDecayVertexXi[2]; + + fDcaXiDaughters = rXiVertex->GetDcaXiDaughters(); + fDcaXiToPrimVertex = rXiVertex->GetD(); + + Double_t tMomPos[3]; rXiVertex->GetPPxPyPz(tMomPos[0],tMomPos[1],tMomPos[2]); + fMomPosX = tMomPos[0]; + fMomPosY = tMomPos[1]; + fMomPosZ = tMomPos[2]; + + Double_t tMomNeg[3]; rXiVertex->GetNPxPyPz(tMomNeg[0],tMomNeg[1],tMomNeg[2]); + fMomNegX = tMomNeg[0]; + fMomNegY = tMomNeg[1]; + fMomNegZ = tMomNeg[2]; + + Double_t tMomBachelor[3]; rXiVertex->GetBPxPyPz(tMomBachelor[0],tMomBachelor[1],tMomBachelor[2]); + fMomBachelorX = tMomBachelor[0]; + fMomBachelorY = tMomBachelor[1]; + fMomBachelorZ = tMomBachelor[2]; + + fKeyPos = (UInt_t)TMath::Abs(rXiVertex->GetPindex());// need to ask why Abs + fKeyNeg = (UInt_t)TMath::Abs(rXiVertex->GetNindex()); + fKeyBachelor = (UInt_t)TMath::Abs(rXiVertex->GetBindex()); + + AliESDtrack *pTrack=rEvent->GetTrack(fKeyPos); + AliESDtrack *nTrack=rEvent->GetTrack(fKeyNeg); + AliESDtrack *bTrack=rEvent->GetTrack(fKeyBachelor); + + Float_t tDcaPosToPrimVertex[2]; + if(pTrack) pTrack->GetImpactParameters(tDcaPosToPrimVertex[0],tDcaPosToPrimVertex[1]); + else { tDcaPosToPrimVertex[0]=999.; tDcaPosToPrimVertex[1]=999.;} + + fDcaPosToPrimVertex = TMath::Sqrt(tDcaPosToPrimVertex[0]*tDcaPosToPrimVertex[0]+tDcaPosToPrimVertex[1]*tDcaPosToPrimVertex[1]); + + Float_t tDcaNegToPrimVertex[2]; + if(nTrack) nTrack->GetImpactParameters(tDcaNegToPrimVertex[0],tDcaNegToPrimVertex[1]); + else { tDcaNegToPrimVertex[0]=999.; tDcaNegToPrimVertex[1]=999.;} + + + fDcaNegToPrimVertex = TMath::Sqrt(tDcaNegToPrimVertex[0]*tDcaNegToPrimVertex[0]+tDcaNegToPrimVertex[1]*tDcaNegToPrimVertex[1]); + + Float_t tDcaBachelorToPrimVertex[2]; + if(bTrack) bTrack->GetImpactParameters(tDcaBachelorToPrimVertex[0],tDcaBachelorToPrimVertex[1]); + else { tDcaBachelorToPrimVertex[0]=999.; tDcaBachelorToPrimVertex[1]=999.;} + + fDcaBachelorToPrimVertex = TMath::Sqrt(tDcaBachelorToPrimVertex[0]*tDcaBachelorToPrimVertex[0]+tDcaBachelorToPrimVertex[1]*tDcaBachelorToPrimVertex[1]); + + fDcaV0Daughters = rXiVertex->GetDcaV0Daughters(); + fDcaV0ToPrimVertex = rXiVertex->GetDcascade(rEvent->GetVertex()->GetXv(), + rEvent->GetVertex()->GetYv(), + rEvent->GetVertex()->GetZv()); + + double tDecayVertexV0[3]; rXiVertex->GetXYZ(tDecayVertexV0[0],tDecayVertexV0[1],tDecayVertexV0[2]); + fDecayVertexV0X=tDecayVertexV0[0]; + fDecayVertexV0Y=tDecayVertexV0[1]; + fDecayVertexV0Z=tDecayVertexV0[2]; +} + +void AliAODxi::ResetXi(){ + // Sets the default values of the AOD data members + fDecayVertexXiX = 999; + fDecayVertexXiY = 999; + fDecayVertexXiZ = 999; + fDcaXiDaughters = 999; + fDcaXiToPrimVertex = 999; + fDcaBachelorToPrimVertex = 999; + fMomBachelorX = 999; + fMomBachelorY = 999; + fMomBachelorZ = 999; + + fKeyBachelor = 999; + fChi2Xi = 999; +} diff --git a/ANALYSIS/AliAODxi.h b/ANALYSIS/AliAODxi.h new file mode 100644 index 00000000000..aa37cf339ce --- /dev/null +++ b/ANALYSIS/AliAODxi.h @@ -0,0 +1,230 @@ +#ifndef ALIAODXI_H +#define ALIAODXI_H + +/* Copyright(c) 2004-2005, ALICE Experiment at CERN, All rights reserved. * + * See cxx source for full Copyright notice */ + +//------------------------------------------------------------------------- +// Implementation of the Analysis Oriented Data (AOD) Xi vertex class +// Origin: B.Hippolyte, IReS, hippolyt@in2p3.fr +// G.Van Buren, BNL, gene@bnl.gov (original STAR MuDsts) +// Purpose: Having observables for physics available for Xis +//------------------------------------------------------------------------- + +#include +#include + +#define MASS(PID) TDatabasePDG::Instance()->GetParticle((PID))->Mass() +#define MASS2(PID) MASS((PID))*MASS((PID)) + +class AliESD; +class AliESDVertex; +class AliESDv0; +class AliESDcascade; +class AliESDtrack; + +class AliAODxi : public AliAODv0 { + +public: + AliAODxi(); + AliAODxi(AliESDcascade *rXiVertex, AliESD *rEvent); + AliAODxi(const AliAODxi& rAliAODxi); + virtual ~AliAODxi(); + + AliAODxi& operator=(const AliAODxi& rAliAODxi); + + void Fill(AliESDcascade *rXiVertex, AliESD *rEvent); + void ResetXi(); + + + Int_t Charge() const; + Double_t DecayVertexXiX() const; + Double_t DecayVertexXiY() const; + Double_t DecayVertexXiZ() const; + virtual Double_t DecayLengthV0() const; + Double_t DcaXiDaughters() const; + Double_t DcaBachelorToPrimVertex() const; + Double_t DcaV0ToPrimVertex(Double_t&, Double_t&, Double_t&) const; + Double_t DcaXiToPrimVertex() const; + Double_t CosPointAngle(Double_t&, Double_t&, Double_t&) const; + + Double_t DecayLengthXi(Double_t*) const; + + Double_t MomBachelorX() const; + Double_t MomBachelorY() const; + Double_t MomBachelorZ() const; + UInt_t KeyBachelor() const; + Double_t Chi2Xi() const; + Double_t MomXiX() const; + Double_t MomXiY() const; + Double_t MomXiZ() const; + + Double_t Ptot2Bachelor() const; + Double_t Ptot2Xi() const; + Double_t Pt2Xi() const; + Double_t MomBachelorAlongXi() const; + Double_t MomV0AlongXi() const; + Double_t AlphaXi() const; + Double_t PtArmXi() const; + Double_t EBachelorPion() const; + Double_t EBachelorKaon() const; + Double_t EXi() const; + Double_t EOmega() const; + Double_t MassXi() const; + Double_t MassOmega() const; + Double_t RapXi() const; + Double_t RapOmega() const; + + +protected: + + Int_t fCharge; // charge of Xi + Double_t fDecayVertexXiX; // decay vertex of Xi along X + Double_t fDecayVertexXiY; // decay vertex of Xi along Y + Double_t fDecayVertexXiZ; // decay vertex of Xi along Z + Double_t fDcaXiDaughters; // dca between Xi daughters + Double_t fDcaXiToPrimVertex; // dca of Xi to primary vertex + Double_t fDcaBachelorToPrimVertex; // dca of bachelor to primary vertex + Double_t fMomBachelorX; // momemtum of bachelor along X + Double_t fMomBachelorY; // momemtum of bachelor along Y + Double_t fMomBachelorZ; // momemtum of bachelor along Z + + UInt_t fKeyBachelor; // track key/index to bachelor + + Double_t fChi2Xi; // main quality variable of Xi + + ClassDef(AliAODxi,1) +}; + +inline Int_t AliAODxi::Charge() const {return fCharge;} + +inline Double_t AliAODxi::DecayVertexXiX() const {return fDecayVertexXiX;} +inline Double_t AliAODxi::DecayVertexXiY() const {return fDecayVertexXiY;} +inline Double_t AliAODxi::DecayVertexXiZ() const {return fDecayVertexXiZ;} + +inline Double_t AliAODxi::DecayLengthV0() const { + return ::sqrt(::pow(fDecayVertexV0X - fDecayVertexXiX,2) + + ::pow(fDecayVertexV0Y - fDecayVertexXiY,2) + + ::pow(fDecayVertexV0Z - fDecayVertexXiZ,2)); +} + +inline Double_t AliAODxi::DcaV0ToPrimVertex(Double_t& primVertexX, Double_t& primVertexY, Double_t& primVertexZ) const { + Double_t momV0X=MomV0X(); + Double_t momV0Y=MomV0Y(); + Double_t momV0Z=MomV0Z(); + Double_t dx=(primVertexY-fDecayVertexV0Y)*momV0Z - (primVertexZ-fDecayVertexV0Z)*momV0Y; + Double_t dy=(primVertexX-fDecayVertexV0X)*momV0Z - (primVertexZ-fDecayVertexV0Z)*momV0X; + Double_t dz=(primVertexX-fDecayVertexV0X)*momV0Y - (primVertexY-fDecayVertexV0Y)*momV0X; + return TMath::Sqrt((dx*dx+dy*dy+dz*dz)/(momV0X*momV0X+momV0Y*momV0Y+momV0Z*momV0Z)); +} + +inline Double_t AliAODxi::DcaXiDaughters() const {return fDcaXiDaughters;} +inline Double_t AliAODxi::DcaBachelorToPrimVertex() const {return fDcaBachelorToPrimVertex;} +inline Double_t AliAODxi::DcaXiToPrimVertex() const {return fDcaXiToPrimVertex;} + +inline Double_t AliAODxi::CosPointAngle(Double_t& refPointX, Double_t& refPointY, Double_t& refPointZ) const { + + Double_t deltaPos[3]; //vector between the reference point and the cascade vertex + deltaPos[0] = fDecayVertexXiX - refPointX; + deltaPos[1] = fDecayVertexXiY - refPointY; + deltaPos[2] = fDecayVertexXiZ - refPointZ; + + Double_t deltaPos2 = deltaPos[0]*deltaPos[0] + deltaPos[1]*deltaPos[1] + deltaPos[2]*deltaPos[2]; + + Double_t cosinePointingAngle = (deltaPos[0]*MomXiX() + + deltaPos[1]*MomXiY() + + deltaPos[2]*MomXiZ() ) / + TMath::Sqrt(Ptot2Xi() * deltaPos2); + return cosinePointingAngle; +} + +inline Double_t AliAODxi::DecayLengthXi(Double_t *tPrimaryVertexPosition) const { + return ::sqrt(::pow(fDecayVertexXiX - tPrimaryVertexPosition[0],2) + + ::pow(fDecayVertexXiY - tPrimaryVertexPosition[1],2) + + ::pow(fDecayVertexXiZ - tPrimaryVertexPosition[2],2)); +} + +inline Double_t AliAODxi::MomBachelorX() const {return fMomBachelorX;} +inline Double_t AliAODxi::MomBachelorY() const {return fMomBachelorY;} +inline Double_t AliAODxi::MomBachelorZ() const {return fMomBachelorZ;} +inline UInt_t AliAODxi::KeyBachelor() const {return fKeyBachelor;} +inline Double_t AliAODxi::Chi2Xi() const {return fChi2Xi;} +inline Double_t AliAODxi::MomXiX() const {return MomV0X()+fMomBachelorX;} +inline Double_t AliAODxi::MomXiY() const {return MomV0Y()+fMomBachelorY;} +inline Double_t AliAODxi::MomXiZ() const {return MomV0Z()+fMomBachelorZ;} + +inline Double_t AliAODxi::Ptot2Bachelor() const { + return (::pow(fMomBachelorX,2) + ::pow(fMomBachelorY,2) + ::pow(fMomBachelorZ,2) ); +} +inline Double_t AliAODxi::Ptot2Xi() const {return ( Pt2Xi() + ::pow(MomXiZ(),2) );} +inline Double_t AliAODxi::Pt2Xi() const { + return (::pow(MomXiX(),2) + ::pow(MomXiY(),2) ); +} + +inline Double_t AliAODxi::MomBachelorAlongXi() const { + Double_t lPtot2Xi = Ptot2Xi(); + if (lPtot2Xi) + return (MomBachelorX()*MomXiX() + + MomBachelorY()*MomXiY() + + MomBachelorZ()*MomXiZ()) / ::sqrt(lPtot2Xi); + return 0.; +} + +inline Double_t AliAODxi::MomV0AlongXi() const { + Double_t lPtot2Xi = Ptot2Xi(); + if (lPtot2Xi) + return (MomV0X()*MomXiX() + + MomV0Y()*MomXiY() + + MomV0Z()*MomXiZ()) / ::sqrt(lPtot2Xi); + return 0.; +} + +inline Double_t AliAODxi::AlphaXi() const { + Double_t lMomV0AlongXi = MomV0AlongXi(); + Double_t lMomBachelorAlongXi = MomBachelorAlongXi(); + + return (((Float_t) Charge()) * (lMomBachelorAlongXi-lMomV0AlongXi)/ + (lMomBachelorAlongXi+lMomV0AlongXi)); +} + +inline Double_t AliAODxi::PtArmXi() const { + return ::sqrt(Ptot2V0()-MomBachelorAlongXi()*MomBachelorAlongXi()); +} + +inline Double_t AliAODxi::EBachelorPion() const { + return ::sqrt(Ptot2Bachelor()+MASS2("pi-")); +} + +inline Double_t AliAODxi::EBachelorKaon() const { + return ::sqrt(Ptot2Bachelor()+MASS2("K-")); +} + +inline Double_t AliAODxi::EXi() const { + return ::sqrt(Ptot2Xi()+MASS2("Xi-")); +} + +inline Double_t AliAODxi::EOmega() const { + return ::sqrt(Ptot2Xi()+MASS2("Omega-")); +} + +inline Double_t AliAODxi::MassXi() const { + return ::sqrt(::pow(ELambda()+EBachelorPion(),2)-Ptot2Xi()); +} + +inline Double_t AliAODxi::MassOmega() const { + return ::sqrt(::pow(ELambda()+EBachelorKaon(),2)-Ptot2Xi()); +} + +inline Double_t AliAODxi::RapXi() const { + Double_t exi = EXi(); + Double_t lMomXiZ = MomXiZ(); + return 0.5*::log((exi+lMomXiZ)/(exi-lMomXiZ)); +} + +inline Double_t AliAODxi::RapOmega() const { + Double_t eom = EOmega(); + Double_t lMomXiZ = MomXiZ(); + return 0.5*::log((eom+lMomXiZ)/(eom-lMomXiZ)); +} + +#endif diff --git a/ANALYSIS/libANALYSIS.pkg b/ANALYSIS/libANALYSIS.pkg index eed8ee25014..8ddf2c2c7bb 100644 --- a/ANALYSIS/libANALYSIS.pkg +++ b/ANALYSIS/libANALYSIS.pkg @@ -10,7 +10,7 @@ SRCS= TGliteXmlEventlist.cxx\ AliReaderESD.cxx AliReaderESDTree.cxx \ AliTrackPoints.cxx AliClusterMap.cxx \ AliD0toKpi.cxx AliD0toKpiAnalysis.cxx AliFlowAnalysis.cxx \ - AliMuonAnalysis.cxx AliAODv0.cxx \ + AliMuonAnalysis.cxx AliAODv0.cxx AliAODxi.cxx AliAODevent.cxx \ AliAnalysisEventCuts.cxx AliAnalysisTrackCuts.cxx AliBalance.cxx HDRS= $(SRCS:.cxx=.h) @@ -27,7 +27,7 @@ EXPORT:=AliAOD.h AliEventBuffer.h\ AliReader.h AliReaderESD.h \ AliTrackPoints.h AliClusterMap.h \ AliFlowAnalysis.h AliReaderESDTree.h \ - AliMuonAnalysis.h AliAODv0.h \ + AliMuonAnalysis.h AliAODv0.h AliAODxi.h AliAODevent.h \ AliAnalysisEventCuts.h AliAnalysisTrackCuts.h AliBalance.h EINCLUDE:= TPC ITS diff --git a/STEER/AliCascadeVertexer.cxx b/STEER/AliCascadeVertexer.cxx index 7451457500e..9ebec6fc60a 100644 --- a/STEER/AliCascadeVertexer.cxx +++ b/STEER/AliCascadeVertexer.cxx @@ -19,6 +19,11 @@ // Fills the ESD with the cascades // Origin: Christian Kuhn, IReS, Strasbourg, christian.kuhn@ires.in2p3.fr //------------------------------------------------------------------------- + +//modified by R. Vernet 30/6/2006 : daughter label +//modified by R. Vernet 3/7/2006 : causality + + #include #include @@ -36,6 +41,8 @@ Int_t AliCascadeVertexer::V0sTracks2CascadeVertices(AliESD *event) { //-------------------------------------------------------------------- Double_t b=event->GetMagneticField(); Int_t nV0=(Int_t)event->GetNumberOfV0s(); + + //stores relevant V0s in an array TObjArray vtcs(nV0); Int_t i; for (i=0; iGetNumberOfTracks(); TArrayI trk(nentr); Int_t ntr=0; for (i=0; iChangeMassHypothesis(kLambda0); // the v0 must be Lambda if (TMath::Abs(v->GetEffMass()-massLambda)>fMassWin) continue; - for (Int_t j=0; jGetNindex()) continue; //bachelor and v0's negative tracks must be different AliESDtrack *btrk=event->GetTrack(bidx); - if (btrk->GetSign()>0) continue; // bachelor's charge - AliESDv0 v0(*v), *pv0=&v0; + AliESDv0 v0(*v), *pv0=&v0; AliExternalTrackParam bt(*btrk), *pbt=&bt; Double_t dca=PropagateToDCA(pv0,pbt,b); if (dca > fDCAmax) continue; - AliESDcascade cascade(*pv0,*pbt,bidx); - if (cascade.GetChi2() > fChi2max) continue; + AliESDcascade cascade(*pv0,*pbt,bidx);//constucts a cascade candidate + if (cascade.GetChi2Xi() > fChi2max) continue; Double_t x,y,z; cascade.GetXYZ(x,y,z); Double_t r2=x*x + y*y; if (r2 > fRmax*fRmax) continue; // condition on fiducial zone if (r2 < fRmin*fRmin) continue; - { + Double_t pxV0,pyV0,pzV0; + pv0->GetPxPyPz(pxV0,pyV0,pzV0); + if (x*pxV0+y*pyV0+z*pzV0 < 0) continue; //causality + Double_t x1,y1,z1; pv0->GetXYZ(x1,y1,z1); if (r2 > (x1*x1+y1*y1)) continue; - //if ((z-fZ)*(z-fZ) > (z1-fZ)*(z1-fZ)) continue; - } - - Double_t px,py,pz; cascade.GetPxPyPz(px,py,pz); - Double_t p2=px*px+py*py+pz*pz; - Double_t cost=((x-fX)*px + (y-fY)*py + (z-fZ)*pz)/ - TMath::Sqrt(p2*((x-fX)*(x-fX) + (y-fY)*(y-fY) + (z-fZ)*(z-fZ))); - if (costAddCascade(&cascade); + if (cascade.GetCascadeCosineOfPointingAngle(fX,fY,fZ) AddCascade(&cascade); ncasc++; - - } - } + } // end loop tracks + } // end loop V0s // Looking for the anti-cascades... - for (i=0; iChangeMassHypothesis(kLambda0Bar); //the v0 must be anti-Lambda if (TMath::Abs(v->GetEffMass()-massLambda)>fMassWin) continue; - for (Int_t j=0; jGetPindex()) continue; //bachelor and v0's positive tracks must be different AliESDtrack *btrk=event->GetTrack(bidx); - if (btrk->GetSign()<0) continue; // bachelor's charge AliESDv0 v0(*v), *pv0=&v0; @@ -126,34 +133,28 @@ Int_t AliCascadeVertexer::V0sTracks2CascadeVertices(AliESD *event) { Double_t dca=PropagateToDCA(pv0,pbt,b); if (dca > fDCAmax) continue; - AliESDcascade cascade(*pv0,*pbt,bidx); - if (cascade.GetChi2() > fChi2max) continue; + AliESDcascade cascade(*pv0,*pbt,bidx); //constucts a cascade candidate + if (cascade.GetChi2Xi() > fChi2max) continue; Double_t x,y,z; cascade.GetXYZ(x,y,z); Double_t r2=x*x + y*y; if (r2 > fRmax*fRmax) continue; // condition on fiducial zone if (r2 < fRmin*fRmin) continue; - { + Double_t pxV0,pyV0,pzV0; + pv0->GetPxPyPz(pxV0,pyV0,pzV0); + if (x*pxV0+y*pyV0+z*pzV0 < 0) continue; //causality + Double_t x1,y1,z1; pv0->GetXYZ(x1,y1,z1); if (r2 > (x1*x1+y1*y1)) continue; if (z*z > z1*z1) continue; - } - - Double_t px,py,pz; cascade.GetPxPyPz(px,py,pz); - Double_t p2=px*px+py*py+pz*pz; - Double_t cost=((x-fX)*px + (y-fY)*py + (z-fZ)*pz)/ - TMath::Sqrt(p2*((x-fX)*(x-fX) + (y-fY)*(y-fY) + (z-fZ)*(z-fZ))); - - if (costAddCascade(&cascade); + if (cascade.GetCascadeCosineOfPointingAngle(fX,fY,fZ) < fCPAmax) continue; //condition on the cascade pointing angle + event->AddCascade(&cascade); ncasc++; - } - } + } // end loop tracks + } // end loop V0s Info("V0sTracks2CascadeVertices","Number of reconstructed cascades: %d",ncasc); diff --git a/STEER/AliESD.cxx b/STEER/AliESD.cxx index 61fccb39327..2d4cb0e58f0 100644 --- a/STEER/AliESD.cxx +++ b/STEER/AliESD.cxx @@ -68,6 +68,48 @@ AliESD::AliESD(): fT0amplitude[i] = 0; } } +//______________________________________________________________________________ +AliESD::AliESD(const AliESD& esd): + TObject(esd), + fEventNumber(esd.fEventNumber), + fRunNumber(esd.fRunNumber), + fTriggerMask(esd.fTriggerMask), + fTriggerCluster(esd.fTriggerCluster), + fRecoVersion(esd.fRecoVersion), + fMagneticField(esd.fMagneticField), + fZDCN1Energy(esd.fZDCN1Energy), + fZDCP1Energy(esd.fZDCP1Energy), + fZDCN2Energy(esd.fZDCN2Energy), + fZDCP2Energy(esd.fZDCP2Energy), + fZDCEMEnergy(esd.fZDCEMEnergy), + fZDCParticipants(esd.fZDCParticipants), + fT0zVertex(esd.fT0zVertex), + fSPDVertex(esd.fSPDVertex), + fPrimaryVertex(esd.fPrimaryVertex), + fT0timeStart(esd.fT0timeStart), + fTracks(*((TClonesArray*)esd.fTracks.Clone())), + fHLTConfMapTracks(*((TClonesArray*)esd.fHLTConfMapTracks.Clone())), + fHLTHoughTracks(*((TClonesArray*)esd.fHLTHoughTracks.Clone())), + fMuonTracks(*((TClonesArray*)esd.fMuonTracks.Clone())), + fPmdTracks(*((TClonesArray*)esd.fPmdTracks.Clone())), + fTrdTracks(*((TClonesArray*)esd.fTrdTracks.Clone())), + fV0s(*((TClonesArray*)esd.fV0s.Clone())), + fCascades(*((TClonesArray*)esd.fCascades.Clone())), + fKinks(*((TClonesArray*)esd.fKinks.Clone())), + fV0MIs(*((TClonesArray*)esd.fV0MIs.Clone())), + fCaloClusters(*((TClonesArray*)esd.fCaloClusters.Clone())), + fEMCALClusters(esd.fEMCALClusters), + fFirstEMCALCluster(esd.fFirstEMCALCluster), + fPHOSClusters(esd.fPHOSClusters), + fFirstPHOSCluster(esd.fFirstPHOSCluster), + fESDFMD(esd.fESDFMD) +{ + for (Int_t i=0; i<24; i++) { + fT0time[i] = esd.fT0time[i]; + fT0amplitude[i] = esd.fT0amplitude[i]; + } +} + //______________________________________________________________________________ AliESD::~AliESD() diff --git a/STEER/AliESD.h b/STEER/AliESD.h index 3627373663c..ac9e815ac45 100644 --- a/STEER/AliESD.h +++ b/STEER/AliESD.h @@ -210,6 +210,7 @@ public: AliESDFMD * GetFMDData(){ return fESDFMD;} protected: + AliESD(const AliESD&); // Event Identification Int_t fEventNumber; // Event Number diff --git a/STEER/AliESDcascade.cxx b/STEER/AliESDcascade.cxx index 67aff20534b..247e8f7e761 100644 --- a/STEER/AliESDcascade.cxx +++ b/STEER/AliESDcascade.cxx @@ -34,37 +34,26 @@ ClassImp(AliESDcascade) AliESDcascade::AliESDcascade() : - TObject(), + AliESDv0(), fPdgCode(kXiMinus), fEffMass(TDatabasePDG::Instance()->GetParticle(kXiMinus)->Mass()), - fChi2(1.e+33), + fChi2Xi(1.e+33), + fDcaXiDaughters(999), fBachIdx(-1) { //-------------------------------------------------------------------- // Default constructor (Xi-) //-------------------------------------------------------------------- for (Int_t j=0; j<3; j++) { - fPos[j]=0.; + fPosXi[j]=0.; fBachMom[j]=0.; } - for (Int_t i=0; i<2; i++) - for (Int_t j=0; j<3; j++) - fV0mom[i][j]=0.; - - fV0idx[0]=fV0idx[1]=-1; - - fPosCov[0]=1e10; - fPosCov[1]=fPosCov[2]=0.; - fPosCov[3]=1e10; - fPosCov[4]=0.; - fPosCov[5]=1e10; - - fV0momCov[0]=1e10; - fV0momCov[1]=fV0momCov[2]=0.; - fV0momCov[3]=1e10; - fV0momCov[4]=0.; - fV0momCov[5]=1e10; + fPosCovXi[0]=1e10; + fPosCovXi[1]=fPosCovXi[2]=0.; + fPosCovXi[3]=1e10; + fPosCovXi[4]=0.; + fPosCovXi[5]=1e10; fBachMomCov[0]=1e10; fBachMomCov[1]=fBachMomCov[2]=0.; @@ -73,19 +62,19 @@ AliESDcascade::AliESDcascade() : fBachMomCov[5]=1e10; } +AliESDcascade::~AliESDcascade() { +} + AliESDcascade::AliESDcascade(const AliESDv0 &v, const AliExternalTrackParam &t, Int_t i) : - TObject(), + AliESDv0(v), fPdgCode(kXiMinus), - fEffMass(TDatabasePDG::Instance()->GetParticle(kXiMinus)->Mass()), - fChi2(1.e+33), + fChi2Xi(1.e+33), fBachIdx(i) { - //-------------------------------------------------------------------- + //--------------------------------------------------------------------------------------------- // Main constructor (Xi-) - //-------------------------------------------------------------------- - - fV0idx[0]=v.GetNindex(); fV0idx[1]=v.GetPindex(); + //--------------------------------------------------------------------------------------------- Double_t r[3]; t.GetXYZ(r); Double_t x1=r[0], y1=r[1], z1=r[2]; // position of the bachelor @@ -103,9 +92,13 @@ AliESDcascade::AliESDcascade(const AliESDv0 &v, Double_t ym=y2+a2*py2; Double_t zm=z2+a2*pz2; + //dca between V0 and bachelor + + fDcaXiDaughters = TMath::Sqrt((x1-xm)*(x1-xm) + (y1-ym)*(y1-ym) + (z1-zm)*(z1-zm)); + // position of the cascade decay - fPos[0]=0.5*(x1+xm); fPos[1]=0.5*(y1+ym); fPos[2]=0.5*(z1+zm); + fPosXi[0]=0.5*(x1+xm); fPosXi[1]=0.5*(y1+ym); fPosXi[2]=0.5*(z1+zm); // invariant mass of the cascade (default is Ximinus) @@ -120,23 +113,13 @@ AliESDcascade::AliESDcascade(const AliESDv0 &v, // momenta of the bachelor and the V0 fBachMom[0]=px1; fBachMom[1]=py1; fBachMom[2]=pz1; - v.GetNPxPyPz(px2,py2,pz2); - fV0mom[0][0]=px2; fV0mom[0][1]=py2; fV0mom[0][2]=pz2; - v.GetPPxPyPz(px2,py2,pz2); - fV0mom[1][0]=px2; fV0mom[1][1]=py2; fV0mom[1][2]=pz2; //PH Covariance matrices: to be calculated correctly in the future - fPosCov[0]=1e10; - fPosCov[1]=fPosCov[2]=0.; - fPosCov[3]=1e10; - fPosCov[4]=0.; - fPosCov[5]=1e10; - - fV0momCov[0]=1e10; - fV0momCov[1]=fV0momCov[2]=0.; - fV0momCov[3]=1e10; - fV0momCov[4]=0.; - fV0momCov[5]=1e10; + fPosCovXi[0]=1e10; + fPosCovXi[1]=fPosCovXi[2]=0.; + fPosCovXi[3]=1e10; + fPosCovXi[4]=0.; + fPosCovXi[5]=1e10; fBachMomCov[0]=1e10; fBachMomCov[1]=fBachMomCov[2]=0.; @@ -144,10 +127,50 @@ AliESDcascade::AliESDcascade(const AliESDv0 &v, fBachMomCov[4]=0.; fBachMomCov[5]=1e10; - fChi2=7.; + fChi2Xi=7.; } +AliESDcascade::AliESDcascade(const AliESDcascade& cas) : + AliESDv0(cas) +{ + //copy constructor + fPdgCode = cas.fPdgCode; + fEffMass = cas.fEffMass; + fChi2Xi = cas.fChi2Xi; + fDcaXiDaughters = cas.fDcaXiDaughters; + fBachIdx = cas.fBachIdx; + for (int i=0; i<3; i++) { + fPosXi[i] = cas.fPosXi[i]; + fBachMom[i] = cas.fBachMom[i]; + } + for (int i=0; i<6; i++) { + fPosCovXi[i] = cas.fPosCovXi[i]; + fBachMomCov[i] = cas.fBachMomCov[i]; + } +} + +AliESDcascade& AliESDcascade::operator=(const AliESDcascade& cas) { + //assignment operator + if (this != &cas) { + AliESDv0::operator=(cas); + fPdgCode = cas.fPdgCode; + fEffMass = cas.fEffMass; + fChi2Xi = cas.fChi2Xi; + fDcaXiDaughters = cas.fDcaXiDaughters; + fBachIdx = cas.fBachIdx; + for (int i=0; i<3; i++) { + fPosXi[i] = cas.fPosXi[i]; + fBachMom[i] = cas.fBachMom[i]; + } + for (int i=0; i<6; i++) { + fPosCovXi[i] = cas.fPosCovXi[i]; + fBachMomCov[i] = cas.fBachMomCov[i]; + } + } + return *this; +} + Double_t AliESDcascade::ChangeMassHypothesis(Double_t &v0q, Int_t code) { //-------------------------------------------------------------------- // This function changes the mass hypothesis for this cascade @@ -181,8 +204,8 @@ Double_t AliESDcascade::ChangeMassHypothesis(Double_t &v0q, Int_t code) { break; } - Double_t pxn=fV0mom[0][0], pyn=fV0mom[0][1], pzn=fV0mom[0][2]; - Double_t pxp=fV0mom[1][0], pyp=fV0mom[1][1], pzp=fV0mom[1][2]; + Double_t pxn=fNmom[0], pyn=fNmom[1], pzn=fNmom[2]; + Double_t pxp=fPmom[0], pyp=fPmom[1], pzp=fPmom[2]; Double_t px0=pxn+pxp, py0=pyn+pyp, pz0=pzn+pzp; Double_t p0=TMath::Sqrt(px0*px0 + py0*py0 + pz0*pz0); @@ -225,29 +248,29 @@ AliESDcascade::GetPxPyPz(Double_t &px, Double_t &py, Double_t &pz) const { //-------------------------------------------------------------------- // This function returns the cascade momentum (global) //-------------------------------------------------------------------- - px=fV0mom[0][0]+fV0mom[1][0]+fBachMom[0]; - py=fV0mom[0][1]+fV0mom[1][1]+fBachMom[1]; - pz=fV0mom[0][2]+fV0mom[1][2]+fBachMom[2]; + px=fNmom[0]+fPmom[0]+fBachMom[0]; + py=fNmom[1]+fPmom[1]+fBachMom[1]; + pz=fNmom[2]+fPmom[2]+fBachMom[2]; } -void AliESDcascade::GetXYZ(Double_t &x, Double_t &y, Double_t &z) const { +void AliESDcascade::GetXYZcascade(Double_t &x, Double_t &y, Double_t &z) const { //-------------------------------------------------------------------- // This function returns cascade position (global) //-------------------------------------------------------------------- - x=fPos[0]; - y=fPos[1]; - z=fPos[2]; + x=fPosXi[0]; + y=fPosXi[1]; + z=fPosXi[2]; } -Double_t AliESDcascade::GetD(Double_t x0, Double_t y0, Double_t z0) const { +Double_t AliESDcascade::GetDcascade(Double_t x0, Double_t y0, Double_t z0) const { //-------------------------------------------------------------------- // This function returns the cascade impact parameter //-------------------------------------------------------------------- - Double_t x=fPos[0],y=fPos[1],z=fPos[2]; - Double_t px=fV0mom[0][0]+fV0mom[1][0]+fBachMom[0]; - Double_t py=fV0mom[0][1]+fV0mom[1][1]+fBachMom[1]; - Double_t pz=fV0mom[0][2]+fV0mom[1][2]+fBachMom[2]; + Double_t x=fPosXi[0],y=fPosXi[1],z=fPosXi[2]; + Double_t px=fNmom[0]+fPmom[0]+fBachMom[0]; + Double_t py=fNmom[1]+fPmom[1]+fBachMom[1]; + Double_t pz=fNmom[2]+fPmom[2]+fBachMom[2]; Double_t dx=(y0-y)*pz - (z0-z)*py; Double_t dy=(x0-x)*pz - (z0-z)*px; @@ -257,3 +280,24 @@ Double_t AliESDcascade::GetD(Double_t x0, Double_t y0, Double_t z0) const { return d; } +Double_t AliESDcascade::GetCascadeCosineOfPointingAngle(Double_t& refPointX, Double_t& refPointY, Double_t& refPointZ) const { + // calculates the pointing angle of the cascade wrt a reference point + + Double_t momCas[3]; //momentum of the cascade + GetPxPyPz(momCas[0],momCas[1],momCas[2]); + + Double_t deltaPos[3]; //vector between the reference point and the cascade vertex + deltaPos[0] = fPosXi[0] - refPointX; + deltaPos[1] = fPosXi[1] - refPointY; + deltaPos[2] = fPosXi[2] - refPointZ; + + Double_t momCas2 = momCas[0]*momCas[0] + momCas[1]*momCas[1] + momCas[2]*momCas[2]; + Double_t deltaPos2 = deltaPos[0]*deltaPos[0] + deltaPos[1]*deltaPos[1] + deltaPos[2]*deltaPos[2]; + + Double_t cosinePointingAngle = (deltaPos[0]*momCas[0] + + deltaPos[1]*momCas[1] + + deltaPos[2]*momCas[2] ) / + TMath::Sqrt(momCas2 * deltaPos2); + + return cosinePointingAngle; +} diff --git a/STEER/AliESDcascade.h b/STEER/AliESDcascade.h index 322e679add4..53e624e660d 100644 --- a/STEER/AliESDcascade.h +++ b/STEER/AliESDcascade.h @@ -14,61 +14,62 @@ #include #include +#include "AliESDv0.h" class AliExternalTrackParam; -class AliESDv0; #define kXiMinus 3312 #define kXiPlusBar -3312 #define kOmegaMinus 3334 #define kOmegaPlusBar -3334 -class AliESDcascade : public TObject { +class AliESDcascade : public AliESDv0 { + public: AliESDcascade(); - AliESDcascade(const AliESDv0 &v0, + AliESDcascade(const AliESDcascade&); + AliESDcascade(const AliESDv0 &v0, const AliExternalTrackParam &t, Int_t i); + ~AliESDcascade(); + + AliESDcascade& operator=(const AliESDcascade&); Double_t ChangeMassHypothesis(Double_t &v0q, Int_t code=kXiMinus); - Int_t GetPdgCode() const {return fPdgCode;} + Int_t GetPdgCode() const {return fPdgCode;} Double_t GetEffMass() const {return fEffMass;} - Double_t GetChi2() const {return fChi2;} - void GetPxPyPz(Double_t &px, Double_t &py, Double_t &pz) const; - void GetXYZ(Double_t &x, Double_t &y, Double_t &z) const; - Double_t GetD(Double_t x0=0.,Double_t y0=0.,Double_t z0=0.) const; + Double_t GetChi2Xi() const {return fChi2Xi;} + void GetPxPyPz(Double_t &px, Double_t &py, Double_t &pz) const; + void GetXYZcascade(Double_t &x, Double_t &y, Double_t &z) const; + Double_t GetDcascade(Double_t x0=0.,Double_t y0=0.,Double_t z0=0.) const; - void GetNPxPyPz(Double_t &px, Double_t &py, Double_t &pz) const { - px=fV0mom[0][0]; py=fV0mom[0][1]; pz=fV0mom[0][2]; - } - Int_t GetNindex() const {return fV0idx[0];} - void GetPPxPyPz(Double_t &px, Double_t &py, Double_t &pz) const { - px=fV0mom[1][0]; py=fV0mom[1][1]; pz=fV0mom[1][2]; - } - Int_t GetPindex() const {return fV0idx[1];} - void GetBPxPyPz(Double_t &px, Double_t &py, Double_t &pz) const { + void GetBPxPyPz(Double_t &px, Double_t &py, Double_t &pz) const { px=fBachMom[0]; py=fBachMom[1]; pz=fBachMom[2]; } - Int_t GetBindex() const {return fBachIdx;} + + Int_t GetBindex() const {return fBachIdx;} + void SetDcaXiDaughters(Double_t rDcaXiDaughters=0.); + Double_t GetDcaXiDaughters() const {return fDcaXiDaughters;} + Double_t GetCascadeCosineOfPointingAngle(Double_t&, Double_t&, Double_t&) const; protected: - Int_t fPdgCode; // reconstructed cascade type (PDG code) + Int_t fPdgCode; // reconstructed cascade type (PDG code) Double_t fEffMass; // reconstructed cascade effective mass - Double_t fChi2; // chi2 value - Double_t fPos[3]; // cascade vertex position (global) - Double_t fPosCov[6]; // covariance matrix of the vertex position + Double_t fChi2Xi; // chi2 value + Double_t fDcaXiDaughters; // dca between Xi's daughters + Double_t fPosXi[3]; // cascade vertex position (global) + Double_t fPosCovXi[6]; // covariance matrix of the vertex position - Int_t fV0idx[2]; // indeices of the V0 daughter tracks - Double_t fV0mom[2][3]; // V0 daughters' momenta (global) - Double_t fV0momCov[6]; // covariance matrix of the V0 momentum. - - Int_t fBachIdx; // label of the bachelor track + Int_t fBachIdx; // label of the bachelor track Double_t fBachMom[3]; // bachelor momentum (global) Double_t fBachMomCov[6]; // covariance matrix of the bachelor momentum. - ClassDef(AliESDcascade,1) // reconstructed cascade vertex + ClassDef(AliESDcascade,2) // reconstructed cascade vertex }; -#endif - +inline +void AliESDcascade::SetDcaXiDaughters(Double_t rDcaXiDaughters){ + fDcaXiDaughters=rDcaXiDaughters; +} +#endif diff --git a/STEER/AliESDv0.cxx b/STEER/AliESDv0.cxx index d4f41dd0ee5..ed277716469 100644 --- a/STEER/AliESDv0.cxx +++ b/STEER/AliESDv0.cxx @@ -39,8 +39,8 @@ AliESDv0::AliESDv0() : TObject(), fPdgCode(kK0Short), fEffMass(TDatabasePDG::Instance()->GetParticle(kK0Short)->Mass()), - fDcaDaughters(0), - fChi2(1.e+33), + fDcaV0Daughters(0), + fChi2V0(1.e+33), fNidx(0), fPidx(0) { @@ -61,13 +61,61 @@ AliESDv0::AliESDv0() : } } +AliESDv0::AliESDv0(const AliESDv0& rAliESDv0) : + TObject(rAliESDv0) +{ + fPdgCode = rAliESDv0.fPdgCode; + fEffMass = rAliESDv0.fEffMass; + fDcaV0Daughters = rAliESDv0.fDcaV0Daughters; + fChi2V0 = rAliESDv0.fChi2V0; + fNidx = rAliESDv0.fNidx; + fPidx = rAliESDv0.fPidx; + + for (int i=0; i<3; i++) { + fPos[i] = rAliESDv0.fPos[i]; + fNmom[i] = rAliESDv0.fNmom[i]; + fPmom[i] = rAliESDv0.fPmom[i]; + } + for (int i=0; i<6; i++) { + fPosCov[i] = rAliESDv0.fPosCov[i]; + fNmomCov[i] = rAliESDv0.fNmomCov[i]; + fPmomCov[i] = rAliESDv0.fPmomCov[i]; + } +} + + +AliESDv0& AliESDv0::operator=(const AliESDv0& rAliESDv0) +{ + if (this!=&rAliESDv0) { + TObject::operator=(rAliESDv0); + fPdgCode = rAliESDv0.fPdgCode; + fEffMass = rAliESDv0.fEffMass; + fDcaV0Daughters = rAliESDv0.fDcaV0Daughters; + fChi2V0 = rAliESDv0.fChi2V0; + fNidx = rAliESDv0.fNidx; + fPidx = rAliESDv0.fPidx; + + for (int i=0; i<3; i++) { + fPos[i] = rAliESDv0.fPos[i]; + fNmom[i] = rAliESDv0.fNmom[i]; + fPmom[i] = rAliESDv0.fPmom[i]; + } + for (int i=0; i<6; i++) { + fPosCov[i] = rAliESDv0.fPosCov[i]; + fNmomCov[i] = rAliESDv0.fNmomCov[i]; + fPmomCov[i] = rAliESDv0.fPmomCov[i]; + } + } + return *this; +} + AliESDv0::AliESDv0(const AliExternalTrackParam &t1, Int_t i1, const AliExternalTrackParam &t2, Int_t i2) : TObject(), fPdgCode(kK0Short), fEffMass(TDatabasePDG::Instance()->GetParticle(kK0Short)->Mass()), - fDcaDaughters(0), - fChi2(1.e+33), + fDcaV0Daughters(0), + fChi2V0(1.e+33), fNidx(i1), fPidx(i2) { @@ -123,10 +171,18 @@ AliESDv0::AliESDv0(const AliExternalTrackParam &t1, Int_t i1, fEffMass=TMath::Sqrt((e1+e2)*(e1+e2)- (px1+px2)*(px1+px2)-(py1+py2)*(py1+py2)-(pz1+pz2)*(pz1+pz2)); - fChi2=7.; + fChi2V0=7.; + +} +AliESDv0::~AliESDv0(){ + //-------------------------------------------------------------------- + // Empty destructor + //-------------------------------------------------------------------- } + + Double_t AliESDv0::ChangeMassHypothesis(Int_t code) { //-------------------------------------------------------------------- // This function changes the mass hypothesis for this V0 @@ -206,3 +262,26 @@ Double_t AliESDv0::GetD(Double_t x0, Double_t y0, Double_t z0) const { Double_t d=TMath::Sqrt((dx*dx+dy*dy+dz*dz)/(px*px+py*py+pz*pz)); return d; } + + +Double_t AliESDv0::GetV0CosineOfPointingAngle(Double_t& refPointX, Double_t& refPointY, Double_t& refPointZ) const { + // calculates the pointing angle of the V0 wrt a reference point + + Double_t momV0[3]; //momentum of the V0 + GetPxPyPz(momV0[0],momV0[1],momV0[2]); + + Double_t deltaPos[3]; //vector between the reference point and the V0 vertex + deltaPos[0] = fPos[0] - refPointX; + deltaPos[1] = fPos[1] - refPointY; + deltaPos[2] = fPos[2] - refPointZ; + + Double_t momV02 = momV0[0]*momV0[0] + momV0[1]*momV0[1] + momV0[2]*momV0[2]; + Double_t deltaPos2 = deltaPos[0]*deltaPos[0] + deltaPos[1]*deltaPos[1] + deltaPos[2]*deltaPos[2]; + + Double_t cosinePointingAngle = (deltaPos[0]*momV0[0] + + deltaPos[1]*momV0[1] + + deltaPos[2]*momV0[2] ) / + TMath::Sqrt(momV02 * deltaPos2); + + return cosinePointingAngle; +} diff --git a/STEER/AliESDv0.h b/STEER/AliESDv0.h index 0599a455597..6a5f41e9406 100644 --- a/STEER/AliESDv0.h +++ b/STEER/AliESDv0.h @@ -23,34 +23,40 @@ public: AliESDv0(const AliExternalTrackParam &t1, Int_t i1, const AliExternalTrackParam &t2, Int_t i2); + AliESDv0(const AliESDv0&); + virtual ~AliESDv0(); + AliESDv0& operator=(const AliESDv0&); + Double_t ChangeMassHypothesis(Int_t code=kK0Short); - Int_t GetPdgCode() const {return fPdgCode;} + Int_t GetPdgCode() const {return fPdgCode;} Double_t GetEffMass() const {return fEffMass;} - Double_t GetChi2() const {return fChi2;} - void GetPxPyPz(Double_t &px, Double_t &py, Double_t &pz) const; - void GetNPxPyPz(Double_t &px, Double_t &py, Double_t &pz) const; - void GetPPxPyPz(Double_t &px, Double_t &py, Double_t &pz) const; - void GetXYZ(Double_t &x, Double_t &y, Double_t &z) const; + Double_t GetChi2V0() const {return fChi2V0;} + void GetPxPyPz(Double_t &px, Double_t &py, Double_t &pz) const; + void GetNPxPyPz(Double_t &px, Double_t &py, Double_t &pz) const; + void GetPPxPyPz(Double_t &px, Double_t &py, Double_t &pz) const; + void GetXYZ(Double_t &x, Double_t &y, Double_t &z) const; Double_t GetD(Double_t x0=0.,Double_t y0=0.,Double_t z0=0.) const; - Int_t GetNindex() const {return fNidx;} - Int_t GetPindex() const {return fPidx;} - void SetESDindexes(Int_t ip, Int_t im){fNidx=ip;fPidx=im;} - void SetDcaDaughters(Double_t rDcaDaughters=0.); - Double_t GetDcaDaughters() {return fDcaDaughters;} + Int_t GetNindex() const {return fNidx;} + Int_t GetPindex() const {return fPidx;} + void SetESDindexes(Int_t ip, Int_t im){fNidx=ip;fPidx=im;} + void SetDcaV0Daughters(Double_t rDcaV0Daughters=0.); + Double_t GetDcaV0Daughters() {return fDcaV0Daughters;} + Double_t GetV0CosineOfPointingAngle(Double_t&, Double_t&, Double_t&) const; + protected: - Int_t fPdgCode; // reconstructed V0's type (PDG code) + Int_t fPdgCode; // reconstructed V0's type (PDG code) Double_t fEffMass; // reconstructed V0's effective mass - Double_t fDcaDaughters; // dca between V0's daughters - Double_t fChi2; // V0's chi2 value + Double_t fDcaV0Daughters; // dca between V0's daughters + Double_t fChi2V0; // V0's chi2 value Double_t fPos[3]; // V0's position (global) Double_t fPosCov[6]; // covariance matrix of the vertex position - Int_t fNidx; // index of the negative daughter + Int_t fNidx; // index of the negative daughter Double_t fNmom[3]; // momentum of the negative daughter (global) Double_t fNmomCov[6]; // covariance matrix of the negative daughter mom. - Int_t fPidx; // index of the positive daughter + Int_t fPidx; // index of the positive daughter Double_t fPmom[3]; // momentum of the positive daughter (global) Double_t fPmomCov[6]; // covariance matrix of the positive daughter mom. @@ -68,10 +74,8 @@ px=fPmom[0]; py=fPmom[1]; pz=fPmom[2]; } inline -void AliESDv0::SetDcaDaughters(Double_t rDcaDaughters){ - fDcaDaughters=rDcaDaughters; +void AliESDv0::SetDcaV0Daughters(Double_t rDcaV0Daughters){ + fDcaV0Daughters=rDcaV0Daughters; } #endif - - diff --git a/STEER/AliV0vertexer.cxx b/STEER/AliV0vertexer.cxx index 08aab873db1..51534e4b851 100644 --- a/STEER/AliV0vertexer.cxx +++ b/STEER/AliV0vertexer.cxx @@ -19,6 +19,8 @@ // fills the ESD with the V0s // Origin: Iouri Belikov, IReS, Strasbourg, Jouri.Belikov@cern.ch //------------------------------------------------------------------------- + + #include #include @@ -99,23 +101,10 @@ Int_t AliV0vertexer::Tracks2V0vertices(AliESD *event) { nt.PropagateTo(xn,b); pt.PropagateTo(xp,b); AliESDv0 vertex(nt,nidx,pt,pidx); - if (vertex.GetChi2() > fChi2max) continue; + if (vertex.GetChi2V0() > fChi2max) continue; - /* Think of something better here ! - nt.PropagateToVertex(); if (TMath::Abs(nt.GetZ())<0.04) continue; - pt.PropagateToVertex(); if (TMath::Abs(pt.GetZ())<0.04) continue; - */ - - Double_t x,y,z; vertex.GetXYZ(x,y,z); - Double_t px,py,pz; vertex.GetPxPyPz(px,py,pz); - Double_t p2=px*px+py*py+pz*pz; - Double_t cost=((x-fX)*px + (y-fY)*py + (z-fZ)*pz)/ - TMath::Sqrt(p2*((x-fX)*(x-fX) + (y-fY)*(y-fY) + (z-fZ)*(z-fZ))); - - //if (cost < (5*fCPAmax-0.9-TMath::Sqrt(r2)*(fCPAmax-1))/4.1) continue; - if (cost < fCPAmax) continue; - vertex.SetDcaDaughters(dca); - //vertex.ChangeMassHypothesis(); //default is Lambda0 + if (vertex.GetV0CosineOfPointingAngle(fX,fY,fZ) < fCPAmax) continue; + vertex.SetDcaV0Daughters(dca); event->AddV0(&vertex); -- 2.43.0