3 /**************************************************************************
\r
4 * This file is property of and copyright by the ALICE HLT Project *
\r
5 * All rights reserved. *
\r
7 * Primary Authors: Oystein Djuvsland *
\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
14 * about the suitability of this software for any purpose. It is *
\r
15 * provided "as is" without express or implied warranty. *
\r
16 **************************************************************************/
\r
19 * @file AliHLTCaloClusterizer.cxx
\r
20 * @author Oystein Djuvsland
\r
22 * @brief Clusterizer for PHOS HLT
\r
25 // see header file for class documentation
\r
27 // refer to README to build package
\r
29 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
\r
31 #include "AliHLTCaloClusterizer.h"
\r
32 #include "AliHLTLogging.h"
\r
34 #include "AliHLTCaloRecPointDataStruct.h"
\r
35 #include "AliHLTCaloDigitDataStruct.h"
\r
36 #include "AliHLTCaloDigitContainerDataStruct.h"
\r
37 #include "AliHLTCaloConstantsHandler.h"
\r
39 ClassImp(AliHLTCaloClusterizer);
\r
41 AliHLTCaloClusterizer::AliHLTCaloClusterizer(TString det):
\r
42 AliHLTCaloConstantsHandler(det),
\r
44 fRecPointDataPtr(0),
\r
45 fFirstRecPointPtr(0),
\r
51 fEmcClusteringThreshold(0),
\r
52 fEmcMinEnergyThreshold(0),
\r
54 fDigitsInCluster(0),
\r
55 fDigitsPointerArray(0),
\r
56 fDigitContainerPtr(0),
\r
57 fMaxDigitIndexDiff(0),
\r
60 //See header file for documentation
\r
61 //fEmcClusteringThreshold = 0.2;
\r
62 //fEmcMinEnergyThreshold = 0.03;
\r
64 fEmcClusteringThreshold = 0.1;
\r
65 fEmcMinEnergyThreshold = 0.01;
\r
66 fEmcTimeGate = 1.e-6 ;
\r
68 fMaxDigitIndexDiff = 2*fCaloConstants->GetNZROWSMOD();
\r
72 fRecPointArray = new AliHLTCaloRecPointDataStruct*[fArraySize];
\r
74 fAvailableSize = sizeof(AliHLTCaloRecPointDataStruct) * 20;
\r
75 fRecPointDataPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(new UChar_t[fAvailableSize]);
\r
76 fFirstRecPointPtr = fRecPointDataPtr;
\r
80 AliHLTCaloClusterizer::~AliHLTCaloClusterizer()
\r
82 //See header file for documentation
\r
86 AliHLTCaloClusterizer::SetRecPointDataPtr(AliHLTCaloRecPointDataStruct* recPointDataPtr)
\r
88 // See header file for documentation
\r
89 fRecPointDataPtr = recPointDataPtr;
\r
93 AliHLTCaloClusterizer::ClusterizeEvent(Int_t nDigits)
\r
95 //see header file for documentation
\r
96 Int_t nRecPoints = 0;
\r
100 fRecPointDataPtr = fFirstRecPointPtr;
\r
101 //Clusterization starts
\r
102 for(Int_t i = 0; i < nDigits; i++)
\r
104 fDigitsInCluster = 0;
\r
106 if(fDigitsPointerArray[i]->fEnergy < fEmcClusteringThreshold)
\r
113 // First digit is placed at the fDigits member variable in the recpoint
\r
114 fDigitIndexPtr = &(fRecPointDataPtr->fDigits);
\r
115 fUsedSize += sizeof(AliHLTCaloRecPointDataStruct);
\r
117 fRecPointDataPtr->fAmp = 0;
\r
118 fRecPointDataPtr->fModule = fDigitsPointerArray[i]->fModule;
\r
120 // Assigning the digit to this rec point
\r
121 fRecPointDataPtr->fDigits = i;
\r
122 fUsedSize += sizeof(AliHLTCaloRecPointDataStruct);
\r
124 // Incrementing the pointer to be ready for new entry
\r
127 fRecPointDataPtr->fAmp += fDigitsPointerArray[i]->fEnergy;
\r
128 fDigitsPointerArray[i]->fEnergy = 0;
\r
129 fDigitsInCluster++;
\r
132 // Scanning for the neighbours
\r
133 if(ScanForNeighbourDigits(i, fRecPointDataPtr) != 0)
\r
138 //fUsedSize += sizeof(AliHLTCaloRecPointDataStruct) + (fDigitsInCluster-1)*sizeof(AliHLTCaloDigitDataStruct);
\r
140 fRecPointDataPtr->fMultiplicity = fDigitsInCluster;
\r
141 fRecPointArray[fNRecPoints] = fRecPointDataPtr;
\r
143 fRecPointDataPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(fDigitIndexPtr);
\r
147 }//end of clusterization
\r
153 AliHLTCaloClusterizer::ScanForNeighbourDigits(Int_t index, AliHLTCaloRecPointDataStruct* recPoint)
\r
155 //see header file for documentation
\r
156 Int_t max = TMath::Min(fNDigits, (Int_t)fMaxDigitIndexDiff+index);
\r
157 Int_t min = TMath::Max(0, (Int_t)(index - (Int_t)fMaxDigitIndexDiff));
\r
161 for(Int_t j = min; j < max; j++)
\r
163 if(fDigitsPointerArray[j]->fEnergy > fEmcMinEnergyThreshold)
\r
167 if(AreNeighbours(fDigitsPointerArray[index],
\r
168 fDigitsPointerArray[j]))
\r
170 // if((fAvailableSize - fUsedSize) < sizeof(Int_t))
\r
172 // UChar_t *tmp = new UChar_t[fAvailableSize*2];
\r
173 // memcpy(tmp, fRecPointDataPtr, fAvailableSize);
\r
174 // for(Int_t n = 0; n < fNRecPoints; n++)
\r
176 // fRecPointArray[n] = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(reinterpret_cast<UChar_t*>(fRecPointArray[n]) - reinterpret_cast<UChar_t*>(fFirstRecPointPtr) + reinterpret_cast<UChar_t*>(tmp));
\r
178 // fRecPointDataPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(tmp);
\r
179 // fFirstRecPointPtr = fRecPointDataPtr;
\r
183 // Assigning index to digit
\r
184 *fDigitIndexPtr = j;
\r
185 fUsedSize += sizeof(Int_t);
\r
187 // Incrementing digit pointer to be ready for new entry
\r
190 recPoint->fAmp += fDigitsPointerArray[j]->fEnergy;
\r
191 fDigitsPointerArray[j]->fEnergy = 0;
\r
192 fDigitsInCluster++;
\r
193 ScanForNeighbourDigits(j, recPoint);
\r
202 AliHLTCaloClusterizer::AreNeighbours(AliHLTCaloDigitDataStruct* digit1,
\r
203 AliHLTCaloDigitDataStruct* digit2)
\r
205 //see header file for documentation
\r
206 if ( (digit1->fModule == digit2->fModule) /*&& (coord1[1]==coord2[1])*/ ) // inside the same PHOS module
\r
208 Int_t rowdiff = TMath::Abs( digit1->fZ - digit2->fZ );
\r
209 Int_t coldiff = TMath::Abs( digit1->fX - digit2->fX );
\r
210 if (( coldiff <= 1 && rowdiff == 0 ) || ( coldiff == 0 && rowdiff <= 1 ))
\r
212 // cout << "Are neighbours: digit (E = " << digit1->fEnergy << ") with x = " << digit1->fX << " and z = " << digit1->fZ <<
\r
213 // " is neighbour with digit (E = " << digit2->fEnergy << ") with x = " << digit2->fX << " and z = " << digit2->fZ << endl;
\r
215 if(TMath::Abs(digit1->fTime - digit2->fTime ) < fEmcTimeGate)
\r
221 /* Float_t rowdiff = TMath::Abs( digit1->fZ - digit2->fZ );
\r
222 Float_t coldiff = TMath::Abs( digit1->fX - digit2->fX );
\r
223 if (( coldiff <= 2.4 && rowdiff < 0.4 ) || ( coldiff < 0.4 && rowdiff <= 2.4 ))
\r
225 // cout << "Are neighbours: digit (E = " << digit1->fEnergy << ") with x = " << digit1->fX << " and z = " << digit1->fZ <<
\r
226 // " is neighbour with digit (E = " << digit2->fEnergy << ") with x = " << digit2->fX << " and z = " << digit2->fZ << endl;
\r
228 if(TMath::Abs(digit1->fTime - digit2->fTime ) < fEmcTimeGate)
\r
236 // cout << "Not neighbours: digit (E = " << digit1->fEnergy << ") with x = " << digit1->fX << " and z = " << digit1->fZ <<
\r
237 // " is not neighbour with digit (E = " << digit2->fEnergy << ") with x = " << digit2->fX << " and z = " << digit2->fZ << endl;
\r
245 Int_t AliHLTCaloClusterizer::CheckArray()
\r
247 if(fArraySize == fNRecPoints)
\r
250 AliHLTCaloRecPointDataStruct **tmp = new AliHLTCaloRecPointDataStruct*[fArraySize];
\r
251 memcpy(tmp, fRecPointArray, fArraySize/2 * sizeof(AliHLTCaloRecPointDataStruct*));
\r
252 delete fRecPointArray;
\r
253 fRecPointArray = tmp;
\r
258 Int_t AliHLTCaloClusterizer::CheckBuffer()
\r
260 // See header file for class documentation
\r
261 if((fAvailableSize - fUsedSize) < sizeof(AliHLTCaloRecPointDataStruct))
\r
263 Int_t recPointOffset = reinterpret_cast<UChar_t*>(fRecPointDataPtr) - reinterpret_cast<UChar_t*>(fFirstRecPointPtr);
\r
264 UChar_t *tmp = new UChar_t[fAvailableSize*2];
\r
265 memcpy(tmp, fFirstRecPointPtr, fAvailableSize);
\r
266 fAvailableSize *= 2;
\r
267 for(Int_t n = 0; n < fNRecPoints; n++)
\r
269 fRecPointArray[n] = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(reinterpret_cast<UChar_t*>(fRecPointArray[n]) - reinterpret_cast<UChar_t*>(fFirstRecPointPtr) + reinterpret_cast<UChar_t*>(tmp));
\r
271 delete fFirstRecPointPtr;
\r
272 fFirstRecPointPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(tmp);
\r
273 fRecPointDataPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(tmp + recPointOffset);
\r
279 Int_t AliHLTCaloClusterizer::CheckDigits(AliHLTCaloRecPointDataStruct** recArray, AliHLTCaloDigitDataStruct** digitArray, Int_t nRP)
\r
281 AliHLTCaloRecPointDataStruct **recpoints = recArray;
\r
282 AliHLTCaloDigitDataStruct **digits = digitArray;
\r
283 Int_t nRecPoints = nRP;
\r
287 recpoints = fRecPointArray;
\r
289 if(digitArray == 0)
\r
291 digits = fDigitsPointerArray;
\r
295 nRecPoints = fNRecPoints;
\r
297 for(Int_t i = 0; i < nRecPoints; i++)
\r
300 AliHLTCaloRecPointDataStruct *recPoint = recpoints[i];
\r
302 //AliHLTCaloRecPointDataStruct *recPoint = fRecPointArray[0];
\r
303 Int_t multiplicity = recPoint->fMultiplicity;
\r
304 Int_t *digitIndexPtr = &(recPoint->fDigits);
\r
305 for(Int_t j = 0; j < multiplicity; j++)
\r
307 //AliHLTCaloRecPointDataStruct *recPoint = fRecPointArray[j];
\r
308 // AliHLTCaloDigitDataStruct *digit = digits[*digitIndexPtr];
\r
310 //recPoint = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(digitIndexPtr);
\r
317 Int_t AliHLTCaloClusterizer::CheckDigits(AliHLTCaloRecPointDataStruct** recArray, AliHLTCaloDigitDataStruct* digitArray, Int_t nRP)
\r
319 AliHLTCaloRecPointDataStruct **recpoints = recArray;
\r
320 AliHLTCaloDigitDataStruct *digits = digitArray;
\r
321 Int_t nRecPoints = nRP;
\r
325 recpoints = fRecPointArray;
\r
329 nRecPoints = fNRecPoints;
\r
331 for(Int_t i = 0; i < nRecPoints; i++)
\r
334 AliHLTCaloRecPointDataStruct *recPoint = recpoints[i];
\r
336 //AliHLTCaloRecPointDataStruct *recPoint = fRecPointArray[0];
\r
337 Int_t multiplicity = recPoint->fMultiplicity;
\r
338 Int_t *digitIndexPtr = &(recPoint->fDigits);
\r
339 for(Int_t j = 0; j < multiplicity; j++)
\r
341 //AliHLTCaloRecPointDataStruct *recPoint = fRecPointArray[j];
\r
342 AliHLTCaloDigitDataStruct digit = digits[*digitIndexPtr];
\r
344 //recPoint = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(digitIndexPtr);
\r