Roll back
[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 "AliHLTCaloRecoParamHandler.h"
27 #include "TString.h"
28
29 /** @file   AliHLTCaloClusterizerComponent.cxx
30     @author Oystein Djuvsland
31     @date
32     @brief  A clusterizer component for PHOS HLT
33 */
34
35 // see header file for class documentation
36 // or
37 // refer to README to build package
38 // or
39 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
40
41 ClassImp(AliHLTCaloClusterizerComponent);
42
43 AliHLTCaloClusterizerComponent::AliHLTCaloClusterizerComponent(TString det):
44         AliHLTCaloProcessor(),
45         AliHLTCaloConstantsHandler(det),
46         fDataOrigin('\0'),
47         fAnalyserPtr(0),
48         fRecoParamsPtr(0),
49         fClusterizerPtr(0),
50         fDigitsPointerArray(0),
51         fOutputDigitsArray(0),
52         fDigitCount(0),
53         fCopyDigitsToOuput(kTRUE)
54 {
55     //See headerfile for documentation
56
57
58
59 }
60
61 AliHLTCaloClusterizerComponent::~AliHLTCaloClusterizerComponent()
62 {
63     //See headerfile for documentation
64     if(fAnalyserPtr)
65     {
66       delete fAnalyserPtr;
67       fAnalyserPtr = 0;
68     }
69 }
70
71 int
72 AliHLTCaloClusterizerComponent::DoEvent(const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
73                                         AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size,
74                                         std::vector<AliHLTComponentBlockData>& outputBlocks)
75 {
76     //See headerfile for documentation
77
78     if (blocks == 0) return 0;
79
80     UInt_t offset           = 0;
81     UInt_t mysize           = 0;
82     Int_t nRecPoints        = 0;
83     Int_t nDigits           = 0;
84     Int_t digCount          = 0;
85
86     UInt_t availableSize = size;
87     AliHLTUInt8_t* outBPtr;
88     outBPtr = outputPtr;
89     const AliHLTComponentBlockData* iter = 0;
90     unsigned long ndx;
91
92     UInt_t specification = 0;
93
94     AliHLTCaloDigitDataStruct *digitDataPtr = 0;
95
96     // Adding together all the digits, should be put in standalone method
97     for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
98     {
99         iter = blocks+ndx;
100
101         if (iter->fDataType == (AliHLTCaloDefinitions::fgkDigitDataType|fDataOrigin))
102         {
103
104             // Update the number of digits
105             nDigits = iter->fSize/sizeof(AliHLTCaloDigitDataStruct);
106             availableSize -= iter->fSize;
107
108             specification = specification|iter->fSpecification;
109
110             digitDataPtr = reinterpret_cast<AliHLTCaloDigitDataStruct*>(iter->fPtr);
111
112             // We copy the digits to the digit buffer used by the clusterizer
113             // This is convinient since we want the digits from all DDLs before starting
114             // Could be changed if this is a bottle neck.
115             for (Int_t i = 0; i < nDigits; i++)
116             {
117                // If we have a digit based on a low gain channel, but there has been no high gain channel, 
118                // we shouldn't use it since we are then very sensitive to noise (e.g. for PHOS 1 LG ADC count = 40 MeV)
119                if(digitDataPtr->fHgPresent)
120                {
121                 fDigitsPointerArray[digCount] = digitDataPtr;
122                 digCount++;
123                 digitDataPtr++;
124                }
125             }
126         }
127     }
128
129     if (digCount > 0)
130     {
131
132         AliHLTCaloClusterHeaderStruct* caloClusterHeaderPtr = reinterpret_cast<AliHLTCaloClusterHeaderStruct*>(outBPtr);
133         caloClusterHeaderPtr->fNDigits = digCount;
134
135         outBPtr += sizeof(AliHLTCaloClusterHeaderStruct);
136         mysize += sizeof(AliHLTCaloClusterHeaderStruct);
137
138         // Sort the digit pointers
139 //      qsort(fDigitsPointerArray, digCount, sizeof(AliHLTCaloDigitDataStruct*), CompareDigits);
140
141
142         if (fCopyDigitsToOuput)
143         {
144             // Copy the digits to the output
145             fOutputDigitsArray = reinterpret_cast<AliHLTCaloDigitDataStruct*>(outBPtr);
146
147             for (Int_t n = 0; n < digCount; n++)
148             {
149                 memcpy(outBPtr, fDigitsPointerArray[n], sizeof(AliHLTCaloDigitDataStruct));
150                 //fOutputDigitsArray[n] = reinterpret_cast<AliHLTCaloDigitDataStruct*>(outBPtr);
151                 outBPtr = outBPtr + sizeof(AliHLTCaloDigitDataStruct);
152             }
153         }
154         
155         // Update the size of the output we have used, needs to be removed if we don't push the digits
156         mysize += digCount*sizeof(AliHLTCaloDigitDataStruct);
157
158         // Do the clusterisation
159         nRecPoints = fClusterizerPtr->ClusterizeEvent(digCount);
160
161         HLTDebug("Number of rec points found: %d", nRecPoints);
162
163         // Give the cluster output to the analyser
164         fAnalyserPtr->SetCaloClusterData(reinterpret_cast<AliHLTCaloClusterDataStruct*>(outBPtr));
165
166         // Give the rec points to the analyser (input)
167         fAnalyserPtr->SetRecPointArray(fClusterizerPtr->GetRecPoints(), nRecPoints);
168
169         // Give the digits to the analyser
170         //fAnalyserPtr->SetDigitDataArray(fOutputDigitsArray);
171         fAnalyserPtr->SetDigitDataArray(fDigitsPointerArray);
172
173         // Then we create the clusters
174         Int_t nClusters = fAnalyserPtr->CreateClusters(nRecPoints, size, mysize);
175
176         if (nClusters < 0)
177         {
178             HLTError("Error in clusterisation");
179             caloClusterHeaderPtr->fNClusters = 0;
180         }
181         else
182         {
183             caloClusterHeaderPtr->fNClusters = nClusters;
184         }
185
186         HLTDebug("Number of clusters: %d", nRecPoints);
187
188         AliHLTComponentBlockData bd;
189         FillBlockData( bd );
190         bd.fOffset = offset;
191         bd.fSize = mysize;
192         bd.fDataType = kAliHLTDataTypeCaloCluster | fDataOrigin;
193         bd.fSpecification = specification;
194         outputBlocks.push_back( bd );
195     }
196
197     size = mysize;
198
199     return 0;
200 }
201
202 int
203 AliHLTCaloClusterizerComponent::Reconfigure(const char* cdbEntry, const char* /*chainId*/)
204 {
205     // see header file for class documentation
206
207     const char* path="HLT/ConfigPHOS/ClusterizerComponent";
208
209     if (cdbEntry) path = cdbEntry;
210
211     return ConfigureFromCDBTObjString(path);
212 }
213
214 int
215 AliHLTCaloClusterizerComponent::ScanConfigurationArgument(int argc, const char **argv)
216 {
217     //See header file for documentation
218
219     if (argc <= 0) return 0;
220
221     for(int i=0;i<argc;i++){
222       TString argument=argv[i];
223
224       if (argument.CompareTo("-digitthreshold") == 0)
225         {
226           if (++i >= argc) return -EPROTO;
227           argument = argv[i];
228           fClusterizerPtr->SetEmcMinEnergyThreshold(argument.Atof());
229         }
230
231       if (argument.CompareTo("-recpointthreshold") == 0)
232         {
233           if (++i >= argc) return -EPROTO;
234           argument = argv[i];
235           fClusterizerPtr->SetEmcClusteringThreshold(argument.Atof());
236         }
237
238       if (argument.CompareTo("-cutonsinglecell") == 0)
239         {
240           if (++i >= argc) return -EPROTO;
241           argument = argv[i];
242           fAnalyserPtr->SetCutOnSingleCellClusters(true, argument.Atof());
243         }
244
245       if (argument.CompareTo("-emctimegate") == 0)
246         {
247           if (++i >= argc) return -EPROTO;
248           argument = argv[i];
249           fClusterizerPtr->SetEmcTimeGate(argument.Atof());
250         }
251
252       if (argument.CompareTo("-sortbyposition") == 0)
253         {
254           fClusterizerPtr->SetSortDigitsByPosition();
255         }
256     }
257
258     return 0;
259 }
260
261 int
262 AliHLTCaloClusterizerComponent::DoInit(int argc, const char** argv )
263 {
264     //See headerfile for documentation
265
266   if (fCaloConstants->GetDETNAME() == "EMCAL") 
267     
268     fDigitsPointerArray = new AliHLTCaloDigitDataStruct*[2*fCaloConstants->GetNXCOLUMNSMOD()*fCaloConstants->GetNZROWSMOD()];
269   else 
270     fDigitsPointerArray = new AliHLTCaloDigitDataStruct*[fCaloConstants->GetNXCOLUMNSMOD()*fCaloConstants->GetNZROWSMOD()];
271
272     fClusterizerPtr->SetDigitArray(fDigitsPointerArray);
273
274     fClusterizerPtr->SetSortDigitsByEnergy();
275
276     fClusterizerPtr->SetDetector(TString(fCaloConstants->GetDETNAME()));
277     
278     fAnalyserPtr = new AliHLTCaloClusterAnalyser();
279
280     if (fCaloConstants->GetDETNAME() == "PHOS")
281     {
282         fAnalyserPtr->SetClusterType(kPHOSCluster);
283     }
284     else if (fCaloConstants->GetDETNAME() == "EMCAL")
285     {
286         fAnalyserPtr->SetClusterType(kEMCALClusterv1);
287     }
288     else
289     {
290         fAnalyserPtr->SetClusterType(kUndef);
291     }
292     InitialiseGeometry();
293     if (fRecoParamsPtr)
294     {
295         if (!fRecoParamsPtr->GetParametersFromCDB())
296         {
297             fAnalyserPtr->SetRecoParamHandler(fRecoParamsPtr);
298             fClusterizerPtr->SetEmcClusteringThreshold(fRecoParamsPtr->GetRecPointThreshold());
299             fClusterizerPtr->SetEmcMinEnergyThreshold(fRecoParamsPtr->GetRecPointMemberThreshold());
300             HLTInfo("Setting thresholds for clusterizer: %f, %f", fRecoParamsPtr->GetRecPointThreshold(), fRecoParamsPtr->GetRecPointMemberThreshold());
301         }
302     }
303     //
304
305     //  const char *path = "HLT/ConfigPHOS/ClusterizerComponent";
306
307     //  ConfigureFromCDBTObjString(path);
308
309     ScanConfigurationArgument(argc, argv);
310
311     return 0;
312 }
313 int AliHLTCaloClusterizerComponent::DoDeinit()
314 {
315     // See header file for documentation
316     if (fDigitsPointerArray)
317     {
318         delete []  fDigitsPointerArray;
319         fDigitsPointerArray = 0;
320     }
321     if (fClusterizerPtr)
322     {
323         delete fClusterizerPtr;
324         fClusterizerPtr = 0;
325     }
326     if (fAnalyserPtr)
327     {
328         delete fAnalyserPtr;
329         fAnalyserPtr = 0;
330     }
331     return 0;
332 }
333
334 Int_t
335 AliHLTCaloClusterizerComponent::CompareDigits(const void *dig0, const void *dig1)
336 {
337     // See header file for documentation
338     return (*((AliHLTCaloDigitDataStruct**)(dig0)))->fID - (*((AliHLTCaloDigitDataStruct**)(dig1)))->fID;
339
340     //return (*((AliHLTCaloDigitDataStruct**)(dig0)))->fID - (*((AliHLTCaloDigitDataStruct**)(dig1)))->fID;
341 }