Bug fix: When moving from C style pointer based strings to the C++ string
[u/mrichter/AliRoot.git] / HLT / PHOS / AliHLTPHOSRawAnalyzerComponent.cxx
1 /**************************************************************************
2  * This file is property of and copyright by the Experimental Nuclear     *
3  * Physics Group, Dep. of Physics                                         *
4  * University of Oslo, Norway, 2007                                       *
5  *                                                                        * 
6  * Author: Per Thomas Hille <perthi@fys.uio.no> for the ALICE HLT Project.*
7  * Contributors are mentioned in the code where appropriate.              *
8  * Please report bugs to perthi@fys.uio.no                                * 
9  *                                                                        *
10  * Permission to use, copy, modify and distribute this software and its   *
11  * documentation strictly for non-commercial purposes is hereby granted   *
12  * without fee, provided that the above copyright notice appears in all   *
13  * copies and that both the copyright notice and this permission notice   *
14  * appear in the supporting documentation. The authors make no claims     *
15  * about the suitability of this software for any purpose. It is          *
16  * provided "as is" without express or implied warranty.                  *
17  **************************************************************************/
18
19 #include "AliHLTPHOSRawAnalyzerComponent.h"
20 #include <iostream>
21 #include "stdio.h"
22
23 #include "AliRawReaderMemory.h"
24 #include "AliCaloRawStream.h"
25 #include <cstdlib>
26 #include "AliHLTPHOSRcuCellEnergyDataStruct.h"
27 //#include "AliHLTPHOSDataHeaderStruct.h"
28
29
30 const AliHLTComponentDataType AliHLTPHOSRawAnalyzerComponent::inputDataTypes[]={kAliHLTVoidDataType,{0,"",""}}; //'zero' terminated array
31 int   AliHLTPHOSRawAnalyzerComponent::fEventCount = 0; 
32
33
34 AliHLTPHOSRawAnalyzerComponent::AliHLTPHOSRawAnalyzerComponent():AliHLTProcessor(),fEquippmentID(0), fRcuX(0), 
35 fRcuZ(0),fRcuRowOffeset(0), fRcuColOffeset(0),  fModuleID(0), fPHOSRawStream(0), fRawMemoryReader(0), fOutPtr(0)
36 //AliHLTPHOSRawAnalyzerComponent::AliHLTPHOSRawAnalyzerComponent():AliHLTProcessor()
37 {
38
39
40
41 AliHLTPHOSRawAnalyzerComponent::~AliHLTPHOSRawAnalyzerComponent()
42 {
43   if(fRawMemoryReader != 0)
44     {
45       delete fRawMemoryReader;
46     }
47     if(fPHOSRawStream != 0)
48     {
49       delete fPHOSRawStream;
50     }
51
52 }
53
54
55
56 AliHLTPHOSRawAnalyzerComponent::AliHLTPHOSRawAnalyzerComponent(const AliHLTPHOSRawAnalyzerComponent & ) : AliHLTProcessor(), 
57 fEquippmentID(0), fRcuX(0), fRcuZ(0),fRcuRowOffeset(0), fRcuColOffeset(0),  fModuleID(0), fPHOSRawStream(0), fRawMemoryReader(0), fOutPtr(0)
58 {
59 }
60
61
62 int 
63 AliHLTPHOSRawAnalyzerComponent::Deinit()
64 {
65   return 0;
66 }
67
68 int 
69 AliHLTPHOSRawAnalyzerComponent::DoDeinit()
70 {
71   Logging(kHLTLogInfo, "HLT", "PHOS", ",AliHLTPHOSRawAnalyzerComponen DoDeinit");
72
73   if(fRawMemoryReader !=0)
74     {
75       delete fRawMemoryReader;
76     }
77     
78   if(fPHOSRawStream != 0)
79     {
80       delete fPHOSRawStream;
81     }
82   return 0;
83
84 }
85
86 const char* 
87 AliHLTPHOSRawAnalyzerComponent::GetComponentID()
88 {
89   return "AliPhosTestRaw";
90 }
91
92 void
93 AliHLTPHOSRawAnalyzerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
94 {
95   const AliHLTComponentDataType* pType=inputDataTypes;
96   while (pType->fID!=0) {
97     list.push_back(*pType);
98     pType++;
99   }
100 }
101
102 AliHLTComponentDataType 
103 AliHLTPHOSRawAnalyzerComponent::GetOutputDataType()
104 {
105   return AliHLTPHOSDefinitions::gkCellEnergyDataType;
106 }
107
108 void
109 AliHLTPHOSRawAnalyzerComponent::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier )
110
111 {
112   constBase = 30;
113   inputMultiplier = 0.1;
114 }
115
116
117 int AliHLTPHOSRawAnalyzerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
118                                               AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
119                                               AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
120 {
121   Int_t tmpMod            = 0;
122   Int_t tmpRow            = 0;
123   Int_t tmpCol            = 0;
124   Int_t tmpGain           = 0;
125   Int_t sampleCnt         = 0;
126   Int_t processedChannels = 0;
127   UInt_t offset           = 0; 
128   UInt_t mysize           = 0;
129   UInt_t tSize            = 0;
130   Int_t tmpChannelCnt     = 0;
131   AliHLTUInt8_t* outBPtr;
132   outBPtr = outputPtr;
133   const AliHLTComponentBlockData* iter = NULL; 
134   unsigned long ndx;
135
136   if((fEventCount % 100) == 0)
137     {
138       cout << "analyzing event: " << fEventCount << endl;
139     }
140
141   for( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
142     {
143       iter = blocks+ndx;
144       mysize = 0;
145       offset = tSize;
146
147       if ( iter->fDataType != AliHLTPHOSDefinitions::gkDDLPackedRawDataType )
148         {
149           cout << "Warning: data type = is nOT gkDDLPackedRawDataType " << endl;
150           continue;
151         }
152
153       fRawMemoryReader->SetMemory( reinterpret_cast<UChar_t*>( iter->fPtr ), iter->fSize );
154       analyzerPtr->SetData(fTmpChannelData);
155       fOutPtr =  (AliHLTPHOSRcuCellEnergyDataStruct*)outBPtr;
156       mysize += sizeof(AliHLTPHOSRcuCellEnergyDataStruct);
157       fOutPtr->fRcuX = fRcuX;
158       fOutPtr->fRcuZ = fRcuZ;
159       fOutPtr->fModuleID = fModuleID;
160       tmpChannelCnt = 0;
161  
162       if(fEventCount%100 ==0)
163         {
164           cout <<"Analyzing event: " << fEventCount << endl; 
165         }
166  
167       while(fPHOSRawStream->Next())
168         {
169           if (fPHOSRawStream->IsNewHWAddress())
170             {
171               if(processedChannels > 0)
172                 {
173                   analyzerPtr->SetData(fTmpChannelData);
174                   analyzerPtr->Evaluate(0, sampleCnt);
175                   fOutPtr->fCellEnergies[tmpRow][tmpCol][tmpGain] =  analyzerPtr->GetEnergy();
176                   sampleCnt = 0;
177                   fOutPtr->fValidData[tmpChannelCnt].fGain = tmpGain;
178                   fOutPtr->fValidData[tmpChannelCnt].fRow  = tmpRow;
179                   fOutPtr->fValidData[tmpChannelCnt].fCol  = tmpCol; 
180                   tmpChannelCnt ++;
181                   ResetDataPtr();
182                   sampleCnt = 0;
183
184                 }
185
186               tmpMod  =  fPHOSRawStream->GetModule() ;
187               tmpRow  =  fPHOSRawStream->GetRow() - fRcuRowOffeset;
188               tmpCol  =  fPHOSRawStream->GetColumn() - fRcuColOffeset;
189               tmpGain =  fPHOSRawStream->IsLowGain(); 
190               processedChannels ++;
191             }
192           fTmpChannelData[fPHOSRawStream->GetTime()] =  fPHOSRawStream->GetSignal();
193           sampleCnt ++;
194
195         }
196    
197       fOutPtr->fCnt =  tmpChannelCnt;
198       AliHLTComponentBlockData bd;
199       FillBlockData( bd );
200       bd.fOffset = offset;
201       bd.fSize = mysize;
202       bd.fDataType = AliHLTPHOSDefinitions::gkCellEnergyDataType;
203       bd.fSpecification = 0xFFFFFFFF;
204       outputBlocks.push_back( bd );
205       tSize += mysize;
206       outBPtr += mysize;
207       
208       if( tSize > size )
209         {
210           Logging( kHLTLogFatal, "HLT::AliHLTPHOSRawAnalyzerComponent::DoEvent", "Too much data",
211                    "Data written over allowed buffer. Amount written: %lu, allowed amount: %lu."
212                    , tSize, size );
213           return EMSGSIZE;
214         }
215     }
216
217   fEventCount++; 
218   size = tSize;
219   return 0;
220 }//end DoEvent
221
222
223
224 int
225 AliHLTPHOSRawAnalyzerComponent::DoInit( int argc, const char** argv )
226 {
227   int equippmentID = atoi(argv[6]);
228   Reset();
229   fRawMemoryReader = new AliRawReaderMemory();
230   fPHOSRawStream = new  AliCaloRawStream(fRawMemoryReader,"PHOS");
231   fRawMemoryReader->SetEquipmentID(equippmentID); 
232   SetEquippmentID(equippmentID);
233   SetCoordinates(equippmentID);
234   if (argc==0 && argv==NULL) {
235     // this is currently just to get rid of the warning "unused parameter"
236   }
237   return 0;
238 }
239
240 void
241 AliHLTPHOSRawAnalyzerComponent::DumpData()
242 {
243   for(int mod = 0; mod <5; mod ++)
244     {
245       printf("\n ***********  MODULE %d ************\n", mod);
246       for(int row = 0; row < 64; row ++)
247         {
248           for(int col = 0; col < 56; col ++)
249             {
250               if( fMaxValues[mod][row][col][0] != 0)
251                 { 
252                   cout << fMaxValues[mod][row][col][0] << "\t";
253                 }
254             }
255         } 
256     }
257 }
258
259 void
260 AliHLTPHOSRawAnalyzerComponent::DumpChannelData(Double_t *data)
261 {
262       cout << endl;
263       
264       for(int i=0; i< 1008; i++)
265         {
266           if (data[i] != 0)
267             {
268               cout <<i <<"\t";
269             }
270         }
271       cout << endl;
272       
273       for(int i=0; i< 1008; i++)
274         {
275           if (data[i] != 0)
276             {
277               cout <<data[i] <<"\t";
278             }
279         }
280       
281       cout << endl;
282 }
283
284
285
286 void
287 AliHLTPHOSRawAnalyzerComponent::Reset()
288 {
289   for(int mod = 0; mod <5; mod ++)
290     {
291       for(int row = 0; row < 64; row ++)
292         {
293           for(int col = 0; col < 56; col ++)
294             {
295               for(int gain = 0; gain <2; gain ++ )
296                 {
297                   fMaxValues[mod][row][col][gain] = 0;
298                 }
299             }
300         }
301     }
302
303   for(int i = 0 ; i< 1008; i++)
304     {
305       fTmpChannelData[i] = 0;
306     }
307 } // end Reset
308
309 void
310 AliHLTPHOSRawAnalyzerComponent::ResetDataPtr()
311 {
312   for(int i = 0 ; i< 1008; i++)
313     {
314       fTmpChannelData[i] = 0;
315     }
316 }
317
318
319 void 
320 AliHLTPHOSRawAnalyzerComponent::SetEquippmentID(AliHLTUInt32_t id)
321 {
322   fEquippmentID = id;
323 }
324
325 int 
326 AliHLTPHOSRawAnalyzerComponent::GetEquippmentID()
327 {
328   return  fEquippmentID;
329 }
330
331 void 
332 AliHLTPHOSRawAnalyzerComponent::SetCoordinates(AliHLTUInt32_t equippmentID)
333 {
334   int rcuIndex =  (fEquippmentID - 1792)%4;
335   fModuleID = (fEquippmentID  -1792 -rcuIndex)/5;
336
337   if(rcuIndex == 0)
338     {
339       fRcuX = 0; 
340       fRcuZ = 0;
341     }
342
343   if(rcuIndex == 1)
344     {
345       fRcuX = 0; 
346       fRcuZ = 1;
347     }
348  
349   if(rcuIndex == 2)
350     {
351       fRcuX = 1; 
352       fRcuZ = 0;
353     }
354
355
356   if(rcuIndex == 3)
357     {
358       fRcuX = 1; 
359       fRcuZ = 1;
360     }
361
362   fRcuRowOffeset = 32*fRcuX;
363   fRcuColOffeset = 28*fRcuZ;
364
365 }