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