// Purpose: Having physics observables available for Xis
//-------------------------------------------------------------------------
-#include <TObject.h>
#include <TVector3.h>
#include <TMath.h>
+#include <TDatabasePDG.h>
#include "AliAODcascade.h"
#include "AliAODTrack.h"
-#include <AliAODVertex.h>
-
ClassImp(AliAODcascade)
-
-
AliAODcascade::AliAODcascade() :
AliAODv0(),
//--------------------------------------------------------------------
}
-
-
-void AliAODcascade::Fill( AliAODVertex* rAODVertexXi,
+void AliAODcascade::Fill(AliAODVertex* rAODVertexXi,
Int_t rChargeXi,
Double_t rDcaXiDaughters,
Double_t rDcaXiToPrimVertex,
const Double_t& rPrimVtxY,
const Double_t& rPrimVtxZ) const
{
+ //--------------------------------------------------------------------
+ // Print the AOD data members
+ //--------------------------------------------------------------------
AliAODv0::Print();
printf("- \n");
printf("AliAODcascade : posXiVtx (%.6f, %.6f, %.6f) \n", DecayVertexXiX(), DecayVertexXiY(), DecayVertexXiZ() );
// Cosine of Xi pointing angle in 3D space, with respect to a point
// (primary vtx ...)
- TVector3 rMomXi( MomXiX(),MomXiY(),MomXiZ() );
- TVector3 rVect_1rVtxToXi(DecayVertexXiX() - rPrimVtxX,
- DecayVertexXiY() - rPrimVtxY,
- DecayVertexXiZ() - rPrimVtxZ);
+ TVector3 lMomXi( MomXiX(),MomXiY(),MomXiZ() );
+ TVector3 lVectPrimVtxToXi(DecayVertexXiX() - rPrimVtxX,
+ DecayVertexXiY() - rPrimVtxY,
+ DecayVertexXiZ() - rPrimVtxZ);
- Double_t PtgAngle = rMomXi.Angle(rVect_1rVtxToXi);
+ Double_t lPtgAngle = lMomXi.Angle(lVectPrimVtxToXi);
- return TMath::Cos(PtgAngle);
+ return TMath::Cos(lPtgAngle);
}
return rBachId;
}
+Double_t AliAODcascade::EBachPion() const {
+ static Double_t lMassPi = TDatabasePDG::Instance()->GetParticle("pi-")->Mass();
+ return ::sqrt(Ptot2Bach() + lMassPi*lMassPi);
+}
+
+Double_t AliAODcascade::EBachKaon() const {
+ static Double_t lMassKaon = TDatabasePDG::Instance()->GetParticle("K-")->Mass();
+ return ::sqrt(Ptot2Bach() + lMassKaon*lMassKaon);
+}
+Double_t AliAODcascade::EXi() const {
+ static Double_t lMassXi = TDatabasePDG::Instance()->GetParticle("Xi-")->Mass();
+ return ::sqrt(Ptot2Bach() + lMassXi*lMassXi);
+}
+Double_t AliAODcascade::EOmega() const {
+ static Double_t lMassOmega = TDatabasePDG::Instance()->GetParticle("Omega-")->Mass();
+ return ::sqrt(Ptot2Bach() + lMassOmega*lMassOmega);
+}
// Purpose: Having physics observables available for Xis
//-------------------------------------------------------------------------
-#include <TDatabasePDG.h>
-
-#include <AliAODv0.h>
-
-
-#define MASS(PID) TDatabasePDG::Instance()->GetParticle((PID))->Mass()
-#define MASS2(PID) MASS((PID))*MASS((PID))
+#include "AliAODv0.h"
class AliAODTrack;
class AliAODVertex;
-
-
class AliAODcascade : public AliAODv0 {
public:
AliAODcascade& operator=(const AliAODcascade& rSource);
- void Fill( AliAODVertex* rAODVertexXi, // No "const" param, see above.
+ void Fill(AliAODVertex* rAODVertexXi, // No "const" param, see above.
Int_t rChargeXi,
Double_t rDcaXiDaughters,
Double_t rDcaXiToPrimVertex,
Double_t DecayVertexXiY() const;
Double_t DecayVertexXiZ() const;
Double_t Chi2Xi() const;
-
Double_t DcaBachToPrimVertex() const;
Double_t DcaXiDaughters() const;
const Double_t& rPrimVtxY,
const Double_t& rPrimVtxZ) const;
-
Double_t DecayLengthV0() const;
Double_t DecayLengthXi(const Double_t& rPrimVtxX,
const Double_t& rPrimVtxY,
const Double_t& rPrimVtxZ) const;
-
-
+
Double_t MomBachX() const;
Double_t MomBachY() const;
Double_t MomBachZ() const;
Double_t RapXi() const;
Double_t RapOmega() const;
-
protected:
TRef fDecayVertexXi; // ref to decay vertex of the cascade (Xi vertex)
Double32_t fMomBachX; // momemtum of bachelor along X
Double32_t fMomBachY; // momemtum of bachelor along Y
Double32_t fMomBachZ; // momemtum of bachelor along Z
-
ClassDef(AliAODcascade,1)
};
-
-
-
//-----------------------------------------------------------
-
-
inline Int_t AliAODcascade::ChargeXi() const {return fChargeXi; }
inline AliAODVertex* AliAODcascade::GetDecayVertexXi() const { return (AliAODVertex*)fDecayVertexXi.GetObject(); }
inline Double_t AliAODcascade::Chi2Xi() const {return GetDecayVertexXi()->GetChi2(); }
-
-
inline Double_t AliAODcascade::DcaBachToPrimVertex() const {return fDcaBachToPrimVertex;}
inline Double_t AliAODcascade::DcaXiDaughters() const {return fDcaXiDaughters;}
inline Double_t AliAODcascade::DcaXiToPrimVertex() const {return fDcaXiToPrimVertex;}
-
-
-
inline Double_t AliAODcascade::DecayLengthV0() const {
return ::sqrt(::pow(DecayVertexV0X() - DecayVertexXiX(),2) +
::pow(DecayVertexV0Y() - DecayVertexXiY(),2) +
::pow(DecayVertexXiZ() - rPrimVtxZ,2));
}
-
-
-
-
-
inline Double_t AliAODcascade::MomBachX() const {return fMomBachX;}
inline Double_t AliAODcascade::MomBachY() const {return fMomBachY;}
inline Double_t AliAODcascade::MomBachZ() const {return fMomBachZ;}
return ::sqrt(Ptot2Bach()-MomBachAlongXi()*MomBachAlongXi());
}
-inline Double_t AliAODcascade::EBachPion() const {
- return ::sqrt(Ptot2Bach()+MASS2("pi-"));
-}
-
-inline Double_t AliAODcascade::EBachKaon() const {
- return ::sqrt(Ptot2Bach()+MASS2("K-"));
-}
-
-inline Double_t AliAODcascade::EXi() const {
- return ::sqrt(Ptot2Xi()+MASS2("Xi-"));
-}
-
-inline Double_t AliAODcascade::EOmega() const {
- return ::sqrt(Ptot2Xi()+MASS2("Omega-"));
-}
-
inline Double_t AliAODcascade::MassXi() const {
return ::sqrt(::pow(ELambda()+EBachPion(),2)-Ptot2Xi());
}
}
void AliAODv0::Fill(AliAODVertex *rAODVertex, Double_t rDcaV0Daughters, Double_t rDcaV0ToPrimVertex,
- const Double_t *rMomPos, const Double_t *rMomNeg, Double_t *rDcaDaughterToPrimVertex){
-
+ const Double_t *rMomPos, const Double_t *rMomNeg, const Double_t *rDcaDaughterToPrimVertex){
+ //--------------------------------------------------------------------
+ // Filling with all needed info
+ //--------------------------------------------------------------------
this->SetSecondaryVtx(rAODVertex);
fDCA[0] = rDcaV0Daughters;
}
void AliAODv0::ResetV0(){
-
+ //--------------------------------------------------------------------
+ // Resetting all the info
+ //--------------------------------------------------------------------
GetSecondaryVtx()->SetChi2perNDF(999);
GetSecondaryVtx()->RemoveCovMatrix();
GetSecondaryVtx()->RemoveDaughters();
-#ifndef AliAODv0_H
-#define AliAODv0_H
+#ifndef ALIAODV0_H
+#define ALIAODV0_H
/* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
AliAODv0& operator=(const AliAODv0& rAliAODv0);
void Fill(AliAODVertex *rAODVertex, Double_t rDcaV0Daughters, Double_t rDcaV0ToPrimVertex,
- const Double_t *rMomPos, const Double_t *rMomNeg, Double_t *rDcaDaughterToPrimVertex);
+ const Double_t *rMomPos, const Double_t *rMomNeg, const Double_t *rDcaDaughterToPrimVertex);
void ResetV0();
void Print(Option_t* option = "") const;
}
inline Double_t AliAODv0::OpenAngleV0() const {
- Double_t lPtot1xPtot2 = PxProng(0)*PxProng(1)+PyProng(0)*PyProng(1)+PzProng(0)*PzProng(1);
- Double_t lPtot1Ptot2_2 = Ptot2Pos()*Ptot2Neg();
- return ::acos(lPtot1xPtot2/::sqrt(lPtot1Ptot2_2) );
+ Double_t lScalPtot1Ptot2 = PxProng(0)*PxProng(1)+PyProng(0)*PyProng(1)+PzProng(0)*PzProng(1);
+ Double_t lPtot1xPtot2 = Ptot2Pos()*Ptot2Neg();
+ return ::acos(lScalPtot1Ptot2/::sqrt(lPtot1xPtot2) );
}
inline Double_t AliAODv0::MomPosX() const {return fPx[0];}
//modified by R. Vernet 3/7/2006 : causality
//modified by I. Belikov 24/11/2006 : static setter for the default cuts
-
-#include <TObjArray.h>
-#include <TTree.h>
-
#include "AliESDEvent.h"
-#include "AliESDv0.h"
#include "AliESDcascade.h"
#include "AliCascadeVertexer.h"
-#include "AliESDtrack.h"
-#include "AliESDVertex.h"
ClassImp(AliCascadeVertexer)
}
-Double_t det(Double_t a00, Double_t a01, Double_t a10, Double_t a11){
- // determinant 2x2
+Double_t AliCascadeVertexer::Det(Double_t a00, Double_t a01, Double_t a10, Double_t a11) const {
+ //--------------------------------------------------------------------
+ // This function calculates locally a 2x2 determinant
+ //--------------------------------------------------------------------
return a00*a11 - a01*a10;
}
-Double_t det (Double_t a00,Double_t a01,Double_t a02,
- Double_t a10,Double_t a11,Double_t a12,
- Double_t a20,Double_t a21,Double_t a22) {
- // determinant 3x3
- return
- a00*det(a11,a12,a21,a22)-a01*det(a10,a12,a20,a22)+a02*det(a10,a11,a20,a21);
+Double_t AliCascadeVertexer::Det(Double_t a00,Double_t a01,Double_t a02,
+ Double_t a10,Double_t a11,Double_t a12,
+ Double_t a20,Double_t a21,Double_t a22) const {
+ //--------------------------------------------------------------------
+ // This function calculates locally a 3x3 determinant
+ //--------------------------------------------------------------------
+ return a00*Det(a11,a12,a21,a22)-a01*Det(a10,a12,a20,a22)+a02*Det(a10,a11,a20,a21);
}
-Double_t AliCascadeVertexer::
-PropagateToDCA(AliESDv0 *v, AliExternalTrackParam *t, Double_t b) {
+Double_t AliCascadeVertexer::PropagateToDCA(AliESDv0 *v, AliExternalTrackParam *t, Double_t b) {
//--------------------------------------------------------------------
// This function returns the DCA between the V0 and the track
//--------------------------------------------------------------------
// calculation dca
- Double_t dd= det(x2-x1,y2-y1,z2-z1,px1,py1,pz1,px2,py2,pz2);
- Double_t ax= det(py1,pz1,py2,pz2);
- Double_t ay=-det(px1,pz1,px2,pz2);
- Double_t az= det(px1,py1,px2,py2);
+ Double_t dd= Det(x2-x1,y2-y1,z2-z1,px1,py1,pz1,px2,py2,pz2);
+ Double_t ax= Det(py1,pz1,py2,pz2);
+ Double_t ay=-Det(px1,pz1,px2,pz2);
+ Double_t az= Det(px1,py1,px2,py2);
Double_t dca=TMath::Abs(dd)/TMath::Sqrt(ax*ax + ay*ay + az*az);
//points of the DCA
- Double_t t1 = det(x2-x1,y2-y1,z2-z1,px2,py2,pz2,ax,ay,az)/
- det(px1,py1,pz1,px2,py2,pz2,ax,ay,az);
+ Double_t t1 = Det(x2-x1,y2-y1,z2-z1,px2,py2,pz2,ax,ay,az)/
+ Det(px1,py1,pz1,px2,py2,pz2,ax,ay,az);
x1 += px1*t1; y1 += py1*t1; //z1 += pz1*t1;
#include "TObject.h"
class AliESDEvent;
-class TTree;
class AliESDv0;
class AliExternalTrackParam;
static void SetDefaultCuts(const Double_t cuts[8]);
Int_t V0sTracks2CascadeVertices(AliESDEvent *event);
+ Double_t Det(Double_t a00, Double_t a01, Double_t a10, Double_t a11) const;
+ Double_t Det(Double_t a00,Double_t a01,Double_t a02,
+ Double_t a10,Double_t a11,Double_t a12,
+ Double_t a20,Double_t a21,Double_t a22) const;
+
Double_t PropagateToDCA(AliESDv0 *vtx,AliExternalTrackParam *trk,Double_t b);
void GetCuts(Double_t cuts[8]) const;
#include <TMath.h>
#include <TVector3.h>
-#include "AliLog.h"
-#include "AliExternalTrackParam.h"
-#include "AliESDv0.h"
#include "AliESDcascade.h"
+#include "AliLog.h"
ClassImp(AliESDcascade)
TVector3 momV0(fNmom[0]+fPmom[0],fNmom[1]+fPmom[1],fNmom[2]+fPmom[2]);
TVector3 momTot(Px(),Py(),Pz());
- Double_t QlBach = momBach.Dot(momTot)/momTot.Mag();
- Double_t QlV0 = momV0.Dot(momTot)/momTot.Mag();
+ Double_t lQlBach = momBach.Dot(momTot)/momTot.Mag();
+ Double_t lQlV0 = momV0.Dot(momTot)/momTot.Mag();
- return 1.-2./(1.+QlBach/QlV0);
+ return 1.-2./(1.+lQlBach/lQlV0);
}
Double_t AliESDcascade::PtArmXi() const {
return d;
}
-Double_t AliESDcascade::GetCascadeCosineOfPointingAngle(Double_t& refPointX, Double_t& refPointY, Double_t& refPointZ) const {
+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
// and Boris Hippolyte,IPHC, hippolyt@in2p3.fr
//-------------------------------------------------------------------------
-#include <TObject.h>
-#include <TPDGCode.h>
#include "AliESDv0.h"
+class AliLog;
class AliExternalTrackParam;
-
class AliESDcascade : public AliESDv0 {
enum { kOmegaPlusBar = -3334,
public:
AliESDcascade();
- AliESDcascade(const AliESDcascade&);
+ AliESDcascade(const AliESDcascade& cas);
AliESDcascade(const AliESDv0 &v0,
const AliExternalTrackParam &t, Int_t i);
~AliESDcascade();
- AliESDcascade& operator=(const AliESDcascade&);
+ AliESDcascade& operator=(const AliESDcascade& cas);
virtual void Copy(TObject &obj) const;
// Start with AliVParticle functions
Int_t GetIndex() const {return GetBindex();} //for the consistency with V0
void SetDcaXiDaughters(Double_t rDcaXiDaughters=0.);
Double_t GetDcaXiDaughters() const {return fDcaXiDaughters;}
- Double_t GetCascadeCosineOfPointingAngle(Double_t&, Double_t&, Double_t&) const;
+ Double_t GetCascadeCosineOfPointingAngle(Double_t refPointX, Double_t refPointY, Double_t refPointZ) const;
void GetPosCovXi(Double_t cov[6]) const;
// and Boris Hippolyte,IPHC, hippolyt@in2p3.fr
//-------------------------------------------------------------------------
-#include <Riostream.h>
#include <TMath.h>
#include <TDatabasePDG.h>
-#include <TPDGCode.h>
#include <TParticlePDG.h>
#include <TVector3.h>
#include "AliLog.h"
#include "AliESDv0.h"
-#include "AliExternalTrackParam.h"
+#include "AliESDV0Params.h"
ClassImp(AliESDv0)
TVector3 momPos(fPmom[0],fPmom[1],fPmom[2]);
TVector3 momTot(Px(),Py(),Pz());
- Double_t QlNeg = momNeg.Dot(momTot)/momTot.Mag();
- Double_t QlPos = momNeg.Dot(momTot)/momTot.Mag();
+ Double_t lQlNeg = momNeg.Dot(momTot)/momTot.Mag();
+ Double_t lQlPos = momNeg.Dot(momTot)/momTot.Mag();
- return 1.-2./(1.+QlNeg/QlPos);
+ return 1.-2./(1.+lQlNeg/lQlPos);
}
Double_t AliESDv0::PtArmV0() const {
return d;
}
-
-Float_t AliESDv0::GetV0CosineOfPointingAngle(Double_t& refPointX, Double_t& refPointY, Double_t& refPointZ) const {
+Float_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
}
-Double_t AliESDv0::GetLikelihoodC(Int_t mode0, Int_t /*mode1*/){
+Double_t AliESDv0::GetLikelihoodC(Int_t mode0, Int_t /*mode1*/) const {
//
// get likelihood for Causality
// !!! Causality variables defined in AliITStrackerMI !!!
fCausality[2] = pa0; // probability - track 0 exist close after vertex
fCausality[3] = pa1; // probability - track 1 exist close after vertex
}
-void AliESDv0::SetClusters(Int_t *clp, Int_t *clm)
+void AliESDv0::SetClusters(const Int_t *clp, const Int_t *clm)
{
//
// Set its clusters indexes
for (Int_t i=0;i<6;i++) fClusters[1][i] = clm[i];
}
-Float_t AliESDv0::GetEffMass(UInt_t p1, UInt_t p2){
+Double_t AliESDv0::GetEffMass(UInt_t p1, UInt_t p2) const{
//
// calculate effective mass
//
if (p2>4) return -1;
Float_t mass1 = kpmass[p1];
Float_t mass2 = kpmass[p2];
- Double_t *m1 = fPmom;
- Double_t *m2 = fNmom;
+ const Double_t *m1 = fPmom;
+ const Double_t *m2 = fNmom;
//
//if (fRP[p1]+fRM[p2]<fRP[p2]+fRM[p1]){
// m1 = fPM;
// and Boris Hippolyte,IPHC, hippolyt@in2p3.fr
//-------------------------------------------------------------------------
-#include <TObject.h>
#include <TPDGCode.h>
-#include "AliESDV0Params.h"
+
#include "AliExternalTrackParam.h"
#include "AliVParticle.h"
+class AliESDV0Params;
+
class AliESDv0 : public AliVParticle {
public:
AliESDv0();
AliESDv0(const AliExternalTrackParam &t1, Int_t i1,
const AliExternalTrackParam &t2, Int_t i2);
- AliESDv0(const AliESDv0&);
+ AliESDv0(const AliESDv0& v0);
virtual ~AliESDv0();
- AliESDv0& operator=(const AliESDv0&);
+ AliESDv0& operator=(const AliESDv0& v0);
virtual void Copy(TObject &obj) const;
// Start with AliVParticle functions
Double_t ChangeMassHypothesis(Int_t code=kK0Short);
Int_t GetPdgCode() const {return fPdgCode;}
- Float_t GetEffMass(UInt_t p1, UInt_t p2);
+ Double_t GetEffMass(UInt_t p1, UInt_t p2) const;
Double_t GetEffMass() const {return fEffMass;}
Double_t GetChi2V0() const {return fChi2V0;}
void GetPxPyPz(Double_t &px, Double_t &py, Double_t &pz) const;
Int_t GetNindex() const {return fNidx;}
Int_t GetPindex() const {return fPidx;}
void SetDcaV0Daughters(Double_t rDcaV0Daughters=0.);
- Double_t GetDcaV0Daughters() {return fDcaV0Daughters;}
- Float_t GetV0CosineOfPointingAngle(Double_t&, Double_t&, Double_t&) const;
- Double_t GetV0CosineOfPointingAngle() const {return fPointAngle;}
+ Double_t GetDcaV0Daughters() const {return fDcaV0Daughters;}
+ Float_t GetV0CosineOfPointingAngle(Double_t refPointX, Double_t refPointY, Double_t refPointZ) const;
+ Double_t GetV0CosineOfPointingAngle() const {return fPointAngle;}
void SetV0CosineOfPointingAngle(Double_t cpa) {fPointAngle=cpa;}
void SetOnFlyStatus(Bool_t status){fOnFlyStatus=status;}
Bool_t GetOnFlyStatus() const {return fOnFlyStatus;}
Double_t GetMinimaxSigmaD0(); // calculate mini-max sigma of dca resolution
Double_t GetLikelihoodAP(Int_t mode0, Int_t mode1); // get likelihood for point angle
Double_t GetLikelihoodD(Int_t mode0, Int_t mode1); // get likelihood for DCA
- Double_t GetLikelihoodC(Int_t mode0, Int_t mode1); // get likelihood for Causality
+ Double_t GetLikelihoodC(Int_t mode0, Int_t mode1) const; // get likelihood for Causality
//
//
static const AliESDV0Params & GetParameterization(){return fgkParams;}
void SetStatus(Int_t status){fStatus=status;}
Int_t GetStatus() const {return fStatus;}
Int_t GetIndex(Int_t i) const {return (i==0) ? fNidx : fPidx;}
- void SetIndex(Int_t i, Int_t ind) {(i==0) ? (fNidx=ind) : (fPidx=ind);}
- Double_t *GetAnglep() {return fAngle;}
+ void SetIndex(Int_t i, Int_t ind);
+ const Double_t *GetAnglep() const {return fAngle;}
Double_t GetRr() const {return fRr;}
Double_t GetDistSigma() const {return fDistSigma;}
void SetDistSigma(Double_t ds) {fDistSigma=ds;}
void SetNBefore(Short_t nb) {fNBefore=nb;}
void SetCausality(Float_t pb0, Float_t pb1, Float_t pa0, Float_t pa1);
const Double_t * GetCausalityP() const {return fCausality;}
- void SetClusters(Int_t *clp, Int_t *clm);
+ void SetClusters(const Int_t *clp, const Int_t *clm);
const Int_t * GetClusters(Int_t i) const {return fClusters[i];}
void SetNormDCAPrim(Float_t nd0, Float_t nd1){fNormDCAPrim[0] = nd0; fNormDCAPrim[1]=nd1;}
const Double_t *GetNormDCAPrimP() const {return fNormDCAPrim;}
fDcaV0Daughters=rDcaV0Daughters;
}
+inline
+void AliESDv0::SetIndex(Int_t i, Int_t ind) {
+ if(i==0)
+ fNidx=ind;
+ else
+ fPidx=ind;
+}
+
#endif
//-------------------------------------------------------------------------
-#include <TObjArray.h>
-#include <TTree.h>
-
#include "AliESDEvent.h"
#include "AliESDv0.h"
-#include "AliESDtrack.h"
#include "AliV0vertexer.h"
-#include "AliESDVertex.h"
ClassImp(AliV0vertexer)