cbb9547744c78efec78662d7332b07b5b6e2a537
[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
28
29 AliHLTPHOSRawAnalyzerComponent::AliHLTPHOSRawAnalyzerComponent():AliHLTProcessor(),  fEventCount(0),  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(),  fEventCount(0),  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
123   //  AliHLTPHOSRcuCellEnergyDataStruct
124   AliHLTPHOSRcuCellEnergyDataStruct* outPtr; 
125   AliHLTUInt8_t* outBPtr;
126   outBPtr = outputPtr;
127   const AliHLTComponentBlockData* iter = NULL; 
128   unsigned long ndx;
129
130   Reset();
131
132   for( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
133     {
134       iter = blocks+ndx;
135       mysize = 0;
136       offset = tSize;
137
138
139       if ( iter->fDataType != AliHLTPHOSDefinitions::gkDDLPackedRawDataType )
140         {
141           cout << "Warning: data type = is nOT gkDDLPackedRawDataType " << endl;
142           continue;
143         }
144
145       fRawMemoryReader->SetMemory( reinterpret_cast<UChar_t*>( iter->fPtr ), iter->fSize );
146       analyzerPtr->SetData(fTmpChannelData);
147       outPtr =  (AliHLTPHOSRcuCellEnergyDataStruct*)outBPtr;
148       mysize += sizeof(AliHLTPHOSRcuCellEnergyDataStruct);
149       outPtr->fRcuX = fRcuX;
150       outPtr->fRcuZ = fRcuZ;
151       outPtr->fModuleID = fModuleID;
152       outPtr->fCnt = 0;
153
154       while(fPHOSRawStream->Next())
155         {
156           if (fPHOSRawStream->IsNewHWAddress())
157             {
158               if(processedChannels > 0)
159                 {
160                   analyzerPtr->SetData(fTmpChannelData);
161                   //              cout << "sampleCnt = " << sampleCnt << endl;
162                   analyzerPtr->Evaluate(0, sampleCnt);
163                   fMaxValues[tmpMod][tmpRow][tmpCol][tmpGain] = analyzerPtr->GetEnergy();
164
165                   //      outPtr->fValidData[fCnt] = ;
166                   outPtr->fCnt ++;
167                   //fCnt;
168                   outPtr->fCellEnergies[tmpRow - fRcuRowOffeset][tmpCol - fRcuColOffeset][tmpGain] =  fMaxValues[tmpMod][tmpRow][tmpCol][tmpGain];
169                   sampleCnt = 0;
170                   ResetDataPtr(); 
171
172                 }
173
174               tmpMod  =  fPHOSRawStream->GetModule();
175               tmpRow  =  fPHOSRawStream->GetRow();
176               tmpCol  =  fPHOSRawStream->GetColumn();
177               tmpGain =  fPHOSRawStream->IsLowGain(); 
178               
179               processedChannels ++;
180             }
181           fTmpChannelData[fPHOSRawStream->GetTime()] =  fPHOSRawStream->GetSignal();
182           sampleCnt ++;
183         }
184       
185  
186       AliHLTComponentBlockData bd;
187       FillBlockData( bd );
188       bd.fOffset = offset;
189       bd.fSize = mysize;
190       bd.fDataType = AliHLTPHOSDefinitions::gkCellEnergyDataType;
191       bd.fSpecification = 0xFFFFFFFF;
192       outputBlocks.push_back( bd );
193       tSize += mysize;
194       outBPtr += mysize;
195       
196       if( tSize > size )
197         {
198           Logging( kHLTLogFatal, "HLT::AliHLTPHOSRawAnalyzerComponent::DoEvent", "Too much data",
199                    "Data written over allowed buffer. Amount written: %lu, allowed amount: %lu."
200                    , tSize, size );
201           return EMSGSIZE;
202         }
203       
204     }
205
206   fEventCount++; 
207   size = tSize;
208   return 0;
209 }//end DoEvent
210
211
212
213 int
214 AliHLTPHOSRawAnalyzerComponent::DoInit( int argc, const char** argv )
215 {
216   int equippmentID = atoi(argv[6]);
217   Reset();
218   fRawMemoryReader = new AliRawReaderMemory();
219   fPHOSRawStream = new  AliCaloRawStream(fRawMemoryReader,"PHOS");
220   fRawMemoryReader->SetEquipmentID(equippmentID); 
221   SetEquippmentID(equippmentID);
222   SetCoordinates(equippmentID);
223   if (argc==0 && argv==NULL) {
224     // this is currently just to get rid of the warning "unused parameter"
225   }
226   return 0;
227 }
228
229 void
230 AliHLTPHOSRawAnalyzerComponent::DumpData()
231 {
232   for(int mod = 0; mod <5; mod ++)
233     {
234       printf("\n ***********  MODULE %d ************\n", mod);
235       for(int row = 0; row < 64; row ++)
236         {
237           for(int col = 0; col < 56; col ++)
238             {
239               if( fMaxValues[mod][row][col][0] != 0)
240                 { 
241                   cout << fMaxValues[mod][row][col][0] << "\t";
242                 }
243             }
244         } 
245     }
246 }
247
248
249 void
250 AliHLTPHOSRawAnalyzerComponent::Reset()
251 {
252   for(int mod = 0; mod <5; mod ++)
253     {
254       for(int row = 0; row < 64; row ++)
255         {
256           for(int col = 0; col < 56; col ++)
257             {
258               for(int gain = 0; gain <2; gain ++ )
259                 {
260                   fMaxValues[mod][row][col][gain] = 0;
261                 }
262             }
263         }
264     }
265
266   for(int i = 0 ; i< 1008; i++)
267     {
268       fTmpChannelData[i] = 0;
269     }
270 } // end Reset
271
272 void
273 AliHLTPHOSRawAnalyzerComponent::ResetDataPtr()
274 {
275   for(int i = 0 ; i< 1008; i++)
276     {
277       fTmpChannelData[i] = 0;
278     }
279 }
280
281
282 void 
283 AliHLTPHOSRawAnalyzerComponent::SetEquippmentID(AliHLTUInt32_t id)
284 {
285   fEquippmentID = id;
286 }
287
288 int 
289 AliHLTPHOSRawAnalyzerComponent::GetEquippmentID()
290 {
291   return  fEquippmentID;
292 }
293
294 void 
295 AliHLTPHOSRawAnalyzerComponent::SetCoordinates(AliHLTUInt32_t equippmentID)
296 {
297   int rcuIndex =  (fEquippmentID - 1792)%4;
298   fModuleID = (fEquippmentID  -1792 -rcuIndex)/5;
299
300   if(rcuIndex == 0)
301     {
302       fRcuX = 0; 
303       fRcuZ = 0;
304     }
305
306   if(rcuIndex == 1)
307     {
308       fRcuX = 0; 
309       fRcuZ = 1;
310     }
311  
312   if(rcuIndex == 2)
313     {
314       fRcuX = 1; 
315       fRcuZ = 0;
316     }
317
318
319   if(rcuIndex == 3)
320     {
321       fRcuX = 1; 
322       fRcuZ = 1;
323     }
324
325   fRcuRowOffeset = 32*fRcuX;
326   fRcuColOffeset = 28*fRcuZ;
327
328 }