added OCDB access for trigger param
[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
f92543f5 221 int i=0;
4d42193f 222
f92543f5 223 TString argument=argv[i];
4d42193f 224
f92543f5 225 if (argument.CompareTo("-digitthreshold") == 0)
4d42193f 226 {
f92543f5 227 if (++i >= argc) return -EPROTO;
228 argument = argv[i];
229 fClusterizerPtr->SetEmcMinEnergyThreshold(argument.Atof());
230 return 1;
4d42193f 231 }
232
f92543f5 233 if (argument.CompareTo("-recpointthreshold") == 0)
4d42193f 234 {
f92543f5 235 if (++i >= argc) return -EPROTO;
236 argument = argv[i];
237 fClusterizerPtr->SetEmcClusteringThreshold(argument.Atof());
238 return 1;
4d42193f 239 }
f92543f5 240
241 if (argument.CompareTo("-cutonsinglecell") == 0)
38a3b2ad 242 {
f92543f5 243 if (++i >= argc) return -EPROTO;
244 argument = argv[i];
245 fAnalyserPtr->SetCutOnSingleCellClusters(true, argument.Atof());
246 return 1;
38a3b2ad 247 }
f92543f5 248 if (argument.CompareTo("-sortbyposition") == 0)
31b89da4 249 {
f92543f5 250 fClusterizerPtr->SetSortDigitsByPosition();
251 return 1;
31b89da4 252 }
f92543f5 253
254 return 0;
4d42193f 255}
256
257int
258AliHLTCaloClusterizerComponent::DoInit(int argc, const char** argv )
259{
f92543f5 260 //See headerfile for documentation
261
262 fDigitsPointerArray = new AliHLTCaloDigitDataStruct*[fCaloConstants->GetNXCOLUMNSMOD()*fCaloConstants->GetNZROWSMOD()];
263
f92543f5 264 fClusterizerPtr->SetDigitArray(fDigitsPointerArray);
265
266 fClusterizerPtr->SetSortDigitsByEnergy();
267
36b00077 268 fClusterizerPtr->SetDetector(TString(fCaloConstants->GetDETNAME()));
269
f92543f5 270 fAnalyserPtr = new AliHLTCaloClusterAnalyser();
271
272 if (fCaloConstants->GetDETNAME() == "PHOS")
273 {
274 fAnalyserPtr->SetClusterType(kPHOSCluster);
275 }
276 else if (fCaloConstants->GetDETNAME() == "EMCAL")
277 {
278 fAnalyserPtr->SetClusterType(kEMCALClusterv1);
279 }
280 else
281 {
282 fAnalyserPtr->SetClusterType(kUndef);
283 }
284 InitialiseGeometry();
285 if (fRecoParamsPtr)
4d42193f 286 {
f92543f5 287 if (!fRecoParamsPtr->GetParametersFromCDB())
288 {
289 fAnalyserPtr->SetRecoParamHandler(fRecoParamsPtr);
290 fClusterizerPtr->SetEmcClusteringThreshold(fRecoParamsPtr->GetRecPointThreshold());
291 fClusterizerPtr->SetEmcMinEnergyThreshold(fRecoParamsPtr->GetRecPointMemberThreshold());
22dba224 292 HLTInfo("Setting thresholds for clusterizer: %f, %f", fRecoParamsPtr->GetRecPointThreshold(), fRecoParamsPtr->GetRecPointMemberThreshold());
f92543f5 293 }
4d42193f 294 }
f92543f5 295 //
4d42193f 296
f92543f5 297 // const char *path = "HLT/ConfigPHOS/ClusterizerComponent";
298
299 // ConfigureFromCDBTObjString(path);
300
301 for (int i = 0; i < argc; i++)
302 {
303 ScanConfigurationArgument(i, argv);
304 }
305
306 return 0;
4d42193f 307}
427c373f 308int AliHLTCaloClusterizerComponent::DoDeinit()
309{
f92543f5 310 // See header file for documentation
311 if (fDigitsPointerArray)
312 {
313 delete [] fDigitsPointerArray;
314 fDigitsPointerArray = 0;
315 }
316 if (fClusterizerPtr)
317 {
318 delete fClusterizerPtr;
319 fClusterizerPtr = 0;
320 }
321 if (fAnalyserPtr)
322 {
323 delete fAnalyserPtr;
324 fAnalyserPtr = 0;
325 }
326 return 0;
427c373f 327}
4d42193f 328
f92543f5 329Int_t
ad44d760 330AliHLTCaloClusterizerComponent::CompareDigits(const void *dig0, const void *dig1)
4d42193f 331{
f92543f5 332 // See header file for documentation
333 return (*((AliHLTCaloDigitDataStruct**)(dig0)))->fID - (*((AliHLTCaloDigitDataStruct**)(dig1)))->fID;
7c80a370 334
f92543f5 335 //return (*((AliHLTCaloDigitDataStruct**)(dig0)))->fID - (*((AliHLTCaloDigitDataStruct**)(dig1)))->fID;
4d42193f 336}