FastFedCablingAnalysis.cc

Go to the documentation of this file.

#include "CondFormats/SiStripObjects/interface/FastFedCablingAnalysis.h"
#include "DataFormats/SiStripCommon/interface/SiStripHistoTitle.h"
#include "DataFormats/SiStripCommon/interface/SiStripEnumsAndStrings.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include <iostream>
#include <sstream>
#include <iomanip>
#include <cmath>

using namespace sistrip;

// ----------------------------------------------------------------------------
//
const float FastFedCablingAnalysis::threshold_ = 100.;  // [ADC]

// ----------------------------------------------------------------------------
//
const float FastFedCablingAnalysis::dirtyThreshold_ = 800;  // [ADC]

// ----------------------------------------------------------------------------
//
const float FastFedCablingAnalysis::trimDacThreshold_ = 10;  // [ADC]

// ----------------------------------------------------------------------------
//
const uint16_t FastFedCablingAnalysis::nBitsForDcuId_ = 32;

// ----------------------------------------------------------------------------
//
const uint16_t FastFedCablingAnalysis::nBitsForLldCh_ = 2;

// ----------------------------------------------------------------------------
//
FastFedCablingAnalysis::FastFedCablingAnalysis(const uint32_t& key)
    : CommissioningAnalysis(key, sistrip::fastCablingAnalysis_),
      dcuHardId_(sistrip::invalid32_),
      lldCh_(sistrip::invalid_),
      highMedian_(1. * sistrip::invalid_),
      highMean_(1. * sistrip::invalid_),
      highRms_(1. * sistrip::invalid_),
      lowMedian_(1. * sistrip::invalid_),
      lowMean_(1. * sistrip::invalid_),
      lowRms_(1. * sistrip::invalid_),
      range_(1. * sistrip::invalid_),
      midRange_(1. * sistrip::invalid_),
      max_(1. * sistrip::invalid_),
      min_(1. * sistrip::invalid_) {
  fecKey(SiStripFecKey(sistrip::invalid_,
                       sistrip::invalid_,
                       sistrip::invalid_,
                       sistrip::invalid_,
                       sistrip::invalid_,
                       sistrip::invalid_,
                       sistrip::invalid_)
             .key());
  fedKey(key);
}

// ----------------------------------------------------------------------------
//
FastFedCablingAnalysis::FastFedCablingAnalysis()
    : CommissioningAnalysis(sistrip::fastCablingAnalysis_),
      dcuHardId_(sistrip::invalid32_),
      lldCh_(sistrip::invalid_),
      highMedian_(1. * sistrip::invalid_),
      highMean_(1. * sistrip::invalid_),
      highRms_(1. * sistrip::invalid_),
      lowMedian_(1. * sistrip::invalid_),
      lowMean_(1. * sistrip::invalid_),
      lowRms_(1. * sistrip::invalid_),
      range_(1. * sistrip::invalid_),
      midRange_(1. * sistrip::invalid_),
      max_(1. * sistrip::invalid_),
      min_(1. * sistrip::invalid_) {
  ;
}

// ----------------------------------------------------------------------------
//
void FastFedCablingAnalysis::reset() {
  dcuHardId_ = sistrip::invalid32_;
  lldCh_ = sistrip::invalid_;
  highMedian_ = 1. * sistrip::invalid_;
  highMean_ = 1. * sistrip::invalid_;
  highRms_ = 1. * sistrip::invalid_;
  lowMedian_ = 1. * sistrip::invalid_;
  lowMean_ = 1. * sistrip::invalid_;
  lowRms_ = 1. * sistrip::invalid_;
  range_ = 1. * sistrip::invalid_;
  midRange_ = 1. * sistrip::invalid_;
  max_ = 1. * sistrip::invalid_;
  min_ = 1. * sistrip::invalid_;
}

// ----------------------------------------------------------------------------
//
bool FastFedCablingAnalysis::isValid() const {
  return (dcuHardId_ < sistrip::invalid32_ && lldCh_ < sistrip::valid_ && highMedian_ < sistrip::valid_ &&
          highMean_ < sistrip::valid_ && highRms_ < sistrip::valid_ && lowMedian_ < sistrip::valid_ &&
          lowMean_ < sistrip::valid_ && lowRms_ < sistrip::valid_ && range_ < sistrip::valid_ &&
          midRange_ < sistrip::valid_ && max_ < sistrip::valid_ && min_ < sistrip::valid_ && getErrorCodes().empty());
}

// ----------------------------------------------------------------------------
//
bool FastFedCablingAnalysis::isDirty() const { return (highMean_ < dirtyThreshold_); }

// ----------------------------------------------------------------------------
//
bool FastFedCablingAnalysis::badTrimDac() const { return (lowMean_ < trimDacThreshold_); }

// ----------------------------------------------------------------------------
//
void FastFedCablingAnalysis::header(std::stringstream& ss) const {
  ss << "[" << myName() << "] Monitorables (65535 means \"invalid\"):" << std::endl;

  //summary(ss);

  SiStripFecKey fec_key(fecKey());
  if (fec_key.isValid()) {
    ss << " Crate/FEC/Ring/CCU/Mod/LLD     : " << fec_key.fecCrate() << "/" << fec_key.fecSlot() << "/"
       << fec_key.fecRing() << "/" << fec_key.ccuAddr() << "/" << fec_key.ccuChan() << "/" << fec_key.lldChan()
       << std::endl;
  } else {
    ss << " Crate/FEC/Ring/CCU/Mod/LLD     : (invalid)" << std::endl;
  }

  SiStripFedKey fed_key(fedKey());
  ss << " FedId/FeUnit/FeChan/FedChannel : " << fed_key.fedId() << "/" << fed_key.feUnit() << "/" << fed_key.feChan()
     << "/" << fed_key.fedChannel() << std::endl;
  // if ( fed_key.fedChannel() != sistrip::invalid_ ) { ss << fed_key.fedChannel(); }
  // else { ss << "(invalid)"; }
  // ss << std::endl;

  ss << " FecKey/Fedkey (hex)            : 0x" << std::hex << std::setw(8) << std::setfill('0') << fecKey() << " / 0x"
     << std::setw(8) << std::setfill('0') << fedKey() << std::dec << std::endl;

  ss << " DcuId (hex/dec)                : 0x" << std::hex << std::setw(8) << std::setfill('0') << dcuId() << " / "
     << std::dec << std::setw(10) << std::setfill(' ') << dcuId() << std::endl;

  ss << " DetId (hex/dec)                : 0x" << std::hex << std::setw(8) << std::setfill('0') << detId() << " / "
     << std::dec << std::setw(10) << std::setfill(' ') << detId() << std::endl;
}

// ----------------------------------------------------------------------------
//
void FastFedCablingAnalysis::summary(std::stringstream& ss) const {
  SiStripFecKey fec_key(fecKey());
  SiStripFedKey fed_key(fedKey());

  sistrip::RunType type = SiStripEnumsAndStrings::runType(myName());
  std::string title =
      SiStripHistoTitle(
          sistrip::EXPERT_HISTO, type, sistrip::FED_KEY, fed_key.key(), sistrip::LLD_CHAN, fec_key.lldChan())
          .title();

  ss << " Summary"
     << ":" << (isValid() ? "Valid" : "Invalid") << ":" << sistrip::readoutView_ << ":" << fed_key.fedId() << "/"
     << fed_key.feUnit() << "/" << fed_key.feChan() << ":" << sistrip::dqmRoot_ << sistrip::dir_ << "Collate"
     << sistrip::dir_ << fed_key.path() << ":" << title << std::endl;
}

// ----------------------------------------------------------------------------
//
void FastFedCablingAnalysis::print(std::stringstream& ss, uint32_t not_used) {
  header(ss);
  ss << std::fixed << std::setprecision(2) << " DCU id extracted from histo     : 0x" << std::hex << std::setw(8)
     << std::setfill('0') << dcuHardId_ << std::endl
     << std::dec << " LLD chan extracted from histo   : " << (lldCh_ > 3 ? sistrip::invalid_ : lldCh_) << std::endl
     << " \"High\" level (mean+/-rms) [ADC] : " << highMean_ << " +/- " << highRms_ << std::endl
     << " \"Low\" level (mean+/-rms)  [ADC] : " << lowMean_ << " +/- " << lowRms_ << std::endl
     << " Median \"high\" level       [ADC] : " << highMedian_ << std::endl
     << " Median \"low\" level        [ADC] : " << lowMedian_ << std::endl
     << " Range                     [ADC] : " << range_ << std::endl
     << " Mid-range level           [ADC] : " << midRange_ << std::endl
     << " Maximum level             [ADC] : " << max_ << std::endl
     << " Minimum level             [ADC] : " << min_ << std::endl;
  ss << std::boolalpha << " isValid                         : " << isValid() << std::endl
     << " isDirty                         : " << isDirty() << std::endl
     << " badTrimDac                      : " << badTrimDac() << std::endl
     << std::noboolalpha << " Error codes (found " << std::setw(2) << std::setfill(' ') << getErrorCodes().size()
     << ")          : ";
  if (getErrorCodes().empty()) {
    ss << "(none)";
  } else {
    VString::const_iterator istr = getErrorCodes().begin();
    VString::const_iterator jstr = getErrorCodes().end();
    for (; istr != jstr; ++istr) {
      ss << *istr << " ";
    }
  }
  ss << std::endl;
}