coding conventions
authorloizides <loizides@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 30 Aug 2011 14:46:42 +0000 (14:46 +0000)
committerloizides <loizides@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 30 Aug 2011 14:46:42 +0000 (14:46 +0000)
EMCAL/AliEMCALClusterizerFixedWindow.cxx
EMCAL/AliEMCALClusterizerFixedWindow.h
EMCAL/AliEMCALFixedWindowClusterInfo.cxx
EMCAL/AliEMCALFixedWindowClusterInfo.h

index 289e397..b094e28 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-// This class derives from AliEMCALClustrerizer but also keeps the API of AliEMCALClusterizerv1
-// Algorithm:
-// 1. peek the most energetic cell
-// 2. assign it as a center of the cluster and add cells surrounding it: 3x3, 5x5...
-// 3. remove the cells contributing to the cluster
-// 4. start from 1 for the remaining clusters
-// 5. cluster splitting (not implemented yet) - use the shape analysis to resolve the energy sharing
-// - for high energy clusters check the surrounding of the 3x3 clusters for extra energy 
-// (merge 3x3 clusters and resolve the internal energy sharing - case for 2 clusters merged)
-// Use Case:
-//  root [0] AliEMCALClusterizerFixedWindow * cl = new AliEMCALClusterizerFixedWindow("galice.root")  
-//  Warning in <TDatabasePDG::TDatabasePDG>: object already instantiated
-//               //reads gAlice from header file "..."                      
-//  root [1] cl->ExecuteTask()  
-//               //finds RecPoints in all events stored in galice.root
-//  root [2] cl->SetDigitsBranch("digits2") 
-//               //sets another title for Digitis (input) branch
-//  root [3] cl->SetRecPointsBranch("recp2")  
-//               //sets another title four output branches
-//  root [4] cl->SetTowerLocalMaxCut(0.03)  
-//               //set clusterization parameters
-//  root [5] cl->ExecuteTask("deb all time")  
-//               //once more finds RecPoints options are 
-//               // deb - print number of found rec points
-//               // deb all - print number of found RecPoints and some their characteristics 
-//               // time - print benchmarking results
+// This class derives from AliEMCALClustrerizer
 
-#include "AliEMCALClusterizerFixedWindow.h"
-
-// --- ROOT system ---
+// --- Root ---
 #include <TMath.h> 
 #include <TMinuit.h>
 #include <TTree.h> 
 #include <TClonesArray.h>
 #include <TH1I.h>
 
-// --- Standard library ---
-#include <cassert>
-//#include <iostream>
-//#include <fstream>
-
-// --- AliRoot header files ---
+// --- AliRoot ---
 #include "AliLog.h"
 #include "AliEMCALRecPoint.h"
 #include "AliEMCALDigit.h"
 #include "AliEMCALUnfolding.h"
 #include "AliEMCALFixedWindowClusterInfo.h"
 
+#include "AliEMCALClusterizerFixedWindow.h"
+
 ClassImp(AliEMCALClusterizerFixedWindow)
 
-//____________________________________________________________________________
+//__________________________________________________________________________________________
 AliEMCALClusterizerFixedWindow::AliEMCALClusterizerFixedWindow()
-: AliEMCALClusterizer(), 
-nPhi(4), 
-nEta(4), 
-shiftPhi(2), 
-shiftEta(2),
-fTRUshift(0), 
-clusters_array(0),
-fClustersInfo(new AliEMCALFixedWindowClusterInfo("clustersInfo"))
+  : AliEMCALClusterizer(), 
+    fNphi(4), 
+    fNeta(4), 
+    fShiftPhi(2), 
+    fShiftEta(2),
+    fTRUshift(0),
+    fClustersInfo(new AliEMCALFixedWindowClusterInfo("clustersInfo")),
+    fClustersArray(0)
 {
-       // ctor with the indication of the file where header Tree and digits Tree are stored
-
+       // Constructor
 }
 
-//____________________________________________________________________________
+//__________________________________________________________________________________________
 AliEMCALClusterizerFixedWindow::AliEMCALClusterizerFixedWindow(AliEMCALGeometry* geometry)
-: AliEMCALClusterizer(geometry), 
-nPhi(4), 
-nEta(4), 
-shiftPhi(2), 
-shiftEta(2), 
-fTRUshift(0), 
-clusters_array(0),
-fClustersInfo(new AliEMCALFixedWindowClusterInfo("clustersInfo"))
+  : AliEMCALClusterizer(geometry), 
+    fNphi(4), 
+    fNeta(4), 
+    fShiftPhi(2), 
+    fShiftEta(2),
+    fTRUshift(0),
+    fClustersInfo(new AliEMCALFixedWindowClusterInfo("clustersInfo")),
+    fClustersArray(0)
 {
-       // ctor with the indication of the file where header Tree and digits Tree are stored
-       // use this contructor to avoid usage of Init() which uses runloader
-       // change needed by HLT - MP
+  // Constructor
 }
 
-//____________________________________________________________________________
+//__________________________________________________________________________________________
 AliEMCALClusterizerFixedWindow::AliEMCALClusterizerFixedWindow(AliEMCALGeometry* geometry, AliEMCALCalibData * calib, AliCaloCalibPedestal * caloped)
-: AliEMCALClusterizer(geometry, calib, caloped),
-nPhi(4), 
-nEta(4), 
-shiftPhi(2), 
-shiftEta(2), 
-fTRUshift(0), 
-clusters_array(0),
-fClustersInfo(new AliEMCALFixedWindowClusterInfo("clustersInfo"))
+  : AliEMCALClusterizer(geometry, calib, caloped),
+    fNphi(4), 
+    fNeta(4), 
+    fShiftPhi(2), 
+    fShiftEta(2),
+    fTRUshift(0),
+    fClustersInfo(new AliEMCALFixedWindowClusterInfo("clustersInfo")),
+    fClustersArray(0)
 {
-       // ctor, geometry and calibration are initialized elsewhere.
+  // Constructor
 }
 
-//____________________________________________________________________________
+//__________________________________________________________________________________________
 AliEMCALClusterizerFixedWindow::~AliEMCALClusterizerFixedWindow()
 {
-       // dtor
+       // Destructor
+  
   delete fClustersInfo;
+  delete fClustersArray;
+}
+
+//__________________________________________________________________________________________
+void AliEMCALClusterizerFixedWindow::SetNphi (Int_t n) 
+{
+  // Set fNphi; if clusterizer already initialized gives a warning and does nothing
+  
+  if (fClustersArray)
+    AliWarning("Clusterizer already initialized. Unable to change the parameters.");
+  else
+    fNphi = n;
+}
+
+//__________________________________________________________________________________________
+void AliEMCALClusterizerFixedWindow::SetNeta (Int_t n) 
+{
+  // Set fNeta; if clusterizer already initialized gives a warning and does nothing
+  
+  if (fClustersArray)
+    AliWarning("Clusterizer already initialized. Unable to change the parameters.");
+  else
+    fNeta = n;
+}
+
+//__________________________________________________________________________________________
+void AliEMCALClusterizerFixedWindow::SetShiftPhi (Int_t s) 
+{
+  // Set fShiftPhi; if clusterizer already initialized gives a warning and does nothing
+  
+  if (fClustersArray)
+    AliWarning("Clusterizer already initialized. Unable to change the parameters.");
+  else
+    fShiftPhi = s;
+}
+
+//__________________________________________________________________________________________
+void AliEMCALClusterizerFixedWindow::SetShiftEta (Int_t s) 
+{
+  // Set fShiftEta; if clusterizer already initialized gives a warning and does nothing
+  
+  if (fClustersArray)
+    AliWarning("Clusterizer already initialized. Unable to change the parameters.");
+  else
+    fShiftEta = s;
+}
+
+//__________________________________________________________________________________________
+void AliEMCALClusterizerFixedWindow::SetTRUshift(Bool_t b) 
+{
+  // Set fTRUshift; if clusterizer already initialized gives a warning and does nothing
+  
+  if (fClustersArray)
+    AliWarning("Clusterizer already initialized. Unable to change the parameters.");
+  else
+    fTRUshift = b;
 }
 
-//____________________________________________________________________________
+
+//__________________________________________________________________________________________
 void AliEMCALClusterizerFixedWindow::Digits2Clusters(Option_t * option)
 {
        // Steering method to perform clusterization for the current event 
-       // in AliEMCALLoader
        
        if (strstr(option,"tim"))
                gBenchmark->Start("EMCALClusterizer"); 
@@ -159,8 +183,6 @@ void AliEMCALClusterizerFixedWindow::Digits2Clusters(Option_t * option)
                }
        }
        
-       //fRecPoints->Sort();
-       
        for (Int_t index = 0; index < fRecPoints->GetEntries(); index++) {
                AliEMCALRecPoint *rp = dynamic_cast<AliEMCALRecPoint *>(fRecPoints->At(index));
                if (rp) {
@@ -184,7 +206,7 @@ void AliEMCALClusterizerFixedWindow::Digits2Clusters(Option_t * option)
        }    
 }
 
-//____________________________________________________________________________
+//__________________________________________________________________________________________
 void AliEMCALClusterizerFixedWindow::MakeClusters()
 {
        // Make clusters
@@ -195,7 +217,7 @@ void AliEMCALClusterizerFixedWindow::MakeClusters()
        fNumberOfECAClusters = 0;
        fRecPoints->Delete();
   
-  if (fClustersInfo->GetLastElementId() > 0)
+  if (fClustersInfo->GetLastElementPosition() > 0)
     fClustersInfo->Clear();
        
        Int_t nSupMod=0, nModule=0, nIphi=0, nIeta=0, iphi=0, ieta=0;
@@ -210,8 +232,7 @@ void AliEMCALClusterizerFixedWindow::MakeClusters()
   Int_t nEtaDigits = nEtaDigitsSupMod * fGeom->GetNumberOfSuperModules() / fGeom->GetNPhiSuperModule();
   Int_t nPhiDigits = nPhiDigitsSupMod * fGeom->GetNPhiSuperModule();    
   
-  if (fTRUshift)
-  {
+  if (fTRUshift){
     nTRUPhi = fGeom->GetNPhiSuperModule() * 3;
     nTRUEta = fGeom->GetNumberOfSuperModules() / fGeom->GetNPhiSuperModule();
     nEtaDigits /= nTRUEta;
@@ -219,68 +240,59 @@ void AliEMCALClusterizerFixedWindow::MakeClusters()
   }
 
   // Check if clusterizer parameter are compatible with calorimeter geometry
-  if (nEtaDigits < nEta)
-       {
-               AliFatal(Form("Error: nEta = %d is greater than nEtaDigits = %d.",nEta,nEtaDigits));
+  if (nEtaDigits < fNeta){
+               AliFatal(Form("Error: fNeta = %d is greater than nEtaDigits = %d.",fNeta,nEtaDigits));
                return;
        }
-       if (nPhiDigits < nPhi)
-       {
-               AliFatal(Form("Error: nPhi = %d is greater than nPhiDigits = %d.",nPhi,nPhiDigits));
+       if (nPhiDigits < fNphi){
+               AliFatal(Form("Error: fNphi = %d is greater than nPhiDigits = %d.",fNphi,nPhiDigits));
                return;
        }
-       if (nEtaDigits % shiftEta != 0)
-       {
-               AliFatal(Form("Error: shiftEta = %d is such that clusters cannot slide the whole calorimeter (nEtaDigits = %d).",shiftEta,nEtaDigits));
+       if (nEtaDigits % fShiftEta != 0){
+               AliFatal(Form("Error: fShiftEta = %d is such that clusters cannot slide the whole calorimeter (nEtaDigits = %d).",fShiftEta,nEtaDigits));
                return;
        }
-       if (nPhiDigits % shiftPhi != 0)
-       {
-               AliFatal(Form("Error: shiftPhi = %d is such that clusters cannot slide the whole calorimeter (nPhiDigits = %d).",shiftPhi,nPhiDigits));
+       if (nPhiDigits % fShiftPhi != 0){
+               AliFatal(Form("Error: fShiftPhi = %d is such that clusters cannot slide the whole calorimeter (nPhiDigits = %d).",fShiftPhi,nPhiDigits));
                return;
        }
-       if (nEta % shiftEta != 0)
-       {
-               AliFatal(Form("Error: shiftEta = %d is not divisor of nEta = %d.",shiftEta,nEta));
+       if (fNeta % fShiftEta != 0){
+               AliFatal(Form("Error: fShiftEta = %d is not divisor of fNeta = %d.",fShiftEta,fNeta));
                return;
        }
-       if (nPhi % shiftPhi != 0)
-       {
-               AliFatal(Form("Error: shiftPhi = %d is not divisor of nPhi = %d).",shiftPhi,nPhi));
+       if (fNphi % fShiftPhi != 0){
+               AliFatal(Form("Error: fShiftPhi = %d is not divisor of fNphi = %d).",fShiftPhi,fNphi));
                return;
        }
   
-  Int_t maxiShiftPhi = nPhi / shiftPhi;
-  Int_t maxiShiftEta = nEta / shiftEta;
+  Int_t maxiShiftPhi = fNphi / fShiftPhi;
+  Int_t maxiShiftEta = fNeta / fShiftEta;
        
-       Int_t nDigitsCluster = nPhi * nEta;
+       Int_t nDigitsCluster = fNphi * fNeta;
   
-  Int_t nClusEtaNoShift = nEtaDigits / nEta;
-  Int_t nClusPhiNoShift = nPhiDigits / nPhi;
+  Int_t nClusEtaNoShift = nEtaDigits / fNeta;
+  Int_t nClusPhiNoShift = nPhiDigits / fNphi;
   
   Int_t nClusters =  nClusEtaNoShift * nClusPhiNoShift * nTRUEta * nTRUPhi;
   
   Int_t nTotalClus = nClusters * maxiShiftEta * maxiShiftPhi;
   
-  if (!clusters_array)
-  {
-    clusters_array = new AliEMCALDigit**[nTotalClus];
+  if (!fClustersArray){
+    fClustersArray = new AliEMCALDigit**[nTotalClus];
     for (Int_t i = 0; i < nTotalClus; i++)
     {
-      clusters_array[i] = NULL;
+      fClustersArray[i] = NULL;
     }
   }
   
   AliEMCALDigit *digit = 0;
   
-  for (Int_t ishiftPhi = 0; ishiftPhi < maxiShiftPhi; ishiftPhi++)
-  {
-    Int_t nClusPhi = (nPhiDigits - shiftPhi * ishiftPhi) / nPhi;
+  for (Int_t ishiftPhi = 0; ishiftPhi < maxiShiftPhi; ishiftPhi++){
+    Int_t nClusPhi = (nPhiDigits - fShiftPhi * ishiftPhi) / fNphi;
     
-    for (Int_t ishiftEta = 0; ishiftEta < maxiShiftEta; ishiftEta++)
-    {
+    for (Int_t ishiftEta = 0; ishiftEta < maxiShiftEta; ishiftEta++){
       
-      Int_t nClusEta = (nEtaDigits - shiftEta * ishiftEta) / nEta; 
+      Int_t nClusEta = (nEtaDigits - fShiftEta * ishiftEta) / fNeta; 
       
       Int_t iTotalClus = nClusters * (ishiftPhi * maxiShiftEta + ishiftEta);
       
@@ -288,70 +300,64 @@ void AliEMCALClusterizerFixedWindow::MakeClusters()
       
       nextdigit.Reset();
       
-      while (digit = static_cast<AliEMCALDigit*>(nextdigit()))
-      {
+      while ((digit = static_cast<AliEMCALDigit*>(nextdigit()))){
         fGeom->GetCellIndex (digit->GetId(), nSupMod, nModule, nIphi, nIeta);
         fGeom->GetCellPhiEtaIndexInSModule (nSupMod, nModule, nIphi, nIeta, iphi, ieta);
         
-        Int_t iphi_eff = iphi - shiftPhi * ishiftPhi + nPhiDigitsSupMod * (nSupMod / 2); // N supermodules along phi
+        Int_t iphi_eff = iphi - fShiftPhi * ishiftPhi + nPhiDigitsSupMod * (nSupMod / 2); // N supermodules along phi
         
         Int_t iTRUphi = iphi_eff / nPhiDigits;
         
         iphi_eff -= iTRUphi * nPhiDigits;
         
-        Int_t iClusPhi = iphi_eff / nPhi; 
+        Int_t iClusPhi = iphi_eff / fNphi; 
         
         if (iphi_eff < 0 || iClusPhi >= nClusPhi) 
           continue;
         
-        Int_t ieta_eff = ieta - shiftEta * ishiftEta + nEtaDigitsSupMod * (nSupMod % 2); // 2 supermodules along eta
+        Int_t ieta_eff = ieta - fShiftEta * ishiftEta + nEtaDigitsSupMod * (nSupMod % 2); // 2 supermodules along eta
         
         Int_t iTRUeta = ieta_eff / nEtaDigits;
         
         ieta_eff -= iTRUeta * nEtaDigits;
         
-        Int_t iClusEta = ieta_eff / nEta; 
+        Int_t iClusEta = ieta_eff / fNeta; 
         
         if (ieta_eff < 0 || iClusEta >= nClusEta) 
           continue;
         
         iphi_eff += iTRUphi * nPhiDigits;
-        iClusPhi = iphi_eff / nPhi; 
+        iClusPhi = iphi_eff / fNphi; 
         
         ieta_eff += iTRUeta * nEtaDigits;
-        iClusEta = ieta_eff / nEta; 
+        iClusEta = ieta_eff / fNeta; 
         
         Int_t iCluster = iClusPhi + iClusEta * nClusPhiNoShift * nTRUPhi; 
-        Int_t iDigit = iphi_eff % nPhi + (ieta_eff % nEta) * nPhi;
+        Int_t iDigit = iphi_eff % fNphi + (ieta_eff % fNeta) * fNphi;
 
-        
-        if (iCluster >= nClusters)
-        {
-          AliFatal(Form("ERROR: iCluster out of range! iCluster = %d, nClusters = %d", iCluster, nClusters));
+        if (iCluster >= nClusters){
+          AliWarning(Form("iCluster out of range! iCluster = %d, nClusters = %d", iCluster, nClusters));
           return;
         }
         
         iCluster += iTotalClus;
         
-        if (clusters_array[iCluster] == NULL)
-        {
+        if (fClustersArray[iCluster] == NULL){
           fNumberOfECAClusters++;
-          clusters_array[iCluster] = new AliEMCALDigit*[nDigitsCluster];
-          for (Int_t i = 0; i < nDigitsCluster; i++)
-          {
-            clusters_array[iCluster][i] = NULL;
+          fClustersArray[iCluster] = new AliEMCALDigit*[nDigitsCluster];
+          for (Int_t i = 0; i < nDigitsCluster; i++){
+            fClustersArray[iCluster][i] = NULL;
           }
           
           fClustersInfo->Add(iCluster, -1, iClusEta, iClusPhi);
         }
         
-        if (clusters_array[iCluster][iDigit] != NULL)
-        {
-          AliFatal("ERROR: digit already added!");
+        if (fClustersArray[iCluster][iDigit] != NULL){
+          AliWarning("Digit already added!");
           return;
         }
         
-        clusters_array[iCluster][iDigit] = digit;
+        fClustersArray[iCluster][iDigit] = digit;
         
       } // loop on digit
       
@@ -360,16 +366,14 @@ void AliEMCALClusterizerFixedWindow::MakeClusters()
        } // loop on phi shift
        
   Int_t iRecPoint = 0;
-       for (Int_t iCluster = 0; iCluster < nTotalClus; iCluster++)
-       {
+       for (Int_t iCluster = 0; iCluster < nTotalClus; iCluster++){
     
-               if (clusters_array[iCluster] == NULL) continue;
+               if (fClustersArray[iCluster] == NULL) continue;
                
                (*fRecPoints)[iRecPoint] = new AliEMCALRecPoint("");
                AliEMCALRecPoint *recPoint = dynamic_cast<AliEMCALRecPoint*> (fRecPoints->At(iRecPoint));
                
-               if (recPoint) 
-               {
+               if (recPoint) {
       if (fClustersInfo->ContainsIndex(iRecPoint))
         AliFatal(Form("ERROR: index present already, %d", iRecPoint));
       
@@ -377,26 +381,24 @@ void AliEMCALClusterizerFixedWindow::MakeClusters()
       
                        iRecPoint++;       
                        recPoint->SetClusterType(AliVCluster::kEMCALClusterv1);
-                       // note: this way the sharing info is lost!
-                       for (Int_t iDigit = 0; iDigit < nDigitsCluster; iDigit++)
-                       {
-                               if (clusters_array[iCluster][iDigit] == NULL) continue;
-                               digit = clusters_array[iCluster][iDigit];
+
+                       for (Int_t iDigit = 0; iDigit < nDigitsCluster; iDigit++){
+                               if (fClustersArray[iCluster][iDigit] == NULL) continue;
+                               digit = fClustersArray[iCluster][iDigit];
         Float_t dEnergyCalibrated = digit->GetAmplitude();
         Float_t time              = digit->GetTime();
         Calibrate(dEnergyCalibrated,time,digit->GetId());
                                digit->SetCalibAmp(dEnergyCalibrated);
                                recPoint->AddDigit(*digit, dEnergyCalibrated, kFALSE); //Time or TimeR?
-        clusters_array[iCluster][iDigit] = NULL;
+        fClustersArray[iCluster][iDigit] = NULL;
                        }
                }
     
-    delete[] clusters_array[iCluster];
-    clusters_array[iCluster] = NULL;
+    delete[] fClustersArray[iCluster];
+    fClustersArray[iCluster] = NULL;
        }
   
-       AliDebug(1,Form("MakeClusters: Number of digits %d  -> (e %f)\n",
-                                       fDigitsArr->GetEntries(),fMinECut));
+       AliDebug(1, Form("MakeClusters: Number of digits %d  -> (e %f)\n", fDigitsArr->GetEntries(),fMinECut));
        
-       AliDebug(1,Form("total no of clusters %d from %d digits",fNumberOfECAClusters,fDigitsArr->GetEntriesFast())); 
+       AliDebug(1, Form("total no of clusters %d from %d digits", fNumberOfECAClusters, fDigitsArr->GetEntriesFast())); 
 }
index ca81d95..e6852fd 100644 (file)
@@ -4,7 +4,7 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-/* $Id: AliEMCALClusterizerFixedWindows.h   */
+/* $Id: AliEMCALClusterizerFixedWindow.h   */
 
 //_________________________________________________________________________
 // This class derives from AliEMCALClustrerizer
@@ -16,88 +16,45 @@ class AliEMCALDigit;
 class AliEMCALFixedWindowClusterInfo;
 
 class AliEMCALClusterizerFixedWindow : public AliEMCALClusterizer {
-       
 public:
-       
        AliEMCALClusterizerFixedWindow() ;         
        AliEMCALClusterizerFixedWindow(AliEMCALGeometry* geometry);
        AliEMCALClusterizerFixedWindow(AliEMCALGeometry* geometry, AliEMCALCalibData * calib, AliCaloCalibPedestal * pedestal);
-       
        virtual ~AliEMCALClusterizerFixedWindow();
        
-       virtual void   Digits2Clusters(Option_t *option);                // Does the job
-       
-       virtual const char * Version() const { return "clu-FixedWindow" ; }  
-       
-       void SetnPhi (Int_t n) 
-  {
-    if (clusters_array)
-      AliWarning("Clusterizer already initialized. Unable to change the parameters.");
-    else
-      nPhi = n;
-  }
-  
-       void SetnEta (Int_t n) 
-  {
-    if (clusters_array)
-      AliWarning("Clusterizer already initialized. Unable to change the parameters.");
-    else
-      nEta = n;
-  }
-       
-       Int_t GetnPhi () {return nPhi;}
-       Int_t GetnEta () {return nEta;}
-  
-  void SetshiftPhi (Int_t s) 
-  {
-    if (clusters_array)
-      AliWarning("Clusterizer already initialized. Unable to change the parameters.");
-    else
-      shiftPhi = s;
-  }
-  
-  void SetshiftEta (Int_t s) 
-  {
-    if (clusters_array)
-      AliWarning("Clusterizer already initialized. Unable to change the parameters.");
-    else
-      shiftEta = s;
-  }
-  
-  Int_t GetshiftPhi () {return shiftPhi;}
-  Int_t GetshiftEta () {return shiftEta;}
-  
-  void SetTRUshift(Bool_t b) 
-  {
-    if (clusters_array)
-      AliWarning("Clusterizer already initialized. Unable to change the parameters.");
-    else
-      fTRUshift = b;
-  }
-  
-  Bool_t GetTRUshift() {return fTRUshift;}
+public:
+       virtual void            Digits2Clusters(Option_t *option);
+       virtual const char     *Version() const { return "clu-FixedWindow"; }  
+       
+  AliEMCALFixedWindowClusterInfo*   GetClustersInfo()                                   const { return fClustersInfo;     }
+  Int_t                             GetNphi ()                                          const { return fNphi;             }
+       Int_t                             GetNeta ()                                          const { return fNeta;             }
+  Int_t                             GetShiftPhi ()                                      const { return fShiftPhi;         }
+  Int_t                             GetShiftEta ()                                      const { return fShiftEta;         }
+  Bool_t                            GetTRUshift()                                       const { return fTRUshift;         }
+  void                              SetClustersInfo(AliEMCALFixedWindowClusterInfo *ClusInfo) { fClustersInfo = ClusInfo; }
+       void                              SetNphi (Int_t n);
+       void                              SetNeta (Int_t n);
+  void                              SetShiftPhi (Int_t s);
+  void                              SetShiftEta (Int_t s);
+  void                              SetTRUshift(Bool_t b);
   
-  AliEMCALFixedWindowClusterInfo* GetClustersInfo() {return fClustersInfo;}
-  void SetClustersInfo(AliEMCALFixedWindowClusterInfo *ClusInfo) {fClustersInfo = ClusInfo;}
-
 protected:
-       
-       virtual void   MakeClusters();            
+       virtual void MakeClusters(); 
+  
+       Int_t                               fNphi;                // Fixed window number of cells in phi direction
+       Int_t                               fNeta;                // Fixed window number of cells in eta direction
+  Int_t                               fShiftPhi;            // Shifting number of cells in phi direction
+  Int_t                               fShiftEta;            // Shifting number of cells in eta direction
+  Bool_t                              fTRUshift;            // Allows shifting inside a TRU (true) of through the whole calorimeter (false)
+  AliEMCALFixedWindowClusterInfo     *fClustersInfo;        //!Point to an object where additional information are stored
+  AliEMCALDigit                    ***fClustersArray;       //!Temporary array that contains clusters
        
 private:
-       AliEMCALClusterizerFixedWindow(const AliEMCALClusterizerFixedWindow &); //copy ctor
-       AliEMCALClusterizerFixedWindow & operator = (const AliEMCALClusterizerFixedWindow &);
-       
-  // nPhi x nEta clusterizer
-       // Those parameter could be changed to get other types of fixed windows.
-       Int_t                               nPhi;
-       Int_t                               nEta; 
-  Int_t                               shiftPhi;
-  Int_t                               shiftEta;
-  Bool_t                              fTRUshift;
-  AliEMCALFixedWindowClusterInfo    *fClustersInfo;
-  AliEMCALDigit                    ***clusters_array;
+       AliEMCALClusterizerFixedWindow(const AliEMCALClusterizerFixedWindow &);                 // not implemented
+       AliEMCALClusterizerFixedWindow & operator = (const AliEMCALClusterizerFixedWindow &);   // not implemented
        
+
        ClassDef(AliEMCALClusterizerFixedWindow,4)   // Clusterizer implementation version 1
 };
 
index bb1a7c2..a2b689a 100644 (file)
 
 /* $Id$ */
 
-#include "AliEMCALFixedWindowClusterInfo.h"
-
+// --- Root ---
 #include <TNamed.h>
 #include <TArrayI.h>
 
+#include "AliEMCALFixedWindowClusterInfo.h"
+
 ClassImp(AliEMCALFixedWindowClusterInfo)
 
+//___________________________________________________________________________________________________________
 AliEMCALFixedWindowClusterInfo::AliEMCALFixedWindowClusterInfo()
-:TNamed(),
-fSize(0),
-lastElement(0),
-fIds(new TArrayI()),
-fIndexes(new TArrayI()),
-fPhi(new TArrayI()),
-fEta(new TArrayI())
+  : TNamed(),
+    fLastPos(0),
+    fIds(new TArrayI()),
+    fIndexes(new TArrayI()),
+    fPhi(new TArrayI()),
+    fEta(new TArrayI())
 {
+  // Constructor
 }
 
+//___________________________________________________________________________________________________________
 AliEMCALFixedWindowClusterInfo::AliEMCALFixedWindowClusterInfo(const char* name, Int_t size)
-:TNamed(name, name),
-fSize(size),
-lastElement(0),
-fIds(new TArrayI(size)),
-fIndexes(new TArrayI(size)),
-fPhi(new TArrayI(size)),
-fEta(new TArrayI(size))
+  : TNamed(name, name),
+    fLastPos(0),
+    fIds(new TArrayI(size)),
+    fIndexes(new TArrayI(size)),
+    fPhi(new TArrayI(size)),
+    fEta(new TArrayI(size))
 {
+  // Constructor
+  
   fIds->Reset(-1);
   fIndexes->Reset(-1);
   fPhi->Reset(-1);
   fEta->Reset(-1);
 }
 
+//___________________________________________________________________________________________________________
 AliEMCALFixedWindowClusterInfo::AliEMCALFixedWindowClusterInfo(const TString& name, Int_t size)
-:TNamed(name, name),
-fSize(size),
-lastElement(0),
-fIds(new TArrayI(size)),
-fIndexes(new TArrayI(size)),
-fPhi(new TArrayI(size)),
-fEta(new TArrayI(size))
+  : TNamed(name, name),
+    fLastPos(0),
+    fIds(new TArrayI(size)),
+    fIndexes(new TArrayI(size)),
+    fPhi(new TArrayI(size)),
+    fEta(new TArrayI(size))
 {
+  // Constructor
+  
   fIds->Reset(-1);
   fIndexes->Reset(-1);
   fPhi->Reset(-1);
   fEta->Reset(-1);
 }
 
+//___________________________________________________________________________________________________________
 AliEMCALFixedWindowClusterInfo::~AliEMCALFixedWindowClusterInfo()
 {
+  // Destructor
+
   delete fIds;
   delete fIndexes;
   delete fPhi;
   delete fEta;
 }
 
-Bool_t AliEMCALFixedWindowClusterInfo::GetInfoFromId(Int_t idclus, Int_t &index, Int_t &eta, Int_t &phi)
+//___________________________________________________________________________________________________________
+Bool_t AliEMCALFixedWindowClusterInfo::GetInfoFromId(Int_t idclus, Int_t &index, Int_t &eta, Int_t &phi) const
 {
+  // Search for the unique ID and return index, eta and phi
+  
   Int_t i = GetPositionFromId(idclus);
-  if (i > -1)
-  {
+  if (i > -1){
     index = fIndexes->At(i);
     eta = fEta->At(i);
     phi = fPhi->At(i);
@@ -84,11 +95,13 @@ Bool_t AliEMCALFixedWindowClusterInfo::GetInfoFromId(Int_t idclus, Int_t &index,
   return kFALSE;
 }
 
-Bool_t AliEMCALFixedWindowClusterInfo::GetInfoFromIndex(Int_t index, Int_t &idclus, Int_t &eta, Int_t &phi)
+//___________________________________________________________________________________________________________
+Bool_t AliEMCALFixedWindowClusterInfo::GetInfoFromIndex(Int_t index, Int_t &idclus, Int_t &eta, Int_t &phi) const
 {
+  // Search for the index and return unique ID, eta and phi
+  
   Int_t i = GetPositionFromIndex(index);
-  if (i > -1)
-  {
+  if (i > -1){
     idclus = fIds->At(i);
     eta = fEta->At(i);
     phi = fPhi->At(i);
@@ -97,34 +110,41 @@ Bool_t AliEMCALFixedWindowClusterInfo::GetInfoFromIndex(Int_t index, Int_t &idcl
   return kFALSE;
 }
 
+//___________________________________________________________________________________________________________
 Bool_t AliEMCALFixedWindowClusterInfo::SetIndexFromId(Int_t idclus, Int_t index)
 {
+  // Search for the unique ID and set index
+  
   Int_t i = GetPositionFromId(idclus);
-  if (i > -1)
-  {
+  if (i > -1){
     fIndexes->AddAt(index, i);
     return kTRUE;
   }
   return kFALSE;
 }
 
+//___________________________________________________________________________________________________________
 void AliEMCALFixedWindowClusterInfo::Add(Int_t idclus, Int_t index, Int_t eta, Int_t phi)
 {
-  if (lastElement >= fSize)
-    Expand(fSize * 2 + 1);
+  // Add a new element to the arrays; if necessary expand the arrays
+  
+  if (fLastPos >= fIds->GetSize())
+    Expand(fIds->GetSize() * 2 + 1);
   
-  fIds->AddAt(idclus, lastElement);
-  fIndexes->AddAt(index, lastElement);
-  fPhi->AddAt(phi, lastElement);
-  fEta->AddAt(eta, lastElement);
-  lastElement++;
+  fIds->AddAt(idclus, fLastPos);
+  fIndexes->AddAt(index, fLastPos);
+  fPhi->AddAt(phi, fLastPos);
+  fEta->AddAt(eta, fLastPos);
+  fLastPos++;
 }
 
+//___________________________________________________________________________________________________________
 Bool_t AliEMCALFixedWindowClusterInfo::RemoveId(Int_t idclus)
 {
+  // Search for the unique ID and remove the corresponding element from the arrays
+  
   Int_t i = GetPositionFromId(idclus);
-  if (i > -1)
-  {
+  if (i > -1){
     fIds->AddAt(-1, i);
     fIndexes->AddAt(-1, i);
     fPhi->AddAt(-1, i);
@@ -134,11 +154,13 @@ Bool_t AliEMCALFixedWindowClusterInfo::RemoveId(Int_t idclus)
   return kFALSE;
 }
 
+//___________________________________________________________________________________________________________
 Bool_t AliEMCALFixedWindowClusterInfo::RemoveIndex(Int_t index)
 {
+  // Search for and index and remove the corresponding element from the arrays
+  
   Int_t i = GetPositionFromIndex(index);
-  if (i > -1)
-  {
+  if (i > -1){
     fIds->AddAt(-1, i);
     fIndexes->AddAt(-1, i);
     fPhi->AddAt(-1, i);
@@ -148,75 +170,96 @@ Bool_t AliEMCALFixedWindowClusterInfo::RemoveIndex(Int_t index)
   return kFALSE;
 }
 
+//___________________________________________________________________________________________________________
 void AliEMCALFixedWindowClusterInfo::Expand(Int_t size)
 {
+  // Expand the arrays
+  
+  Int_t oldsize = fIds->GetSize();
+  
   fIds->Set(size);
   fIndexes->Set(size);
   fPhi->Set(size);
   fEta->Set(size);
   
-  for (Int_t i = fSize; i < size; i++)
-  {
+  for (Int_t i = oldsize; i < size; i++){
     fIds->AddAt(-1, i);
     fIndexes->AddAt(-1, i);
     fPhi->AddAt(-1, i);
     fEta->AddAt(-1, i);
   }
-  
-  fSize = size;
 }
 
+//___________________________________________________________________________________________________________
 void AliEMCALFixedWindowClusterInfo::Clear(Option_t* option)
 {
+  // Clear the arrays
+  
   fIds->Reset(-1);
   fIndexes->Reset(-1);
   fPhi->Reset(-1);
   fEta->Reset(-1);
-  lastElement = 0;
+  fLastPos = 0;
 }
 
-Int_t AliEMCALFixedWindowClusterInfo::GetSize()
+//___________________________________________________________________________________________________________
+Int_t AliEMCALFixedWindowClusterInfo::GetSize() const
 {
-  return fSize;
+  // Return the size of the arrays
+  
+  return fIds->GetSize();
 }
 
-Bool_t AliEMCALFixedWindowClusterInfo::ContainsId(Int_t idclus)
+//___________________________________________________________________________________________________________
+Bool_t AliEMCALFixedWindowClusterInfo::ContainsId(Int_t idclus) const
 {
+  // Search for the unique ID and return whether or not it exists
+  
   if(GetPositionFromId(idclus) > -1)
     return kTRUE;
   else
     return kFALSE;
 }
 
-Bool_t AliEMCALFixedWindowClusterInfo::ContainsIndex(Int_t index)
+//___________________________________________________________________________________________________________
+Bool_t AliEMCALFixedWindowClusterInfo::ContainsIndex(Int_t index) const
 {
+  // Search for the index and return whether or not it exists
+  
   if(GetPositionFromIndex(index) > -1)
     return kTRUE;
   else
     return kFALSE;
 }
 
-Int_t AliEMCALFixedWindowClusterInfo::GetPositionFromId(Int_t idclus)
+//___________________________________________________________________________________________________________
+Int_t AliEMCALFixedWindowClusterInfo::GetPositionFromId(Int_t idclus) const
 {
-  for (Int_t i = 0; i < lastElement; i++)
-  {
+  // Return the the position corresponding to a given unique ID
+  
+  for (Int_t i = 0; i < fLastPos; i++){
     if (fIds->At(i) == idclus)
       return i;
   }
   return -1;
 }
 
-Int_t AliEMCALFixedWindowClusterInfo::GetPositionFromIndex(Int_t index)
+//___________________________________________________________________________________________________________
+Int_t AliEMCALFixedWindowClusterInfo::GetPositionFromIndex(Int_t index) const
 {
-  for (Int_t i = 0; i < lastElement; i++)
-  {
+  // Return the the position corresponding to a given index
+  
+  for (Int_t i = 0; i < fLastPos; i++){
     if (fIndexes->At(i) == index)
       return i;
   }
   return -1;
 }
 
-Int_t AliEMCALFixedWindowClusterInfo::GetLastElementId()
+//___________________________________________________________________________________________________________
+Int_t AliEMCALFixedWindowClusterInfo::GetLastElementPosition() const
 {
-  return lastElement;
+  // Return the position of the last non-empty element in the arrays
+  
+  return fLastPos;
 }
index 80730b1..b2ab5f3 100644 (file)
@@ -15,32 +15,34 @@ public:
   AliEMCALFixedWindowClusterInfo(const TString& name, Int_t size = 1000);
   virtual ~AliEMCALFixedWindowClusterInfo();
   
-  Bool_t GetInfoFromId(Int_t idclus, Int_t &index, Int_t &eta, Int_t &phi);
-  Bool_t GetInfoFromIndex(Int_t index, Int_t &idclus, Int_t &eta, Int_t &phi);
-  
-  void Add(Int_t idclus, Int_t index, Int_t eta, Int_t phi);
-  Bool_t SetIndexFromId(Int_t idclus, Int_t index);
-  Bool_t RemoveId(Int_t idclus);
-  Bool_t RemoveIndex(Int_t index);
-  void Expand(Int_t size);
-  Int_t GetSize();
-  Bool_t ContainsId(Int_t idclus);
-  Bool_t ContainsIndex(Int_t index);
-  Int_t GetLastElementId();
+public:
+  Bool_t  GetInfoFromId(Int_t idclus, Int_t &index, Int_t &eta, Int_t &phi)     const;
+  Bool_t  GetInfoFromIndex(Int_t index, Int_t &idclus, Int_t &eta, Int_t &phi)  const;
+  Int_t   GetSize()                                                             const;
+  Bool_t  ContainsId(Int_t idclus)                                              const;
+  Bool_t  ContainsIndex(Int_t index)                                            const;
+  Int_t   GetLastElementPosition()                                              const;
+  void    Add(Int_t idclus, Int_t index, Int_t eta, Int_t phi);
+  Bool_t  SetIndexFromId(Int_t idclus, Int_t index);
+  Bool_t  RemoveId(Int_t idclus);
+  Bool_t  RemoveIndex(Int_t index);
+  void    Expand(Int_t size);
   
   virtual void Clear(Option_t* option = "");
   
 protected:
-  Int_t GetPositionFromId(Int_t idclus);
-  Int_t GetPositionFromIndex(Int_t index);
+  Int_t GetPositionFromId(Int_t idclus) const;
+  Int_t GetPositionFromIndex(Int_t index) const;
+  
+  Int_t     fLastPos;         // Last non-empty position in the arrays
+  TArrayI  *fIds;             // Array containing unique IDs of clusters
+  TArrayI  *fIndexes;         // Array containing corresponding indexes in the cluster collection (usually a TClonesObject)
+  TArrayI  *fPhi;             // Array containing corresponding Phi index
+  TArrayI  *fEta;             // Array containing corresponding Eta index
   
 private:
-  Int_t     fSize;
-  Int_t     lastElement;
-  TArrayI  *fIds;
-  TArrayI  *fIndexes;
-  TArrayI  *fPhi;
-  TArrayI  *fEta;
+  AliEMCALFixedWindowClusterInfo(const AliEMCALFixedWindowClusterInfo&);            // not implemented
+  AliEMCALFixedWindowClusterInfo &operator=(const AliEMCALFixedWindowClusterInfo&); // not implemented
   
   ClassDef(AliEMCALFixedWindowClusterInfo, 1);
 };