Coding convention (F.Carminati)

diff --git a/ITS/AliITStrackerMI.cxx b/ITS/AliITStrackerMI.cxx
index 5c586105e1767d5c6648c0f057932d587daa3600..542c3efac1872ec197b9936dd8876698d9ee4f74 100644 (file)
--- a/ITS/AliITStrackerMI.cxx
+++ b/ITS/AliITStrackerMI.cxx
@@ -21,17 +21,19 @@
 //     dEdx analysis by: Boris Batyunya, JINR, Boris.Batiounia@cern.ch
 //     
 //-------------------------------------------------------------------------
-#include "AliITSrecoV2.h"
+
+#include <TFile.h>
+#include <TMatrixD.h>
 #include <TTree.h>
-#include "AliITSgeom.h"
+
+
 #include "AliESD.h"
+#include "AliESDV0MI.h"
+#include "AliHelix.h"
 #include "AliITSclusterV2.h"
+#include "AliITSgeom.h"
+#include "AliITSrecoV2.h"
 #include "AliITStrackerMI.h"
-#include "TMatrixD.h"
-#include "TFile.h"
-#include "TTree.h"
-#include "AliHelix.h"
-#include "AliESDV0MI.h"
 
 
 ClassImp(AliITStrackerMI)
@@ -3075,79 +3077,79 @@ void  AliITStrackerMI::FindV0(AliESD *event)
       //
       if (distance>0.3*(dist[itrack1]+dist[itrack0])) continue;
       //if (distance>0.2*dist[itrack0]) continue;
-      if (pvertex->fRr<0.3*(dist[itrack1]+dist[itrack0])) continue;
-      if (pvertex->fRr>27) continue;
+      if (pvertex->GetRr()<0.3*(dist[itrack1]+dist[itrack0])) continue;
+      if (pvertex->GetRr()>27) continue;
       pvertex->SetM(*track0);
       pvertex->SetP(*track1);
       pvertex->Update(primvertex);
       //
       //
-      if (pvertex->fPointAngle<0.85) continue;       
+      if (pvertex->GetPointAngle()<0.85) continue;           
       //
       //
-      pvertex->fLab[0]=track0->GetLabel();
-      pvertex->fLab[1]=track1->GetLabel();
-      pvertex->fIndex[0] = track0->GetESDtrack()->GetID();
-      pvertex->fIndex[1] = track1->GetESDtrack()->GetID();
+      pvertex->SetLab(0,track0->GetLabel());
+      pvertex->SetLab(1,track1->GetLabel());
+      pvertex->SetIndex(0,track0->GetESDtrack()->GetID());
+      pvertex->SetIndex(1,track1->GetESDtrack()->GetID());
       // calculate chi2s
       //
-      pvertex->fChi2After  = 0;
-      pvertex->fChi2Before = 0;
-      pvertex->fNBefore=0;
-      pvertex->fNAfter=0;
+      pvertex->SetChi2After(0);
+      pvertex->SetChi2Before(0);
+      pvertex->SetNBefore(0);
+      pvertex->SetNAfter(0);
       
       for (Int_t i=0;i<6;i++){
        Float_t radius = fgLayers[i].GetR();
-       if (pvertex->fRr>radius+0.5){
-         pvertex->fNBefore+=2.;
+       if (pvertex->GetRr()>radius+0.5){
+         pvertex->SetNBefore(pvertex->GetNBefore()+2.);
          //
          if (track0->fClIndex[i]<=0) {
-           pvertex->fChi2Before+=9;
+           pvertex->SetChi2Before(pvertex->GetChi2Before()+9);
          }else{
            Float_t chi2 = track0->fDy[i]*track0->fDy[i]/(track0->fSigmaY[i]*track0->fSigmaY[i])+
              track0->fDz[i]*track0->fDz[i]/(track0->fSigmaZ[i]*track0->fSigmaZ[i]);
-             pvertex->fChi2Before+=chi2;
+             pvertex->SetChi2Before(pvertex->GetChi2Before()+chi2);
          }
 
          if (track1->fClIndex[i]<=0) {
-           pvertex->fChi2Before+=9;
+           pvertex->SetChi2Before(pvertex->GetChi2Before()+9);
          }else{
            Float_t chi2 = track1->fDy[i]*track1->fDy[i]/(track1->fSigmaY[i]*track1->fSigmaY[i])+
              track1->fDz[i]*track1->fDz[i]/(track1->fSigmaZ[i]*track1->fSigmaZ[i]);
-             pvertex->fChi2Before+=chi2;
+             pvertex->SetChi2Before(pvertex->GetChi2Before()+chi2);
          }
        }
 
-       if (pvertex->fRr<radius-0.5){
-         pvertex->fNAfter+=2.;
+       if (pvertex->GetRr()<radius-0.5){
+         pvertex->SetNAfter(pvertex->GetNAfter()+2.);
          //
          if (track0->fClIndex[i]<=0) {
-           pvertex->fChi2After+=9;
+           pvertex->SetChi2After(pvertex->GetChi2After()+9);
          }else{
            Float_t chi2 = track0->fDy[i]*track0->fDy[i]/(track0->fSigmaY[i]*track0->fSigmaY[i])+
              track0->fDz[i]*track0->fDz[i]/(track0->fSigmaZ[i]*track0->fSigmaZ[i]);
-             pvertex->fChi2After+=chi2;
+             pvertex->SetChi2After(pvertex->GetChi2After()+chi2);
          }
 
          if (track1->fClIndex[i]<=0) {
-           pvertex->fChi2After+=9;
+           pvertex->SetChi2After(pvertex->GetChi2After()+9);
          }else{
            Float_t chi2 = track1->fDy[i]*track1->fDy[i]/(track1->fSigmaY[i]*track1->fSigmaY[i])+
              track1->fDz[i]*track1->fDz[i]/(track1->fSigmaZ[i]*track1->fSigmaZ[i]);
-             pvertex->fChi2After+=chi2;
+             pvertex->SetChi2After(pvertex->GetChi2After()+chi2);
          }
        }
       }
-      if (pvertex->fNBefore>2){
-       if (pvertex->fChi2Before/pvertex->fNBefore<4.) continue; //have clusters before vetex
+      if (pvertex->GetNBefore()>2){
+       if (pvertex->GetChi2Before()/pvertex->GetNBefore()<4.) continue; //have clusters before vetex
       }
       distance = FindBestPair(itrack0,itrack1,pvertex);
-      if (pvertex->fPointAngle<0.85) continue; 
+      if (pvertex->GetPointAngle()<0.85) continue;     
       //
       if (distance>0.3) continue;
-      //      if (pvertex->fDistSigma*6>pvertex->fRr) continue;
-      // if (pvertex->fDistSigma>0.4) continue;
-      //if (pvertex->fDistNorm>5.5) continue;
+      //      if (pvertex->GetDistSigma()*6>pvertex->GetRr()) continue;
+      // if (pvertex->GetDistSigma()>0.4) continue;
+      //if (pvertex->GetDistNorm()>5.5) continue;
       new (&oldvertexarray[vertexall]) AliV0vertex(*track0,*track1) ;
       vertexes++;
       vertexall++;
@@ -3161,27 +3163,27 @@ void  AliITStrackerMI::FindV0(AliESD *event)
   Int_t   indexes[10000];
   Int_t   trackvertices[30000];
   for (Int_t i=0;i<entries;i++) trackvertices[i]=0;
-  for (Int_t i=0;i<vertexall;i++) quality[i] = 1.-vertexarray[i].fPointAngle;
+  for (Int_t i=0;i<vertexall;i++) quality[i] = 1.-vertexarray[i].GetPointAngle();
   TMath::Sort(vertexall,quality,indexes,kFALSE);
   
   for (Int_t i=0;i<vertexall;i++){
     pvertex= &vertexarray[indexes[i]];
-    Int_t index0 = vertexarray[indexes[i]].fIndex[0];
-    Int_t index1 = vertexarray[indexes[i]].fIndex[1];
-    vertexarray[indexes[i]].fOrder[2] = i;
-    vertexarray[indexes[i]].fOrder[1] = trackvertices[index1];
-    vertexarray[indexes[i]].fOrder[0] = trackvertices[index0];
+    Int_t index0 = vertexarray[indexes[i]].GetIndex(0);
+    Int_t index1 = vertexarray[indexes[i]].GetIndex(1);
+    vertexarray[indexes[i]].SetOrder(2,i);
+    vertexarray[indexes[i]].SetOrder(1,trackvertices[index1]);
+    vertexarray[indexes[i]].SetOrder(0,trackvertices[index0]);
     if (trackvertices[index1]+trackvertices[index0]>2) continue;
     if (trackvertices[index1]+trackvertices[index0]>0) {
-      //      if (pvertex->fPointAngle<0.995)  continue;
+      //      if (pvertex->GetPointAngle()<0.995)  continue;
     }
     trackvertices[index0]++;
     trackvertices[index1]++;
     
     //    event->AddV0(&oldvertexarray[indexes[i]]);
     Int_t v0index = event->AddV0MI(&vertexarray[indexes[i]]);
-    AliESDtrack * ptrack0 = event->GetTrack(vertexarray[indexes[i]].fIndex[0]);
-    AliESDtrack * ptrack1 = event->GetTrack(vertexarray[indexes[i]].fIndex[1]);
+    AliESDtrack * ptrack0 = event->GetTrack(vertexarray[indexes[i]].GetIndex(0));
+    AliESDtrack * ptrack1 = event->GetTrack(vertexarray[indexes[i]].GetIndex(1));
     if (!ptrack0 || !ptrack1){
       printf("BBBBBBBUUUUUUUUUUGGGGGGGGGG\n");
     }
@@ -3221,7 +3223,7 @@ Double_t  AliITStrackerMI::FindBestPair(Int_t esdtrack0, Int_t esdtrack1, AliESD
   //
   //
   //AliESDV0MI v0;
-  Double_t criticalradius = vertex->fRr;
+  Double_t criticalradius = vertex->GetRr();
   //
   AliITStrackMI * track0= (AliITStrackMI*)array0->At(fBestTrackIndex[esdtrack0]);
   AliITStrackMI * track1= (AliITStrackMI*)array1->At(fBestTrackIndex[esdtrack1]);
@@ -3247,8 +3249,8 @@ Double_t  AliITStrackerMI::FindBestPair(Int_t esdtrack0, Int_t esdtrack1, AliESD
     }
   }
   //propagate to vertex
-  Double_t alpha = TMath::ATan2(vertex->fXr[1],vertex->fXr[0]);
-  Double_t radius =TMath::Sqrt(vertex->fXr[1]*vertex->fXr[1]+vertex->fXr[0]*vertex->fXr[0]);
+  Double_t alpha = TMath::ATan2(vertex->GetXr(1),vertex->GetXr(0));
+  Double_t radius =TMath::Sqrt(vertex->GetXr(1)*vertex->GetXr(1)+vertex->GetXr(0)*vertex->GetXr(0));
   AliITStrackMI track0p = *track0;
   AliITStrackMI track1p = *track1;
   if (!track0p.Propagate(alpha,radius)) return 100000;
@@ -3270,8 +3272,8 @@ Double_t  AliITStrackerMI::FindBestPair(Int_t esdtrack0, Int_t esdtrack1, AliESD
   vertex->SetP(*track1);
   vertex->Update(v);
   Float_t sigma = TMath::Sqrt(track1p.GetSigmaY2()+track1p.GetSigmaZ2()+track0p.GetSigmaY2()+track0p.GetSigmaZ2());
-  vertex->fDistNorm = distance/sigma;
-  vertex->fDistSigma = sigma;
+  vertex->SetDistNorm(distance/sigma);
+  vertex->SetDistSigma(sigma);
   return distance;
 }
 
@@ -3306,7 +3308,7 @@ Double_t   AliITStrackerMI::TestV0(AliHelix *helix1, AliHelix *helix2, AliESDV0M
     dhelix1.LinearDCA(mhelix,phase[1][0],phase[1][1],radius[1],delta2);
   }
   distance1 = TMath::Min(delta1,delta2);
-  vertex->fDist1 = TMath::Sqrt(distance1);
+  vertex->SetDist1(TMath::Sqrt(distance1));
   //
   //find intersection parabolic
   //
@@ -3321,27 +3323,27 @@ Double_t   AliITStrackerMI::TestV0(AliHelix *helix1, AliHelix *helix2, AliESDV0M
   }
   
   distance2 = TMath::Min(delta1,delta2);
-  vertex->fDist2 = TMath::Sqrt(distance2);      
+  vertex->SetDist2(TMath::Sqrt(distance2));      
   if (distance2<100){
     if (delta1<delta2){
       //get V0 info
-      dhelix1.Evaluate(phase[0][0],vertex->fXr);
-      dhelix1.GetMomentum(phase[0][0],vertex->fPP);
-      mhelix.GetMomentum(phase[0][1],vertex->fPM);
-      dhelix1.GetAngle(phase[0][0],mhelix,phase[0][1],vertex->fAngle);
-       vertex->fRr = TMath::Sqrt(radius[0]);
+      dhelix1.Evaluate(phase[0][0],vertex->GetXrp());
+      dhelix1.GetMomentum(phase[0][0],vertex->GetPPp());
+      mhelix.GetMomentum(phase[0][1],vertex->GetPMp());
+      dhelix1.GetAngle(phase[0][0],mhelix,phase[0][1],vertex->GetAnglep());
+       vertex->SetRr(TMath::Sqrt(radius[0]));
     }
     else{
-      dhelix1.Evaluate(phase[1][0],vertex->fXr);
-      dhelix1.GetMomentum(phase[1][0],vertex->fPP);
-      mhelix.GetMomentum(phase[1][1],vertex->fPM);
-      dhelix1.GetAngle(phase[1][0],mhelix,phase[1][1],vertex->fAngle);
-      vertex->fRr = TMath::Sqrt(radius[1]);
+      dhelix1.Evaluate(phase[1][0],vertex->GetXrp());
+      dhelix1.GetMomentum(phase[1][0],vertex->GetPPp());
+      mhelix.GetMomentum(phase[1][1],vertex->GetPMp());
+      dhelix1.GetAngle(phase[1][0],mhelix,phase[1][1],vertex->GetAnglep());
+      vertex->SetRr(TMath::Sqrt(radius[1]));
     }
   }
   //            
   //
-  return  vertex->fDist2;
+  return  vertex->GetDist2();
 }
 
 

diff --git a/STEER/AliESD.cxx b/STEER/AliESD.cxx
index 55230c579cda5c820c15d00b2873abe6e7d0c644..b6a64982ce1d8961ed6cb97ab7d368aa30c7aa7c 100644 (file)
--- a/STEER/AliESD.cxx
+++ b/STEER/AliESD.cxx
@@ -79,8 +79,8 @@ void AliESD::UpdateV0PIDs()
   Int_t nV0 = GetNumberOfV0MIs();
   for (Int_t i=0;i<nV0;i++){
     AliESDV0MI * v0 = GetV0MI(i);
-    AliESDtrack* tp = GetTrack(v0->fIndex[0]);
-    AliESDtrack* tm = GetTrack(v0->fIndex[1]);
+    AliESDtrack* tp = GetTrack(v0->GetIndex(0));
+    AliESDtrack* tm = GetTrack(v0->GetIndex(1));
     if (!tm || !tp){
       printf("BBBUUUUUUUGGGG\n");
     }

diff --git a/STEER/AliESDV0MI.cxx b/STEER/AliESDV0MI.cxx
index 68dd82d6793cc781438873bdb55bb73fc58dab19..df825985608c1a1d214c56422afb6ee4d189b25c 100644 (file)
--- a/STEER/AliESDV0MI.cxx
+++ b/STEER/AliESDV0MI.cxx
@@ -21,7 +21,7 @@
 
 #include <Riostream.h>
 #include <TMath.h>
-#include <TPDGCode.h>
+
 #include "AliESDV0MI.h"
 #include "AliHelix.h"
 
@@ -87,12 +87,12 @@ Float_t AliESDV0MI::GetEffMass(UInt_t p1, UInt_t p2){
   //
   // calculate effective mass
   //
-  const Float_t pmass[5] = {5.10000000000000037e-04,1.05660000000000004e-01,1.39570000000000000e-01,
+  const Float_t kpmass[5] = {5.10000000000000037e-04,1.05660000000000004e-01,1.39570000000000000e-01,
                      4.93599999999999983e-01, 9.38270000000000048e-01};
   if (p1>4) return -1;
   if (p2>4) return -1;
-  Float_t mass1 = pmass[p1]; 
-  Float_t mass2 = pmass[p2];   
+  Float_t mass1 = kpmass[p1]; 
+  Float_t mass2 = kpmass[p2];   
   Double_t *m1 = fPP;
   Double_t *m2 = fPM;
   //

diff --git a/STEER/AliESDV0MI.h b/STEER/AliESDV0MI.h
index c7d731acde7ddca96a41e895f501ee64a4fe8093..741ed5b9bbcb55ba040f6627d2ad789341c4cf38 100644 (file)
--- a/STEER/AliESDV0MI.h
+++ b/STEER/AliESDV0MI.h
@@ -12,9 +12,8 @@
 //    Origin: Marian Ivanov marian.ivanov@cern.ch
 //-------------------------------------------------------------------------
 
-#include <AliESDv0.h>
+#include "AliESDv0.h"
 #include "AliExternalTrackParam.h"
-#include <TPDGCode.h>
 
 class AliESDtrack;
 
@@ -29,7 +28,37 @@ public:
   Float_t GetProb(UInt_t p1, UInt_t p2);
   void Update(Float_t vertex[3]);            //update
   void SetID(Int_t id){fID =id;}
-  Int_t GetID(){ return fID;}
+  Int_t GetID() const { return fID;}
+  Int_t GetIndex(Int_t i) const {return fIndex[i];}
+  void SetIndex(Int_t i, Int_t ind) {fIndex[i]=ind;}
+  void SetDist1(Double_t d1) {fDist1=d1;}
+  void SetDist2(Double_t d2) {fDist2=d2;}
+  Double_t GetDist1() const {return fDist1;}
+  Double_t GetDist2() const {return fDist2;}
+  Double_t *GetAnglep() {return fAngle;}
+  Double_t GetRr() const {return fRr;}
+  void SetRr(Double_t rr) {fRr=rr;}
+  Double_t *GetPMp() {return fPM;}
+  Double_t *GetPPp() {return fPP;}
+  Double_t *GetXrp() {return fXr;}
+  Double_t GetXr(Int_t i) const {return fXr[i];}
+  Double_t GetDistSigma() const {return fDistSigma;}
+  void SetDistSigma(Double_t ds) {fDistSigma=ds;}
+  Double_t GetDistNorm() const {return fDistNorm;}
+  void SetDistNorm(Double_t ds) {fDistNorm=ds;}
+  Float_t GetChi2Before() const {return fChi2Before;}
+  void SetChi2Before(Float_t cb) {fChi2Before=cb;}
+  Float_t GetChi2After() const {return fChi2After;}
+  void SetChi2After(Float_t ca) {fChi2After=ca;}
+  Float_t GetPointAngle() const {return fPointAngle;}
+  void SetOrder(Int_t i, Int_t ord) {fOrder[i]=ord;}
+  Float_t GetNAfter() const {return fNAfter;}
+  void SetNAfter(Float_t na) {fNAfter=na;}
+  Float_t GetNBefore() const {return fNBefore;}
+  void SetNBefore(Float_t nb) {fNBefore=nb;}  
+  void SetLab(Int_t i, Int_t lab) {fLab[i]=lab;}
+
+private:
   AliExternalTrackParam fParamP;
   AliExternalTrackParam fParamM;
   Float_t        fRP[5];         // combined pid positive