Methods renamed

diff --git a/ITS/AliITSMultReconstructor.cxx b/ITS/AliITSMultReconstructor.cxx
index 07cd5001c49b55e6c97410098d14b1df80444304..cb876016f076a0aa7ac8ec1c40024e444125b80e 100644 (file)
--- a/ITS/AliITSMultReconstructor.cxx
+++ b/ITS/AliITSMultReconstructor.cxx
@@ -46,8 +46,9 @@
 //     - multiple association forbidden (fOnlyOneTrackletPerC2 = kTRUE) 
 //     - phi definition changed to ALICE convention (0,2*TMath::pi()) 
 //     - cluster coordinates taken with GetGlobalXYZ()
 //     - 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>
 //____________________________________________________________________
 
 #include <TClonesArray.h>


@@ -56,6 +57,7 @@
 #include <TTree.h>
 
 #include "AliITSMultReconstructor.h"
 #include <TTree.h>
 
 #include "AliITSMultReconstructor.h"

+#include "AliITSsegmentationSPD.h"

 #include "AliITSRecPoint.h"
 #include "AliITSgeom.h"
 #include "AliLog.h"
 #include "AliITSRecPoint.h"
 #include "AliITSgeom.h"
 #include "AliLog.h"


@@ -93,6 +95,10 @@ fhetaTracklets(0),
 fhphiTracklets(0),
 fhetaClustersLay1(0),
 fhphiClustersLay1(0){
 fhphiTracklets(0),
 fhetaClustersLay1(0),
 fhphiClustersLay1(0){

+
+  fNFiredChips[0] = 0;
+  fNFiredChips[1] = 0;
+

   // Method to reconstruct the charged particles multiplicity with the 
   // SPD (tracklets).
 
   // 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
   // - 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;
   
   fNClustersLay1 = 0;
   fNClustersLay2 = 0;

+  fNFiredChips[0] = 0;
+  fNFiredChips[1] = 0;

   
   

+  AliITSsegmentationSPD *seg = new AliITSsegmentationSPD();
+

   TClonesArray* itsClusters = new TClonesArray("AliITSRecPoint");
   TBranch* itsClusterBranch=itsClusterTree->GetBranch("ITSRecPoints");
 
   TClonesArray* itsClusters = new TClonesArray("AliITSRecPoint");
   TBranch* itsClusterBranch=itsClusterTree->GetBranch("ITSRecPoints");
 


@@ -460,20 +471,29 @@ AliITSMultReconstructor::LoadClusterArrays(TTree* itsClusterTree) {
       continue;
     
     Int_t nClusters = itsClusters->GetEntriesFast();
       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);
       
     
     // 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];      
       
       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;
        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++;
       }
                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;
        fClustersLay2[fNClustersLay2][0] = x;
        fClustersLay2[fNClustersLay2][1] = y;
        fClustersLay2[fNClustersLay2][2] = z;


@@ -491,14 +511,86 @@ AliITSMultReconstructor::LoadClusterArrays(TTree* itsClusterTree) {
       }
       
     }// end of cluster loop
       }
       
     }// 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  
   } // end of its "subdetector" loop  

-  
+

   if (itsClusters) {
     itsClusters->Delete();
     delete itsClusters;
   if (itsClusters) {
     itsClusters->Delete();
     delete itsClusters;

+    delete seg;

     itsClusters = 0;
   }
   AliDebug(1,Form("(clusters in layer 1 : %d,  layer 2: %d)",fNClustersLay1,fNClustersLay2));
     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
 }
 //____________________________________________________________________
 void


@@ -526,5 +618,3 @@ AliITSMultReconstructor::SaveHists() {
   fhetaClustersLay1->Write();
   fhphiClustersLay1->Write();
 }
   fhetaClustersLay1->Write();
   fhphiClustersLay1->Write();
 }

-
-

diff --git a/ITS/AliITSMultReconstructor.h b/ITS/AliITSMultReconstructor.h
index c0e69e65cae4d6e388858115df0ca0c0aee75482..7699c0a477c61215fa01e77c2c5c91969204e21a 100644 (file)
--- a/ITS/AliITSMultReconstructor.h
+++ b/ITS/AliITSMultReconstructor.h
@@ -37,6 +37,7 @@ public:
   virtual ~AliITSMultReconstructor();
 
   void Reconstruct(TTree* tree, Float_t* vtx, Float_t* vtxRes);
   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;}
 
   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;}
   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];}
 
   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);
 
   
   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        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);
 
 
   void LoadClusterArrays(TTree* tree);
 

diff --git a/ITS/AliITSVertexer.cxx b/ITS/AliITSVertexer.cxx
index 250b9cca5b18cdad8533bf2468c15f47ac6a832d..29aa88bb6f8134e3d9bb3cedc5daf84d5b8d2dec 100644 (file)
--- a/ITS/AliITSVertexer.cxx
+++ b/ITS/AliITSVertexer.cxx
@@ -41,11 +41,22 @@ void AliITSVertexer::FindMultiplicity(TTree *itsClusterTree){
   Bool_t success=kTRUE;
   if(!fCurrentVertex)success=kFALSE;
   if(fCurrentVertex && fCurrentVertex->GetNContributors()<1)success=kFALSE;
   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");
   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;
   }
     return;
   }

-  AliITSMultReconstructor* multReco = new AliITSMultReconstructor();

 
   if (!itsClusterTree) {
     AliError(" Invalid ITS cluster tree !\n");
 
   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];
   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];
   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++){
   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;
   delete [] tht;
   delete [] phi;
   delete [] dphi;


@@ -86,7 +101,6 @@ void AliITSVertexer::FindMultiplicity(TTree *itsClusterTree){
   delete [] labels;
   delete [] labelsL2;
 
   delete [] labels;
   delete [] labelsL2;
 

-  delete multReco;

   return;
 }
 
   return;
 }
 

diff --git a/STEER/AliMultiplicity.cxx b/STEER/AliMultiplicity.cxx
index d3332f8fba8f1a43d80a4afd690ebb92ae3ebcf7..370d2a646b5f3949499eedb4d96308600ea544f7 100644 (file)
--- a/STEER/AliMultiplicity.cxx
+++ b/STEER/AliMultiplicity.cxx
@@ -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),
   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];
     }
   }
       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;
 
 }
   if(fPhisingle)delete [] fPhisingle;fPhisingle = 0;
 
 }

-
-

diff --git a/STEER/AliMultiplicity.h b/STEER/AliMultiplicity.h
index 9c5a3cc2eeca09e9392121768f49300a04e8664b..974cca53a0c74ab8da00429a069c3a023676307c 100644 (file)
--- a/STEER/AliMultiplicity.h
+++ b/STEER/AliMultiplicity.h
@@ -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,
   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;
   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.;}}
 
   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:
   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
   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);
 };
 
   ClassDef(AliMultiplicity,7);
 };