moved some files, added generator function to addtask macro
[u/mrichter/AliRoot.git] / HLT / CALO / AliHLTCaloClusterizerComponent.cxx
CommitLineData
4d42193f 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
4d42193f 17#include "AliHLTCaloClusterizerComponent.h"
18#include "AliHLTCaloClusterizer.h"
f92543f5 19#include "AliHLTCaloClusterAnalyser.h"
4d42193f 20#include "AliHLTCaloRecPointDataStruct.h"
21#include "AliHLTCaloRecPointHeaderStruct.h"
22#include "AliHLTCaloDigitDataStruct.h"
23#include "AliHLTCaloDigitContainerDataStruct.h"
24#include "AliHLTCaloDefinitions.h"
7c80a370 25#include "AliHLTCaloClusterDataStruct.h"
c1e4a18c 26#include "AliHLTCaloRecoParamHandler.h"
ad44d760 27#include "TString.h"
4d42193f 28
29/** @file AliHLTCaloClusterizerComponent.cxx
30 @author Oystein Djuvsland
f92543f5 31 @date
4d42193f 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
c556a27e 41ClassImp(AliHLTCaloClusterizerComponent);
42
f92543f5 43AliHLTCaloClusterizerComponent::AliHLTCaloClusterizerComponent(TString det):
44 AliHLTCaloProcessor(),
45 AliHLTCaloConstantsHandler(det),
46 fDataOrigin('\0'),
47 fAnalyserPtr(0),
48 fRecoParamsPtr(0),
78943659 49 fClusterizerPtr(0),
f92543f5 50 fDigitsPointerArray(0),
51 fOutputDigitsArray(0),
f92543f5 52 fDigitCount(0),
53 fCopyDigitsToOuput(kTRUE)
4d42193f 54{
f92543f5 55 //See headerfile for documentation
56
57
58
4d42193f 59}
60
61AliHLTCaloClusterizerComponent::~AliHLTCaloClusterizerComponent()
62{
f92543f5 63 //See headerfile for documentation
78943659 64 if(fAnalyserPtr)
4d42193f 65 {
78943659 66 delete fAnalyserPtr;
67 fAnalyserPtr = 0;
4d42193f 68 }
4d42193f 69}
70
4d42193f 71int
72AliHLTCaloClusterizerComponent::DoEvent(const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
73 AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size,
74 std::vector<AliHLTComponentBlockData>& outputBlocks)
75{
f92543f5 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++ )
4d42193f 98 {
f92543f5 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 {
22dba224 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 {
f92543f5 121 fDigitsPointerArray[digCount] = digitDataPtr;
122 digCount++;
123 digitDataPtr++;
22dba224 124 }
f92543f5 125 }
126 }
4d42193f 127 }
4d42193f 128
f92543f5 129 if (digCount > 0)
4d42193f 130 {
f92543f5 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
31b89da4 139// qsort(fDigitsPointerArray, digCount, sizeof(AliHLTCaloDigitDataStruct*), CompareDigits);
4d42193f 140
f92543f5 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 );
ad44d760 195 }
196
f92543f5 197 size = mysize;
198
199 return 0;
4d42193f 200}
201
f92543f5 202int
4d42193f 203AliHLTCaloClusterizerComponent::Reconfigure(const char* cdbEntry, const char* /*chainId*/)
f92543f5 204{
205 // see header file for class documentation
4d42193f 206
f92543f5 207 const char* path="HLT/ConfigPHOS/ClusterizerComponent";
4d42193f 208
f92543f5 209 if (cdbEntry) path = cdbEntry;
4d42193f 210
36b00077 211 return ConfigureFromCDBTObjString(path);
4d42193f 212}
213
f92543f5 214int
4d42193f 215AliHLTCaloClusterizerComponent::ScanConfigurationArgument(int argc, const char **argv)
216{
f92543f5 217 //See header file for documentation
4d42193f 218
f92543f5 219 if (argc <= 0) return 0;
4d42193f 220
80156a86 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 }
31b89da4 256 }
f92543f5 257
258 return 0;
4d42193f 259}
260
261int
262AliHLTCaloClusterizerComponent::DoInit(int argc, const char** argv )
263{
f92543f5 264 //See headerfile for documentation
265
26b5a813 266 if (fCaloConstants->GetDETNAME() == "EMCAL")
267
268 fDigitsPointerArray = new AliHLTCaloDigitDataStruct*[2*fCaloConstants->GetNXCOLUMNSMOD()*fCaloConstants->GetNZROWSMOD()];
269 else
f92543f5 270 fDigitsPointerArray = new AliHLTCaloDigitDataStruct*[fCaloConstants->GetNXCOLUMNSMOD()*fCaloConstants->GetNZROWSMOD()];
271
f92543f5 272 fClusterizerPtr->SetDigitArray(fDigitsPointerArray);
273
274 fClusterizerPtr->SetSortDigitsByEnergy();
275
36b00077 276 fClusterizerPtr->SetDetector(TString(fCaloConstants->GetDETNAME()));
277
f92543f5 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)
4d42193f 294 {
f92543f5 295 if (!fRecoParamsPtr->GetParametersFromCDB())
296 {
297 fAnalyserPtr->SetRecoParamHandler(fRecoParamsPtr);
298 fClusterizerPtr->SetEmcClusteringThreshold(fRecoParamsPtr->GetRecPointThreshold());
299 fClusterizerPtr->SetEmcMinEnergyThreshold(fRecoParamsPtr->GetRecPointMemberThreshold());
22dba224 300 HLTInfo("Setting thresholds for clusterizer: %f, %f", fRecoParamsPtr->GetRecPointThreshold(), fRecoParamsPtr->GetRecPointMemberThreshold());
f92543f5 301 }
4d42193f 302 }
f92543f5 303 //
4d42193f 304
f92543f5 305 // const char *path = "HLT/ConfigPHOS/ClusterizerComponent";
306
307 // ConfigureFromCDBTObjString(path);
308
80156a86 309 ScanConfigurationArgument(argc, argv);
f92543f5 310
311 return 0;
4d42193f 312}
427c373f 313int AliHLTCaloClusterizerComponent::DoDeinit()
314{
f92543f5 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;
427c373f 332}
4d42193f 333
f92543f5 334Int_t
ad44d760 335AliHLTCaloClusterizerComponent::CompareDigits(const void *dig0, const void *dig1)
4d42193f 336{
f92543f5 337 // See header file for documentation
338 return (*((AliHLTCaloDigitDataStruct**)(dig0)))->fID - (*((AliHLTCaloDigitDataStruct**)(dig1)))->fID;
7c80a370 339
f92543f5 340 //return (*((AliHLTCaloDigitDataStruct**)(dig0)))->fID - (*((AliHLTCaloDigitDataStruct**)(dig1)))->fID;
4d42193f 341}