135964b997285d4a7ce4bfa9a4ea10b59a2d8683
[u/mrichter/AliRoot.git] / HLT / CALO / AliHLTCaloClusterAnalyser.cxx
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"
36 #include "AliHLTCaloGeometry.h"
37 #include "AliESDCaloCluster.h"
38 #include "TMath.h"
39 #include "TVector3.h"
40 #include "TH1F.h"
41 #include "TFile.h"
42 #include "AliHLTCaloClusterizer.h"
43
44 ClassImp(AliHLTCaloClusterAnalyser);
45
46 AliHLTCaloClusterAnalyser::AliHLTCaloClusterAnalyser() : 
47   //  AliHLTCaloBase(),
48   fLogWeight(4.5),
49   fRecPointArray(0),
50   fDigitDataArray(0),
51   fNRecPoints(0),
52   fCaloClusterDataPtr(0),
53   fCaloClusterHeaderPtr(0),
54   //fAnalyzerPtr(0),
55   fDoClusterFit(false),
56   fHaveCPVInfo(false),
57   fDoPID(false),
58   fHaveDistanceToBadChannel(false),
59   fGeometry(0),
60   fClusterType(AliESDCaloCluster::kPHOSCluster)
61 {
62   //See header file for documentation
63 }
64
65 AliHLTCaloClusterAnalyser::~AliHLTCaloClusterAnalyser() 
66 {
67   // See header file for class documentation
68 }
69
70 void 
71 AliHLTCaloClusterAnalyser::SetCaloClusterData(AliHLTCaloClusterDataStruct *caloClusterDataPtr)
72
73   //see header file for documentation
74   fCaloClusterDataPtr = caloClusterDataPtr; 
75 }
76
77 void
78 AliHLTCaloClusterAnalyser::SetRecPointArray(AliHLTCaloRecPointDataStruct **recPointDataPtr, Int_t nRecPoints)
79
80   fRecPointArray = recPointDataPtr; 
81   fNRecPoints = nRecPoints;
82 }
83
84 void 
85 AliHLTCaloClusterAnalyser::SetDigitDataArray(AliHLTCaloDigitDataStruct *digits) 
86
87 //   AliHLTCaloClusterizer cl("PHOS");
88   // cl.CheckDigits(fRecPointArray, digits, fNRecPoints);
89    fDigitDataArray = digits; 
90    //cl.CheckDigits(fRecPointArray, fDigitDataArray, fNRecPoints);
91 }
92
93 Int_t
94 AliHLTCaloClusterAnalyser::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;
104
105   UInt_t iDigit = 0;
106
107   for(Int_t iRecPoint=0; iRecPoint < fNRecPoints; iRecPoint++) 
108     {
109       AliHLTCaloRecPointDataStruct *recPoint = fRecPointArray[iRecPoint];
110       //      digit = &(recPoint->fDigits);
111
112       Int_t *digitIndexPtr = &(recPoint->fDigits);
113
114       for(iDigit = 0; iDigit < recPoint->fMultiplicity; iDigit++)
115         {
116
117           digit = &(fDigitDataArray[*digitIndexPtr]);
118
119           xi = digit->fX;
120           zi = digit->fZ;
121
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             }
129           digitIndexPtr++;
130         }
131
132       if (wtot>0) 
133         {
134           recPoint->fX = x/wtot ;
135           recPoint->fZ = z/wtot ;
136         }
137       else
138         {
139           recPoint->fAmp = 0;
140         }
141     }
142   return 0;
143 }
144
145
146 Int_t 
147 AliHLTCaloClusterAnalyser::CalculateRecPointMoments()
148 {
149   //See header file for documentation
150   return 0;
151 }
152
153 Int_t 
154 AliHLTCaloClusterAnalyser::CalculateClusterMoments(AliHLTCaloRecPointDataStruct */*recPointPtr*/, AliHLTCaloClusterDataStruct* /*clusterPtr*/)
155 {
156   //See header file for documentation
157   return 0;
158 }
159
160
161 Int_t 
162 AliHLTCaloClusterAnalyser::DeconvoluteClusters()
163 {
164   //See header file for documentation
165   return 0;
166 }
167
168 Int_t 
169 AliHLTCaloClusterAnalyser::CreateClusters(Int_t nRecPoints, UInt_t availableSize, UInt_t& totSize)
170 {
171   //See header file for documentation
172
173    
174   totSize += sizeof(AliHLTCaloClusterDataStruct);
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
184   //  AliHLTCaloDigitDataStruct* digitPtr = &(recPointPtr->fDigits);  
185   AliHLTCaloDigitDataStruct* digitPtr = 0;
186
187   AliHLTCaloClusterDataStruct* caloClusterPtr = 0;
188   UShort_t* cellIDPtr = 0;
189   Float_t* cellAmpFracPtr = 0;;
190   
191 //  Int_t id = -1;
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     {
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      
207       AliHLTCaloRecPointDataStruct *recPointPtr = fRecPointArray[i];
208       
209       AliHLTCaloGlobalCoordinate globalCoord;
210       fGeometry->GetGlobalCoordinates(*recPointPtr, globalCoord);
211
212       caloClusterPtr->fGlobalPos[0] = globalCoord.fX;
213       caloClusterPtr->fGlobalPos[1] = globalCoord.fY;
214       caloClusterPtr->fGlobalPos[2] = globalCoord.fZ;
215
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       
226       for(UInt_t j = 0; j < caloClusterPtr->fNCells; j++)
227         {
228 /*        fGeometry->GetCellAbsId(recPointPtr->fModule, digitPtr->fX, digitPtr->fZ, id);
229           *cellIDPtr = id;
230           *cellAmpFracPtr = digitPtr->fEnergy/recPointPtr->fAmp;
231           digitPtr++;
232           cellIDPtr = reinterpret_cast<UShort_t*>(reinterpret_cast<char*>(cellAmpFracPtr) + sizeof(Float_t)); 
233           cellAmpFracPtr = reinterpret_cast<Float_t*>(reinterpret_cast<char*>(cellIDPtr) + sizeof(Short_t)); */
234         }
235
236       totSize += tmpSize;
237
238       caloClusterPtr->fEnergy = recPointPtr->fAmp;
239
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
280       caloClusterPtr->fClusterType = fClusterType;
281       //      totSize += sizeof(AliHLTCaloClusterDataStruct) + (caloClusterPtr->fNCells)*(sizeof(Short_t) +sizeof(Float_t)-1);   
282       //totSize += sizeof(AliHLTCaloClusterDataStruct) + (caloClusterPtr->fNCells-1)*(sizeof(Short_t) + sizeof(Float_t));   
283
284       //      caloClusterPtr = reinterpret_cast<AliHLTCaloClusterDataStruct*>(cellAmpFracPtr);
285       caloClusterPtr = reinterpret_cast<AliHLTCaloClusterDataStruct*>(cellIDPtr);
286
287       recPointPtr = reinterpret_cast<AliHLTCaloRecPointDataStruct*>(digitPtr);
288       //digitPtr = &(recPointPtr->fDigits);  
289     }
290
291 return fNRecPoints;
292
293 }
294