- fixing bug in resizing of array/buffer in clusterizer
[u/mrichter/AliRoot.git] / HLT / CALO / AliHLTCaloClusterizerComponent.cxx
1 // $Id: AliHLTCaloClusterizerComponent.cxx 36709 2009-11-12 16:57:55Z odjuvsla $
2
3 /**************************************************************************
4  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
5  *                                                                        *
6  * Authors: Oystein Djuvsland <oysteind@ift.uib.no>                       *
7  *                                                                        *
8  * Permission to use, copy, modify and distribute this software and its   *
9  * documentation strictly for non-commercial purposes is hereby granted   *
10  * without fee, provided that the above copyright notice appears in all   *
11  * copies and that both the copyright notice and this permission notice   *
12  * appear in the supporting documentation. The authors make no claims     *
13  * about the suitability of this software for any purpose. It is          *
14  * provided "as is" without express or implied warranty.                  *
15  **************************************************************************/
16
17 #include "AliHLTCaloClusterizerComponent.h"
18 #include "AliHLTCaloClusterizer.h"
19 #include "AliHLTCaloClusterAnalyser.h" 
20 #include "AliHLTCaloRecPointDataStruct.h"
21 #include "AliHLTCaloRecPointHeaderStruct.h"
22 #include "AliHLTCaloDigitDataStruct.h"
23 #include "AliHLTCaloDigitContainerDataStruct.h"
24 #include "AliHLTCaloDefinitions.h"
25 #include "AliHLTCaloClusterDataStruct.h"
26 #include "TString.h"
27
28 /** @file   AliHLTCaloClusterizerComponent.cxx
29     @author Oystein Djuvsland
30     @date   
31     @brief  A clusterizer component for PHOS HLT
32 */
33
34 // see header file for class documentation
35 // or
36 // refer to README to build package
37 // or
38 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
39
40 AliHLTCaloClusterizerComponent::AliHLTCaloClusterizerComponent(TString det): 
41   AliHLTCaloProcessor(),
42   AliHLTCaloConstantsHandler(det),
43   fDataOrigin('\0'),
44   fAnalyserPtr(0),
45   fDigitsPointerArray(0), 
46   fOutputDigitsArray(0),
47   fClusterizerPtr(0),
48   fDigitCount(0)
49 {
50   //See headerfile for documentation
51
52   fDigitsPointerArray = new AliHLTCaloDigitDataStruct*[fCaloConstants->GetNXCOLUMNSMOD()*fCaloConstants->GetNZROWSMOD()];
53
54   fClusterizerPtr = new AliHLTCaloClusterizer(det);
55
56   fClusterizerPtr->SetDigitArray(fDigitsPointerArray);
57    
58   fAnalyserPtr = new AliHLTCaloClusterAnalyser();
59   
60   if(det == "PHOS")
61   {
62      fAnalyserPtr->SetClusterType(kPHOSCluster);
63   }
64   else if(det == "EMCAL")
65   {
66      fAnalyserPtr->SetClusterType(kEMCALClusterv1);
67   }
68   else
69   {
70      fAnalyserPtr->SetClusterType(kUndef);
71   }
72   
73   
74 }
75
76 AliHLTCaloClusterizerComponent::~AliHLTCaloClusterizerComponent()
77 {
78   //See headerfile for documentation
79 delete fAnalyserPtr;
80   if(fClusterizerPtr)
81     {
82       delete fClusterizerPtr;
83       fClusterizerPtr = 0;
84     }
85 }
86
87
88 int
89 AliHLTCaloClusterizerComponent::Deinit()
90 {
91   //See headerfile for documentation
92
93 if (fClusterizerPtr)
94     {
95       delete fClusterizerPtr;
96       fClusterizerPtr = 0;
97     }
98
99   return 0;
100 }
101
102 int
103 AliHLTCaloClusterizerComponent::DoEvent(const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
104                                         AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size,
105                                         std::vector<AliHLTComponentBlockData>& outputBlocks)
106 {
107   //See headerfile for documentation
108
109   if(blocks == 0) return 0;
110   
111   UInt_t offset           = 0;
112   UInt_t mysize           = 0;
113   Int_t nRecPoints        = 0;
114   Int_t nDigits           = 0;
115   Int_t digCount          = 0;
116
117   UInt_t availableSize = size;
118   AliHLTUInt8_t* outBPtr;
119   outBPtr = outputPtr;
120   const AliHLTComponentBlockData* iter = 0;
121   unsigned long ndx;
122   
123   UInt_t specification = 0;
124   
125   AliHLTCaloDigitDataStruct *digitDataPtr = 0;
126   
127   // Adding together all the digits, should be put in standalone method  
128   for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
129     {
130       iter = blocks+ndx;
131       //            HLTError("Got block");
132       if (iter->fDataType == (AliHLTCaloDefinitions::fgkDigitDataType|fDataOrigin))
133         {
134
135            // Update the number of digits
136           nDigits = iter->fSize/sizeof(AliHLTCaloDigitDataStruct);
137           availableSize -= iter->fSize;
138           
139           specification = specification|iter->fSpecification;
140
141           digitDataPtr = reinterpret_cast<AliHLTCaloDigitDataStruct*>(iter->fPtr);
142           for (Int_t i = 0; i < nDigits; i++)
143             {
144               fDigitsPointerArray[digCount] = digitDataPtr;
145               digCount++;
146               digitDataPtr++;
147             }
148         }
149     }
150
151   if(digCount > 0)
152     {
153        
154       AliHLTCaloClusterHeaderStruct* caloClusterHeaderPtr = reinterpret_cast<AliHLTCaloClusterHeaderStruct*>(outBPtr);
155       caloClusterHeaderPtr->fNDigits = digCount;
156       
157       outBPtr += sizeof(AliHLTCaloClusterHeaderStruct);
158       mysize += sizeof(AliHLTCaloClusterHeaderStruct);
159       
160       // Sort the digit pointers
161       qsort(fDigitsPointerArray, digCount, sizeof(AliHLTCaloDigitDataStruct*), CompareDigits);
162
163       // Copy the digits to the output
164       fOutputDigitsArray = reinterpret_cast<AliHLTCaloDigitDataStruct*>(outBPtr);
165       for(Int_t n = 0; n < digCount; n++)
166         {
167           memcpy(outBPtr, fDigitsPointerArray[n], sizeof(AliHLTCaloDigitDataStruct));
168           //fOutputDigitsArray[n] = reinterpret_cast<AliHLTCaloDigitDataStruct*>(outBPtr);
169           outBPtr = outBPtr + sizeof(AliHLTCaloDigitDataStruct);
170         }
171   
172       mysize += digCount*sizeof(AliHLTCaloDigitDataStruct);
173       
174       //HLTDebug("Total number of digits: %d", digCount );
175
176       nRecPoints = fClusterizerPtr->ClusterizeEvent(digCount);
177
178       //HLTDebug("Number of rec points found: %d", nRecPoints);
179       fAnalyserPtr->SetCaloClusterData(reinterpret_cast<AliHLTCaloClusterDataStruct*>(outBPtr));
180       
181       fAnalyserPtr->SetRecPointArray(fClusterizerPtr->GetRecPoints(), nRecPoints);
182
183       fAnalyserPtr->SetDigitDataArray(fOutputDigitsArray);
184       
185       Int_t nClusters = fAnalyserPtr->CreateClusters(nRecPoints, size, mysize);
186       
187       if (nClusters < 0) 
188         {
189           caloClusterHeaderPtr->fNClusters = 0;
190         } 
191       else 
192         {
193           caloClusterHeaderPtr->fNClusters = nClusters;
194         }
195      
196       //HLTDebug("Number of clusters: %d", nRecPoints);
197       
198       AliHLTComponentBlockData bd;
199       FillBlockData( bd );
200       bd.fOffset = offset;
201       bd.fSize = mysize;
202       bd.fDataType = kAliHLTDataTypeCaloCluster | fDataOrigin;
203       bd.fSpecification = specification;
204       outputBlocks.push_back( bd );
205     }
206
207   size = mysize;
208   
209   return 0;
210 }
211
212 int 
213 AliHLTCaloClusterizerComponent::Reconfigure(const char* cdbEntry, const char* /*chainId*/)
214 {  
215   // see header file for class documentation
216
217   const char* path="HLT/ConfigPHOS/ClusterizerComponent";
218
219   if (cdbEntry) path = cdbEntry;
220
221   return ConfigureFromCDBTObjString(cdbEntry);
222 }
223
224 int 
225 AliHLTCaloClusterizerComponent::ScanConfigurationArgument(int argc, const char **argv)
226 {
227   //See header file for documentation
228
229   if(argc <= 0) return 0;
230
231   int i=0;
232
233   TString argument=argv[i];
234
235   if (argument.CompareTo("-digitthreshold") == 0)
236     {
237       if (++i >= argc) return -EPROTO;
238       argument = argv[i];
239       fClusterizerPtr->SetEmcMinEnergyThreshold(argument.Atof());
240       return 1;
241     }
242
243   if (argument.CompareTo("-recpointthreshold") == 0)
244     {
245       if (++i >= argc) return -EPROTO;
246       argument = argv[i];
247       fClusterizerPtr->SetEmcClusteringThreshold(argument.Atof());
248       return 1;
249     }
250   return 0;
251 }
252
253 int
254 AliHLTCaloClusterizerComponent::DoInit(int argc, const char** argv )
255 {
256   //See headerfile for documentation
257
258   
259   //
260
261   //  const char *path = "HLT/ConfigPHOS/ClusterizerComponent";
262
263   //  ConfigureFromCDBTObjString(path);
264
265   for (int i = 0; i < argc; i++)
266     {
267       ScanConfigurationArgument(i, argv);
268     }
269
270   return 0;
271 }
272
273 Int_t 
274 AliHLTCaloClusterizerComponent::CompareDigits(const void *dig0, const void *dig1)
275 {
276   // See header file for documentation
277   return (*((AliHLTCaloDigitDataStruct**)(dig0)))->fID - (*((AliHLTCaloDigitDataStruct**)(dig1)))->fID;
278
279   //return (*((AliHLTCaloDigitDataStruct**)(dig0)))->fID - (*((AliHLTCaloDigitDataStruct**)(dig1)))->fID;
280 }