1 // $Id: AliHLTCaloClusterizerComponent.cxx 36709 2009-11-12 16:57:55Z odjuvsla $
3 /**************************************************************************
4 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
6 * Authors: Oystein Djuvsland <oysteind@ift.uib.no> *
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 **************************************************************************/
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"
29 /** @file AliHLTCaloClusterizerComponent.cxx
30 @author Oystein Djuvsland
32 @brief A clusterizer component for PHOS HLT
35 // see header file for class documentation
37 // refer to README to build package
39 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
41 ClassImp(AliHLTCaloClusterizerComponent);
43 AliHLTCaloClusterizerComponent::AliHLTCaloClusterizerComponent(TString det):
44 AliHLTCaloProcessor(),
45 AliHLTCaloConstantsHandler(det),
50 fDigitsPointerArray(0),
51 fOutputDigitsArray(0),
53 fCopyDigitsToOuput(kTRUE)
55 //See headerfile for documentation
61 AliHLTCaloClusterizerComponent::~AliHLTCaloClusterizerComponent()
63 //See headerfile for documentation
72 AliHLTCaloClusterizerComponent::DoEvent(const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
73 AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size,
74 std::vector<AliHLTComponentBlockData>& outputBlocks)
76 //See headerfile for documentation
78 if (blocks == 0) return 0;
86 UInt_t availableSize = size;
87 AliHLTUInt8_t* outBPtr;
89 const AliHLTComponentBlockData* iter = 0;
92 UInt_t specification = 0;
94 AliHLTCaloDigitDataStruct *digitDataPtr = 0;
96 // Adding together all the digits, should be put in standalone method
97 for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
101 if (iter->fDataType == (AliHLTCaloDefinitions::fgkDigitDataType|fDataOrigin))
104 // Update the number of digits
105 nDigits = iter->fSize/sizeof(AliHLTCaloDigitDataStruct);
106 availableSize -= iter->fSize;
108 specification = specification|iter->fSpecification;
110 digitDataPtr = reinterpret_cast<AliHLTCaloDigitDataStruct*>(iter->fPtr);
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++)
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)
121 fDigitsPointerArray[digCount] = digitDataPtr;
132 AliHLTCaloClusterHeaderStruct* caloClusterHeaderPtr = reinterpret_cast<AliHLTCaloClusterHeaderStruct*>(outBPtr);
133 caloClusterHeaderPtr->fNDigits = digCount;
135 outBPtr += sizeof(AliHLTCaloClusterHeaderStruct);
136 mysize += sizeof(AliHLTCaloClusterHeaderStruct);
138 // Sort the digit pointers
139 // qsort(fDigitsPointerArray, digCount, sizeof(AliHLTCaloDigitDataStruct*), CompareDigits);
142 if (fCopyDigitsToOuput)
144 // Copy the digits to the output
145 fOutputDigitsArray = reinterpret_cast<AliHLTCaloDigitDataStruct*>(outBPtr);
147 for (Int_t n = 0; n < digCount; n++)
149 memcpy(outBPtr, fDigitsPointerArray[n], sizeof(AliHLTCaloDigitDataStruct));
150 //fOutputDigitsArray[n] = reinterpret_cast<AliHLTCaloDigitDataStruct*>(outBPtr);
151 outBPtr = outBPtr + sizeof(AliHLTCaloDigitDataStruct);
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);
158 // Do the clusterisation
159 nRecPoints = fClusterizerPtr->ClusterizeEvent(digCount);
161 HLTDebug("Number of rec points found: %d", nRecPoints);
163 // Give the cluster output to the analyser
164 fAnalyserPtr->SetCaloClusterData(reinterpret_cast<AliHLTCaloClusterDataStruct*>(outBPtr));
166 // Give the rec points to the analyser (input)
167 fAnalyserPtr->SetRecPointArray(fClusterizerPtr->GetRecPoints(), nRecPoints);
169 // Give the digits to the analyser
170 //fAnalyserPtr->SetDigitDataArray(fOutputDigitsArray);
171 fAnalyserPtr->SetDigitDataArray(fDigitsPointerArray);
173 // Then we create the clusters
174 Int_t nClusters = fAnalyserPtr->CreateClusters(nRecPoints, size, mysize);
178 HLTError("Error in clusterisation");
179 caloClusterHeaderPtr->fNClusters = 0;
183 caloClusterHeaderPtr->fNClusters = nClusters;
186 HLTDebug("Number of clusters: %d", nRecPoints);
188 AliHLTComponentBlockData bd;
192 bd.fDataType = kAliHLTDataTypeCaloCluster | fDataOrigin;
193 bd.fSpecification = specification;
194 outputBlocks.push_back( bd );
203 AliHLTCaloClusterizerComponent::Reconfigure(const char* cdbEntry, const char* /*chainId*/)
205 // see header file for class documentation
207 const char* path="HLT/ConfigPHOS/ClusterizerComponent";
209 if (cdbEntry) path = cdbEntry;
211 return ConfigureFromCDBTObjString(path);
215 AliHLTCaloClusterizerComponent::ScanConfigurationArgument(int argc, const char **argv)
217 //See header file for documentation
219 if (argc <= 0) return 0;
221 for(int i=0;i<argc;i++){
222 TString argument=argv[i];
224 if (argument.CompareTo("-digitthreshold") == 0)
226 if (++i >= argc) return -EPROTO;
228 fClusterizerPtr->SetEmcMinEnergyThreshold(argument.Atof());
231 if (argument.CompareTo("-recpointthreshold") == 0)
233 if (++i >= argc) return -EPROTO;
235 fClusterizerPtr->SetEmcClusteringThreshold(argument.Atof());
238 if (argument.CompareTo("-cutonsinglecell") == 0)
240 if (++i >= argc) return -EPROTO;
242 fAnalyserPtr->SetCutOnSingleCellClusters(true, argument.Atof());
245 if (argument.CompareTo("-emctimegate") == 0)
247 if (++i >= argc) return -EPROTO;
249 fClusterizerPtr->SetEmcTimeGate(argument.Atof());
252 if (argument.CompareTo("-sortbyposition") == 0)
254 fClusterizerPtr->SetSortDigitsByPosition();
262 AliHLTCaloClusterizerComponent::DoInit(int argc, const char** argv )
264 //See headerfile for documentation
266 if (fCaloConstants->GetDETNAME() == "EMCAL")
268 fDigitsPointerArray = new AliHLTCaloDigitDataStruct*[2*fCaloConstants->GetNXCOLUMNSMOD()*fCaloConstants->GetNZROWSMOD()];
270 fDigitsPointerArray = new AliHLTCaloDigitDataStruct*[fCaloConstants->GetNXCOLUMNSMOD()*fCaloConstants->GetNZROWSMOD()];
272 fClusterizerPtr->SetDigitArray(fDigitsPointerArray);
274 fClusterizerPtr->SetSortDigitsByEnergy();
276 fClusterizerPtr->SetDetector(TString(fCaloConstants->GetDETNAME()));
278 fAnalyserPtr = new AliHLTCaloClusterAnalyser();
280 if (fCaloConstants->GetDETNAME() == "PHOS")
282 fAnalyserPtr->SetClusterType(kPHOSCluster);
284 else if (fCaloConstants->GetDETNAME() == "EMCAL")
286 fAnalyserPtr->SetClusterType(kEMCALClusterv1);
290 fAnalyserPtr->SetClusterType(kUndef);
292 InitialiseGeometry();
295 if (!fRecoParamsPtr->GetParametersFromCDB())
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());
305 // const char *path = "HLT/ConfigPHOS/ClusterizerComponent";
307 // ConfigureFromCDBTObjString(path);
309 ScanConfigurationArgument(argc, argv);
313 int AliHLTCaloClusterizerComponent::DoDeinit()
315 // See header file for documentation
316 if (fDigitsPointerArray)
318 delete [] fDigitsPointerArray;
319 fDigitsPointerArray = 0;
323 delete fClusterizerPtr;
335 AliHLTCaloClusterizerComponent::CompareDigits(const void *dig0, const void *dig1)
337 // See header file for documentation
338 return (*((AliHLTCaloDigitDataStruct**)(dig0)))->fID - (*((AliHLTCaloDigitDataStruct**)(dig1)))->fID;
340 //return (*((AliHLTCaloDigitDataStruct**)(dig0)))->fID - (*((AliHLTCaloDigitDataStruct**)(dig1)))->fID;