Methods renamed
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 8 Jul 2008 08:55:13 +0000 (08:55 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 8 Jul 2008 08:55:13 +0000 (08:55 +0000)
ITS/AliITSMultReconstructor.cxx
ITS/AliITSMultReconstructor.h
ITS/AliITSVertexer.cxx
STEER/AliMultiplicity.cxx
STEER/AliMultiplicity.h

index 07cd500..cb87601 100644 (file)
@@ -46,8 +46,9 @@
 //     - multiple association forbidden (fOnlyOneTrackletPerC2 = kTRUE) 
 //     - phi definition changed to ALICE convention (0,2*TMath::pi()) 
 //     - cluster coordinates taken with GetGlobalXYZ()
+//     - fGeometry removed
+//     - number of fired chips on the two layers
 //
-//  fGeometry removed
 //____________________________________________________________________
 
 #include <TClonesArray.h>
@@ -56,6 +57,7 @@
 #include <TTree.h>
 
 #include "AliITSMultReconstructor.h"
+#include "AliITSsegmentationSPD.h"
 #include "AliITSRecPoint.h"
 #include "AliITSgeom.h"
 #include "AliLog.h"
@@ -93,6 +95,10 @@ fhetaTracklets(0),
 fhphiTracklets(0),
 fhetaClustersLay1(0),
 fhphiClustersLay1(0){
+
+  fNFiredChips[0] = 0;
+  fNFiredChips[1] = 0;
+
   // Method to reconstruct the charged particles multiplicity with the 
   // SPD (tracklets).
 
@@ -439,12 +445,17 @@ AliITSMultReconstructor::LoadClusterArrays(TTree* itsClusterTree) {
   // - 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
   
-  AliDebug(1,"Loading clusters ...");
+  AliDebug(1,"Loading clusters and cluster-fired chips ...");
   
   fNClustersLay1 = 0;
   fNClustersLay2 = 0;
+  fNFiredChips[0] = 0;
+  fNFiredChips[1] = 0;
   
+  AliITSsegmentationSPD *seg = new AliITSsegmentationSPD();
+
   TClonesArray* itsClusters = new TClonesArray("AliITSRecPoint");
   TBranch* itsClusterBranch=itsClusterTree->GetBranch("ITSRecPoints");
 
@@ -460,20 +471,29 @@ AliITSMultReconstructor::LoadClusterArrays(TTree* itsClusterTree) {
       continue;
     
     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);
       
-      if (cluster->GetLayer()>1) 
-       continue;            
+      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 (cluster->GetLayer()==0) {
+      if (layer==0) {
        fClustersLay1[fNClustersLay1][0] = x;
        fClustersLay1[fNClustersLay1][1] = y;
        fClustersLay1[fNClustersLay1][2] = z;
@@ -481,7 +501,7 @@ AliITSMultReconstructor::LoadClusterArrays(TTree* itsClusterTree) {
                fClustersLay1[fNClustersLay1][3+i] = cluster->GetLabel(i);
        fNClustersLay1++;
       }
-      if (cluster->GetLayer()==1) {
+      if (layer==1) {
        fClustersLay2[fNClustersLay2][0] = x;
        fClustersLay2[fNClustersLay2][1] = y;
        fClustersLay2[fNClustersLay2][2] = z;
@@ -491,14 +511,86 @@ AliITSMultReconstructor::LoadClusterArrays(TTree* itsClusterTree) {
       }
       
     }// end of cluster loop
+
+    // get number of fired chips in the current module
+    if(layer<2)
+    for(Int_t ifChip=0; ifChip<5; ifChip++) {
+      if(nClustersInChip[ifChip] >= 1)  fNFiredChips[layer]++;
+    }
+
   } // end of its "subdetector" loop  
-  
+
   if (itsClusters) {
     itsClusters->Delete();
     delete itsClusters;
+    delete seg;
     itsClusters = 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]));
+}
+//____________________________________________________________________
+void
+AliITSMultReconstructor::LoadClusterFiredChips(TTree* itsClusterTree) {
+  // This method
+  // - gets the clusters from the cluster tree 
+  // - counts the number of (cluster)fired chips
+  
+  AliDebug(1,"Loading cluster-fired chips ...");
+  
+  fNFiredChips[0] = 0;
+  fNFiredChips[1] = 0;
+  
+  AliITSsegmentationSPD *seg = new AliITSsegmentationSPD();
+
+  TClonesArray* itsClusters = new TClonesArray("AliITSRecPoint");
+  TBranch* itsClusterBranch=itsClusterTree->GetBranch("ITSRecPoints");
+
+  itsClusterBranch->SetAddress(&itsClusters);
+
+  Int_t nItsSubs = (Int_t)itsClusterTree->GetEntries();  
+  // loop over the its subdetectors
+  for (Int_t iIts=0; iIts < nItsSubs; iIts++) {
+    
+    if (!itsClusterTree->GetEvent(iIts)) 
+      continue;
+    
+    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;            
+
+      // find the chip for the current cluster
+      Float_t locz = cluster->GetDetLocalZ();
+      Int_t iChip = seg->GetChipFromLocal(0,locz);
+      nClustersInChip[iChip]++; 
+      
+    }// end of cluster loop
+
+    // get number of fired chips in the current module
+    if(layer<2)
+    for(Int_t ifChip=0; ifChip<5; ifChip++) {
+      if(nClustersInChip[ifChip] >= 1)  fNFiredChips[layer]++;
+    }
+
+  } // end of its "subdetector" loop  
+  
+  if (itsClusters) {
+    itsClusters->Delete();
+    delete itsClusters;
+    delete seg;
+    itsClusters = 0;
+  }
+  AliDebug(1,Form("(cluster-fired chips in layer 1 : %d,  layer 2: %d)",fNFiredChips[0],fNFiredChips[1]));
 }
 //____________________________________________________________________
 void
@@ -526,5 +618,3 @@ AliITSMultReconstructor::SaveHists() {
   fhetaClustersLay1->Write();
   fhphiClustersLay1->Write();
 }
-
-
index c0e69e6..7699c0a 100644 (file)
@@ -37,6 +37,7 @@ public:
   virtual ~AliITSMultReconstructor();
 
   void Reconstruct(TTree* tree, Float_t* vtx, Float_t* vtxRes);
+  void LoadClusterFiredChips(TTree* tree);
 
   void SetPhiWindow(Float_t w=0.08) {fPhiWindow=w;}
   void SetZetaWindow(Float_t w=1.) {fZetaWindow=w;}
@@ -46,6 +47,7 @@ public:
   Int_t GetNClustersLayer2() const {return fNClustersLay2;}
   Int_t GetNTracklets() const {return fNTracklets;}
   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];}
@@ -60,42 +62,43 @@ protected:
   AliITSMultReconstructor& operator=(const AliITSMultReconstructor& mr);
 
   
-  Float_t**     fClustersLay1;        // clusters in the 1st layer of ITS 
-  Float_t**     fClustersLay2;        // clusters in the 2nd layer of ITS 
-  Float_t**     fTracklets;           // tracklets 
-  Float_t**     fSClusters;           // single clusters (unassociated)
-  Bool_t*       fAssociationFlag;     // flag for the associations 
+  Float_t**     fClustersLay1;         // clusters in the 1st layer of ITS 
+  Float_t**     fClustersLay2;         // clusters in the 2nd layer of ITS 
+  Float_t**     fTracklets;            // tracklets 
+  Float_t**     fSClusters;            // single clusters (unassociated)
+  Bool_t*       fAssociationFlag;      // flag for the associations 
   
-  Int_t         fNClustersLay1; // Number of clusters (Layer1)
-  Int_t         fNClustersLay2; // Number of clusters (Layer2)
-  Int_t         fNTracklets;    // Number of tracklets
-  Int_t         fNSingleCluster;    // Number of unassociated clusters
-
-  Float_t       fPhiWindow;     // Search window in phi
-  Float_t       fZetaWindow;    // SEarch window in eta
+  Int_t         fNClustersLay1;        // Number of clusters (Layer1)
+  Int_t         fNClustersLay2;        // Number of clusters (Layer2)
+  Int_t         fNTracklets;           // Number of tracklets
+  Int_t         fNSingleCluster;       // Number of unassociated clusters
+  Short_t       fNFiredChips[2];       // Number of fired chips in the two SPD layers
+  Float_t       fPhiWindow;            // Search window in phi
+  Float_t       fZetaWindow;           // SEarch window in eta
 
   Bool_t        fOnlyOneTrackletPerC2; // only one tracklet per cluster in L. 2
   
-  Bool_t        fHistOn; // Option to define and fill the histograms 
+  Bool_t        fHistOn;               // Option to define and fill the histograms 
 
 
-  TH1F*         fhClustersDPhiAcc;   // Phi2 - Phi1 for tracklets 
-  TH1F*         fhClustersDThetaAcc; // Theta2 - Theta1 for tracklets 
-  TH1F*         fhClustersDZetaAcc;  // z2 - z1projected for tracklets 
-  TH1F*         fhClustersDPhiAll;   // Phi2 - Phi1 all the combinations 
-  TH1F*         fhClustersDThetaAll; // Theta2 - Theta1 all the combinations
-  TH1F*         fhClustersDZetaAll;  // z2 - z1projected all the combinations
-  TH2F*         fhDPhiVsDThetaAll; // 2D plot for all the combinations  
-  TH2F*         fhDPhiVsDThetaAcc; // same plot for tracklets 
-  TH2F*         fhDPhiVsDZetaAll;  // 2d plot for all the combination 
-  TH2F*         fhDPhiVsDZetaAcc;  // same plot for tracklets 
-
-  TH1F*         fhetaTracklets;    // Pseudorapidity distr. for tracklets 
-  TH1F*         fhphiTracklets;    // Azimuthal (Phi) distr. for tracklets  
-  TH1F*         fhetaClustersLay1; // Pseudorapidity distr. for Clusters L. 1
-  TH1F*         fhphiClustersLay1; // Azimuthal (Phi) distr. for Clusters L. 1 
+  TH1F*         fhClustersDPhiAcc;     // Phi2 - Phi1 for tracklets 
+  TH1F*         fhClustersDThetaAcc;   // Theta2 - Theta1 for tracklets 
+  TH1F*         fhClustersDZetaAcc;    // z2 - z1projected for tracklets 
+  TH1F*         fhClustersDPhiAll;     // Phi2 - Phi1 all the combinations 
+  TH1F*         fhClustersDThetaAll;   // Theta2 - Theta1 all the combinations
+  TH1F*         fhClustersDZetaAll;    // z2 - z1projected all the combinations
  
+  TH2F*         fhDPhiVsDThetaAll;     // 2D plot for all the combinations  
+  TH2F*         fhDPhiVsDThetaAcc;     // same plot for tracklets 
+  TH2F*         fhDPhiVsDZetaAll;      // 2d plot for all the combination 
+  TH2F*         fhDPhiVsDZetaAcc;      // same plot for tracklets 
+
+  TH1F*         fhetaTracklets;        // Pseudorapidity distr. for tracklets 
+  TH1F*         fhphiTracklets;        // Azimuthal (Phi) distr. for tracklets  
+  TH1F*         fhetaClustersLay1;     // Pseudorapidity distr. for Clusters L. 1
+  TH1F*         fhphiClustersLay1;     // Azimuthal (Phi) distr. for Clusters L. 1 
+
 
   void LoadClusterArrays(TTree* tree);
 
index 250b9cc..29aa88b 100644 (file)
@@ -41,11 +41,22 @@ void AliITSVertexer::FindMultiplicity(TTree *itsClusterTree){
   Bool_t success=kTRUE;
   if(!fCurrentVertex)success=kFALSE;
   if(fCurrentVertex && fCurrentVertex->GetNContributors()<1)success=kFALSE;
+
+  AliITSMultReconstructor multReco;
+
   if(!success){
     AliWarning("Tracklets multiplicity not determined because the primary vertex was not found");
+    AliWarning("Just counting the number of cluster-fired chips on the SPD layers");
+    if (!itsClusterTree) {
+      AliError(" Invalid ITS cluster tree !\n");
+      return;
+    }
+    multReco.LoadClusterFiredChips(itsClusterTree);
+    Short_t nfcL1 = multReco.GetNFiredChips(0);
+    Short_t nfcL2 = multReco.GetNFiredChips(1);
+    fMult = new AliMultiplicity(0,0,0,0,0,0,0,0,0,nfcL1,nfcL2);
     return;
   }
-  AliITSMultReconstructor* multReco = new AliITSMultReconstructor();
 
   if (!itsClusterTree) {
     AliError(" Invalid ITS cluster tree !\n");
@@ -55,29 +66,33 @@ void AliITSVertexer::FindMultiplicity(TTree *itsClusterTree){
   fCurrentVertex->GetXYZ(vtx);
   Float_t vtxf[3];
   for(Int_t i=0;i<3;i++)vtxf[i]=vtx[i];
-  multReco->SetHistOn(kFALSE);
-  multReco->Reconstruct(itsClusterTree,vtxf,vtxf);
-  Int_t notracks=multReco->GetNTracklets();
+  multReco.SetHistOn(kFALSE);
+  multReco.Reconstruct(itsClusterTree,vtxf,vtxf);
+  Int_t notracks=multReco.GetNTracklets();
   Float_t *tht = new Float_t [notracks];
   Float_t *phi = new Float_t [notracks];
   Float_t *dphi = new Float_t [notracks];
   Int_t *labels = new Int_t[notracks];
   Int_t *labelsL2 = new Int_t[notracks];
-  for(Int_t i=0;i<multReco->GetNTracklets();i++){
-    tht[i] = multReco->GetTracklet(i)[0];
-    phi[i] =  multReco->GetTracklet(i)[1];
-    dphi[i] = multReco->GetTracklet(i)[2];
-    labels[i] = static_cast<Int_t>(multReco->GetTracklet(i)[3]);
-    labelsL2[i] = static_cast<Int_t>(multReco->GetTracklet(i)[4]);
+  for(Int_t i=0;i<multReco.GetNTracklets();i++){
+    tht[i] = multReco.GetTracklet(i)[0];
+    phi[i] =  multReco.GetTracklet(i)[1];
+    dphi[i] = multReco.GetTracklet(i)[2];
+    labels[i] = static_cast<Int_t>(multReco.GetTracklet(i)[3]);
+    labelsL2[i] = static_cast<Int_t>(multReco.GetTracklet(i)[4]);
   }
-  Int_t nosingleclus=multReco->GetNSingleClusters();
+  Int_t nosingleclus=multReco.GetNSingleClusters();
   Float_t *ths = new Float_t [nosingleclus];
   Float_t *phs = new Float_t [nosingleclus];
   for(Int_t i=0;i<nosingleclus;i++){
-    ths[i] = multReco->GetCluster(i)[0];
-    phs[i] =  multReco->GetCluster(i)[1];
+    ths[i] = multReco.GetCluster(i)[0];
+    phs[i] = multReco.GetCluster(i)[1];
   }
-  fMult = new AliMultiplicity(notracks,tht,phi,dphi,labels,labelsL2,nosingleclus,ths,phs);
+  Short_t nfcL1 = multReco.GetNFiredChips(0);
+  Short_t nfcL2 = multReco.GetNFiredChips(1);
+  multReco.Dump();
+  fMult = new AliMultiplicity(notracks,tht,phi,dphi,labels,labelsL2,nosingleclus,ths,phs,nfcL1,nfcL2);
+
   delete [] tht;
   delete [] phi;
   delete [] dphi;
@@ -86,7 +101,6 @@ void AliITSVertexer::FindMultiplicity(TTree *itsClusterTree){
   delete [] labels;
   delete [] labelsL2;
 
-  delete multReco;
   return;
 }
 
index d3332f8..370d2a6 100644 (file)
@@ -22,7 +22,7 @@ AliMultiplicity::AliMultiplicity():
 }
 
 //______________________________________________________________________
-AliMultiplicity::AliMultiplicity(Int_t ntr, Float_t *t,  Float_t *ph, Float_t *df, Int_t *labels, Int_t* labelsL2, Int_t ns, Float_t *ts, Float_t *ps):
+AliMultiplicity::AliMultiplicity(Int_t ntr, Float_t *t,  Float_t *ph, Float_t *df, Int_t *labels, Int_t* labelsL2, Int_t ns, Float_t *ts, Float_t *ps, Short_t nfcL1, Short_t nfcL2):
   TObject(),
   fNtracks(ntr),
   fNsingle(ns),
@@ -57,8 +57,8 @@ AliMultiplicity::AliMultiplicity(Int_t ntr, Float_t *t,  Float_t *ph, Float_t *d
       fPhisingle[i]=ps[i];
     }
   }
-  fFiredChips[0] = 0;
-  fFiredChips[1] = 0;
+  fFiredChips[0] = nfcL1;
+  fFiredChips[1] = nfcL2;
 }
 
 //______________________________________________________________________
@@ -161,5 +161,3 @@ AliMultiplicity::~AliMultiplicity(){
   if(fPhisingle)delete [] fPhisingle;fPhisingle = 0;
 
 }
-
-
index 9c5a3cc..974cca5 100644 (file)
@@ -16,7 +16,7 @@ class AliMultiplicity : public TObject {
   AliMultiplicity();               // default constructor
   // standard constructor
   AliMultiplicity(Int_t ntr,Float_t *t, Float_t *ph, Float_t *df, Int_t *labels,
-                  Int_t* labelsL2, Int_t ns, Float_t *ts, Float_t *ps);
+                  Int_t* labelsL2, Int_t ns, Float_t *ts, Float_t *ps, Short_t nfcL1, Short_t nfcL2);
   AliMultiplicity(const AliMultiplicity& m);
   AliMultiplicity& operator=(const AliMultiplicity& m);
   virtual void Copy(TObject &obj) const;
@@ -41,7 +41,7 @@ class AliMultiplicity : public TObject {
   Double_t GetPhiSingle(Int_t i) const { if(i>=0 && i<fNsingle) {return fPhisingle[i];}
   else {Error("GetPhisingle","Invalid cluster number %d",i); return -9999.;}}
 
-  Short_t GetFiredChips(Int_t layer) { return fFiredChips[layer]; }
+  Short_t GetNumberOfFiredChips(Int_t layer) { return fFiredChips[layer]; }
   void SetFiredChips(Int_t layer, Short_t firedChips) { fFiredChips[layer] = firedChips; }
 
   protected:
@@ -57,7 +57,7 @@ class AliMultiplicity : public TObject {
   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
-  Short_t fFiredChips[2]; // number of fired chips in the two SPD layers
+  Short_t fFiredChips[2];    // Number of fired chips in the two SPD layers
 
   ClassDef(AliMultiplicity,7);
 };