PixelDataFormatter.cc

Go to the documentation of this file.

#include "EventFilter/SiPixelRawToDigi/interface/PixelDataFormatter.h"
 
#include "CondFormats/SiPixelObjects/interface/SiPixelFedCablingTree.h"
#include "CondFormats/SiPixelObjects/interface/SiPixelFedCablingMap.h"
#include "CondFormats/SiPixelObjects/interface/SiPixelFrameConverter.h"
 
#include "CondFormats/SiPixelObjects/interface/SiPixelQuality.h"
 
#include "DataFormats/FEDRawData/interface/FEDRawData.h"
#include "DataFormats/FEDRawData/interface/FEDHeader.h"
#include "DataFormats/FEDRawData/interface/FEDTrailer.h"
 
#include "CondFormats/SiPixelObjects/interface/PixelROC.h"
#include "DataFormats/SiPixelDetId/interface/PixelBarrelName.h"
 
#include "FWCore/Utilities/interface/Exception.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
 
#include <bitset>
#include <sstream>
#include <iostream>
 
using namespace std;
using namespace edm;
using namespace sipixelobjects;
namespace {
  constexpr int LINK_bits = 6;
  constexpr int ROC_bits = 5;
  constexpr int DCOL_bits = 5;
  constexpr int PXID_bits = 8;
  constexpr int ADC_bits = 8;
 
  // Add phase1 constants
  // For phase1
  //GO BACK TO OLD VALUES. THE 48-CHAN FED DOES NOT NEED A NEW FORMAT
  // 28/9/16 d.k.
  constexpr int LINK_bits1 = 6;  // 7;
  constexpr int ROC_bits1 = 5;   // 4;
  // Special for layer 1 bpix rocs 6/9/16 d.k. THIS STAYS.
  constexpr int COL_bits1_l1 = 6;
  constexpr int ROW_bits1_l1 = 7;
 
  // Moved to the header file, keep commented out unti the final version is done/
  // constexpr int ADC_shift  = 0;
  // constexpr int PXID_shift = ADC_shift + ADC_bits;
  // constexpr int DCOL_shift = PXID_shift + PXID_bits;
  // constexpr int ROC_shift  = DCOL_shift + DCOL_bits;
  // constexpr int LINK_shift = ROC_shift + ROC_bits;
  // constexpr PixelDataFormatter::Word32 LINK_mask = ~(~PixelDataFormatter::Word32(0) << LINK_bits);
  // constexpr PixelDataFormatter::Word32 ROC_mask  = ~(~PixelDataFormatter::Word32(0) << ROC_bits);
  // constexpr PixelDataFormatter::Word32 DCOL_mask = ~(~PixelDataFormatter::Word32(0) << DCOL_bits);
  // constexpr PixelDataFormatter::Word32 PXID_mask = ~(~PixelDataFormatter::Word32(0) << PXID_bits);
  // constexpr PixelDataFormatter::Word32 ADC_mask  = ~(~PixelDataFormatter::Word32(0) << ADC_bits);
  //const bool DANEK = false;
}  // namespace
 
PixelDataFormatter::PixelDataFormatter(const SiPixelFedCabling* map, bool phase)
    : theDigiCounter(0),
      theWordCounter(0),
      theCablingTree(map),
      badPixelInfo(nullptr),
      modulesToUnpack(nullptr),
      phase1(phase) {
  int s32 = sizeof(Word32);
  int s64 = sizeof(Word64);
  int s8 = sizeof(char);
  if (s8 != 1 || s32 != 4 * s8 || s64 != 2 * s32) {
    LogError("UnexpectedSizes") << " unexpected sizes: "
                                << "  size of char is: " << s8 << ", size of Word32 is: " << s32
                                << ", size of Word64 is: " << s64 << ", send exception";
  }
  includeErrors = false;
  useQualityInfo = false;
  allDetDigis = 0;
  hasDetDigis = 0;
 
  ADC_shift = 0;
  PXID_shift = ADC_shift + ADC_bits;
  DCOL_shift = PXID_shift + PXID_bits;
  ROC_shift = DCOL_shift + DCOL_bits;
 
  if (phase1) {  // for phase 1
    LINK_shift = ROC_shift + ROC_bits1;
    LINK_mask = ~(~PixelDataFormatter::Word32(0) << LINK_bits1);
    ROC_mask = ~(~PixelDataFormatter::Word32(0) << ROC_bits1);
    // special for layer 1 ROC
    ROW_shift = ADC_shift + ADC_bits;
    COL_shift = ROW_shift + ROW_bits1_l1;
    COL_mask = ~(~PixelDataFormatter::Word32(0) << COL_bits1_l1);
    ROW_mask = ~(~PixelDataFormatter::Word32(0) << ROW_bits1_l1);
    maxROCIndex = 8;
 
  } else {  // for phase 0
    LINK_shift = ROC_shift + ROC_bits;
    LINK_mask = ~(~PixelDataFormatter::Word32(0) << LINK_bits);
    ROC_mask = ~(~PixelDataFormatter::Word32(0) << ROC_bits);
    maxROCIndex = 25;
  }
 
  DCOL_mask = ~(~PixelDataFormatter::Word32(0) << DCOL_bits);
  PXID_mask = ~(~PixelDataFormatter::Word32(0) << PXID_bits);
  ADC_mask = ~(~PixelDataFormatter::Word32(0) << ADC_bits);
 
  if (phase1) {
    errorcheck = std::unique_ptr<ErrorCheckerBase>(new ErrorChecker());
  } else {
    errorcheck = std::unique_ptr<ErrorCheckerBase>(new ErrorCheckerPhase0());
  }
}
 
void PixelDataFormatter::setErrorStatus(bool ErrorStatus) {
  includeErrors = ErrorStatus;
  errorcheck->setErrorStatus(includeErrors);
}
 
void PixelDataFormatter::setQualityStatus(bool QualityStatus, const SiPixelQuality* QualityInfo) {
  useQualityInfo = QualityStatus;
  badPixelInfo = QualityInfo;
}
 
void PixelDataFormatter::setModulesToUnpack(const std::set<unsigned int>* moduleIds) { modulesToUnpack = moduleIds; }
 
void PixelDataFormatter::passFrameReverter(const SiPixelFrameReverter* reverter) { theFrameReverter = reverter; }
 
void PixelDataFormatter::interpretRawData(
    bool& errorsInEvent, int fedId, const FEDRawData& rawData, Collection& digis, Errors& errors) {
  using namespace sipixelobjects;
 
  int nWords = rawData.size() / sizeof(Word64);
  if (nWords == 0)
    return;
 
  SiPixelFrameConverter converter(theCablingTree, fedId);
 
  // check CRC bit
  const Word64* trailer = reinterpret_cast<const Word64*>(rawData.data()) + (nWords - 1);
  if (!errorcheck->checkCRC(errorsInEvent, fedId, trailer, errors))
    return;
 
  // check headers
  const Word64* header = reinterpret_cast<const Word64*>(rawData.data());
  header--;
  bool moreHeaders = true;
  while (moreHeaders) {
    header++;
    LogTrace("") << "HEADER:  " << print(*header);
    bool headerStatus = errorcheck->checkHeader(errorsInEvent, fedId, header, errors);
    moreHeaders = headerStatus;
  }
 
  // check trailers
  bool moreTrailers = true;
  trailer++;
  while (moreTrailers) {
    trailer--;
    LogTrace("") << "TRAILER: " << print(*trailer);
    bool trailerStatus = errorcheck->checkTrailer(errorsInEvent, fedId, nWords, trailer, errors);
    moreTrailers = trailerStatus;
  }
 
  // data words
  theWordCounter += 2 * (nWords - 2);
  LogTrace("") << "data words: " << (trailer - header - 1);
 
  int link = -1;
  int roc = -1;
  int layer = 0;
  PixelROC const* rocp = nullptr;
  bool skipROC = false;
  edm::DetSet<PixelDigi>* detDigis = nullptr;
 
  const Word32* bw = (const Word32*)(header + 1);
  const Word32* ew = (const Word32*)(trailer);
  if (*(ew - 1) == 0) {
    ew--;
    theWordCounter--;
  }
  for (auto word = bw; word < ew; ++word) {
    LogTrace("") << "DATA: " << print(*word);
 
    auto ww = *word;
    if
      UNLIKELY(ww == 0) {
        theWordCounter--;
        continue;
      }
    int nlink = (ww >> LINK_shift) & LINK_mask;
    int nroc = (ww >> ROC_shift) & ROC_mask;
 
    //if(DANEK) cout<<" fed, link, roc "<<fedId<<" "<<nlink<<" "<<nroc<<endl;
 
    if ((nlink != link) | (nroc != roc)) {  // new roc
      link = nlink;
      roc = nroc;
      skipROC = LIKELY(roc < maxROCIndex)
                    ? false
                    : !errorcheck->checkROC(errorsInEvent, fedId, &converter, theCablingTree, ww, errors);
      if (skipROC)
        continue;
      rocp = converter.toRoc(link, roc);
      if
        UNLIKELY(!rocp) {
          errorsInEvent = true;
          errorcheck->conversionError(fedId, &converter, 2, ww, errors);
          skipROC = true;
          continue;
        }
      auto rawId = rocp->rawId();
      bool barrel = PixelModuleName::isBarrel(rawId);
      if (barrel)
        layer = PixelROC::bpixLayerPhase1(rawId);
      else
        layer = 0;
 
      //if(DANEK) cout<<" rocp "<<rocp->print()<<" layer "<<rocp->bpixLayerPhase1(rawId)<<" "
      //  <<layer<<" phase1 "<<phase1<<" rawid "<<rawId<<endl;
 
      if (useQualityInfo & (nullptr != badPixelInfo)) {
        short rocInDet = (short)rocp->idInDetUnit();
        skipROC = badPixelInfo->IsRocBad(rawId, rocInDet);
        if (skipROC)
          continue;
      }
      skipROC = modulesToUnpack && (modulesToUnpack->find(rawId) == modulesToUnpack->end());
      if (skipROC)
        continue;
 
      detDigis = &digis.find_or_insert(rawId);
      if ((*detDigis).empty())
        (*detDigis).data.reserve(32);  // avoid the first relocations
    }
 
    // skip is roc to be skipped ot invalid
    if
      UNLIKELY(skipROC || !rocp) continue;
 
    int adc = (ww >> ADC_shift) & ADC_mask;
    std::unique_ptr<LocalPixel> local;
 
    if (phase1 && layer == 1) {  // special case for layer 1ROC
      // for l1 roc use the roc column and row index instead of dcol and pixel index.
      int col = (ww >> COL_shift) & COL_mask;
      int row = (ww >> ROW_shift) & ROW_mask;
      //if(DANEK) cout<<" layer 1: raw2digi "<<link<<" "<<roc<<" "
      //  <<col<<" "<<row<<" "<<adc<<endl;
 
      LocalPixel::RocRowCol localCR = {row, col};  // build pixel
      //if(DANEK)cout<<localCR.rocCol<<" "<<localCR.rocRow<<endl;
      if
        UNLIKELY(!localCR.valid()) {
          LogDebug("PixelDataFormatter::interpretRawData") << "status #3";
          errorsInEvent = true;
          errorcheck->conversionError(fedId, &converter, 3, ww, errors);
          continue;
        }
      local = std::make_unique<LocalPixel>(localCR);  // local pixel coordinate
      //if(DANEK) cout<<local->dcol()<<" "<<local->pxid()<<" "<<local->rocCol()<<" "<<local->rocRow()<<endl;
 
    } else {  // phase0 and phase1 except bpix layer 1
      int dcol = (ww >> DCOL_shift) & DCOL_mask;
      int pxid = (ww >> PXID_shift) & PXID_mask;
      //if(DANEK) cout<<" raw2digi "<<link<<" "<<roc<<" "
      //<<dcol<<" "<<pxid<<" "<<adc<<" "<<layer<<endl;
 
      LocalPixel::DcolPxid localDP = {dcol, pxid};
      //if(DANEK) cout<<localDP.dcol<<" "<<localDP.pxid<<endl;
 
      if
        UNLIKELY(!localDP.valid()) {
          LogDebug("PixelDataFormatter::interpretRawData") << "status #3";
          errorsInEvent = true;
          errorcheck->conversionError(fedId, &converter, 3, ww, errors);
          continue;
        }
      local = std::make_unique<LocalPixel>(localDP);  // local pixel coordinate
      //if(DANEK) cout<<local->dcol()<<" "<<local->pxid()<<" "<<local->rocCol()<<" "<<local->rocRow()<<endl;
    }
 
    GlobalPixel global = rocp->toGlobal(*local);  // global pixel coordinate (in module)
    (*detDigis).data.emplace_back(global.row, global.col, adc);
    //if(DANEK) cout<<global.row<<" "<<global.col<<" "<<adc<<endl;
    LogTrace("") << (*detDigis).data.back();
  }
}
 
// I do not know what this was for or if it is needed? d.k. 10.14
// Keep it commented out until we are sure that it is not needed.
// void doVectorize(int const * __restrict__ w, int * __restrict__ row, int * __restrict__ col, int * __restrict__ valid, int N, PixelROC const * rocp) {
//   for (int i=0; i<N; ++i) {
//     auto ww = w[i];
//     int dcol = (ww >> DCOL_shift) & DCOL_mask;
//     int pxid = (ww >> PXID_shift) & PXID_mask;
//     // int adc  = (ww >> ADC_shift) & ADC_mask;
//     LocalPixel::DcolPxid local = { dcol, pxid };
//     valid[i] = local.valid();
//     GlobalPixel global = rocp->toGlobal( LocalPixel(local) );
//     row[i]=global.row; col[i]=global.col;
//   }
// }
 
void PixelDataFormatter::formatRawData(unsigned int lvl1_ID,
                                       RawData& fedRawData,
                                       const Digis& digis,
                                       const BadChannels& badChannels) {
  std::map<int, vector<Word32> > words;
 
  // translate digis into 32-bit raw words and store in map indexed by Fed
  for (Digis::const_iterator im = digis.begin(); im != digis.end(); im++) {
    allDetDigis++;
    cms_uint32_t rawId = im->first;
    int layer = 0;
    bool barrel = PixelModuleName::isBarrel(rawId);
    if (barrel)
      layer = PixelROC::bpixLayerPhase1(rawId);
    //if(DANEK) cout<<" layer "<<layer<<" "<<phase1<<endl;
 
    BadChannels::const_iterator detBadChannels = badChannels.find(rawId);
 
    hasDetDigis++;
    const DetDigis& detDigis = im->second;
    for (DetDigis::const_iterator it = detDigis.begin(); it != detDigis.end(); it++) {
      theDigiCounter++;
      const PixelDigi& digi = (*it);
      int fedId = 0;
 
      if (layer == 1 && phase1)
        fedId = digi2wordPhase1Layer1(rawId, digi, words);
      else
        fedId = digi2word(rawId, digi, words);
 
      if (fedId < 0) {
        LogError("FormatDataException") << " digi2word returns error #" << fedId << " Ndigis: " << theDigiCounter
                                        << endl
                                        << " detector: " << rawId << endl
                                        << print(digi) << endl;
      } else if (detBadChannels != badChannels.end()) {
        auto badChannel =
            std::find_if(detBadChannels->second.begin(), detBadChannels->second.end(), [&](const PixelFEDChannel& ch) {
              return (int(ch.fed) == fedId && ch.link == linkId(words[fedId].back()));
            });
        if (badChannel != detBadChannels->second.end()) {
          LogError("FormatDataException") << " while marked bad, found digi for FED " << fedId << " Link "
                                          << linkId(words[fedId].back()) << " on module " << rawId << endl
                                          << print(digi) << endl;
        }
      }  // if (fedId)
    }    // for (DetDigis
  }      // for (Digis
  LogTrace(" allDetDigis/hasDetDigis : ") << allDetDigis << "/" << hasDetDigis;
 
  // fill FED error 25 words
  for (const auto& detBadChannels : badChannels) {
    for (const auto& badChannel : detBadChannels.second) {
      unsigned int FEDError25 = 25;
      Word32 word = (badChannel.link << LINK_shift) | (FEDError25 << ROC_shift);
      words[badChannel.fed].push_back(word);
      theWordCounter++;
    }
  }
 
  typedef std::map<int, vector<Word32> >::const_iterator RI;
  for (RI feddata = words.begin(); feddata != words.end(); feddata++) {
    int fedId = feddata->first;
    // since raw words are written in the form of 64-bit packets
    // add extra 32-bit word to make number of words even if necessary
    if (words.find(fedId)->second.size() % 2 != 0)
      words[fedId].push_back(Word32(0));
 
    // size in Bytes; create output structure
    int dataSize = words.find(fedId)->second.size() * sizeof(Word32);
    int nHeaders = 1;
    int nTrailers = 1;
    dataSize += (nHeaders + nTrailers) * sizeof(Word64);
    FEDRawData* rawData = new FEDRawData(dataSize);
 
    // get begining of data;
    Word64* word = reinterpret_cast<Word64*>(rawData->data());
 
    // write one header
    FEDHeader::set(reinterpret_cast<unsigned char*>(word), 0, lvl1_ID, 0, fedId);
    word++;
 
    // write data
    unsigned int nWord32InFed = words.find(fedId)->second.size();
    for (unsigned int i = 0; i < nWord32InFed; i += 2) {
      *word = (Word64(words.find(fedId)->second[i + 1]) << 32) | words.find(fedId)->second[i];
      LogDebug("PixelDataFormatter") << print(*word);
      word++;
    }
 
    // write one trailer
    FEDTrailer::set(reinterpret_cast<unsigned char*>(word), dataSize / sizeof(Word64), 0, 0, 0);
    word++;
 
    // check memory
    if (word != reinterpret_cast<Word64*>(rawData->data() + dataSize)) {
      string s = "** PROBLEM in PixelDataFormatter !!!";
      throw cms::Exception(s);
    }  // if (word !=
    fedRawData[fedId] = *rawData;
    delete rawData;
  }  // for (RI feddata
}
 
int PixelDataFormatter::digi2word(cms_uint32_t detId,
                                  const PixelDigi& digi,
                                  std::map<int, vector<Word32> >& words) const {
  LogDebug("PixelDataFormatter")
      // <<" detId: " << detId
      << print(digi);
 
  DetectorIndex detector = {detId, digi.row(), digi.column()};
  ElectronicIndex cabling;
  int fedId = theFrameReverter->toCabling(cabling, detector);
  if (fedId < 0)
    return fedId;
 
  //if(DANEK) cout<<" digi2raw "<<detId<<" "<<digi.column()<<" "<<digi.row()<<" "<<digi.adc()<<" "
  //  <<cabling.link<<" "<<cabling.roc<<" "<<cabling.dcol<<" "<<cabling.pxid<<endl;
 
  Word32 word = (cabling.link << LINK_shift) | (cabling.roc << ROC_shift) | (cabling.dcol << DCOL_shift) |
                (cabling.pxid << PXID_shift) | (digi.adc() << ADC_shift);
  words[fedId].push_back(word);
  theWordCounter++;
 
  return fedId;
}
int PixelDataFormatter::digi2wordPhase1Layer1(cms_uint32_t detId,
                                              const PixelDigi& digi,
                                              std::map<int, vector<Word32> >& words) const {
  LogDebug("PixelDataFormatter")
      // <<" detId: " << detId
      << print(digi);
 
  DetectorIndex detector = {detId, digi.row(), digi.column()};
  ElectronicIndex cabling;
  int fedId = theFrameReverter->toCabling(cabling, detector);
  if (fedId < 0)
    return fedId;
 
  int col = ((cabling.dcol) * 2) + ((cabling.pxid) % 2);
  int row = LocalPixel::numRowsInRoc - ((cabling.pxid) / 2);
 
  //if(DANEK) cout<<" layer 1: digi2raw "<<detId<<" "<<digi.column()<<" "<<digi.row()<<" "<<digi.adc()<<" "
  //  <<cabling.link<<" "<<cabling.roc<<" "<<cabling.dcol<<" "<<cabling.pxid<<" "
  //  <<col<<" "<<row<<endl;
 
  Word32 word = (cabling.link << LINK_shift) | (cabling.roc << ROC_shift) | (col << COL_shift) | (row << ROW_shift) |
                (digi.adc() << ADC_shift);
  words[fedId].push_back(word);
  theWordCounter++;
 
  return fedId;
}
 
// obsolete...
int PixelDataFormatter::word2digi(const int fedId,
                                  const SiPixelFrameConverter* converter,
                                  const bool includeErrors,
                                  const bool useQuality,
                                  const Word32& word,
                                  Digis& digis) const {
  // do not interpret false digis
  if (word == 0)
    return 0;
 
  ElectronicIndex cabling;
  cabling.dcol = (word >> DCOL_shift) & DCOL_mask;
  cabling.pxid = (word >> PXID_shift) & PXID_mask;
  cabling.link = (word >> LINK_shift) & LINK_mask;
  cabling.roc = (word >> ROC_shift) & ROC_mask;
  int adc = (word >> ADC_shift) & ADC_mask;
 
  if (debug) {
    LocalPixel::DcolPxid pixel = {cabling.dcol, cabling.pxid};
    LocalPixel local(pixel);
    LogTrace("") << " link: " << cabling.link << ", roc: " << cabling.roc << " rocRow: " << local.rocRow()
                 << ", rocCol:" << local.rocCol() << " (dcol: " << cabling.dcol << ", pxid:" << cabling.pxid
                 << "), adc:" << adc;
  }
 
  if (!converter)
    return 0;
 
  DetectorIndex detIdx;
  int status = converter->toDetector(cabling, detIdx);
  if (status)
    return status;
 
  // exclude ROC(raw) based on bad ROC list bad in SiPixelQuality
  // enable: process.siPixelDigis.UseQualityInfo = True
  // 20-10-2010 A.Y.
  if (useQuality && badPixelInfo) {
    CablingPathToDetUnit path = {static_cast<unsigned int>(fedId),
                                 static_cast<unsigned int>(cabling.link),
                                 static_cast<unsigned int>(cabling.roc)};
    const PixelROC* roc = theCablingTree->findItem(path);
    short rocInDet = (short)roc->idInDetUnit();
    bool badROC = badPixelInfo->IsRocBad(detIdx.rawId, rocInDet);
    if (badROC)
      return 0;
  }
 
  if (modulesToUnpack && modulesToUnpack->find(detIdx.rawId) == modulesToUnpack->end())
    return 0;
 
  digis[detIdx.rawId].emplace_back(detIdx.row, detIdx.col, adc);
 
  theDigiCounter++;
 
  if (debug)
    LogTrace("") << digis[detIdx.rawId].back();
  return 0;
}
 
std::string PixelDataFormatter::print(const PixelDigi& digi) const {
  ostringstream str;
  str << " DIGI: row: " << digi.row() << ", col: " << digi.column() << ", adc: " << digi.adc();
  return str.str();
}
 
std::string PixelDataFormatter::print(const Word64& word) const {
  ostringstream str;
  str << "word64:  " << reinterpret_cast<const bitset<64>&>(word);
  return str.str();
}