///////////////////////////////////////////////////////////////////////////////
// //
// class for reading packed data for the HLT //
+// includes reordering of the pads //
// //
///////////////////////////////////////////////////////////////////////////////
-#if __GNUC__== 3
+
+#if __GNUC__>= 3
using namespace std;
#endif
#if defined(HAVE_ALIRAWDATA) && defined(HAVE_ALITPCRAWSTREAM_H)
#include "AliHLTTPCDigitReaderPacked.h"
+
#include "AliTPCRawStream.h"
#include "AliRawReaderMemory.h"
#include "AliRawDataHeader.h"
+#if ENABLE_PAD_SORTING
+#include "AliHLTTPCTransform.h"
+#endif // ENABLE_PAD_SORTING
#include "AliHLTStdIncludes.h"
ClassImp(AliHLTTPCDigitReaderPacked)
AliHLTTPCDigitReaderPacked::AliHLTTPCDigitReaderPacked(){
fRawMemoryReader = new AliRawReaderMemory;
+
fTPCRawStream = new AliTPCRawStream( fRawMemoryReader );
+
+#if ENABLE_PAD_SORTING
+ fCurrentRow = 0;
+ fCurrentPad = 0;
+ fCurrentBin = -1;
+
+ fNRows = 0;
+ fRowOffset = 0;
+
+ // get max number of rows
+ fNMaxRows = 0;
+ for (Int_t ii=0; ii < 6; ii++)
+ if (AliHLTTPCTransform::GetNRows(ii) > fNMaxRows)
+ fNMaxRows = AliHLTTPCTransform::GetNRows(ii);
+
+ // get max number of pads
+ fNMaxPads = 0;
+ for (Int_t ii=0; ii < AliHLTTPCTransform::GetNRows();ii++ )
+ if (AliHLTTPCTransform::GetNPads(ii) > fNMaxPads)
+ fNMaxPads = AliHLTTPCTransform::GetNPads(ii);
+
+ // get max number of bins
+ fNTimeBins = AliHLTTPCTransform::GetNTimeBins();
+
+ HLTDebug("||| MAXPAD=%d ||| MAXROW=%d ||| MAXBIN=%d ||| MAXMUL=%d",
+ fNMaxPads, fNMaxRows, fNTimeBins, fNTimeBins*fNMaxRows*fNMaxPads);
+
+ // init Data array
+ fData = new Int_t[ fNMaxRows*fNMaxPads*fNTimeBins ];
+#endif // ENABLE_PAD_SORTING
}
AliHLTTPCDigitReaderPacked::~AliHLTTPCDigitReaderPacked(){
delete fRawMemoryReader;
fRawMemoryReader = NULL;
if ( fTPCRawStream )
- delete fTPCRawStream;
+ delete fTPCRawStream;
fTPCRawStream = NULL;
+#if ENABLE_PAD_SORTING
+ if ( fData )
+ delete [] fData;
+ fData = NULL;
+#endif // ENABLE_PAD_SORTING
}
-int AliHLTTPCDigitReaderPacked::InitBlock(void* ptr,unsigned long size,Int_t firstrow, Int_t lastrow){
+Int_t AliHLTTPCDigitReaderPacked::InitBlock(void* ptr,unsigned long size,Int_t firstrow, Int_t lastrow, Int_t patch, Int_t slice){
+
fRawMemoryReader->SetMemory( reinterpret_cast<UChar_t*>( ptr ), size );
+
+ //get DDL ID in order to tell the memory reader which slice/patch to use
+ Int_t DDLid= 0;
+ if (patch < 2)
+ DDLid = 2 *slice + patch;
+ else
+ DDLid = 70 + 4*slice + patch;
+
+ //fRawMemoryReader->SetEquipmentID(DDLid);
+//fRawMemoryReader->SetEquipmentID(1);
+
+// fTPCRawStream->SetOldRCUFormat(kTRUE);
+
+#if ENABLE_PAD_SORTING
+
+ fCurrentRow = 0;
+ fCurrentPad = 0;
+ fCurrentBin = -1;
+
+ fNRows = lastrow - firstrow + 1;
+
+ Int_t offset=0;
+ if (patch > 1) offset = AliHLTTPCTransform::GetFirstRow( 2 );
+
+ fRowOffset = firstrow - offset;
+ firstrow -= offset;
+ lastrow -= offset;
+
+ // Init array with -1
+ memset( fData, 0xFF, sizeof(Int_t)*(fNMaxRows*fNMaxPads*fNTimeBins) );
+
+ // read data and fill in array
+ while( fTPCRawStream->Next()){
+
+ Int_t row = fTPCRawStream->GetRow();
+ Int_t pad = fTPCRawStream->GetPad();
+ Int_t bin = fTPCRawStream->GetTime();
+
+ if ( row < firstrow || row > lastrow || pad > AliHLTTPCTransform::GetNPads(row + offset) || bin > fNTimeBins){
+ HLTFatal("Index out of Range Probably wrong patch! %d - %d", slice, patch);
+ if ( row < firstrow || row > lastrow )
+ HLTFatal("Row out of Range %d < %d < %d",firstrow, row, lastrow);
+ if ( pad > AliHLTTPCTransform::GetNPads(row + offset) )
+ HLTFatal("Pad out of Range %d < %d < %d",pad, AliHLTTPCTransform::GetNPads(row + offset));
+ if ( bin > fNTimeBins )
+ HLTFatal("Bin out of Range %d < %d < %d",bin, fNTimeBins);
+ }
+ else {
+ if ((row-fRowOffset)*fNMaxPads*fNTimeBins+ pad*fNTimeBins + bin >= fNMaxRows*fNMaxPads*fNTimeBins ) {
+ HLTFatal("Index out of array range PAD=%d ||| ROW=%d ||| BIN=%d ||| OFFSET=%d ||| ROWOFFSET=%d", pad, row, bin, offset, fRowOffset);
+ continue;
+ }
+ else {
+ fData[ (row-fRowOffset)*fNMaxPads*fNTimeBins+ pad*fNTimeBins + bin ] = fTPCRawStream->GetSignal() ;
+ }
+ }
+ }
+#endif // ENABLE_PAD_SORTING
+
return 0;
}
-bool AliHLTTPCDigitReaderPacked::Next(){
- bool rreadvalue;
- rreadvalue = fTPCRawStream->Next();
- return rreadvalue;
+Bool_t AliHLTTPCDigitReaderPacked::Next(){
+ Bool_t readvalue = kTRUE;
+
+#if ENABLE_PAD_SORTING
+ while (1) {
+ fCurrentBin++;
+ if (fCurrentBin >= fNTimeBins){
+ fCurrentBin = 0;
+ fCurrentPad++;
+
+ if (fCurrentPad >=fNMaxPads){
+ fCurrentPad = 0;
+ fCurrentRow++;
+
+ if (fCurrentRow >= fNMaxRows){
+ readvalue = kFALSE;
+ break;
+ }
+ }
+ }
+
+ if (fCurrentRow*fNMaxPads*fNTimeBins+ fCurrentPad*fNTimeBins + fCurrentBin >= fNMaxRows*fNMaxPads*fNTimeBins ) {
+ HLTFatal("Overflow: row=%d pad=%d bin=%d", fCurrentRow, fCurrentPad, fCurrentBin);
+ readvalue = kFALSE;
+ break;
+ }
+
+ if (fData[ fCurrentRow*fNMaxPads*fNTimeBins + fCurrentPad*fNTimeBins + fCurrentBin ] != -1) break;
+ }
+#else // !ENABLE_PAD_SORTING
+ readvalue = fTPCRawStream->Next();
+#endif // ENABLE_PAD_SORTING
+
+ return readvalue;
}
-int AliHLTTPCDigitReaderPacked::GetRow(){
- int rrow;
- rrow = (int)fTPCRawStream->GetRow();
- return rrow;
+Int_t AliHLTTPCDigitReaderPacked::GetRow(){
+#if ENABLE_PAD_SORTING
+ return (fCurrentRow + fRowOffset);
+#else // !ENABLE_PAD_SORTING
+ return (Int_t) fTPCRawStream->GetRow();
+#endif // ENABLE_PAD_SORTING
}
int AliHLTTPCDigitReaderPacked::GetPad(){
- int rpad;
- rpad = fTPCRawStream->GetPad();
- return rpad ;
+#if ENABLE_PAD_SORTING
+ return fCurrentPad;
+#else // !ENABLE_PAD_SORTING
+ return fTPCRawStream->GetPad();
+#endif // ENABLE_PAD_SORTING
}
-int AliHLTTPCDigitReaderPacked::GetSignal(){
- int rsignal;
- rsignal = fTPCRawStream->GetSignal();
- return rsignal;
+Int_t AliHLTTPCDigitReaderPacked::GetSignal(){
+#if ENABLE_PAD_SORTING
+ return fData[ fCurrentRow*fNMaxPads*fNTimeBins+ fCurrentPad*fNTimeBins + fCurrentBin ];
+#else // !ENABLE_PAD_SORTING
+ return fTPCRawStream->GetSignal();
+#endif // ENABLE_PAD_SORTING
}
-int AliHLTTPCDigitReaderPacked::GetTime(){
- int rtime;
- rtime = fTPCRawStream->GetTime();
- return rtime;
+Int_t AliHLTTPCDigitReaderPacked::GetTime(){
+#if ENABLE_PAD_SORTING
+ return fCurrentBin;
+#else // !ENABLE_PAD_SORTING
+ return fTPCRawStream->GetTime();
+#endif // ENABLE_PAD_SORTING
}
#endif //defined(HAVE_ALIRAWDATA) && defined(HAVE_ALITPCRAWSTREAM_H)
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff