fHWAddress(-1),
fRawReader(rawReader),
fData(NULL),
+ fChannelStartPos(-1),
fPosition(-1),
fCount(-1),
fStartTimeBin(-1),
fAltroCFG1(0),
fAltroCFG2(0),
fOldStream(NULL),
- fCheckAltroPayload(kTRUE)
+ fCheckAltroPayload(kTRUE),
+ fFormatVersion(0)
{
// Constructor
// Create an object to read Altro raw digits in
fHWAddress(stream.fHWAddress),
fRawReader(stream.fRawReader),
fData(stream.fData),
+ fChannelStartPos(stream.fChannelStartPos),
fPosition(stream.fPosition),
fCount(stream.fCount),
fStartTimeBin(stream.fStartTimeBin),
fAltroCFG1(stream.fAltroCFG1),
fAltroCFG2(stream.fAltroCFG2),
fOldStream(NULL),
- fCheckAltroPayload(stream.fCheckAltroPayload)
+ fCheckAltroPayload(stream.fCheckAltroPayload),
+ fFormatVersion(0)
{
// Copy constructor
// Copy the bunch data array
fHWAddress = stream.fHWAddress;
fRawReader = stream.fRawReader;
fData = stream.fData;
+ fChannelStartPos = stream.fChannelStartPos;
fPosition = stream.fPosition;
fCount = stream.fCount;
fStartTimeBin = stream.fStartTimeBin;
fActiveFECsB = stream.fActiveFECsB;
fAltroCFG1 = stream.fAltroCFG1;
fAltroCFG2 = stream.fAltroCFG2;
+ fFormatVersion = stream.fFormatVersion;
for(Int_t i = 0; i < kMaxNTimeBins; i++) fBunchData[i] = stream.fBunchData[i];
// Reset of the raw-reader as well
fDDLNumber = fRCUId = fHWAddress = -1;
+ fChannelStartPos = -1;
fPosition = fCount = -1;
fBunchLength = fStartTimeBin = -1;
fBadChannel = kFALSE;
// Read the next DDL payload (CDH + RCU trailer)
// Updates the information which is coming from these
// two sources
-
+ fFormatVersion = 0;
fPosition = 0;
// Get next DDL payload
// return wtih false in case no more data payloads
fDDLNumber = fRawReader->GetDDLID();
fChannelPayloadSize = -1;
+ fChannelStartPos = -1;
- UChar_t rcuVer = fRawReader->GetBlockAttributes();
+ fFormatVersion = fRawReader->GetBlockAttributes();
- if (rcuVer < 2) {
+ if (fFormatVersion < 2) {
// old altro format data
if (!fOldStream) {
fOldStream = new AliAltroRawStream(fRawReader);
AliInfo(Form("RCU firmware verion %d detected. Using AliAltroRawStream to decode the data.",
- rcuVer));
+ fFormatVersion));
}
Bool_t status = fOldStream->NextDDL(fData);
if (status) {
return status;
}
- return ReadRCUTrailer(rcuVer);
+ return ReadRCUTrailer(fFormatVersion);
}
//_____________________________________________________________________________
return status;
}
+ Int_t channelStartPos=fPosition;
+ fChannelStartPos = -1;
fCount = -1;
fBadChannel = kFALSE;
fBunchDataIndex = 0;
word = Get32bitWord(fPosition++);
if ((word >> 30) != 0) {
// Unexpected end of altro channel payload
- AliWarning(Form("Unexpected end of payload in altro channel payload! Address=0x%x, word=0x%x",
- fHWAddress,word));
+ AliWarning(Form("Unexpected end of payload in altro channel payload! DDL=%03d, Address=0x%x, word=0x%x",
+ fDDLNumber,fHWAddress,word));
fRawReader->AddMinorErrorLog(kAltroPayloadErr,Form("hw=0x%x",fHWAddress));
+ if (AliDebugLevel() > 0) HexDumpChannel();
fCount = -1;
fPosition--;
return kFALSE;
fBunchData[isample++] = word & 0x3FF;
}
+ fChannelStartPos=channelStartPos;
return kTRUE;
}
fBunchLength = fBunchData[fBunchDataIndex];
if (fBunchLength <= 2) {
// Invalid bunch size
- AliWarning(Form("Too short bunch length (%d) in Address=0x%x !",
- fBunchLength,fHWAddress));
+ AliWarning(Form("Too short bunch length (%d) @ %d in Address=0x%x (DDL=%03d)!",
+ fBunchLength,fBunchDataIndex,fHWAddress,fDDLNumber));
fRawReader->AddMinorErrorLog(kAltroBunchHeadErr,Form("hw=0x%x",fHWAddress));
+ if (AliDebugLevel() > 0) HexDumpChannel();
fCount = fBunchLength = -1;
return kFALSE;
}
if ((fBunchDataIndex + fBunchLength) > fCount) {
// Too long bunch detected
- AliWarning(Form("Too long bunch detected in Address=0x%x ! Expected <= %d 10-bit words, found %d !",
- fHWAddress,fCount-fBunchDataIndex,fBunchLength));
+ AliWarning(Form("Too long bunch detected @ %d in Address=0x%x (DDL=%03d) ! Expected <= %d 10-bit words, found %d !", fBunchDataIndex,
+ fHWAddress,fDDLNumber,fCount-fBunchDataIndex,fBunchLength));
fRawReader->AddMinorErrorLog(kAltroBunchHeadErr,Form("hw=0x%x",fHWAddress));
+ if (AliDebugLevel() > 0) HexDumpChannel();
fCount = fBunchLength = -1;
return kFALSE;
}
fStartTimeBin = fBunchData[fBunchDataIndex++];
if (fCheckAltroPayload) {
if ((fStartTimeBin-fBunchLength+1) < 0) {
- AliWarning(Form("Invalid start time-bin in Address=0x%x ! (%d-%d+1) < 0",
- fHWAddress,fStartTimeBin,fBunchLength));
+ AliWarning(Form("Invalid start time-bin @ %d in Address=0x%x (DDL=%03d)! (%d-%d+1) < 0", fBunchDataIndex-1,
+ fHWAddress,fDDLNumber,fStartTimeBin,fBunchLength));
fRawReader->AddMinorErrorLog(kAltroPayloadErr,Form("hw=0x%x",fHWAddress));
+ if (AliDebugLevel() > 0) HexDumpChannel();
fCount = fBunchLength = -1;
return kFALSE;
}
if (fStartTimeBin >= prevTimeBin) {
- AliWarning(Form("Invalid start time-bin in Address=0x%x ! (%d>=%d)",
- fHWAddress,fStartTimeBin,prevTimeBin));
+ AliWarning(Form("Invalid start time-bin @ %d in Address=0x%x (DDL=%03d)! (%d>=%d)", fBunchDataIndex-1,
+ fHWAddress,fDDLNumber,fStartTimeBin,prevTimeBin));
fRawReader->AddMinorErrorLog(kAltroPayloadErr,Form("hw=0x%x",fHWAddress));
+ if (AliDebugLevel() > 0) HexDumpChannel();
fCount = fBunchLength = -1;
return kFALSE;
}
return kTRUE;
}
+//_____________________________________________________________________________
+const UChar_t *AliAltroRawStreamV3::GetChannelPayload() const
+{
+ //returns raw channel data, length 4+(fChannelPayloadSize+2)/3*4
+ if (fChannelStartPos<0 || fChannelPayloadSize<0) return NULL;
+ Int_t channelSize=1+(fChannelPayloadSize+2)/3; // nof 32bit words
+ if (fPosition<fChannelStartPos+channelSize) return NULL;
+ return fData+(fChannelStartPos<<2);
+}
+
//_____________________________________________________________________________
UInt_t AliAltroRawStreamV3::Get32bitWord(Int_t index) const
{
{
// Prints the contents of
// the RCU trailer data
- printf("RCU trailer:\n===========\n");
- printf("FECERRA: 0x%x\nFECERRB: 0x%x\n",fFECERRA,fFECERRB);
- printf("ERRREG2: 0x%x\n",fERRREG2);
+ printf("RCU trailer (Format version %d):\n"
+ "==================================================\n", GetFormatVersion());
+ printf("FECERRA: 0x%x\n", fFECERRA);
+ printf("FECERRB: 0x%x\n", fFECERRB);
+ printf("ERRREG2: 0x%x\n", fERRREG2);
printf("#channels skipped due to address mismatch: %d\n",GetNChAddrMismatch());
printf("#channels skipped due to bad block length: %d\n",GetNChLengthMismatch());
- printf("Active FECs (branch A): 0x%x\nActive FECs (branch B): 0x%x\n",fActiveFECsA,fActiveFECsB);
- printf("Baseline corr: 0x%x\n",GetBaselineCorr());
- printf("Number of presamples: %d\nNumber of postsamples: %d\n",GetNPresamples(),GetNPostsamples());
- printf("Second baseline corr: %d\n",GetSecondBaselineCorr());
- printf("GlitchFilter: %d\n",GetGlitchFilter());
- printf("Number of non-ZS postsamples: %d\nNumber of non-ZS presamples: %d\n",GetNNonZSPostsamples(),GetNNonZSPresamples());
- printf("Number of ALTRO buffers: %d\n",GetNAltroBuffers());
- printf("Number of pretrigger samples: %d\n",GetNPretriggerSamples());
- printf("Number of samples per channel: %d\n",GetNSamplesPerCh());
- printf("Sparse readout: %d\n",GetSparseRO());
- printf("Sampling time: %e s\n",GetTSample());
- printf("L1 Phase: %e s\n",GetL1Phase());
- printf("AltroCFG1: 0x%x\nAltroCFG2: 0x%x\n",GetAltroCFG1(),GetAltroCFG2());
- printf("===========\n");
+ printf("Active FECs (branch A): 0x%x\n", fActiveFECsA);
+ printf("Active FECs (branch B): 0x%x\n", fActiveFECsB);
+ printf("Baseline corr: 0x%x\n",GetBaselineCorr());
+ printf("Number of presamples: %d\n", GetNPresamples());
+ printf("Number of postsamples: %d\n",GetNPostsamples());
+ printf("Second baseline corr: %d\n",GetSecondBaselineCorr());
+ printf("GlitchFilter: %d\n",GetGlitchFilter());
+ printf("Number of non-ZS postsamples: %d\n",GetNNonZSPostsamples());
+ printf("Number of non-ZS presamples: %d\n",GetNNonZSPresamples());
+ printf("Number of ALTRO buffers: %d\n",GetNAltroBuffers());
+ printf("Number of pretrigger samples: %d\n",GetNPretriggerSamples());
+ printf("Number of samples per channel: %d\n",GetNSamplesPerCh());
+ printf("Sparse readout: %d\n",GetSparseRO());
+ printf("Sampling time: %e s\n",GetTSample());
+ printf("L1 Phase: %e s\n",GetL1Phase());
+ printf("AltroCFG1: 0x%x\n",GetAltroCFG1());
+ printf("AltroCFG2: 0x%x\n",GetAltroCFG2());
+ printf("==================================================\n");
}
//_____________________________________________________________________________
}
return -1;
}
+
+//_____________________________________________________________________________
+
+void AliAltroRawStreamV3::HexDumpChannel() const
+{
+ // Print of the Hex Data of the current channel
+ // to decipher read-out warnings and errors
+ if (fCount>0 && fPosition>0) {
+ printf("Hex-Dump of DDL: %3d, RCU ID: %d, HWADDR: 0x%03x\n",
+ fDDLNumber,fRCUId,fHWAddress);
+ printf("32-bit - 2bit 10bit 10bit 10bit - ");
+ printf("Index 10bit 10bit 10bit\n");
+ printf("********** **** ***** ***** ***** - ");
+ printf("***** ****** ****** ******\n");
+ Int_t nwords = (fCount+2)/3+1;
+ for (Int_t iword = 0; iword < nwords; iword++) {
+ UInt_t word32 = Get32bitWord(fPosition-nwords+iword);
+ UInt_t marker = word32 >> 30 & 0x3;
+ UInt_t word101 = word32 >> 20 & 0x3FF;
+ UInt_t word102 = word32 >> 10 & 0x3FF;
+ UInt_t word103 = word32 >> 00 & 0x3FF; // nice octal number
+ printf("0x%08x - 0b%1d%1d 0x%03x 0x%03x 0x%03x",
+ word32,marker>>1,marker&0x1,word101,word102,word103);
+ if (iword == 0) { printf(" - Channel Header\n"); continue; }
+ Int_t base = 3*(iword-1);
+ printf(" - %5d 0x%03x%c 0x%03x%c 0x%03x%c\n", base,
+ fBunchData[base], (fBunchDataIndex == base ? '*' : ' '),
+ fBunchData[base+1], (fBunchDataIndex == base+1 ? '*' : ' '),
+ fBunchData[base+2], (fBunchDataIndex == base+2 ? '*' : ' '));
+ }
+ }
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff