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