#include "AliHLTTPCTransform.h"
#include "AliHLTTPCDigitReader.h"
#include "AliHLTTPCDigitReaderUnpacked.h"
-#include "AliHLTTPCDigitReaderPacked.h"
-#include "AliHLTTPCDigitReaderRaw.h"
+#include "AliHLTTPCDigitReader32Bit.h"
#include "AliHLTTPCDefinitions.h"
-#define DefaultRawreaderMode 0
-
/** ROOT macro for the implementation of ROOT specific class methods */
ClassImp(AliHLTTPCDigitDumpComponent)
AliHLTTPCDigitDumpComponent::AliHLTTPCDigitDumpComponent()
:
AliHLTFileWriter(),
- fRawreaderMode(DefaultRawreaderMode),
- fDigitReaderType(kDigitReaderRaw)
+ fDigitReaderType(kDigitReader32Bit),
+ fRcuTrailerSize(2),
+ fUnsorted(true),
+ fbBulkMode(true),
+ fpReader(NULL),
+ f32BitFormat(kFALSE)
{
// see header file for class documentation
// or
int AliHLTTPCDigitDumpComponent::InitWriter()
{
// see header file for class documentation
- return 0;
+ int iResult=0;
+ switch (fDigitReaderType) {
+ case kDigitReaderUnpacked:
+ HLTInfo("create DigitReaderUnpacked");
+ fpReader=new AliHLTTPCDigitReaderUnpacked;
+ break;
+ case kDigitReader32Bit:
+ HLTInfo("create DigitReader32Bit");
+ fpReader=new AliHLTTPCDigitReader32Bit();
+ f32BitFormat = kTRUE;
+ break;
+ }
+ if (!fpReader) {
+ HLTError("can not create digit reader of type %d", fDigitReaderType);
+ iResult=-EFAULT;
+ } else {
+ fpReader->SetUnsorted(fUnsorted);
+ }
+ return iResult;
}
int AliHLTTPCDigitDumpComponent::ScanArgument(int argc, const char** argv)
// -rawreadermode
if (argument.CompareTo("-rawreadermode")==0) {
if ((bMissingParam=(++i>=argc))) break;
- int mode=AliHLTTPCDigitReaderRaw::DecodeMode(argv[i]);
- if (mode<0) {
- HLTError("invalid rawreadermode specifier '%s'", argv[i]);
- iResult=-EINVAL;
- } else {
- fRawreaderMode=static_cast<unsigned>(mode);
- }
+ HLTWarning("argument '-rawreadermode' deprecated");
break;
}
if (param.CompareTo("unpacked", TString::kIgnoreCase)==0) {
fDigitReaderType=kDigitReaderUnpacked;
} else if (param.CompareTo("packed", TString::kIgnoreCase)==0) {
- fDigitReaderType=kDigitReaderPacked;
+ HLTWarning("argument 'packed' is deprecated, falling back to DigitReader32Bit");
+ fDigitReaderType=kDigitReader32Bit;
} else if (param.CompareTo("raw", TString::kIgnoreCase)==0) {
- fDigitReaderType=kDigitReaderRaw;
+ HLTWarning("argument 'raw' is deprecated, falling back to DigitReader32Bit");
+ fDigitReaderType=kDigitReader32Bit;
+ } else if (param.CompareTo("decoder", TString::kIgnoreCase)==0) {
+ HLTWarning("argument 'decoder' is deprecated, falling back to DigitReader32Bit");
+ fDigitReaderType=kDigitReader32Bit;
+ } else if (param.CompareTo("32bit", TString::kIgnoreCase)==0) {
+ fDigitReaderType=kDigitReader32Bit;
} else {
HLTError("unknown digit reader type %s", param.Data());
iResult=-EINVAL;
}
- if (fDigitReaderType!=kDigitReaderRaw && fRawreaderMode!=DefaultRawreaderMode && iResult>=0) {
- HLTWarning("the selected digit reader does not support the option \'-rawreadermode\'");
+ break;
+ }
+
+ // -rcutrailersize
+ if (argument.CompareTo("-rcutrailersize")==0) {
+ if ((bMissingParam=(++i>=argc))) break;
+ char *endptr=NULL;
+ fRcuTrailerSize=strtoul(argv[i], &endptr, 0);
+ if (/*endptr ||*/ fRcuTrailerSize<1) {
+ HLTError("invalid parameter '%s', %s", argv[i], endptr==NULL?"number >= 1 expected":"can not convert string to number");
+ iResult=-EINVAL;
}
+ break;
+ }
+
+ // -unsorted
+ if (argument.CompareTo("-unsorted")==0) {
+ fUnsorted=true;
+ break;
+ }
+
+ // -sorted
+ if (argument.CompareTo("-sorted")==0) {
+ fUnsorted=false;
+ break;
+ }
+ // -bulk
+ if (argument.CompareTo("-bulk")==0) {
+ fbBulkMode=true;
break;
}
+ // -stream
+ if (argument.CompareTo("-stream")==0) {
+ fbBulkMode=false;
+ break;
+ }
} while (0); // just use the do/while here to have the option of breaking
if (bMissingParam) iResult=-EPROTO;
int AliHLTTPCDigitDumpComponent::CloseWriter()
{
// see header file for class documentation
+ if (fpReader) delete fpReader;
+ fpReader=NULL;
return 0;
}
int AliHLTTPCDigitDumpComponent::DumpEvent( const AliHLTComponentEventData& evtData,
- const AliHLTComponentBlockData* blocks,
+ const AliHLTComponentBlockData* /*blocks*/,
AliHLTComponentTriggerData& /*trigData*/ )
{
// see header file for class documentation
int blockno=0;
const AliHLTComponentBlockData* pDesc=NULL;
+ AliHLTTPCDigitReader* pReader=fpReader;
+ if (!pReader) return -ENODEV;
+
for (pDesc=GetFirstInputBlock(kAliHLTAnyDataType); pDesc!=NULL; pDesc=GetNextInputBlock(), blockno++) {
HLTDebug("event %Lu block %d: %s 0x%08x size %d", evtData.fEventID, blockno, DataType2Text(pDesc->fDataType).c_str(), pDesc->fSpecification, pDesc->fSize);
assert(slice==AliHLTTPCDefinitions::GetMaxSliceNr(*pDesc));
int firstRow=AliHLTTPCTransform::GetFirstRow(part);
int lastRow=AliHLTTPCTransform::GetLastRow(part);
- AliHLTTPCDigitReader* pReader=NULL;
- switch (fDigitReaderType) {
- case kDigitReaderUnpacked:
- HLTInfo("create DigitReaderUnpacked");
- pReader=new AliHLTTPCDigitReaderUnpacked;
- break;
- case kDigitReaderPacked:
- HLTInfo("create DigitReaderPacked");
- pReader=new AliHLTTPCDigitReaderPacked;
- break;
- case kDigitReaderRaw:
- HLTInfo("create DigitReaderRaw");
- pReader=new AliHLTTPCDigitReaderRaw(fRawreaderMode);
- break;
- }
- if (!pReader) {
- HLTError("can not create digit reader of type %d", fDigitReaderType);
- iResult=-EFAULT;
- break;
- }
+
iResult=pReader->InitBlock(pDesc->fPtr,pDesc->fSize,firstRow,lastRow,part,slice);
int iPrintedRow=-1;
int iPrintedPad=-1;
int iLastTime=-1;
- while (pReader->Next()) {
- if ((iPrintedSlice!=-1 && iLastTime!=pReader->GetTime()+1 && iLastTime!=pReader->GetTime()-1) ||
- (iPrintedPad!=-1 && iPrintedPad!=pReader->GetPad()) ||
- (iPrintedRow!=-1 && iPrintedRow!=pReader->GetRow())) {
- dump << endl;
- }
- if (iPrintedSlice!=slice || iPrintedPart!=part) {
- iPrintedSlice=slice;
- iPrintedPart=part;
- dump << "====================================================================" << endl;
- dump << " Slice: " << iPrintedSlice << " Partition: " << iPrintedPart << endl;
- iPrintedRow=-1;
+ if (fbBulkMode) {
+ while (pReader->NextChannel()) {
+ if (PrintHeaders(slice, iPrintedSlice, part, iPrintedPart, pReader, iPrintedRow, iPrintedPad, dump)) {
+ iLastTime=-1;
+ }
+ while (pReader->NextBunch()) {
+ int bunchLength=pReader->GetBunchSize();
+
+ // Kenneth: 20-04-09. The following if have been added because of inconsistency in the 40 bit decoder and the 32 bit decoder.
+ // GetSignals() in the 40 bit decoder returns an array of UInt_t while the 32 bit one returns UShort_t
+ if(f32BitFormat == kTRUE){
+ const UShort_t* bunchData=pReader->GetSignalsShort();
+
+ // bunch data is printed in 'reverse' order in order to produce
+ // the same output as in stream reading mode
+ dump << " Time " << pReader->GetTime()+bunchLength-1 << ": ";
+ for (int bin=bunchLength-1; bin>=0; bin--) {
+ dump << " " << bunchData[bin];
+ }
+ dump << " -> Time: " << pReader->GetTime() << endl;
+ }
+ else{
+ const UInt_t* bunchData=pReader->GetSignals();
+ dump << " Time " << pReader->GetTime()+bunchLength-1 << ": ";
+ for (int bin=0; bin<bunchLength; bin++) {
+ dump << " " << bunchData[bin];
+ }
+ dump << " -> Time: " << pReader->GetTime() << endl;
+ }
+ }
}
- if (iPrintedRow!=pReader->GetRow()) {
- iPrintedRow=pReader->GetRow();
- dump << "--------------------------------------------------------------------" << endl;
- dump << "Row: " << iPrintedRow << endl;
- iPrintedPad=-1;
+ dump << endl;
+ } else {
+ while (pReader->Next()) {
+ if ((iPrintedSlice!=-1 && iLastTime!=-1 && iLastTime!=pReader->GetTime()+1 && iLastTime!=pReader->GetTime()-1)) {
+ dump << " -> Time: " << iLastTime << endl;
+ } else if ((iPrintedPad!=-1 && iPrintedPad!=pReader->GetPad()) ||
+ (iPrintedRow!=-1 && iPrintedRow!=pReader->GetRow())) {
+ dump << " -> Time: " << iLastTime << endl;
+ //dump << endl;
}
- if (iPrintedPad!=pReader->GetPad()) {
- iPrintedPad=pReader->GetPad();
- dump << "Row: " << iPrintedRow << " Pad: " << iPrintedPad << endl;
+
+ if (PrintHeaders(slice, iPrintedSlice, part, iPrintedPart, pReader, iPrintedRow, iPrintedPad, dump)) {
iLastTime=-1;
}
- if (iLastTime!=pReader->GetTime()+1 && iLastTime!=pReader->GetTime()-1 ) {
+ if (iLastTime==-1 || (iLastTime!=pReader->GetTime()+1 && iLastTime!=pReader->GetTime()-1)) {
dump << " Time " << pReader->GetTime() << ": ";
}
iLastTime=pReader->GetTime();
dump << " " << pReader->GetSignal();
}
- dump << endl << endl;
- delete pReader;
- pReader=NULL;
+ if (iLastTime>=0) dump << " -> Time: " << iLastTime << endl << endl;
+ }
} else {
HLTError("can not open file %s for writing", filename.Data());
iResult=-EBADF;
}
dump.close();
}
+ pReader->Reset();
}
return iResult;
}
+
+int AliHLTTPCDigitDumpComponent::PrintHeaders(int slice, int &iPrintedSlice,
+ int part, int &iPrintedPart,
+ AliHLTTPCDigitReader* pReader,
+ int &iPrintedRow, int &iPrintedPad,
+ ofstream &dump) const
+{
+ // see header file for class documentation
+ int iResult=0;
+ assert(pReader);
+ if (iPrintedSlice!=slice || iPrintedPart!=part) {
+ iPrintedSlice=slice;
+ iPrintedPart=part;
+ dump << "====================================================================" << endl;
+ dump << " Slice: " << iPrintedSlice << " Partition: " << iPrintedPart << endl;
+ iPrintedRow=-1;
+ }
+ if (iPrintedRow!=pReader->GetRow()) {
+ iPrintedRow=pReader->GetRow();
+ dump << "--------------------------------------------------------------------" << endl;
+ dump << "Row: " << iPrintedRow << endl;
+ iPrintedPad=-1;
+ }
+ if (iPrintedPad!=pReader->GetPad()) {
+ iPrintedPad=pReader->GetPad();
+ dump << "Row: " << iPrintedRow << " Pad: " << iPrintedPad << " HW address: " << pReader->GetAltroBlockHWaddr() << endl;
+ iResult=1;
+ }
+
+ return iResult;
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff