- cleaning up debug output
[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->GetNXCOLUMNSRCU()*fCaloConstants->GetNZROWSRCU()];
53
54   fClusterizerPtr = new AliHLTCaloClusterizer(det);
55
56   fClusterizerPtr->SetDigitArray(fDigitsPointerArray);
57    
58   fAnalyserPtr = new AliHLTCaloClusterAnalyser();
59   
60 }
61
62 AliHLTCaloClusterizerComponent::~AliHLTCaloClusterizerComponent()
63 {
64   //See headerfile for documentation
65 delete fAnalyserPtr;
66   if(fClusterizerPtr)
67     {
68       delete fClusterizerPtr;
69       fClusterizerPtr = 0;
70     }
71 }
72
73
74 int
75 AliHLTCaloClusterizerComponent::Deinit()
76 {
77   //See headerfile for documentation
78
79 if (fClusterizerPtr)
80     {
81       delete fClusterizerPtr;
82       fClusterizerPtr = 0;
83     }
84
85   return 0;
86 }
87
88 int
89 AliHLTCaloClusterizerComponent::DoEvent(const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
90                                         AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size,
91                                         std::vector<AliHLTComponentBlockData>& outputBlocks)
92 {
93   //See headerfile for documentation
94
95   if(blocks == 0) return 0;
96   
97   UInt_t offset           = 0;
98   UInt_t mysize           = 0;
99   Int_t nRecPoints        = 0;
100   Int_t nDigits           = 0;
101   Int_t digCount          = 0;
102
103   UInt_t availableSize = size;
104   AliHLTUInt8_t* outBPtr;
105   outBPtr = outputPtr;
106   const AliHLTComponentBlockData* iter = 0;
107   unsigned long ndx;
108   
109   UInt_t specification = 0;
110   
111   AliHLTCaloDigitDataStruct *digitDataPtr = 0;
112   
113   // Adding together all the digits, should be put in standalone method  
114   for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
115     {
116       iter = blocks+ndx;
117       //            HLTError("Got block");
118       if (iter->fDataType == (AliHLTCaloDefinitions::fgkDigitDataType|fDataOrigin))
119         {
120
121           // Update the number of digits
122           nDigits = iter->fSize/sizeof(AliHLTCaloDigitDataStruct);;
123           
124           availableSize -= iter->fSize;
125           
126           specification = specification|iter->fSpecification;
127
128           digitDataPtr = reinterpret_cast<AliHLTCaloDigitDataStruct*>(iter->fPtr);
129           for (Int_t i = 0; i < nDigits; i++)
130             {
131               fDigitsPointerArray[digCount] = digitDataPtr;
132               digCount++;
133               digitDataPtr++;
134             }
135         }
136     }
137
138   if(digCount > 0)
139     {
140        
141       AliHLTCaloClusterHeaderStruct* caloClusterHeaderPtr = reinterpret_cast<AliHLTCaloClusterHeaderStruct*>(outBPtr);
142       caloClusterHeaderPtr->fNDigits = digCount;
143       
144       outBPtr += sizeof(AliHLTCaloClusterHeaderStruct);
145       mysize += sizeof(AliHLTCaloClusterHeaderStruct);
146       
147       // Sort the digit pointers
148       qsort(fDigitsPointerArray, digCount, sizeof(AliHLTCaloDigitDataStruct*), CompareDigits);
149
150       // Copy the digits to the output
151       fOutputDigitsArray = reinterpret_cast<AliHLTCaloDigitDataStruct*>(outBPtr);
152       for(Int_t n = 0; n < digCount; n++)
153         {
154           memcpy(outBPtr, fDigitsPointerArray[n], sizeof(AliHLTCaloDigitDataStruct));
155           //fOutputDigitsArray[n] = reinterpret_cast<AliHLTCaloDigitDataStruct*>(outBPtr);
156           outBPtr = outBPtr + sizeof(AliHLTCaloDigitDataStruct);
157         }
158   
159        mysize += digCount*sizeof(AliHLTCaloDigitDataStruct);
160
161       //HLTDebug("Total number of digits: %d", digCount );
162
163       nRecPoints = fClusterizerPtr->ClusterizeEvent(digCount);
164
165       //HLTDebug("Number of rec points found: %d", nRecPoints);
166
167       fAnalyserPtr->SetCaloClusterData(reinterpret_cast<AliHLTCaloClusterDataStruct*>(outBPtr));
168       
169       fAnalyserPtr->SetRecPointArray(fClusterizerPtr->GetRecPoints(), nRecPoints);
170
171       fAnalyserPtr->SetDigitDataArray(fOutputDigitsArray);
172
173       Int_t nClusters = fAnalyserPtr->CreateClusters(nRecPoints, size, mysize);
174   
175       caloClusterHeaderPtr->fNClusters = nClusters;
176       
177       //HLTDebug("Number of clusters: %d", nRecPoints);
178       
179       AliHLTComponentBlockData bd;
180       FillBlockData( bd );
181       bd.fOffset = offset;
182       bd.fSize = mysize;
183       bd.fDataType = kAliHLTDataTypeCaloCluster | kAliHLTDataOriginPHOS;
184       bd.fSpecification = specification;
185       outputBlocks.push_back( bd );
186     }
187
188   size = mysize;
189   
190   return 0;
191 }
192
193 int 
194 AliHLTCaloClusterizerComponent::Reconfigure(const char* cdbEntry, const char* /*chainId*/)
195 {  
196   // see header file for class documentation
197
198   const char* path="HLT/ConfigPHOS/ClusterizerComponent";
199
200   if (cdbEntry) path = cdbEntry;
201
202   return ConfigureFromCDBTObjString(cdbEntry);
203 }
204
205 int 
206 AliHLTCaloClusterizerComponent::ScanConfigurationArgument(int argc, const char **argv)
207 {
208   //See header file for documentation
209
210   if(argc <= 0) return 0;
211
212   int i=0;
213
214   TString argument=argv[i];
215
216   if (argument.CompareTo("-digitthreshold") == 0)
217     {
218       if (++i >= argc) return -EPROTO;
219       argument = argv[i];
220       fClusterizerPtr->SetEmcMinEnergyThreshold(argument.Atof());
221       return 1;
222     }
223
224   if (argument.CompareTo("-recpointthreshold") == 0)
225     {
226       if (++i >= argc) return -EPROTO;
227       argument = argv[i];
228       fClusterizerPtr->SetEmcClusteringThreshold(argument.Atof());
229       return 1;
230     }
231   return 0;
232 }
233
234 int
235 AliHLTCaloClusterizerComponent::DoInit(int argc, const char** argv )
236 {
237   //See headerfile for documentation
238
239   
240   //
241
242   //  const char *path = "HLT/ConfigPHOS/ClusterizerComponent";
243
244   //  ConfigureFromCDBTObjString(path);
245
246   for (int i = 0; i < argc; i++)
247     {
248       ScanConfigurationArgument(i, argv);
249     }
250
251   return 0;
252 }
253
254 Int_t 
255 AliHLTCaloClusterizerComponent::CompareDigits(const void *dig0, const void *dig1)
256 {
257   // See header file for documentation
258   return (*((AliHLTCaloDigitDataStruct**)(dig0)))->fID - (*((AliHLTCaloDigitDataStruct**)(dig1)))->fID;
259
260   //return (*((AliHLTCaloDigitDataStruct**)(dig0)))->fID - (*((AliHLTCaloDigitDataStruct**)(dig1)))->fID;
261 }