Modified trackleting: AliMultiplicity stores info if the clusters
authorshahoian <shahoian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 17 Jun 2010 11:58:25 +0000 (11:58 +0000)
committershahoian <shahoian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 17 Jun 2010 11:58:25 +0000 (11:58 +0000)
used by the tracklets or "singles" are used in tracks.
The trackleting step is moved from the vertexer to the end of
reconstruction loop.

17 files changed:
ITS/AliITSMultReconstructor.cxx
ITS/AliITSMultReconstructor.h
ITS/AliITSReconstructor.cxx
ITS/AliITSReconstructor.h
ITS/AliITSVertexer3D.cxx
ITS/AliITSVertexerCosmics.cxx
ITS/AliITSVertexerZ.cxx
STEER/AliESDtrack.h
STEER/AliMultiplicity.cxx
STEER/AliMultiplicity.h
STEER/AliReconstruction.cxx
STEER/AliReconstruction.h
STEER/AliReconstructor.h
STEER/AliTrackleter.cxx [new file with mode: 0644]
STEER/AliTrackleter.h [new file with mode: 0644]
STEER/STEERLinkDef.h
STEER/libSTEER.pkg

index 651cae1..53e4338 100644 (file)
@@ -13,8 +13,6 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/* $Id$ */
-
 //_________________________________________________________________________
 // 
 //        Implementation of the ITS-SPD trackleter class
 //     - update to the new algorithm by Mariella and Jan Fiete
 //     - store also DeltaTheta in the ESD 
 //     - less new and delete calls when creating the needed arrays
+//
+//     - RS: to decrease the number of new/deletes the clusters data are stored 
+//           not in float[6] attached to float**, but in 1-D array.
+//     - RS: Clusters are sorted in Z in roder to have the same numbering as in the ITS reco
+//     - RS: Clusters used by ESDtrack are flagged, this information is passed to AliMulitiplicity object 
+//           when storing the tracklets and single cluster info
 //_________________________________________________________________________
 
 #include <TClonesArray.h>
 #include <TH1F.h>
 #include <TH2F.h>
 #include <TTree.h>
-#include "TArrayI.h"
+#include <TBits.h>
+#include <TArrayI.h>
 
 #include "AliITSMultReconstructor.h"
 #include "AliITSReconstructor.h"
 #include "AliITSRecPointContainer.h"
 #include "AliITSgeom.h"
 #include "AliITSgeomTGeo.h"
+#include "AliITSDetTypeRec.h"
+#include "AliESDEvent.h"
+#include "AliESDVertex.h"
+#include "AliESDtrack.h"
+#include "AliMultiplicity.h"
 #include "AliLog.h"
 #include "TGeoGlobalMagField.h"
 #include "AliMagF.h"
@@ -79,7 +89,7 @@ ClassImp(AliITSMultReconstructor)
 
 //____________________________________________________________________
 AliITSMultReconstructor::AliITSMultReconstructor():
-TObject(),
+fDetTypeRec(0),fESDEvent(0),fTreeRP(0),fUsedClusLay1(0),fUsedClusLay2(0),
 fClustersLay1(0),
 fClustersLay2(0),
 fDetectorIndexClustersLay1(0),
@@ -112,11 +122,9 @@ fhphiClustersLay1(0){
 
   fNFiredChips[0] = 0;
   fNFiredChips[1] = 0;
-
   // Method to reconstruct the charged particles multiplicity with the 
   // SPD (tracklets).
 
-
   SetHistOn();
 
   if(AliITSReconstructor::GetRecoParam()) { 
@@ -135,7 +143,6 @@ fhphiClustersLay1(0){
     SetZetaOverlapCut();
   } 
   
-
   fClustersLay1              = 0;
   fClustersLay2              = 0;
   fDetectorIndexClustersLay1 = 0;
@@ -168,45 +175,50 @@ fhphiClustersLay1(0){
 }
 
 //______________________________________________________________________
-AliITSMultReconstructor::AliITSMultReconstructor(const AliITSMultReconstructor &mr) : TObject(mr),
-fClustersLay1(mr.fClustersLay1),
-fClustersLay2(mr.fClustersLay2),
-fDetectorIndexClustersLay1(mr.fDetectorIndexClustersLay1),
-fDetectorIndexClustersLay2(mr.fDetectorIndexClustersLay2),
-fOverlapFlagClustersLay1(mr.fOverlapFlagClustersLay1),
-fOverlapFlagClustersLay2(mr.fOverlapFlagClustersLay2),
-fTracklets(mr.fTracklets),
-fSClusters(mr.fSClusters),
-fNClustersLay1(mr.fNClustersLay1),
-fNClustersLay2(mr.fNClustersLay2),
-fNTracklets(mr.fNTracklets),
-fNSingleCluster(mr.fNSingleCluster),
-fPhiWindow(mr.fPhiWindow),
-fThetaWindow(mr.fThetaWindow),
-fPhiShift(mr.fPhiShift),
-fRemoveClustersFromOverlaps(mr.fRemoveClustersFromOverlaps),
-fPhiOverlapCut(mr.fPhiOverlapCut),
-fZetaOverlapCut(mr.fZetaOverlapCut),
-fHistOn(mr.fHistOn),
-fhClustersDPhiAcc(mr.fhClustersDPhiAcc),
-fhClustersDThetaAcc(mr.fhClustersDThetaAcc),
-fhClustersDPhiAll(mr.fhClustersDPhiAll),
-fhClustersDThetaAll(mr.fhClustersDThetaAll),
-fhDPhiVsDThetaAll(mr.fhDPhiVsDThetaAll),
-fhDPhiVsDThetaAcc(mr.fhDPhiVsDThetaAcc),
-fhetaTracklets(mr.fhetaTracklets),
-fhphiTracklets(mr.fhphiTracklets),
-fhetaClustersLay1(mr.fhetaClustersLay1),
-fhphiClustersLay1(mr.fhphiClustersLay1) {
-  // Copy constructor
-
+AliITSMultReconstructor::AliITSMultReconstructor(const AliITSMultReconstructor &mr) : 
+AliTrackleter(mr),
+fDetTypeRec(0),fESDEvent(0),fTreeRP(0),fUsedClusLay1(0),fUsedClusLay2(0),
+fClustersLay1(0),
+fClustersLay2(0),
+fDetectorIndexClustersLay1(0),
+fDetectorIndexClustersLay2(0),
+fOverlapFlagClustersLay1(0),
+fOverlapFlagClustersLay2(0),
+fTracklets(0),
+fSClusters(0),
+fNClustersLay1(0),
+fNClustersLay2(0),
+fNTracklets(0),
+fNSingleCluster(0),
+fPhiWindow(0),
+fThetaWindow(0),
+fPhiShift(0),
+fRemoveClustersFromOverlaps(0),
+fPhiOverlapCut(0),
+fZetaOverlapCut(0),
+fHistOn(0),
+fhClustersDPhiAcc(0),
+fhClustersDThetaAcc(0),
+fhClustersDPhiAll(0),
+fhClustersDThetaAll(0),
+fhDPhiVsDThetaAll(0),
+fhDPhiVsDThetaAcc(0),
+fhetaTracklets(0),
+fhphiTracklets(0),
+fhetaClustersLay1(0),
+fhphiClustersLay1(0)
+ {
+  // Copy constructor :!!! RS ATTENTION: old c-tor reassigned the pointers instead of creating a new copy -> would crash on delete
+   AliError("May not use");
 }
 
 //______________________________________________________________________
 AliITSMultReconstructor& AliITSMultReconstructor::operator=(const AliITSMultReconstructor& mr){
   // Assignment operator
-  this->~AliITSMultReconstructor();
-  new(this) AliITSMultReconstructor(mr);
+  if (this != &mr) {
+    this->~AliITSMultReconstructor();
+    new(this) AliITSMultReconstructor(mr);
+  }
   return *this;
 }
 
@@ -225,14 +237,9 @@ AliITSMultReconstructor::~AliITSMultReconstructor(){
   delete fhphiTracklets;
   delete fhetaClustersLay1;
   delete fhphiClustersLay1;
-
-  // delete arrays
-  for(Int_t i=0; i<fNClustersLay1; i++)
-    delete [] fClustersLay1[i];
-    
-  for(Int_t i=0; i<fNClustersLay2; i++)
-    delete [] fClustersLay2[i];
-    
+  delete[] fUsedClusLay1;
+  delete[] fUsedClusLay2;
+  // delete arrays    
   for(Int_t i=0; i<fNTracklets; i++)
     delete [] fTracklets[i];
     
@@ -250,9 +257,10 @@ AliITSMultReconstructor::~AliITSMultReconstructor(){
 }
 
 //____________________________________________________________________
-void AliITSMultReconstructor::Reconstruct(TTree* clusterTree, Float_t* vtx, Float_t* /* vtxRes*/) {
+void AliITSMultReconstructor::Reconstruct(AliESDEvent* esd, TTree* treeRP) 
+{
   //
-  // - calls LoadClusterArray that finds the position of the clusters
+  // - calls LoadClusterArrays that finds the position of the clusters
   //   (in global coord) 
   // - convert the cluster coordinates to theta, phi (seen from the
   //   interaction vertex). 
@@ -262,13 +270,79 @@ void AliITSMultReconstructor::Reconstruct(TTree* clusterTree, Float_t* vtx, Floa
   // and the tracklets can be retrieved by calling the Get'er methods.
 
   // reset counters
+  if (fMult) delete fMult; fMult = 0;
+  fNClustersLay1 = 0;
+  fNClustersLay2 = 0;
+  fNTracklets = 0; 
+  fNSingleCluster = 0;
+  //
+  if (!treeRP) { AliError(" Invalid ITS cluster tree !\n"); return; }
+  //
+  fESDEvent = esd;
+  fTreeRP = treeRP;
+  //
+  // >>>> RS: this part is equivalent to former AliITSVertexer::FindMultiplicity
+  //
+  // see if there is a SPD vertex 
+  Bool_t isVtxOK=kTRUE, isCosmics=kFALSE;
+  AliESDVertex* vtx = (AliESDVertex*)fESDEvent->GetPrimaryVertexSPD();
+  if (!vtx && vtx->GetNContributors()<0) isVtxOK = kFALSE;
+  if (vtx && strstr(vtx->GetTitle(),"cosmics")) {
+    isVtxOK = kFALSE;
+    isCosmics = kTRUE;
+  }
+  //
+  if (!isVtxOK) {
+    if (!isCosmics) {
+      AliDebug(1,"Tracklets multiplicity not determined because the primary vertex was not found");
+      AliDebug(1,"Just counting the number of cluster-fired chips on the SPD layers");
+    }
+    vtx = 0;
+  }
+  float vtxf[3] = {vtx->GetX(),vtx->GetY(),vtx->GetZ()};
+  FindTracklets(vtxf);
+  //
+  CreateMultiplicityObject();
+}
+
+//____________________________________________________________________
+void AliITSMultReconstructor::Reconstruct(TTree* clusterTree, Float_t* vtx, Float_t* /* vtxRes*/) {
+  //
+  // RS NOTE - this is old reconstructor invocation, to be used from VertexFinder
+  //
+  // - calls LoadClusterArray that finds the position of the clusters
+  //   (in global coord) 
+  // - convert the cluster coordinates to theta, phi (seen from the
+  //   interaction vertex). 
+  // - makes an array of tracklets 
+  //   
+  // After this method has been called, the clusters of the two layers
+  // and the tracklets can be retrieved by calling the Get'er methods.
+  if (fMult) delete fMult; fMult = 0;
   fNClustersLay1 = 0;
   fNClustersLay2 = 0;
   fNTracklets = 0; 
   fNSingleCluster = 0;
+  //
+  if (!clusterTree) { AliError(" Invalid ITS cluster tree !\n"); return; }
+  //
+  fESDEvent = 0;
+  fTreeRP = clusterTree;
+  //
+  FindTracklets(vtx);
+  //
+}
 
-  // loading the clusters 
-  LoadClusterArrays(clusterTree);
+//____________________________________________________________________
+void AliITSMultReconstructor::FindTracklets(const Float_t *vtx) 
+{
+  // Find tracklets converging to vertex
+  //
+  LoadClusterArrays(fTreeRP);
+  // flag clusters used by ESD tracks
+  ProcessESDTracks();
+
+  if (!vtx) return;
 
   const Double_t pi = TMath::Pi();
   
@@ -276,8 +350,7 @@ void AliITSMultReconstructor::Reconstruct(TTree* clusterTree, Float_t* vtx, Floa
   // get average magnetic field
   Float_t bz = 0;
   AliMagF* field = 0;
-  if (TGeoGlobalMagField::Instance())
-    field = dynamic_cast<AliMagF*>(TGeoGlobalMagField::Instance()->GetField());
+  if (TGeoGlobalMagField::Instance()) field = dynamic_cast<AliMagF*>(TGeoGlobalMagField::Instance()->GetField());
   if (!field)
   {
     AliError("Could not retrieve magnetic field. Assuming no field. Delta Phi shift will be deactivated in AliITSMultReconstructor.")
@@ -311,34 +384,36 @@ void AliITSMultReconstructor::Reconstruct(TTree* clusterTree, Float_t* vtx, Floa
   //###########################################################
   // Loop on layer 1 : finding theta, phi and z 
   for (Int_t iC1=0; iC1<fNClustersLay1; iC1++) {    
-    Float_t x = fClustersLay1[iC1][0] - vtx[0];
-    Float_t y = fClustersLay1[iC1][1] - vtx[1];
-    Float_t z = fClustersLay1[iC1][2] - vtx[2];
+    float *clPar = GetClusterLayer1(iC1);
+    Float_t x = clPar[kClTh] - vtx[0];
+    Float_t y = clPar[kClPh] - vtx[1];
+    Float_t z = clPar[kClZ]  - vtx[2];
 
     Float_t r    = TMath::Sqrt(x*x + y*y + z*z);
     
-    fClustersLay1[iC1][0] = TMath::ACos(z/r);                   // Store Theta
-    fClustersLay1[iC1][1] = TMath::Pi() + TMath::ATan2(-y,-x);  // Store Phi
+    clPar[kClTh] = TMath::ACos(z/r);                   // Store Theta
+    clPar[kClPh] = TMath::Pi() + TMath::ATan2(-y,-x);  // Store Phi
     
     if (fHistOn) {
-      Float_t eta=fClustersLay1[iC1][0];
+      Float_t eta = clPar[kClTh];
       eta= TMath::Tan(eta/2.);
       eta=-TMath::Log(eta);
       fhetaClustersLay1->Fill(eta);    
-      fhphiClustersLay1->Fill(fClustersLay1[iC1][1]);
+      fhphiClustersLay1->Fill(clPar[kClPh]);
     }      
   }
   
   // Loop on layer 2 : finding theta, phi and r   
   for (Int_t iC2=0; iC2<fNClustersLay2; iC2++) {    
-    Float_t x = fClustersLay2[iC2][0] - vtx[0];
-    Float_t y = fClustersLay2[iC2][1] - vtx[1];
-    Float_t z = fClustersLay2[iC2][2] - vtx[2];
+    float *clPar = GetClusterLayer2(iC2);
+    Float_t x = clPar[kClTh] - vtx[0];
+    Float_t y = clPar[kClPh] - vtx[1];
+    Float_t z = clPar[kClZ]  - vtx[2];
    
     Float_t r    = TMath::Sqrt(x*x + y*y + z*z);
-    
-    fClustersLay2[iC2][0] = TMath::ACos(z/r);                   // Store Theta
-    fClustersLay2[iC2][1] = TMath::Pi() + TMath::ATan2(-y,-x);  // Store Phi
+
+    clPar[kClTh] = TMath::ACos(z/r);                   // Store Theta
+    clPar[kClPh] = TMath::Pi() + TMath::ATan2(-y,-x);  // Store Phi    
   }  
   
   //###########################################################
@@ -358,16 +433,18 @@ void AliITSMultReconstructor::Reconstruct(TTree* clusterTree, Float_t* vtx, Floa
       // reset of variables for multiple candidates
       Int_t  iC2WithBestDist = -1;   // reset
       Double_t minDist       =  2;   // reset
-     
+      float* clPar1 = GetClusterLayer1(iC1);
+
       // Loop on layer 2 
       for (Int_t iC2=0; iC2<fNClustersLay2; iC2++) {      
 
         // in the overlap ?
         if (fOverlapFlagClustersLay2[iC2]) continue;
+       float* clPar2 = GetClusterLayer2(iC2);
 
         if (blacklist[iC1]) {
           Bool_t blacklisted = kFALSE;
-          for (Int_t i=0; i<blacklist[iC1]->GetSize(); i++) {
+          for (Int_t i=blacklist[iC1]->GetSize(); i--;) {
             if (blacklist[iC1]->At(i) == iC2) {
               blacklisted = kTRUE;
               break;
@@ -377,8 +454,8 @@ void AliITSMultReconstructor::Reconstruct(TTree* clusterTree, Float_t* vtx, Floa
         }
 
        // find the difference in angles
-       Double_t dTheta = TMath::Abs(fClustersLay2[iC2][0] - fClustersLay1[iC1][0]);
-       Double_t dPhi  = TMath::Abs(fClustersLay2[iC2][1] - fClustersLay1[iC1][1]);
+       Double_t dTheta = TMath::Abs(clPar2[kClTh] - clPar1[kClTh]);
+       Double_t dPhi   = TMath::Abs(clPar2[kClPh] - clPar1[kClPh]);
         // take into account boundary condition
         if (dPhi>pi) dPhi=2.*pi-dPhi;
         
@@ -447,28 +524,29 @@ void AliITSMultReconstructor::Reconstruct(TTree* clusterTree, Float_t* vtx, Floa
 
     if (fOverlapFlagClustersLay1[partners[iC2]] || fOverlapFlagClustersLay2[iC2]) continue;
 
-    fTracklets[fNTracklets] = new Float_t[6];
+    float* clPar2 = GetClusterLayer2(iC2);
+    float* clPar1 = GetClusterLayer1(partners[iC2]);
+
+    Float_t* tracklet = fTracklets[fNTracklets] = new Float_t[kTrNPar]; // RS Add also the cluster id's
   
     // use the theta from the clusters in the first layer
-    fTracklets[fNTracklets][0] = fClustersLay1[partners[iC2]][0];
+    tracklet[kTrTheta] = clPar1[kClTh];
     // use the phi from the clusters in the first layer
-    fTracklets[fNTracklets][1] = fClustersLay1[partners[iC2]][1];
+    tracklet[kTrPhi] = clPar1[kClPh];
     // store the difference between phi1 and phi2
-    fTracklets[fNTracklets][2] = fClustersLay1[partners[iC2]][1] - fClustersLay2[iC2][1];
+    tracklet[kTrDPhi] = clPar1[kClPh] - clPar2[kClPh];
 
     // define dphi in the range [0,pi] with proper sign (track charge correlated)
-    if (fTracklets[fNTracklets][2] > TMath::Pi())
-      fTracklets[fNTracklets][2] = fTracklets[fNTracklets][2]-2.*TMath::Pi();
-    if (fTracklets[fNTracklets][2] < -TMath::Pi())
-      fTracklets[fNTracklets][2] = fTracklets[fNTracklets][2]+2.*TMath::Pi();
+    if (tracklet[kTrDPhi] > TMath::Pi())   tracklet[kTrDPhi] = tracklet[kTrDPhi]-2.*TMath::Pi();
+    if (tracklet[kTrDPhi] < -TMath::Pi())  tracklet[kTrDPhi] = tracklet[kTrDPhi]+2.*TMath::Pi();
 
     // store the difference between theta1 and theta2
-    fTracklets[fNTracklets][3] = fClustersLay1[partners[iC2]][0] - fClustersLay2[iC2][0];
+    tracklet[kTrDTheta] = clPar1[kClTh] - clPar2[kClTh];
 
     if (fHistOn) {
-      fhClustersDPhiAcc->Fill(fTracklets[fNTracklets][2]); 
-      fhClustersDThetaAcc->Fill(fTracklets[fNTracklets][3]);    
-      fhDPhiVsDThetaAcc->Fill(fTracklets[fNTracklets][3],fTracklets[fNTracklets][2]);
+      fhClustersDPhiAcc->Fill(tracklet[kTrDPhi]); 
+      fhClustersDThetaAcc->Fill(tracklet[kTrDTheta]);    
+      fhDPhiVsDThetaAcc->Fill(tracklet[kTrDTheta],tracklet[kTrDPhi]);
     }
 
     // find label
@@ -477,7 +555,7 @@ void AliITSMultReconstructor::Reconstruct(TTree* clusterTree, Float_t* vtx, Floa
     Int_t label1 = 0;
     Int_t label2 = 0;
     while (label2 < 3) {
-      if ((Int_t) fClustersLay1[partners[iC2]][3+label1] != -2 && (Int_t) fClustersLay1[partners[iC2]][3+label1] == (Int_t) fClustersLay2[iC2][3+label2])
+      if ((Int_t) clPar1[kClMC0+label1] != -2 && (Int_t) clPar1[kClMC0+label1] == (Int_t) clPar2[kClMC0+label2])
         break;
       label1++;
       if (label1 == 3) {
@@ -486,23 +564,26 @@ void AliITSMultReconstructor::Reconstruct(TTree* clusterTree, Float_t* vtx, Floa
       }
     }
     if (label2 < 3) {
-      AliDebug(AliLog::kDebug, Form("Found label %d == %d for tracklet candidate %d\n", (Int_t) fClustersLay1[partners[iC2]][3+label1], (Int_t) fClustersLay2[iC2][3+label2], fNTracklets));
-      fTracklets[fNTracklets][4] = fClustersLay1[partners[iC2]][3+label1];
-      fTracklets[fNTracklets][5] = fClustersLay2[iC2][3+label2];
+      AliDebug(AliLog::kDebug, Form("Found label %d == %d for tracklet candidate %d\n", (Int_t) clPar1[kClMC0+label1], (Int_t) clPar1[kClMC0+label2], fNTracklets));
+      tracklet[kTrLab1] = clPar1[kClMC0+label1];
+      tracklet[kTrLab2] = clPar2[kClMC0+label2];
     } else {
-      AliDebug(AliLog::kDebug, Form("Did not find label %d %d %d %d %d %d for tracklet candidate %d\n", (Int_t) fClustersLay1[partners[iC2]][3], (Int_t) fClustersLay1[partners[iC2]][4], (Int_t) fClustersLay1[partners[iC2]][5], (Int_t) fClustersLay2[iC2][3], (Int_t) fClustersLay2[iC2][4], (Int_t) fClustersLay2[iC2][5], fNTracklets));
-      fTracklets[fNTracklets][4] = fClustersLay1[partners[iC2]][3];
-      fTracklets[fNTracklets][5] = fClustersLay2[iC2][3];
+      AliDebug(AliLog::kDebug, Form("Did not find label %d %d %d %d %d %d for tracklet candidate %d\n", (Int_t) clPar1[kClMC0], (Int_t) clPar1[kClMC1], (Int_t) clPar1[kClMC2], (Int_t) clPar2[kClMC0], (Int_t) clPar2[kClMC1], (Int_t) clPar2[kClMC2], fNTracklets));
+      tracklet[kTrLab1] = clPar1[kClMC0];
+      tracklet[kTrLab2] = clPar2[kClMC0];
     }
 
     if (fHistOn) {
-      Float_t eta=fTracklets[fNTracklets][0];
+      Float_t eta = tracklet[kTrTheta];
       eta= TMath::Tan(eta/2.);
       eta=-TMath::Log(eta);
       fhetaTracklets->Fill(eta);
-      fhphiTracklets->Fill(fTracklets[fNTracklets][1]);
+      fhphiTracklets->Fill(tracklet[kTrPhi]);
     }
-
+    //
+    tracklet[kClID1] = partners[iC2];
+    tracklet[kClID2] = iC2;
+    //
     AliDebug(1,Form(" Adding tracklet candidate %d ", fNTracklets));
     AliDebug(1,Form(" Cl. %d of Layer 1 and %d of Layer 2", partners[iC2], iC2));
     fNTracklets++;
@@ -513,10 +594,14 @@ void AliITSMultReconstructor::Reconstruct(TTree* clusterTree, Float_t* vtx, Floa
   // Delete the following else if you do not want to save Clusters! 
   // store the cluster
   for (Int_t iC1=0; iC1<fNClustersLay1; iC1++) {
+
+    float* clPar1 = GetClusterLayer1(iC1);
+
     if (associatedLay1[iC1]==2||associatedLay1[iC1]==0) { 
-      fSClusters[fNSingleCluster] = new Float_t[2];
-      fSClusters[fNSingleCluster][0] = fClustersLay1[iC1][0];
-      fSClusters[fNSingleCluster][1] = fClustersLay1[iC1][1];
+      fSClusters[fNSingleCluster] = new Float_t[kClNPar];
+      fSClusters[fNSingleCluster][kSCTh] = clPar1[kClTh];
+      fSClusters[fNSingleCluster][kSCPh] = clPar1[kClPh];
+      fSClusters[fNSingleCluster][kSCID] = iC1;
       AliDebug(1,Form(" Adding a single cluster %d (cluster %d  of layer 1)",
                 fNSingleCluster, iC1));
       fNSingleCluster++;
@@ -535,13 +620,48 @@ void AliITSMultReconstructor::Reconstruct(TTree* clusterTree, Float_t* vtx, Floa
 }
 
 //____________________________________________________________________
-void
-AliITSMultReconstructor::LoadClusterArrays(TTree* itsClusterTree) {
+void AliITSMultReconstructor::CreateMultiplicityObject()
+{
+  // create AliMultiplicity object and store it in the ESD event
+  //
+  TBits fastOrFiredMap,firedChipMap;
+  if (fDetTypeRec) {
+   fastOrFiredMap  = fDetTypeRec->GetFastOrFiredMap();
+   firedChipMap    = fDetTypeRec->GetFiredChipMap(fTreeRP);
+  }
+  //
+  fMult = new AliMultiplicity(fNTracklets,fNSingleCluster,fNFiredChips[0],fNFiredChips[1],fastOrFiredMap);
+  fMult->SetFiredChipMap(firedChipMap);
+  AliITSRecPointContainer* rcont = AliITSRecPointContainer::Instance();
+  fMult->SetITSClusters(0,rcont->GetNClustersInLayer(1,fTreeRP));
+  for(Int_t kk=2;kk<=6;kk++) fMult->SetITSClusters(kk-1,rcont->GetNClustersInLayerFast(kk));
+  //
+  for (int i=fNTracklets;i--;)  {
+    float* tlInfo = fTracklets[i];
+    fMult->SetTrackletData(i,tlInfo, fUsedClusLay1[int(tlInfo[kClID1])]|fUsedClusLay2[int(tlInfo[kClID2])]);
+  }
+  //  
+  for (int i=fNSingleCluster;i--;) {
+    float* clInfo = fSClusters[i];
+    fMult->SetSingleClusterData(i,clInfo,fUsedClusLay1[int(clInfo[kSCID])]);
+  }
+  fMult->CompactBits();
+  //
+}
+
+
+//____________________________________________________________________
+void AliITSMultReconstructor::LoadClusterArrays(TTree* itsClusterTree) 
+{
   // This method
   // - gets the clusters from the cluster tree 
   // - convert them into global coordinates 
   // - store them in the internal arrays
   // - count the number of cluster-fired chips
+  //
+  // RS: This method was strongly modified wrt original by Jan Fiete. In order to have the same numbering
+  // of clusters as in the ITS reco I had to introduce sorting in Z
+  // Also note that now the clusters data are stored not in float[6] attached to float**, but in 1-D array
   
   AliDebug(1,"Loading clusters and cluster-fired chips ...");
   
@@ -558,113 +678,73 @@ AliITSMultReconstructor::LoadClusterArrays(TTree* itsClusterTree) {
     AliWarning("No SPD rec points found, multiplicity not calculated");
     return;
   } 
-  Float_t cluGlo[3]={0.,0.,0.};
-
+  //
   // count clusters
   // loop over the SPD subdetectors
-  Int_t nSPDL1 = AliITSgeomTGeo::GetModuleIndex(2,1,1);
-  for (Int_t iIts=0; iIts < nSPDL1; iIts++) {
-    itsClusters=rpcont->UncheckedGetClusters(iIts);
-    fNClustersLay1 += itsClusters->GetEntriesFast();
-  }
-  Int_t nSPDL2=AliITSgeomTGeo::GetModuleIndex(3,1,1);
-  for (Int_t iIts=nSPDL1; iIts < nSPDL2; iIts++) {
-    itsClusters=rpcont->UncheckedGetClusters(iIts);
-    fNClustersLay2 += itsClusters->GetEntriesFast();
-  }
-  
-  // create arrays
-  fClustersLay1              = new Float_t*[fNClustersLay1];
-  fDetectorIndexClustersLay1 = new Int_t[fNClustersLay1];
-  fOverlapFlagClustersLay1   = new Bool_t[fNClustersLay1];
-  
-  fClustersLay2              = new Float_t*[fNClustersLay2];
-  fDetectorIndexClustersLay2 = new Int_t[fNClustersLay2];
-  fOverlapFlagClustersLay2   = new Bool_t[fNClustersLay2];
-  
-  // no double association allowed
-  fTracklets                 = new Float_t*[TMath::Min(fNClustersLay1, fNClustersLay2)];
-  fSClusters                 = new Float_t*[fNClustersLay1];
-  
-  for (Int_t i=0; i<fNClustersLay1; i++) {
-    fClustersLay1[i]       = new Float_t[6];
-    fOverlapFlagClustersLay1[i]   = kFALSE;
-    fSClusters[i] = 0;
-  } 
-  for (Int_t i=0; i<fNClustersLay2; i++) {
-    fClustersLay2[i]       = new Float_t[6];
-    fOverlapFlagClustersLay2[i]   = kFALSE;
-  } 
-  for (Int_t i=0; i<TMath::Min(fNClustersLay1, fNClustersLay2); i++)
-    fTracklets[i] = 0;
-    
-  // fill clusters
-  // loop over the its subdetectors
-  fNClustersLay1 = 0; // reset to 0
-  fNClustersLay2 = 0;
-  for (Int_t iIts=0; iIts < nSPDL2; iIts++) {
-    
-    itsClusters=rpcont->UncheckedGetClusters(iIts);
-    
-    Int_t nClusters = itsClusters->GetEntriesFast();
-
-    // number of clusters in each chip of the current module
-    Int_t nClustersInChip[5] = {0,0,0,0,0};
-    Int_t layer = 0;
-    
-    // loop over clusters
-    while(nClusters--) {
-      AliITSRecPoint* cluster = (AliITSRecPoint*)itsClusters->UncheckedAt(nClusters);
-      
-      layer = cluster->GetLayer();
-      if (layer>1) continue;            
-      
-      cluster->GetGlobalXYZ(cluGlo);
-      Float_t x = cluGlo[0];
-      Float_t y = cluGlo[1];
-      Float_t z = cluGlo[2];      
-
-      // find the chip for the current cluster
-      Float_t locz = cluster->GetDetLocalZ();
-      Int_t iChip = seg.GetChipFromLocal(0,locz);
-      nClustersInChip[iChip]++; 
-      
-      if (layer==0) {
-       fClustersLay1[fNClustersLay1][0] = x;
-       fClustersLay1[fNClustersLay1][1] = y;
-       fClustersLay1[fNClustersLay1][2] = z;
-        fDetectorIndexClustersLay1[fNClustersLay1]=iIts;  
-
-       for (Int_t i=0; i<3; i++)
-               fClustersLay1[fNClustersLay1][3+i] = cluster->GetLabel(i);
-       fNClustersLay1++;
+  TObjArray clArr(100);
+  for (int il=0;il<2;il++) {
+    int nclLayer = 0;
+    int detMin = AliITSgeomTGeo::GetModuleIndex(il+1,1,1);
+    int detMax = AliITSgeomTGeo::GetModuleIndex(il+2,1,1);
+    for (int idt=detMin;idt<detMax;idt++) {
+      itsClusters=rpcont->UncheckedGetClusters(idt);
+      int nClusters = itsClusters->GetEntriesFast();
+      if (!nClusters) continue;
+      Int_t nClustersInChip[5] = {0,0,0,0,0};
+      while(nClusters--) {
+       AliITSRecPoint* cluster = (AliITSRecPoint*)itsClusters->UncheckedAt(nClusters);
+       if (!cluster) continue;
+       clArr[nclLayer++] = cluster;
+       nClustersInChip[ seg.GetChipFromLocal(0,cluster->GetDetLocalZ()) ]++; 
       }
-      if (layer==1) {
-       fClustersLay2[fNClustersLay2][0] = x;
-       fClustersLay2[fNClustersLay2][1] = y;
-       fClustersLay2[fNClustersLay2][2] = z;
-
-        fDetectorIndexClustersLay2[fNClustersLay2]=iIts;
-       for (Int_t i=0; i<3; i++)
-               fClustersLay2[fNClustersLay2][3+i] = cluster->GetLabel(i);
-       fNClustersLay2++;
-      }
-      
-    }// end of cluster loop
-
-    // get number of fired chips in the current module
-
-    for(Int_t ifChip=0; ifChip<5; ifChip++) {
-      if(nClustersInChip[ifChip] >= 1)  fNFiredChips[layer]++;
+      for(Int_t ifChip=5;ifChip--;) if (nClustersInChip[ifChip]) fNFiredChips[il]++;
     }
-
-  } // end of its "subdetector" loop  
-
+    // sort the clusters in Z (to have the same numbering as in ITS reco
+    Float_t *z    = new Float_t[nclLayer];
+    Int_t * index = new Int_t[nclLayer];
+    for (int ic=0;ic<nclLayer;ic++) z[ic] = ((AliITSRecPoint*)clArr[ic])->GetZ();
+    TMath::Sort(nclLayer,z,index,kFALSE);
+    Float_t*   clustersLay              = new Float_t[nclLayer*kClNPar];
+    Int_t*     detectorIndexClustersLay = new Int_t[nclLayer];
+    Bool_t*    overlapFlagClustersLay   = new Bool_t[nclLayer];
+    Char_t*    usedClusLay              = new Char_t[nclLayer];
+    //
+    for (int ic=0;ic<nclLayer;ic++) {
+      AliITSRecPoint* cluster = (AliITSRecPoint*)clArr[index[ic]];
+      float* clPar = &clustersLay[ic*kClNPar];
+      //      
+      cluster->GetGlobalXYZ( clPar );
+      detectorIndexClustersLay[ic] = cluster->GetDetectorIndex(); 
+      overlapFlagClustersLay[ic]   = kFALSE;
+      usedClusLay[ic]              = 0;
+      for (Int_t i=3;i--;) clPar[kClMC0+i] = cluster->GetLabel(i);
+    }
+    clArr.Clear();
+    delete[] z;
+    delete[] index;
+    //
+    if (il==0) {
+      fClustersLay1              = clustersLay;
+      fOverlapFlagClustersLay1   = overlapFlagClustersLay;
+      fDetectorIndexClustersLay1 = detectorIndexClustersLay;
+      fUsedClusLay1              = usedClusLay;
+      fNClustersLay1             = nclLayer;
+    }
+    else {
+      fClustersLay2              = clustersLay;
+      fOverlapFlagClustersLay2   = overlapFlagClustersLay;
+      fDetectorIndexClustersLay2 = detectorIndexClustersLay;
+      fUsedClusLay2              = usedClusLay;
+      fNClustersLay2             = nclLayer;
+    }
+  }
+  //
+  // no double association allowed
+  int nmaxT                  = TMath::Min(fNClustersLay1, fNClustersLay2);
+  fTracklets                 = new Float_t*[nmaxT];
+  fSClusters                 = new Float_t*[fNClustersLay1]; 
+  for (Int_t i=nmaxT;i--;) fTracklets[i] = 0;
+  //
   AliDebug(1,Form("(clusters in layer 1 : %d,  layer 2: %d)",fNClustersLay1,fNClustersLay2));
   AliDebug(1,Form("(cluster-fired chips in layer 1 : %d,  layer 2: %d)",fNFiredChips[0],fNFiredChips[1]));
 }
@@ -758,18 +838,20 @@ AliITSMultReconstructor::FlagClustersInOverlapRegions (Int_t iC1, Int_t iC2WithB
   Float_t zproj1=0.;
   Float_t zproj2=0.;
   Float_t deZproj=0.;
-
+  Float_t* clPar1  = GetClusterLayer1(iC1);
+  Float_t* clPar2B = GetClusterLayer2(iC2WithBestDist);
   // Loop on inner layer clusters
   for (Int_t iiC1=0; iiC1<fNClustersLay1; iiC1++) {
     if (!fOverlapFlagClustersLay1[iiC1]) {
       // only for adjacent modules
       if ((TMath::Abs(fDetectorIndexClustersLay1[iC1]-fDetectorIndexClustersLay1[iiC1])==4)||
          (TMath::Abs(fDetectorIndexClustersLay1[iC1]-fDetectorIndexClustersLay1[iiC1])==76)) {
-        Float_t dePhi=TMath::Abs(fClustersLay1[iiC1][1]-fClustersLay1[iC1][1]);
+       Float_t *clPar11 = GetClusterLayer1(iiC1);
+        Float_t dePhi=TMath::Abs(clPar11[kClPh]-clPar1[kClPh]);
         if (dePhi>TMath::Pi()) dePhi=2.*TMath::Pi()-dePhi;
 
-        zproj1=meanRadiusLay1/TMath::Tan(fClustersLay1[iC1][0]);
-        zproj2=meanRadiusLay1/TMath::Tan(fClustersLay1[iiC1][0]);
+        zproj1=meanRadiusLay1/TMath::Tan(clPar1[kClTh]);
+        zproj2=meanRadiusLay1/TMath::Tan(clPar11[kClTh]);
 
         deZproj=TMath::Abs(zproj1-zproj2);
 
@@ -797,13 +879,14 @@ AliITSMultReconstructor::FlagClustersInOverlapRegions (Int_t iC1, Int_t iC2WithB
   for (Int_t iiC2=0; iiC2<fNClustersLay2; iiC2++) {
     if (!fOverlapFlagClustersLay2[iiC2]) {
       // only for adjacent modules
+      Float_t *clPar2 = GetClusterLayer2(iiC2);
       if ((TMath::Abs(fDetectorIndexClustersLay2[iC2WithBestDist]-fDetectorIndexClustersLay2[iiC2])==4) ||
          (TMath::Abs(fDetectorIndexClustersLay2[iC2WithBestDist]-fDetectorIndexClustersLay2[iiC2])==156)) {
-        Float_t dePhi=TMath::Abs(fClustersLay2[iiC2][1]-fClustersLay2[iC2WithBestDist][1]);
+        Float_t dePhi=TMath::Abs(clPar2[kClPh]-clPar2B[kClPh]);
         if (dePhi>TMath::Pi()) dePhi=2.*TMath::Pi()-dePhi;
 
-        zproj1=meanRadiusLay2/TMath::Tan(fClustersLay2[iC2WithBestDist][0]);
-        zproj2=meanRadiusLay2/TMath::Tan(fClustersLay2[iiC2][0]);
+        zproj1=meanRadiusLay2/TMath::Tan(clPar2B[kClTh]);
+        zproj2=meanRadiusLay2/TMath::Tan(clPar2[kClTh]);
 
         deZproj=TMath::Abs(zproj1-zproj2);
         distClSameMod = TMath::Sqrt(TMath::Power(deZproj/fZetaOverlapCut,2)+TMath::Power(dePhi/fPhiOverlapCut,2));
@@ -823,3 +906,63 @@ AliITSMultReconstructor::FlagClustersInOverlapRegions (Int_t iC1, Int_t iC2WithB
 //  if (distClSameModMin!=0.) fOverlapFlagClustersLay2[iClOverlap]=kTRUE;
 
 }
+
+//____________________________________________________________________
+void AliITSMultReconstructor::ProcessESDTracks()
+{
+  // Flag the clusters used by ESD tracks
+  // Flag primary tracks to be used for multiplicity counting 
+  //
+  AliESDVertex* vtx = (AliESDVertex*)fESDEvent->GetPrimaryVertexTracks();
+  if (!vtx) vtx = (AliESDVertex*)fESDEvent->GetPrimaryVertexSPD();
+  if (!vtx) {
+    AliDebug(1,"No primary vertex: cannot flag primary tracks");
+    return;
+  }
+  Int_t ntracks = fESDEvent->GetNumberOfTracks();
+  for(Int_t itr=0; itr<ntracks; itr++) {
+    AliESDtrack* track = fESDEvent->GetTrack(itr);
+    if (!track->IsOn(AliESDtrack::kITSin)) continue; // use only tracks propagated in ITS to vtx
+    FlagTrackClusters(track);
+    FlagIfPrimary(track,vtx);
+  }
+  //
+}
+
+//____________________________________________________________________
+void AliITSMultReconstructor::FlagTrackClusters(const AliESDtrack* track)
+{
+  // RS: flag the SPD clusters of the track if it is useful for the multiplicity estimation
+  //
+  Int_t idx[12];
+  if ( track->GetITSclusters(idx)<3 ) return; // at least 3 clusters must be used in the fit
+  //
+  char mark = track->IsOn(AliESDtrack::kITSpureSA) ? kITSSAPBit : kITSTPCBit;
+  char *uClus[2] = {fUsedClusLay1,fUsedClusLay2};
+  for (int i=AliESDfriendTrack::kMaxITScluster;i--;) {
+    // note: i>=6 is for extra clusters
+    if (idx[i]<0) continue;
+    int layID= (idx[i] & 0xf0000000) >> 28; 
+    if (layID>1) continue; // SPD only
+    int clID = (idx[i] & 0x0fffffff);
+    uClus[layID][clID] |= mark;
+  }
+  //
+}
+
+//____________________________________________________________________
+void AliITSMultReconstructor::FlagIfPrimary(AliESDtrack* track, const AliVertex* vtx)
+{
+  // RS: check if the track is primary and set the flag
+  const double kPDCASPD1 = 0.1;
+  const double kPDCASPD0 = 0.3;
+  //
+  double cut = (track->HasPointOnITSLayer(0)||track->HasPointOnITSLayer(1)) ? kPDCASPD1 : kPDCASPD0;
+  // in principle, the track must already have been propagated to vertex
+  /*
+  Double_t dzRec[2]={0,0}, covdzRec[3];
+  track->PropagateToDCA(vtx, fESDEvent->GetMagneticField(), 3.0, dzRec, covdzRec);
+  */
+  double dist = track->GetD(vtx->GetX(),vtx->GetY(),fESDEvent->GetMagneticField());
+  if (TMath::Abs(dist*track->P())<cut) track->SetStatus(AliESDtrack::kMultPrimary);
+}
index da7d201..b05e398 100644 (file)
@@ -3,8 +3,6 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-/* $Id$ */
-
 //_________________________________________________________________________
 // 
 //        Implementation of the ITS-SPD trackleter class
 // In case of multiple candidates the candidate with minimum
 // distance is selected. 
 //_________________________________________________________________________
+#include "AliTrackleter.h"
 
-#include "TObject.h"
-
+class TBits;
 class TTree;
 class TH1F;
 class TH2F; 
-
+class AliITSDetTypeRec;
 class AliITSgeom;
+class AliESDEvent;
+class AliESDtrack;
+class AliVertex;
+class AliMultiplicity;
 
-class AliITSMultReconstructor : public TObject 
+class AliITSMultReconstructor : public AliTrackleter
 {
 public:
+  //
+  enum {kClTh,kClPh,kClZ,kClMC0,kClMC1,kClMC2,kClNPar};
+  enum {kTrTheta,kTrPhi,kTrDPhi,kTrDTheta,kTrLab1,kTrLab2,kClID1,kClID2,kTrNPar};
+  enum {kSCTh,kSCPh,kSCID,kSCNPar};
+  enum {kITSTPC,kITSSAP,kITSTPCBit=BIT(kITSTPC),kITSSAPBit=BIT(kITSSAP)}; // RS
   AliITSMultReconstructor();
   virtual ~AliITSMultReconstructor();
 
-  void Reconstruct(TTree* tree, Float_t* vtx, Float_t* vtxRes);
+  void Reconstruct(AliESDEvent* esd, TTree* treeRP);
+  void Reconstruct(TTree* tree, Float_t* vtx, Float_t* vtxRes);   // old reconstructor invocation
+  void FindTracklets(const Float_t* vtx); 
   void LoadClusterFiredChips(TTree* tree);
   void FlagClustersInOverlapRegions(Int_t ic1,Int_t ic2);
-
+  void FlagTrackClusters(const AliESDtrack* track);
+  void FlagIfPrimary(AliESDtrack* track, const AliVertex* vtx);
+  void ProcessESDTracks();
+  
+  void CreateMultiplicityObject();
+  //
   // Following members are set via AliITSRecoParam
   void SetPhiWindow(Float_t w=0.08) {fPhiWindow=w;}
   void SetThetaWindow(Float_t w=0.025) {fThetaWindow=w;}
@@ -51,27 +65,35 @@ public:
   Int_t GetNSingleClusters() const {return fNSingleCluster;}
   Short_t GetNFiredChips(Int_t layer) const {return fNFiredChips[layer];}
 
-  Float_t* GetClusterLayer1(Int_t n) {return fClustersLay1[n];}
-  Float_t* GetClusterLayer2(Int_t n) {return fClustersLay2[n];}
+  Float_t* GetClusterLayer1(Int_t n) {return &fClustersLay1[n*kClNPar];}
+  Float_t* GetClusterLayer2(Int_t n) {return &fClustersLay2[n*kClNPar];}
+
   Float_t* GetTracklet(Int_t n) {return fTracklets[n];}
   Float_t* GetCluster(Int_t n) {return fSClusters[n];}
 
   void SetHistOn(Bool_t b=kFALSE) {fHistOn=b;}
   void SaveHists();
 
+  AliITSDetTypeRec *GetDetTypeRec() const {return fDetTypeRec;}
+  void SetDetTypeRec(AliITSDetTypeRec *ptr){fDetTypeRec = ptr;}
+
 protected:
   AliITSMultReconstructor(const AliITSMultReconstructor& mr);
   AliITSMultReconstructor& operator=(const AliITSMultReconstructor& mr);
+  AliITSDetTypeRec* fDetTypeRec;            //! pointer to DetTypeRec
+  AliESDEvent*      fESDEvent;              //! pointer to ESD event
+  TTree*            fTreeRP;                //! ITS recpoints
 
-  
-  Float_t**     fClustersLay1;               // clusters in the 1st layer of ITS 
-  Float_t**     fClustersLay2;               // clusters in the 2nd layer of ITS 
+  Char_t*       fUsedClusLay1;               // RS: flag of clusters usage in ESD tracks: 0=unused, bit0=TPC/ITS+ITSSA, bit1=ITSSA_Pure
+  Char_t*       fUsedClusLay2;               // RS: flag of clusters usage in ESD tracks: 0=unused, bit0=TPC/ITS+ITSSA, bit1=ITSSA_Pure
+
+  Float_t*      fClustersLay1;               // clusters in the 1st layer of ITS 
+  Float_t*      fClustersLay2;               // clusters in the 2nd layer of ITS 
   Int_t*        fDetectorIndexClustersLay1;  // module index for clusters 1st ITS layer
   Int_t*        fDetectorIndexClustersLay2;  // module index for clusters 2nd ITS layer
   Bool_t*       fOverlapFlagClustersLay1;    // flag for clusters in the overlap regions 1st ITS layer
   Bool_t*       fOverlapFlagClustersLay2;    // flag for clusters in the overlap regions 2nd ITS layer 
 
-
   Float_t**     fTracklets;            // tracklets 
   Float_t**     fSClusters;            // single clusters (unassociated)
   
@@ -107,7 +129,7 @@ protected:
 
   void LoadClusterArrays(TTree* tree);
 
-  ClassDef(AliITSMultReconstructor,6)
+  ClassDef(AliITSMultReconstructor,7)
 };
 
 #endif
index 2f19dae..5fa324f 100644 (file)
@@ -40,7 +40,7 @@
 #include "AliITSVertexerCosmics.h"
 #include "AliITSInitGeometry.h"
 #include "AliITSTrackleterSPDEff.h"
-
+#include "AliITSMultReconstructor.h"
 
 ClassImp(AliITSReconstructor)
 
@@ -114,6 +114,17 @@ void AliITSReconstructor::Reconstruct(AliRawReader* rawReader, TTree *clustersTr
   fDetTypeRec->SetDefaultClusterFindersV2(kTRUE);
   fDetTypeRec->DigitsToRecPoints(rawReader,clustersTree);
 }
+
+//_____________________________________________________________________________
+AliTrackleter* AliITSReconstructor::CreateMultFinder() const
+{
+  // create the SPD trackeleter for mult. reconstruction
+  AliITSMultReconstructor* multReco = new AliITSMultReconstructor();
+  multReco->SetHistOn(kFALSE);
+  multReco->SetDetTypeRec(fDetTypeRec);
+  return multReco;
+}
+
 //_____________________________________________________________________________
 AliTracker* AliITSReconstructor::CreateTrackleter() const
 {
index 9f41003..7fe0585 100644 (file)
@@ -16,6 +16,7 @@
 class AliESDpid;
 class AliITSgeom;
 class AliTracker;
+class AliTrackleter;
 class AliITStrackerMI;
 
 class AliITSReconstructor: public AliReconstructor {
@@ -30,6 +31,7 @@ public:
   virtual AliTracker*  CreateTracker() const;
   virtual AliVertexer* CreateVertexer() const;
   virtual AliTracker*  CreateTrackleter() const;
+  virtual AliTrackleter* CreateMultFinder() const;
 
   virtual void         FillESD(TTree* /*digitsTree*/, TTree* clustersTree, 
                               AliESDEvent* /* esd */) const; 
index 04f9a18..bccbc54 100644 (file)
@@ -151,7 +151,8 @@ AliESDVertex* AliITSVertexer3D::FindVertexForCurrentEvent(TTree *itsClusterTree)
     }
 
   }
-  FindMultiplicity(itsClusterTree);
+  //RS
+  //  FindMultiplicity(itsClusterTree);
   return fCurrentVertex;
 }  
 
index 1ca3428..c3c629e 100644 (file)
@@ -309,7 +309,8 @@ AliESDVertex* AliITSVertexerCosmics::FindVertexForCurrentEvent(TTree *itsCluster
   fCurrentVertex->SetTitle("cosmics fake vertex");
   fCurrentVertex->SetNContributors(ncontributors);
   //fCurrentVertex->Print();
-  FindMultiplicity(itsClusterTree);
+  // RS
+  // FindMultiplicity(itsClusterTree);
 
   delete recpoints;
 
index 27fcad2..b5d3368 100644 (file)
@@ -180,7 +180,8 @@ AliESDVertex* AliITSVertexerZ::FindVertexForCurrentEvent(TTree *itsClusterTree){
       fDiffPhiMax=diffPhiMaxOrig;
     }
   }
-  FindMultiplicity(itsClusterTree);
+  //RS
+  //  FindMultiplicity(itsClusterTree);
   return fCurrentVertex;
 }  
 
index 0257e83..fb0fbb9 100644 (file)
@@ -55,7 +55,8 @@ public:
     kESDpid=0x40000000,
     kTIME=0x80000000,
     kGlobalMerge=0x08000000,
-    kITSpureSA=0x10000000
+    kITSpureSA=0x10000000,
+    kMultPrimary=0x4000000 //BIT(26): assumed to be primary for multiplicity estimates
   }; 
   enum {
     kTRDnPlanes = 6,
@@ -328,7 +329,7 @@ public:
   }
   Bool_t  IsHMPID() const {return fFlags&kHMPIDpid;}
   Bool_t  IsPureITSStandalone() const {return fFlags&kITSpureSA;}
-
+  Bool_t  IsMultPrimary() const {return fFlags&kMultPrimary;}
 
   Int_t GetEMCALcluster() {return fCaloIndex;}
   void SetEMCALcluster(Int_t index) {fCaloIndex=index;}
index 38b3a86..001f08a 100644 (file)
@@ -74,6 +74,46 @@ AliMultiplicity::AliMultiplicity(Int_t ntr, Float_t *th,  Float_t *ph, Float_t *
 }
 
 //______________________________________________________________________
+AliMultiplicity::AliMultiplicity(Int_t ntr, Int_t ns, Short_t nfcL1, Short_t nfcL2, const TBits & fFastOr) :
+  TObject(),
+  fNtracks(ntr),
+  fNsingle(ns),
+  fLabels(0),
+  fLabelsL2(0),
+  fTh(0),
+  fPhi(0),
+  fDeltTh(0),
+  fDeltPhi(0),
+  fThsingle(0),
+  fPhisingle(0),
+  fFastOrFiredChips(1200),
+  fClusterFiredChips(1200)
+{
+  // Standard constructor to create the arrays w/o filling
+  if(ntr>0){
+    fLabels   = new Int_t[ntr];
+    fLabelsL2 = new Int_t[ntr];
+    fTh       = new Double_t [ntr];
+    fPhi      = new Double_t [ntr];
+    fDeltTh   = new Double_t [ntr];
+    fDeltPhi  = new Double_t [ntr];
+    for(Int_t i=fNtracks;i--;){
+      fTh[i]=fPhi[i]=fDeltTh[i]=fDeltPhi[i] = 0;
+      fLabels[i] = fLabelsL2[i] = 0;
+    }
+  }
+  if(ns>0){
+    fThsingle  = new Double_t [ns];
+    fPhisingle = new Double_t [ns];
+    for(Int_t i=fNsingle;i--;) fThsingle[i] = fPhisingle[i] = 0;
+  }
+  fFiredChips[0] = nfcL1;
+  fFiredChips[1] = nfcL2;
+  fFastOrFiredChips = fFastOr;
+  for(Int_t ilayer=6;ilayer--;) fITSClusters[ilayer] = 0;
+}
+
+//______________________________________________________________________
 AliMultiplicity::AliMultiplicity(const AliMultiplicity& m):
   TObject(m),
   fNtracks(m.fNtracks),
@@ -170,8 +210,11 @@ void AliMultiplicity::Duplicate(const AliMultiplicity& m){
     fITSClusters[ilayer] = m.fITSClusters[ilayer];
   }
 
+  fUsedClusT[0] = m.fUsedClusT[0];
+  fUsedClusT[1] = m.fUsedClusT[1];
+  fUsedClusS[0] = m.fUsedClusS[0];
+  fUsedClusS[1] = m.fUsedClusS[1];
   
-
   fFastOrFiredChips = m.fFastOrFiredChips;
   fClusterFiredChips = m.fClusterFiredChips;
 }
@@ -191,6 +234,31 @@ AliMultiplicity::~AliMultiplicity(){
 }
 
 //______________________________________________________________________
+void AliMultiplicity::Clear(Option_t*)
+{
+  // reset all
+  TObject::Clear();
+  if(fTh)delete [] fTh;fTh = 0;
+  if(fPhi)delete [] fPhi;fPhi = 0; 
+  if(fDeltTh)delete [] fDeltTh;fDeltTh = 0; 
+  if(fDeltPhi)delete [] fDeltPhi;fDeltPhi = 0; 
+  if(fLabels)delete [] fLabels;fLabels = 0;
+  if(fLabelsL2)delete [] fLabelsL2;fLabelsL2 = 0;
+  if(fThsingle)delete [] fThsingle;fThsingle = 0;
+  if(fPhisingle)delete [] fPhisingle;fPhisingle = 0;
+  fNtracks = fNsingle = 0;
+  for (int i=6;i--;) fITSClusters[0] = 0;
+  fFiredChips[0] = fFiredChips[1] = 0;
+  fFastOrFiredChips.ResetAllBits(kTRUE);
+  fClusterFiredChips.ResetAllBits(kTRUE);
+  fUsedClusT[0].ResetAllBits(kTRUE);
+  fUsedClusT[1].ResetAllBits(kTRUE);
+  fUsedClusS[0].ResetAllBits(kTRUE);
+  fUsedClusS[1].ResetAllBits(kTRUE);
+  //
+}
+
+//______________________________________________________________________
 void AliMultiplicity::SetLabel(Int_t i, Int_t layer, Int_t label)
 {
     if(i>=0 && i<fNtracks) {
@@ -228,3 +296,64 @@ UInt_t AliMultiplicity::GetNumberOfITSClusters(Int_t layMin, Int_t layMax) const
   return sum; 
 
 }
+
+//______________________________________________________________________
+void AliMultiplicity::SetTrackletData(Int_t id, const Float_t* tlet, UInt_t bits)
+{
+  // fill tracklet data
+  if (id>=fNtracks) {AliError(Form("Number of declared tracklets %d < %d",fNtracks,id)); return;}
+  fTh[id]      = tlet[0];
+  fPhi[id]     = tlet[1];
+  fDeltPhi[id] = tlet[2];
+  fDeltTh[id]  = tlet[3];
+  fLabels[id]   = Int_t(tlet[4]);
+  fLabelsL2[id] = Int_t(tlet[5]);  
+  if (bits&BIT(0)) fUsedClusT[0].SetBitNumber(id);
+  if (bits&BIT(1)) fUsedClusT[1].SetBitNumber(id);
+  //
+}
+
+//______________________________________________________________________
+void AliMultiplicity::SetSingleClusterData(Int_t id, const Float_t* scl, UInt_t bits)
+{
+  // fill single cluster data
+  if (id>=fNsingle) {AliError(Form("Number of declared singles %d < %d",fNsingle,id)); return;}
+  fThsingle[id]  = scl[0];
+  fPhisingle[id] = scl[1];
+  if (bits&BIT(0)) fUsedClusS[0].SetBitNumber(id);
+  if (bits&BIT(1)) fUsedClusS[1].SetBitNumber(id);
+  //
+}
+
+//______________________________________________________________________
+void AliMultiplicity::CompactBits()
+{
+  // sqeeze bit contrainers to minimum
+  fFastOrFiredChips.Compact();
+  fClusterFiredChips.Compact();
+  fUsedClusT[0].Compact();
+  fUsedClusT[1].Compact();
+  fUsedClusS[0].Compact();
+  fUsedClusS[1].Compact();
+}
+
+//______________________________________________________________________
+void AliMultiplicity::Print(Option_t *opt) const
+{
+  // print
+  printf("N.tracklets: %4d N.singles: %4d\n",fNtracks,fNsingle);
+  TString opts = opt; opts.ToLower();
+  if (opts.Contains("t")) {
+    for (int i=0;i<fNtracks;i++) 
+      printf("T#%3d| Th:%+6.3f Phi:%+6.3f DTh:%+6.3f DPhi:%+6.3f L1:%4d L2:%4d U0:%d U1:%d\n",
+            i,fTh[i],fPhi[i],fDeltTh[i],fDeltPhi[i],fLabels[i],fLabelsL2[i],
+            FreeClustersTracklet(i,0),FreeClustersTracklet(i,1));
+  }
+  if (opts.Contains("s")) {
+    for (int i=0;i<fNsingle;i++) 
+      printf("S#%3d| Th:%+6.3f Phi:%+6.3f U0:%d U1:%d\n",
+            i,fThsingle[i],fPhisingle[i],
+            FreeClustersTracklet(i,0),FreeClustersTracklet(i,1));
+  }
+  //
+}
index b1a501d..ad6082a 100644 (file)
@@ -18,9 +18,11 @@ class AliMultiplicity : public TObject {
   // standard constructor
   AliMultiplicity(Int_t ntr,Float_t *th, Float_t *ph, Float_t *dth, Float_t *dph, Int_t *labels,
          Int_t* labelsL2, Int_t ns, Float_t *ts, Float_t *ps, Short_t nfcL1, Short_t nfcL2, const TBits & fFastOrFiredChips);
+  AliMultiplicity(Int_t ntr, Int_t ns, Short_t nfcL1, Short_t nfcL2, const TBits & fFastOr);
   AliMultiplicity(const AliMultiplicity& m);
   AliMultiplicity& operator=(const AliMultiplicity& m);
   virtual void Copy(TObject &obj) const;
+  virtual void Clear(Option_t* opt="");
   virtual ~AliMultiplicity();
 // methods to access tracklet information
   Int_t GetNumberOfTracklets() const {return fNtracks;}
@@ -47,6 +49,10 @@ class AliMultiplicity : public TObject {
 
   Int_t GetLabel(Int_t i, Int_t layer) const;
   void  SetLabel(Int_t i, Int_t layer, Int_t label);
+
+  Bool_t FreeClustersTracklet(Int_t i, Int_t mode) const {return (mode>=0&&mode<2&&i>=0&&i<fNtracks) ? fUsedClusT[mode].TestBitNumber(i):kFALSE;}
+  Bool_t FreeSingleCluster(Int_t i, Int_t mode)    const {return (mode>=0&&mode<2&&i>=0&&i<fNsingle) ? fUsedClusS[mode].TestBitNumber(i):kFALSE;}
+
   
 // methods to access single cluster information
   Int_t GetNumberOfSingleClusters() const {return fNsingle;}
@@ -76,6 +82,24 @@ class AliMultiplicity : public TObject {
   const TBits & GetFiredChipMap() const {return fClusterFiredChips;}
   Bool_t TestFiredChipMap(UInt_t chipKey) const {return fClusterFiredChips.TestBitNumber(chipKey);}
 
+
+
+  // array getters
+  Double_t* GetTheta()       const {return (Double_t*)fTh;}
+  Double_t* GetPhi()         const {return (Double_t*)fPhi;}
+  Double_t* GetDeltTheta()   const {return (Double_t*)fDeltTh;}
+  Double_t* GetDeltPhi()     const {return (Double_t*)fDeltPhi;}
+  Double_t* GetThetaSingle() const {return (Double_t*)fThsingle;}
+  Double_t* GetPhiSingle()   const {return (Double_t*)fPhisingle;}
+  Int_t*    GetLabels()      const {return (Int_t*)fLabels;}
+  Int_t*    GetLabels2()     const {return (Int_t*)fLabelsL2;}
+  
+  void SetTrackletData(Int_t id, const Float_t* tlet, UInt_t bits);
+  void SetSingleClusterData(Int_t id, const Float_t* scl,UInt_t bits);
+  void CompactBits();
+
+  virtual void Print(Option_t *opt="") const;
+
   protected:
   void Duplicate(const AliMultiplicity &m);  // used by copy ctr.
 
@@ -89,13 +113,15 @@ class AliMultiplicity : public TObject {
   Double32_t *fDeltTh;       //[fNtracks] array with delta theta values
   Double32_t *fDeltPhi;      //[fNtracks] array with delta phi values
   Double32_t *fThsingle;     //[fNsingle] array with theta values of L1 clusters
-  Double32_t *fPhisingle;    //[fNsingle] array with phi values of L2 clusters
+  Double32_t *fPhisingle;    //[fNsingle] array with phi values of L1 clusters
   Short_t fFiredChips[2];    // Number of fired chips in the two SPD layers
   UInt_t fITSClusters[6];   // Number of ITS cluster per layer
   TBits fFastOrFiredChips;   // Map of FastOr fired chips
-  TBits fClusterFiredChips;         // Map of fired chips (= at least one cluster)
+  TBits fClusterFiredChips;  // Map of fired chips (= at least one cluster)
+  TBits fUsedClusT[2];       // flag that at least one of tracklets clusters is used by TPC/ITS+ITS_SA (0) or ITS_SA_PURE tracks (1)
+  TBits fUsedClusS[2];       // flag that the single clusters is used by TPC/ITS+ITS_SA (0) or ITS_SA_PURE tracks
 
-  ClassDef(AliMultiplicity,12);
+  ClassDef(AliMultiplicity,13);
 };
 
 inline Int_t AliMultiplicity::GetLabel(Int_t i, Int_t layer) const
index 68eaccf..5b53f50 100644 (file)
 #include "AliTriggerConfiguration.h"
 #include "AliV0vertexer.h"
 #include "AliVertexer.h"
+#include "AliTrackleter.h"
 #include "AliVertexerTracks.h"
 #include "AliTriggerRunScalers.h"
 #include "AliCTPTimeParams.h" 
@@ -209,6 +210,7 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename) :
   fRunMuonTracking(kFALSE),
   fRunV0Finder(kTRUE),
   fRunCascadeFinder(kTRUE),
+  fRunMultFinder(kTRUE),
   fStopOnError(kTRUE),
   fWriteAlignmentData(kFALSE),
   fWriteESDfriend(kFALSE),
@@ -314,6 +316,7 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
   fRunMuonTracking(rec.fRunMuonTracking),
   fRunV0Finder(rec.fRunV0Finder),
   fRunCascadeFinder(rec.fRunCascadeFinder),
+  fRunMultFinder(rec.fRunMultFinder),
   fStopOnError(rec.fStopOnError),
   fWriteAlignmentData(rec.fWriteAlignmentData),
   fWriteESDfriend(rec.fWriteESDfriend),
@@ -435,6 +438,7 @@ AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
   fRunMuonTracking       = rec.fRunMuonTracking;
   fRunV0Finder           = rec.fRunV0Finder;
   fRunCascadeFinder      = rec.fRunCascadeFinder;
+  fRunMultFinder         = rec.fRunMultFinder;
   fStopOnError           = rec.fStopOnError;
   fWriteAlignmentData    = rec.fWriteAlignmentData;
   fWriteESDfriend        = rec.fWriteESDfriend;
@@ -1032,8 +1036,9 @@ Bool_t AliReconstruction::InitGRP() {
        !((detMask >> AliDAQ::DetectorID("ITSSDD")) & 0x1) &&
        !((detMask >> AliDAQ::DetectorID("ITSSSD")) & 0x1) ) {
       // switch off the vertexer
-      AliInfo("SPD,SDD,SSD is not in the list of active detectors. Vertexer switched off.");
+      AliInfo("SPD,SDD,SSD is not in the list of active detectors. Vertexer and Trackleter are switched off.");
       fRunVertexFinder = kFALSE;
+      fRunMultFinder = kFALSE;
     }
     if (!((detMask >> AliDAQ::DetectorID("TRG")) & 0x1)) {
       // switch off the reading of CTP raw-data payload
@@ -2008,6 +2013,16 @@ Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
        }
     }
  
+    // RS run updated trackleter: since we want to mark the clusters used by tracks and also mark the 
+    // tracks interpreted as primary, this step should be done in the very end, when full 
+    // ESD info is available (particulalry, V0s)
+    // vertex finder
+    if (fRunMultFinder) {
+      if (!RunMultFinder(fesd)) {
+       if (fStopOnError) {CleanUp(); return kFALSE;}
+      }
+    }
+
     // write ESD
     if (fCleanESD) CleanESD(fesd);
 
@@ -2398,10 +2413,11 @@ Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd)
   if(novertices>1){
     for (Int_t kk=1; kk<novertices; kk++)esd->AddPileupVertexSPD(&vpileup[kk]);
   }
+  /*
   // if SPD multiplicity has been determined, it is stored in the ESD
   AliMultiplicity *mult = vertexer->GetMultiplicity();
   if(mult)esd->SetMultiplicity(mult);
-
+  */
   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
     if (fTracker[iDet]) fTracker[iDet]->SetVertex(vtxPos, vtxErr);
   }  
@@ -2413,6 +2429,40 @@ Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd)
 }
 
 //_____________________________________________________________________________
+Bool_t AliReconstruction::RunMultFinder(AliESDEvent*& esd)
+{
+  // run the trackleter for multiplicity study
+
+  AliCodeTimerAuto("",0)
+
+  AliTrackleter *trackleter = CreateMultFinder();
+  if (!trackleter) return kFALSE;
+
+  AliInfo(Form("running the ITS multiplicity finder: %s",trackleter->ClassName()));
+
+  if (fLoader[0]) {
+    fLoader[0]->LoadRecPoints();
+    TTree* cltree = fLoader[0]->TreeR();
+    if (cltree) {
+      trackleter->Reconstruct(esd,cltree);
+      AliMultiplicity *mult = trackleter->GetMultiplicity();
+      if(mult) esd->SetMultiplicity(mult);
+    }
+    else {
+      AliError("Can't get the ITS cluster tree");
+    }
+    fLoader[0]->UnloadRecPoints();
+  }
+  else {
+    AliError("Can't get the ITS loader");
+  }
+
+  delete trackleter;
+
+  return kTRUE;
+}
+
+//_____________________________________________________________________________
 Bool_t AliReconstruction::RunHLTTracking(AliESDEvent*& esd)
 {
 // run the HLT barrel tracking
@@ -3054,6 +3104,25 @@ AliVertexer* AliReconstruction::CreateVertexer()
 }
 
 //_____________________________________________________________________________
+AliTrackleter* AliReconstruction::CreateMultFinder()
+{
+// create the ITS trackleter for mult. estimation
+// Please note that the caller is the owner of the
+// trackleter
+
+  AliTrackleter* trackleter = NULL;
+  AliReconstructor* itsReconstructor = GetReconstructor(0);
+  if (itsReconstructor && ((fRunLocalReconstruction.Contains("ITS")) || fRunTracking.Contains("ITS"))) {
+    trackleter = itsReconstructor->CreateMultFinder();
+  }
+  if (!trackleter) {
+    AliWarning("couldn't create a trackleter for ITS");
+  }
+
+  return trackleter;
+}
+
+//_____________________________________________________________________________
 Bool_t AliReconstruction::CreateTrackers(const TString& detectors)
 {
 // create the trackers
@@ -3074,7 +3143,6 @@ Bool_t AliReconstruction::CreateTrackers(const TString& detectors)
       continue;
     }
 
-
     fTracker[iDet] = reconstructor->CreateTracker();
     if (!fTracker[iDet] && (iDet < 7)) {
       AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
index a41ce80..f3d9aec 100644 (file)
@@ -28,6 +28,7 @@ class AliLoader;
 class AliTracker;
 class AliMagF;
 class AliVertexer;
+class AliTrackleter;
 class AliESDVertex;
 class AliESDEvent;
 class AliESDfriend;
@@ -179,6 +180,7 @@ private:
   Bool_t         RunHLTTracking(AliESDEvent*& esd);
   Bool_t         RunMuonTracking(AliESDEvent*& esd);
   Bool_t         RunSPDTrackleting(AliESDEvent*& esd);
+  Bool_t         RunMultFinder(AliESDEvent*& esd);
   Bool_t         RunTracking(AliESDEvent*& esd, AliESDpid &PID);
   Bool_t         CleanESD(AliESDEvent *esd);
   Bool_t         FillESD(AliESDEvent*& esd, const TString& detectors);
@@ -190,6 +192,7 @@ private:
   Bool_t         InitRunLoader();
   AliReconstructor* GetReconstructor(Int_t iDet);
   AliVertexer*   CreateVertexer();
+  AliTrackleter* CreateMultFinder();
   void           CleanUp();
 
   Bool_t         ParseOutput();
@@ -221,6 +224,7 @@ private:
   Bool_t         fRunMuonTracking;    // run the HLT tracking
   Bool_t         fRunV0Finder;        // run the ESD V0 finder
   Bool_t         fRunCascadeFinder;   // run the ESD cascade finder
+  Bool_t         fRunMultFinder;      // run the trackleter for ITS clusters
   Bool_t         fStopOnError;        // stop or continue on errors
   Bool_t         fWriteAlignmentData; // write track space-points flag
   Bool_t         fWriteESDfriend;     // write ESD friend flag
@@ -313,7 +317,7 @@ private:
   
   TTree*              fChain;      //! The raw-data chain in case of AliRawReaderChain
 
-  ClassDef(AliReconstruction, 35)      // class for running the reconstruction
+  ClassDef(AliReconstruction, 36)      // class for running the reconstruction
 };
 
 #endif
index d19dcb0..659b114 100644 (file)
@@ -18,6 +18,7 @@ class TTree;
 class AliRawReader;
 class AliVertexer;
 class AliTracker;
+class AliTrackleter;
 class AliESDEvent;
 class AliDetectorRecoParam;
 class AliRunInfo;
@@ -45,6 +46,8 @@ public:
     {return NULL;}
   virtual AliTracker*  CreateTrackleter() const 
     {return NULL;}
+  virtual AliTrackleter* CreateMultFinder() const 
+    {return NULL;}
 
   virtual void         FillESD(TTree* digitsTree, TTree* clustersTree, 
                               AliESDEvent* esd) const;
diff --git a/STEER/AliTrackleter.cxx b/STEER/AliTrackleter.cxx
new file mode 100644 (file)
index 0000000..122b99f
--- /dev/null
@@ -0,0 +1,22 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+#include "AliTrackleter.h"
+#include "AliESDEvent.h"
+#include "AliMultiplicity.h"
+
+#include <TTree.h>
+
+ClassImp(AliTrackleter)
+
diff --git a/STEER/AliTrackleter.h b/STEER/AliTrackleter.h
new file mode 100644 (file)
index 0000000..e6251d1
--- /dev/null
@@ -0,0 +1,33 @@
+#ifndef ALITRACKLETER_H
+#define ALITRACKLETER_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+//-------------------------------------------------------------------------
+//   class Alitrackleter
+//   An abstract interface for tracklet reconstruction
+//-------------------------------------------------------------------------
+
+#include <TObject.h>
+class TTree;
+class AliESDEvent;
+class AliMultiplicity;
+
+class AliTrackleter : public TObject {
+public:
+ AliTrackleter() :fMult(0) {}
+  virtual ~AliTrackleter() { delete fMult; }
+  virtual void Reconstruct(AliESDEvent* esd, TTree* treeRP) = 0;
+  virtual AliMultiplicity* GetMultiplicity() const {return fMult;}
+  //
+protected:
+ AliTrackleter(const AliTrackleter &src) : TObject(src) {}
+  AliTrackleter & operator=(const AliTrackleter &src) {if (&src!=this) TObject::operator=(src); return *this;}
+  
+ protected:
+  AliMultiplicity* fMult;   // multiplicity object
+
+  ClassDef(AliTrackleter,1) //base trackleter
+};
+
+#endif
index 229c781..de30367 100644 (file)
 #pragma link C++ class  AliCluster+;
 #pragma link C++ class  AliCluster3D+;
 #pragma link C++ class  AliTracker+;
+#pragma link C++ class  AliTrackleter+;
 #pragma link C++ class  AliV0+;
 #pragma link C++ class  AliKink+;
 
index d45bb0d..d052bbe 100644 (file)
@@ -42,6 +42,7 @@ AliExpression.cxx \
 AliCTPRawStream.cxx \
 AliMathBase.cxx AliSignalProcesor.cxx \
 AliTracker.cxx AliCluster.cxx AliCluster3D.cxx \
+AliTrackleter.cxx \
 AliHelix.cxx AliV0.cxx AliKink.cxx \
 AliSelectorRL.cxx \
 AliSurveyObj.cxx AliSurveyPoint.cxx \