7256884efabc0174248ecef64e9f715eb3073c56
[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
28 //using namespace std;
29
30 AliHLTPHOSRawAnalyzerComponent::AliHLTPHOSRawAnalyzerComponent():AliHLTPHOSRcuProcessor(), fAnalyzerPtr(0), 
31                                                                  fSendChannelData(kFALSE),fOutPtr(0), fMapperPtr(0), fDecoderPtr(0), 
32                                                                  fAltroDataPtr(0), fAltroBunchPtr(0) 
33 {
34   fMapperPtr = new AliHLTPHOSMapper();
35   
36
37
38
39 AliHLTPHOSRawAnalyzerComponent::~AliHLTPHOSRawAnalyzerComponent()
40 {
41   delete  fMapperPtr;
42 }
43
44
45 int 
46 AliHLTPHOSRawAnalyzerComponent::Deinit()
47 {
48   Logging(kHLTLogInfo, "HLT", "PHOS", ",AliHLTPHOSRawAnalyzerComponen Deinit");
49   return 0;
50 }
51
52
53 const char* 
54 AliHLTPHOSRawAnalyzerComponent::GetComponentID()
55 {
56   return "AliPhosTestRaw";
57 }
58
59
60 void
61 AliHLTPHOSRawAnalyzerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
62 {
63   const AliHLTComponentDataType* pType=fgkInputDataTypes;
64   while (pType->fID!=0) {
65     list.push_back(*pType);
66     pType++;
67   }
68 }
69
70
71 AliHLTComponentDataType 
72 AliHLTPHOSRawAnalyzerComponent::GetOutputDataType()
73 {
74   return AliHLTPHOSDefinitions::fgkCellEnergyDataType;
75 }
76
77
78 void
79 AliHLTPHOSRawAnalyzerComponent::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier )
80
81 {
82   constBase = 30;
83   inputMultiplier = 1;
84 }
85
86
87 int 
88 AliHLTPHOSRawAnalyzerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
89 {
90   UInt_t offset           = 0; 
91   UInt_t mysize           = 0;
92   UInt_t tSize            = 0;
93   //  Int_t tmpChannelCnt     = 0;
94   AliHLTUInt8_t* outBPtr;
95
96   AliHLTAltroBunch *bunchPtr;
97   outBPtr = outputPtr;
98   const AliHLTComponentBlockData* iter = NULL; 
99   unsigned long ndx;
100   for( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
101     {
102   
103
104     Int_t tmpChannelCnt     = 0;
105       iter = blocks+ndx;
106       mysize = 0;
107       offset = tSize;
108  
109       if ( iter->fDataType != AliHLTPHOSDefinitions::fgkDDLPackedRawDataType )
110         {
111           //      cout <<"WARNING: not AliHLTPHOSDefinitions::fgkDDLPackedRawDataType  "  << endl;
112           continue; //!!!!! Commented out to read TPC data, remember to put back
113         }
114
115        fDecoderPtr->SetMemory(reinterpret_cast<UChar_t*>( iter->fPtr ), iter->fSize);
116       //    fDecoderPtr->SetMemory2(reinterpret_cast<UChar_t*>( iter->fPtr ), iter->fSize);
117       fDecoderPtr->Decode();
118       fOutPtr =  (AliHLTPHOSRcuCellEnergyDataStruct*)outBPtr;
119       fOutPtr->fRcuX = fRcuX;
120       fOutPtr->fRcuZ = fRcuZ;
121       fOutPtr->fModuleID =fModuleID;
122       while( fDecoderPtr->NextChannel(fAltroDataPtr) == true )
123         {
124           fAnalyzerPtr->SetData(fAltroDataPtr->fData);
125           fAnalyzerPtr->Evaluate(0, fAltroDataPtr->fDataSize -2);  
126
127           fOutPtr->fValidData[tmpChannelCnt].fZ  = fMapperPtr->hw2geomapPtr[fAltroDataPtr->fHadd].zRow;
128           fOutPtr->fValidData[tmpChannelCnt].fX  = fMapperPtr->hw2geomapPtr[fAltroDataPtr->fHadd].xCol; 
129           fOutPtr->fValidData[tmpChannelCnt].fGain  = fMapperPtr->hw2geomapPtr[fAltroDataPtr->fHadd].gain; 
130           fOutPtr->fValidData[tmpChannelCnt].fEnergy  = (float)fAnalyzerPtr->GetEnergy();
131           fOutPtr->fValidData[tmpChannelCnt].fTime    = (float)fAnalyzerPtr->GetTiming();
132           tmpChannelCnt ++;
133         }
134     
135   
136       fOutPtr->fCnt =  tmpChannelCnt;
137       mysize += sizeof(AliHLTPHOSRcuCellEnergyDataStruct);
138
139       AliHLTComponentBlockData bd;
140       FillBlockData( bd );
141       bd.fOffset = offset;
142       bd.fSize = mysize;
143  
144       bd.fDataType = AliHLTPHOSDefinitions::fgkCellEnergyDataType;
145       bd.fSpecification = 0xFFFFFFFF;
146       outputBlocks.push_back( bd );
147  
148       tSize += mysize;
149       outBPtr += mysize;
150       
151       if( tSize > size )
152         {
153           cout <<"kHLTLogFatal, HLT::AliHLTPHOSRawAnalyzerComponent::DoEvent Too much dataData written over allowed buffer. Amount written:"
154                << tSize << " allowed" << size << endl;
155           Logging( kHLTLogFatal, "HLT::AliHLTPHOSRawAnalyzerComponent::DoEvent", "Too much data",
156                    "Data written over allowed buffer. Amount written: %lu, allowed amount: %lu."
157                    , tSize, size );
158           return EMSGSIZE;
159         }
160       //   fDecoderPtr->GetFailureRate();
161
162     }
163
164   fPhosEventCount++; 
165
166   if(fPrintInfo == kTRUE)
167     {
168       if(fPhosEventCount%fPrintInfoFrequncy == 0)
169         {
170           cout <<"Analyzing event " <<  fPhosEventCount  << "for Equippment " << fkEquippmentID << endl; 
171         }  
172     }
173   size = tSize;
174
175   return 0;
176 }//end DoEvent
177
178
179 int
180 AliHLTPHOSRawAnalyzerComponent::DoInit( int argc, const char** argv )
181 {
182   cout <<"AliHLTPHOSRawAnalyzerComponent::DoInit( int argc, const char** argv ) "<< endl;
183   fAltroDataPtr = new AliHLTAltroData();
184   fAltroBunchPtr = new AliHLTAltroBunch();
185   fDecoderPtr = new AliHLTDDLDecoder();
186   fSendChannelData = kFALSE;
187   fPrintInfo = kFALSE;
188   Reset();
189   int iResult=0;
190   TString argument="";
191   iResult = ScanArguments(argc, argv);
192
193   if(fIsSetEquippmentID == kFALSE)
194     {
195       cout << "The argument equippmentID is not set: set it with a component argumet like this: -equippmentID  <number>" << endl;
196       Logging( kHLTLogFatal, "HLT::AliHLTPHOSRcuHistogramProducerComponent::DoInt( int argc, const char** argv )", "Missing argument",
197                "The argument equippmentID is not set: set it with a component argumet like this: -equippmentID  <number>");
198       iResult = -3; 
199     }
200   else
201     {
202       iResult = 0; 
203       //      fRawMemoryReader->SetEquipmentID(fkEquippmentID);
204     }
205
206   //  return iResult;
207   //  return 0;
208   return iResult;
209 }
210
211
212 void
213 AliHLTPHOSRawAnalyzerComponent::Reset()
214 {
215   for(int mod = 0; mod < N_MODULES; mod ++)
216     {
217       for(int row = 0; row < N_ZROWS_MOD; row ++)
218         {
219           for(int col = 0; col < N_XCOLUMNS_MOD; col ++)
220             {
221               for(int gain = 0; gain < N_GAINS; gain ++ )
222                 {
223                   fMaxValues[mod][row][col][gain] = 0;
224                 }
225             }
226         }
227     }
228
229   ResetDataPtr(0, ALTRO_MAX_SAMPLES);
230
231 } // end Reset
232
233
234 void
235 AliHLTPHOSRawAnalyzerComponent::ResetDataPtr(int startindex, int sampleCnt)
236 {
237   for(int i = startindex ; i< sampleCnt; i++)
238     {
239       fTmpChannelData[i] = 0;
240     }
241 }
242