Coding conventions, additional comments, code clean-up (Yu.Belikov)

diff --git a/ITS/AliCascadeVertexer.cxx b/ITS/AliCascadeVertexer.cxx
index 2eede113605286e7b40267ac7e7185304fbe265c..e808bbdd7e03d0ef59ca86d54e94d66b4ae513f3 100644 (file)
--- a/ITS/AliCascadeVertexer.cxx
+++ b/ITS/AliCascadeVertexer.cxx
@@ -15,7 +15,8 @@
 
 //-------------------------------------------------------------------------
 //               Implementation of the cascade vertexer class
-//
+//          Reads V0s and tracks, writes out cascade vertices
+//                     Fills the ESD with the cascades 
 //    Origin: Christian Kuhn, IReS, Strasbourg, christian.kuhn@ires.in2p3.fr
 //-------------------------------------------------------------------------
 #include <TObjArray.h>
@@ -23,7 +24,6 @@
 
 #include "AliESD.h"
 #include "AliESDv0.h"
-#include "AliESDcascade.h"
 #include "AliCascadeVertex.h"
 #include "AliCascadeVertexer.h"
 #include "AliITStrackV2.h"
@@ -50,8 +50,16 @@ Int_t AliCascadeVertexer::V0sTracks2CascadeVertices(AliESD *event) {
    TObjArray trks(ntr);
    for (i=0; i<ntr; i++) {
        AliESDtrack *esdtr=event->GetTrack(i);
+       Int_t status=esdtr->GetStatus();
+
+       if ((status&AliESDtrack::kITSrefit)==0)
+       if ((status&AliESDtrack::kITSout)!=0 || (status&AliESDtrack::kITSin)==0)
+           continue;
+
        AliITStrackV2 *iotrack=new AliITStrackV2(*esdtr);
-       iotrack->PropagateTo(3.,0.0023,65.19); iotrack->PropagateTo(2.5,0.,0.);
+       if ((status&AliESDtrack::kITSrefit)==0)   //correction for the beam pipe
+          iotrack->PropagateTo(3.,0.0023,65.19); //material 
+       iotrack->PropagateTo(2.5,0.,0.);
        trks.AddLast(iotrack);
    }   
 

diff --git a/ITS/AliCascadeVertexer.h b/ITS/AliCascadeVertexer.h
index c14b5ffc1eb662d6901c94b8f07a66d2d0e8ac6b..edbecf55fff482af8350e067f538507e53c96d2b 100644 (file)
--- a/ITS/AliCascadeVertexer.h
+++ b/ITS/AliCascadeVertexer.h
@@ -5,7 +5,7 @@
 
 //------------------------------------------------------------------
 //                    Cascade Vertexer Class
-//
+//          Reads V0s and tracks, writes out cascade vertices
 //    Origin: Christian Kuhn, IReS, Strasbourg, christian.kuhn@ires.in2p3.fr
 //------------------------------------------------------------------
 

diff --git a/ITS/AliITSComparisonV2.C b/ITS/AliITSComparisonV2.C
index 892c52103332a09f66bb1b93250c47e0e8f46ce7..952d88b45af70283e87f8dd6d75eb63d6e8f4983 100644 (file)
--- a/ITS/AliITSComparisonV2.C
+++ b/ITS/AliITSComparisonV2.C
@@ -54,18 +54,18 @@ Int_t AliITSComparisonV2() {
        return 1;
    }
    rl->LoadgAlice();
-   if (rl->GetAliRun()) 
+   if (rl->GetAliRun())
    AliKalmanTrack::
    SetConvConst(1000/0.299792458/rl->GetAliRun()->Field()->SolenoidField());
    else {
       cerr<<"AliITSComparisonV2.C :Can't get AliRun !\n";
       return 1;
    }
-   rl->UnloadgAlice();
+   //rl->UnloadgAlice();
     
    AliITSLoader* itsl = (AliITSLoader*)rl->GetLoader("ITSLoader");
    if (itsl == 0x0) {
-       cerr<<"AliITSComparisonV2.C : Can not find TPCLoader\n";
+       cerr<<"AliITSComparisonV2.C : Can not find ITSLoader\n";
        delete rl;
        return 3;
    }
@@ -76,23 +76,6 @@ Int_t AliITSComparisonV2() {
      const char* evfoldname = AliConfig::fgkDefaultEventFolderName
    );//declaration only
 
-   Int_t nentr=0; TObjArray tarray(2000);
-   {/* Load tracks */ 
-     itsl->LoadTracks();
-     TTree *tracktree=itsl->TreeT();
-     if (!tracktree) {cerr<<"Can't get a tree with ITS tracks !\n"; return 4;}
-     TBranch *tbranch=tracktree->GetBranch("tracks");
-     nentr=(Int_t)tracktree->GetEntries();
-
-     for (Int_t i=0; i<nentr; i++) {
-        AliITStrackV2 *iotrack=new AliITStrackV2;
-        tbranch->SetAddress(&iotrack);
-        tracktree->GetEvent(i);
-        tarray.AddLast(iotrack);
-     }
-     itsl->UnloadTracks();
-   }
-
    /* Generate a list of "good" tracks */
    GoodTrackITS gt[MAX];
    Int_t ngood=0;
@@ -123,6 +106,23 @@ Int_t AliITSComparisonV2() {
       out.close();
    }
 
+   Int_t nentr=0; TObjArray tarray(2000);
+   {/* Load tracks */ 
+     itsl->LoadTracks();
+     TTree *tracktree=itsl->TreeT();
+     if (!tracktree) {cerr<<"Can't get a tree with ITS tracks !\n"; return 4;}
+     TBranch *tbranch=tracktree->GetBranch("tracks");
+     nentr=(Int_t)tracktree->GetEntries();
+
+     for (Int_t i=0; i<nentr; i++) {
+        AliITStrackV2 *iotrack=new AliITStrackV2;
+        tbranch->SetAddress(&iotrack);
+        tracktree->GetEvent(i);
+        tarray.AddLast(iotrack);
+     }
+     itsl->UnloadTracks();
+   }
+
    TH1F *hp=new TH1F("hp","PHI resolution",50,-20.,20.); hp->SetFillColor(4);
    TH1F *hl=new TH1F("hl","LAMBDA resolution",50,-20,20);hl->SetFillColor(4);
    TH1F *hpt=new TH1F("hpt","Relative Pt resolution",30,-10.,10.); 
@@ -325,14 +325,14 @@ Int_t AliITSComparisonV2() {
 Int_t good_tracks_its(GoodTrackITS *gt, const Int_t max, const char* evfoldname) {
    AliRunLoader* rl = AliRunLoader::GetRunLoader(evfoldname);
    if (rl == 0x0) {
-      ::Fatal("AliTPCComparison.C::good_tracks_its",
+      ::Fatal("AliITSComparisonV2.C::good_tracks_its",
               "Can not find Run Loader in Folder Named %s",
               evfoldname);
    }
 
    AliITSLoader* itsl = (AliITSLoader*)rl->GetLoader("ITSLoader");
    if (itsl == 0x0) {
-       cerr<<"AliITSComparisonV2.C : Can not find TPCLoader\n";
+       cerr<<"AliITSComparisonV2.C : Can not find ITSLoader\n";
        delete rl;
        return 3;
    }

diff --git a/ITS/AliITStrackerV2.cxx b/ITS/AliITStrackerV2.cxx
index fb72a090dfa4d142794bbd4347dee11adbda41c9..768ca5fb0210522574e1628865ef486405657445 100644 (file)
--- a/ITS/AliITStrackerV2.cxx
+++ b/ITS/AliITStrackerV2.cxx
@@ -15,7 +15,8 @@
 
 //-------------------------------------------------------------------------
 //               Implementation of the ITS tracker class
-//
+//    It reads AliITSclusterV2 clusters and creates AliITStrackV2 tracks
+//                   and fills with them the ESD
 //          Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
 //     dEdx analysis by: Boris Batyunya, JINR, Boris.Batiounia@cern.ch
 //-------------------------------------------------------------------------
@@ -33,7 +34,7 @@
 
 ClassImp(AliITStrackerV2)
 
-AliITStrackerV2::AliITSlayer AliITStrackerV2::fLayers[kMaxLayer]; // ITS layers
+AliITStrackerV2::AliITSlayer AliITStrackerV2::fgLayers[kMaxLayer]; // ITS layers
 
 AliITStrackerV2::AliITStrackerV2(const AliITSgeom *geom) : AliTracker() {
   //--------------------------------------------------------------------
@@ -60,7 +61,7 @@ AliITStrackerV2::AliITStrackerV2(const AliITSgeom *geom) : AliTracker() {
     r += TMath::Sqrt(x*x + y*y);
     r*=0.25;
 
-    new (fLayers+i-1) AliITSlayer(r,poff,zoff,nlad,ndet);
+    new (fgLayers+i-1) AliITSlayer(r,poff,zoff,nlad,ndet);
 
     for (Int_t j=1; j<nlad+1; j++) {
       for (Int_t k=1; k<ndet+1; k++) { //Fill this layer with detectors
@@ -73,7 +74,7 @@ AliITStrackerV2::AliITStrackerV2(const AliITSgeom *geom) : AliTracker() {
         Double_t cp=TMath::Cos(phi), sp=TMath::Sin(phi);
         Double_t r=x*cp+y*sp;
 
-        AliITSdetector &det=fLayers[i-1].GetDetector((j-1)*ndet + k-1); 
+        AliITSdetector &det=fgLayers[i-1].GetDetector((j-1)*ndet + k-1); 
         new(&det) AliITSdetector(r,phi); 
       } 
     }  
@@ -115,18 +116,18 @@ Int_t AliITStrackerV2::LoadClusters(TTree *cTree) {
 
   Int_t j=0;
   for (Int_t i=0; i<kMaxLayer; i++) {
-    Int_t ndet=fLayers[i].GetNdetectors();
-    Int_t jmax = j + fLayers[i].GetNladders()*ndet;
+    Int_t ndet=fgLayers[i].GetNdetectors();
+    Int_t jmax = j + fgLayers[i].GetNladders()*ndet;
     for (; j<jmax; j++) {           
       if (!cTree->GetEvent(j)) continue;
       Int_t ncl=clusters->GetEntriesFast();
       while (ncl--) {
         AliITSclusterV2 *c=(AliITSclusterV2*)clusters->UncheckedAt(ncl);
-        fLayers[i].InsertCluster(new AliITSclusterV2(*c));
+        fgLayers[i].InsertCluster(new AliITSclusterV2(*c));
       }
       clusters->Delete();
     }
-    fLayers[i].ResetRoad(); //road defined by the cluster density
+    fgLayers[i].ResetRoad(); //road defined by the cluster density
   }
 
   return 0;
@@ -136,7 +137,7 @@ void AliITStrackerV2::UnloadClusters() {
   //--------------------------------------------------------------------
   //This function unloads ITS clusters
   //--------------------------------------------------------------------
-  for (Int_t i=0; i<kMaxLayer; i++) fLayers[i].ResetClusters();
+  for (Int_t i=0; i<kMaxLayer; i++) fgLayers[i].ResetClusters();
 }
 
 static Int_t CorrectForDeadZoneMaterial(AliITStrackV2 *t) {
@@ -526,6 +527,10 @@ Int_t AliITStrackerV2::RefitInward(AliESD *event) {
        fTrackToFollow.SetLabel(t->GetLabel());
        fTrackToFollow.CookdEdx();
        CookLabel(&fTrackToFollow,0.); //For comparison only
+
+       fTrackToFollow.PropagateTo(3.,0.0028,65.19); //The beam pipe
+       fTrackToFollow.PropagateToVertex();
+
        fTrackToFollow.UpdateESDtrack(AliESDtrack::kITSrefit);
        UseClusters(&fTrackToFollow);
        ntrk++;
@@ -682,7 +687,7 @@ AliCluster *AliITStrackerV2::GetCluster(Int_t index) const {
   //--------------------------------------------------------------------
   Int_t l=(index & 0xf0000000) >> 28;
   Int_t c=(index & 0x0fffffff) >> 00;
-  return fLayers[l].GetCluster(c);
+  return fgLayers[l].GetCluster(c);
 }
 
 
@@ -693,13 +698,13 @@ void AliITStrackerV2::FollowProlongation() {
   while (fI>fLastLayerToTrackTo) {
     Int_t i=fI-1;
 
-    AliITSlayer &layer=fLayers[i];
+    AliITSlayer &layer=fgLayers[i];
     AliITStrackV2 &track=fTracks[i];
 
     Double_t r=layer.GetR();
 
     if (i==3 || i==1) {
-       Double_t rs=0.5*(fLayers[i+1].GetR() + r);
+       Double_t rs=0.5*(fgLayers[i+1].GetR() + r);
        Double_t d=0.0034, x0=38.6;
        if (i==1) {rs=9.; d=0.0097; x0=42;}
        if (!fTrackToFollow.PropagateTo(rs,d,x0)) {
@@ -791,7 +796,7 @@ Int_t AliITStrackerV2::TakeNextProlongation() {
   //
   //  dEdx analysis by: Boris Batyunya, JINR, Boris.Batiounia@cern.ch 
   //--------------------------------------------------------------------
-  AliITSlayer &layer=fLayers[fI];
+  AliITSlayer &layer=fgLayers[fI];
   ResetTrackToFollow(fTracks[fI]);
 
   Double_t dz=7*TMath::Sqrt(fTrackToFollow.GetSigmaZ2() + kSigmaZ2[fI]);
@@ -1104,10 +1109,10 @@ Double_t AliITStrackerV2::GetEffectiveThickness(Double_t y,Double_t z) const
   Double_t d=0.0028*3*3; //beam pipe
   Double_t x0=0;
 
-  Double_t xn=fLayers[fI].GetR();
+  Double_t xn=fgLayers[fI].GetR();
   for (Int_t i=0; i<fI; i++) {
-    Double_t xi=fLayers[i].GetR();
-    d+=fLayers[i].GetThickness(y,z,x0)*xi*xi;
+    Double_t xi=fgLayers[i].GetR();
+    d+=fgLayers[i].GetThickness(y,z,x0)*xi*xi;
   }
 
   if (fI>1) {
@@ -1116,7 +1121,7 @@ Double_t AliITStrackerV2::GetEffectiveThickness(Double_t y,Double_t z) const
   }
 
   if (fI>3) {
-    Double_t xi=0.5*(fLayers[3].GetR()+fLayers[4].GetR());
+    Double_t xi=0.5*(fgLayers[3].GetR()+fgLayers[4].GetR());
     d+=0.0034*xi*xi;
   }
 
@@ -1170,13 +1175,13 @@ AliITStrackerV2::RefitAt(Double_t xx,AliITStrackV2 *t,const AliITStrackV2 *c) {
   }
 
   for (Int_t i=from; i != to; i += step) {
-     AliITSlayer &layer=fLayers[i];
+     AliITSlayer &layer=fgLayers[i];
      Double_t r=layer.GetR();
  
      {
      Double_t hI=i-0.5*step; 
      if (TMath::Abs(hI-1.5)<0.01 || TMath::Abs(hI-3.5)<0.01) {             
-        Double_t rs=0.5*(fLayers[i-step].GetR() + r);
+        Double_t rs=0.5*(fgLayers[i-step].GetR() + r);
         Double_t d=0.0034, x0=38.6; 
         if (TMath::Abs(hI-1.5)<0.01) {rs=9.; d=0.0097; x0=42;}
         if (!t->PropagateTo(rs,-step*d,x0)) {

diff --git a/ITS/AliITStrackerV2.h b/ITS/AliITStrackerV2.h
index b5983255ed4066293ed63bd7bd9471491cf2f821..e821cd4c83988f6e81cac409d0a864a18c961786 100644 (file)
--- a/ITS/AliITStrackerV2.h
+++ b/ITS/AliITStrackerV2.h
@@ -1,12 +1,12 @@
-#ifndef ALIITSTRACKER_H
-#define ALIITSTRACKER_H
+#ifndef ALIITSTRACKERV2_H
+#define ALIITSTRACKERV2_H
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
 //-------------------------------------------------------------------------
 //                          ITS tracker
-//
-//       Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch 
+//     reads AliITSclusterV2 clusters and creates AliITStrackV2 tracks
+//           Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch 
 //-------------------------------------------------------------------------
 #include "AliTracker.h"
 #include "AliITSrecoV2.h"
@@ -105,7 +105,7 @@ private:
      new(&fTrackToFollow) AliITStrackV2(t);
   }
   Int_t fI;                              // index of the current layer
-  static AliITSlayer fLayers[kMaxLayer]; // ITS layers
+  static AliITSlayer fgLayers[kMaxLayer];// ITS layers
   AliITStrackV2 fTracks[kMaxLayer];      // track estimations at the ITS layers
   AliITStrackV2 fBestTrack;              // "best" track 
   AliITStrackV2 fTrackToFollow;          // followed track

diff --git a/ITS/AliV0vertexer.cxx b/ITS/AliV0vertexer.cxx
index 4eda554ec5700bf7e75821ef244c3c3c36e2cc87..139d3b95d760c38512ce01e4e564772823a89292 100644 (file)
--- a/ITS/AliV0vertexer.cxx
+++ b/ITS/AliV0vertexer.cxx
@@ -15,7 +15,8 @@
 
 //-------------------------------------------------------------------------
 //               Implementation of the V0 vertexer class
-//
+//                  reads tracks writes out V0 vertices
+//                      fills the ESD with the V0s       
 //     Origin: Iouri Belikov, IReS, Strasbourg, Jouri.Belikov@cern.ch
 //-------------------------------------------------------------------------
 #include <TObjArray.h>
@@ -52,7 +53,8 @@ Int_t AliV0vertexer::Tracks2V0vertices(AliESD *event) {
 
      AliITStrackV2 *iotrack=new AliITStrackV2(*esd);
      iotrack->SetLabel(i);  // now it is the index in array of ESD tracks
-     iotrack->PropagateTo(3.,0.0023,65.19); 
+     if ((status&AliESDtrack::kITSrefit)==0)   //correction for the beam pipe
+        iotrack->PropagateTo(3.,0.0023,65.19); //material
      iotrack->PropagateTo(2.5,0.,0.);
 
      if (iotrack->Get1Pt() > 0.) {nneg++; negtrks.AddLast(iotrack);}
@@ -213,7 +215,8 @@ Int_t AliV0vertexer::Tracks2V0vertices(TTree *tTree, TTree *vTree) {
    return 0;
 }
 
-Double_t AliV0vertexer::PropagateToDCA(AliITStrackV2 *n, AliITStrackV2 *p) {
+Double_t 
+AliV0vertexer::PropagateToDCA(AliITStrackV2 *n, AliITStrackV2 *p) const {
   //--------------------------------------------------------------------
   // This function returns the DCA between two tracks
   // The tracks will be moved to the point of DCA ! 

diff --git a/ITS/AliV0vertexer.h b/ITS/AliV0vertexer.h
index 0f5cd52094b26a80b5961f52075082306fd7673a..6ddf03aa14faa3963d6fe3d80e67ca45e91b4362 100644 (file)
--- a/ITS/AliV0vertexer.h
+++ b/ITS/AliV0vertexer.h
@@ -5,7 +5,7 @@
 
 //------------------------------------------------------------------
 //                    V0 Vertexer Class
-//
+//            reads tracks writes out V0 vertices
 //   Origin: Iouri Belikov, IReS, Strasbourg, Jouri.Belikov@cern.ch 
 //------------------------------------------------------------------
 
@@ -26,10 +26,10 @@ public:
   Int_t Tracks2V0vertices(AliESD *event);
 
   Int_t Tracks2V0vertices(TTree *in, TTree *out);
-  Double_t PropagateToDCA(AliITStrackV2 *nt, AliITStrackV2 *pt);
+  Double_t PropagateToDCA(AliITStrackV2 *nt, AliITStrackV2 *pt) const;
 
   void GetCuts(Double_t cuts[7]) const;
-  void GetVertex(Double_t *vtx) { vtx[0]=fX; vtx[1]=fY; vtx[2]=fZ; }
+  void GetVertex(Double_t *vtx) const { vtx[0]=fX; vtx[1]=fY; vtx[2]=fZ; }
 
 private: