]>
Commit | Line | Data |
---|---|---|
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 raw data, using the offline | |
25 | AliAltroRawStream/AliTPCRawStream. | |
26 | */ | |
27 | ||
28 | #if __GNUC__>= 3 | |
29 | using namespace std; | |
30 | #endif | |
31 | ||
32 | #include "AliHLTTPCDigitReaderPacked.h" | |
33 | ||
34 | #include "AliTPCRawStream.h" | |
35 | #include "AliRawReaderMemory.h" | |
36 | #include "AliRawDataHeader.h" | |
37 | ||
38 | #include "AliHLTTPCTransform.h" | |
39 | #include "AliHLTStdIncludes.h" | |
40 | ||
41 | ClassImp(AliHLTTPCDigitReaderPacked) | |
42 | ||
43 | AliHLTTPCDigitReaderPacked::AliHLTTPCDigitReaderPacked() | |
44 | : | |
45 | fTPCRawStream(NULL), | |
46 | fCurrentRow(0), | |
47 | fCurrentPad(0), | |
48 | fCurrentBin(-1), | |
49 | fRowOffset(0), | |
50 | fNRows(0), | |
51 | fNPads(0), | |
52 | fData(NULL), | |
53 | fUnsorted(kFALSE), | |
54 | fDataBunch(), | |
55 | fCurrentChannel(-1), | |
56 | fbHaveData(false), | |
57 | fCurrentPatch(0) | |
58 | { | |
59 | // see header file for class documentation | |
60 | // or | |
61 | // refer to README to build package | |
62 | // or | |
63 | // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt | |
64 | ||
65 | ||
66 | // Matthias Sep 2008: the pad sorting functionality needs a deep | |
67 | // revision of the code | |
68 | // I just stumbled over a few awkward implementation | |
69 | // - each instance allocates the buffer for sorted data, this is | |
70 | // approx. 8 MByte each | |
71 | // - each instance loops to extract the buffer size | |
72 | // - the AliTPCRawStream reads the Altro mapping for each instance | |
73 | // | |
74 | // There is now an instance handling of the buffer and the buffer size | |
75 | // is only calculated once The sorting of pads is going to be a common | |
76 | // functionality of the DigitReader base class in the future. | |
77 | // | |
78 | // Same applies to the instance of the AliRawReaderMemory and | |
79 | // AliTPCRawStream. Since processing of multiple instances is always | |
80 | // sequential, one instance can be used for all readers. | |
81 | ||
82 | // get max number of rows | |
83 | if (fNMaxRows<0) { | |
84 | for (Int_t ii=0; ii < 6; ii++) | |
85 | if (AliHLTTPCTransform::GetNRows(ii) > fNMaxRows) | |
86 | fNMaxRows = AliHLTTPCTransform::GetNRows(ii); | |
87 | } | |
88 | ||
89 | // get max number of pads | |
90 | if (fNMaxPads<0) { | |
91 | for (Int_t ii=0; ii < AliHLTTPCTransform::GetNRows();ii++ ) | |
92 | if (AliHLTTPCTransform::GetNPads(ii) > fNMaxPads) | |
93 | fNMaxPads = AliHLTTPCTransform::GetNPads(ii); | |
94 | } | |
95 | ||
96 | // get max number of bins | |
97 | if (fNTimeBins<0) { | |
98 | fNTimeBins = AliHLTTPCTransform::GetNTimeBins(); | |
99 | } | |
100 | ||
101 | fgObjectCount++; | |
102 | } | |
103 | ||
104 | Int_t AliHLTTPCDigitReaderPacked::fNMaxRows=-1; | |
105 | Int_t AliHLTTPCDigitReaderPacked::fNMaxPads=-1; | |
106 | Int_t AliHLTTPCDigitReaderPacked::fNTimeBins=-1; | |
107 | Int_t* AliHLTTPCDigitReaderPacked::fgpFreeBufferInstance=NULL; | |
108 | Int_t* AliHLTTPCDigitReaderPacked::fgpIssuedBufferInstance=NULL; | |
109 | AliHLTTPCDigitReaderPacked::AliHLTTPCRawStream* AliHLTTPCDigitReaderPacked::fgpFreeStreamInstance=NULL; | |
110 | AliHLTTPCDigitReaderPacked::AliHLTTPCRawStream* AliHLTTPCDigitReaderPacked::fgpIssuedStreamInstance=NULL; | |
111 | Int_t AliHLTTPCDigitReaderPacked::fgObjectCount=0; | |
112 | ||
113 | AliHLTTPCDigitReaderPacked::~AliHLTTPCDigitReaderPacked() | |
114 | { | |
115 | // see header file for class documentation | |
116 | if (fData) ReleaseBufferInstance(fData); | |
117 | fData=NULL; | |
118 | ||
119 | if (fTPCRawStream) ReleaseRawStreamInstance(fTPCRawStream); | |
120 | fTPCRawStream=NULL; | |
121 | ||
122 | if (--fgObjectCount==0) { | |
123 | if (fgpFreeBufferInstance) delete fgpFreeBufferInstance; | |
124 | fgpFreeBufferInstance=NULL; | |
125 | if (fgpIssuedBufferInstance) delete fgpIssuedBufferInstance; | |
126 | fgpIssuedBufferInstance=NULL; | |
127 | if (fgpFreeStreamInstance) delete fgpFreeStreamInstance; | |
128 | fgpFreeStreamInstance=NULL; | |
129 | if (fgpIssuedStreamInstance) delete fgpIssuedStreamInstance; | |
130 | fgpIssuedStreamInstance=NULL; | |
131 | } | |
132 | } | |
133 | ||
134 | Int_t AliHLTTPCDigitReaderPacked::InitBlock(void* ptr,ULong_t size, Int_t patch, Int_t slice) | |
135 | { | |
136 | // see header file for class documentation | |
137 | fTPCRawStream=GetRawStreamInstance(); | |
138 | if (!fTPCRawStream) return -ENODEV; | |
139 | ||
140 | fCurrentPatch=patch; | |
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 = 768 + 2*slice + patch; | |
146 | else | |
147 | DDLid = 840 + 4*slice + patch-2; | |
148 | ||
149 | fTPCRawStream->SetMemory(DDLid, reinterpret_cast<UChar_t*>( ptr ), size ); | |
150 | ||
151 | // fCurrentRow always is the row number within a partition, whereas the TPCRawStream | |
152 | // counts rows within the inner and outer sector, i.e. 0 to 62 for the inner and | |
153 | // 63 to 158 for the outer sector | |
154 | // fRowOffset is the offset of the first row of the current partition with respect | |
155 | // to inner or outer sector. | |
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 | for (Int_t ii=firstrow; ii <= lastrow;ii++ ) { | |
164 | if (AliHLTTPCTransform::GetNPads(ii) > fNPads) | |
165 | fNPads = AliHLTTPCTransform::GetNPads(ii); | |
166 | } | |
167 | ||
168 | Int_t offset=0; | |
169 | if (patch > 1) offset = AliHLTTPCTransform::GetFirstRow( 2 ); | |
170 | ||
171 | fRowOffset = firstrow - offset; | |
172 | firstrow -= offset; | |
173 | lastrow -= offset; | |
174 | ||
175 | fbHaveData=false; | |
176 | ||
177 | if(!fUnsorted){ | |
178 | ||
179 | // get the global instance of the array | |
180 | fData=GetBufferInstance(); | |
181 | if (!fData) return -ENOMEM; | |
182 | ||
183 | // Init array with -1 | |
184 | memset( fData, 0xFF, sizeof(Int_t)*(fNMaxRows*fNMaxPads*fNTimeBins) ); | |
185 | ||
186 | // read data and fill in array | |
187 | while( fTPCRawStream->Next()){ | |
188 | ||
189 | Int_t row = fTPCRawStream->GetRow(); | |
190 | Int_t pad = fTPCRawStream->GetPad(); | |
191 | Int_t bin = fTPCRawStream->GetTime(); | |
192 | ||
193 | if ( row < firstrow || row > lastrow || pad > AliHLTTPCTransform::GetNPads(row + offset) || bin > fNTimeBins){ | |
194 | HLTFatal("Index out of Range Probably wrong patch! %d - %d", slice, patch); | |
195 | if ( row < firstrow || row > lastrow ) | |
196 | HLTFatal("Row out of Range %d < %d < %d",firstrow, row, lastrow); | |
197 | if ( pad > AliHLTTPCTransform::GetNPads(row + offset) ) | |
198 | HLTFatal("Pad out of Range %d < %d < %d",pad, AliHLTTPCTransform::GetNPads(row + offset)); | |
199 | if ( bin > fNTimeBins ) | |
200 | HLTFatal("Bin out of Range %d < %d < %d",bin, fNTimeBins); | |
201 | } | |
202 | else { | |
203 | if ((row-fRowOffset)*fNMaxPads*fNTimeBins+ pad*fNTimeBins + bin >= fNMaxRows*fNMaxPads*fNTimeBins ) { | |
204 | HLTFatal("Index out of array range PAD=%d ||| ROW=%d ||| BIN=%d ||| OFFSET=%d ||| ROWOFFSET=%d", pad, row, bin, offset, fRowOffset); | |
205 | continue; | |
206 | } | |
207 | else { | |
208 | fData[ (row-fRowOffset)*fNMaxPads*fNTimeBins+ pad*fNTimeBins + bin ] = fTPCRawStream->GetSignal() ; | |
209 | } | |
210 | } | |
211 | } | |
212 | } | |
213 | return 0; | |
214 | } | |
215 | ||
216 | int AliHLTTPCDigitReaderPacked::Reset() | |
217 | { | |
218 | // see header file for class documentation | |
219 | if (fData) ReleaseBufferInstance(fData); | |
220 | fData=NULL; | |
221 | if (fTPCRawStream) ReleaseRawStreamInstance(fTPCRawStream); | |
222 | fTPCRawStream=NULL; | |
223 | return 0; | |
224 | } | |
225 | ||
226 | Bool_t AliHLTTPCDigitReaderPacked::NextSignal() | |
227 | { | |
228 | // see header file for class documentation | |
229 | Bool_t readvalue = kTRUE; | |
230 | ||
231 | if(!fUnsorted) { | |
232 | if (!fData) return false; | |
233 | while (1) { | |
234 | fCurrentBin++; | |
235 | if (fCurrentBin >= fNTimeBins){ | |
236 | fCurrentBin = 0; | |
237 | fCurrentPad++; | |
238 | ||
239 | if (fCurrentPad >=fNPads){ | |
240 | fCurrentPad = 0; | |
241 | fCurrentRow++; | |
242 | ||
243 | if (fCurrentRow >= fNRows){ | |
244 | readvalue = kFALSE; | |
245 | break; | |
246 | } | |
247 | } | |
248 | } | |
249 | ||
250 | if (fCurrentRow*fNMaxPads*fNTimeBins+ fCurrentPad*fNTimeBins + fCurrentBin >= fNMaxRows*fNMaxPads*fNTimeBins ) { | |
251 | HLTFatal("Overflow: row=%d pad=%d bin=%d", fCurrentRow, fCurrentPad, fCurrentBin); | |
252 | readvalue = kFALSE; | |
253 | break; | |
254 | } | |
255 | ||
256 | if (fData[ fCurrentRow*fNMaxPads*fNTimeBins + fCurrentPad*fNTimeBins + fCurrentBin ] != -1) break; | |
257 | } | |
258 | } else{ | |
259 | if ((readvalue = fTPCRawStream->Next())) { | |
260 | fCurrentBin=fTPCRawStream->GetTime(); | |
261 | } | |
262 | } | |
263 | ||
264 | fbHaveData=readvalue; | |
265 | return readvalue; | |
266 | } | |
267 | ||
268 | Int_t AliHLTTPCDigitReaderPacked::GetRow() | |
269 | { | |
270 | // see header file for class documentation | |
271 | if(!fUnsorted){ | |
272 | return (fCurrentRow + fRowOffset); | |
273 | } | |
274 | else{ | |
275 | return (Int_t) fTPCRawStream->GetRow()-fRowOffset; | |
276 | } | |
277 | } | |
278 | ||
279 | int AliHLTTPCDigitReaderPacked::GetPad() | |
280 | { | |
281 | // see header file for class documentation | |
282 | if(!fUnsorted){ | |
283 | return fCurrentPad; | |
284 | } | |
285 | else{ | |
286 | return fTPCRawStream->GetPad(); | |
287 | } | |
288 | } | |
289 | ||
290 | AliHLTUInt32_t AliHLTTPCDigitReaderPacked::GetAltroBlockHWaddr() const | |
291 | { | |
292 | // see header file for class documentation | |
293 | return fTPCRawStream->GetHWAddress(); | |
294 | } | |
295 | ||
296 | int AliHLTTPCDigitReaderPacked::GetRCUTrailerSize() | |
297 | { | |
298 | // see header file for class documentation | |
299 | if(fTPCRawStream){ | |
300 | return fTPCRawStream->GetRCUTrailerSize(); | |
301 | } | |
302 | return 0; | |
303 | } | |
304 | ||
305 | bool AliHLTTPCDigitReaderPacked::GetRCUTrailerData(UChar_t*& trData) | |
306 | { | |
307 | // see header file for class documentation | |
308 | if(fTPCRawStream){ | |
309 | return fTPCRawStream->GetRCUTrailerData(trData); | |
310 | } | |
311 | return false; | |
312 | } | |
313 | ||
314 | Int_t AliHLTTPCDigitReaderPacked::GetSignal() | |
315 | { | |
316 | // see header file for class documentation | |
317 | if(!fUnsorted){ | |
318 | // check for validity of fData is in NextSignal, no check at here | |
319 | return fData[ fCurrentRow*fNMaxPads*fNTimeBins+ fCurrentPad*fNTimeBins + fCurrentBin ]; | |
320 | } | |
321 | else{ | |
322 | return fTPCRawStream->GetSignal(); | |
323 | } | |
324 | } | |
325 | ||
326 | Int_t AliHLTTPCDigitReaderPacked::GetTime() | |
327 | { | |
328 | // see header file for class documentation | |
329 | return fCurrentBin; | |
330 | } | |
331 | ||
332 | Int_t AliHLTTPCDigitReaderPacked::GetTimeOfUnsortedSignal(){ | |
333 | return fTPCRawStream->GetTime(); | |
334 | } | |
335 | ||
336 | bool AliHLTTPCDigitReaderPacked::NextChannel() | |
337 | { | |
338 | // see header file for class documentation | |
339 | ||
340 | // return true if a channel is available. This is true if | |
341 | // 1. the current row position >=0 : a signal has already been read in the stream | |
342 | // but it was not part of the previous bunch | |
343 | // 2. the current row position <0 : this is the first invocation at all, read | |
344 | // signal and send result according to the availability | |
345 | if(fbHaveData || // data available from the last NextSignal call? | |
346 | NextSignal()) { // there is data | |
347 | fCurrentChannel=GetAltroBlockHWaddr(); | |
348 | return true; | |
349 | } | |
350 | return false; | |
351 | } | |
352 | ||
353 | int AliHLTTPCDigitReaderPacked::NextBunch() | |
354 | { | |
355 | // see header file for class documentation | |
356 | if (fCurrentChannel<0) return 0; | |
357 | ||
358 | fDataBunch.clear(); | |
359 | //adding the first signal (will always be the leftover from either NextChannel call or Previous bunch) | |
360 | fDataBunch.push_back(GetSignal()); | |
361 | ||
362 | Int_t prevTime=GetTimeOfUnsortedSignal(); | |
363 | do{ | |
364 | if(NextSignal()){ | |
365 | if((int)GetAltroBlockHWaddr()==fCurrentChannel){//check if there is a change in channel(new row and pad) | |
366 | if(prevTime==GetTimeOfUnsortedSignal()+1){//if true means that we have consecutive signals | |
367 | prevTime=GetTimeOfUnsortedSignal(); | |
368 | fDataBunch.insert(fDataBunch.begin(), GetSignal()); | |
369 | } | |
370 | else{//end of bunch but not of channel | |
371 | break; | |
372 | } | |
373 | } | |
374 | else{ | |
375 | fCurrentChannel=-1; | |
376 | break; | |
377 | } | |
378 | } | |
379 | else{ | |
380 | // end of data, but there is one bunch to be completed | |
381 | fCurrentChannel=-1; | |
382 | break; | |
383 | } | |
384 | }while(1); | |
385 | ||
386 | fCurrentBin=prevTime; | |
387 | return fDataBunch.size(); | |
388 | ||
389 | } | |
390 | ||
391 | int AliHLTTPCDigitReaderPacked::GetBunchSize(){ | |
392 | // see header file for class documentation | |
393 | return fDataBunch.size(); | |
394 | } | |
395 | ||
396 | const UInt_t* AliHLTTPCDigitReaderPacked::GetSignals() | |
397 | { | |
398 | // see header file for class documentation | |
399 | return &fDataBunch[0]; | |
400 | } | |
401 | ||
402 | Int_t* AliHLTTPCDigitReaderPacked::GetBufferInstance() | |
403 | { | |
404 | // see header file for class documentation | |
405 | ||
406 | // for the moment only a singleton of the buffer is foreseen | |
407 | // could be extended but very unlikly to be worth the effort | |
408 | // because pad sorting is just a debug feature. | |
409 | ||
410 | // This is just a poor man's solution, no synchronization for the | |
411 | // moment | |
412 | AliHLTLogging log; | |
413 | if (fgpIssuedBufferInstance) { | |
414 | log.LoggingVarargs(kHLTLogError, "AliHLTTPCDigitReaderPacked", "GetBufferInstance" , __FILE__ , __LINE__ , | |
415 | "instance of sorted buffer has not been released or multiple instances requested. Only available as global singleton for DigitReaderPacked"); | |
416 | return NULL; | |
417 | } | |
418 | ||
419 | if (!fgpFreeBufferInstance) { | |
420 | if (fNMaxRows<0 || fNMaxPads<0 || fNTimeBins<0) { | |
421 | log.LoggingVarargs(kHLTLogError, "AliHLTTPCDigitReaderPacked", "GetBufferInstance" , __FILE__ , __LINE__ , | |
422 | "can not determine size of buffer for sorted data"); | |
423 | return NULL; | |
424 | } | |
425 | fgpFreeBufferInstance=new Int_t[ fNMaxRows*fNMaxPads*fNTimeBins ]; | |
426 | log.LoggingVarargs(kHLTLogDebug, "AliHLTTPCDigitReaderPacked", "GetBufferInstance" , __FILE__ , __LINE__ , | |
427 | "Array Borders ||| MAXPAD=%d ||| MAXROW=%d ||| MAXBIN=%d ||| MAXMUL=%d", | |
428 | fNMaxPads, fNMaxRows, fNTimeBins, fNTimeBins*fNMaxRows*fNMaxPads); | |
429 | } | |
430 | ||
431 | fgpIssuedBufferInstance=fgpFreeBufferInstance; | |
432 | fgpFreeBufferInstance=NULL; | |
433 | return fgpIssuedBufferInstance; | |
434 | } | |
435 | ||
436 | void AliHLTTPCDigitReaderPacked::ReleaseBufferInstance(Int_t* pInstance) | |
437 | { | |
438 | // see header file for class documentation | |
439 | if (!pInstance) return; | |
440 | if (pInstance!=fgpIssuedBufferInstance) { | |
441 | AliHLTLogging log; | |
442 | log.LoggingVarargs(kHLTLogError, "AliHLTTPCDigitReaderPacked", "ReleaseBufferInstance" , __FILE__ , __LINE__ , | |
443 | "wrong instance %p, expecting %p", pInstance, fgpIssuedBufferInstance); | |
444 | return; | |
445 | } | |
446 | fgpFreeBufferInstance=fgpIssuedBufferInstance; | |
447 | fgpIssuedBufferInstance=NULL; | |
448 | } | |
449 | ||
450 | AliHLTTPCDigitReaderPacked::AliHLTTPCRawStream* AliHLTTPCDigitReaderPacked::GetRawStreamInstance() | |
451 | { | |
452 | // see header file for class documentation | |
453 | if (fgpIssuedStreamInstance) { | |
454 | HLTError("instance of TPCRawStream has not been released or multiple instances requested. Only available as global singleton for DigitReaderPacked"); | |
455 | return NULL; | |
456 | } | |
457 | ||
458 | if (!fgpFreeStreamInstance) { | |
459 | fgpFreeStreamInstance=new AliHLTTPCDigitReaderPacked::AliHLTTPCRawStream; | |
460 | } | |
461 | ||
462 | fgpIssuedStreamInstance=fgpFreeStreamInstance; | |
463 | fgpFreeStreamInstance=NULL; | |
464 | return fgpIssuedStreamInstance; | |
465 | } | |
466 | ||
467 | void AliHLTTPCDigitReaderPacked::ReleaseRawStreamInstance(AliHLTTPCDigitReaderPacked::AliHLTTPCRawStream* pInstance) | |
468 | { | |
469 | // see header file for class documentation | |
470 | if (!pInstance) return; | |
471 | if (pInstance!=fgpIssuedStreamInstance) { | |
472 | HLTError("wrong instance %p, expecting %p", pInstance, fgpIssuedStreamInstance); | |
473 | return; | |
474 | } | |
475 | fgpFreeStreamInstance=fgpIssuedStreamInstance; | |
476 | fgpIssuedStreamInstance=NULL; | |
477 | } | |
478 | ||
479 | AliHLTTPCDigitReaderPacked::AliHLTTPCRawStream::AliHLTTPCRawStream() | |
480 | : | |
481 | fRawMemoryReader(new AliRawReaderMemory), | |
482 | fTPCRawStream(new AliTPCRawStream(fRawMemoryReader)) | |
483 | { | |
484 | // see header file for class documentation | |
485 | } | |
486 | ||
487 | AliHLTTPCDigitReaderPacked::AliHLTTPCRawStream::~AliHLTTPCRawStream() | |
488 | { | |
489 | // see header file for class documentation | |
490 | if (fRawMemoryReader) delete fRawMemoryReader; | |
491 | fRawMemoryReader=NULL; | |
492 | if (fTPCRawStream) delete fTPCRawStream; | |
493 | fTPCRawStream=NULL; | |
494 | } | |
495 | ||
496 | Bool_t AliHLTTPCDigitReaderPacked::AliHLTTPCRawStream::SetMemory(Int_t ddlId, UChar_t* memory, ULong_t size ) | |
497 | { | |
498 | // see header file for class documentation | |
499 | if (!fRawMemoryReader) return false; | |
500 | Bool_t result=fRawMemoryReader->SetMemory(memory, size ); | |
501 | fRawMemoryReader->SetEquipmentID(ddlId); | |
502 | fRawMemoryReader->RewindEvents(); | |
503 | fRawMemoryReader->NextEvent(); | |
504 | return result; | |
505 | } | |
506 | ||
507 | bool AliHLTTPCDigitReaderPacked::AliHLTTPCRawStream::Next() | |
508 | { | |
509 | // see header file for class documentation | |
510 | if (!fTPCRawStream) return -1; | |
511 | return fTPCRawStream->Next(); | |
512 | } | |
513 | ||
514 | Int_t AliHLTTPCDigitReaderPacked::AliHLTTPCRawStream::GetRow() const | |
515 | { | |
516 | // see header file for class documentation | |
517 | if (!fTPCRawStream) return -1; | |
518 | return fTPCRawStream->GetRow(); | |
519 | } | |
520 | ||
521 | Int_t AliHLTTPCDigitReaderPacked::AliHLTTPCRawStream::GetPad() const | |
522 | { | |
523 | // see header file for class documentation | |
524 | if (!fTPCRawStream) return -1; | |
525 | return fTPCRawStream->GetPad(); | |
526 | } | |
527 | ||
528 | Int_t AliHLTTPCDigitReaderPacked::AliHLTTPCRawStream::GetTime() const | |
529 | { | |
530 | // see header file for class documentation | |
531 | if (!fTPCRawStream) return -1; | |
532 | return fTPCRawStream->GetTime(); | |
533 | } | |
534 | ||
535 | Int_t AliHLTTPCDigitReaderPacked::AliHLTTPCRawStream::GetSignal() const | |
536 | { | |
537 | // see header file for class documentation | |
538 | if (!fTPCRawStream) return -1; | |
539 | return fTPCRawStream->GetSignal(); | |
540 | } | |
541 | ||
542 | Int_t AliHLTTPCDigitReaderPacked::AliHLTTPCRawStream::GetHWAddress() const | |
543 | { | |
544 | // see header file for class documentation | |
545 | if (!fTPCRawStream) return -1; | |
546 | return fTPCRawStream->GetHWAddress(); | |
547 | } | |
548 | ||
549 | Bool_t AliHLTTPCDigitReaderPacked::AliHLTTPCRawStream::GetRCUTrailerData(UChar_t*& data) const | |
550 | { | |
551 | // see header file for class documentation | |
552 | if (!fTPCRawStream) return -1; | |
553 | return fTPCRawStream->GetRCUTrailerData(data); | |
554 | } | |
555 | ||
556 | Int_t AliHLTTPCDigitReaderPacked::AliHLTTPCRawStream::GetRCUTrailerSize() const | |
557 | { | |
558 | // see header file for class documentation | |
559 | if (!fTPCRawStream) return -1; | |
560 | return fTPCRawStream->GetRCUTrailerSize(); | |
561 | } |