#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+;
--- /dev/null
+/**************************************************************************
+ * 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; i<e->GetNumberOfV0s(); i++) {
+ AliAODv0* v=new AliAODv0(e->GetV0(i),e);
+ this->AddV0(v);
+ delete v;
+ }
+
+ for (Int_t i=0; i<e->GetNumberOfCascades(); 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);
+}
--- /dev/null
+#ifndef ALIAODEVENT_H
+#define ALIAODEVENT_H
+
+#include <TObject.h>
+#include <TClonesArray.h>
+
+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
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();
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]);
else { tDcaNegToPrimVertex[0]=999.; tDcaNegToPrimVertex[1]=999.;}
fDcaNegToPrimVertex = TMath::Sqrt(tDcaNegToPrimVertex[0]*tDcaNegToPrimVertex[0]+tDcaNegToPrimVertex[1]*tDcaNegToPrimVertex[1]);
+
+ fChi2 = rV0Vertex->GetChi2V0();
}
void AliAODv0::ResetV0(){
class AliESD;
class AliESDVertex;
class AliESDv0;
+class AliESDV0MI;
class AliESDtrack;
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;
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:
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)
};
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;}
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();}
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
--- /dev/null
+/**************************************************************************
+ * 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 <TMath.h>
+
+#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;
+}
--- /dev/null
+#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 <TObject.h>
+#include <TDatabasePDG.h>
+
+#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
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)
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
// 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 <TObjArray.h>
#include <TTree.h>
//--------------------------------------------------------------------
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; i<nV0; i++) {
}
nV0=vtcs.GetEntriesFast();
+ // stores relevant tracks in another array
Int_t nentr=(Int_t)event->GetNumberOfTracks();
TArrayI trk(nentr); Int_t ntr=0;
for (i=0; i<nentr; i++) {
Int_t ncasc=0;
// Looking for the cascades...
- for (i=0; i<nV0; i++) {
+
+ for (i=0; i<nV0; i++) { //loop on V0s
+
AliESDv0 *v=(AliESDv0*)vtcs.UncheckedAt(i);
v->ChangeMassHypothesis(kLambda0); // the v0 must be Lambda
if (TMath::Abs(v->GetEffMass()-massLambda)>fMassWin) continue;
- for (Int_t j=0; j<ntr; j++) {
+
+ for (Int_t j=0; j<ntr; j++) {//loop on tracks
Int_t bidx=trk[j];
+ if (bidx==v->GetNindex()) 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 (cost<fCPAmax) continue; //condition on the cascade pointing angle
- //cascade.ChangeMassHypothesis(); //default is Xi
-
- event->AddCascade(&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
// Looking for the anti-cascades...
- for (i=0; i<nV0; i++) {
+
+ for (i=0; i<nV0; i++) { //loop on V0s
AliESDv0 *v=(AliESDv0*)vtcs.UncheckedAt(i);
v->ChangeMassHypothesis(kLambda0Bar); //the v0 must be anti-Lambda
if (TMath::Abs(v->GetEffMass()-massLambda)>fMassWin) continue;
- for (Int_t j=0; j<ntr; j++) {
+
+ for (Int_t j=0; j<ntr; j++) {//loop on tracks
Int_t bidx=trk[j];
+ if (bidx==v->GetPindex()) 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;
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 (cost<fCPAmax) continue; //condition on the cascade pointing angle
- //cascade.ChangeMassHypothesis(); //default is Xi
-
- event->AddCascade(&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);
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()
AliESDFMD * GetFMDData(){ return fESDFMD;}
protected:
+ AliESD(const AliESD&);
// Event Identification
Int_t fEventNumber; // Event Number
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.;
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
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)
// 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.;
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
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);
//--------------------------------------------------------------------
// 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;
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;
+}
#include <TObject.h>
#include <TPDGCode.h>
+#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
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)
{
}
}
+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)
{
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
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;
+}
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.
}
inline
-void AliESDv0::SetDcaDaughters(Double_t rDcaDaughters){
- fDcaDaughters=rDcaDaughters;
+void AliESDv0::SetDcaV0Daughters(Double_t rDcaV0Daughters){
+ fDcaV0Daughters=rDcaV0Daughters;
}
#endif
-
-
// fills the ESD with the V0s
// Origin: Iouri Belikov, IReS, Strasbourg, Jouri.Belikov@cern.ch
//-------------------------------------------------------------------------
+
+
#include <TObjArray.h>
#include <TTree.h>
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);
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff