adding new classes to build
[u/mrichter/AliRoot.git] / HLT / CALO / AliHLTCaloClusterizer.cxx
CommitLineData
ef44ec64 1// $Id$\r
2\r
3/**************************************************************************\r
31b89da4 4 * This file is property of and copyright by the ALICE HLT Project *\r
ef44ec64 5 * All rights reserved. *\r
6 * *\r
7 * Primary Authors: Oystein Djuvsland *\r
8 * *\r
9 * Permission to use, copy, modify and distribute this software and its *\r
10 * documentation strictly for non-commercial purposes is hereby granted *\r
11 * without fee, provided that the above copyright notice appears in all *\r
12 * copies and that both the copyright notice and this permission notice *\r
13 * appear in the supporting documentation. The authors make no claims *\r
31b89da4 14 * about the suitability of this software for any purpose. It is *\r
ef44ec64 15 * provided "as is" without express or implied warranty. *\r
16 **************************************************************************/\r
17\r
31b89da4 18/**\r
ef44ec64 19 * @file AliHLTCaloClusterizer.cxx\r
20 * @author Oystein Djuvsland\r
31b89da4 21 * @date\r
22 * @brief Clusterizer for PHOS HLT\r
ef44ec64 23 */\r
24\r
25// see header file for class documentation\r
26// or\r
27// refer to README to build package\r
28// or\r
29// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt\r
30\r
31#include "AliHLTCaloClusterizer.h"\r
ef44ec64 32#include "AliHLTLogging.h"\r
33#include "TMath.h"\r
ef44ec64 34#include "AliHLTCaloRecPointDataStruct.h"\r
35#include "AliHLTCaloDigitDataStruct.h"\r
36#include "AliHLTCaloDigitContainerDataStruct.h"\r
4f4b7ba4 37#include "AliHLTCaloConstantsHandler.h"\r
ef44ec64 38\r
39ClassImp(AliHLTCaloClusterizer);\r
40\r
41AliHLTCaloClusterizer::AliHLTCaloClusterizer(TString det):\r
31b89da4 42 AliHLTCaloConstantsHandler(det),\r
43 fCompareFunction(CompareDigitsByPosition),\r
44 fRecPointArray(0),\r
45 fRecPointDataPtr(0),\r
46 fFirstRecPointPtr(0),\r
47 fArraySize(0),\r
48 fAvailableSize(0),\r
49 fUsedSize(0),\r
50 fNRecPoints(0),\r
51 fDigitIndexPtr(0),\r
52 fEmcClusteringThreshold(0),\r
53 fEmcMinEnergyThreshold(0),\r
54 fEmcTimeGate(0),\r
55 fDigitsInCluster(0),\r
56 fDigitsPointerArray(0),\r
57 fDigitContainerPtr(0),\r
58 fMaxDigitIndexDiff(0),\r
59 fNDigits(0),\r
60 fSortedByPosition(false),\r
61 fSortedByEnergy(false),\r
7cc065a2 62 fSortDigits(false),\r
63 fBuffer(0)\r
ef44ec64 64{\r
31b89da4 65 //See header file for documentation\r
66 //fEmcClusteringThreshold = 0.2;\r
67 //fEmcMinEnergyThreshold = 0.03;\r
68\r
69 fEmcClusteringThreshold = 0.1;\r
70 fEmcMinEnergyThreshold = 0.01;\r
71 fEmcTimeGate = 1.e-6 ;\r
72\r
73 fMaxDigitIndexDiff = 2*fCaloConstants->GetNZROWSMOD();\r
74\r
75\r
76 fArraySize = 10;\r
77 fRecPointArray = new AliHLTCaloRecPointDataStruct*[fArraySize];\r
78\r
79 fAvailableSize = sizeof(AliHLTCaloRecPointDataStruct) * 20;\r
7cc065a2 80 fBuffer = new UChar_t[fAvailableSize]; //FR\r
81\r
82 // fFirstRecPointPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(new UChar_t[fAvailableSize]);\r
83 fFirstRecPointPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(fBuffer);\r
31b89da4 84 fRecPointDataPtr = fFirstRecPointPtr;\r
c375e15d 85\r
c375e15d 86}//end\r
87\r
31b89da4 88AliHLTCaloClusterizer::~AliHLTCaloClusterizer()\r
ef44ec64 89{\r
31b89da4 90 //See header file for documentation\r
7cc065a2 91 delete [] fBuffer;\r
92 //delete [] fRecPointDataPtr;\r
9991396c 93 delete [] fRecPointArray;\r
ef44ec64 94}\r
95\r
31b89da4 96void\r
ef44ec64 97AliHLTCaloClusterizer::SetRecPointDataPtr(AliHLTCaloRecPointDataStruct* recPointDataPtr)\r
98{\r
31b89da4 99 // See header file for documentation\r
100 fRecPointDataPtr = recPointDataPtr;\r
ef44ec64 101}\r
102\r
31b89da4 103Int_t\r
7c80a370 104AliHLTCaloClusterizer::ClusterizeEvent(Int_t nDigits)\r
ef44ec64 105{\r
31b89da4 106 //see header file for documentation\r
107 Int_t nRecPoints = 0;\r
108 fNRecPoints = 0;\r
109 fUsedSize = 0;\r
110 fNDigits = nDigits;\r
111 fRecPointDataPtr = fFirstRecPointPtr;\r
112\r
113 // Sort our digits\r
114 SortDigits();\r
115\r
116 //Clusterization starts\r
117 for (Int_t i = 0; i < nDigits; i++)\r
118 {\r
119 fDigitsInCluster = 0;\r
120\r
f92543f5 121 HLTDebug("Digit with energy: %f", fDigitsPointerArray[i]->fEnergy);\r
122 \r
123 if (fDigitsPointerArray[i]->fEnergy < fEmcClusteringThreshold && fSortedByEnergy)\r
31b89da4 124 {\r
f92543f5 125 // Since we have sorted by energy the next digit will have even lower energy, so we return \r
126 return fNRecPoints;\r
127 }\r
128\r
129 if(fDigitsPointerArray[i]->fAssociatedCluster != -1)\r
130 {\r
131 // The digit is added to a previous cluster, continue\r
132 continue;\r
133 }\r
31b89da4 134\r
f92543f5 135 CheckArray();\r
31b89da4 136 CheckBuffer();\r
137\r
138 // First digit is placed at the fDigits member variable in the recpoint\r
139 fDigitIndexPtr = &(fRecPointDataPtr->fDigits);\r
140\r
141 fRecPointDataPtr->fAmp = 0;\r
142 fRecPointDataPtr->fModule = fDigitsPointerArray[i]->fModule;\r
143\r
144 // Assigning the digit to this rec point\r
145 fRecPointDataPtr->fDigits = i;\r
146 fUsedSize += sizeof(AliHLTCaloRecPointDataStruct);\r
147\r
148 // Incrementing the pointer to be ready for new entry\r
149 fDigitIndexPtr++;\r
150\r
151 fRecPointDataPtr->fAmp += fDigitsPointerArray[i]->fEnergy;\r
f92543f5 152 \r
153 \r
154 //fDigitsPointerArray[i]->fEnergy = 0;\r
155 fDigitsPointerArray[i]->fAssociatedCluster = fNRecPoints;\r
156 \r
157 \r
158 fDigitsInCluster++;\r
31b89da4 159 nRecPoints++;\r
160\r
161 // Scanning for the neighbours\r
162 if (ScanForNeighbourDigits(i, fRecPointDataPtr) != 0)\r
163 {\r
164 return -1;\r
165 }\r
166\r
167 //fUsedSize += sizeof(AliHLTCaloRecPointDataStruct) + (fDigitsInCluster-1)*sizeof(AliHLTCaloDigitDataStruct);\r
168\r
169 fRecPointDataPtr->fMultiplicity = fDigitsInCluster;\r
170 fRecPointArray[fNRecPoints] = fRecPointDataPtr;\r
171\r
172 fRecPointDataPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(fDigitIndexPtr);\r
173\r
174 fNRecPoints++;\r
175\r
ef44ec64 176 }//end of clusterization\r
70c86cde 177\r
178 return nRecPoints;\r
ef44ec64 179}\r
180\r
9bd6f29b 181Int_t\r
ef44ec64 182AliHLTCaloClusterizer::ScanForNeighbourDigits(Int_t index, AliHLTCaloRecPointDataStruct* recPoint)\r
183{\r
31b89da4 184 //see header file for documentation\r
ef44ec64 185\r
31b89da4 186 // The following cuts can be used if we sort by posisiton. Not tested, but it should be fine...\r
187 Int_t max = TMath::Min(fNDigits, (Int_t)fMaxDigitIndexDiff+index);\r
188 Int_t min = TMath::Max(0, (Int_t)(index - (Int_t)fMaxDigitIndexDiff));\r
189\r
190 // All digits for now\r
191 max = fNDigits;\r
192 min = 0;\r
193\r
194 for (Int_t j = min; j < max; j++)\r
ef44ec64 195 {\r
f92543f5 196 if (fDigitsPointerArray[j]->fAssociatedCluster == -1 && fDigitsPointerArray[j]->fEnergy > fEmcMinEnergyThreshold)\r
31b89da4 197 {\r
198 if (j != index)\r
199 {\r
200 if (AreNeighbours(fDigitsPointerArray[index],\r
201 fDigitsPointerArray[j]))\r
202 {\r
203 // Check that the buffer is large enough for adding a digit (can be heavily improved wrt performance)\r
204 CheckBuffer();\r
205\r
206 // Assigning index to digit\r
207 *fDigitIndexPtr = j;\r
208 fUsedSize += sizeof(Int_t);\r
209\r
210 // Incrementing digit pointer to be ready for new entry\r
211 fDigitIndexPtr++;\r
212\r
213 // Adding the digit energy to the rec point\r
214 fRecPointDataPtr->fAmp += fDigitsPointerArray[j]->fEnergy;\r
215\r
f92543f5 216 // Setting energy to 0\r
217 //fDigitsPointerArray[j]->fEnergy = 0;\r
218 \r
219 // Setting the associated cluster \r
220 fDigitsPointerArray[j]->fAssociatedCluster = fNRecPoints;\r
221 \r
222 HLTDebug("Added digit with index: %d, energy: %f, to associated cluster: %d", fDigitsPointerArray[j]->fID, fDigitsPointerArray[j]->fEnergy, fDigitsPointerArray[j]->fAssociatedCluster);\r
223 \r
31b89da4 224 fDigitsInCluster++;\r
225\r
226 // Scan for neighbours of this digit\r
227 ScanForNeighbourDigits(j, recPoint);\r
228 }\r
229 }\r
230 }\r
ef44ec64 231 }\r
31b89da4 232 return 0;\r
ef44ec64 233}\r
234\r
31b89da4 235Int_t\r
236AliHLTCaloClusterizer::AreNeighbours(AliHLTCaloDigitDataStruct* digit1,\r
237 AliHLTCaloDigitDataStruct* digit2)\r
ef44ec64 238{\r
31b89da4 239 //see header file for documentation\r
240 if ( (digit1->fModule == digit2->fModule) /*&& (coord1[1]==coord2[1])*/ ) // inside the same PHOS module\r
241 {\r
242 Int_t rowdiff = TMath::Abs( digit1->fZ - digit2->fZ );\r
243 Int_t coldiff = TMath::Abs( digit1->fX - digit2->fX );\r
244\r
245 // As in the offline code we define neighbours as cells that share an edge, a corner is not enough\r
c5688f76 246 // if (( coldiff <= 1 && rowdiff == 0 ) || ( coldiff == 0 && rowdiff <= 1 ))\r
247 if (( coldiff <= 1) || ( rowdiff <= 1 ))\r
31b89da4 248 {\r
249 // Check also for time\r
250 if (TMath::Abs(digit1->fTime - digit2->fTime ) < fEmcTimeGate)\r
251 {\r
252 return 1;\r
253 }\r
254 }\r
ef44ec64 255 }\r
31b89da4 256 return 0;\r
ef44ec64 257}\r
7c80a370 258\r
259\r
260\r
261Int_t AliHLTCaloClusterizer::CheckArray()\r
262{\r
31b89da4 263 // See header file for class documentation\r
264 if (fArraySize == fNRecPoints)\r
265 {\r
266 fArraySize *= 2;\r
267 AliHLTCaloRecPointDataStruct **tmp = new AliHLTCaloRecPointDataStruct*[fArraySize];\r
268 memcpy(tmp, fRecPointArray, fArraySize/2 * sizeof(AliHLTCaloRecPointDataStruct*));\r
269 delete [] fRecPointArray;\r
270 fRecPointArray = tmp;\r
271 }\r
272 return 0;\r
7c80a370 273}\r
274\r
275Int_t AliHLTCaloClusterizer::CheckBuffer()\r
276{\r
31b89da4 277 // See header file for class documentation\r
278 if ((fAvailableSize - fUsedSize) < (Int_t)sizeof(AliHLTCaloRecPointDataStruct))\r
279 {\r
280 Int_t recPointOffset = reinterpret_cast<UChar_t*>(fRecPointDataPtr) - reinterpret_cast<UChar_t*>(fFirstRecPointPtr);\r
281 Int_t digitIndexOffset = reinterpret_cast<UChar_t*>(fDigitIndexPtr) - reinterpret_cast<UChar_t*>(fRecPointDataPtr);\r
282 UChar_t *tmp = new UChar_t[fAvailableSize*2];\r
283\r
284 memcpy(tmp, fFirstRecPointPtr, fUsedSize);\r
285 fAvailableSize *= 2;\r
286 for (Int_t n = 0; n < fNRecPoints; n++)\r
287 {\r
288 fRecPointArray[n] = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(reinterpret_cast<UChar_t*>(fRecPointArray[n]) - reinterpret_cast<UChar_t*>(fFirstRecPointPtr) + reinterpret_cast<UChar_t*>(tmp));\r
289 }\r
290 delete [] fFirstRecPointPtr;\r
291 fFirstRecPointPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(tmp);\r
292 fRecPointDataPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(tmp + recPointOffset);\r
293 fDigitIndexPtr = reinterpret_cast<Int_t*>(reinterpret_cast<UChar_t*>(fRecPointDataPtr) + digitIndexOffset);\r
294 //fUsedSize = 0;\r
295 }\r
296 return 0;\r
7c80a370 297}\r
298\r
31b89da4 299void AliHLTCaloClusterizer::SetSortDigitsByPosition()\r
7c80a370 300{\r
31b89da4 301 // Sort the digit pointers by position\r
302 fCompareFunction = &CompareDigitsByPosition;\r
303 fSortDigits = true;\r
304 fSortedByPosition = true;\r
7c80a370 305}\r
306\r
31b89da4 307void AliHLTCaloClusterizer::SetSortDigitsByEnergy()\r
308{\r
309 // See header file for class documentation\r
310 fCompareFunction = &CompareDigitsByEnergy;\r
311 fSortDigits = true;\r
312 fSortedByEnergy = true;\r
313}\r
314\r
315void AliHLTCaloClusterizer::SortDigits()\r
316{\r
317 // See header file for class documentation\r
318 if (fSortDigits) qsort(fDigitsPointerArray, fNDigits, sizeof(AliHLTCaloDigitDataStruct*), fCompareFunction);\r
319}\r
320\r
321Int_t\r
322AliHLTCaloClusterizer::CompareDigitsByPosition(const void *dig0, const void *dig1)\r
323{\r
324 // See header file for documentation\r
325 return (*((AliHLTCaloDigitDataStruct**)(dig0)))->fID - (*((AliHLTCaloDigitDataStruct**)(dig1)))->fID;\r
326}\r
327\r
328Int_t\r
329AliHLTCaloClusterizer::CompareDigitsByEnergy(const void *dig0, const void *dig1)\r
7c80a370 330{\r
31b89da4 331 // See header file for documentation\r
02f2218d 332 if ( ((*((AliHLTCaloDigitDataStruct**)(dig1)))->fEnergy - (*((AliHLTCaloDigitDataStruct**)(dig0)))->fEnergy) < 0) return -1;\r
333 return 1;\r
2a24cbbe 334}\r