- adding clusterizer component to the CALO library
[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 <iostream>
18
19 #include "AliHLTCaloClusterizerComponent.h"
20 #include "AliHLTCaloClusterizer.h"
21 #include "AliHLTCaloRecPointDataStruct.h"
22 #include "AliHLTCaloRecPointHeaderStruct.h"
23 #include "AliHLTCaloDigitDataStruct.h"
24 #include "AliHLTCaloDigitContainerDataStruct.h"
25 #include "AliHLTCaloDefinitions.h"
26
27 /** @file   AliHLTCaloClusterizerComponent.cxx
28     @author Oystein Djuvsland
29     @date   
30     @brief  A clusterizer component for PHOS HLT
31 */
32
33 // see header file for class documentation
34 // or
35 // refer to README to build package
36 // or
37 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
38
39 AliHLTCaloClusterizerComponent gAliHLTCaloClusterizerComponent;
40
41 AliHLTCaloClusterizerComponent::AliHLTCaloClusterizerComponent(): 
42   AliHLTPHOSProcessor(), 
43   fAllDigitsPtr(0),
44   fClusterizerPtr(0),
45   fDigitCount(0),
46   fNoCrazyness(0)
47 {
48   //See headerfile for documentation
49 }
50
51 AliHLTCaloClusterizerComponent::~AliHLTCaloClusterizerComponent()
52 {
53   //See headerfile for documentation
54
55   if(fClusterizerPtr)
56     {
57       delete fClusterizerPtr;
58       fClusterizerPtr = 0;
59     }
60   if(fAllDigitsPtr)
61     {
62       delete fAllDigitsPtr;
63       fAllDigitsPtr = 0;
64     }
65 }
66
67
68 int
69 AliHLTCaloClusterizerComponent::Deinit()
70 {
71   //See headerfile for documentation
72
73   if (fClusterizerPtr)
74     {
75       delete fClusterizerPtr;
76       fClusterizerPtr = 0;
77     }
78
79   return 0;
80 }
81
82 void
83 AliHLTCaloClusterizerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
84 {
85   //See headerfile for documentation
86   list.clear();
87   list.push_back(AliHLTPHOSDefinitions::fgkDigitDataType);
88 }
89
90 AliHLTComponentDataType
91 AliHLTCaloClusterizerComponent::GetOutputDataType()
92 {
93   //See headerfile for documentation
94   return AliHLTPHOSDefinitions::fgkRecPointDataType;
95 }
96
97 void
98 AliHLTCaloClusterizerComponent::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier )
99
100 {
101   //See headerfile for documentation
102   constBase = sizeof(AliHLTCaloRecPointHeaderStruct) + sizeof(AliHLTPHOSRecPointDataStruct) + (sizeof(AliHLTCaloDigitDataStruct) << 7); //Reasonable estimate... ;
103   inputMultiplier = 1.5;
104 }
105
106 int
107 AliHLTCaloClusterizerComponent::DoEvent(const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
108                                         AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size,
109                                         std::vector<AliHLTComponentBlockData>& outputBlocks)
110 {
111   //See headerfile for documentation
112
113   if(blocks == 0) return 0;
114   
115   UInt_t offset           = 0;
116   UInt_t mysize           = 0;
117   Int_t nRecPoints        = 0;
118   Int_t nDigits           = 0;
119
120   UInt_t availableSize = size;
121   AliHLTUInt8_t* outBPtr;
122   outBPtr = outputPtr;
123   const AliHLTComponentBlockData* iter = 0;
124   unsigned long ndx;
125   
126   UInt_t specification = 0;
127   
128   AliHLTCaloDigitDataStruct *digitDataPtr = 0;
129
130   AliHLTCaloRecPointHeaderStruct* recPointHeaderPtr = reinterpret_cast<AliHLTCaloRecPointHeaderStruct*>(outBPtr);
131
132   fClusterizerPtr->SetRecPointDataPtr(reinterpret_cast<AliHLTCaloRecPointDataStruct*>(outBPtr+sizeof(AliHLTCaloRecPointHeaderStruct)));
133
134   // Adding together all the digits, should be put in standalone method  
135   for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
136     {
137       iter = blocks+ndx;
138       if (iter->fDataType == AliHLTCaloDefinitions::fgkDigitDataType)
139         {
140           // Get the digit header
141
142           // Update the number of digits
143           nDigits += iter->fSize/sizeof(AliHLTCaloDigitDataStruct);;
144           // Get the specification
145           specification = specification|iter->fSpecification;
146
147           digitDataPtr = reinterpret_cast<AliHLTCaloDigitDataStruct*>(iter->fPtr);
148           for (Int_t i = 0; i < nDigits; i++)
149             {
150               fAllDigitsPtr->fDigitDataStruct[j].fX = digitDataPtr->fX;
151               fAllDigitsPtr->fDigitDataStruct[j].fZ = digitDataPtr->fZ;
152               fAllDigitsPtr->fDigitDataStruct[j].fEnergy = digitDataPtr->fEnergy;
153               //  HLTDebug("Digit energy: %f", digitDataPtr->fEnergy);
154               fAllDigitsPtr->fDigitDataStruct[j].fTime = digitDataPtr->fTime;
155               fAllDigitsPtr->fDigitDataStruct[j].fCrazyness = digitDataPtr->fCrazyness;
156               j++;
157               digitDataPtr++;
158             }
159
160         }
161     }
162   
163   fAllDigitsPtr->fNDigits = j;
164   nRecPoints = fClusterizerPtr->ClusterizeEvent(size, mysize);
165
166   if(nRecPoints == -1)
167     {
168       HLTError("Running out of buffer, exiting for safety.");
169       return -ENOBUFS;
170     }
171
172   recPointHeaderPtr->fNRecPoints = nRecPoints;
173   mysize += sizeof(AliHLTCaloRecPointHeaderStruct);
174   
175   HLTDebug("Number of clusters: %d", nRecPoints);
176
177   AliHLTComponentBlockData bd;
178   FillBlockData( bd );
179   bd.fOffset = offset;
180   bd.fSize = mysize;
181   bd.fDataType = AliHLTPHOSDefinitions::fgkClusterDataType;
182   bd.fSpecification = specification;
183   outputBlocks.push_back( bd );
184      
185   size = mysize;
186   
187   return 0;
188 }
189
190 int 
191 AliHLTCaloClusterizerComponent::Reconfigure(const char* cdbEntry, const char* /*chainId*/)
192 {  
193   // see header file for class documentation
194
195   const char* path="HLT/ConfigPHOS/ClusterizerComponent";
196
197   if (cdbEntry) path = cdbEntry;
198
199   return ConfigureFromCDBTObjString(cdbEntry);
200 }
201
202 int 
203 AliHLTCaloClusterizerComponent::ScanConfigurationArgument(int argc, const char **argv)
204 {
205   //See header file for documentation
206
207   if(argc <= 0) return 0;
208
209   int i=0;
210
211   TString argument=argv[i];
212
213   if (argument.CompareTo("-digitthreshold") == 0)
214     {
215       if (++i >= argc) return -EPROTO;
216       argument = argv[i];
217       fClusterizerPtr->SetEmcMinEnergyThreshold(argument.Atof());
218       return 1;
219     }
220
221   if (argument.CompareTo("-recpointthreshold") == 0)
222     {
223       if (++i >= argc) return -EPROTO;
224       argument = argv[i];
225       fClusterizerPtr->SetEmcClusteringThreshold(argument.Atof());
226       return 1;
227     }
228   return 0;
229 }
230
231 int
232 AliHLTCaloClusterizerComponent::DoInit(int argc, const char** argv )
233 {
234   //See headerfile for documentation
235
236   fAllDigitsPtr = new AliHLTCaloDigitContainerDataStruct();
237   fClusterizerPtr = new AliHLTCaloClusterizer();
238   fClusterizerPtr->SetDigitContainer(fAllDigitsPtr);
239   fNoCrazyness = false;
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 AliHLTComponent*
255 AliHLTCaloClusterizerComponent::Spawn()
256 {
257   //See headerfile for documentation
258
259   return new AliHLTCaloClusterizerComponent();
260 }