3 /**************************************************************************
4 * This file is property of and copyright by the ALICE HLT Project *
5 * ALICE Experiment at CERN, All rights reserved. *
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. *
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 **************************************************************************/
21 /** @file AliHLTTPCDigitReaderPacked.cxx
22 @author Timm Steinbeck, Jochen Thaeder, Matthias Richter, Kenneth Aamodt
24 @brief A digit reader implementation for simulated, packed TPC 'raw' data.
31 #if defined(HAVE_ALIRAWDATA) && defined(HAVE_ALITPCRAWSTREAM_H)
32 #include "AliHLTTPCDigitReaderPacked.h"
34 #include "AliTPCRawStream.h"
35 #include "AliRawReaderMemory.h"
36 #include "AliRawDataHeader.h"
38 #if ENABLE_PAD_SORTING
39 #include "AliHLTTPCTransform.h"
40 #endif // ENABLE_PAD_SORTING
41 #include "AliHLTStdIncludes.h"
43 ClassImp(AliHLTTPCDigitReaderPacked)
45 AliHLTTPCDigitReaderPacked::AliHLTTPCDigitReaderPacked()
47 #if ENABLE_PAD_SORTING
57 #endif // ENABLE_PAD_SORTING
58 fRawMemoryReader(NULL),
62 fRawMemoryReader = new AliRawReaderMemory;
64 fTPCRawStream = new AliTPCRawStream( fRawMemoryReader );
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);
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);
77 // get max number of bins
78 fNTimeBins = AliHLTTPCTransform::GetNTimeBins();
80 HLTDebug("Array Borders ||| MAXPAD=%d ||| MAXROW=%d ||| MAXBIN=%d ||| MAXMUL=%d",
81 fNMaxPads, fNMaxRows, fNTimeBins, fNTimeBins*fNMaxRows*fNMaxPads);
84 fData = new Int_t[ fNMaxRows*fNMaxPads*fNTimeBins ];
85 #endif // ENABLE_PAD_SORTING
88 AliHLTTPCDigitReaderPacked::AliHLTTPCDigitReaderPacked(const AliHLTTPCDigitReaderPacked& src)
90 #if ENABLE_PAD_SORTING
100 #endif // ENABLE_PAD_SORTING
101 fRawMemoryReader(NULL),
103 fOldRCUFormat(kFALSE)
105 HLTFatal("copy constructor not for use");
108 AliHLTTPCDigitReaderPacked& AliHLTTPCDigitReaderPacked::operator=(const AliHLTTPCDigitReaderPacked& src)
110 #if ENABLE_PAD_SORTING
120 #endif // ENABLE_PAD_SORTING
121 fRawMemoryReader=NULL;
123 fOldRCUFormat=kFALSE;
124 HLTFatal("assignment operator not for use");
128 AliHLTTPCDigitReaderPacked::~AliHLTTPCDigitReaderPacked(){
129 if ( fRawMemoryReader )
130 delete fRawMemoryReader;
131 fRawMemoryReader = NULL;
133 delete fTPCRawStream;
134 fTPCRawStream = NULL;
135 #if ENABLE_PAD_SORTING
139 #endif // ENABLE_PAD_SORTING
142 Int_t AliHLTTPCDigitReaderPacked::InitBlock(void* ptr,unsigned long size, Int_t patch, Int_t slice){
144 fRawMemoryReader->SetMemory( reinterpret_cast<UChar_t*>( ptr ), size );
146 //get DDL ID in order to tell the memory reader which slice/patch to use
149 DDLid = 768 + 2*slice + patch;
151 DDLid = 840 + 4*slice + patch-2;
153 fRawMemoryReader->SetEquipmentID(DDLid);
154 //fRawMemoryReader->SetEquipmentID(1);
156 fTPCRawStream->SetOldRCUFormat(kTRUE);
158 #if ENABLE_PAD_SORTING
164 Int_t firstrow=AliHLTTPCTransform::GetFirstRow(patch);
165 Int_t lastrow=AliHLTTPCTransform::GetLastRow(patch);
166 fNRows = lastrow - firstrow + 1;
169 if (patch > 1) offset = AliHLTTPCTransform::GetFirstRow( 2 );
171 fRowOffset = firstrow - offset;
175 // Init array with -1
176 memset( fData, 0xFF, sizeof(Int_t)*(fNMaxRows*fNMaxPads*fNTimeBins) );
178 // read data and fill in array
179 while( fTPCRawStream->Next()){
181 Int_t row = fTPCRawStream->GetRow();
182 Int_t pad = fTPCRawStream->GetPad();
183 Int_t bin = fTPCRawStream->GetTime();
185 if ( row < firstrow || row > lastrow || pad > AliHLTTPCTransform::GetNPads(row + offset) || bin > fNTimeBins){
186 HLTFatal("Index out of Range Probably wrong patch! %d - %d", slice, patch);
187 if ( row < firstrow || row > lastrow )
188 HLTFatal("Row out of Range %d < %d < %d",firstrow, row, lastrow);
189 if ( pad > AliHLTTPCTransform::GetNPads(row + offset) )
190 HLTFatal("Pad out of Range %d < %d < %d",pad, AliHLTTPCTransform::GetNPads(row + offset));
191 if ( bin > fNTimeBins )
192 HLTFatal("Bin out of Range %d < %d < %d",bin, fNTimeBins);
195 if ((row-fRowOffset)*fNMaxPads*fNTimeBins+ pad*fNTimeBins + bin >= fNMaxRows*fNMaxPads*fNTimeBins ) {
196 HLTFatal("Index out of array range PAD=%d ||| ROW=%d ||| BIN=%d ||| OFFSET=%d ||| ROWOFFSET=%d", pad, row, bin, offset, fRowOffset);
200 fData[ (row-fRowOffset)*fNMaxPads*fNTimeBins+ pad*fNTimeBins + bin ] = fTPCRawStream->GetSignal() ;
204 #endif // ENABLE_PAD_SORTING
209 Bool_t AliHLTTPCDigitReaderPacked::Next(){
210 Bool_t readvalue = kTRUE;
212 #if ENABLE_PAD_SORTING
215 if (fCurrentBin >= fNTimeBins){
219 if (fCurrentPad >=fNMaxPads){
223 if (fCurrentRow >= fNMaxRows){
230 if (fCurrentRow*fNMaxPads*fNTimeBins+ fCurrentPad*fNTimeBins + fCurrentBin >= fNMaxRows*fNMaxPads*fNTimeBins ) {
231 HLTFatal("Overflow: row=%d pad=%d bin=%d", fCurrentRow, fCurrentPad, fCurrentBin);
236 if (fData[ fCurrentRow*fNMaxPads*fNTimeBins + fCurrentPad*fNTimeBins + fCurrentBin ] != -1) break;
238 #else // !ENABLE_PAD_SORTING
239 readvalue = fTPCRawStream->Next();
240 #endif // ENABLE_PAD_SORTING
245 Int_t AliHLTTPCDigitReaderPacked::GetRow(){
246 #if ENABLE_PAD_SORTING
247 return (fCurrentRow + fRowOffset);
248 #else // !ENABLE_PAD_SORTING
249 return (Int_t) fTPCRawStream->GetRow();
250 #endif // ENABLE_PAD_SORTING
253 int AliHLTTPCDigitReaderPacked::GetPad(){
254 #if ENABLE_PAD_SORTING
256 #else // !ENABLE_PAD_SORTING
257 return fTPCRawStream->GetPad();
258 #endif // ENABLE_PAD_SORTING
261 Int_t AliHLTTPCDigitReaderPacked::GetSignal(){
262 #if ENABLE_PAD_SORTING
263 return fData[ fCurrentRow*fNMaxPads*fNTimeBins+ fCurrentPad*fNTimeBins + fCurrentBin ];
264 #else // !ENABLE_PAD_SORTING
265 return fTPCRawStream->GetSignal();
266 #endif // ENABLE_PAD_SORTING
269 Int_t AliHLTTPCDigitReaderPacked::GetTime(){
270 #if ENABLE_PAD_SORTING
272 #else // !ENABLE_PAD_SORTING
273 return fTPCRawStream->GetTime();
274 #endif // ENABLE_PAD_SORTING
276 #endif //defined(HAVE_ALIRAWDATA) && defined(HAVE_ALITPCRAWSTREAM_H)