Primary vertex reconstruction and standalone ITS tracking in the reconstruction chain
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 19 Feb 2004 15:47:26 +0000 (15:47 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 19 Feb 2004 15:47:26 +0000 (15:47 +0000)
26 files changed:
ANALYSIS/AliD0toKpiAnalysis.cxx
ITS/AliITS.cxx
ITS/AliITS.h
ITS/AliITSVertexer.cxx
ITS/AliITSVertexer.h
ITS/AliITSVertexerFast.cxx
ITS/AliITSVertexerIons.cxx
ITS/AliITSVertexerPPZ.cxx
ITS/AliITSVertexerTracks.cxx
ITS/AliITSVertexerZ.cxx
ITS/AliITSclusterTable.cxx
ITS/AliITSclusterTable.h
ITS/AliITStrackerSA.cxx
ITS/AliITStrackerSA.h
ITS/AliITStrackerV2.cxx
STEER/AliESD.cxx
STEER/AliESD.h
STEER/AliESDVertex.cxx
STEER/AliESDVertex.h
STEER/AliModule.h
STEER/AliReconstruction.cxx
STEER/AliReconstruction.h
STEER/AliVertexer.cxx [new file with mode: 0644]
STEER/AliVertexer.h [new file with mode: 0644]
STEER/STEERLinkDef.h
STEER/libSTEER.pkg

index be83cb5c76e78368282b3bb7e0876a4d250e671e..6d7d5bcc3d65d4df90278e17a5c59c5b333c7d3c 100644 (file)
@@ -391,7 +391,6 @@ void AliD0toKpiAnalysis::FindCandidatesESD(Int_t evFirst,Int_t evLast,
   TString outName1=outName;
   TString outName2("nTotEvents.dat");
 
-  Double_t covV1[6];
   Int_t    nTotEv=0,nD0rec=0,nD0rec1ev=0;
   Double_t dca;
   Double_t v2[3],mom[6],d0[2];
@@ -447,7 +446,7 @@ void AliD0toKpiAnalysis::FindCandidatesESD(Int_t evFirst,Int_t evLast,
     //AliESDVertex *vertex1stored = (AliESDVertex*)trkFile->Get(vtxName);
     //vertex1stored->GetXYZ(fV1);
     //delete vertex1stored;
-    event->GetVertex(fV1,covV1);
+    event->GetVertex()->GetXYZ(fV1);
 
     trkEntries = event->GetNumberOfTracks();
     printf(" Number of tracks: %d\n",trkEntries);
index 52d69b32988e94a662da5afc2e4ba3e6601db0c0..19b0a77616ee84def3ec511ab04e2bb4389359c0 100644 (file)
@@ -112,8 +112,13 @@ the AliITS class.
 #include "AliITSDigitizer.h"
 #include "AliITSclustererV2.h"
 #include "AliITStrackerV2.h"
+#include "AliITStrackerSA.h"
 #include "AliITSpidESD.h"
 #include "AliV0vertexer.h"
+#include "AliITSVertexerPPZ.h"
+#include "AliITSVertexerFast.h"
+#include "AliITSVertexerZ.h"
+#include "AliITSVertexerIons.h"
 #include "AliCascadeVertexer.h"
 #include "AliESD.h"
 #include "AliRun.h"
@@ -164,6 +169,7 @@ AliITS::AliITS() : AliDetector() {
     fNRecPoints = 0;
 
     SetMarkerColor(kRed);
+    SelectVertexer(" ");
 }
 //______________________________________________________________________
 AliITS::AliITS(const char *name, const char *title):AliDetector(name,title){
@@ -222,7 +228,7 @@ AliITS::AliITS(const char *name, const char *title):AliDetector(name,title){
     } // end for i
 
     SetMarkerColor(kRed);
-
+    SelectVertexer(" ");
 }
 //______________________________________________________________________
 AliITS::~AliITS(){
@@ -1813,7 +1819,29 @@ AliTracker* AliITS::CreateTracker() const
 {
 // create an ITS tracker
 
-  return new AliITStrackerV2(GetITSgeom());
+  return new AliITStrackerSA(GetITSgeom());
+}
+//_____________________________________________________________________________
+AliVertexer* AliITS::CreateVertexer() const
+{
+  // create a ITS vertexer
+
+  if(fSelectedVertexer.Contains("ions") || fSelectedVertexer.Contains("IONS")){
+    Info("CreateVertexer","a AliITSVertexerIons object has been selected\n");
+    return new AliITSVertexerIons("null");
+  }
+  if(fSelectedVertexer.Contains("smear") || fSelectedVertexer.Contains("SMEAR")){
+    Double_t smear[3]={0.005,0.005,0.01};
+    Info("CreateVertexer","a AliITSVertexerFast object has been selected\n"); 
+    return new AliITSVertexerFast(smear);
+  }
+  if(fSelectedVertexer.Contains("ppz") || fSelectedVertexer.Contains("PPZ")){
+    Info("CreateVertexer","a AliITSVertexerPPZ object has been selected\n");
+    return new AliITSVertexerPPZ("null");
+  }
+  // by default an AliITSVertexerZ object is instatiated
+  Info("CreateVertexer","a AliITSVertexerZ object has been selected\n");
+  return new AliITSVertexerZ("null");
 }
 
 //_____________________________________________________________________________
@@ -1836,7 +1864,8 @@ void AliITS::FillESD(AliESD* esd) const
   };
   AliV0vertexer vtxer(cuts);
   Double_t vtx[3], cvtx[6];
-  esd->GetVertex(vtx, cvtx);
+  esd->GetVertex()->GetXYZ(vtx);
+  esd->GetVertex()->GetSigmaXYZ(cvtx);
   vtxer.SetVertex(vtx);
   vtxer.Tracks2V0vertices(esd);
 
index 59ffdff2d3dafc97e1fbfd850a165c4db3389186..5709f68d64e06e9764d17f3c86c6bd8963d47d3f 100644 (file)
@@ -33,6 +33,7 @@ class AliITSdigit;
 class AliITSRecPoint;
 class AliITSRawCluster;
 class AliITSmodule;
+class AliVertexer;
 
 const Int_t kNTYPES=3;
 
@@ -146,6 +147,7 @@ class AliITS : public AliDetector {
     Int_t        *Ndtype() {return fNdtype;}
     TClonesArray *DigitsAddress(Int_t id)
        {return ((TClonesArray *) (*fDtype)[id]);}
+    void SelectVertexer(TString sel=" "){fSelectedVertexer = sel;}
 
     //===================== Raw Data IO ================================
     // Write digits into raw data format
@@ -182,6 +184,7 @@ class AliITS : public AliDetector {
 
     virtual void Reconstruct() const;
     virtual AliTracker* CreateTracker() const;
+    virtual AliVertexer* CreateVertexer() const;
     virtual void FillESD(AliESD* esd) const;
      
  protected:
@@ -209,8 +212,9 @@ class AliITS : public AliDetector {
 
     TClonesArray *fRecPoints;  //! List of reconstructed points
     Int_t         fNRecPoints; // Number of rec points
+    TString fSelectedVertexer; // Vertexer selected in CreateVertexer
 
-    ClassDef(AliITS,3) // Base class for ITS
+    ClassDef(AliITS,4) // Base class for ITS
 };
 
 #endif
index a9bde2e4cde455ee3464e5c66ff20f80cf4f6911..f66b6f56af75830b9268fd1cbb7a9befc2c3645b 100644 (file)
@@ -2,6 +2,8 @@
 #include <AliITSVertexer.h>
 #include <AliRunLoader.h>
 #include <AliITSLoader.h>
+#include <AliITSRecPoint.h>
+#include <AliITSclusterV2.h>
 
 ClassImp(AliITSVertexer)
 
@@ -13,13 +15,9 @@ ClassImp(AliITSVertexer)
 //////////////////////////////////////////////////////////////////////
 
 //______________________________________________________________________
-AliITSVertexer::AliITSVertexer() {
+AliITSVertexer::AliITSVertexer():AliVertexer() {
   // Default Constructor
-
-    fCurrentVertex  = 0;
-    SetDebug();
-    SetFirstEvent(0);
-    SetLastEvent(0);
+  SetUseV2Clusters(kTRUE);
 }
 
 AliITSVertexer::AliITSVertexer(TString filename) {
@@ -38,17 +36,18 @@ AliITSVertexer::AliITSVertexer(TString filename) {
   rl->LoadHeader();
   AliITSLoader* itsLoader =  (AliITSLoader*) rl->GetLoader("ITSLoader");
   if(!filename.Contains("default"))itsLoader->SetVerticesFileName(filename);
-  itsLoader->LoadVertices("recreate");
+  if(!filename.Contains("null"))itsLoader->LoadVertices("recreate");
   itsLoader->LoadRecPoints();
   Int_t lst;
   if(rl->TreeE()){
     lst = static_cast<Int_t>(rl->TreeE()->GetEntries());
     SetLastEvent(lst-1);
   }
+  SetUseV2Clusters(kTRUE);
 }
 
 //______________________________________________________________________
-AliITSVertexer::AliITSVertexer(const AliITSVertexer &vtxr) : TObject(vtxr) {
+AliITSVertexer::AliITSVertexer(const AliITSVertexer &vtxr) : AliVertexer(vtxr) {
   // Copy constructor
   // Copies are not allowed. The method is protected to avoid misuse.
   Error("AliITSVertexer","Copy constructor not allowed\n");
@@ -62,14 +61,6 @@ AliITSVertexer& AliITSVertexer::operator=(const AliITSVertexer& /* vtxr */){
   return *this;
 }
 
-//______________________________________________________________________
-AliITSVertexer::~AliITSVertexer() {
-  // Default Destructor
-  // The objects pointed by the following pointers are not owned
-  // by this class and are not deleted
-
-    fCurrentVertex  = 0;
-}
 
 //______________________________________________________________________
 void AliITSVertexer::WriteCurrentVertex(){
@@ -82,3 +73,51 @@ void AliITSVertexer::WriteCurrentVertex(){
   Int_t rc = itsLoader->PostVertex(fCurrentVertex);
   rc = itsLoader->WriteVertices();
 }
+
+//______________________________________________________________________
+void AliITSVertexer::Clusters2RecPoints
+(const TClonesArray *clusters, Int_t idx, TClonesArray *points) {
+  //------------------------------------------------------------
+  // Conversion AliITSclusterV2 -> AliITSRecPoints for the ITS
+  // module "idx" (entry in the tree with the clusters).
+  // Simplified version, supposed to work with the pixels only !
+  //------------------------------------------------------------
+  const Int_t lastSPD1=79; //let's hope the number of the SPDs will not change
+  const Int_t lastSPD2=239;//let's hope the number of the SPDs will not change
+
+  Float_t yshift = 0; //see AliITSclustererV2.cxx about these shifts
+  Float_t zshift[4] = {-10.708000, -3.536000, 3.536000, 10.708000}; //let's hope the positioning of the SPDs will not change
+
+  if (idx<=lastSPD1) {
+    yshift=0.248499;  //let's hope the positioning of the SPDs will not change
+  } else if (idx<=lastSPD2) {
+    yshift=3.096207;  //let's hope the positioning of the SPDs will not change
+  } else {
+    Fatal("Clusters2RecPoints","This is not an SPD module ! %d",idx);
+  }
+
+  TClonesArray &pn=*points;
+  Int_t ncl=clusters->GetEntriesFast();
+  for (Int_t i=0; i<ncl; i++) {
+    AliITSRecPoint p;
+    AliITSclusterV2 *c = (AliITSclusterV2 *)clusters->UncheckedAt(i);
+
+    Float_t x=c->GetY();  if (idx<=lastSPD1) x=-x;
+    x+=yshift;
+
+    Float_t z=c->GetZ();
+    z=-z; z+=zshift[idx%4];
+
+    p.SetX(x);
+    p.SetZ(z);
+    p.SetQ(c->GetQ());
+    p.SetSigmaX2(c->GetSigmaY2());
+    p.SetSigmaZ2(c->GetSigmaZ2());
+    p.SetLabel(0,c->GetLabel(0));
+    p.SetLabel(1,c->GetLabel(1));
+    p.SetLabel(2,c->GetLabel(2));
+
+    new (pn[i]) AliITSRecPoint(p);
+  }
+
+}
index 0d5fa1f95fe681141031c0362f22e41e3c38dc64..2a4fb7de49f41b959e862c77b117a02a2d963231 100644 (file)
@@ -1,38 +1,29 @@
 #ifndef ALIITSVERTEXER_H
 #define ALIITSVERTEXER_H
 
-#include<TObject.h>
+#include<AliVertexer.h>
 
 ///////////////////////////////////////////////////////////////////
 //                                                               //
-// Base class for primary vertex reconstruction                  //
+// Base class for primary vertex reconstruction  for ITS         //
 //                                                               //
 ///////////////////////////////////////////////////////////////////
 
-class TFile;
 class TString;
-class TTRee;
-class AliESDVertex;
+class TClonesArray;
 
 
-class AliITSVertexer : public TObject {
+class AliITSVertexer : public AliVertexer {
 
  public:
     // default constructor
     AliITSVertexer();   
     // standard constructor     
     AliITSVertexer(TString filename); 
-    // destructor
-    virtual ~AliITSVertexer(); 
-    // computes the vertex for the current event
-    virtual AliESDVertex* FindVertexForCurrentEvent(Int_t evnumb)=0; 
-    // computes the vetex for each event and stores it on file
-    virtual void FindVertices()= 0;
-    virtual void PrintStatus() const = 0;
-    virtual void SetDebug(Int_t debug = 0){fDebug = debug;}
-    virtual void SetFirstEvent(Int_t ev){fFirstEvent = ev;}
-    virtual void SetLastEvent(Int_t ev){fLastEvent = ev;}
+    virtual void SetUseV2Clusters(Bool_t v2c){fUseV2Clusters = v2c;}
     virtual void WriteCurrentVertex();
+    virtual void Clusters2RecPoints(const TClonesArray *clusters, Int_t idx, TClonesArray *points);
 
  
  protected:
@@ -41,14 +32,9 @@ class AliITSVertexer : public TObject {
     AliITSVertexer(const AliITSVertexer& vtxr);
     // assignment operator (NO assignment allowed)
     AliITSVertexer& operator=(const AliITSVertexer& /* vtxr */);
+    Bool_t fUseV2Clusters;   // true if V2 clusters are used
 
-    AliESDVertex *fCurrentVertex;  //! pointer to the vertex of the current
-                                   //  event
-    Int_t fFirstEvent;          // First event to be processed by FindVertices
-    Int_t fLastEvent;           // Last event to be processed by FindVertices 
-    Int_t fDebug;               //! debug flag - verbose printing if >0
-
-  ClassDef(AliITSVertexer,1);
+  ClassDef(AliITSVertexer,2);
 };
 
 #endif
index e9a234e376a26cb72be4451e2fe134ab05657e1e..44be20d9162490dc6b222716eae38706c0c9e1c5 100644 (file)
@@ -45,6 +45,7 @@ AliITSVertexerFast::AliITSVertexerFast(Double_t *smear):AliITSVertexer() {
   // Standard constructor
   fSmear = new Double_t[3];
   for(Int_t i=0;i<3;i++)fSmear[i]=smear[i];
+  Info("AliITSVertexerFast","Gaussian smaring of the generated vertex. Parameters %f12.5 , %f12.5 , %f12.5 \n",fSmear[0],fSmear[1],fSmear[2]);
 }
 
 //______________________________________________________________________
index e5e257a0dbbdcd40c11c064ba4966d73efa469e6..0f95dcf5d140c718a073779f0c589b53db52d367 100644 (file)
@@ -86,6 +86,16 @@ AliESDVertex* AliITSVertexerIons::FindVertexForCurrentEvent(Int_t evnumber){
   fITS->SetTreeAddress();
   AliITSgeom *g2 = fITS->GetITSgeom(); 
   TClonesArray  *recpoints = fITS->RecPoints();
+  TClonesArray dummy("AliITSclusterV2",10000), *clusters=&dummy;
+  TBranch *branch;
+  if(fUseV2Clusters){
+    branch = itsloader->TreeR()->GetBranch("Clusters");
+    branch->SetAddress(&clusters);
+  }
+  else {
+    branch = itsloader->TreeR()->GetBranch("ITSRecPoints");
+  }
+
   AliITSRecPoint *pnt;
 
   Int_t nopoints1 = 0;                                         
@@ -109,7 +119,10 @@ AliESDVertex* AliITSVertexerIons::FindVertexForCurrentEvent(Int_t evnumber){
   for(i=g2->GetStartSPD();i<=g2->GetLastSPD();i++) 
     {
       fITS->ResetRecPoints();
-      tr->GetEvent(i);    
+      tr->GetEvent(i); 
+      if(fUseV2Clusters){
+       Clusters2RecPoints(clusters,i,recpoints);
+      }
       npoints = recpoints->GetEntries();
       for (ipoint=0;ipoint<npoints;ipoint++) {
        pnt = (AliITSRecPoint*)recpoints->UncheckedAt(ipoint);
@@ -129,7 +142,10 @@ AliESDVertex* AliITSVertexerIons::FindVertexForCurrentEvent(Int_t evnumber){
     }  
   
   nopoints1 = (Int_t)(hITSz1->GetEntries()); 
-           
+  if (nopoints1 == 0) {
+    delete hITSz1;
+    return fCurrentVertex;
+  }         
   aspar[0] = (mxpiu-mxmeno)/(mxpiu+mxmeno);
   aspar[1] = (mypiu-mymeno)/(mypiu+mymeno); 
    
@@ -210,6 +226,9 @@ AliESDVertex* AliITSVertexerIons::FindVertexForCurrentEvent(Int_t evnumber){
     {
       fITS->ResetRecPoints(); 
       itsloader->TreeR()->GetEvent(i);
+     if(fUseV2Clusters){
+       Clusters2RecPoints(clusters,i,recpoints);
+      }
       npoints = recpoints->GetEntries();
       for (ipoint=0;ipoint<npoints;ipoint++) {
                
@@ -267,7 +286,7 @@ AliESDVertex* AliITSVertexerIons::FindVertexForCurrentEvent(Int_t evnumber){
 
     Warning("FindVertexForCurrentEvent","AliITSVertexerIons finder is not reliable for low multiplicity events. Switching to AliITSVertexerPPZ with default parameters...\n");
     Warning("FindVertexForCurrentEvent","N rec points = %d - Threshold is %d",np1,fNpThreshold);
-    AliITSVertexerPPZ *dovert = new AliITSVertexerPPZ("default");
+    AliITSVertexerPPZ *dovert = new AliITSVertexerPPZ("null");
     fCurrentVertex =dovert->FindVertexForCurrentEvent(rl->GetEventNumber());
     delete dovert;
     return fCurrentVertex;
index 02b878805d449314f501668e8d2baea515cca55e..cea187a3c1a410a005fe89484d72a52d942a1cbb 100644 (file)
@@ -195,24 +195,31 @@ AliESDVertex* AliITSVertexerPPZ::FindVertexForCurrentEvent(Int_t evnumber){
     Error("FindVertexForCurrentEvent","ITS geometry is not defined");
     return fCurrentVertex;
   }
-  TTree *TR=0;
-  TClonesArray *ITSrec  = 0;
+  TTree *tR=0;
+  TClonesArray *itsRec  = 0;
   Float_t lc[3]; for(Int_t ii=0; ii<3; ii++) lc[ii]=0.;
   Float_t gc[3]; for(Int_t ii=0; ii<3; ii++) gc[ii]=0.;
   Float_t lc2[3]; for(Int_t ii=0; ii<3; ii++) lc2[ii]=0.;
   Float_t gc2[3]; for(Int_t ii=0; ii<3; ii++) gc2[ii]=0.;
 
-  TR = ITSloader->TreeR();
-  if(!TR){
+  tR = ITSloader->TreeR();
+  if(!tR){
     Error("FindVertexForCurrentEvent","TreeR not found");
     return fCurrentVertex;
   }
-  ITSrec  = fITS->RecPoints();  // uses slow points or fast points if slow are
+  itsRec  = fITS->RecPoints();  // uses slow points or fast points if slow are
   // missing
-  TBranch *branch = TR->GetBranch("ITSRecPoints");
-  if(!branch){ 
-    branch = TR->GetBranch("ITSRecPointsF");
-    //   Warning("FindVertexForCurrentEvent","Using Fast points");
+  TClonesArray dummy("AliITSclusterV2",10000), *clusters=&dummy;
+  TBranch *branch;
+  if(fUseV2Clusters){
+    branch = tR->GetBranch("Clusters");
+    branch->SetAddress(&clusters);
+  }
+  else {
+    branch = tR->GetBranch("ITSRecPoints");
+    if(!branch){ 
+      branch = tR->GetBranch("ITSRecPointsF");
+    }
   }
   if(!branch){
    Error("FindVertexForCurrentEvent","branch for ITS rec points not found");
@@ -224,9 +231,12 @@ AliESDVertex* AliITSVertexerPPZ::FindVertexForCurrentEvent(Int_t evnumber){
   Int_t firipixe=0;
   for(Int_t module= fFirstL1; module<=fLastL1;module++){
     branch->GetEvent(module);
-    Int_t nrecp1 = ITSrec->GetEntries();
+    if(fUseV2Clusters){
+      Clusters2RecPoints(clusters,module,itsRec);
+    }
+    Int_t nrecp1 = itsRec->GetEntries();
     for(Int_t i=0; i<nrecp1;i++){
-      AliITSRecPoint *current = (AliITSRecPoint*)ITSrec->At(i);
+      AliITSRecPoint *current = (AliITSRecPoint*)itsRec->At(i);
       lc[0]=current->GetX();
       lc[2]=current->GetZ();
       geom->LtoG(module,lc,gc);
@@ -263,9 +273,12 @@ AliESDVertex* AliITSVertexerPPZ::FindVertexForCurrentEvent(Int_t evnumber){
   for(Int_t module= fFirstL1; module<=fLastL1;module++){
     if(fDebug>0)cout<<"processing module   "<<module<<"                  \r";
     branch->GetEvent(module);
-    Int_t nrecp1 = ITSrec->GetEntries();
+    if(fUseV2Clusters){
+      Clusters2RecPoints(clusters,module,itsRec);
+    }
+    Int_t nrecp1 = itsRec->GetEntries();
     TObjArray *poiL1 = new TObjArray(nrecp1);
-    for(Int_t i=0; i<nrecp1;i++)poiL1->AddAt(ITSrec->At(i),i);
+    for(Int_t i=0; i<nrecp1;i++)poiL1->AddAt(itsRec->At(i),i);
     fITS->ResetRecPoints();
     for(Int_t i=0; i<nrecp1;i++){
       AliITSRecPoint *current = (AliITSRecPoint*)poiL1->At(i);
@@ -280,9 +293,12 @@ AliESDVertex* AliITSVertexerPPZ::FindVertexForCurrentEvent(Int_t evnumber){
       if(fDebug>1)cout<<"module "<<module<<" "<<gc[0]<<" "<<gc[1]<<" "<<gc[2]<<" "<<phi1<<"     \n";
       for(Int_t modul2=fFirstL2; modul2<=fLastL2; modul2++){
        branch->GetEvent(modul2);
-       Int_t nrecp2 = ITSrec->GetEntries();
+       if(fUseV2Clusters){
+         Clusters2RecPoints(clusters,modul2,itsRec);
+       }
+       Int_t nrecp2 = itsRec->GetEntries();
        for(Int_t j=0; j<nrecp2;j++){
-         AliITSRecPoint *recp = (AliITSRecPoint*)ITSrec->At(j);
+         AliITSRecPoint *recp = (AliITSRecPoint*)itsRec->At(j);
          lc2[0]=recp->GetX();
          lc2[2]=recp->GetZ();
          geom->LtoG(modul2,lc2,gc2);
index c36af398c0dbc5fdc82bfb6314bbe986d02a3cc4..1ff61a52255b4b784e41252cf35b077e7e28fae3 100644 (file)
@@ -347,7 +347,7 @@ AliESDVertex* AliITSVertexerTracks::FindVertexForCurrentEvent(AliESD *esdEvent)
   if(nTrks < fMinTracks) { TooFewTracks(); return fCurrentVertex; }
 
   // Set initial vertex position from ESD
-  esdEvent->GetVertex(vtx,cvtx);
+  esdEvent->GetVertex()->GetXYZ(vtx);
   SetVtxStart(vtx[0],vtx[1]);
 
   // VERTEX FINDER
@@ -361,7 +361,7 @@ AliESDVertex* AliITSVertexerTracks::FindVertexForCurrentEvent(AliESD *esdEvent)
   // store vertex information in ESD
   fCurrentVertex->GetXYZ(vtx);
   fCurrentVertex->GetCovMatrix(cvtx);
-  esdEvent->SetVertex(vtx,cvtx);
+  esdEvent->SetVertex(fCurrentVertex);
 
   cout<<"Vertex: "<<vtx[0]<<", "<<vtx[1]<<", "<<vtx[2]<<endl;
   return fCurrentVertex;
index 4565d07cc6f0932420f3167b76db8327ac7959f5..92f64a761291fdec33772be741d845234ba79e61 100644 (file)
@@ -110,8 +110,7 @@ AliESDVertex* AliITSVertexerZ::FindVertexForCurrentEvent(Int_t evnumber){
   fCurrentVertex = 0;
   AliRunLoader *rl =AliRunLoader::GetRunLoader();
   AliITSLoader* itsLoader =  (AliITSLoader*) rl->GetLoader("ITSLoader");
-  itsLoader->ReloadRecPoints();
-
+  itsLoader->LoadRecPoints();
   rl->GetEvent(evnumber);
 
   if(!fITS)  {
@@ -133,8 +132,18 @@ AliESDVertex* AliITSVertexerZ::FindVertexForCurrentEvent(Int_t evnumber){
   Float_t lc2[3]; for(Int_t ii=0; ii<3; ii++) lc2[ii]=0.;
   Float_t gc2[3]; for(Int_t ii=0; ii<3; ii++) gc2[ii]=0.;
 
-  itsRec  = fITS->RecPoints();
-  TBranch *branch = tR->GetBranch("ITSRecPoints");
+  itsRec = fITS->RecPoints();
+
+  //cout<<"Address of itsRec = "<<itsRec<<endl;
+  TClonesArray dummy("AliITSclusterV2",10000), *clusters=&dummy;
+  TBranch *branch;
+  if(fUseV2Clusters){
+    branch = tR->GetBranch("Clusters");
+    branch->SetAddress(&clusters);
+  }
+  else {
+    branch = tR->GetBranch("ITSRecPoints");
+  }
 
   Int_t nbinfine = static_cast<Int_t>((fHighLim-fLowLim)/fStepFine);
   Int_t nbincoarse = static_cast<Int_t>((fHighLim-fLowLim)/fStepCoarse);
@@ -147,18 +156,24 @@ AliESDVertex* AliITSVertexerZ::FindVertexForCurrentEvent(Int_t evnumber){
   Int_t nrpL2 = 0;
   for(Int_t module= fFirstL1; module<=fLastL1;module++){
     if(module%4==0 || module%4==3)continue;
+    //   cout<<"Procesing module "<<module<<" ";
     branch->GetEvent(module);
+    //    cout<<"Number of clusters "<<clusters->GetEntries()<<endl;
+    if(fUseV2Clusters){
+      Clusters2RecPoints(clusters,module,itsRec);
+    }
     nrpL1+= itsRec->GetEntries();
     fITS->ResetRecPoints();
   }
   for(Int_t module= fFirstL2; module<=fLastL2;module++){
     branch->GetEvent(module);
+    if(fUseV2Clusters){
+      Clusters2RecPoints(clusters,module,itsRec);
+    }
     nrpL2+= itsRec->GetEntries();
     fITS->ResetRecPoints();
   }
-  cout<<"nrpL1 = "<<nrpL1<<"; nrpL2= "<<nrpL2<<endl;
   if(nrpL1 == 0 || nrpL2 == 0){
-    cout<<"achi, achi\n";
     ResetHistograms();
     return fCurrentVertex;
   }
@@ -174,6 +189,9 @@ AliESDVertex* AliITSVertexerZ::FindVertexForCurrentEvent(Int_t evnumber){
   for(Int_t module= fFirstL1; module<=fLastL1;module++){
     if(module%4==0 || module%4==3)continue;
     branch->GetEvent(module);
+    if(fUseV2Clusters){
+      Clusters2RecPoints(clusters,module,itsRec);
+    }
     Int_t nrecp1 = itsRec->GetEntries();
     for(Int_t j=0;j<nrecp1;j++){
       AliITSRecPoint *recp = (AliITSRecPoint*)itsRec->At(j);
@@ -194,6 +212,9 @@ AliESDVertex* AliITSVertexerZ::FindVertexForCurrentEvent(Int_t evnumber){
   ind = 0;
   for(Int_t module= fFirstL2; module<=fLastL2;module++){
     branch->GetEvent(module);
+    if(fUseV2Clusters){
+      Clusters2RecPoints(clusters,module,itsRec);
+    }
     Int_t nrecp2 = itsRec->GetEntries();
     for(Int_t j=0;j<nrecp2;j++){
       AliITSRecPoint *recp = (AliITSRecPoint*)itsRec->At(j);
@@ -237,9 +258,9 @@ AliESDVertex* AliITSVertexerZ::FindVertexForCurrentEvent(Int_t evnumber){
     ResetHistograms();
     return fCurrentVertex;
   }
-  else {
-    cout<<"Number of entries in hist. "<<fZCombc->GetEntries()<<endl;
-  }
+  //  else {
+  //    cout<<"Number of entries in hist. "<<fZCombc->GetEntries()<<endl;
+  //  }
   Int_t bi = fZCombc->GetMaximumBin();
   Float_t centre = fZCombc->GetBinCenter(bi);
   Int_t n1 = static_cast<Int_t>((centre-fZCombc->GetBinWidth(bi)-fZCombf->GetBinLowEdge(0))/fZCombf->GetBinWidth(0));
@@ -266,7 +287,6 @@ AliESDVertex* AliITSVertexerZ::FindVertexForCurrentEvent(Int_t evnumber){
       fZFound/=num;
     }
     goon = TMath::Abs(TMath::Abs(fZFound-fZCombf->GetBinCenter(n1))-TMath::Abs(fZFound-fZCombf->GetBinCenter(n2)))>fTolerance;
-    cout<<"Simmetria "<<TMath::Abs(TMath::Abs(fZFound-fZCombf->GetBinCenter(n1))-TMath::Abs(fZFound-fZCombf->GetBinCenter(n2)))<<endl;
     n1 = static_cast<Int_t>((fZFound-fZCombc->GetBinWidth(bi)-fZCombf->GetBinLowEdge(0))/fZCombf->GetBinWidth(0));
     n2 = static_cast<Int_t>((fZFound+fZCombc->GetBinWidth(bi)-fZCombf->GetBinLowEdge(0))/fZCombf->GetBinWidth(0));
     niter++;
@@ -275,7 +295,7 @@ AliESDVertex* AliITSVertexerZ::FindVertexForCurrentEvent(Int_t evnumber){
       Warning("FindVertexForCurrentEvent","The procedure dows not converge\n");
     }
   }
-  cout<<"Numer of Iterations "<<niter<<endl<<endl;
+  //  cout<<"Numer of Iterations "<<niter<<endl<<endl;
   fCurrentVertex = new AliESDVertex(fZFound,fZsig,num);
   fCurrentVertex->SetTitle("vertexer: B");
   ResetHistograms();
index 25435c43d9282ceae6d5e190dfd4dc2ff8da3a68..0dc4be8b2fd3a254eb5d91a4ef4071d4de8796ed 100644 (file)
@@ -51,6 +51,10 @@ AliITSclusterTable::AliITSclusterTable(){
   fLambdaList = 0;
   fXList = 0;
   fYList =0;
+  fZList =0;
+  fSxList = 0;
+  fSyList =0;
+  fSzList =0;
   for(Int_t i=0;i<3;i++){fPrimaryVertex[i]=0;}
 }
 
@@ -69,6 +73,10 @@ AliITSclusterTable::AliITSclusterTable(AliITSgeom* geom, AliITStrackerSA* tracke
   fLambdaList = 0;
   fXList = 0;
   fYList = 0;
+  fZList =0;
+  fSxList = 0;
+  fSyList =0;
+  fSzList =0;
 }
 
 //______________________________________________________________________
@@ -96,25 +104,37 @@ AliITSclusterTable::~AliITSclusterTable(){
     for (Int_t i=0; i<nm; i++){
       delete fDet[i];
     }
-    delete fDet;
+    delete[] fDet;
   }
-  if (fLbl)delete [] fLbl;
+  if (fLbl)delete [] fLbl; // memory leak!
   if (fNCl)delete [] fNCl;
-  if (fPhiList)delete [] fPhiList;
-  if (fLambdaList) delete [] fLambdaList;
-  if (fXList) delete [] fXList;
-  if (fYList) delete [] fYList;
+  for (Int_t i = 0; i < fGeom->GetNlayers(); i++) {
+    if (fPhiList) delete fPhiList[i];
+    if (fLambdaList) delete fLambdaList[i];
+    if (fXList) delete fXList[i];
+    if (fYList) delete fYList[i];
+    if (fZList) delete fZList[i];
+    if (fSxList) delete fSxList[i];
+    if (fSyList) delete fSyList[i];
+    if (fSzList) delete fSzList[i];
+  }
+  if (fPhiList) delete[] fPhiList;
+  if (fLambdaList) delete[] fLambdaList;
+  if (fXList) delete[] fXList;
+  if (fYList) delete[] fYList;
+  if (fZList) delete[] fZList;
+  if (fSxList) delete[] fSxList;
+  if (fSyList) delete[] fSyList;
+  if (fSzList) delete[] fSzList;
 }
 
 //__________________________________________________________
 
-void AliITSclusterTable::FillArray(TTree* clusterTree,Int_t evnumber){
+void AliITSclusterTable::FillArray(TTree* clusterTree){
   
   //
   Int_t nm = fGeom->GetIndexMax();
   fDet = new TArrayI*[nm];
-  fTracker->SetEventNumber(evnumber);
-  fTracker->LoadClusters(clusterTree);
 
   TArrayI** vect = new TArrayI*[fGeom->GetNlayers()];
   
@@ -145,7 +165,7 @@ void AliITSclusterTable::FillArray(TTree* clusterTree,Int_t evnumber){
     Int_t nlr = FindIndex(fGeom->GetNlayers(),firstmod,mod);
     if(nlr<0){
       Fatal("FillArray","Wrong module number %d . Limits: %d , %d",mod,firstmod[0],firstmod[fGeom->GetNlayers()+1]);
-      return;
+      exit(1);
     }
     else {
       for(Int_t n=0;n<vect[nlr]->GetSize();n++){
@@ -156,21 +176,19 @@ void AliITSclusterTable::FillArray(TTree* clusterTree,Int_t evnumber){
   }
 
 
-  fTracker->UnloadClusters();
-
+  clus->Delete();
+  delete clus;
   for(Int_t n=0;n<fGeom->GetNlayers();n++)delete vect[n];
-  delete vect;
+  delete [] vect;
   delete [] firstmod;
 }
 
 //_________________________________________________________________
-void AliITSclusterTable::FillArrayLabel(Int_t numberofparticles,TTree* clusterTree,Int_t evnumber){
+void AliITSclusterTable::FillArrayLabel(Int_t numberofparticles){
   //
 
 
   fLbl = new TArrayI*[numberofparticles];
-  fTracker->SetEventNumber(evnumber);
-  fTracker->LoadClusters(clusterTree);
   const Int_t knm =fGeom->GetNlayers();
   for(Int_t nlab=0;nlab<numberofparticles;nlab++){
     fLbl[nlab] = new TArrayI(knm);
@@ -192,7 +210,6 @@ void AliITSclusterTable::FillArrayLabel(Int_t numberofparticles,TTree* clusterTr
     delete [] nn;
   }
 
-  fTracker->UnloadClusters();
 }
 
 //_______________________________________________________________
@@ -226,7 +243,7 @@ Int_t AliITSclusterTable::FindIndex(Int_t ndim, Int_t *ptr, Int_t value){
   return retval;
 }
 
-void AliITSclusterTable::FillArrayCoorAngles(TTree* clusterTree,Int_t evnumber){
+void AliITSclusterTable::FillArrayCoorAngles(){
   //Fill arrays with phi,lambda and indices of clusters for each layer
   Info("FillArrayCoorAngles","Filling Array...");
 
@@ -239,8 +256,6 @@ void AliITSclusterTable::FillArrayCoorAngles(TTree* clusterTree,Int_t evnumber){
   fSyList = new TArrayD*[fGeom->GetNlayers()];
   fSzList = new TArrayD*[fGeom->GetNlayers()];
 
-  fTracker->SetEventNumber(evnumber);
-  fTracker->LoadClusters(clusterTree);
   Int_t * firstmod = new Int_t[fGeom->GetNlayers()+1];
   firstmod[fGeom->GetNlayers()]=fGeom->GetIndexMax();  // upper limit
 
@@ -277,7 +292,6 @@ void AliITSclusterTable::FillArrayCoorAngles(TTree* clusterTree,Int_t evnumber){
     
   }
   
-  fTracker->UnloadClusters();
   delete [] firstmod;
 }
 
index 2580eda11c8590832e7593b064c845041cabab00..6f3c6c7de0e61f6eb5659972ed4347b4c5b06e50 100644 (file)
@@ -32,10 +32,9 @@ class AliITSclusterTable : public TObject {
 
   AliITSclusterTable();
   AliITSclusterTable(AliITSgeom* geom, AliITStrackerSA* tracker, Double_t* primaryVertex);
-  void FillArray(TTree* clusterTree,Int_t evnumber=0);
-  void FillArrayLabel(Int_t numberofparticles,TTree* clusterTree,
-                     Int_t evnumber=0);
-  void FillArrayCoorAngles(TTree* clusterTree, Int_t evnumber=0);
+  void FillArray(TTree* clusterTree);
+  void FillArrayLabel(Int_t numberofparticles);
+  void FillArrayCoorAngles();
   void GetCoorAngles(AliITSclusterV2* cl,Int_t module,Double_t &phi,Double_t &lambda,Double_t &x,Double_t &y,Double_t &z);
   void GetCoorErrors(AliITSclusterV2* cl, Int_t module,Double_t &sx,Double_t &sy, Double_t &sz);
   virtual ~AliITSclusterTable();
index d84d8a1607d99fb6e1da55d7d12819ca8ba598fd..617ad6a107b18c6108fb0ac4bf22041ede3d7601 100644 (file)
@@ -45,6 +45,15 @@ AliITStrackerSA::AliITStrackerSA():AliITStrackerV2(){
   // Default constructor
   Init();
 }
+//____________________________________________________________________________
+AliITStrackerSA::AliITStrackerSA(AliITSgeom *geom):AliITStrackerV2(geom) 
+{
+  // Standard constructor (Vertex is known and passed to this obj.)
+  Init();
+  fVert = 0;
+  fGeom = geom;
+}
+
 //____________________________________________________________________________
 AliITStrackerSA::AliITStrackerSA(AliITSgeom *geom, AliESDVertex *vert):AliITStrackerV2(geom) 
 {
@@ -145,6 +154,8 @@ void AliITStrackerSA::Init(){
     fFlagLoad = 0;
     SetWindowSizes();
     fTable = 0;
+    fITSclusters = 0;
+    SetSixPoints();
 }
 //_______________________________________________________________________
 void AliITStrackerSA::ResetForFinding(){
@@ -160,26 +171,24 @@ void AliITStrackerSA::ResetForFinding(){
     fPointc[1]=0;
 }
 //____________________________________________________________________________
-void AliITStrackerSA::FindTracks(TTree *clusterTree, TTree *out,Int_t evnumber,char *opt){
+void AliITStrackerSA::FindTracks(TTree *out,Int_t evnumber){
 
   /**************************************************************************
    * This function finds primary tracks.
-   * Options: to use only ITS execute FindTracks                            *
-   *          to define good tracks with 6 points out of 6 in the ITS write *
-   *          *opt="6/6". The default is *opt="6/6"                         *
    *                                                                        * 
    *                                                                        *
    * Example: to execute function with only the ITS (no combined tracking   *
    *          with TPC+ITS) and requiring 5/6 points to define a good track *
-   *          use: FindTracks(treein,treeout,evnumber,"5/6")                *
-   *          to execute combined tracking, before using FindTracks use     *
+   *          call SetSixPoinbts(kFALSE) in advance and then                *
+   *          use: FindTracks(treein,treeout,evnumber)                      *
+   *          to execute combined tracking, before using FindTracks, use    *
    *          UseFoundTracksV2                                              *
    *************************************************************************/
 
-  //options
-  TString choice(opt);
-  Bool_t sixpoints= choice.Contains("6/6");
-
+  if(!fITSclusters){
+    Fatal("FindTracks","ITS cluster tree is not accessed - Abort!!!\n Please use method SetClusterTree to pass the pointer to the tree\n");
+    exit(1);
+  }
   //Get primary vertex
   if(fVertexer){
     if(fVert)delete fVert;
@@ -207,12 +216,10 @@ void AliITStrackerSA::FindTracks(TTree *clusterTree, TTree *out,Int_t evnumber,c
   //Fill array with cluster indices for each module
   if(!fTable){
     fTable = new AliITSclusterTable(fGeom,this,primaryVertex);
-    fTable->FillArray(clusterTree,evnumber);
-    fTable->FillArrayCoorAngles(clusterTree,evnumber); 
+    fTable->FillArray(fITSclusters);
+    fTable->FillArrayCoorAngles(); 
   }
 
-  SetEventNumber(evnumber);
-  if(GetFlagLoadedClusters()==0) LoadClusters(clusterTree);
    
 //Fill tree for found tracks
   AliITStrackV2* outrack=0;
@@ -244,8 +251,8 @@ void AliITStrackerSA::FindTracks(TTree *clusterTree, TTree *out,Int_t evnumber,c
       AliITStrackSA* trs = new AliITStrackSA();      
       fPoint1[0]=primaryVertex[0];
       fPoint1[1]=primaryVertex[1];
-      fPoint2[0]=fTable->GetXCluster(0,ncl);;
-      fPoint2[1]=fTable->GetYCluster(0,ncl);;
+      fPoint2[0]=fTable->GetXCluster(0,ncl);
+      fPoint2[1]=fTable->GetYCluster(0,ncl);
       
       Int_t * nn = new Int_t[fGeom->GetNlayers()];//counter for clusters on each layer
       for(Int_t i=0;i<fGeom->GetNlayers();i++){ nn[i]=0;}
@@ -277,13 +284,13 @@ void AliITStrackerSA::FindTracks(TTree *clusterTree, TTree *out,Int_t evnumber,c
 
       Int_t layOK=0;
       Int_t numberofpoints;
-      if(sixpoints) numberofpoints=6;  //check of the candidate track
+      if(fSixPoints) numberofpoints=6;  //check of the candidate track
       else numberofpoints=5;           //if track is good (with the required number        
       for(Int_t nnp=0;nnp<fGeom->GetNlayers();nnp++){    //of points) it is written on file
         if(nn[nnp]!=0) layOK+=1;
       }
       if(layOK>=numberofpoints){
-        AliITStrackV2* tr2 = FitTrack(trs,primaryVertex,errorsprimvert,opt);
+        AliITStrackV2* tr2 = FitTrack(trs,primaryVertex,errorsprimvert);
         if(tr2==0){
           Int_t nct = trs->GetNumberOfClustersSA();
           while(nct--){
@@ -323,7 +330,7 @@ void AliITStrackerSA::FindTracks(TTree *clusterTree, TTree *out,Int_t evnumber,c
   //from second layer, to find tracks with point of 
   //layer 1 missing
    
-  if(!sixpoints){
+  if(!fSixPoints){
     //   counter for clusters on each layer  
     Int_t * nn = new Int_t[fGeom->GetNlayers()-1];      
     for(Int_t nloop=0;nloop<fNloop;nloop++){
@@ -359,7 +366,7 @@ void AliITStrackerSA::FindTracks(TTree *clusterTree, TTree *out,Int_t evnumber,c
           if(nn[nnp]!=0) fl+=1;
         }
         if(fl>=5){  // 5/6       
-          AliITStrackV2* tr2 = FitTrack(trs,primaryVertex,errorsprimvert,opt);
+          AliITStrackV2* tr2 = FitTrack(trs,primaryVertex,errorsprimvert);
           if(tr2==0){
             Int_t nct = trs->GetNumberOfClustersSA();
             while(nct--){
@@ -392,63 +399,40 @@ void AliITStrackerSA::FindTracks(TTree *clusterTree, TTree *out,Int_t evnumber,c
       }//end loop on clusters of layer2
     }
     delete [] nn;
-  }  //end opt="5/6"  
+  }  // if(!fSixPoints....  
 
   delete [] firstmod;
-
-  UnloadClusters();
+  delete fTable;
 }
 
+
 //______________________________________________________________________
-void AliITStrackerSA::FindTracks(TTree *clusterTree, AliESD* event, Int_t evnumber,char *opt){
-  /**************************************************************************
-   * Options: to use only ITS execute FindTracks                            *
-   *          to define good tracks with 6 points out of 6 in the ITS write *
-   *          *opt="6/6". The default is *opt="6/6"                         *
-   *                                                                        * 
-   *                                                                        *
-   * Example: to execute function with only the ITS (no combined tracking   *
-   *          with TPC+ITS) and requiring 5/6 points to define a good track *
-   *          use: FindTracks(treein,treeout,evnumber,"5/6")                *
-   *          to execute combined tracking, before using FindTracks use     *
-   *          UseFoundTracksV2                                              *
-   *************************************************************************/
+Int_t AliITStrackerSA::FindTracks(AliESD* event){
 
-  //options
-  TString choice(opt);
-  Bool_t sixpoints= choice.Contains("6/6");
-  //Get primary vertex
-  if(fVertexer){
-    if(fVert)delete fVert;
-    fVert = fVertexer->FindVertexForCurrentEvent(evnumber);
-  }
-  else {
-    gAlice->GetEvent(evnumber);
-    if(!fVert){
-      Fatal("FindTracks","Vertex is missing\n");
-      return;
-    }
+  // Track finder using the ESD object
+
+  if(!fITSclusters){
+    Fatal("FindTracks","ITS cluster tree is not accessed - Abort!!!\n Please use method SetClusterTree to pass the pointer to the tree\n");
+    return -1;
   }
-  Double_t primaryVertex[3];
+  //Get primary vertex
   Double_t errorsprimvert[3];
-  fVert->GetXYZ(primaryVertex);
-  fVert->GetSigmaXYZ(errorsprimvert);
+  Double_t primaryVertex[3];
+  event->GetVertex()->GetXYZ(primaryVertex);
+  event->GetVertex()->GetSigmaXYZ(errorsprimvert);
+
   if(errorsprimvert[0]==0 || errorsprimvert[1]==0){
-    Warning("FindTracks","Set errors on vertex positions x and y at 0.0001");
-    errorsprimvert[0]=0.0001;
-    errorsprimvert[1]=0.0001;
+    //    Warning("FindTracks","Set errors on vertex positions x and y at 0.005");
+    errorsprimvert[0]=0.005;
+    errorsprimvert[1]=0.005;
   }
-  fVert->PrintStatus();
 
   //Fill array with cluster indices for each module
-  if(!fTable){
-    fTable = new AliITSclusterTable(fGeom,this,primaryVertex);
-    fTable->FillArray(clusterTree,evnumber);   
-    fTable->FillArrayCoorAngles(clusterTree,evnumber); 
- }
+  fTable = new AliITSclusterTable(fGeom,this,primaryVertex);
+  fTable->FillArray(fITSclusters);
+  fTable->FillArrayCoorAngles();
   
-  SetEventNumber(evnumber);
-  if(GetFlagLoadedClusters()==0) LoadClusters(clusterTree);
 
   Int_t * firstmod = new Int_t[fGeom->GetNlayers()];
   for(Int_t i=0;i<fGeom->GetNlayers();i++){
@@ -507,13 +491,13 @@ void AliITStrackerSA::FindTracks(TTree *clusterTree, AliESD* event, Int_t evnumb
 
       Int_t layOK=0;
       Int_t numberofpoints;
-      if(sixpoints) numberofpoints=6;  //check of the candidate track
+      if(fSixPoints) numberofpoints=6;  //check of the candidate track
       else numberofpoints=5;           //if track is good (with the required number        
       for(Int_t nnp=0;nnp<fGeom->GetNlayers();nnp++){    //of points) it is written on file
         if(nn[nnp]!=0) layOK+=1;
       }
       if(layOK>=numberofpoints){
-        AliITStrackV2* tr2 = FitTrack(trs,primaryVertex,errorsprimvert,opt);
+        AliITStrackV2* tr2 = FitTrack(trs,primaryVertex,errorsprimvert);
         if(tr2==0){
           Int_t nct = trs->GetNumberOfClustersSA();
           while(nct--){
@@ -545,6 +529,7 @@ void AliITStrackerSA::FindTracks(TTree *clusterTree, AliESD* event, Int_t evnumb
         }
       }
       delete trs;
+      delete[] nn;
 
     }//end loop on clusters of layer1
 
@@ -554,7 +539,7 @@ void AliITStrackerSA::FindTracks(TTree *clusterTree, AliESD* event, Int_t evnumb
   //from second layer, to find tracks with point of 
   //layer 1 missing
    
-  if(!sixpoints){
+  if(!fSixPoints){
     //   counter for clusters on each layer  
     Int_t * nn = new Int_t[fGeom->GetNlayers()-1];      
     for(Int_t nloop=0;nloop<fNloop;nloop++){
@@ -589,7 +574,7 @@ void AliITStrackerSA::FindTracks(TTree *clusterTree, AliESD* event, Int_t evnumb
           if(nn[nnp]!=0) fl+=1;
         }
         if(fl>=5){  // 5/6       
-          AliITStrackV2* tr2 = FitTrack(trs,primaryVertex,errorsprimvert,opt);
+          AliITStrackV2* tr2 = FitTrack(trs,primaryVertex,errorsprimvert);
           if(tr2==0){
            ntrack++;
             Int_t nct = trs->GetNumberOfClustersSA();
@@ -630,21 +615,18 @@ void AliITStrackerSA::FindTracks(TTree *clusterTree, AliESD* event, Int_t evnumb
 
   delete [] firstmod;
   delete fTable;   
-  UnloadClusters();
   Info("FindTracks","Number of found tracks: %d",event->GetNumberOfTracks());
 
-
+  return 0;
 
 }
+
+
 //________________________________________________________________________
 
-AliITStrackV2* AliITStrackerSA::FitTrack(AliITStrackSA* tr,Double_t *primaryVertex,Double_t *errorsprimvert,char *opt){
+AliITStrackV2* AliITStrackerSA::FitTrack(AliITStrackSA* tr,Double_t *primaryVertex,Double_t *errorsprimvert){
   //fit of the found track
 
-//options
-  TString choice(opt);
-  Bool_t sixpoints= choice.Contains("6/6");
   
   Int_t * firstmod = new Int_t[fGeom->GetNlayers()];
   for(Int_t i=0;i<fGeom->GetNlayers();i++){
@@ -876,7 +858,7 @@ AliITStrackV2* AliITStrackerSA::FitTrack(AliITStrackSA* tr,Double_t *primaryVert
     labl[2]=-1;
   }
   Int_t numberofpoints;
-  if(sixpoints) numberofpoints=6;
+  if(fSixPoints) numberofpoints=6;
   else numberofpoints=5;
   Int_t label =  Label(cl0->GetLabel(0),cl1->GetLabel(0), 
                        cl2->GetLabel(0),cl3->GetLabel(0),
@@ -921,8 +903,8 @@ void AliITStrackerSA::UseFoundTracksV2(Int_t evnum,TTree* treev2, TTree* cluster
 
   if(!fTable){
     fTable = new AliITSclusterTable(fGeom,this,primaryVertex);
-    fTable->FillArray(clustertree,evnum);
-    fTable->FillArrayCoorAngles(clustertree,evnum);
+    fTable->FillArray(fITSclusters);
+    fTable->FillArrayCoorAngles();
   }
   SetEventNumber(evnum);
   if(GetFlagLoadedClusters()==0) LoadClusters(clustertree);
@@ -968,8 +950,8 @@ clustertree){
 
   if(!fTable){
     fTable = new AliITSclusterTable(fGeom,this,primaryVertex);
-    fTable->FillArray(clustertree,evnum);
-    fTable->FillArrayCoorAngles(clustertree,evnum); 
+    fTable->FillArray(fITSclusters);
+    fTable->FillArrayCoorAngles(); 
   }
   SetEventNumber(evnum);
   if(GetFlagLoadedClusters()==0) LoadClusters(clustertree);
@@ -1006,7 +988,10 @@ Int_t AliITStrackerSA::SearchClusters(Int_t layer,Double_t phiwindow,Double_t la
     Float_t cx1,cx2,cy1,cy2;
     FindEquation(fPoint1[0],fPoint1[1],fPoint2[0],fPoint2[1],fPoint3[0],fPoint3[1],fCoef1,fCoef2,fCoef3);
     Int_t fun = FindIntersection(fCoef1,fCoef2,fCoef3,-(lay.GetR()*lay.GetR()),cx1,cy1,cx2,cy2);
-    if(fun==0) return 0;
+    if(fun==0) {
+      delete[] firstmod;
+      return 0;
+    }
     Double_t fi1 =TMath::ATan2(cy1,cx1);
     Double_t fi2 =TMath::ATan2(cy2,cx2);
     fPhiEstimate = ChoosePoint(fi1,fi2,fPhic);
@@ -1017,20 +1002,23 @@ Int_t AliITStrackerSA::SearchClusters(Int_t layer,Double_t phiwindow,Double_t la
   Double_t zed2  =  TMath::Tan(fLambdac-lambdawindow)*lay.GetR()+zvertex;
   
   Double_t fi = fPhiEstimate;
-  Int_t nmod  = lay.FindDetectorIndex(fi,zed)+firstmod[layer];
+  Int_t nmod  = lay.FindDetectorIndex(fi,zed);
+  if (nmod < 0) {
+    delete[] firstmod;
+    return 0;
+  }
+  nmod += firstmod[layer];
  
   Int_t nm[8]={0,0,0,0,0,0,0,0};
-  nm[0] = lay.FindDetectorIndex(fi+phiwindow,zed)+firstmod[layer];
-  nm[1] = lay.FindDetectorIndex(fi-phiwindow,zed)+firstmod[layer];
-  nm[2]  = lay.FindDetectorIndex(fi,zed1)+firstmod[layer];
-  nm[3]  = lay.FindDetectorIndex(fi,zed2)+firstmod[layer];
-  nm[4]  = lay.FindDetectorIndex(fi+phiwindow,zed1)+firstmod[layer];
-  nm[5]  = lay.FindDetectorIndex(fi-phiwindow,zed1)+firstmod[layer];
-  nm[6]  = lay.FindDetectorIndex(fi+phiwindow,zed2)+firstmod[layer];
-  nm[7]  = lay.FindDetectorIndex(fi-phiwindow,zed2)+firstmod[layer];
+  nm[0] = lay.FindDetectorIndex(fi+phiwindow,zed);
+  nm[1] = lay.FindDetectorIndex(fi-phiwindow,zed);
+  nm[2]  = lay.FindDetectorIndex(fi,zed1);
+  nm[3]  = lay.FindDetectorIndex(fi,zed2);
+  nm[4]  = lay.FindDetectorIndex(fi+phiwindow,zed1);
+  nm[5]  = lay.FindDetectorIndex(fi-phiwindow,zed1);
+  nm[6]  = lay.FindDetectorIndex(fi+phiwindow,zed2);
+  nm[7]  = lay.FindDetectorIndex(fi-phiwindow,zed2);
 
-   if(nmod<0) return 0;
   Int_t nn=0;
   TArrayI* array =(TArrayI*)table->GetListOfClusters(nmod);
   TArrayI* list = new TArrayI(array->GetSize());
@@ -1040,9 +1028,10 @@ Int_t AliITStrackerSA::SearchClusters(Int_t layer,Double_t phiwindow,Double_t la
     nn++;
   }
   
+//  Info("SearchClusters", "layer %d, module %d", layer, nmod);
   for(Int_t ii=0;ii<8;ii++){
     if(nm[ii]!=nmod && nm[ii]>=0){
-      TArrayI* ar =(TArrayI*)table->GetListOfClusters(nm[ii]);
+      TArrayI* ar =(TArrayI*)table->GetListOfClusters(nm[ii]+firstmod[layer]);
       list->Set(list->GetSize()+ar->GetSize());
       for(Int_t j=0;j<ar->GetSize();j++){
         Int_t in=(Int_t)ar->At(j);
@@ -1064,6 +1053,7 @@ Int_t AliITStrackerSA::SearchClusters(Int_t layer,Double_t phiwindow,Double_t la
       nc+=1;
       fLambdac = lambda;
       if(trs->GetNumberOfClustersSA()==20){
+       delete[] firstmod;
         delete list;
         return 0;
       }
index fa60a1b193508dff23868d64471cfebb8322c850..46bd8f0116f30393735a878596d8281e9a9653d2 100644 (file)
@@ -18,6 +18,7 @@ class AliITSclusterTable;
 class AliITStrackSA;
 class AliESDVertex;
 class AliITSVertexer;
+class TTree;
 
 class AliITStrackerSA : public AliITStrackerV2 {
 
@@ -25,19 +26,23 @@ class AliITStrackerSA : public AliITStrackerV2 {
  public:
 
   AliITStrackerSA();
+  AliITStrackerSA(AliITSgeom *geom);
   AliITStrackerSA(AliITSgeom *geom,AliESDVertex *vert);
   AliITStrackerSA(AliITSgeom *geom,AliITSVertexer *vertexer);
   AliITStrackerSA(AliITStrackerSA& tracker);
   virtual ~AliITStrackerSA();  
-  void     FindTracks(TTree *clusterTree, TTree *out,Int_t evnumber=0,
-                      char *opt="6/6");
-  void     FindTracks(TTree *clusterTree, AliESD* event, Int_t evnumber=0,
-                     char *opt="6/6");
+  virtual Int_t Clusters2Tracks(AliESD *event){Int_t rc = AliITStrackerV2::Clusters2Tracks(event); if(!rc)rc=FindTracks(event); return rc;}
+  Int_t FindTracks(AliESD* event);
+  void  FindTracks(TTree *out,Int_t evnumber=0);
   AliITStrackV2* FitTrack(AliITStrackSA* tr,Double_t* primaryVertex,
-                          Double_t *errorprimvert,char *opt="6/6");
+                          Double_t *errorprimvert);
 
   AliITStrackV2* FindTrackLowChiSquare(TObjArray* tracklist, Int_t dim) const;
+  Int_t LoadClusters(TTree *cf) {Int_t rc=AliITStrackerV2::LoadClusters(cf); SetClusterTree(cf); return rc;}
   void SetVertex(AliESDVertex *vtx){fVert = vtx;}
+  void SetClusterTree(TTree * itscl){fITSclusters = itscl;}
+  void SetSixPoints(Bool_t sp = kTRUE){fSixPoints = sp;}
+  Bool_t GetSixPoints() const {return fSixPoints;}
   void SetWindowSizes(Int_t n=46, Double_t *phi=0, Double_t *lam=0);
   void UseFoundTracksV2(Int_t evnum,TTree* treev2, TTree* clustertree);
   void UseFoundTracksV2(Int_t evnum,AliESD *event, TTree* clustertree);
@@ -95,7 +100,9 @@ class AliITStrackerSA : public AliITStrackerV2 {
   AliESDVertex *fVert;        //! primary vertex
   AliITSVertexer *fVertexer;  //! vertexer 
   AliITSgeom *fGeom;          //! ITS geometry
+  TTree *fITSclusters;        //! pointer to ITS tree of clusters
   Int_t fFlagLoad;            //  flag for loaded clusters (1==already loaded)
+  Bool_t fSixPoints;          // If true 6/6 points are required (default). 5/6 otherwise
   AliITSclusterTable* fTable; //  table with clusters
   ClassDef(AliITStrackerSA,1)
 };
index 5e26df14fe609f1f8eee47ece89ce24d4d1f03dc..ab854f4b82fb0bd3e434e2040b91c0caa4438ea5 100644 (file)
@@ -272,17 +272,10 @@ Int_t AliITStrackerV2::Clusters2Tracks(AliESD *event) {
   Int_t entries = fTrackHypothesys.GetEntriesFast();
   for (Int_t ientry=0;ientry<entries;ientry++){
     TObjArray * array =(TObjArray*)fTrackHypothesys.UncheckedAt(ientry);
-    if (array){
-      Int_t arrayentries = array->GetEntriesFast();
-      for (Int_t j=0;j<arrayentries;j++){
-       AliITStrackV2 * track = (AliITStrackV2*)array->UncheckedAt(j);
-       if (track){
-         delete array->RemoveAt(j);
-       }
-      }
-      delete fTrackHypothesys.RemoveAt(ientry); 
-    }
+    if (array) array->Delete();
+    delete fTrackHypothesys.RemoveAt(ientry); 
   }
+
   fTrackHypothesys.Delete();
   Info("Clusters2Tracks","Number of prolonged tracks: %d\n",ntrk);
 
@@ -459,7 +452,7 @@ Int_t AliITStrackerV2::RefitInward(AliESD *event) {
     if ((esd->GetStatus()&AliESDtrack::kITSout) == 0) continue;
     if (esd->GetStatus()&AliESDtrack::kITSrefit) continue;
     if (esd->GetStatus()&AliESDtrack::kTPCout)
-    if ((esd->GetStatus()&AliESDtrack::kTPCrefit)==0) continue;
+      if ((esd->GetStatus()&AliESDtrack::kTPCrefit)==0) continue;
 
     AliITStrackV2 *t=0;
     try {
@@ -480,6 +473,9 @@ Int_t AliITStrackerV2::RefitInward(AliESD *event) {
     ResetTrackToFollow(*t);
     fTrackToFollow.ResetClusters();
 
+    if ((esd->GetStatus()&AliESDtrack::kTPCin)==0)
+      fTrackToFollow.ResetCovariance();
+
     //Refitting...
     if (RefitAt(3.7, &fTrackToFollow, t)) {
        fTrackToFollow.SetLabel(t->GetLabel());
@@ -1159,7 +1155,7 @@ void AliITStrackerV2::AddTrackHypothesys(AliITStrackV2 * track, Int_t esdindex)
 
   if (esdindex>=fTrackHypothesys.GetEntriesFast()) fTrackHypothesys.Expand(esdindex*2+10);
   //
-  TObjArray * array = (TObjArray*) fTrackHypothesys.UncheckedAt(esdindex);
+  TObjArray * array = (TObjArray*) fTrackHypothesys.At(esdindex);
   if (!array) {
     array = new TObjArray(10);
     fTrackHypothesys.AddAt(array,esdindex);
@@ -1173,18 +1169,21 @@ void AliITStrackerV2::CompressTrackHypothesys(Int_t esdindex, Int_t maxsize)
   // compress array of track hypothesys
   // keep only maxsize best hypothesys
   //-------------------------------------------------------------------
-  if (! (fTrackHypothesys.UncheckedAt(esdindex)) ) return;
-  TObjArray * array = (TObjArray*) fTrackHypothesys.UncheckedAt(esdindex);
+  if (esdindex>fTrackHypothesys.GetEntriesFast()) return;
+  if (! (fTrackHypothesys.At(esdindex)) ) return;
+  TObjArray * array = (TObjArray*) fTrackHypothesys.At(esdindex);
   Int_t entries = array->GetEntries();
   if (entries<maxsize) return;
-  Float_t chi2[entries];
-  Int_t index[entries];
+  Float_t * chi2 = new Float_t[entries];
+  Int_t * index = new Int_t[entries];
   Int_t current=0;
   //
   for (Int_t i=0;i<array->GetEntriesFast();i++){
-    AliITStrackV2 * track = (AliITStrackV2*)array->UncheckedAt(i);
-    if (!track) continue;
-    chi2[current] = track->GetNumberOfClusters()+0.001+track->GetChi2()/track->GetNumberOfClusters();
+    AliITStrackV2 * track = (AliITStrackV2*)array->At(i);
+    if (track)
+      chi2[current] = track->GetNumberOfClusters()+0.001+track->GetChi2()/track->GetNumberOfClusters();
+    else
+      chi2[current] = 100000000;
     current++;
   }
   TMath::Sort(current,chi2,index,kFALSE);
@@ -1194,9 +1193,12 @@ void AliITStrackerV2::CompressTrackHypothesys(Int_t esdindex, Int_t maxsize)
     newarray->AddLast(array->RemoveAt(index[i]));
   }
   array->Delete();
-  delete array;
+  delete fTrackHypothesys.RemoveAt(esdindex);
   fTrackHypothesys.AddAt(newarray,esdindex);
 
+  delete [] chi2;
+  delete [] index;
+
 }
 
 
index 973dbf4de769a6e31194790ffed3e58b3facacf2..d6ec88d8f0d2e0bb53bd2a34be623926e1c6bb72 100644 (file)
@@ -33,31 +33,13 @@ AliESD::AliESD():
   fTrigger(0),
   fRecoVersion(0),
   fMagneticField(0),
+  fPrimaryVertex(),
   fTracks("AliESDtrack",15000),
   fCaloTracks("AliESDCaloTrack",500),
   fMuonTracks("AliESDMuonTrack",30),
   fV0s("AliESDv0",200),
   fCascades("AliESDcascade",20)
 {
-  Int_t i;
-  for (i=0; i<3; i++) fVtx[i]=0.;
-  for (i=0; i<6; i++) fCovVtx[i]=0.;
-}
-
-void AliESD::SetVertex(const Double_t *vtx, const Double_t *cvtx) {
-  //Save the primary vertex position
-  Int_t i;
-  for (i=0; i<3; i++) fVtx[i]=vtx[i];
-  if (cvtx)
-  for (i=0; i<6; i++) fCovVtx[i]=cvtx[i];   
-}
-
-void AliESD::GetVertex(Double_t *vtx, Double_t *cvtx) const {
-  //Get the primary vertex position
-  Int_t i;
-  for (i=0; i<3; i++) vtx[i]=fVtx[i];
-  if (cvtx)
-  for (i=0; i<6; i++) cvtx[i]=fCovVtx[i];   
 }
 
 void AliESD::Print(Option_t *) const {
@@ -68,6 +50,10 @@ void AliESD::Print(Option_t *) const {
         GetRunNumber(),
         GetTrigger(),
         GetMagneticField() );
+  printf("Vertex: (%.4f +- %.4f, %.4f +- %.4f, %.4f +- %.4f) cm\n",
+        fPrimaryVertex.GetXv(), fPrimaryVertex.GetXRes(),
+        fPrimaryVertex.GetYv(), fPrimaryVertex.GetYRes(),
+        fPrimaryVertex.GetZv(), fPrimaryVertex.GetZRes());
   printf("Event from reconstruction version %d \n",fRecoVersion);
   printf("Number of tracks: \n");
   printf("                 charged   %d\n",GetNumberOfTracks());
index d1215e7f59e737fe75043cc6fe8be524282b2299..ea3e8aea23015f6493ef3a47a122a5fb592a90d4 100644 (file)
@@ -15,6 +15,7 @@
 
 #include "TObject.h"
 #include "TClonesArray.h"
+#include  "AliESDVertex.h"
 #include  "AliESDtrack.h"
 #include  "AliESDMuonTrack.h"
 #include  "AliESDCaloTrack.h"
@@ -34,6 +35,7 @@ public:
 
   void SetEventNumber(Int_t n) {fEventNumber=n;}
   void SetRunNumber(Int_t n) {fRunNumber=n;}
+  void SetTrigger(Long_t n) {fTrigger=n;}
   void SetMagneticField(Float_t mf){fMagneticField = mf;}
   Float_t GetMagneticField() const {return fMagneticField;}
   
@@ -71,8 +73,10 @@ public:
     new(fCascades[fCascades.GetEntriesFast()]) AliESDcascade(*c);
   }
 
-  void SetVertex(const Double_t *vtx, const Double_t *cvtx=0);
-  void GetVertex(Double_t *vtx, Double_t *cvtx) const;
+  void SetVertex(AliESDVertex* vertex) {
+    new(&fPrimaryVertex) AliESDVertex(*vertex);
+  }
+  const AliESDVertex* GetVertex() const {return &fPrimaryVertex;};
 
   Int_t  GetEventNumber() const {return fEventNumber;}
   Int_t  GetRunNumber() const {return fRunNumber;}
@@ -95,8 +99,7 @@ protected:
   Int_t        fRecoVersion;     // Version of reconstruction 
   Float_t      fMagneticField;   // Solenoid Magnetic Field in kG : for compatibility with AliMagF
 
-  Double_t fVtx[3];              // Primary vertex position
-  Double_t fCovVtx[6];           // Cov. matrix of the primary vertex position
+  AliESDVertex  fPrimaryVertex;  // Primary vertex
 
   TClonesArray  fTracks;         // ESD tracks
   TClonesArray  fCaloTracks;     // Calorimeters' ESD tracks
@@ -104,7 +107,7 @@ protected:
   TClonesArray  fV0s;            // V0 vertices
   TClonesArray  fCascades;       // Cascade vertices
   
-  ClassDef(AliESD,2)  //ESD class 
+  ClassDef(AliESD,3)  //ESD class 
                       //ver. 2: Magnetic Field Added; skowron
 };
 
index febc4a689a174256388b13411561debbe513e160..89b6921a8b63bb0fe91320a2d839eef016472f80 100644 (file)
@@ -135,12 +135,12 @@ void AliESDVertex::SetToZero() {
     fTruePos[i] = 0;
     fSNR[i] = 0.;
   }
-  fCovXX         = 0;
+  fCovXX         = 0.005*0.005;
   fCovXY         = 0;
-  fCovYY         = 0;
+  fCovYY         = 0.005*0.005;
   fCovXZ         = 0;
   fCovYZ         = 0;
-  fCovZZ         = 0;
+  fCovZZ         = 5.3*5.3;
 
   fChi2          = 0;
   fNContributors = 0;
index 9420c0fe37d45b8dd17612690ccff6fae06e208a..7af82640ee59d3c3c4ac3d5a4a5b4a36c476e882 100644 (file)
@@ -3,6 +3,7 @@
 /* Copyright(c) 1998-2003, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
+/* $Id$ */
 
 //-------------------------------------------------------
 //                    Primary Vertex Class
index d70269c6c92a1b86bc8166bec5df1447f18378ff..20d1609b6fba94abb379df41dea19e8e9c2c1b92 100644 (file)
@@ -22,6 +22,7 @@ class AliLoader;
 class AliTrackReference;
 class AliDigitizer;
 class AliRunDigitizer;
+class AliVertexer;
 class AliTracker;
 class AliESD;
 class AliRunLoader;
@@ -91,6 +92,7 @@ public:
   virtual void        Hits2Digits() {}
   virtual void        Digits2Reco() {}
   virtual void        Reconstruct() const {}
+  virtual AliVertexer* CreateVertexer() const {return NULL;}
   virtual AliTracker* CreateTracker() const {return NULL;}
   virtual void        FillESD(AliESD* /*esd*/) const {}
   virtual void        Digits2Raw() {}
index d7c1c878a3655fddbd1c815dbb959818b9c429ad..54b1dbbc3a51ebf48bf43ace34fc5c3f92f7934e 100644 (file)
@@ -75,6 +75,8 @@
 #include "AliDetector.h"
 #include "AliTracker.h"
 #include "AliESD.h"
+#include "AliESDVertex.h"
+#include "AliVertexer.h"
 #include "AliHeader.h"
 #include "AliGenEventHeader.h"
 #include "AliESDpid.h"
@@ -93,6 +95,7 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename,
   TNamed(name, title),
 
   fRunReconstruction("ALL"),
+  fRunVertexFinder(kTRUE),
   fRunTracking(kTRUE),
   fFillESD("ALL"),
   fGAliceFileName(gAliceFilename),
@@ -101,6 +104,7 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename,
 
   fRunLoader(NULL),
   fITSLoader(NULL),
+  fITSVertexer(NULL),
   fITSTracker(NULL),
   fTPCLoader(NULL),
   fTPCTracker(NULL),
@@ -118,6 +122,7 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
   TNamed(rec),
 
   fRunReconstruction(rec.fRunReconstruction),
+  fRunVertexFinder(rec.fRunVertexFinder),
   fRunTracking(rec.fRunTracking),
   fFillESD(rec.fFillESD),
   fGAliceFileName(rec.fGAliceFileName),
@@ -126,6 +131,7 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
 
   fRunLoader(NULL),
   fITSLoader(NULL),
+  fITSVertexer(NULL),
   fITSTracker(NULL),
   fTPCLoader(NULL),
   fTPCTracker(NULL),
@@ -195,7 +201,15 @@ Bool_t AliReconstruction::Run()
       if (fStopOnError) {CleanUp(); return kFALSE;}
     }
   }
-  if (!fRunTracking && fFillESD.IsNull()) return kTRUE;
+  if (!fRunVertexFinder && !fRunTracking && fFillESD.IsNull()) return kTRUE;
+
+  // get vertexer
+  if (fRunVertexFinder && !CreateVertexer()) {
+    if (fStopOnError) {
+      CleanUp(); 
+      return kFALSE;
+    }
+  }
 
   // get loaders and trackers
   if (fRunTracking && !CreateTrackers()) {
@@ -227,6 +241,16 @@ Bool_t AliReconstruction::Run()
     esd->SetEventNumber(aliRun->GetEvNumber());
     esd->SetMagneticField(aliRun->Field()->SolenoidField());
 
+    // vertex finder
+    if (fRunVertexFinder) {
+      if (!ReadESD(esd, "vertex")) {
+       if (!RunVertexFinder(esd)) {
+         if (fStopOnError) {CleanUp(file); return kFALSE;}
+       }
+       if (fCheckPointLevel > 0) WriteESD(esd, "vertex");
+      }
+    }
+
     // barrel tracking
     if (fRunTracking) {
       if (!ReadESD(esd, "tracking")) {
@@ -305,28 +329,64 @@ Bool_t AliReconstruction::RunReconstruction(const TString& detectors)
 }
 
 //_____________________________________________________________________________
-Bool_t AliReconstruction::RunTracking(AliESD*& esd)
+Bool_t AliReconstruction::RunVertexFinder(AliESD*& esd)
 {
 // run the barrel tracking
 
   TStopwatch stopwatch;
   stopwatch.Start();
 
-  // get the primary vertex (from MC for the moment)
-  TArrayF vertex(3);     
-  fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(vertex);
-  Double_t vtxPos[3] = {vertex[0], vertex[1], vertex[2]};
-  Double_t vtxCov[6] = {
-    0.005,
-    0.000, 0.005,
-    0.000, 0.000, 0.010
-  };
-  Double_t vtxErr[3] = {vtxCov[0], vtxCov[2], vtxCov[5]}; // diag. elements
-  esd->SetVertex(vtxPos, vtxCov);
+  AliESDVertex* vertex = NULL;
+  Double_t vtxPos[3] = {0, 0, 0};
+  Double_t vtxErr[3] = {0.07, 0.07, 0.1};
+  TArrayF mcVertex(3); 
+  fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(mcVertex);
+  for (Int_t i = 0; i < 3; i++) vtxPos[i] = mcVertex[i];
+
+  if (fITSVertexer) {
+    Info("RunVertexFinder", "running the ITS vertex finder");
+    fITSVertexer->SetDebug(1);
+    vertex = fITSVertexer->FindVertexForCurrentEvent(fRunLoader->GetEventNumber());
+    if(!vertex){
+      Warning("RunVertexFinder","Vertex not found \n");
+      vtxErr[2]=10000.;
+      vertex = new AliESDVertex(vtxPos, vtxErr);
+    }
+    else {
+      vertex->SetTruePos(vtxPos);  // store also the vertex from MC
+    }
+
+  } else {
+    Info("RunVertexFinder", "getting the primary vertex from MC");
+    vertex = new AliESDVertex(vtxPos, vtxErr);
+  }
+
+  if (vertex) {
+    vertex->GetXYZ(vtxPos);
+    vertex->GetSigmaXYZ(vtxErr);
+  } else {
+    Warning("RunVertexFinder", "no vertex reconstructed");
+    vertex = new AliESDVertex(vtxPos, vtxErr);
+  }
+  esd->SetVertex(vertex);
   if (fITSTracker) fITSTracker->SetVertex(vtxPos, vtxErr);
   if (fTPCTracker) fTPCTracker->SetVertex(vtxPos, vtxErr);
   if (fTRDTracker) fTRDTracker->SetVertex(vtxPos, vtxErr);
-  if (fCheckPointLevel > 1) WriteESD(esd, "vertex");
+  delete vertex;
+
+  Info("RunVertexFinder", "execution time:");
+  stopwatch.Print();
+
+  return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::RunTracking(AliESD*& esd)
+{
+// run the barrel tracking
+
+  TStopwatch stopwatch;
+  stopwatch.Start();
 
   if (!fTPCTracker) {
     Error("RunTracking", "no TPC tracker");
@@ -534,6 +594,24 @@ Bool_t AliReconstruction::IsSelected(TString detName, TString& detectors) const
   return result;
 }
 
+//_____________________________________________________________________________
+Bool_t AliReconstruction::CreateVertexer()
+{
+// create the vertexer
+
+  fITSVertexer = NULL;
+  AliRun* aliRun = fRunLoader->GetAliRun();
+  if (aliRun->GetDetector("ITS")) {
+    fITSVertexer = aliRun->GetDetector("ITS")->CreateVertexer();
+  }
+  if (!fITSVertexer) {
+    Warning("CreateVertexer", "couldn't create a vertexer for ITS");
+    if (fStopOnError) return kFALSE;
+  }
+
+  return kTRUE;
+}
+
 //_____________________________________________________________________________
 Bool_t AliReconstruction::CreateTrackers()
 {
@@ -609,6 +687,8 @@ void AliReconstruction::CleanUp(TFile* file)
 {
 // delete trackers and the run loader and close and delete the file
 
+  delete fITSVertexer;
+  fITSVertexer = NULL;
   delete fITSTracker;
   fITSTracker = NULL;
   delete fTPCTracker;
index 43e6be73d96758a14a07c9cc8a3cb82a0656721f..ba4ded0736c29fae3dd4acac51c67c18f1e39422 100644 (file)
@@ -10,6 +10,7 @@
 
 class AliRunLoader;
 class AliLoader;
+class AliVertexer;
 class AliTracker;
 class AliESD;
 class TFile;
@@ -28,6 +29,7 @@ public:
 
   void           SetRunReconstruction(const char* detectors) {
     fRunReconstruction = detectors;};
+  void           SetRunVertexFinder(Bool_t run) {fRunVertexFinder = run;};
   void           SetRunTracking(Bool_t run) {fRunTracking = run;};
   void           SetFillESD(const char* detectors) {fFillESD = detectors;};
 
@@ -40,10 +42,12 @@ public:
 
 private:
   Bool_t         RunReconstruction(const TString& detectors);
+  Bool_t         RunVertexFinder(AliESD*& esd);
   Bool_t         RunTracking(AliESD*& esd);
   Bool_t         FillESD(AliESD*& esd, const TString& detectors);
 
   Bool_t         IsSelected(TString detName, TString& detectors) const;
+  Bool_t         CreateVertexer();
   Bool_t         CreateTrackers();
   void           CleanUp(TFile* file = NULL);
 
@@ -51,6 +55,7 @@ private:
   void           WriteESD(AliESD* esd, const char* recStep) const;
 
   TString        fRunReconstruction;  // run the reconstr. for these detectors
+  Bool_t         fRunVertexFinder;    // run the vertex finder
   Bool_t         fRunTracking;        // run the barrel tracking
   TString        fFillESD;            // fill ESD for these detectors
   TString        fGAliceFileName;     // name of the galice file
@@ -59,6 +64,7 @@ private:
 
   AliRunLoader*  fRunLoader;          //! current run loader object
   AliLoader*     fITSLoader;          //! loader for ITS
+  AliVertexer*   fITSVertexer;        //! vertexer for ITS
   AliTracker*    fITSTracker;         //! tracker for ITS
   AliLoader*     fTPCLoader;          //! loader for TPC
   AliTracker*    fTPCTracker;         //! tracker for TPC
diff --git a/STEER/AliVertexer.cxx b/STEER/AliVertexer.cxx
new file mode 100644 (file)
index 0000000..1125ff7
--- /dev/null
@@ -0,0 +1,46 @@
+#include <AliESDVertex.h>
+#include <AliVertexer.h>
+
+ClassImp(AliVertexer)
+
+//////////////////////////////////////////////////////////////////////
+// Base class for primary vertex reconstruction                     //
+// AliESDVertexer is a class for full 3D primary vertex finding     //
+// derived classes: AliITSVertexer                                  //
+//                                                                  //
+//////////////////////////////////////////////////////////////////////
+
+//______________________________________________________________________
+AliVertexer::AliVertexer() {
+  // Default Constructor
+
+    fCurrentVertex  = 0;
+    SetDebug();
+    SetFirstEvent(0);
+    SetLastEvent(0);
+}
+
+
+//______________________________________________________________________
+AliVertexer::AliVertexer(const AliVertexer &vtxr) : TObject(vtxr) {
+  // Copy constructor
+  // Copies are not allowed. The method is protected to avoid misuse.
+  Error("AliVertexer","Copy constructor not allowed\n");
+}
+
+//______________________________________________________________________
+AliVertexer& AliVertexer::operator=(const AliVertexer& /* vtxr */){
+  // Assignment operator
+  // Assignment is not allowed. The method is protected to avoid misuse.
+  Error("= operator","Assignment operator not allowed\n");
+  return *this;
+}
+
+//______________________________________________________________________
+AliVertexer::~AliVertexer() {
+  // Default Destructor
+  // The objects pointed by the following pointers are not owned
+  // by this class and are not deleted
+
+    fCurrentVertex  = 0;
+}
diff --git a/STEER/AliVertexer.h b/STEER/AliVertexer.h
new file mode 100644 (file)
index 0000000..64afa9e
--- /dev/null
@@ -0,0 +1,54 @@
+#ifndef ALIVERTEXER_H
+#define ALIVERTEXER_H
+
+#include<TObject.h>
+
+///////////////////////////////////////////////////////////////////
+//                                                               //
+// Base class for primary vertex reconstruction                  //
+//                                                               //
+///////////////////////////////////////////////////////////////////
+
+class TFile;
+class TString;
+class TTRee;
+class AliESDVertex;
+
+
+class AliVertexer : public TObject {
+
+ public:
+    // default constructor
+    AliVertexer();  
+    // destructor
+    virtual ~AliVertexer(); 
+    // computes the vertex for the current event
+    virtual AliESDVertex* FindVertexForCurrentEvent(Int_t evnumb)=0; 
+    // computes the vetex for each event and stores it on file
+    virtual void FindVertices()= 0;
+    virtual void PrintStatus() const = 0;
+    virtual void SetDebug(Int_t debug = 0){fDebug = debug;}
+    virtual void SetFirstEvent(Int_t ev){fFirstEvent = ev;}
+    virtual void SetLastEvent(Int_t ev){fLastEvent = ev;}
+    virtual void SetUseV2Clusters(Bool_t choice) = 0;
+    virtual void WriteCurrentVertex() = 0;
+
+ protected:
+    // copy constructor (NO copy allowed: the constructor is protected
+    // to avoid misuse)
+    AliVertexer(const AliVertexer& vtxr);
+    // assignment operator (NO assignment allowed)
+    AliVertexer& operator=(const AliVertexer& /* vtxr */);
+
+    AliESDVertex *fCurrentVertex;  //! pointer to the vertex of the current
+                                   //  event
+    Int_t fFirstEvent;          // First event to be processed by FindVertices
+    Int_t fLastEvent;           // Last event to be processed by FindVertices 
+    Int_t fDebug;               //! debug flag - verbose printing if >0
+
+  ClassDef(AliVertexer,1);
+};
+
+#endif
index b6cff99d1065167896a207dc6b99b106d1784316..184821bdba505b7081298315e4077844c08f5192 100644 (file)
@@ -81,6 +81,7 @@
 #pragma link C++ class  AliSimulation+;
 #pragma link C++ class  AliReconstruction+;
 #pragma link C++ class  AliVertexGenFile+;
+#pragma link C++ class  AliVertexer+;
 #endif
 
 
index cc51982eff069a099750897aace2d7b0f72ced13..1dc42039e7d482ae1428b91168e58f048cfe7d30 100644 (file)
@@ -17,6 +17,7 @@ AliGausCorr.cxx AliTrackReference.cxx AliESD.cxx \
 AliTrackMap.cxx AliTrackMapper.cxx AliCollisionGeometry.cxx \
 AliMemoryWatcher.cxx AliBarrelTrack.cxx \
 AliESDtrack.cxx AliESDCaloTrack.cxx AliESDMuonTrack.cxx AliESDv0.cxx AliESDcascade.cxx AliESDVertex.cxx AliESDpid.cxx \
+AliVertexer.cxx \
 AliMC.cxx AliSimulation.cxx AliReconstruction.cxx AliVertexGenFile.cxx 
 HDRS:= $(SRCS:.cxx=.h)