X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=FMD%2FAliFMDRawReader.cxx;h=fa0ff8c836cfd922dc6cf60506e68b010642084e;hb=13c4abee0af78d47498b2da6bcf402c97c91f1f4;hp=0206986b411ebf7ce202677b11b07921cd47ffcf;hpb=152e72628c0edf693eeba011aad1edb99117b877;p=u%2Fmrichter%2FAliRoot.git diff --git a/FMD/AliFMDRawReader.cxx b/FMD/AliFMDRawReader.cxx index 0206986b411..fa0ff8c836c 100644 --- a/FMD/AliFMDRawReader.cxx +++ b/FMD/AliFMDRawReader.cxx @@ -58,6 +58,7 @@ #include "AliFMDCalibSampleRate.h" #include "AliFMDCalibStripRange.h" #include "AliFMDAltroMapping.h" +#include "AliFMDUShortMap.h" // #include "AliFMDAltroIO.h" // ALIFMDALTROIO_H #include "AliAltroRawStreamV3.h" #include // ROOT_TArrayS @@ -85,13 +86,19 @@ AliFMDRawReader::AliFMDRawReader(AliRawReader* reader, TTree* tree) fMinStrip(0), fMaxStrip(127), fPreSamp(14+5), - fSeen(0) + fSeen(0), + fVerbose(false), + fErrors("TObject"), + fNErrChanLen(0), + fNErrAddress(0) { // Default CTOR for (Int_t i = 0; i < 3; i++) { fSampleRate[i] = 0; fZeroSuppress[i] = kFALSE; fNoiseFactor[i] = 1; + fL1Phase[i] = 0; + fNErrors[i] = 0; } } @@ -110,8 +117,44 @@ AliFMDRawReader::Exec(Option_t*) ReadAdcs(array); Int_t nWrite = fTree->Fill(); - AliFMDDebug(1, ("Got a grand total of %d digits, wrote %d bytes to tree", - array->GetEntriesFast(), nWrite)); + AliDebugF(1,"Got a grand total of %d digits, wrote %d bytes to tree", + array->GetEntriesFast(), nWrite); + delete array; +} + +//____________________________________________________________________ +void +AliFMDRawReader::AddError(Int_t ddl, Int_t hwaddr) +{ + Int_t nErr = fErrors.GetEntries(); + TObject* o = new (fErrors[nErr]) TObject; + o->SetUniqueID((ddl & 0xFF) << 12 | (hwaddr & 0xFFF)); +} +//____________________________________________________________________ +void +AliFMDRawReader::ReadbackError(const AliAltroRawStreamV3& input, + const char* format, ...) +{ + static char buf[512]; + va_list ap; + va_start(ap, format); + vsnprintf(buf, 511, format, ap); + buf[511] = '\0'; + va_end(ap); + + // { AliWarning(buf); } + if (AliDebugLevel() > 10) { + AliLog::Flush(); + AliWarning(buf); + input.HexDumpChannel(); + } + + Int_t ddl = input.GetDDLNumber(); + Int_t hwaddr = input.GetHWAddress(); + + fReader->AddMinorErrorLog(AliAltroRawStreamV3::kAltroPayloadErr,buf); + AddError(ddl, hwaddr); + fNErrors[ddl]++; } //____________________________________________________________________ @@ -130,33 +173,111 @@ AliFMDRawReader::NewDDL(AliAltroRawStreamV3& input, UShort_t& det) // Get the DDL number UInt_t ddl = input.GetDDLNumber(); - AliFMDDebug(2, ("DDL number %d", ddl)); - - // Get zero suppression flag - fZeroSuppress[ddl] = input.GetZeroSupp(); - AliFMDDebug(3, ("RCU @ DDL %d zero suppression: %s", - ddl, (fZeroSuppress[ddl] ? "yes" : "no"))); - - // WARNING: We store the noise factor in the 2nd baseline - // filters excluded post samples, since we'll never use that - // mode. - fNoiseFactor[ddl] = input.GetNPostsamples(); - AliFMDDebug(3, ("RCU @ DDL %d noise factor: %d", ddl,fNoiseFactor[ddl])); - - // WARNING: We store the sample rate in the number of pre-trigger - // samples, since we'll never use that mode. - fSampleRate[ddl] = input.GetNPretriggerSamples(); - AliFMDDebug(3, ("RCU @ DDL %d sample rate: %d", ddl,fSampleRate[ddl])); + AliDebugF(2,"DDL number %d", ddl); + // Note, previously, the ALTROCFG1 register was interpreted as + // + // Bits Value Description + // 0- 3 0/1 1st Baseline filter, mode + // 4- 5 Over-1 2nd baseline filter, # of pre-samples + // 6- 9 factor 2nd baseline filter, # of post-samples + // 10- 0 2nd baseline filter, enable + // 11-12 00 Zero suppression, glitch filter mode + // 13-15 001 Zero suppression, # of post samples + // 16-17 01 Zero suppression, # of pre samples + // 18 0/1 Zero suppression, enable + // + // The interpretation used in AliAltroRawStreamerV3 - which + // corresponds directly to ALTRO DPCFG register - is + // + // Bits Value Description + // 0- 3 0/1 1st Baseline filter, mode + // 4 0 Polarity (if '1', then "1's inverse") + // 5- 6 01 Zero suppression, # of pre samples + // 7-10 0001 Zero suppression, # of post samples + // 11 0 2nd baseline filter, enable + // 12-13 00 Zero suppression, glitch filter mode + // 14-16 factor 2nd baseline filter, # of post-samples + // 17-18 01 2nd baseline filter, # of pre-samples + // 19 0/1 Zero suppression, enable + // + // From ALTRO DPCF2 we get + // + // 20-23 rate Pre-samples + // + // Writing 'x' for variable values, that means we have the + // following patterns for the 2 cases + // + // bit # 20 16 12 8 4 0 + // old |0x01|0010|00xx|xxxx|xxxx| + // new |x01x|xx00|0000|1010|xxxx| + // + // That means that we can check if bits 10-13 are '1000' or + // '0000', which will tell us if the value was written with the + // new or the old interpretation. That is, we can check that + // + // if (((altrocfg1 >> 10) & 0x8) == 0x8) { + // // old interpretation + // } + // else { + // // New interpretation + // } + // + // That means, that we should never + // + // - change the # of zero suppression post samples + // - Turn on 2nd baseline correction + // - Change the zero-suppression glitch filter mode + // + // This change as introduced in version 1.2 of Rcu++ + // + UInt_t cfg1 = input.GetAltroCFG1(); + if (((cfg1 >> 10) & 0x8) == 0x8) { + UInt_t cfg2 = input.GetAltroCFG2(); + AliDebugF(3,"We have data from older MiniConf 0x%x cfg2=0x%08x", + ((cfg1 >> 10) & 0x8), cfg2); + fZeroSuppress[ddl] = (cfg1 >> 0) & 0x1; + fNoiseFactor[ddl] = (cfg1 >> 6) & 0xF; + fSampleRate[ddl] = (cfg2 >> 20) & 0xF; + } + else { + AliDebugF(3,"We have data from newer MiniConf 0x%x", + ((cfg1 >> 10) & 0x8)); + fZeroSuppress[ddl] = input.GetZeroSupp(); + // WARNING: We store the noise factor in the 2nd baseline + // filters excluded post samples, since we'll never use that + // mode. + // fNoiseFactor[ddl] = input.GetNPostsamples(); + fNoiseFactor[ddl] = input.GetNNonZSPostsamples(); + // WARNING: We store the sample rate in the number of pre-trigger + // samples, since we'll never use that mode. + fSampleRate[ddl] = input.GetNPretriggerSamples(); + // + } + AliDebugF(10,"Phase of DDL=%d is %g (%d)", ddl, input.GetL1Phase(), + input.GetAltroCFG2() & 0x1F); + fL1Phase[ddl] = input.GetAltroCFG2() & 0x1F; // input.GetL1Phase(); + AliDebugF(3,"RCU @ DDL %d zero suppression: %s", + ddl, (fZeroSuppress[ddl] ? "yes" : "no")); + AliDebugF(3,"RCU @ DDL %d noise factor: %d", ddl,fNoiseFactor[ddl]); + AliDebugF(3,"RCU @ DDL %d sample rate: %d", ddl,fSampleRate[ddl]); + + // Get Errors seen Int_t nChAddrMismatch = input.GetNChAddrMismatch(); Int_t nChLenMismatch = input.GetNChLengthMismatch(); - if (nChAddrMismatch != 0) - AliWarning(Form("Got %d channels with address mis-matches for 0x%03x", - nChAddrMismatch, ddl)); - if (nChLenMismatch != 0) - AliWarning(Form("Got %d channels with length mis-matches for 0x%03x", - nChLenMismatch, ddl)); + if (nChAddrMismatch != 0) { + ReadbackError(input, + "Got %d channels with address mis-matches for 0x%03x", + nChAddrMismatch, ddl); + fNErrAddress += nChAddrMismatch; + } + if (nChLenMismatch != 0) { + ReadbackError(input, + "Got %d channels with length mis-matches for 0x%03x", + nChLenMismatch, ddl); + fNErrChanLen += nChLenMismatch; + } // Map DDL number to the detector number AliFMDParameters* pars = AliFMDParameters::Instance(); @@ -171,7 +292,7 @@ AliFMDRawReader::NewDDL(AliAltroRawStreamV3& input, UShort_t& det) //____________________________________________________________________ Int_t -AliFMDRawReader::NewChannel(AliAltroRawStreamV3& input, UShort_t det, +AliFMDRawReader::NewChannel(const AliAltroRawStreamV3& input, UShort_t det, Char_t& ring, UShort_t& sec, Short_t& strbase) { // Processs a new channel. Sets the internal data members @@ -191,7 +312,9 @@ AliFMDRawReader::NewChannel(AliAltroRawStreamV3& input, UShort_t det, Int_t ddl = input.GetDDLNumber(); Int_t hwaddr = input.GetHWAddress(); if (input.IsChannelBad()) { - AliError(Form("Channel 0x%03x is marked as bad!", hwaddr)); + ReadbackError(input, "Ignoring channel %03d/0x%03x with errors", + ddl, hwaddr); + return 0xFFFF; } AliFMDParameters* pars = AliFMDParameters::Instance(); @@ -200,26 +323,68 @@ AliFMDRawReader::NewChannel(AliAltroRawStreamV3& input, UShort_t det, map->ChannelAddress(hwaddr, board, chip, channel); // Then try to map to detector address if (!map->Channel2StripBase(board, chip, channel, ring, sec, strbase)) { - AliError(Form("Failed to get detector id from DDL %d, " - "hardware address 0x%03x", ddl, hwaddr)); + AliErrorF("Failed to get detector id from DDL %d, " + "hardware address 0x%03x", ddl, hwaddr); return -1; } - AliFMDDebug(3, ("Board: 0x%02x, Altro: 0x%x, Channel: 0x%x", - board, chip, channel)); + AliDebugF(7,"Board: 0x%02x, Altro: 0x%x, Channel: 0x%x", + board, chip, channel); // Get the 'conditions' fMinStrip = pars->GetMinStrip(det, ring, sec, strbase); fMaxStrip = pars->GetMaxStrip(det, ring, sec, strbase); fPreSamp = pars->GetPreSamples(det, ring, sec, strbase); - if (fSampleRate[ddl] == 0) + if (fSampleRate[ddl] == 0) { + AliDebugF(7,"Get sample rate for RCU @ DDL %d from OCDB", ddl); fSampleRate[ddl] = pars->GetSampleRate(det, ring, sec, strbase); + } + AliDebugF(7,"RCU @ DDL %d sample rate: %d", ddl,fSampleRate[ddl]); return hwaddr; } +//____________________________________________________________________ +Bool_t +AliFMDRawReader::NewBunch(const AliAltroRawStreamV3& input, + UShort_t& start, UShort_t& length) +{ + // + // Do some checks on the bunch data + // + Int_t ddl = input.GetDDLNumber(); + Int_t hwaddr = input.GetHWAddress(); + UShort_t nSamples = input.GetNSamplesPerCh() + fPreSamp; + UShort_t tstart = input.GetStartTimeBin(); + length = input.GetBunchLength(); + + if (tstart >= nSamples) { + ReadbackError(input, + "Bunch in %03d/0x%03x has an start time greater " + "than number of samples: 0x%x >= 0x%x", + ddl, hwaddr, tstart, nSamples); + return false; + } + if ((int(tstart) - length + 1) < 0) { + ReadbackError(input, + "Bunch in %03d/0x%03x has an invalid length and " + "start time: 0x%x,0x%x (%d-%d+1=%d<0)", + ddl, hwaddr, length, tstart, tstart, length, + int(tstart)-length+1); + return false; + } + if (tstart >= start) { + ReadbackError(input, + "Bunch in %03d/0x%03x has early start time: " + "0x%x >= 0x%x", ddl, hwaddr, tstart, start); + return false; + } + start = tstart; + return true; +} + //____________________________________________________________________ Int_t -AliFMDRawReader::NewSample(AliAltroRawStreamV3& input, +AliFMDRawReader::NewSample(const AliAltroRawStreamV3& input, Int_t i, UShort_t t, UShort_t sec, UShort_t strbase, Short_t& str, UShort_t& samp) { @@ -241,7 +406,7 @@ AliFMDRawReader::NewSample(AliAltroRawStreamV3& input, Int_t hwa = input.GetHWAddress(); const UShort_t* data = input.GetSignals(); Short_t adc = data[i]; - AliFMDDebug(10, ("0x%04x/0x%03x/%04d %4d", ddl, hwa, t, adc)); + AliDebugF(10,"0x%04x/0x%03x/%04d %4d", ddl, hwa, t, adc); AliFMDParameters* pars = AliFMDParameters::Instance(); AliFMDAltroMapping* map = pars->GetAltroMap(); @@ -251,39 +416,65 @@ AliFMDRawReader::NewSample(AliAltroRawStreamV3& input, map->Timebin2Strip(sec, t, fPreSamp, fSampleRate[ddl], stroff, samp); str = strbase + stroff; - AliFMDDebug(20, ("0x%04x/0x%03x/%04d maps to strip %3d sample %d " - "(pre: %d, min: %d, max: %d, rate: %d)", - ddl, hwa, t, str, samp, fPreSamp, - fMinStrip, fMaxStrip, fSampleRate[ddl])); + AliDebugF(20,"0x%04x/0x%03x/%04d=%4d maps to strip %3d sample %d " + "(pre: %d, min: %d, max: %d, rate: %d)", + ddl, hwa, t, adc, str, samp, fPreSamp, + fMinStrip, fMaxStrip, fSampleRate[ddl]); if (str < 0) { - AliFMDDebug(10, ("Got presamples at timebin %d", i)); + AliDebugF(10,"Got presamples at timebin %d", i); return -1; } // VA1 Local strip number Short_t lstrip = (t - fPreSamp) / fSampleRate[ddl] + fMinStrip; - AliFMDDebug(15, ("Checking if strip %d (%d) in range [%d,%d]", - lstrip, str, fMinStrip, fMaxStrip)); + AliDebugF(15,"Checking if strip %d (%d) in range [%d,%d]", + lstrip, str, fMinStrip, fMaxStrip); if (lstrip < fMinStrip || lstrip > fMaxStrip) { - AliFMDDebug(20, ("Strip %03d-%d (%d,%d) from t=%d out of range (%3d->%3d)", - str, samp, lstrip, stroff, t, fMinStrip, fMaxStrip)); - return -1; + AliDebugF(10,"Strip %03d-%d (%d,%d) from t=%d out of range (%3d->%3d)", + str, samp, lstrip, stroff, t, fMinStrip, fMaxStrip); + adc = -1; } // Possibly do pedestal subtraction of signal if (adc > 1023) - AliWarning(Form("ADC value out of range: %4d", adc)); + AliWarningF("ADC value out of range: %4d", adc); return adc; } //____________________________________________________________________ -Bool_t +Int_t AliFMDRawReader::NextSample(UShort_t& det, Char_t& rng, UShort_t& sec, UShort_t& str, UShort_t& sam, UShort_t& rat, Short_t& adc, Bool_t& zs, UShort_t& fac) { // Scan current event for next signal. It returns kFALSE when // there's no more data in the event. + // + // Note, that this member function is in principle very fast, but + // contains less error checking. In particular, channels that have + // bad bunches cannot be checked here. Seeing a bad bunch will only + // skip the remainder of the channel and not reset the already read + // digits. This is potentially dangerous. + // + // Parameters: + // det On return, contain the detector number + // rng On return, contain the ring identifier + // sec On return, contain the sector number + // str On return, contain the strip number + // sam On return, contain the sample number + // rat On return, contain the sample rate + // adc On return, contain the ADC counts + // zs On return, contain the zero-supp. flag + // fac On return, contain the zero-supp. noise factor + // + // Return values: + // 0 No more data + // -1 Read sample belongs to a bad bunch + // >0 Good status - contains bit mask of values + // Bit 1 New DDL + // Bit 2 New Channel + // Bit 3 New Bunch + // Bit 4 New Sample static AliAltroRawStreamV3 stream(fReader); // = 0; static Int_t ddl = -1; static UShort_t tdet = 0; @@ -292,7 +483,7 @@ AliFMDRawReader::NextSample(UShort_t& det, Char_t& rng, UShort_t& sec, static Short_t tstr = 0; static Short_t bstr = -1; static UShort_t tsam = 0; - static UInt_t trate = 0; + // static UInt_t trate = 0; static Int_t hwaddr = -1; static UShort_t start = 0; static UShort_t length = 0; @@ -300,11 +491,16 @@ AliFMDRawReader::NextSample(UShort_t& det, Char_t& rng, UShort_t& sec, static Int_t i = 0; // First entry! if (stream.GetDDLNumber() < 0) { + fReader->Reset(); fReader->Select("FMD"); + stream.Reset(); + stream.SelectRawData("FMD"); + stream.SetCheckAltroPayload(false); + for (Int_t j = 0; j < kNDDL; j++) fNErrors[j] = 0; // Reset variables ddl = -1; - trate = 0; + // trate= 0; tdet = 0; trng = '\0'; tsec = 0; @@ -313,24 +509,64 @@ AliFMDRawReader::NextSample(UShort_t& det, Char_t& rng, UShort_t& sec, hwaddr = -1; } + UShort_t ret = 0; do { + AliDebugF(15, "t=%4d, start=%4d, length=%4d", t, start, length); if (t < start - length + 1) { - if (!stream.NextBunch()) { - if (!stream.NextChannel()) { + AliDebugF(10,"Time t=%d < start-length+1=%d-%d+1 (%3d/0x%03x)", + t, start, length, ddl, hwaddr); + if (hwaddr > 0xFFF || + hwaddr < 0 || + !stream.NextBunch()) { + if (AliDebugLevel() >= 10 && hwaddr > 0xFFF) { + AliDebug(10,"Last channel read was marked bad"); + } + if (AliDebugLevel() >= 10 && hwaddr < 0) { + AliDebug(10,"No more channels"); + } + AliDebug(10,"No next bunch, or first entry"); + if (ddl < 0 || !stream.NextChannel()) { + if (AliDebugLevel() >= 10 && ddl < 0) { + AliDebug(10,"No DDL"); + } + AliDebug(10,"No next channel, or first entry"); if (!stream.NextDDL()) { + AliDebug(10,"No more DDLs"); stream.Reset(); - return kFALSE; + return 0; } ddl = NewDDL(stream, tdet); + AliDebugF(5,"New DDL: %d (%d)", ddl, tdet); + ret |= 0x1; + continue; } hwaddr = NewChannel(stream, tdet, trng, tsec, bstr); + if (hwaddr > 0xFFF) fNErrors[ddl] += 1; + AliDebugF(5,"New Channel: %3d/0x%03x", ddl, hwaddr); + start = 1024; + ret |= 0x2; + continue; } - start = stream.GetStartTimeBin(); - length = stream.GetBunchLength(); + if (!NewBunch(stream, start, length)) { + // AliWarning(Form("Bad bunch in %3d/0x%03x read - " + // "should progress to next channel " + // "(t=%4d,start=%4d,length=%4d)", + // ddl, hwaddr, t,start, length)); + hwaddr = 0xFFFF; // Bad channel + return -1; + } + AliDebugF(5, "New bunch in %3d/0x%03x: start=0x%03x, length=%4d", + ddl, hwaddr, start, length); + ret |= 0x4; t = start; i = 0; + AliDebugF(10,"Got new bunch FMD%d%c[%2d], bunch @ %d, length=%d", + tdet, trng, tsec, start, length); } Int_t tadc = NewSample(stream, i, t, tsec, bstr, tstr, tsam); + AliDebugF(10,"New sample FMD%d%c[%2d,%3d]-%d = 0x%03x", + tdet, trng, tsec, tstr, tsam, tadc); + ret |= 0x8; if (tadc >= 0) { det = tdet; rng = trng; @@ -343,39 +579,51 @@ AliFMDRawReader::NextSample(UShort_t& det, Char_t& rng, UShort_t& sec, fac = fNoiseFactor[ddl]; t--; i++; + AliDebugF(10,"Returning FMD%d%c[%2d,%3d]-%d = 0x%03x (%d,%d,%d)", + det, rng, sec, str, sam, adc, rat, zs, fac); break; } + t--; + i++; } while (true); - - return kTRUE; + AliDebugF(5,"Returning 0x%02x", ret); + return ret; } //____________________________________________________________________ -Bool_t +Int_t AliFMDRawReader::NextSignal(UShort_t& det, Char_t& rng, UShort_t& sec, UShort_t& str, Short_t& adc, Bool_t& zs, UShort_t& fac) { - + // + // Get the next signal + // + // Parameters: + // det On return, the detector + // rng On return, the ring + // sec On return, the sector + // str On return, the strip + // adc On return, the ADC value + // zs On return, whether zero-supp. is enabled + // fac On return, the usd noise factor + // + // Return: + // true if valid data is returned + // + Int_t ret = 0; do { UShort_t samp, rate; - if (!NextSample(det, rng, sec, str, samp, rate, adc, zs, fac)) - return kFALSE; - - Bool_t take = kFALSE; - switch (rate) { - case 1: take = kTRUE; break; - case 2: if (samp == 1) take = kTRUE; break; - case 3: if (samp == 1) take = kTRUE; break; - case 4: if (samp == 2) take = kTRUE; break; - default: if (samp == rate-2) take = kTRUE; break; - } + if ((ret = NextSample(det, rng, sec, str, samp, rate, adc, zs, fac)) <= 0) + return ret; + + Bool_t take = SelectSample(samp, rate); if (!take) continue; break; } while (true); - return kTRUE; + return ret; } //____________________________________________________________________ @@ -401,18 +649,24 @@ AliFMDRawReader::ReadAdcs(TClonesArray* array) { // Read ADC values from raw input into passed TClonesArray of AliFMDDigit // objects. - AliFMDDebug(2, ("Reading ADC values into a TClonesArray")); + AliDebug(3,"Reading ADC values into a TClonesArray"); // Read raw data into the digits array, using AliFMDAltroReader. if (!array) { AliError("No TClonesArray passed"); return kFALSE; } + // static ULong_t unique = 0; const UShort_t kUShortMax = (1 << 16) - 1; fSeen.Reset(kUShortMax); + fErrors.Clear(); + fNErrChanLen = 0; + fNErrAddress = 0; + for (Int_t ddl = 0; ddl < kNDDL; ddl++) fNErrors[ddl] = 0; AliAltroRawStreamV3 input(fReader); input.Reset(); + input.SetCheckAltroPayload(false); input.SelectRawData("FMD"); // Loop over input RORCs @@ -420,21 +674,31 @@ AliFMDRawReader::ReadAdcs(TClonesArray* array) UShort_t det = 0; Int_t ddl = NewDDL(input, det); if (ddl < 0) break; + fNErrors[ddl] = 0; while (input.NextChannel()) { // Get the hardware address, and map that to detector coordinates Char_t ring; UShort_t sec; Short_t strbase; - Int_t hwaddr = NewChannel(input, det, ring, sec, strbase); + Int_t hwaddr = NewChannel(input, det, ring, sec, strbase); if (hwaddr < 0) break; + if (hwaddr > 0xFFF) continue; + UShort_t start = 0x3FF; + Bool_t errors = false; + Int_t first = -1; + Int_t last = -1; // Loop over bunches while (input.NextBunch()) { // Get Lenght of bunch, and pointer to the data const UShort_t* data = input.GetSignals(); - UShort_t start = input.GetStartTimeBin(); - UShort_t length = input.GetBunchLength(); + UShort_t length; + if (!NewBunch(input, start, length)) { + errors = true; + break; + } + // Loop over the data and store it. for (Int_t i = 0; i < length; i++) { @@ -443,29 +707,155 @@ AliFMDRawReader::ReadAdcs(TClonesArray* array) UShort_t samp; Int_t t = start - i; Int_t adc = NewSample(input, i, t, sec, strbase, str, samp); - if (adc < 0) continue; + if (adc <= 0) continue; UShort_t counts = adc; - AliFMDDebug(10, ("FMD%d%c[%02d,%03d]-%d: %4d", - det, ring, sec, str, samp, counts)); + AliDebugF(10,"FMD%d%c[%02d,%03d]-%d: %4d", + det, ring, sec, str, samp, counts); // Check the cache of indicies Int_t idx = fSeen(det, ring, sec, str); + AliFMDDigit* digit = 0; if (idx == kUShortMax) { // We haven't seen this strip yet. fSeen(det, ring, sec, str) = idx = array->GetEntriesFast(); - AliFMDDebug(7,("making digit for FMD%d%c[%2d,%3d]-%d " - "from timebin %4d", - det, ring, sec, str, samp, t)); - new ((*array)[idx]) AliFMDDigit(det, ring, sec, str); + AliDebugF(7, "making digit @ %5d for FMD%d%c[%2d,%3d]-%d " + "from %3d/0x%03x/%4d (def: %d)", + idx, det, ring, sec, str, samp, ddl, hwaddr, t, + fSampleRate[ddl]); + digit = new ((*array)[idx]) AliFMDDigit(det, ring, sec, str); + digit->SetDefaultCounts(fSampleRate[ddl]); } - AliFMDBaseDigit* digit = - static_cast(array->At(idx)); - AliFMDDebug(10, ("Setting FMD%d%c[%2d,%3d]-%d " - "from timebin %4d=%4d (%4d)", - det, ring, sec, str, samp, t, counts, data[i])); + else { + digit = static_cast(array->At(idx)); + } + if (first < 0) first = idx; + last = idx; + AliDebugF(5,"Setting FMD%d%c[%2d,%3d]-%d from timebin " + "%4d=%4d (%4d)", det, ring, sec, str, samp, t, + counts, data[i]); digit->SetCount(samp, counts); + if (AliLog::GetDebugLevel("FMD","") >= 5) digit->Print(); } // for (i) } // while (bunch) + if (errors) { + AliDebugF(2,"Channel %3d/0x%03x contain errors, " + "resetting index %d to %d", ddl, hwaddr, first, last); + if (first >= 0) { + for (Int_t i = first; i <= last; i++) { + AliFMDDigit* digit = static_cast(array->At(i)); + for (Int_t j = 0; j < fSampleRate[ddl]; j++) { + AliDebugF(10,"Resetting strip %s=%d", + digit->GetName(),digit->Counts()); + digit->SetCount(j, kBadSignal); + } + } + } + } + // if (errors && (AliDebugLevel() > 0)) input.HexDumpChannel(); + } // while (channel) + } // while (ddl) + if (fNErrors[0] > 0 || fNErrors[1] > 0 || fNErrors[2] > 0 || + fNErrChanLen > 0 || fNErrAddress > 0) { + // AliLog::Flush(); + AliLog::SetPrintRepetitions(false); + AliWarningF("R/O errors: FMD1=%d, FMD2=%d, FMD3=%d, " + "Channel Length=%d, address=%d", + fNErrors[0], fNErrors[1], fNErrors[2], + fNErrChanLen, fNErrAddress); + AliLog::SetPrintRepetitions(true); + } + if (fVerbose && fErrors.GetEntries() > 0) { + TString msg; + Int_t nErr = fErrors.GetEntries(); + for (Int_t i = 0; i < nErr; i++) { + UInt_t where = fErrors.At(i)->GetUniqueID(); + if (i % 6 == 0) msg.Append("\n"); + msg.Append(Form(" %3d/0x%03x", (where >> 12) & 0xFF, (where & 0xFFF))); + } + // AliLog::Flush(); + AliLog::SetPrintRepetitions(false); + AliWarningF("Got %d errors in channels %s", nErr, msg.Data()); + AliLog::SetPrintRepetitions(true); + } + return kTRUE; +} +//____________________________________________________________________ +Bool_t +AliFMDRawReader::ReadAdcs(AliFMDUShortMap& map) +{ + // Read ADC values from raw input into passed TClonesArray of AliFMDDigit + // objects. + AliDebug(3,"Reading ADC values into a map"); + + // const UShort_t kUShortMax = (1 << 16) - 1; + for (Int_t ddl = 0; ddl < kNDDL; ddl++) fNErrors[ddl] = 0; + + AliAltroRawStreamV3 input(fReader); + input.Reset(); + input.SetCheckAltroPayload(false); + input.SelectRawData("FMD"); + + // Loop over input RORCs + while (input.NextDDL()) { + UShort_t det = 0; + Int_t ddl = NewDDL(input, det); + if (ddl < 0) break; + fNErrors[ddl] = 0; + + while (input.NextChannel()) { + // Get the hardware address, and map that to detector coordinates + Char_t ring; + UShort_t sec; + Short_t strbase; + Int_t hwaddr = NewChannel(input, det, ring, sec, strbase); + if (hwaddr < 0) break; + if (hwaddr > 0xFFF) continue; + + UShort_t start = 0x3FF; + Bool_t errors = false; + Int_t first = -1; + Int_t last = -1; + // Loop over bunches + while (input.NextBunch()) { + // Get Lenght of bunch, and pointer to the data + // const UShort_t* data = input.GetSignals(); + UShort_t length; + if (!NewBunch(input, start, length)) { + errors = true; + break; + } + + + // Loop over the data and store it. + for (Int_t i = 0; i < length; i++) { + // Time + Short_t str; + UShort_t samp; + Int_t t = start - i; + Int_t adc = NewSample(input, i, t, sec, strbase, str, samp); + if (adc < 0) continue; + UShort_t counts = adc; + + AliDebugF(10, "FMD%d%c[%02d,%03d]-%d: %4d", + det, ring, sec, str, samp, counts); + if (SelectSample(samp, fSampleRate[ddl])) + map(det,ring,sec,str) = counts; + if (first < 0) first = str; + last = str; + } // for (i) + } // while (bunch) + if (errors) { + AliDebugF(2, "Channel %3d/0x%03x contain errors, " + "resetting strips %d to %d", ddl, hwaddr, first, last); + if (first >= 0) { + Int_t ds = first <= last ? 1 : -1; + for (Int_t i = first; i != last+ds; i += ds) { + AliDebugF(10, "Resetting strip FMD%d%c[%02d,%03d]=%d", + det,ring,sec,i,map(det,ring,sec,i)); + map(det,ring,sec,i) = kBadSignal; + } + } + } } // while (channel) } // while (ddl) return kTRUE; @@ -478,8 +868,19 @@ Bool_t AliFMDRawReader::ReadSODevent(AliFMDCalibSampleRate* sampleRate, TArrayS &pulseLength, Bool_t* detectors) { - - AliFMDDebug(0, ("Start of SOD/EOD")); + // + // Read SOD event into passed objects. + // + // Parameters: + // samplerate The sample rate object to fill + // striprange The strip range object to fill + // pulseSize The pulse size object to fill + // pulseLength The pulse length (in events) object to fill + // + // Return: + // @c true on success + // + AliDebug(0,"Start of SOD/EOD"); UInt_t shift_clk[18]; UInt_t sample_clk[18]; @@ -487,39 +888,37 @@ Bool_t AliFMDRawReader::ReadSODevent(AliFMDCalibSampleRate* sampleRate, UInt_t strip_high[18]; UInt_t pulse_size[18]; UInt_t pulse_length[18]; + for (size_t i = 0; i < 18; i++) { + shift_clk[i] = 0; + sample_clk[i] = 0; + strip_low[i] = 0; + strip_high[i] = 0; + pulse_size[i] = 0; + pulse_length[i] = 0; + } AliFMDParameters* param = AliFMDParameters::Instance(); AliFMDAltroMapping* map = param->GetAltroMap(); - while(fReader->ReadNextData(fData)) { - - Int_t ddl = fReader->GetDDLID(); + AliAltroRawStreamV3 streamer(fReader); + streamer.Reset(); + streamer.SelectRawData("FMD"); + //fReader->GetDDLID(); + while (streamer.NextDDL()) { + Int_t ddl = streamer.GetDDLNumber(); Int_t detID = fReader->GetDetectorID(); if (detectors) detectors[map->DDL2Detector(ddl)-1] = kTRUE; - AliFMDDebug(0, (" From reader: DDL number is %d , det ID is %d",ddl,detID)); - - fNbytes = fReader->GetDataSize(); + AliDebugF(0," From reader: DDL number is %d , det ID is %d",ddl,detID); - ULong_t nWords = GetNwords(); - UInt_t trailerLast = Get32bitWord(nWords); - AliFMDDebug(20, (" # Bytes: %d, # Words: %d, Last word: 0x%08x", - fNbytes, nWords, trailerLast)); - if ((trailerLast & 0xFFFF0000) != 0xAAAA0000) { - AliWarning(Form("Last word 0x%08x does not match RCU II trailer", - trailerLast)); - //return kFALSE; - } - - // 7 last bits is size of trailer - ULong_t nTrailerWords = trailerLast & 0x7f; - ULong_t nPayloadWords = Get32bitWord(nWords - nTrailerWords+1); + ULong_t nPayloadWords = streamer.GetRCUPayloadSizeInSOD(); + UChar_t* payloadData = streamer.GetRCUPayloadInSOD(); + UInt_t* payloadWords = reinterpret_cast(payloadData); + //UInt_t* payloadWords = streamer.GetRCUPayloadInSOD(); - AliFMDDebug(20, (" # trailer words: %d, # payload words: %d", - nTrailerWords, nPayloadWords)); + //std::cout<> 21) & 0xf); @@ -544,14 +943,15 @@ Bool_t AliFMDRawReader::ReadSODevent(AliFMDCalibSampleRate* sampleRate, readDataWord = kTRUE; case 0x1: // Fec cmd case 0x2: // Fec write - i++; + i++; + payloadWords++; break; case 0x4: // Loop case 0x5: // Wait break; case 0x6: // End sequence case 0x7: // End Mem - i = nPayloadWords + 1; + i = nPayloadWords + 1; break; default: break; @@ -560,17 +960,17 @@ Bool_t AliFMDRawReader::ReadSODevent(AliFMDCalibSampleRate* sampleRate, //Don't read unless we have a FEC_RD if(!readDataWord) continue; - UInt_t dataWord = Get32bitWord(i); + UInt_t dataWord = *payloadWords;//Get32bitWord(i); UInt_t data = (0xFFFFF & dataWord) ; //UInt_t data = (0xFFFF & dataWord) ; if(error) { - AliWarning(Form("error bit detected at Word 0x%06x; " - "error % d, type %d, bc_not_altro %d, " - "bcast %d, board 0x%02x, chip 0x%x, " - "channel 0x%02x, instruction 0x%03x", - address, error, type, bc_not_altro, - bcast,board,chip,channel,instruction)); + AliWarningF("error bit detected at Word 0x%06x; " + "error % d, type %d, bc_not_altro %d, " + "bcast %d, board 0x%02x, chip 0x%x, " + "channel 0x%02x, instruction 0x%03x", + address, error, type, bc_not_altro, + bcast,board,chip,channel,instruction); //process error continue; } @@ -651,6 +1051,8 @@ Bool_t AliFMDRawReader::ReadSODevent(AliFMDCalibSampleRate* sampleRate, case 0x24: break; // FMD: L2 timeout case 0x25: // FMD: Shift clk shift_clk[board] = ((data >> 8 ) & 0xFF); + AliDebugF(30, "Read shift_clk=%d for board 0x%02x", + shift_clk[board], board); break; case 0x26: // FMD: Strips strip_low[board] = ((data >> 0 ) & 0xFF); @@ -664,6 +1066,8 @@ Bool_t AliFMDRawReader::ReadSODevent(AliFMDCalibSampleRate* sampleRate, case 0x2A: break; // FMD: Preamp ref case 0x2B: // FMD: Sample clk sample_clk[board] = ((data >> 8 ) & 0xFF); + AliDebugF(30,"Read sample_clk=%d for board 0x%02x", + sample_clk[board], board); break; case 0x2C: break; // FMD: Commands case 0x4B: // FMD: Cal events @@ -672,13 +1076,14 @@ Bool_t AliFMDRawReader::ReadSODevent(AliFMDCalibSampleRate* sampleRate, default: break; } - AliFMDDebug(50, ("instruction 0x%x, dataword 0x%x", - instruction,dataWord)); - } + AliDebugF(50,"instruction 0x%x, dataword 0x%x", + instruction,dataWord); + } // End of loop over Result memory event - UShort_t det,sector; - Short_t strip; - Char_t ring; + UShort_t det = 0; + UShort_t sector = 0; + Short_t strip = -1; + Char_t ring = '\0'; const UInt_t boards[4] = {0,1,16,17}; for(Int_t i=0;i<4;i++) { @@ -688,7 +1093,8 @@ Bool_t AliFMDRawReader::ReadSODevent(AliFMDCalibSampleRate* sampleRate, det = map->DDL2Detector(ddl); map->Channel2StripBase(boards[i], chip, channel, ring, sector, strip); - UInt_t samplerate = 1; + UInt_t samplerate = 0; +#if USE_VOTE if(sample_clk[boards[i]] == 0) { if(ddl == 0) { Int_t sample1 = sample_clk[boards[0]]; @@ -719,19 +1125,22 @@ Bool_t AliFMDRawReader::ReadSODevent(AliFMDCalibSampleRate* sampleRate, strip_high[boards[i]] = strip_high[boards[idx]]; pulse_length[boards[i]] = pulse_length[boards[idx]]; pulse_size[boards[i]] = pulse_size[boards[idx]]; - AliFMDDebug(0, ("Vote taken for ddl %d, board 0x%x", - ddl,boards[i])); + AliDebugF(3,"Vote taken for ddl %d, board 0x%x", + ddl,boards[i]); } } } +#endif if(sample_clk[boards[i]]) samplerate = shift_clk[boards[i]]/sample_clk[boards[i]]; + AliDebugF(10,"Sample rate for board 0x%02x is %d", + boards[i], samplerate); sampleRate->Set(det,ring,sector,0,samplerate); stripRange->Set(det,ring,sector,0, strip_low[boards[i]],strip_high[boards[i]]); - AliFMDDebug(20, ("det %d, ring %c, ",det,ring)); + AliDebugF(20,"det %d, ring %c, ",det,ring); pulseLength.AddAt(pulse_length[boards[i]], GetHalfringIndex(det,ring,boards[i]/16)); pulseSize.AddAt(pulse_size[boards[i]], @@ -739,14 +1148,14 @@ Bool_t AliFMDRawReader::ReadSODevent(AliFMDCalibSampleRate* sampleRate, - AliFMDDebug(20, (": Board: 0x%02x\n" - "\tstrip_low %3d, strip_high %3d\n" - "\tshift_clk %3d, sample_clk %3d\n" - "\tpulse_size %3d, pulse_length %3d", - boards[i], - strip_low[boards[i]], strip_high[boards[i]], - shift_clk[boards[i]], sample_clk[boards[i]], - pulse_size[boards[i]],pulse_length[boards[i]])); + AliDebugF(20,": Board: 0x%02x\n" + "\tstrip_low %3d, strip_high %3d\n" + "\tshift_clk %3d, sample_clk %3d\n" + "\tpulse_size %3d, pulse_length %3d", + boards[i], + strip_low[boards[i]], strip_high[boards[i]], + shift_clk[boards[i]], sample_clk[boards[i]], + pulse_size[boards[i]],pulse_length[boards[i]]); } } @@ -754,7 +1163,7 @@ Bool_t AliFMDRawReader::ReadSODevent(AliFMDCalibSampleRate* sampleRate, AliFMDParameters::Instance()->SetSampleRate(sampleRate); AliFMDParameters::Instance()->SetStripRange(stripRange); - AliFMDDebug(0, ("End of SOD/EOD")); + AliDebug(0,"End of SOD/EOD"); return kTRUE; } @@ -776,7 +1185,7 @@ UInt_t AliFMDRawReader::Get32bitWord(Int_t idx) if (index < 4) { // fRawReader->AddFatalErrorLog(k32bitWordReadErr,Form("pos = %d",index)); // PrintDebug(); - AliWarning(Form("Invalid raw data payload position (%d) !",index)); + AliWarningF("Invalid raw data payload position (%d) !",index); } UInt_t word = 0; @@ -790,8 +1199,19 @@ UInt_t AliFMDRawReader::Get32bitWord(Int_t idx) } //_____________________________________________________________________ Int_t AliFMDRawReader::GetHalfringIndex(UShort_t det, Char_t ring, - UShort_t board) { - + UShort_t board) const +{ + // + // Get short index for a given half-ring + // + // Parameters: + // det Detector number + // ring Ring identifer + // board Board number + // + // Return: + // + // UShort_t iring = (ring == 'I' ? 1 : 0); Int_t index = (((det-1) << 2) | (iring << 1) | (board << 0));