end-of-line normalization
[u/mrichter/AliRoot.git] / HLT / CALO / AliHLTCaloClusterizer.cxx
index 1b67653..d904823 100644 (file)
-// $Id$\r
-\r
-/**************************************************************************\r
- * This file is property of and copyright by the ALICE HLT Project        *\r
- * All rights reserved.                                                   *\r
- *                                                                        *\r
- * Primary Authors: Oystein Djuvsland                                     *\r
- *                                                                        *\r
- * Permission to use, copy, modify and distribute this software and its   *\r
- * documentation strictly for non-commercial purposes is hereby granted   *\r
- * without fee, provided that the above copyright notice appears in all   *\r
- * copies and that both the copyright notice and this permission notice   *\r
- * appear in the supporting documentation. The authors make no claims     *\r
- * about the suitability of this software for any purpose. It is          *\r
- * provided "as is" without express or implied warranty.                  *\r
- **************************************************************************/\r
-\r
-/**\r
- * @file   AliHLTCaloClusterizer.cxx\r
- * @author Oystein Djuvsland\r
- * @date\r
- * @brief  Clusterizer for PHOS HLT\r
- */\r
-\r
-// see header file for class documentation\r
-// or\r
-// refer to README to build package\r
-// or\r
-// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt\r
-\r
-#include "AliHLTCaloClusterizer.h"\r
-#include "AliHLTLogging.h"\r
-#include "TMath.h"\r
-#include "AliHLTCaloRecPointDataStruct.h"\r
-#include "AliHLTCaloDigitDataStruct.h"\r
-#include "AliHLTCaloDigitContainerDataStruct.h"\r
-#include "AliHLTCaloConstantsHandler.h"\r
-\r
-ClassImp(AliHLTCaloClusterizer);\r
-\r
-AliHLTCaloClusterizer::AliHLTCaloClusterizer(TString det):\r
-        AliHLTCaloConstantsHandler(det),\r
-        fCompareFunction(CompareDigitsByPosition),\r
-        fRecPointArray(0),\r
-        fRecPointDataPtr(0),\r
-        fFirstRecPointPtr(0),\r
-        fArraySize(0),\r
-        fAvailableSize(0),\r
-        fUsedSize(0),\r
-        fNRecPoints(0),\r
-        fDigitIndexPtr(0),\r
-        fEmcClusteringThreshold(0),\r
-        fEmcMinEnergyThreshold(0),\r
-        fEmcTimeGate(0),\r
-        fDigitsInCluster(0),\r
-        fDigitsPointerArray(0),\r
-        fDigitContainerPtr(0),\r
-        fMaxDigitIndexDiff(0),\r
-        fNDigits(0),\r
-        fSortedByPosition(false),\r
-        fSortedByEnergy(false),\r
-        fSortDigits(false),\r
-        fIsEMCAL(false),\r
-       fBuffer(0)\r
-       \r
-{\r
-    //See header file for documentation\r
-    //fEmcClusteringThreshold = 0.2;\r
-    //fEmcMinEnergyThreshold = 0.03;\r
-\r
-    fEmcClusteringThreshold = 0.1;\r
-    fEmcMinEnergyThreshold = 0.01;\r
-    fEmcTimeGate = 1.e-6 ;\r
-\r
-    fMaxDigitIndexDiff = 2*fCaloConstants->GetNZROWSMOD();\r
-\r
-\r
-    fArraySize = 10;\r
-    fRecPointArray = new AliHLTCaloRecPointDataStruct*[fArraySize];\r
-\r
-    fAvailableSize = sizeof(AliHLTCaloRecPointDataStruct) * 20;\r
-    fBuffer = new UChar_t[fAvailableSize]; //FR\r
-    \r
-    fFirstRecPointPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(fBuffer);\r
-    fRecPointDataPtr = fFirstRecPointPtr;\r
-\r
-}//end\r
-\r
-AliHLTCaloClusterizer::~AliHLTCaloClusterizer()\r
-{\r
-    //See header file for documentation\r
-  delete [] fBuffer; //FR\r
-  fBuffer = NULL;    //FR\r
-  fAvailableSize = 0;  //FR\r
-\r
-  delete [] fRecPointArray;\r
-}\r
-\r
-void\r
-AliHLTCaloClusterizer::SetRecPointDataPtr(AliHLTCaloRecPointDataStruct* recPointDataPtr)\r
-{\r
-    // See header file for documentation\r
-    fRecPointDataPtr = recPointDataPtr;\r
-}\r
-\r
-Int_t\r
-AliHLTCaloClusterizer::ClusterizeEvent(Int_t nDigits)\r
-{\r
-    //see header file for documentation\r
-    Int_t nRecPoints = 0;\r
-    fNRecPoints = 0;\r
-    fUsedSize = 0;\r
-    fNDigits = nDigits;\r
-    fRecPointDataPtr = fFirstRecPointPtr;\r
-\r
-    // Sort our digits\r
-    SortDigits();\r
-\r
-    //Clusterization starts\r
-    for (Int_t i = 0; i < nDigits; i++)\r
-    {\r
-        fDigitsInCluster = 0;\r
-\r
-        HLTDebug("Digit with energy: %f", fDigitsPointerArray[i]->fEnergy);\r
-       \r
-        if (fDigitsPointerArray[i]->fEnergy < fEmcClusteringThreshold && fSortedByEnergy)\r
-        {\r
-          // Since we have sorted by energy the next digit will have even lower energy, so we return \r
-          return fNRecPoints;\r
-       }\r
-\r
-       if(fDigitsPointerArray[i]->fAssociatedCluster != -1)\r
-       {\r
-          // The digit is added to a previous cluster, continue\r
-          continue;\r
-       }\r
-\r
-       CheckArray();\r
-        CheckBuffer();\r
-\r
-        // First digit is placed at the fDigits member variable in the recpoint\r
-        fDigitIndexPtr = &(fRecPointDataPtr->fDigits);\r
-\r
-        fRecPointDataPtr->fAmp = 0;\r
-        fRecPointDataPtr->fModule = fDigitsPointerArray[i]->fModule;\r
-       \r
-        // Assigning the digit to this rec point\r
-        fRecPointDataPtr->fDigits = i;\r
-        fUsedSize += sizeof(AliHLTCaloRecPointDataStruct);\r
-\r
-        // Incrementing the pointer to be ready for new entry\r
-        fDigitIndexPtr++;\r
-\r
-        fRecPointDataPtr->fAmp += fDigitsPointerArray[i]->fEnergy;\r
-    \r
-       \r
-       //fDigitsPointerArray[i]->fEnergy = 0;\r
-        fDigitsPointerArray[i]->fAssociatedCluster = fNRecPoints;\r
-       \r
-       \r
-       fDigitsInCluster++;\r
-        nRecPoints++;\r
-\r
-        // Scanning for the neighbours\r
-        if (ScanForNeighbourDigits(i, fRecPointDataPtr) != 0)\r
-        {\r
-            return -1;\r
-        }\r
-\r
-        //fUsedSize += sizeof(AliHLTCaloRecPointDataStruct) + (fDigitsInCluster-1)*sizeof(AliHLTCaloDigitDataStruct);\r
-\r
-        fRecPointDataPtr->fMultiplicity = fDigitsInCluster;\r
-        fRecPointArray[fNRecPoints] = fRecPointDataPtr;\r
-\r
-        fRecPointDataPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(fDigitIndexPtr);\r
-\r
-        fNRecPoints++;\r
-\r
-    }//end of clusterization\r
-\r
-    return nRecPoints;\r
-}\r
-\r
-Int_t\r
-AliHLTCaloClusterizer::ScanForNeighbourDigits(Int_t index, AliHLTCaloRecPointDataStruct* recPoint)\r
-{\r
-    //see header file for documentation\r
-\r
-    // The following cuts can be used if we sort by posisiton. Not tested, but it should be fine...\r
-    Int_t max = TMath::Min(fNDigits, (Int_t)fMaxDigitIndexDiff+index);\r
-    Int_t min = TMath::Max(0, (Int_t)(index - (Int_t)fMaxDigitIndexDiff));\r
-\r
-    // All digits for now\r
-    max = fNDigits;\r
-    min = 0;\r
-\r
-    for (Int_t j = min; j < max; j++)\r
-    {\r
-        if (fDigitsPointerArray[j]->fAssociatedCluster == -1 &&  fDigitsPointerArray[j]->fEnergy > fEmcMinEnergyThreshold)\r
-        {\r
-            if (j != index)\r
-            {\r
-                if (AreNeighbours(fDigitsPointerArray[index],\r
-                                  fDigitsPointerArray[j]))\r
-                {\r
-                    // Check that the buffer is large enough for adding a digit (can be heavily improved wrt performance)\r
-                    CheckBuffer();\r
-\r
-                    // Assigning index to digit\r
-                    *fDigitIndexPtr = j;\r
-                    fUsedSize += sizeof(Int_t);\r
-\r
-                    // Incrementing digit pointer to be ready for new entry\r
-                    fDigitIndexPtr++;\r
-\r
-                    // Adding the digit energy to the rec point\r
-                    fRecPointDataPtr->fAmp += fDigitsPointerArray[j]->fEnergy;\r
-\r
-                    // Setting energy to 0\r
-                   //fDigitsPointerArray[j]->fEnergy = 0;\r
-                   \r
-                   // Setting the associated cluster \r
-                   fDigitsPointerArray[j]->fAssociatedCluster = fNRecPoints;\r
-                   \r
-                   HLTDebug("Added digit with index: %d, energy: %f, to associated cluster: %d", fDigitsPointerArray[j]->fID, fDigitsPointerArray[j]->fEnergy, fDigitsPointerArray[j]->fAssociatedCluster);\r
-                   \r
-                    fDigitsInCluster++;\r
-\r
-                    // Scan for neighbours of this digit\r
-                    ScanForNeighbourDigits(j, recPoint);\r
-                }\r
-            }\r
-        }\r
-    }\r
-    return 0;\r
-}\r
-\r
-Int_t\r
-AliHLTCaloClusterizer::AreNeighbours(AliHLTCaloDigitDataStruct* digit1,\r
-                                     AliHLTCaloDigitDataStruct* digit2)\r
-{\r
-    //see header file for documentation\r
-    if ( (digit1->fModule == digit2->fModule) || AreEdgeCells(digit1, digit2))\r
-    {\r
-        Int_t rowdiff = TMath::Abs( digit1->fZ - digit2->fZ );\r
-        Int_t coldiff = TMath::Abs( digit1->fX - digit2->fX );\r
-\r
-       // Common edge defines neighbour\r
-        //if (( coldiff <= 1   &&  rowdiff == 0 ) || ( coldiff == 0 &&  rowdiff <= 1 ))\r
-         // Common edge and corner defines neighbour\r
-       if (( coldiff <= 1   &&  rowdiff <= 1 ))\r
-        {\r
-            // Check also for time\r
-            if (TMath::Abs(digit1->fTime - digit2->fTime ) < fEmcTimeGate)\r
-            {\r
-                return 1;\r
-            }\r
-        }\r
-    }\r
-    return 0;\r
-}\r
-\r
-\r
-\r
-Int_t AliHLTCaloClusterizer::CheckArray()\r
-{\r
-    // See header file for class documentation\r
-    if (fArraySize == fNRecPoints)\r
-    {\r
-        fArraySize *= 2;\r
-        AliHLTCaloRecPointDataStruct **tmp = new AliHLTCaloRecPointDataStruct*[fArraySize];\r
-        memcpy(tmp, fRecPointArray, fArraySize/2 * sizeof(AliHLTCaloRecPointDataStruct*));\r
-        delete [] fRecPointArray;\r
-        fRecPointArray = tmp;\r
-    }\r
-    return 0;\r
-}\r
-\r
-Int_t AliHLTCaloClusterizer::CheckBuffer()\r
-{\r
-    // See header file for class documentation\r
-    if ((fAvailableSize - fUsedSize) < (Int_t)sizeof(AliHLTCaloRecPointDataStruct))\r
-    {\r
-        Int_t recPointOffset = reinterpret_cast<UChar_t*>(fRecPointDataPtr) - reinterpret_cast<UChar_t*>(fFirstRecPointPtr);\r
-        Int_t digitIndexOffset = reinterpret_cast<UChar_t*>(fDigitIndexPtr) - reinterpret_cast<UChar_t*>(fRecPointDataPtr);\r
-        UChar_t *tmp = new UChar_t[fAvailableSize*2];\r
-       \r
-       if (tmp == NULL)\r
-         {\r
-           HLTError("Pointer error");\r
-           return(-1);\r
-         }\r
-       \r
-        memcpy(tmp, fFirstRecPointPtr, fUsedSize);\r
-        fAvailableSize *= 2;\r
-        for (Int_t n = 0; n < fNRecPoints; n++)\r
-        {\r
-            fRecPointArray[n] = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(reinterpret_cast<UChar_t*>(fRecPointArray[n]) - reinterpret_cast<UChar_t*>(fFirstRecPointPtr) + reinterpret_cast<UChar_t*>(tmp));\r
-        }\r
-       delete [] fBuffer; //FR\r
-        fBuffer = tmp; //FR\r
-       \r
-        fFirstRecPointPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(tmp);\r
-        fRecPointDataPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(tmp + recPointOffset);\r
-        fDigitIndexPtr = reinterpret_cast<Int_t*>(reinterpret_cast<UChar_t*>(fRecPointDataPtr) + digitIndexOffset);\r
-        //fUsedSize = 0;\r
-    }\r
-    return 0;\r
-}\r
-\r
-void AliHLTCaloClusterizer::SetSortDigitsByPosition()\r
-{\r
-    // Sort the digit pointers by position\r
-    fCompareFunction = &CompareDigitsByPosition;\r
-    fSortDigits = true;\r
-    fSortedByPosition = true;\r
-}\r
-\r
-void AliHLTCaloClusterizer::SetSortDigitsByEnergy()\r
-{\r
-    // See header file for class documentation\r
-    fCompareFunction = &CompareDigitsByEnergy;\r
-    fSortDigits = true;\r
-    fSortedByEnergy = true;\r
-}\r
-\r
-void AliHLTCaloClusterizer::SortDigits()\r
-{\r
-    // See header file for class documentation\r
-    if (fSortDigits) qsort(fDigitsPointerArray, fNDigits, sizeof(AliHLTCaloDigitDataStruct*), fCompareFunction);\r
-}\r
-\r
-Int_t\r
-AliHLTCaloClusterizer::CompareDigitsByPosition(const void *dig0, const void *dig1)\r
-{\r
-    // See header file for documentation\r
-    return (*((AliHLTCaloDigitDataStruct**)(dig0)))->fID - (*((AliHLTCaloDigitDataStruct**)(dig1)))->fID;\r
-}\r
-\r
-Int_t\r
-AliHLTCaloClusterizer::CompareDigitsByEnergy(const void *dig0, const void *dig1)\r
-{\r
-    // See header file for documentation\r
-  if ( ((*((AliHLTCaloDigitDataStruct**)(dig1)))->fEnergy - (*((AliHLTCaloDigitDataStruct**)(dig0)))->fEnergy) < 0) return -1;\r
-  return 1;\r
-}\r
-\r
-void AliHLTCaloClusterizer::SetDetector(TString det)\r
-{\r
-  if(det.CompareTo("EMCAL"))\r
-  {\r
-    fIsEMCAL = true;\r
-  }\r
-  else\r
-  {\r
-    fIsEMCAL = false;\r
-  }\r
-}\r
-\r
-Bool_t AliHLTCaloClusterizer::AreEdgeCells(AliHLTCaloDigitDataStruct *digit0, AliHLTCaloDigitDataStruct *digit1)\r
-{\r
-  if(fIsEMCAL)\r
-  {\r
-    Int_t modDiff = digit0->fModule - digit1->fModule;\r
-    if(TMath::Abs(modDiff) > 1) return kFALSE;\r
-    if(digit0->fModule > digit1->fModule && digit1->fModule%2 == 0) \r
-    {\r
-      if(digit0->fZ == 0 && digit1->fZ == (fCaloConstants->GetNZROWSMOD()-1))\r
-      return kTRUE;\r
-    }\r
-    if(digit1->fModule > digit0->fModule && digit0->fModule%2 == 0) \r
-    {\r
-      if(digit1->fZ == 0 && digit0->fZ == (fCaloConstants->GetNZROWSMOD()-1))\r
-      return kTRUE;\r
-    }\r
-  }\r
-  \r
-  return false;\r
-\r
-}\r
+// $Id$
+
+/**************************************************************************
+ * This file is property of and copyright by the ALICE HLT Project        *
+ * All rights reserved.                                                   *
+ *                                                                        *
+ * Primary Authors: Oystein Djuvsland                                     *
+ *                                                                        *
+ * 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.                  *
+ **************************************************************************/
+
+/**
+ * @file   AliHLTCaloClusterizer.cxx
+ * @author Oystein Djuvsland
+ * @date
+ * @brief  Clusterizer for PHOS HLT
+ */
+
+// see header file for class documentation
+// or
+// refer to README to build package
+// or
+// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
+
+#include "AliHLTCaloClusterizer.h"
+#include "AliHLTLogging.h"
+#include "TMath.h"
+#include "AliHLTCaloRecPointDataStruct.h"
+#include "AliHLTCaloDigitDataStruct.h"
+#include "AliHLTCaloDigitContainerDataStruct.h"
+#include "AliHLTCaloConstantsHandler.h"
+
+ClassImp(AliHLTCaloClusterizer);
+
+AliHLTCaloClusterizer::AliHLTCaloClusterizer(TString det):
+        AliHLTCaloConstantsHandler(det),
+        fCompareFunction(CompareDigitsByPosition),
+        fRecPointArray(0),
+        fRecPointDataPtr(0),
+        fFirstRecPointPtr(0),
+        fArraySize(0),
+        fAvailableSize(0),
+        fUsedSize(0),
+        fNRecPoints(0),
+        fDigitIndexPtr(0),
+        fEmcClusteringThreshold(0),
+        fEmcMinEnergyThreshold(0),
+        fEmcTimeGate(0),
+        fDigitsInCluster(0),
+        fDigitsPointerArray(0),
+        fDigitContainerPtr(0),
+        fMaxDigitIndexDiff(0),
+        fNDigits(0),
+        fSortedByPosition(false),
+        fSortedByEnergy(false),
+        fSortDigits(false),
+        fIsEMCAL(false),
+       fBuffer(0)
+       
+{
+    //See header file for documentation
+    //fEmcClusteringThreshold = 0.2;
+    //fEmcMinEnergyThreshold = 0.03;
+
+    fEmcClusteringThreshold = 0.1;
+    fEmcMinEnergyThreshold = 0.01;
+    fEmcTimeGate = 1.e-6 ;
+
+    fMaxDigitIndexDiff = 2*fCaloConstants->GetNZROWSMOD();
+
+
+    fArraySize = 10;
+    fRecPointArray = new AliHLTCaloRecPointDataStruct*[fArraySize];
+
+    fAvailableSize = sizeof(AliHLTCaloRecPointDataStruct) * 20;
+    fBuffer = new UChar_t[fAvailableSize]; //FR
+    
+    fFirstRecPointPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(fBuffer);
+    fRecPointDataPtr = fFirstRecPointPtr;
+
+}//end
+
+AliHLTCaloClusterizer::~AliHLTCaloClusterizer()
+{
+    //See header file for documentation
+  delete [] fBuffer; //FR
+  fBuffer = NULL;    //FR
+  fAvailableSize = 0;  //FR
+
+  delete [] fRecPointArray;
+}
+
+void
+AliHLTCaloClusterizer::SetRecPointDataPtr(AliHLTCaloRecPointDataStruct* recPointDataPtr)
+{
+    // See header file for documentation
+    fRecPointDataPtr = recPointDataPtr;
+}
+
+Int_t
+AliHLTCaloClusterizer::ClusterizeEvent(Int_t nDigits)
+{
+    //see header file for documentation
+    Int_t nRecPoints = 0;
+    fNRecPoints = 0;
+    fUsedSize = 0;
+    fNDigits = nDigits;
+    fRecPointDataPtr = fFirstRecPointPtr;
+
+    // Sort our digits
+    SortDigits();
+
+    //Clusterization starts
+    for (Int_t i = 0; i < nDigits; i++)
+    {
+        fDigitsInCluster = 0;
+
+        HLTDebug("Digit with energy: %f", fDigitsPointerArray[i]->fEnergy);
+       
+        if (fDigitsPointerArray[i]->fEnergy < fEmcClusteringThreshold && fSortedByEnergy)
+        {
+          // Since we have sorted by energy the next digit will have even lower energy, so we return 
+          return fNRecPoints;
+       }
+
+       if(fDigitsPointerArray[i]->fAssociatedCluster != -1)
+       {
+          // The digit is added to a previous cluster, continue
+          continue;
+       }
+
+       CheckArray();
+        CheckBuffer();
+
+        // First digit is placed at the fDigits member variable in the recpoint
+        fDigitIndexPtr = &(fRecPointDataPtr->fDigits);
+
+        fRecPointDataPtr->fAmp = 0;
+        fRecPointDataPtr->fModule = fDigitsPointerArray[i]->fModule;
+       
+        // Assigning the digit to this rec point
+        fRecPointDataPtr->fDigits = i;
+        fUsedSize += sizeof(AliHLTCaloRecPointDataStruct);
+
+        // Incrementing the pointer to be ready for new entry
+        fDigitIndexPtr++;
+
+        fRecPointDataPtr->fAmp += fDigitsPointerArray[i]->fEnergy;
+    
+       
+       //fDigitsPointerArray[i]->fEnergy = 0;
+        fDigitsPointerArray[i]->fAssociatedCluster = fNRecPoints;
+       
+       
+       fDigitsInCluster++;
+        nRecPoints++;
+
+        // Scanning for the neighbours
+        if (ScanForNeighbourDigits(i, fRecPointDataPtr) != 0)
+        {
+            return -1;
+        }
+
+        //fUsedSize += sizeof(AliHLTCaloRecPointDataStruct) + (fDigitsInCluster-1)*sizeof(AliHLTCaloDigitDataStruct);
+
+        fRecPointDataPtr->fMultiplicity = fDigitsInCluster;
+        fRecPointArray[fNRecPoints] = fRecPointDataPtr;
+
+        fRecPointDataPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(fDigitIndexPtr);
+
+        fNRecPoints++;
+
+    }//end of clusterization
+
+    return nRecPoints;
+}
+
+Int_t
+AliHLTCaloClusterizer::ScanForNeighbourDigits(Int_t index, AliHLTCaloRecPointDataStruct* recPoint)
+{
+    //see header file for documentation
+
+    // The following cuts can be used if we sort by posisiton. Not tested, but it should be fine...
+    Int_t max = TMath::Min(fNDigits, (Int_t)fMaxDigitIndexDiff+index);
+    Int_t min = TMath::Max(0, (Int_t)(index - (Int_t)fMaxDigitIndexDiff));
+
+    // All digits for now
+    max = fNDigits;
+    min = 0;
+
+    for (Int_t j = min; j < max; j++)
+    {
+        if (fDigitsPointerArray[j]->fAssociatedCluster == -1 &&  fDigitsPointerArray[j]->fEnergy > fEmcMinEnergyThreshold)
+        {
+            if (j != index)
+            {
+                if (AreNeighbours(fDigitsPointerArray[index],
+                                  fDigitsPointerArray[j]))
+                {
+                    // Check that the buffer is large enough for adding a digit (can be heavily improved wrt performance)
+                    CheckBuffer();
+
+                    // Assigning index to digit
+                    *fDigitIndexPtr = j;
+                    fUsedSize += sizeof(Int_t);
+
+                    // Incrementing digit pointer to be ready for new entry
+                    fDigitIndexPtr++;
+
+                    // Adding the digit energy to the rec point
+                    fRecPointDataPtr->fAmp += fDigitsPointerArray[j]->fEnergy;
+
+                    // Setting energy to 0
+                   //fDigitsPointerArray[j]->fEnergy = 0;
+                   
+                   // Setting the associated cluster 
+                   fDigitsPointerArray[j]->fAssociatedCluster = fNRecPoints;
+                   
+                   HLTDebug("Added digit with index: %d, energy: %f, to associated cluster: %d", fDigitsPointerArray[j]->fID, fDigitsPointerArray[j]->fEnergy, fDigitsPointerArray[j]->fAssociatedCluster);
+                   
+                    fDigitsInCluster++;
+
+                    // Scan for neighbours of this digit
+                    ScanForNeighbourDigits(j, recPoint);
+                }
+            }
+        }
+    }
+    return 0;
+}
+
+Int_t
+AliHLTCaloClusterizer::AreNeighbours(AliHLTCaloDigitDataStruct* digit1,
+                                     AliHLTCaloDigitDataStruct* digit2)
+{
+    //see header file for documentation
+    if ( (digit1->fModule == digit2->fModule) || AreEdgeCells(digit1, digit2))
+    {
+        Int_t rowdiff = TMath::Abs( digit1->fZ - digit2->fZ );
+        Int_t coldiff = TMath::Abs( digit1->fX - digit2->fX );
+
+       // Common edge defines neighbour
+        //if (( coldiff <= 1   &&  rowdiff == 0 ) || ( coldiff == 0 &&  rowdiff <= 1 ))
+         // Common edge and corner defines neighbour
+       if (( coldiff <= 1   &&  rowdiff <= 1 ))
+        {
+            // Check also for time
+            if (TMath::Abs(digit1->fTime - digit2->fTime ) < fEmcTimeGate)
+            {
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+
+
+
+Int_t AliHLTCaloClusterizer::CheckArray()
+{
+    // See header file for class documentation
+    if (fArraySize == fNRecPoints)
+    {
+        fArraySize *= 2;
+        AliHLTCaloRecPointDataStruct **tmp = new AliHLTCaloRecPointDataStruct*[fArraySize];
+        memcpy(tmp, fRecPointArray, fArraySize/2 * sizeof(AliHLTCaloRecPointDataStruct*));
+        delete [] fRecPointArray;
+        fRecPointArray = tmp;
+    }
+    return 0;
+}
+
+Int_t AliHLTCaloClusterizer::CheckBuffer()
+{
+    // See header file for class documentation
+    if ((fAvailableSize - fUsedSize) < (Int_t)sizeof(AliHLTCaloRecPointDataStruct))
+    {
+        Int_t recPointOffset = reinterpret_cast<UChar_t*>(fRecPointDataPtr) - reinterpret_cast<UChar_t*>(fFirstRecPointPtr);
+        Int_t digitIndexOffset = reinterpret_cast<UChar_t*>(fDigitIndexPtr) - reinterpret_cast<UChar_t*>(fRecPointDataPtr);
+        UChar_t *tmp = new UChar_t[fAvailableSize*2];
+       
+       if (tmp == NULL)
+         {
+           HLTError("Pointer error");
+           return(-1);
+         }
+       
+        memcpy(tmp, fFirstRecPointPtr, fUsedSize);
+        fAvailableSize *= 2;
+        for (Int_t n = 0; n < fNRecPoints; n++)
+        {
+            fRecPointArray[n] = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(reinterpret_cast<UChar_t*>(fRecPointArray[n]) - reinterpret_cast<UChar_t*>(fFirstRecPointPtr) + reinterpret_cast<UChar_t*>(tmp));
+        }
+       delete [] fBuffer; //FR
+        fBuffer = tmp; //FR
+       
+        fFirstRecPointPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(tmp);
+        fRecPointDataPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(tmp + recPointOffset);
+        fDigitIndexPtr = reinterpret_cast<Int_t*>(reinterpret_cast<UChar_t*>(fRecPointDataPtr) + digitIndexOffset);
+        //fUsedSize = 0;
+    }
+    return 0;
+}
+
+void AliHLTCaloClusterizer::SetSortDigitsByPosition()
+{
+    // Sort the digit pointers by position
+    fCompareFunction = &CompareDigitsByPosition;
+    fSortDigits = true;
+    fSortedByPosition = true;
+}
+
+void AliHLTCaloClusterizer::SetSortDigitsByEnergy()
+{
+    // See header file for class documentation
+    fCompareFunction = &CompareDigitsByEnergy;
+    fSortDigits = true;
+    fSortedByEnergy = true;
+}
+
+void AliHLTCaloClusterizer::SortDigits()
+{
+    // See header file for class documentation
+    if (fSortDigits) qsort(fDigitsPointerArray, fNDigits, sizeof(AliHLTCaloDigitDataStruct*), fCompareFunction);
+}
+
+Int_t
+AliHLTCaloClusterizer::CompareDigitsByPosition(const void *dig0, const void *dig1)
+{
+    // See header file for documentation
+    return (*((AliHLTCaloDigitDataStruct**)(dig0)))->fID - (*((AliHLTCaloDigitDataStruct**)(dig1)))->fID;
+}
+
+Int_t
+AliHLTCaloClusterizer::CompareDigitsByEnergy(const void *dig0, const void *dig1)
+{
+    // See header file for documentation
+  if ( ((*((AliHLTCaloDigitDataStruct**)(dig1)))->fEnergy - (*((AliHLTCaloDigitDataStruct**)(dig0)))->fEnergy) < 0) return -1;
+  return 1;
+}
+
+void AliHLTCaloClusterizer::SetDetector(TString det)
+{
+  if(det.CompareTo("EMCAL"))
+  {
+    fIsEMCAL = true;
+  }
+  else
+  {
+    fIsEMCAL = false;
+  }
+}
+
+Bool_t AliHLTCaloClusterizer::AreEdgeCells(AliHLTCaloDigitDataStruct *digit0, AliHLTCaloDigitDataStruct *digit1)
+{
+  if(fIsEMCAL)
+  {
+    Int_t modDiff = digit0->fModule - digit1->fModule;
+    if(TMath::Abs(modDiff) > 1) return kFALSE;
+    if(digit0->fModule > digit1->fModule && digit1->fModule%2 == 0) 
+    {
+      if(digit0->fZ == 0 && digit1->fZ == (fCaloConstants->GetNZROWSMOD()-1))
+      return kTRUE;
+    }
+    if(digit1->fModule > digit0->fModule && digit0->fModule%2 == 0) 
+    {
+      if(digit1->fZ == 0 && digit0->fZ == (fCaloConstants->GetNZROWSMOD()-1))
+      return kTRUE;
+    }
+  }
+  
+  return false;
+
+}