@brief A digit reader implementation for unpacked TPC data.
*/
-#if __GNUC__== 3
-using namespace std;
-#endif
-
#include <cassert>
#include "AliHLTTPCDigitReaderUnpacked.h"
#include "AliHLTTPCDigitData.h"
#include "AliHLTStdIncludes.h"
#include "AliHLTTPCMapping.h"
+using namespace std;
+
ClassImp(AliHLTTPCDigitReaderUnpacked)
AliHLTTPCDigitReaderUnpacked::AliHLTTPCDigitReaderUnpacked()
fPrevTime(0),
fEndTimeBinOfBunch(0),
fPrevSignal(0),
- fPrevPad(0),
+ fPrevPad(-1),
fPrevRow(-1),
fNextChannelIsAlreadyConfirmed(kFALSE),
fMapping(NULL),
fDigitsVector(),
+ fBinRowPositionSorted(),
fPatch(0)
{
// see header file for class documentation
fPrevTime=0;
fEndTimeBinOfBunch=0;
fPrevSignal=0;
- fPrevPad=0;
+ fPrevPad=-1;
fPrevRow=-1;
fNextChannelIsAlreadyConfirmed=kFALSE;
fDigitsVector.clear();
AliHLTTPCDigitRowData* pCurrent=pRow;
assert(pCurrent);
pRow=NULL;
+ if (!pCurrent) return -EINVAL;
Byte_t *tmp = (Byte_t*) pCurrent;
Int_t size = sizeof(AliHLTTPCDigitRowData) + pCurrent->fNDigit*sizeof(AliHLTTPCDigitData);
tmp += size;
return iResult;
}
+void AliHLTTPCDigitReaderUnpacked::SortBunchBinVector(){
+ fBinRowPositionSorted.clear();
+
+ fBinRowPositionSorted.push_back(0);
+ Int_t nAdded=0;
+ Int_t beginningOfPadIndex=0;
+ Int_t totalAdded=0;
+ for(Int_t i=1;i<(Int_t)fActRowData->fNDigit;i++){
+ if(fData[i-1].fPad == fData[i].fPad){// means that these sinals belong to the same pad
+ if(fData[i-1].fTime+1 == fData[i].fTime){ //means that the signal belong to the same bunch
+ nAdded++;
+ totalAdded++;
+ fBinRowPositionSorted.insert(fBinRowPositionSorted.begin()+beginningOfPadIndex+nAdded,i);
+ }
+ else{//we have a new bunch on this pad, put it in fornt of the previous bunch
+ totalAdded++;
+ nAdded=0;
+ fBinRowPositionSorted.insert(fBinRowPositionSorted.begin()+beginningOfPadIndex,i);
+ }
+ }
+ else{
+ totalAdded++;
+ beginningOfPadIndex=totalAdded;
+ fBinRowPositionSorted.push_back(i);
+ nAdded=0;
+ }
+ }
+}
bool AliHLTTPCDigitReaderUnpacked::NextSignal(){
// see header file for class documentation
fBin++;
- if ( fBin >= (Int_t)fActRowData->fNDigit ){
+ while ( fBin >= (Int_t)fActRowData->fNDigit ){
fRow++;
if ((fRow >= fFirstRow) && (fRow <= fLastRow)){
-
+
//new row
if (GetNextRowData(fActRowData)<0) {
rreadvalue = false;
return rreadvalue;
}
-
fBin = 0;
}
else {
rreadvalue = false;
return rreadvalue;
}
- if(!fActRowData){
- return false;
- }
+ if(!fActRowData){
+ return false;
+ }
if ((Int_t)fActRowData->fRow != fRow){
HLTWarning("Row number should match! fActRowData->fRow=%d fRow=%d", fActRowData->fRow, fRow);
}
}
-
+
fData = fActRowData->fDigitData;
+
+ if(fBin==0){
+ SortBunchBinVector();
+ }
+
+ if(fPrevPad == -1){
+ fPrevPad = GetSortedPad();
+ }
return rreadvalue;
}
return (AliHLTUInt32_t)(fMapping->GetHwAddress((UInt_t)GetSortedRow(),(UInt_t)GetSortedPad()));//fTPCRawStream->GetHWAddress();
}
+AliHLTTPCDigitData AliHLTTPCDigitReaderUnpacked::GetSortedDigit(){
+ // see header file for class documentation
+ assert(fData);
+ if (!fData) return AliHLTTPCDigitData();
+ return fData[fBinRowPositionSorted.at(fBin)];
+}
+
Int_t AliHLTTPCDigitReaderUnpacked::GetSortedTime(){
// see header file for class documentation
assert(fData);
if (!fData) return -1;
int rtime;
- rtime = (int)fData[fBin].fTime;
+ rtime = (int)fData[fBinRowPositionSorted.at(fBin)].fTime;
if(fDataBunch.size()>1){
fEndTimeBinOfBunch=rtime;
}
assert(fData);
if (!fData) return -1;
int rsignal;
- rsignal = (int)fData[fBin].fCharge;
+ rsignal = (int)fData[fBinRowPositionSorted.at(fBin)].fCharge;
return rsignal;
}
assert(fData);
if (!fData) return -1;
int rpad;
- rpad = (int)fData[fBin].fPad;
+ rpad = (int)fData[fBinRowPositionSorted.at(fBin)].fPad;
return rpad ;
}
fPrevSignal=GetSortedSignal();
fPrevPad = GetSortedPad();
fPrevRow = GetSortedRow();
+
+ if(GetAltroBlockHWaddr() == (UInt_t)-1){
+ fPrevPad = -1;
+ return NextChannel();
+ }
+
return true;
}
else if(NextSignal()) { // there is data
+
+ if(GetAltroBlockHWaddr() == (UInt_t)-1){
+ fPrevPad = -1;
+ return NextChannel();
+ }
return true;
}
return false;
fPrevPad = GetSortedPad();
fPrevRow = GetSortedRow();
fDataBunch.push_back(GetSortedSignal());
- fDigitsVector.push_back(fData[fBin]);
+ fDigitsVector.push_back(GetSortedDigit());
do{
if(NextSignal()){
fPrevTime = GetSortedTime();
//fDataBunch.insert(fDataBunch.begin(), GetSortedSignal());// add the signal to the beginning of the buffer
fDataBunch.push_back(GetSortedSignal());// add the signal to the beginning of the buffer
- fDigitsVector.push_back(fData[fBin]);
+ fDigitsVector.push_back(GetSortedDigit());
}
else{//end of bunch but not of channel
break;