Fixing the coding conventions (B. Hippolyte).
authorbelikov <belikov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 4 Dec 2008 14:00:18 +0000 (14:00 +0000)
committerbelikov <belikov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 4 Dec 2008 14:00:18 +0000 (14:00 +0000)
STEER/AliAODcascade.cxx
STEER/AliAODcascade.h
STEER/AliAODv0.cxx
STEER/AliAODv0.h
STEER/AliCascadeVertexer.cxx
STEER/AliCascadeVertexer.h
STEER/AliESDcascade.cxx
STEER/AliESDcascade.h
STEER/AliESDv0.cxx
STEER/AliESDv0.h
STEER/AliV0vertexer.cxx

index f283dd5..6128e17 100644 (file)
 //     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(),
      
@@ -172,9 +168,7 @@ AliAODcascade::~AliAODcascade(){
   //--------------------------------------------------------------------
 }
 
-
-
-void  AliAODcascade::Fill( AliAODVertex* rAODVertexXi, 
+void  AliAODcascade::Fill(AliAODVertex* rAODVertexXi, 
                       Int_t         rChargeXi,
                      Double_t      rDcaXiDaughters,
                      Double_t      rDcaXiToPrimVertex,
@@ -239,6 +233,9 @@ void AliAODcascade::PrintXi(const Double_t& rPrimVtxX,
                             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() );
@@ -286,14 +283,14 @@ Double_t AliAODcascade::CosPointingAngleXi(const Double_t& rPrimVtxX,
   // 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); 
 
 }
 
@@ -325,5 +322,22 @@ Int_t      AliAODcascade::GetBachID()  const     {
        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);
+}
index 92f3e5a..016c520 100644 (file)
 //     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:
@@ -62,7 +54,7 @@ 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,
@@ -100,7 +92,6 @@ public:
   Double_t DecayVertexXiY()          const;
   Double_t DecayVertexXiZ()          const;
   Double_t Chi2Xi()                  const;
-  
     
   Double_t DcaBachToPrimVertex() const;
   Double_t DcaXiDaughters()          const;
@@ -112,13 +103,11 @@ public:
                               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;
@@ -144,7 +133,6 @@ public:
   Double_t RapXi()          const;
   Double_t RapOmega()       const;
 
-
 protected:
 
   TRef          fDecayVertexXi;           // ref to decay vertex of the cascade (Xi vertex)
@@ -157,18 +145,12 @@ protected:
   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(); }
@@ -178,15 +160,10 @@ inline Double_t AliAODcascade::DecayVertexXiZ() const {return GetDecayVertexXi()
 
 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) +
@@ -201,11 +178,6 @@ inline Double_t AliAODcascade::DecayLengthXi(const Double_t& rPrimVtxX,
                ::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;}
@@ -252,22 +224,6 @@ inline Double_t AliAODcascade::PtArmXi() const {
   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());
 }
index 3926ad7..78e3eb4 100644 (file)
@@ -117,8 +117,10 @@ AliAODv0::~AliAODv0(){
 }
 
 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;
@@ -137,7 +139,9 @@ void AliAODv0::Fill(AliAODVertex *rAODVertex, Double_t rDcaV0Daughters, Double_t
 }
 
 void AliAODv0::ResetV0(){
-
+  //--------------------------------------------------------------------
+  // Resetting all the info
+  //--------------------------------------------------------------------
   GetSecondaryVtx()->SetChi2perNDF(999);
   GetSecondaryVtx()->RemoveCovMatrix();
   GetSecondaryVtx()->RemoveDaughters();
index 1b45d4d..ce508ab 100644 (file)
@@ -1,5 +1,5 @@
-#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                               */
 
@@ -24,7 +24,7 @@ public:
   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;
 
@@ -111,9 +111,9 @@ inline Double_t AliAODv0::RadiusV0() 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];}
index 60a2802..10484cb 100644 (file)
 //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)
 
@@ -193,24 +186,26 @@ Info("V0sTracks2CascadeVertices","Number of reconstructed cascades: %d",ncasc);
 }
 
 
-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
   //--------------------------------------------------------------------
@@ -228,16 +223,16 @@ PropagateToDCA(AliESDv0 *v, AliExternalTrackParam *t, Double_t b) {
  
 // 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;
   
index 2ba43cf..8df3487 100644 (file)
@@ -12,7 +12,6 @@
 #include "TObject.h"
 
 class AliESDEvent;
-class TTree;
 class AliESDv0;
 class AliExternalTrackParam;
 
@@ -24,6 +23,11 @@ public:
   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;
index 61b67c0..4b4bb8c 100644 (file)
 #include <TMath.h>
 #include <TVector3.h>
 
-#include "AliLog.h"
-#include "AliExternalTrackParam.h"
-#include "AliESDv0.h"
 #include "AliESDcascade.h"
+#include "AliLog.h"
 
 ClassImp(AliESDcascade)
 
@@ -253,10 +251,10 @@ Double_t AliESDcascade::AlphaXi() const {
   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 {
@@ -388,7 +386,7 @@ Double_t AliESDcascade::GetDcascade(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 {
+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
index 667408f..ac32cea 100644 (file)
 //            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,
@@ -30,11 +28,11 @@ class AliESDcascade : public AliESDv0 {
 
 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
@@ -90,7 +88,7 @@ public:
   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;
 
index eca5482..f038831 100644 (file)
 //            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)
 
@@ -319,10 +317,10 @@ Double_t AliESDv0::AlphaV0() const {
   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 {
@@ -425,8 +423,7 @@ Float_t AliESDv0::GetD(Double_t x0, Double_t y0, Double_t z0) 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
@@ -641,7 +638,7 @@ Double_t AliESDv0::GetLikelihoodD(Int_t mode0, Int_t mode1){
 
 }
 
-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 !!! 
@@ -676,7 +673,7 @@ void AliESDv0::SetCausality(Float_t pb0, Float_t pb1, Float_t pa0, Float_t pa1)
   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
@@ -685,7 +682,7 @@ void  AliESDv0::SetClusters(Int_t *clp, Int_t *clm)
   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
   //
@@ -695,8 +692,8 @@ Float_t AliESDv0::GetEffMass(UInt_t p1, UInt_t p2){
   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;
index ac5a36f..a41be80 100644 (file)
 //            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
@@ -69,7 +70,7 @@ public:
   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;
@@ -80,9 +81,9 @@ public:
   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;}
@@ -104,7 +105,7 @@ public:
   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;}
@@ -113,8 +114,8 @@ public:
   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;}
@@ -128,7 +129,7 @@ public:
   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;}
@@ -198,4 +199,12 @@ void AliESDv0::SetDcaV0Daughters(Double_t rDcaV0Daughters){
   fDcaV0Daughters=rDcaV0Daughters;
 }
 
+inline 
+void AliESDv0::SetIndex(Int_t i, Int_t ind) {
+  if(i==0)
+    fNidx=ind;
+  else
+    fPidx=ind;
+}
+
 #endif
index 1e00e1a..43e9cc2 100644 (file)
 //-------------------------------------------------------------------------
 
 
-#include <TObjArray.h>
-#include <TTree.h>
-
 #include "AliESDEvent.h"
 #include "AliESDv0.h"
-#include "AliESDtrack.h"
 #include "AliV0vertexer.h"
-#include "AliESDVertex.h"
 
 ClassImp(AliV0vertexer)