Fast online clusterizer now working (Oystein)
[u/mrichter/AliRoot.git] / HLT / PHOS / AliHLTPHOSClusterizerComponent.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Authors: Ã\98ystein Djuvsland <oysteind@ift.uib.no>                       *
5  *                                                                        *
6  * Permission to use, copy, modify and distribute this software and its   *
7  * documentation strictly for non-commercial purposes is hereby granted   *
8  * without fee, provided that the above copyright notice appears in all   *
9  * copies and that both the copyright notice and this permission notice   *
10  * appear in the supporting documentation. The authors make no claims     *
11  * about the suitability of this software for any purpose. It is          *
12  * provided "as is" without express or implied warranty.                  *
13  **************************************************************************/
14
15
16
17
18 #include "AliHLTPHOSClusterizerComponent.h"
19 #include "AliHLTPHOSClusterizer.h"
20 //#include "AliHLTPHOSPhysicsDefinitions.h"
21 //#include "AliHLTPHOSDefinitions.h"
22 #include "AliHLTPHOSRecPointDataStruct.h"
23 #include "AliHLTPHOSClusterDataStruct.h"
24 #include "AliHLTPHOSRecPointListDataStruct.h"
25 #include "AliHLTPHOSDigitContainerDataStruct.h"
26
27 using namespace std;
28
29
30 const AliHLTComponentDataType AliHLTPHOSClusterizerComponent::fgkInputDataTypes[]=
31   {
32     kAliHLTVoidDataType,{0,"",""}
33   };
34
35 AliHLTPHOSClusterizerComponent gAliHLTPHOSClusterizerComponent;
36
37 //AliHLTPHOSClusterizerComponent::AliHLTPHOSClusterizerComponent(): AliHLTPHOSBase(), AliHLTProcessor(), fClusterizerPtr(0), fOutPtr(0),
38 //                                                               fRecPointStructArrayPtr(0), fRecPointListPtr(0)
39 AliHLTPHOSClusterizerComponent::AliHLTPHOSClusterizerComponent(): AliHLTPHOSProcessor(), fClusterizerPtr(0), fOutPtr(0),
40     fRecPointStructArrayPtr(0), fRecPointListPtr(0)
41 {
42   //Constructor
43 }
44
45 AliHLTPHOSClusterizerComponent::~AliHLTPHOSClusterizerComponent()
46 {
47   //Destructor
48
49   if (fClusterizerPtr)
50     {
51       delete fClusterizerPtr;
52       fClusterizerPtr = 0;
53     }
54
55   if (fRecPointListPtr)
56     {
57       delete fRecPointListPtr;
58       fRecPointListPtr = 0;
59     }
60
61   if (fRecPointStructArrayPtr)
62     {
63       for (int i = 0; i < 1000; i++)
64         {
65           //      fRecPointStructArrayPtr[i].Del();
66         }
67       delete fRecPointStructArrayPtr;
68       fRecPointStructArrayPtr = 0;
69     }
70
71 }
72
73 /*
74 int
75 AliHLTPHOSClusterizerComponent::AliHLTPHOSClusterizerComponent::Deinit()
76 {
77   ////////// PTH WARNING you should Define a class AliHLTPHOSModuleProcessor
78 }
79 */
80
81 // PTH AliHLTPHOSClusterizerComponent::AliHLTPHOSClusterizerComponent(const AliHLTPHOSClusterizerComponent &):AliHLTProcessor(),
82 //                                                                                                     fClusterizerPtr(0),
83 //                                                                                                     fOutPtr(0),
84 //                                                                                                     fRecPointStructArrayPtr(0),
85 //                                                                                                     fRecPointListPtr(0)
86 //{
87 //Copy constructor, not implemented
88 //}
89
90 int
91 AliHLTPHOSClusterizerComponent::Deinit()
92 {
93   //Deinitialization
94
95   if (fClusterizerPtr)
96     {
97       delete fClusterizerPtr;
98       fClusterizerPtr = 0;
99     }
100
101   if (fRecPointListPtr)
102     {
103       delete fRecPointListPtr;
104       fRecPointListPtr = 0;
105     }
106
107   for (int i = 0; i < 1000; i++)
108     {
109       //    fRecPointStructArrayPtr[i].Del();
110     }
111
112   if (fRecPointStructArrayPtr)
113     {
114       for (int i = 0; i < 1000; i++)
115         {
116           //      fRecPointStructArrayPtr[i].Del();
117         }
118       delete fRecPointStructArrayPtr;
119       fRecPointStructArrayPtr = 0;
120     }
121
122   return 0;
123 }
124
125 int
126 AliHLTPHOSClusterizerComponent::DoDeinit()
127 {
128   //Do deinitialization
129   Logging(kHLTLogInfo, "HLT", "PHOS", ",AliHLTPHOSClusterizerComponent DoDeinit");
130
131   return 0;
132 }
133
134
135 const Char_t*
136 AliHLTPHOSClusterizerComponent::GetComponentID()
137 {
138   return "AliHltPhosClusterizer";
139 }
140
141 void
142 AliHLTPHOSClusterizerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
143 {
144   //Get datatypes for input
145   const AliHLTComponentDataType* pType=fgkInputDataTypes;
146   while (pType->fID!=0)
147     {
148       list.push_back(*pType);
149       pType++;
150     }
151 }
152
153 AliHLTComponentDataType
154 AliHLTPHOSClusterizerComponent::GetOutputDataType()
155 {
156   //  return AliHLTPHOSPhysicsDefinitions::fgkAliHLTClusterDataType;
157   return AliHLTPHOSDefinitions::fgkAliHLTClusterDataType;
158 }
159
160 void
161 AliHLTPHOSClusterizerComponent::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier )
162
163 {
164   constBase = 30;
165   inputMultiplier = 0.2;
166 }
167
168 int
169 AliHLTPHOSClusterizerComponent::DoEvent(const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
170                                         AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size,
171                                         std::vector<AliHLTComponentBlockData>& outputBlocks)
172 {
173   //Do event
174
175   UInt_t tSize            = 0;
176   UInt_t offset           = 0;
177   UInt_t mysize           = 0;
178   Int_t nRecPoints        = 0;
179   Int_t nDigits           = 0;
180   Int_t index             = 0;
181   Int_t j =0;
182
183   AliHLTUInt8_t* outBPtr;
184   outBPtr = outputPtr;
185   const AliHLTComponentBlockData* iter = 0;
186   unsigned long ndx;
187
188   AliHLTPHOSDigitContainerDataStruct *digitContainerPtr = 0;
189   
190   //AliHLTPHOSRecPointContainerStruct *recPointContainerPtr = (AliHLTPHOSRecPointContainerStruct*)outBPtr;
191   fClusterizerPtr->SetRecPointContainer((AliHLTPHOSRecPointContainerStruct*)outBPtr);
192   for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
193     {
194       iter = blocks+ndx;
195       digitContainerPtr = reinterpret_cast<AliHLTPHOSDigitContainerDataStruct*>(iter->fPtr);
196       if (iter->fDataType != AliHLTPHOSDefinitions::fgkAliHLTDigitDataType)
197         {
198           //      cout << "Warning: data type is not fgkAliHLTDigitDataType " << endl;
199           continue;
200         }
201       for (Int_t i = 0; i < digitContainerPtr->fNDigits; i++)
202         {
203           if(fNoCrazyness && digitContainerPtr->fDigitDataStruct[i].fCrazyness)
204             continue;
205             
206           fAllDigitsPtr->fDigitDataStruct[j+nDigits].fX = digitContainerPtr->fDigitDataStruct[i].fX;
207           fAllDigitsPtr->fDigitDataStruct[j+nDigits].fZ = digitContainerPtr->fDigitDataStruct[i].fZ;
208           fAllDigitsPtr->fDigitDataStruct[j+nDigits].fAmplitude = digitContainerPtr->fDigitDataStruct[i].fAmplitude;
209           fAllDigitsPtr->fDigitDataStruct[j+nDigits].fTime = digitContainerPtr->fDigitDataStruct[i].fTime;
210          // fAllDigitsPtr->fDigitDataStruct[i+nDigits].fCrazyness = digitContainerPtr->fDigitDataStruct[i].fCrazyness;
211           j++;
212         }
213       nDigits++;
214     }
215
216 // nRecPoints = fClusterizerPtr->CreateRecPointStructArray(fRecPointStructArrayPtr, fRecPointListPtr, index);
217
218   fOutPtr =  (AliHLTPHOSRecPointContainerStruct*)outBPtr;
219   nRecPoints = fClusterizerPtr->ClusterizeEvent();
220   //nRecPoints = fClusterizerPtr->CalculateCenterOfGravity(&fRecPointStructArrayPtr[i]);
221   cout << "Number of clusters found: " << nRecPoints << " extracted from " << nDigits << " digits" << endl;
222
223   mysize = 0;
224   offset = tSize;
225
226   //      fClusterizerPtr->CalculateMoments(&fRecPointStructArrayPtr[i], 0);
227   //     fClusterizerPtr->ClusterizeStruct(&fRecPointStructArrayPtr[i], fOutPtr);
228
229   mysize += sizeof(AliHLTPHOSClusterDataStruct);
230
231   AliHLTComponentBlockData bd;
232   FillBlockData( bd );
233   bd.fOffset = offset;
234   bd.fSize = mysize;
235   // PTH      bd.fDataType = AliHLTPHOSPhysicsDefinitions::fgkAliHLTClusterDataType;
236   bd.fDataType = AliHLTPHOSDefinitions::fgkAliHLTClusterDataType;
237   bd.fSpecification = 0xFFFFFFFF;
238   outputBlocks.push_back( bd );
239
240   tSize += mysize;
241   outBPtr += mysize;
242
243   if ( tSize > size )
244     {
245       Logging( kHLTLogFatal, "HLT::AliHLTPHOSClusterizerComponent::DoEvent", "Too much data",
246                "Data written over allowed buffer. Amount written: %lu, allowed amount: %lu."
247                , tSize, size );
248       return EMSGSIZE;
249     }
250
251
252   size = tSize;
253 // fClusterizerPtr->ResetCellEnergyArray();
254
255   return 0;
256
257 }
258
259 int
260 AliHLTPHOSClusterizerComponent::DoInit(int argc, const char** argv )
261 {
262   //Do initialization
263   fAllDigitsPtr = new AliHLTPHOSDigitContainerDataStruct();
264   fClusterizerPtr = new AliHLTPHOSClusterizer();
265   //fClusterizerPtr->SetNoCrazyness(true);
266   //
267   for (int i = 0; i < argc; i++)
268     {
269       /*
270       if(!strcmp("-threshold", argv[i]))
271       fClusterizerPtr->SetThreshold(atof(argv[i+1]));
272       if(!strcmp("-clusterthreshold", argv[i]))
273       fClusterizerPtr->SetClusterThreshold(atof(argv[i+1]));
274       if(!strcmp("-highgain", argv[i]))
275       fClusterizerPtr->SetHighGainFactor(atof(argv[i+1]));
276       if(!strcmp("-lowgain", argv[i]))
277       fClusterizerPtr->SetLowGainFactor(atof(argv[i+1]));
278       if(!strcmp("-arraysize", argv[i]))
279       fClusterizerPtr->SetArraySize(atoi(argv[i+1]));*/
280     }
281   //  fClusterizerPtr->ResetCellEnergyArray();
282   fRecPointListPtr = new AliHLTPHOSRecPointListDataStruct[N_ZROWS_MOD*N_XCOLUMNS_MOD];
283   fRecPointStructArrayPtr = new AliHLTPHOSRecPointDataStruct[1000];
284   for (int i = 0; i < 1000; i++)
285     {
286       fRecPointStructArrayPtr[i].fMultiplicity = atoi(argv[4])* atoi(argv[4]);
287       // fRecPointStructArrayPtr[i].New();
288     }
289   /*
290   printf("Clusterizer component started with:\n");
291   printf(" Cell threshold:     %f\n", fClusterizerPtr->GetThreshold());
292   printf(" Cluster threshold:  %f\n", fClusterizerPtr->GetClusterThreshold());
293   printf(" High gain factor:   %f\n", fClusterizerPtr->GetHighGainFactor());
294   printf(" Low gain factor:    %f\n", fClusterizerPtr->GetLowGainFactor());
295   printf(" Cluster array size: %d\n\n", fClusterizerPtr->GetArraySize());
296   */
297   return 0;
298 }
299
300 AliHLTComponent*
301 AliHLTPHOSClusterizerComponent::Spawn()
302 {
303   //Spawn a new AliHLTPHOSClusterizerComponent, for HLT framework
304   return new AliHLTPHOSClusterizerComponent();
305 }