AliESDv0 and AliESDcascade are now inherited from AliVParticle (B. Hippolyte)
authorbelikov <belikov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 4 Nov 2008 14:31:49 +0000 (14:31 +0000)
committerbelikov <belikov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 4 Nov 2008 14:31:49 +0000 (14:31 +0000)
STEER/AliESDcascade.cxx
STEER/AliESDcascade.h
STEER/AliESDv0.cxx
STEER/AliESDv0.h

index 5e96cb1e066245454664d3a49a971ff98a8339ae..987b52a2c161cda0dc34c63b70077bf32046e16f 100644 (file)
@@ -190,6 +190,16 @@ void AliESDcascade::Copy(TObject &obj) const {
 
 }
 
+// Start with AliVParticle functions
+Double_t AliESDcascade::E() const {
+  //--------------------------------------------------------------------
+  // This gives the energy assuming the ChangeMassHypothesis was called
+  //--------------------------------------------------------------------
+  Double_t mass = TDatabasePDG::Instance()->GetParticle(fPdgCodeXi)->Mass();
+  return TMath::Sqrt(mass*mass+P()*P());
+}
+
+// Then the older functions
 Double_t AliESDcascade::ChangeMassHypothesis(Double_t &v0q, Int_t code) {
   //--------------------------------------------------------------------
   // This function changes the mass hypothesis for this cascade
index b3755d98f40847b14b7ff988ca4c0825388f7d21..c5f87aa764b1ac6b591f9fa4a8fb5f28c9e41a94 100644 (file)
@@ -35,6 +35,31 @@ public:
   AliESDcascade& operator=(const AliESDcascade&);
   virtual void Copy(TObject &obj) const;
 
+// Start with AliVParticle functions
+  virtual Double_t Px() const { return fNmom[0]+fPmom[0]+fBachMom[0]; }
+  virtual Double_t Py() const { return fNmom[1]+fPmom[1]+fBachMom[1]; }
+  virtual Double_t Pz() const { return fNmom[2]+fPmom[2]+fBachMom[2]; }
+  virtual Double_t Pt() const { return TMath::Sqrt(Px()*Px()+Py()*Py()); }
+  virtual Double_t P()  const { 
+     return TMath::Sqrt(Px()*Px()+Py()*Py()+Pz()*Pz()); 
+  }
+  virtual Bool_t   PxPyPz(Double_t p[3]) const { p[0] = Px(); p[1] = Py(); p[2] = Pz(); return kTRUE; }
+  virtual Double_t Xv() const { return fPosXi[0]; }
+  virtual Double_t Yv() const { return fPosXi[1]; }
+  virtual Double_t Zv() const { return fPosXi[2]; }
+  virtual Bool_t   XvYvZv(Double_t x[3]) const { x[0] = Xv(); x[1] = Yv(); x[2] = Zv(); return kTRUE; }
+  virtual Double_t OneOverPt() const { return (Pt() != 0.) ? 1./Pt() : -999.; }
+  virtual Double_t Phi() const {return TMath::Pi()+TMath::ATan2(-Py(),-Px()); }
+  virtual Double_t Theta() const {return 0.5*TMath::Pi()-TMath::ATan(Pz()/(Pt()+1.e-13)); }
+  virtual Double_t E() const; // default is Xis but can be changed via ChangeMassHypothesis (defined in the .cxx)
+  virtual Double_t M() const { return GetEffMassXi(); }
+  virtual Double_t Eta() const { return 0.5*TMath::Log((P()+Pz())/(P()-Pz()+1.e-13)); }
+  virtual Double_t Y() const { return 0.5*TMath::Log((E()+Pz())/(E()-Pz()+1.e-13)); }
+  virtual Short_t  Charge() const { return 0; }
+  virtual Int_t    GetLabel() const { return -1; }  // temporary
+  virtual const Double_t *PID() const { return 0; } // return PID object ? (to be discussed!)
+
+  // Then the older functions
   Double_t ChangeMassHypothesis(Double_t &v0q, Int_t code=kXiMinus); 
 
   Int_t    GetPdgCodeXi() const {return fPdgCodeXi;}
@@ -49,8 +74,8 @@ public:
   }
 
   Int_t    GetBindex() const {return fBachIdx;}
-  void     SetIndex(Int_t i) {fBachIdx=i;}        //for the consistensy with V0
-  Int_t    GetIndex() const {return GetBindex();} //for the consistensy with V0
+  void     SetIndex(Int_t i) {fBachIdx=i;}        //for the consistency with V0
+  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;
index 62b6c677f16de9e9c661d33129d2123c4e43ef9d..3609b54f812249c3acf0b8eaeac0c735bd245330 100644 (file)
@@ -40,7 +40,7 @@ ClassImp(AliESDv0)
 const AliESDV0Params  AliESDv0::fgkParams;
 
 AliESDv0::AliESDv0() :
-  TObject(),
+  AliVParticle(),
   fParamN(),
   fParamP(),
   fEffMass(TDatabasePDG::Instance()->GetParticle(kK0Short)->Mass()),
@@ -82,7 +82,7 @@ AliESDv0::AliESDv0() :
 }
 
 AliESDv0::AliESDv0(const AliESDv0& v0) :
-  TObject(v0),
+  AliVParticle(v0),
   fParamN(v0.fParamN),
   fParamP(v0.fParamP),
   fEffMass(v0.fEffMass),
@@ -132,7 +132,7 @@ AliESDv0::AliESDv0(const AliESDv0& v0) :
 
 AliESDv0::AliESDv0(const AliExternalTrackParam &t1, Int_t i1,
                    const AliExternalTrackParam &t2, Int_t i2) :
-  TObject(),
+  AliVParticle(),
   fParamN(t1),
   fParamP(t2),
   fEffMass(TDatabasePDG::Instance()->GetParticle(kK0Short)->Mass()),
@@ -203,7 +203,7 @@ AliESDv0& AliESDv0::operator=(const AliESDv0 &v0){
   //--------------------------------------------------------------------
 
   if(this==&v0)return *this;
-  TObject::operator=(v0);
+  AliVParticle::operator=(v0);
   fParamN  = v0.fParamN;
   fParamP  = v0.fParamP;
   fEffMass = v0.fEffMass;
@@ -266,8 +266,16 @@ AliESDv0::~AliESDv0(){
   //--------------------------------------------------------------------
 }
 
+// Start with AliVParticle functions
+Double_t AliESDv0::E() const {
+  //--------------------------------------------------------------------
+  // This gives the energy assuming the ChangeMassHypothesis was called
+  //--------------------------------------------------------------------
+  Double_t mass = TDatabasePDG::Instance()->GetParticle(fPdgCode)->Mass();
+  return TMath::Sqrt(mass*mass+P()*P());
+}
 
-
+// Then the older functions
 Double_t AliESDv0::ChangeMassHypothesis(Int_t code) {
   //--------------------------------------------------------------------
   // This function changes the mass hypothesis for this V0
index 0ae196dffb89876d8ad582fa3e91e256bbde306d..ff471e88b44fe9339d93bfb92c55ec2d06ddc808 100644 (file)
@@ -18,8 +18,9 @@
 #include <TPDGCode.h>
 #include "AliESDV0Params.h"
 #include "AliExternalTrackParam.h"
+#include "AliVParticle.h"
 
-class AliESDv0 : public TObject {
+class AliESDv0 : public AliVParticle {
 public:
   AliESDv0();
   AliESDv0(const AliExternalTrackParam &t1, Int_t i1,
@@ -30,6 +31,31 @@ public:
   AliESDv0& operator=(const AliESDv0&);
   virtual void Copy(TObject &obj) const;
 
+// Start with AliVParticle functions
+  virtual Double_t Px() const { return fNmom[0]+fPmom[0]; }
+  virtual Double_t Py() const { return fNmom[1]+fPmom[1]; }
+  virtual Double_t Pz() const { return fNmom[2]+fPmom[2]; }
+  virtual Double_t Pt() const { return TMath::Sqrt(Px()*Px()+Py()*Py()); }
+  virtual Double_t P()  const { 
+     return TMath::Sqrt(Px()*Px()+Py()*Py()+Pz()*Pz()); 
+  }
+  virtual Bool_t   PxPyPz(Double_t p[3]) const { p[0] = Px(); p[1] = Py(); p[2] = Pz(); return kTRUE; }
+  virtual Double_t Xv() const { return fPos[0]; }
+  virtual Double_t Yv() const { return fPos[1]; }
+  virtual Double_t Zv() const { return fPos[2]; }
+  virtual Bool_t   XvYvZv(Double_t x[3]) const { x[0] = Xv(); x[1] = Yv(); x[2] = Zv(); return kTRUE; }
+  virtual Double_t OneOverPt() const { return (Pt() != 0.) ? 1./Pt() : -999.; }
+  virtual Double_t Phi() const {return TMath::Pi()+TMath::ATan2(-Py(),-Px()); }
+  virtual Double_t Theta() const {return 0.5*TMath::Pi()-TMath::ATan(Pz()/(Pt()+1.e-13)); }
+  virtual Double_t E() const; // default is KOs but can be changed via ChangeMassHypothesis (defined in the .cxx)
+  virtual Double_t M() const { return GetEffMass(); }
+  virtual Double_t Eta() const { return 0.5*TMath::Log((P()+Pz())/(P()-Pz()+1.e-13)); }
+  virtual Double_t Y() const { return 0.5*TMath::Log((E()+Pz())/(E()-Pz()+1.e-13)); }
+  virtual Short_t  Charge() const { return 0; }
+  virtual Int_t    GetLabel() const { return -1; }  // temporary
+  virtual const Double_t *PID() const { return 0; } // return PID object ? (to be discussed!)
+
+  // Then the older functions
   Double_t ChangeMassHypothesis(Int_t code=kK0Short); 
 
   Int_t    GetPdgCode() const {return fPdgCode;}
@@ -110,7 +136,7 @@ protected:
   Double32_t   fPosCov[6];      // covariance matrix of the vertex position
   Double32_t   fNmom[3];        // momentum of the negative daughter (global)
   Double32_t   fPmom[3];        // momentum of the positive daughter (global)
-  Double32_t   fNormDCAPrim[2];  // normalize distance to the priary vertex CKBrev
+  Double32_t   fNormDCAPrim[2];  // normalize distance to the primary vertex CKBrev
   Double32_t   fRr;         //rec position of the vertex CKBrev
   Double32_t   fDistSigma; //sigma of distance CKBrev
   Double32_t        fChi2Before;   //chi2 of the tracks before V0 CKBrev