Minor changes needed for debugging purphoses
[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 "AliHLTPHOSRawAnalyzer.h"
20 #include "AliHLTPHOSRawAnalyzerComponent.h"
21 #include "AliHLTPHOSRcuCellEnergyDataStruct.h"
22 #include "AliHLTPHOSRcuChannelDataStruct.h"
23 #include "AliHLTDDLDecoder.h"
24 #include "AliHLTAltroData.h"
25 #include "AliHLTPHOSMapper.h"
26 #include "AliHLTAltroBunch.h"
27 #include "AliHLTPHOSSanityInspector.h"
28 #include "AliHLTPHOSBaseline.h"
29 #include "TFile.h"
30 #include "TTree.h"
31 #include "TClonesArray.h"
32 //using namespace std;
33
34 AliHLTPHOSRawAnalyzerComponent::AliHLTPHOSRawAnalyzerComponent():AliHLTPHOSRcuProcessor(), fAnalyzerPtr(0), 
35                                                                  fSendChannelData(kFALSE),fOutPtr(0), fMapperPtr(0), fDecoderPtr(0), 
36                                                                  fAltroDataPtr(0), fAltroBunchPtr(0), fUseBaselineSubtraction(false), fDebugCnt(0)
37 {
38   fMapperPtr = new AliHLTPHOSMapper();
39   
40
41
42
43 AliHLTPHOSRawAnalyzerComponent::~AliHLTPHOSRawAnalyzerComponent()
44 {
45   delete  fMapperPtr;
46 }
47
48
49 int 
50 AliHLTPHOSRawAnalyzerComponent::Deinit()
51 {
52   Logging(kHLTLogInfo, "HLT", "PHOS", ",AliHLTPHOSRawAnalyzerComponen Deinit");
53   return 0;
54 }
55
56
57 const char* 
58 AliHLTPHOSRawAnalyzerComponent::GetComponentID()
59 {
60   return "AliPhosTestRaw";
61 }
62
63
64 void
65 AliHLTPHOSRawAnalyzerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
66 {
67   const AliHLTComponentDataType* pType=fgkInputDataTypes;
68   while (pType->fID!=0) {
69     list.push_back(*pType);
70     pType++;
71   }
72 }
73
74
75 AliHLTComponentDataType 
76 AliHLTPHOSRawAnalyzerComponent::GetOutputDataType()
77 {
78   return AliHLTPHOSDefinitions::fgkCellEnergyDataType;
79 }
80
81
82 void
83 AliHLTPHOSRawAnalyzerComponent::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier )
84
85 {
86   constBase = 30;
87   inputMultiplier = 1.2;
88 }
89
90
91 //int 
92 //AliHLTPHOSRawAnalyzerComponent::DoEvent( const AliHLTComponentEventD  //  AliHLTPHOSRcuCellEnergyDebugDataStruct* fOutPtr;ata& evtData, const AliHLTComponentBlockData* blocks, AliHLTComponentTriggerData& trigData, 
93 //                                       AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
94 int 
95 AliHLTPHOSRawAnalyzerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, AliHLTComponentTriggerData& trigData, 
96                                          AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
97 {
98   UInt_t offset           = 0; 
99   UInt_t mysize           = 0;
100   UInt_t tSize            = 0;
101   Float_t baseline = 0;
102   AliHLTUInt8_t* outBPtr;
103   AliHLTAltroBunch *bunchPtr;
104   outBPtr = outputPtr;
105   const AliHLTComponentBlockData* iter = NULL; 
106   unsigned long ndx;
107   
108   //  printf("\n% \n", ndx);
109
110   //  cout << "evtData block count =   " <<  evtData.fBlockCnt  << endl;
111
112
113   fDebugCnt++;
114   
115
116   for( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
117     {
118       //      cout <<"TP0"<< endl;
119  
120      Int_t tmpChannelCnt     = 0;
121       iter = blocks+ndx;
122       mysize = 0;
123       offset = tSize;
124       //      cout <<"TP1"<< endl;
125       Int_t *dt = (Int_t*)(reinterpret_cast<UChar_t*>( iter->fPtr ));
126       //      cout <<"TP2"<< endl;
127       Int_t crazyness = 0;
128
129       if ( iter->fDataType != AliHLTPHOSDefinitions::fgkDDLPackedRawDataType )
130         {
131           //      cout <<"WARNING: not AliHLTPHOSDefinitions::fgkDDLPackedRawDataType  "  << endl;
132           //      cout <<  "equippment "<< fkEquippmentID << " Event count =" <<  fDebugCnt   <<"    AliHLTPHOSRawAnalyzerComponent::DoEvent ,  ERROR"<< endl;
133           continue; 
134
135           //      if(fPhosEventCount < 10)
136           //        { 
137           //          continue; //!!!!! Commented out to read TPC data, remember to put back
138           //        }
139         }
140       else
141         {
142           //      cout << "equippment " << fkEquippmentID << " Event count =" <<  fDebugCnt  << " Dat type is:  AliHLTPHOSDefinitions::fgkDDLPackedRawDataType" << endl;
143         }
144       
145       if( fPhosEventCount%100 == 0)
146         {
147           cout << "event count = "<< fPhosEventCount <<endl;
148           
149         } 
150
151     
152       /*
153       printf("\Common data header for equippment %d\n",  fkEquippmentID);
154       printf("Event#: %d -- RCU X: %d - RCU Z: %d\n\n", fPhosEventCount, fRcuX, fRcuZ);
155
156       for(Int_t n = 0; n < 8; n++)
157         {
158           printf("CDH(%d): 0x%X\n", n, dt[n]);
159         }
160
161       printf("\n");    
162       */
163     
164
165       fDecoderPtr->SetMemory(reinterpret_cast<UChar_t*>( iter->fPtr ), iter->fSize);
166       //    fDecoderPtr->SetMemory2(reinterpret_cast<UChar_t*>( iter->fPtr ), iter->fSize);
167       fDecoderPtr->Decode();
168   
169       fOutPtr =  (AliHLTPHOSRcuCellEnergyDataStruct*)outBPtr;
170       fOutPtr->fRcuX = fRcuX;
171       fOutPtr->fRcuZ = fRcuZ;
172       fOutPtr->fModuleID =fModuleID;
173       
174       while( fDecoderPtr->NextChannel(fAltroDataPtr) == true )
175         {
176           
177           //      if(fAltroDataPtr->fDataSize != 72)
178           //      if(fAltroDataPtr->fDataSize != 142)
179           if(fAltroDataPtr->fDataSize != (fNTotalSamples +2))
180             {
181               cout << "Error, fDataSize = " << fAltroDataPtr->fDataSize << endl;
182               continue;
183             }
184
185           crazyness = fSanityInspectorPtr->CheckInsanity(fAltroDataPtr->fData, fAltroDataPtr->fDataSize - 2);
186           fAnalyzerPtr->SetData(fAltroDataPtr->fData);  //  AliHLTPHOSRcuCellEnergyDebugDataStruct* fOutPtr;
187           fAnalyzerPtr->Evaluate(0, fAltroDataPtr->fDataSize -2);  
188
189           fOutPtr->fValidData[tmpChannelCnt].fZ  = fMapperPtr->hw2geomapPtr[fAltroDataPtr->fHadd].zRow;
190           fOutPtr->fValidData[tmpChannelCnt].fX  = fMapperPtr->hw2geomapPtr[fAltroDataPtr->fHadd].xCol; 
191           fOutPtr->fValidData[tmpChannelCnt].fGain  = fMapperPtr->hw2geomapPtr[fAltroDataPtr->fHadd].gain; 
192           if(fUseBaselineSubtraction)
193            {
194              baseline = fBaselines[fOutPtr->fValidData[tmpChannelCnt].fX][fOutPtr->fValidData[tmpChannelCnt].fZ][ fOutPtr->fValidData[tmpChannelCnt].fGain];
195            }
196           fOutPtr->fValidData[tmpChannelCnt].fEnergy  = (float)fAnalyzerPtr->GetEnergy() - baseline;
197           fOutPtr->fValidData[tmpChannelCnt].fTime    = (float)fAnalyzerPtr->GetTiming();
198           fOutPtr->fValidData[tmpChannelCnt].fCrazyness = (int)crazyness;
199           for(Int_t sample = 0; sample < fNTotalSamples; sample++)
200             {
201               //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
202               (fOutPtr->fValidData[tmpChannelCnt].fData)[sample] = fAltroDataPtr->fData[sample] - (int)baseline;
203             }
204           
205           tmpChannelCnt ++;
206           
207         }
208       fOutPtr->fCnt =  tmpChannelCnt;
209       mysize += sizeof(AliHLTPHOSRcuCellEnergyDataStruct);
210
211       AliHLTComponentBlockData bd;
212       FillBlockData( bd );
213       bd.fOffset = offset;
214       bd.fSize = mysize;
215  
216       bd.fDataType = AliHLTPHOSDefinitions::fgkCellEnergyDataType;
217       bd.fSpecification = 0xFFFFFFFF;
218       outputBlocks.push_back( bd );
219  
220       tSize += mysize;
221       outBPtr += mysize;
222       
223       if( tSize > size )
224         {
225           cout <<"kHLTLogFatal, HLT::AliHLTPHOSRawAnalyzerComponent::DoEvent Too much dataData written over allowed buffer. Amount written:"
226                << tSize << " allowed" << size << endl;
227           Logging( kHLTLogFatal, "HLT::AliHLTPHOSRawAnalyzerComponent::DoEvent", "Too much data",
228                    "Data written over allowed buffer. Amount written: %lu, allowed amount: %lu."
229                    , tSize, size );
230           return EMSGSIZE;
231         }
232         
233       //   fDecoderPtr->GetFailureRate();
234      
235     }
236   
237
238   fPhosEventCount++; 
239
240   //  cout << "event cunt =" <<   fPhosEventCount << endl;
241
242   if(fPrintInfo == kTRUE)
243     {
244      if(fPhosEventCount%fPrintInfoFrequncy == 0)
245         {
246           cout <<"Analyzing event " <<  fPhosEventCount  << "for Equippment " << fkEquippmentID << endl; 
247         }  
248     }
249
250   return 0;
251 }//end DoEvent
252
253
254 int
255 AliHLTPHOSRawAnalyzerComponent::DoInit( int argc, const char** argv )
256 {
257   cout <<"AliHLTPHOSRawAnalyzerComponent::DoInit( int argc, const char** argv ) "<< endl;
258   fAltroDataPtr = new AliHLTAltroData();
259   fAltroBunchPtr = new AliHLTAltroBunch();
260   fDecoderPtr = new AliHLTDDLDecoder();
261   fSanityInspectorPtr = new AliHLTPHOSSanityInspector();
262   fSendChannelData = kFALSE;
263   fPrintInfo = kFALSE;
264   Reset();
265   int iResult=0;
266   TString argument="";
267   iResult = ScanArguments(argc, argv);
268
269   for(int i = 0; i < argc; i++)
270     {
271       if(!strcmp("-baselinefile", argv[i]))
272         {
273           cout << "Getting baselines from " << argv[i+1] << endl;
274           SetBaselines(argv[i+1]);
275         }
276     }
277  
278
279   if(fIsSetEquippmentID == kFALSE)
280     {
281       cout << "The argument equippmentID is not set: set it with a component argumet like this: -equippmentID  <number>" << endl;
282       Logging( kHLTLogFatal, "HLT::AliHLTPHOSRcuHistogramProducerComponent::DoInt( int argc, const char** argv )", "Missing argument",
283                "The argument equippmentID is not set: set it with a component argumet like this: -equippmentID  <number>");
284       iResult = -3; 
285     }
286   else
287     {
288       iResult = 0; 
289       //      fRawMemoryReader->SetEquipmentID(fkEquippmentID);
290     }
291   
292   //  return iResult;
293   //  return 0;
294   return iResult;
295 }
296
297
298 void
299 AliHLTPHOSRawAnalyzerComponent::Reset()
300 {
301   for(int mod = 0; mod < N_MODULES; mod ++)
302     {
303       for(int row = 0; row < N_ZROWS_MOD; row ++)
304         {
305           for(int col = 0; col < N_XCOLUMNS_MOD; col ++)
306             {
307               for(int gain = 0; gain < N_GAINS; gain ++ )
308                 {
309                   fMaxValues[mod][row][col][gain] = 0;
310                 }
311             }
312         }
313     }
314   
315   ResetDataPtr(0, ALTRO_MAX_SAMPLES);
316
317 } // end Reset
318
319
320 void
321 AliHLTPHOSRawAnalyzerComponent::ResetDataPtr(int startindex, int sampleCnt)
322 {
323   for(int i = startindex ; i< sampleCnt; i++)
324     {
325       fTmpChannelData[i] = 0;
326     }
327 }
328
329 void 
330 AliHLTPHOSRawAnalyzerComponent::SetBaselines(const char* file)
331 {
332   fUseBaselineSubtraction = true;
333   AliHLTPHOSBaseline *baseline = 0;
334   TFile *baselineFile = TFile::Open(file);
335   TTree *baselineTree = (TTree*)baselineFile->Get("baselineTree");
336   TClonesArray *baselineArray = new TClonesArray("AliHLTPHOSBaseline", 7168);
337   baselineTree->SetBranchAddress("Baselines", &baselineArray);
338   baselineTree->GetEntry(0);
339   for(Int_t i = 0; i < baselineArray->GetEntriesFast(); i++)
340     {
341       baseline = (AliHLTPHOSBaseline*)baselineArray->At(i);
342       if((baseline->GetX() < ((fRcuX + 1)*N_XCOLUMNS_RCU)) && (baseline->GetX() >= fRcuX*N_XCOLUMNS_RCU))
343         {
344           if((baseline->GetZ() < ((fRcuZ + 1)*N_ZROWS_RCU)) && (baseline->GetZ() >= fRcuZ*N_ZROWS_RCU))
345             {
346               fBaselines[baseline->GetX() - fRcuX*N_XCOLUMNS_RCU][baseline->GetZ() - fRcuZ*N_ZROWS_RCU][baseline->GetGain()] = baseline->GetBaseline();
347               //              cout <<  fBaselines[baseline->GetX() - fRcuX*N_XCOLUMNS_RCU][baseline->GetZ() - fRcuZ*N_ZROWS_RCU][baseline->GetGain()] << endl;
348             }
349         }
350     }
351   baselineFile->Close();
352   delete baselineFile;
353   baselineFile = 0;
354 }