-// $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;
+
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff