coding conventions and compilation warnings
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCDigitReaderPacked.cxx
1 // $Id$
2
3 //*************************************************************************
4 // This file is property of and copyright by the ALICE HLT Project        * 
5 // ALICE Experiment at CERN, All rights reserved.                         *
6 //                                                                        *
7 // Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
8 //                  Timm Steinbeck <timm@kip.uni-heidelberg.de>           *
9 //                  Jochen Thaeder <thaeder@kip.uni-heidelberg.de>        *
10 //                  for The ALICE HLT Project.                            *
11 //                                                                        *
12 // Permission to use, copy, modify and distribute this software and its   *
13 // documentation strictly for non-commercial purposes is hereby granted   *
14 // without fee, provided that the above copyright notice appears in all   *
15 // copies and that both the copyright notice and this permission notice   *
16 // appear in the supporting documentation. The authors make no claims     *
17 // about the suitability of this software for any purpose. It is          *
18 // provided "as is" without express or implied warranty.                  *
19 //*************************************************************************/
20
21 /** @file   AliHLTTPCDigitReaderPacked.cxx
22     @author Timm Steinbeck, Jochen Thaeder, Matthias Richter, Kenneth Aamodt
23     @date   
24     @brief  A digit reader implementation for simulated, packed TPC 'raw' data.
25 */
26
27 #if __GNUC__>= 3
28 using namespace std;
29 #endif
30
31 #include "AliHLTTPCDigitReaderPacked.h"
32
33 #include "AliTPCRawStream.h"
34 #include "AliRawReaderMemory.h"
35 #include "AliRawDataHeader.h"
36
37 //#if ENABLE_PAD_SORTING
38 #include "AliHLTTPCTransform.h"
39 //#endif // ENABLE_PAD_SORTING
40 #include "AliHLTStdIncludes.h"
41
42 ClassImp(AliHLTTPCDigitReaderPacked)
43
44 AliHLTTPCDigitReaderPacked::AliHLTTPCDigitReaderPacked()
45   :
46   fRawMemoryReader(NULL),
47   fTPCRawStream(NULL),
48   //#if ENABLE_PAD_SORTING
49   fCurrentRow(0),
50   fCurrentPad(0),
51   fCurrentBin(-1),
52   fRowOffset(0),
53   fNRows(0),
54   fNMaxRows(0),
55   fNMaxPads(0),
56   fNTimeBins(0),
57   fData(NULL),
58   //#endif // ENABLE_PAD_SORTING  
59   fOldRCUFormat(kFALSE),
60   fUnsorted(kFALSE)
61 {
62   fRawMemoryReader = new AliRawReaderMemory;
63   
64   fTPCRawStream = new AliTPCRawStream( fRawMemoryReader );
65
66   //#if ENABLE_PAD_SORTING
67   // get max number of rows
68   for (Int_t ii=0; ii < 6; ii++)
69       if (AliHLTTPCTransform::GetNRows(ii) > fNMaxRows) 
70           fNMaxRows = AliHLTTPCTransform::GetNRows(ii);
71
72   // get max number of pads
73   for (Int_t ii=0; ii < AliHLTTPCTransform::GetNRows();ii++ )
74       if (AliHLTTPCTransform::GetNPads(ii) > fNMaxPads) 
75           fNMaxPads = AliHLTTPCTransform::GetNPads(ii);
76
77   // get max number of bins
78   fNTimeBins = AliHLTTPCTransform::GetNTimeBins();
79
80   HLTDebug("Array Borders  ||| MAXPAD=%d ||| MAXROW=%d ||| MAXBIN=%d ||| MAXMUL=%d", 
81            fNMaxPads, fNMaxRows, fNTimeBins, fNTimeBins*fNMaxRows*fNMaxPads);
82
83   // init Data array
84   fData = new Int_t[ fNMaxRows*fNMaxPads*fNTimeBins ];
85   //#endif // ENABLE_PAD_SORTING
86 }
87
88 AliHLTTPCDigitReaderPacked::~AliHLTTPCDigitReaderPacked(){
89   if ( fRawMemoryReader )
90     delete fRawMemoryReader;
91   fRawMemoryReader = NULL;
92   if ( fTPCRawStream )
93       delete fTPCRawStream;
94   fTPCRawStream = NULL;
95   //#if ENABLE_PAD_SORTING 
96   if ( fData )
97       delete [] fData;
98   fData = NULL;
99   //#endif // ENABLE_PAD_SORTING
100 }
101
102 Int_t AliHLTTPCDigitReaderPacked::InitBlock(void* ptr,ULong_t size, Int_t patch, Int_t slice)
103 {
104
105   fRawMemoryReader->SetMemory( reinterpret_cast<UChar_t*>( ptr ), size );
106
107   //get DDL ID in order to tell the memory reader which slice/patch to use
108   Int_t DDLid= 0;
109   if (patch < 2)
110     DDLid = 768 + 2*slice + patch;
111   else 
112     DDLid = 840 + 4*slice + patch-2;
113
114   fRawMemoryReader->SetEquipmentID(DDLid);
115   //fRawMemoryReader->SetEquipmentID(1);
116   if(fOldRCUFormat) {
117     fTPCRawStream->SetOldRCUFormat(kTRUE);
118     HLTInfo("set old RCU format (1 trailer word: 40bit payload)");
119   }
120   fRawMemoryReader->RewindEvents();
121   fRawMemoryReader->NextEvent();
122
123   if(!fUnsorted){
124   //#if ENABLE_PAD_SORTING
125
126   fCurrentRow = 0;
127   fCurrentPad = 0;
128   fCurrentBin = -1;
129
130   Int_t firstrow=AliHLTTPCTransform::GetFirstRow(patch);
131   Int_t lastrow=AliHLTTPCTransform::GetLastRow(patch);
132   fNRows = lastrow - firstrow + 1;
133
134   Int_t offset=0;
135   if (patch > 1) offset =  AliHLTTPCTransform::GetFirstRow( 2 );
136
137   fRowOffset = firstrow - offset;
138   firstrow -= offset;
139   lastrow  -= offset;
140
141   // Init array with -1
142   memset( fData, 0xFF, sizeof(Int_t)*(fNMaxRows*fNMaxPads*fNTimeBins) );
143
144   // read data and fill in array
145   while( fTPCRawStream->Next()){
146
147       Int_t row = fTPCRawStream->GetRow();
148       Int_t pad = fTPCRawStream->GetPad();
149       Int_t bin = fTPCRawStream->GetTime();
150
151       if ( row < firstrow || row > lastrow || pad > AliHLTTPCTransform::GetNPads(row + offset) || bin > fNTimeBins){
152         HLTFatal("Index out of Range Probably wrong patch! %d - %d", slice, patch);
153         if ( row < firstrow || row > lastrow ) 
154           HLTFatal("Row out of Range %d < %d < %d",firstrow, row, lastrow);
155         if ( pad > AliHLTTPCTransform::GetNPads(row + offset) ) 
156           HLTFatal("Pad out of Range %d < %d < %d",pad, AliHLTTPCTransform::GetNPads(row + offset));
157         if ( bin > fNTimeBins )
158           HLTFatal("Bin out of Range %d < %d < %d",bin, fNTimeBins);
159       }
160       else {  
161           if ((row-fRowOffset)*fNMaxPads*fNTimeBins+ pad*fNTimeBins + bin >=  fNMaxRows*fNMaxPads*fNTimeBins ) {
162               HLTFatal("Index out of array range PAD=%d ||| ROW=%d ||| BIN=%d ||| OFFSET=%d ||| ROWOFFSET=%d", pad, row, bin, offset, fRowOffset);
163               continue;
164           }
165           else {
166               fData[ (row-fRowOffset)*fNMaxPads*fNTimeBins+ pad*fNTimeBins + bin ] = fTPCRawStream->GetSignal() ;
167           }
168       }
169   }
170   //#endif // ENABLE_PAD_SORTING
171   }
172   return 0;
173 }
174
175 Bool_t AliHLTTPCDigitReaderPacked::NextSignal(){
176   Bool_t readvalue = kTRUE;
177
178   if(!fUnsorted){//added for test
179     //#if ENABLE_PAD_SORTING
180     while (1) {
181       fCurrentBin++;
182       if (fCurrentBin >= fNTimeBins){
183           fCurrentBin = 0;
184           fCurrentPad++;
185      
186           if (fCurrentPad >=fNMaxPads){
187               fCurrentPad = 0;
188               fCurrentRow++;
189               
190               if (fCurrentRow >= fNMaxRows){
191                   readvalue = kFALSE;
192                   break;
193               }
194           }
195       }
196
197       if (fCurrentRow*fNMaxPads*fNTimeBins+ fCurrentPad*fNTimeBins + fCurrentBin >=  fNMaxRows*fNMaxPads*fNTimeBins ) {
198           HLTFatal("Overflow: row=%d pad=%d bin=%d", fCurrentRow, fCurrentPad, fCurrentBin);
199           readvalue = kFALSE;
200           break;
201       }
202
203       if (fData[ fCurrentRow*fNMaxPads*fNTimeBins + fCurrentPad*fNTimeBins + fCurrentBin  ] != -1) break;
204     }
205   }// added for test
206   else{//added for test
207     //#else // !ENABLE_PAD_SORTING
208     readvalue = fTPCRawStream->Next();
209   }//added for test
210   //#endif // ENABLE_PAD_SORTING
211
212   return readvalue;
213 }
214
215 Int_t AliHLTTPCDigitReaderPacked::GetRow(){
216   /*#if ENABLE_PAD_SORTING
217   return (fCurrentRow + fRowOffset);
218 #else // !ENABLE_PAD_SORTING
219   return (Int_t) fTPCRawStream->GetRow();
220 #endif // ENABLE_PAD_SORTING
221   */
222   if(!fUnsorted){
223   return (fCurrentRow + fRowOffset);
224   }
225   else{
226   return (Int_t) fTPCRawStream->GetRow();
227   }
228 }
229
230 int AliHLTTPCDigitReaderPacked::GetPad(){
231   /*#if ENABLE_PAD_SORTING
232     return fCurrentPad;
233     #else // !ENABLE_PAD_SORTING
234     return fTPCRawStream->GetPad();
235     #endif // ENABLE_PAD_SORTING
236   */
237   if(!fUnsorted){
238     return fCurrentPad;
239   }
240   else{
241     return fTPCRawStream->GetPad();
242   }
243 }
244
245 AliHLTUInt32_t AliHLTTPCDigitReaderPacked::GetAltroBlockHWaddr() const
246 {
247   return fTPCRawStream->GetHWAddress();
248 }
249
250 Int_t AliHLTTPCDigitReaderPacked::GetSignal(){ 
251   /*
252     #if ENABLE_PAD_SORTING
253     return fData[ fCurrentRow*fNMaxPads*fNTimeBins+ fCurrentPad*fNTimeBins + fCurrentBin ];
254     #else // !ENABLE_PAD_SORTING
255     return fTPCRawStream->GetSignal();
256     #endif // ENABLE_PAD_SORTING
257   */
258   if(!fUnsorted){
259     return fData[ fCurrentRow*fNMaxPads*fNTimeBins+ fCurrentPad*fNTimeBins + fCurrentBin ];
260   }
261   else{
262     return fTPCRawStream->GetSignal();
263   }
264 }
265
266 Int_t AliHLTTPCDigitReaderPacked::GetTime(){
267   /*
268     #if ENABLE_PAD_SORTING
269     return fCurrentBin;
270     #else // !ENABLE_PAD_SORTING
271     return fTPCRawStream->GetTime();
272     #endif // ENABLE_PAD_SORTING
273   */
274   if(!fUnsorted){
275     return fCurrentBin;
276   }
277   else{
278     return fTPCRawStream->GetTime();
279   }
280 }