X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=HLT%2FTPCLib%2FAliHLTTPCDigitReaderPacked.cxx;h=67cbc984a70c83ff47d808b2b01a7ca656f94026;hb=aff6e98158591a8af494856bc5b03eeb19956842;hp=3ad77b0626aec9f1671fe194696dfa0de2993566;hpb=74c73e5abdcd5213870ce450183e6ee336527a84;p=u%2Fmrichter%2FAliRoot.git diff --git a/HLT/TPCLib/AliHLTTPCDigitReaderPacked.cxx b/HLT/TPCLib/AliHLTTPCDigitReaderPacked.cxx index 3ad77b0626a..67cbc984a70 100644 --- a/HLT/TPCLib/AliHLTTPCDigitReaderPacked.cxx +++ b/HLT/TPCLib/AliHLTTPCDigitReaderPacked.cxx @@ -1,12 +1,13 @@ // $Id$ /************************************************************************** - * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * This file is property of and copyright by the ALICE HLT Project * + * ALICE Experiment at CERN, All rights reserved. * * * - * Authors: Matthias Richter * - * Timm Steinbeck * - * Jochen Thaeder * - * for The ALICE Off-line Project. * + * Primary Authors: Matthias Richter * + * Timm Steinbeck * + * Jochen Thaeder * + * for The ALICE HLT Project. * * * * Permission to use, copy, modify and distribute this software and its * * documentation strictly for non-commercial purposes is hereby granted * @@ -17,29 +18,72 @@ * provided "as is" without express or implied warranty. * **************************************************************************/ -/////////////////////////////////////////////////////////////////////////////// -// // -// class for reading packed data for the HLT // -// // -/////////////////////////////////////////////////////////////////////////////// +/** @file AliHLTTPCDigitReaderPacked.cxx + @author Timm Steinbeck, Jochen Thaeder, Matthias Richter, Kenneth Aamodt + @date + @brief A digit reader implementation for simulated, packed TPC 'raw' data. +*/ -#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(){ +#if defined(HAVE_ALIRAWDATA) && defined(HAVE_ALITPCRAWSTREAM_H) +AliHLTTPCDigitReaderPacked::AliHLTTPCDigitReaderPacked() + : + //#if ENABLE_PAD_SORTING + fCurrentRow(0), + fCurrentPad(0), + fCurrentBin(-1), + fNRows(0), + fRowOffset(0), + fNMaxRows(0), + fNMaxPads(0), + fNTimeBins(0), + fData(NULL), + //#endif // ENABLE_PAD_SORTING + fRawMemoryReader(NULL), + fTPCRawStream(NULL), + fOldRCUFormat(kFALSE), + fUnsorted(kFALSE) +{ fRawMemoryReader = new AliRawReaderMemory; + fTPCRawStream = new AliTPCRawStream( fRawMemoryReader ); + + //#if ENABLE_PAD_SORTING + // get max number of rows + for (Int_t ii=0; ii < 6; ii++) + if (AliHLTTPCTransform::GetNRows(ii) > fNMaxRows) + fNMaxRows = AliHLTTPCTransform::GetNRows(ii); + + // get max number of pads + 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("Array Borders ||| 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(){ @@ -47,42 +91,182 @@ 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 patch, Int_t slice){ + fRawMemoryReader->SetMemory( reinterpret_cast( 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 = 768 + 2*slice + patch; + else + DDLid = 840 + 4*slice + patch-2; + + fRawMemoryReader->SetEquipmentID(DDLid); + //fRawMemoryReader->SetEquipmentID(1); + if(fOldRCUFormat) + fTPCRawStream->SetOldRCUFormat(kTRUE); + + if(!fUnsorted){ + //#if ENABLE_PAD_SORTING + + fCurrentRow = 0; + fCurrentPad = 0; + fCurrentBin = -1; + + Int_t firstrow=AliHLTTPCTransform::GetFirstRow(patch); + Int_t lastrow=AliHLTTPCTransform::GetLastRow(patch); + 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::NextSignal(){ + Bool_t readvalue = kTRUE; + + if(!fUnsorted){//added for test + //#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; + } + }// added for test + else{//added for test + //#else // !ENABLE_PAD_SORTING + readvalue = fTPCRawStream->Next(); + }//added for test + //#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 + */ + if(!fUnsorted){ + return (fCurrentRow + fRowOffset); + } + else{ + return (Int_t) fTPCRawStream->GetRow(); + } } 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 + */ + if(!fUnsorted){ + return fCurrentPad; + } + else{ + return fTPCRawStream->GetPad(); + } } -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 + */ + if(!fUnsorted){ + return fData[ fCurrentRow*fNMaxPads*fNTimeBins+ fCurrentPad*fNTimeBins + fCurrentBin ]; + } + else{ + return fTPCRawStream->GetSignal(); + } } -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 + */ + if(!fUnsorted){ + return fCurrentBin; + } + else{ + return fTPCRawStream->GetTime(); + } } #endif //defined(HAVE_ALIRAWDATA) && defined(HAVE_ALITPCRAWSTREAM_H)