SiPixelPerformanceSummary.cc

Go to the documentation of this file.

#include "FWCore/MessageLogger/interface/MessageLogger.h"
 
#include "CondFormats/SiPixelObjects/interface/SiPixelPerformanceSummary.h"
 
#include <algorithm>
 
using namespace edm;
using namespace std;
 
SiPixelPerformanceSummary::SiPixelPerformanceSummary()
    : timeStamp_(0), runNumber_(0), luminosityBlock_(0), numberOfEvents_(0) {}
 
SiPixelPerformanceSummary::SiPixelPerformanceSummary(const SiPixelPerformanceSummary& performanceSummary) {
  timeStamp_ = performanceSummary.getTimeStamp();
  runNumber_ = performanceSummary.getRunNumber();
  luminosityBlock_ = performanceSummary.getLuminosityBlock();
  numberOfEvents_ = performanceSummary.getNumberOfEvents();
  allDetSummaries_ = performanceSummary.getAllDetSummaries();
}
 
SiPixelPerformanceSummary::~SiPixelPerformanceSummary() {}
 
void SiPixelPerformanceSummary::clear() {
  timeStamp_ = 0;
  runNumber_ = 0;
  luminosityBlock_ = 0;
  numberOfEvents_ = 0;
  allDetSummaries_.clear();
}
 
pair<bool, vector<SiPixelPerformanceSummary::DetSummary>::iterator> SiPixelPerformanceSummary::initDet(
    const uint32_t detId) {
  vector<float> performanceValues;
  for (int i = 0; i < kDetSummarySize; ++i)
    performanceValues.push_back(kDefaultValue);
  return setDet(detId, performanceValues);
}
 
pair<bool, vector<SiPixelPerformanceSummary::DetSummary>::iterator> SiPixelPerformanceSummary::setDet(
    const uint32_t detId, const vector<float>& performanceValues) {
  vector<DetSummary>::iterator iDetSumm = allDetSummaries_.end();
 
  if (performanceValues.size() != kDetSummarySize) {  // for inappropriate input
    cout << "not adding these " << performanceValues.size() << " values; "
         << "SiPixelPerformanceSummary can only add " << kDetSummarySize << " values per DetSummary";
    return make_pair(false, iDetSumm);
  }
  iDetSumm = lower_bound(
      allDetSummaries_.begin(), allDetSummaries_.end(), detId, SiPixelPerformanceSummary::StrictWeakOrdering());
 
  if (iDetSumm != allDetSummaries_.end() &&  // for an existong entry
      iDetSumm->detId_ == detId)
    return make_pair(false, iDetSumm);
 
  DetSummary newDetSumm;  // for a new entry, put at (position-1) returned by StrictWeakOrdering
  newDetSumm.detId_ = detId;
  newDetSumm.performanceValues_ = performanceValues;
  return make_pair(true, allDetSummaries_.insert(iDetSumm, newDetSumm));
}
 
bool SiPixelPerformanceSummary::setValue(uint32_t detId, int index, float performanceValue) {
  if (index > kDetSummarySize) {
    cout << "cannot set the performance value for index = " << index << " > " << kDetSummarySize;
    return false;
  }
  pair<bool, vector<DetSummary>::iterator> initResult = initDet(detId);
  if (initResult.first || initResult.second != allDetSummaries_.end()) {
    initResult.second->performanceValues_[index] = performanceValue;
    return true;
  } else {
    cout << "cannot set the performance value; cannot create new entry for detId = " << detId;
    return false;
  }
  return true;
}
 
float SiPixelPerformanceSummary::getValue(uint32_t detId, int index) {
  if (index > kDetSummarySize) {
    cout << "cannot get value for detId = " << detId << " index = " << index << " > " << kDetSummarySize;
    return kDefaultValue;
  }
  vector<float> performanceValues = getDetSummary(detId);
  if (performanceValues.size() == kDetSummarySize)
    return performanceValues[index];
  else
    return kDefaultValue;
}
 
bool SiPixelPerformanceSummary::setRawDataErrorType(uint32_t detId, int bin, float nErrors) {
  return setValue(detId, bin, nErrors);
}
 
bool SiPixelPerformanceSummary::setNumberOfDigis(uint32_t detId, float mean, float rms, float emPtn) {
  return (setValue(detId, 15, mean) && setValue(detId, 16, rms) && setValue(detId, 17, emPtn));
}
 
bool SiPixelPerformanceSummary::setADC(uint32_t detId, float mean, float rms, float emPtn) {
  return (setValue(detId, 18, mean) && setValue(detId, 19, rms) && setValue(detId, 20, emPtn));
}
 
bool SiPixelPerformanceSummary::setNumberOfClusters(uint32_t detId, float mean, float rms, float emPtn) {
  return (setValue(detId, 21, mean) && setValue(detId, 22, rms) && setValue(detId, 23, emPtn));
}
 
bool SiPixelPerformanceSummary::setClusterCharge(uint32_t detId, float mean, float rms, float emPtn) {
  return (setValue(detId, 24, mean) && setValue(detId, 25, rms) && setValue(detId, 26, emPtn));
}
 
bool SiPixelPerformanceSummary::setClusterSize(uint32_t detId, float mean, float rms, float emPtn) {
  return (setValue(detId, 27, mean) && setValue(detId, 28, rms) && setValue(detId, 29, emPtn));
}
 
bool SiPixelPerformanceSummary::setClusterSizeX(uint32_t detId, float mean, float rms, float emPtn) {
  return (setValue(detId, 30, mean) && setValue(detId, 31, rms) && setValue(detId, 32, emPtn));
}
 
bool SiPixelPerformanceSummary::setClusterSizeY(uint32_t detId, float mean, float rms, float emPtn) {
  return (setValue(detId, 33, mean) && setValue(detId, 34, rms) && setValue(detId, 35, emPtn));
}
 
bool SiPixelPerformanceSummary::setNumberOfRecHits(uint32_t detId, float mean, float rms, float emPtn) {
  return (setValue(detId, 36, mean) && setValue(detId, 37, rms) && setValue(detId, 38, emPtn));
}
 
bool SiPixelPerformanceSummary::setResidualX(uint32_t detId, float mean, float rms, float emPtn) {
  return (setValue(detId, 39, mean) && setValue(detId, 40, rms) && setValue(detId, 41, emPtn));
}
 
bool SiPixelPerformanceSummary::setResidualY(uint32_t detId, float mean, float rms, float emPtn) {
  return (setValue(detId, 42, mean) && setValue(detId, 43, rms) && setValue(detId, 44, emPtn));
}
 
bool SiPixelPerformanceSummary::setNumberOfNoisCells(uint32_t detId, float nNpixCells) {
  return setValue(detId, 45, nNpixCells);
}
 
bool SiPixelPerformanceSummary::setNumberOfDeadCells(uint32_t detId, float nNpixCells) {
  return setValue(detId, 46, nNpixCells);
}
 
bool SiPixelPerformanceSummary::setNumberOfPixelHitsInTrackFit(uint32_t detId, float nPixelHits) {
  return setValue(detId, 47, nPixelHits);
}
 
bool SiPixelPerformanceSummary::setFractionOfTracks(uint32_t detId, float mean, float rms) {
  return (setValue(detId, 48, mean) && setValue(detId, 49, rms));
}
 
bool SiPixelPerformanceSummary::setNumberOfOnTrackClusters(uint32_t detId, float nClusters) {
  return setValue(detId, 50, nClusters);
}
 
bool SiPixelPerformanceSummary::setNumberOfOffTrackClusters(uint32_t detId, float nClusters) {
  return setValue(detId, 51, nClusters);
}
 
bool SiPixelPerformanceSummary::setClusterChargeOnTrack(uint32_t detId, float mean, float rms) {
  return (setValue(detId, 52, mean) && setValue(detId, 53, rms));
}
 
bool SiPixelPerformanceSummary::setClusterChargeOffTrack(uint32_t detId, float mean, float rms) {
  return (setValue(detId, 54, mean) && setValue(detId, 55, rms));
}
 
bool SiPixelPerformanceSummary::setClusterSizeOnTrack(uint32_t detId, float mean, float rms) {
  return (setValue(detId, 56, mean) && setValue(detId, 57, rms));
}
 
bool SiPixelPerformanceSummary::setClusterSizeOffTrack(uint32_t detId, float mean, float rms) {
  return (setValue(detId, 58, mean) && setValue(detId, 59, rms));
}
 
vector<uint32_t> SiPixelPerformanceSummary::getAllDetIds() const {
  vector<uint32_t> allDetIds;
  for (vector<DetSummary>::const_iterator iDetSumm = allDetSummaries_.begin(); iDetSumm != allDetSummaries_.end();
       ++iDetSumm)
    allDetIds.push_back(iDetSumm->detId_);
  return allDetIds;
}
 
vector<float> SiPixelPerformanceSummary::getDetSummary(const uint32_t detId) const {
  vector<DetSummary>::const_iterator iDetSumm =
      find_if(allDetSummaries_.begin(), allDetSummaries_.end(), [&detId](const DetSummary& detSumm) -> bool {
        return detSumm.detId_ == detId;
      });
  if (iDetSumm == allDetSummaries_.end()) {
    vector<float> performanceValues;
    cout << "cannot get DetSummary for detId = " << detId;
    return performanceValues;
  } else
    return iDetSumm->performanceValues_;
}
 
void SiPixelPerformanceSummary::print(const uint32_t detId) const {
  vector<float> performanceValues = getDetSummary(detId);
  cout << "DetSummary for detId " << detId << " : ";
  for (vector<float>::const_iterator v = performanceValues.begin(); v != performanceValues.end(); ++v)
    cout << " " << *v;
  cout << endl;
}
 
void SiPixelPerformanceSummary::print() const {
  cout << "SiPixelPerformanceSummary size (allDets) = " << allDetSummaries_.size() << ", "
       << "time stamp = " << timeStamp_ << ", "
       << "run number = " << runNumber_ << ", "
       << "luminosity section = " << luminosityBlock_ << ", "
       << "number of events = " << numberOfEvents_ << endl;
}
 
void SiPixelPerformanceSummary::printAll() const {
  print();
  for (vector<DetSummary>::const_iterator iDetSumm = allDetSummaries_.begin(); iDetSumm != allDetSummaries_.end();
       ++iDetSumm)
    print(iDetSumm->detId_);
}