SiStripSpyUtilities.cc

Go to the documentation of this file.

#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/ESHandle.h"
 
// Needed for the FED cabling and pedestals
#include "CondFormats/DataRecord/interface/SiStripFedCablingRcd.h"
#include "CalibTracker/Records/interface/SiStripDetCablingRcd.h"
#include "CondFormats/SiStripObjects/interface/SiStripFedCabling.h"
#include "CondFormats/DataRecord/interface/SiStripPedestalsRcd.h"
#include "CondFormats/DataRecord/interface/SiStripNoisesRcd.h"
 
#include "DQM/SiStripMonitorHardware/interface/SiStripFEDSpyBuffer.h"
#include "DQM/SiStripMonitorHardware/interface/SiStripSpyUtilities.h"
 
using edm::LogError;
using edm::LogInfo;
using edm::LogWarning;
 
namespace sistrip {
  SpyUtilities::SpyUtilities()
      : cabling_(nullptr),
        cacheId_(0),
        detCabling_(nullptr),
        cacheIdDet_(0),
        pedsCacheId_(0),
        pedsHandle_(nullptr),
        noiseCacheId_(0),
        noiseHandle_(nullptr) {}
 
  SpyUtilities::~SpyUtilities() {
    if (cabling_)
      cabling_ = nullptr;
    if (detCabling_)
      detCabling_ = nullptr;
  }
 
  const SiStripFedCabling* SpyUtilities::getCabling(const edm::EventSetup& setup) {
    uint32_t cache_id = setup.get<SiStripFedCablingRcd>().cacheIdentifier();
 
    if (cacheId_ != cache_id) {  // If the cache ID has changed since the last update...
      // Update the cabling object
      edm::ESHandle<SiStripFedCabling> c;
      setup.get<SiStripFedCablingRcd>().get(c);
      cabling_ = c.product();
 
      //          if ( edm::isDebugEnabled() ) {
      //        if ( !cacheId_ ) { // First time cabling has been retrieved - print it out in full.
      //          std::stringstream ss;
      //          ss << "[sistrip::SpyChannelUnpackerModule::" << __func__ << "]"
      //         << " Updating cabling for first time..." << std::endl
      //         << " Terse print out of FED cabling:" << std::endl;
      //          //cabling_->terse(ss);
      //          //LogTrace("SiStripMonitorHardwareUnpacker") << ss.str();
      //        } // end of cacheId_ check
      //      } // end of debugEnabled check
 
      //       if ( edm::isDebugEnabled() ) {
      //    std::stringstream sss;
      //    sss << "[sistrip::SpyUtilities::" << __func__ << "]"
      //        << " Summary of FED cabling:" << std::endl;
      //    cabling_->summary(sss);
      //    LogTrace("SiStripSpyUtilities") << sss.str();
      //       }
 
      // Update the cache ID with the new value.
      cacheId_ = cache_id;
 
    }  // end of new cache ID check
 
    return cabling_;
  }
 
  const SiStripDetCabling* SpyUtilities::getDetCabling(const edm::EventSetup& setup) {
    uint32_t cache_id = setup.get<SiStripDetCablingRcd>().cacheIdentifier();  //.get( cabling_ );
 
    if (cacheIdDet_ != cache_id) {  // If the cache ID has changed since the last update...
      // Update the cabling object
      edm::ESHandle<SiStripDetCabling> c;
      setup.get<SiStripDetCablingRcd>().get(c);
      detCabling_ = c.product();
      cacheIdDet_ = cache_id;
    }  // end of new cache ID check
 
    return detCabling_;
  }
 
  edm::ESHandle<SiStripPedestals> SpyUtilities::getPedestalHandle(const edm::EventSetup& eventSetup) {
    //check if new pedestal values are available
    uint32_t lCacheId = eventSetup.get<SiStripPedestalsRcd>().cacheIdentifier();
    if (lCacheId != pedsCacheId_) {
      eventSetup.get<SiStripPedestalsRcd>().get(pedsHandle_);
      pedsCacheId_ = lCacheId;
    }
 
    return pedsHandle_;
  }
 
  edm::ESHandle<SiStripNoises> SpyUtilities::getNoiseHandle(const edm::EventSetup& eventSetup) {
    //check if new noise values are available
    uint32_t lCacheId = eventSetup.get<SiStripNoisesRcd>().cacheIdentifier();
    if (lCacheId != noiseCacheId_) {
      eventSetup.get<SiStripNoisesRcd>().get(noiseHandle_);
      noiseCacheId_ = lCacheId;
    }
 
    return noiseHandle_;
  }
 
  const SpyUtilities::Frame SpyUtilities::extractFrameInfo(
      const edm::DetSetVector<SiStripRawDigi>::detset& channelDigis, bool aPrintDebug) {
    SpyUtilities::Frame lFrame;
    lFrame.detId = channelDigis.detId();
    lFrame.firstHeaderBit = 0;
    lFrame.firstTrailerBit = 0;
    lFrame.digitalLow = 0;
    lFrame.digitalHigh = 0;
    lFrame.baseline = 0;
    lFrame.apvErrorBit.first = false;
    lFrame.apvErrorBit.second = false;
    lFrame.apvAddress.first = 0;
    lFrame.apvAddress.second = 0;
 
    uint16_t min = 0x3FF;
    uint16_t max = 0;
    edm::DetSetVector<SiStripRawDigi>::detset::const_iterator iDigi = channelDigis.begin();
    const edm::DetSetVector<SiStripRawDigi>::detset::const_iterator endChannelDigis = channelDigis.end();
 
    //counters for outputting warnings
    uint16_t numzeroes = 0, numsats = 0;
 
    if (iDigi == endChannelDigis)
      return lFrame;
 
    for (; iDigi != endChannelDigis; ++iDigi) {
      const uint16_t val = iDigi->adc();
      if (val < min)
        min = val;
      if (val > max)
        max = val;
      if (val == 0)
        numzeroes++;
      if (val == 0x3FF)
        numsats++;
      lFrame.baseline += val;
    }
 
    if (!channelDigis.empty())
      lFrame.baseline = lFrame.baseline / channelDigis.size();
    lFrame.digitalLow = min;
    lFrame.digitalHigh = max;
 
    const uint16_t threshold = static_cast<uint16_t>((2.0 * static_cast<double>(max - min)) / 3.0);
 
    if (aPrintDebug) {
      if (edm::isDebugEnabled()) {
        LogDebug("SiStripSpyUtilities") << "Channel with key: " << lFrame.detId << " Min: " << min << " Max: " << max
                                        << " Range: " << (max - min) << " Threshold: " << threshold;
      }
      if (numzeroes > 0 || numsats > 0) {
        edm::LogWarning("SiStripSpyUtilities") << "Channel with key: " << lFrame.detId << " has " << numzeroes
                                               << " zero and " << numsats << " saturated samples.";
      }
    }
 
    lFrame.firstHeaderBit = findHeaderBits(channelDigis, threshold);
    lFrame.firstTrailerBit = findTrailerBits(channelDigis, threshold);
 
    lFrame.apvErrorBit = findAPVErrorBits(channelDigis, threshold, lFrame.firstHeaderBit);
    lFrame.apvAddress = findAPVAddresses(channelDigis, threshold, lFrame.firstHeaderBit);
 
    return lFrame;
  }
 
  const uint16_t SpyUtilities::range(const SpyUtilities::Frame& aFrame) {
    if (aFrame.digitalHigh < aFrame.digitalLow)
      return 0;
    else
      return aFrame.digitalHigh - aFrame.digitalLow;
  }
 
  const uint16_t SpyUtilities::threshold(const SpyUtilities::Frame& aFrame) {
    return static_cast<uint16_t>((2.0 * static_cast<double>(range(aFrame))) / 3.0);
  }
 
  const uint8_t SpyUtilities::extractAPVaddress(const SpyUtilities::Frame& aFrame) {
    if (aFrame.apvErrorBit.first == false)
      return aFrame.apvAddress.first;
    else if (aFrame.apvErrorBit.second == false) {
      return aFrame.apvAddress.second;
    } else {
      return 0;
    }
  }
 
  void SpyUtilities::getMajorityHeader(const edm::DetSetVector<SiStripRawDigi>* aInputDigis,
                                       uint16_t& aFirstHeaderBit,
                                       bool printResult) {
    std::vector<uint16_t> lFirstBitVec;
    lFirstBitVec.reserve(aInputDigis->size());
    aFirstHeaderBit = 0;
    edm::DetSetVector<SiStripRawDigi>::const_iterator lDigis = aInputDigis->begin();
 
    for (; lDigis != aInputDigis->end(); lDigis++) {
      sistrip::SpyUtilities::Frame lFrame = sistrip::SpyUtilities::extractFrameInfo(*lDigis);
      lFirstBitVec.push_back(lFrame.firstHeaderBit);
    }
 
    std::pair<uint16_t, uint32_t> lMaj = sistrip::SpyUtilities::findMajorityValue(lFirstBitVec);
    aFirstHeaderBit = lMaj.first;
    uint32_t lMajorityCounter = lMaj.second;
 
    //header is 24-sample long (2*8+2+6)
    uint16_t lFirstTrailerBit = aFirstHeaderBit + 24 + sistrip::STRIPS_PER_FEDCH;
 
    if (printResult) {
      LogInfo("SiStripSpyUtilities") << " -- Found majority position of first header (trailer) bit: " << aFirstHeaderBit
                                     << " (" << lFirstTrailerBit << ") for " << lMajorityCounter << " out of "
                                     << lFirstBitVec.size() << " channels." << std::endl;
    }
  }
 
  const bool SpyUtilities::isValid(const SpyUtilities::Frame& aFrame,
                                   const FrameQuality& aQuality,
                                   const uint16_t aExpectedPos) {
    uint16_t lRange = sistrip::SpyUtilities::range(aFrame);
 
    if (lRange < aQuality.minDigiRange || lRange > aQuality.maxDigiRange) {
      return false;
    } else if (aFrame.digitalLow < aQuality.minZeroLight || aFrame.digitalLow > aQuality.maxZeroLight) {
      return false;
    } else if (aFrame.digitalHigh < aQuality.minTickHeight || aFrame.digitalHigh > aQuality.maxTickHeight) {
      return false;
    }
    //if expectedPos=0: return true whatever the position of header is...
    else if (aExpectedPos > 0 && (!(aFrame.firstHeaderBit == aExpectedPos &&
                                    aFrame.firstTrailerBit == aExpectedPos + 24 + sistrip::STRIPS_PER_FEDCH))) {
      return false;
    } else if (aFrame.apvErrorBit.first && aFrame.apvErrorBit.second) {
      return false;
    }
 
    return true;
  }
 
  const uint16_t SpyUtilities::findHeaderBits(const edm::DetSetVector<SiStripRawDigi>::detset& channelDigis,
                                              const uint16_t threshold) {
    // Loop over digis looking for first above threshold
    uint8_t aboveThreshold = 0;
    bool foundHeader = false;
    uint16_t count = 0;
 
    edm::DetSetVector<SiStripRawDigi>::detset::const_iterator iDigi = channelDigis.begin();
    const edm::DetSetVector<SiStripRawDigi>::detset::const_iterator endChannelDigis = channelDigis.end();
 
    for (; iDigi != endChannelDigis; ++iDigi) {
      if (iDigi->adc() > threshold) {
        aboveThreshold++;
      } else {
        aboveThreshold = 0;
      }
      if (aboveThreshold == 6) {
        foundHeader = true;
        break;
      }
      count++;
    }  //end of loop over digis
 
    //break before incrementing the last time... so count-5 is the first header sample.
    if (foundHeader && count < 5)
      return 0;
    if (foundHeader)
      return count - 5;
    return sistrip::SPY_SAMPLES_PER_CHANNEL;
  }
 
  const uint16_t SpyUtilities::findTrailerBits(const edm::DetSetVector<SiStripRawDigi>::detset& channelDigis,
                                               const uint16_t threshold) {
    // Loop over digis looking for last above threshold
    uint8_t aboveThreshold = 0;
    bool foundTrailer = false;
 
    //discard the first 30 values, which will have some digital high in them...
    //start searching from the expected position : sometimes after 24+256 samples,
    //normally at 6+24+256 if 6-bit low before tickmark header bits...
    uint16_t count = 24 + sistrip::STRIPS_PER_FEDCH;
 
    if (count >= sistrip::SPY_SAMPLES_PER_CHANNEL)
      return sistrip::SPY_SAMPLES_PER_CHANNEL;
 
    edm::DetSetVector<SiStripRawDigi>::detset::const_iterator iDigi = channelDigis.begin() + count;
    const edm::DetSetVector<SiStripRawDigi>::detset::const_iterator endChannelDigis = channelDigis.end();
 
    for (; iDigi != endChannelDigis; ++iDigi) {
      if (iDigi->adc() > threshold) {
        aboveThreshold++;
      } else {
        aboveThreshold = 0;
      }
      if (aboveThreshold == 2) {
        foundTrailer = true;
        break;
      }
      count++;
    }  //end of loop over digis
 
    //break before incrementing the last time... so count-1 is the first trailer sample.
    if (foundTrailer && count < 1)
      return 0;
    if (foundTrailer)
      return count - 1;
    return sistrip::SPY_SAMPLES_PER_CHANNEL;
  }
 
  const std::pair<bool, bool> SpyUtilities::findAPVErrorBits(
      const edm::DetSetVector<SiStripRawDigi>::detset& channelDigis,
      const uint16_t threshold,
      const uint16_t aFirstBits) {
    // Loop over digis looking for firstHeader+6+16
    uint16_t count = aFirstBits + 22;
 
    std::pair<bool, bool> lPair = std::pair<bool, bool>(false, false);
 
    //if header invalid: we don't know what apverr is....
    if (count >= sistrip::SPY_SAMPLES_PER_CHANNEL - 1)
      return lPair;
 
    edm::DetSetVector<SiStripRawDigi>::detset::const_iterator iDigi = channelDigis.begin() + count;
    const edm::DetSetVector<SiStripRawDigi>::detset::const_iterator endChannelDigis = channelDigis.end();
 
    //double check....
    if (iDigi == endChannelDigis)
      return lPair;
 
    if (iDigi->adc() <= threshold)
      lPair.first = true;
    ++iDigi;
 
    //triple check...
    if (iDigi == endChannelDigis)
      return std::pair<bool, bool>(false, false);
 
    if (iDigi->adc() <= threshold)
      lPair.second = true;
 
    return lPair;
  }
 
  const std::pair<uint8_t, uint8_t> SpyUtilities::findAPVAddresses(
      const edm::DetSetVector<SiStripRawDigi>::detset& channelDigis,
      const uint16_t threshold,
      const uint16_t aFirstBits) {
    // Loop over digis looking for firstHeader+6
    uint16_t count = aFirstBits + 6;
    std::pair<uint8_t, uint8_t> lPair = std::pair<uint8_t, uint8_t>(0, 0);
 
    //check enough room to have 16 values....
    if (count >= sistrip::SPY_SAMPLES_PER_CHANNEL - 15)
      return lPair;
 
    edm::DetSetVector<SiStripRawDigi>::detset::const_iterator iDigi = channelDigis.begin() + count;
    const edm::DetSetVector<SiStripRawDigi>::detset::const_iterator endChannelDigis = channelDigis.end();
 
    //double check....
    if (iDigi == endChannelDigis)
      return lPair;
 
    for (uint8_t i = 0; i < 16; ++i) {
      if (iDigi->adc() > threshold) {
        //data is MSB first
        if (i % 2 == 0)
          lPair.first |= (0x80 >> static_cast<uint8_t>(i / 2));
        else
          lPair.second |= (0x80 >> static_cast<uint8_t>(i / 2));
      }
      ++iDigi;
    }
 
    return lPair;
  }
 
  std::string SpyUtilities::print(const SpyUtilities::Frame& aFrame, std::string aErr) {
    std::ostringstream lOs;
    lOs << " ------------------------------------------------------" << std::endl
        << " -- Error: " << aErr << std::endl
        << " ------- Printing Frame for detId " << aFrame.detId << " --------" << std::endl
        << " -- firstHeaderBit = " << aFrame.firstHeaderBit << std::endl
        << " -- firstTrailerBit = " << aFrame.firstTrailerBit << std::endl
        << " -- digitalLow = " << aFrame.digitalLow << std::endl
        << " -- digitalHigh = " << aFrame.digitalHigh << std::endl
        << " -- baseline = " << aFrame.baseline << std::endl
        << " -- apvErrorBits = " << aFrame.apvErrorBit.first << " " << aFrame.apvErrorBit.second << std::endl
        << " -- apvAddresses = " << static_cast<uint16_t>(aFrame.apvAddress.first) << " "
        << static_cast<uint16_t>(aFrame.apvAddress.second) << std::endl
        << " ------------------------------------------------------" << std::endl;
    return lOs.str();
  }
 
  void SpyUtilities::fedIndex(const uint32_t aFedIndex, uint16_t& aFedId, uint16_t& aFedChannel) {
    //find the corresponding detId (for the pedestals)
    aFedId = static_cast<uint16_t>(aFedIndex / sistrip::FEDCH_PER_FED);
    aFedChannel = static_cast<uint16_t>(aFedIndex % sistrip::FEDCH_PER_FED);
 
    if (aFedId < sistrip::FED_ID_MIN || aFedId > sistrip::FED_ID_MAX || aFedChannel >= sistrip::FEDCH_PER_FED) {
      aFedId = sistrip::invalid_;
      aFedChannel = sistrip::invalid_;
    }
  }
 
  std::pair<uint16_t, uint32_t> SpyUtilities::findMajorityValue(std::vector<uint16_t>& values, const uint16_t aFedId) {
    uint32_t lTot = values.size();
    if (!lTot)
      return std::pair<uint16_t, uint32_t>(0, 0);
 
    std::sort(values.begin(), values.end());
    uint32_t lMajorityCounter = 0;
    uint16_t lMaj = 0;
 
    std::vector<uint16_t>::iterator lIter = values.begin();
    for (; lIter != values.end();) {
      uint32_t lCounter = std::count(lIter, values.end(), *lIter);
      if (lCounter > lMajorityCounter) {
        lMajorityCounter = lCounter;
        lMaj = *lIter;
      }
      lIter += lCounter;
    }
 
    //std::cout << " -- Found majority value " << lMaj << " for " << lMajorityCounter << " elements out of " << values.size() << "." << std::endl;
 
    if (static_cast<float>(lMajorityCounter) / lTot < 0.5) {
      LogError("SiStripSpyUtilities") << " -- Found majority position for index " << aFedId << ": " << lMaj
                                      << " for less than half the values : " << lMajorityCounter << " out of " << lTot
                                      << " values." << std::endl;
    }
 
    return std::pair<uint16_t, uint32_t>(lMaj, lMajorityCounter);
  }
 
  void SpyUtilities::fillFEDMajorities(const std::map<uint32_t, uint32_t>& channelValues,
                                       std::vector<uint32_t>& fedMajoritiesToFill) {
    std::map<uint32_t, uint32_t>::const_iterator lMapIter = channelValues.begin();
    uint16_t lPreviousFedId = 0;
    std::vector<uint16_t> lAddrVec;
    lAddrVec.reserve(sistrip::FEDCH_PER_FED);
    fedMajoritiesToFill.resize(sistrip::FED_ID_MAX - sistrip::FED_ID_MIN + 1, 0);
    uint32_t lChCount = 0;
 
    for (; lMapIter != channelValues.end(); ++lMapIter, ++lChCount) {
      uint16_t lFedId = static_cast<uint16_t>(lMapIter->first / sistrip::FEDCH_PER_FED);
 
      if (lPreviousFedId == 0) {
        lPreviousFedId = lFedId;
      }
      if (lFedId == lPreviousFedId) {
        lAddrVec.push_back(lMapIter->second);
      }
      if (lFedId != lPreviousFedId || (lChCount == channelValues.size() - 1)) {
        //extract majority address
 
        uint32_t lMaj = sistrip::SpyUtilities::findMajorityValue(lAddrVec, lPreviousFedId).first;
        fedMajoritiesToFill[lPreviousFedId] = lMaj;
 
        lAddrVec.clear();
 
        //if new fed, fill the first channel
        if (lFedId != lPreviousFedId) {
          lAddrVec.push_back(lMapIter->second);
          lPreviousFedId = lFedId;
        }
      }
    }
  }
 
}  // namespace sistrip