- cleaning up debug output
[u/mrichter/AliRoot.git] / HLT / CALO / AliHLTCaloClusterAnalyser.cxx
CommitLineData
ea367f6a 1// $Id: AliHLTCaloClusterAnalyser.cxx 35107 2009-09-30 01:45:06Z phille $
2
3/**************************************************************************
4 * This file is property of and copyright by the ALICE HLT Project *
5 * All rights reserved. *
6 * *
7 * Primary Authors: Oystein Djuvsland *
8 * *
9 * Permission to use, copy, modify and distribute this software and its *
10 * documentation strictly for non-commercial purposes is hereby granted *
11 * without fee, provided that the above copyright notice appears in all *
12 * copies and that both the copyright notice and this permission notice *
13 * appear in the supporting documentation. The authors make no claims *
14 * about the suitability of this software for any purpose. It is *
15 * provided "as is" without express or implied warranty. *
16 **************************************************************************/
17
18/**
19 * @file AliHLTCaloClusterAnalyser.cxx
20 * @author Oystein Djuvsland
21 * @date
22 * @brief Cluster analyser for Calo HLT
23 */
24
25// see header file for class documentation
26// or
27// refer to README to build package
28// or
29// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
30
31#include "AliHLTCaloClusterAnalyser.h"
32#include "AliHLTCaloRecPointHeaderStruct.h"
33#include "AliHLTCaloRecPointDataStruct.h"
34#include "AliHLTCaloClusterDataStruct.h"
35//#include "AliHLTCaloPhysicsAnalyzer.h"
7c80a370 36#include "AliHLTCaloGeometry.h"
ea367f6a 37#include "AliESDCaloCluster.h"
38#include "TMath.h"
39#include "TVector3.h"
73d6f579 40#include "TH1F.h"
41#include "TFile.h"
7c80a370 42#include "AliHLTCaloClusterizer.h"
ea367f6a 43
44ClassImp(AliHLTCaloClusterAnalyser);
45
7c80a370 46AliHLTCaloClusterAnalyser::AliHLTCaloClusterAnalyser() :
ea367f6a 47 // AliHLTCaloBase(),
7c80a370 48 fLogWeight(4.5),
49 fRecPointArray(0),
50 fDigitDataArray(0),
ea367f6a 51 fNRecPoints(0),
52 fCaloClusterDataPtr(0),
53 fCaloClusterHeaderPtr(0),
ea367f6a 54 //fAnalyzerPtr(0),
55 fDoClusterFit(false),
56 fHaveCPVInfo(false),
57 fDoPID(false),
7c80a370 58 fHaveDistanceToBadChannel(false),
73d6f579 59 fGeometry(0),
60 fClusterType(AliESDCaloCluster::kPHOSCluster)
ea367f6a 61{
62 //See header file for documentation
ea367f6a 63}
64
65AliHLTCaloClusterAnalyser::~AliHLTCaloClusterAnalyser()
66{
98baf84d 67 // See header file for class documentation
ea367f6a 68}
69
70void
7c80a370 71AliHLTCaloClusterAnalyser::SetCaloClusterData(AliHLTCaloClusterDataStruct *caloClusterDataPtr)
ea367f6a 72{
73 //see header file for documentation
74 fCaloClusterDataPtr = caloClusterDataPtr;
75}
7c80a370 76
ea367f6a 77void
7c80a370 78AliHLTCaloClusterAnalyser::SetRecPointArray(AliHLTCaloRecPointDataStruct **recPointDataPtr, Int_t nRecPoints)
ea367f6a 79{
7c80a370 80 fRecPointArray = recPointDataPtr;
81 fNRecPoints = nRecPoints;
82}
83
84void
85AliHLTCaloClusterAnalyser::SetDigitDataArray(AliHLTCaloDigitDataStruct *digits)
86{
87// AliHLTCaloClusterizer cl("PHOS");
88 // cl.CheckDigits(fRecPointArray, digits, fNRecPoints);
89 fDigitDataArray = digits;
90 //cl.CheckDigits(fRecPointArray, fDigitDataArray, fNRecPoints);
ea367f6a 91}
92
93Int_t
94AliHLTCaloClusterAnalyser::CalculateCenterOfGravity()
95{
96 //see header file for documentation
97 Float_t wtot = 0.;
98 Float_t x = 0.;
99 Float_t z = 0.;
100 Float_t xi = 0.;
101 Float_t zi = 0.;
102
103 AliHLTCaloDigitDataStruct *digit = 0;
ea367f6a 104
105 UInt_t iDigit = 0;
106
107 for(Int_t iRecPoint=0; iRecPoint < fNRecPoints; iRecPoint++)
108 {
7c80a370 109 AliHLTCaloRecPointDataStruct *recPoint = fRecPointArray[iRecPoint];
ad44d760 110 // digit = &(recPoint->fDigits);
98baf84d 111
7c80a370 112 Int_t *digitIndexPtr = &(recPoint->fDigits);
113
ea367f6a 114 for(iDigit = 0; iDigit < recPoint->fMultiplicity; iDigit++)
115 {
7c80a370 116
117 digit = &(fDigitDataArray[*digitIndexPtr]);
98baf84d 118
ea367f6a 119 xi = digit->fX;
120 zi = digit->fZ;
98baf84d 121
ea367f6a 122 if (recPoint->fAmp > 0 && digit->fEnergy > 0)
123 {
124 Float_t w = TMath::Max( 0., fLogWeight + TMath::Log( digit->fEnergy / recPoint->fAmp ) ) ;
125 x += xi * w ;
126 z += zi * w ;
127 wtot += w ;
128 }
7c80a370 129 digitIndexPtr++;
ea367f6a 130 }
98baf84d 131
ea367f6a 132 if (wtot>0)
133 {
134 recPoint->fX = x/wtot ;
135 recPoint->fZ = z/wtot ;
136 }
137 else
138 {
139 recPoint->fAmp = 0;
140 }
ea367f6a 141 }
142 return 0;
143}
144
145
146Int_t
147AliHLTCaloClusterAnalyser::CalculateRecPointMoments()
148{
149 //See header file for documentation
150 return 0;
151}
152
153Int_t
154AliHLTCaloClusterAnalyser::CalculateClusterMoments(AliHLTCaloRecPointDataStruct */*recPointPtr*/, AliHLTCaloClusterDataStruct* /*clusterPtr*/)
155{
156 //See header file for documentation
157 return 0;
158}
159
160
161Int_t
162AliHLTCaloClusterAnalyser::DeconvoluteClusters()
163{
164 //See header file for documentation
165 return 0;
166}
167
168Int_t
7c80a370 169AliHLTCaloClusterAnalyser::CreateClusters(Int_t nRecPoints, UInt_t availableSize, UInt_t& totSize)
ea367f6a 170{
171 //See header file for documentation
172
73d6f579 173
b4479a87 174 totSize += sizeof(AliHLTCaloClusterDataStruct);
7c80a370 175 fNRecPoints = nRecPoints;
176
177 if(fGeometry == 0)
178 {
179 HLTError("No geometry object is initialised, creation of clusters stopped");
180 }
181
182 CalculateCenterOfGravity();
183
ad44d760 184 // AliHLTCaloDigitDataStruct* digitPtr = &(recPointPtr->fDigits);
185 AliHLTCaloDigitDataStruct* digitPtr = 0;
186
73d6f579 187 AliHLTCaloClusterDataStruct* caloClusterPtr = 0;
188 UShort_t* cellIDPtr = 0;
189 Float_t* cellAmpFracPtr = 0;;
ea367f6a 190
98baf84d 191// Int_t id = -1;
ea367f6a 192 TVector3 globalPos;
193
194 for(Int_t i = 0; i < fNRecPoints; i++) //TODO needs fix when we start unfolding (number of clusters not necessarily same as number of recpoints gotten from the clusterizer
195 {
73d6f579 196 if((availableSize - totSize) < sizeof(AliHLTCaloClusterDataStruct))
197 {
198 HLTError("Out of buffer");
199 return -ENOBUFS;
200 }
201
202 caloClusterPtr = fCaloClusterDataPtr;
203
204 cellIDPtr = &(caloClusterPtr->fCellsAbsId);
205 cellAmpFracPtr = &(caloClusterPtr->fCellsAmpFraction);
206
7c80a370 207 AliHLTCaloRecPointDataStruct *recPointPtr = fRecPointArray[i];
7c80a370 208
209 AliHLTCaloGlobalCoordinate globalCoord;
210 fGeometry->GetGlobalCoordinates(*recPointPtr, globalCoord);
ea367f6a 211
7c80a370 212 caloClusterPtr->fGlobalPos[0] = globalCoord.fX;
213 caloClusterPtr->fGlobalPos[1] = globalCoord.fY;
214 caloClusterPtr->fGlobalPos[2] = globalCoord.fZ;
ea367f6a 215
73d6f579 216 caloClusterPtr->fNCells = 0;//recPointPtr->fMultiplicity;
217
218 Int_t tmpSize = totSize + (caloClusterPtr->fNCells-1)*(sizeof(Short_t) + sizeof(Float_t));
219
220 if((availableSize - totSize) < tmpSize)
221 {
222 HLTError("Out of buffer");
223 return -ENOBUFS;
224 }
225
ea367f6a 226 for(UInt_t j = 0; j < caloClusterPtr->fNCells; j++)
227 {
73d6f579 228/* fGeometry->GetCellAbsId(recPointPtr->fModule, digitPtr->fX, digitPtr->fZ, id);
229 *cellIDPtr = id;
ea367f6a 230 *cellAmpFracPtr = digitPtr->fEnergy/recPointPtr->fAmp;
231 digitPtr++;
232 cellIDPtr = reinterpret_cast<UShort_t*>(reinterpret_cast<char*>(cellAmpFracPtr) + sizeof(Float_t));
7c80a370 233 cellAmpFracPtr = reinterpret_cast<Float_t*>(reinterpret_cast<char*>(cellIDPtr) + sizeof(Short_t)); */
ea367f6a 234 }
235
73d6f579 236 totSize += tmpSize;
237
ea367f6a 238 caloClusterPtr->fEnergy = recPointPtr->fAmp;
73d6f579 239
ea367f6a 240 if(fDoClusterFit)
241 {
242 FitCluster(recPointPtr);
243 }
244 else
245 {
246 caloClusterPtr->fDispersion = 0;
247 caloClusterPtr->fFitQuality = 0;
248 caloClusterPtr->fM20 = 0;
249 caloClusterPtr->fM02 = 0;
250
251 }
252 if(fHaveCPVInfo)
253 {
254 caloClusterPtr->fEmcCpvDistance = GetCPVDistance(recPointPtr);
255 }
256 else
257 {
258 caloClusterPtr->fEmcCpvDistance = -1;
259 }
260 if(fDoPID)
261 {
262 DoParticleIdentification(caloClusterPtr);
263 }
264 else
265 {
266 for(Int_t k = 0; k < AliPID::kSPECIESN; k++)
267 {
268 caloClusterPtr->fPID[k] = 0;
269 }
270 }
271 if(fHaveDistanceToBadChannel)
272 {
273 caloClusterPtr->fDistanceToBadChannel = GetDistanceToBadChannel(caloClusterPtr);
274 }
275 else
276 {
277 caloClusterPtr->fDistanceToBadChannel = -1;
278 }
279
73d6f579 280 caloClusterPtr->fClusterType = fClusterType;
ea367f6a 281 // totSize += sizeof(AliHLTCaloClusterDataStruct) + (caloClusterPtr->fNCells)*(sizeof(Short_t) +sizeof(Float_t)-1);
73d6f579 282 //totSize += sizeof(AliHLTCaloClusterDataStruct) + (caloClusterPtr->fNCells-1)*(sizeof(Short_t) + sizeof(Float_t));
ea367f6a 283
284 // caloClusterPtr = reinterpret_cast<AliHLTCaloClusterDataStruct*>(cellAmpFracPtr);
285 caloClusterPtr = reinterpret_cast<AliHLTCaloClusterDataStruct*>(cellIDPtr);
7c80a370 286
ea367f6a 287 recPointPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(digitPtr);
73d6f579 288 //digitPtr = &(recPointPtr->fDigits);
ea367f6a 289 }
98baf84d 290
291return fNRecPoints;
ea367f6a 292
293}
294