SiStripQualityESProducer.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:    SiStripQualityESProducer
// Class:      SiStripQualityESProducer
//
//
// Original Author:  Domenico GIORDANO
//         Created:  Wed Oct  3 12:11:10 CEST 2007
//
//

// system include files
#include <memory>

// user include files
#include "FWCore/Framework/interface/ModuleFactory.h"
#include "FWCore/Framework/interface/ESProducer.h"
#include "FWCore/Framework/interface/ModuleFactory.h"

#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"

#include "DataFormats/SiStripCommon/interface/SiStripConstants.h"
#include "CalibFormats/SiStripObjects/interface/SiStripQuality.h"
#include "CalibTracker/Records/interface/SiStripDependentRecords.h"
#include "CalibTracker/SiStripCommon/interface/SiStripDetInfoFileReader.h"
#include "CondFormats/RunInfo/interface/RunInfo.h"

namespace {
  class ProductAdder {
  public:
    virtual ~ProductAdder() = default;
    virtual void add(const SiStripQualityRcd& iRecord, SiStripQuality& quality) const = 0;
  };

  template <typename Product, typename RealRecord>
  class ProductAdderT : public ProductAdder {
  public:
    ProductAdderT(edm::ESConsumesCollector& cc, const std::string& label)
        : token_{cc.consumesFrom<Product, RealRecord>(edm::ESInputTag{"", label})} {}
    void add(const SiStripQualityRcd& iRecord, SiStripQuality& quality) const override {
      quality.add(&iRecord.get(token_));
    }

  private:
    edm::ESGetToken<Product, RealRecord> token_;
  };

  template <typename Product, typename RealRecord>
  auto make_ProductAdder(edm::ESConsumesCollector& cc, const std::string& label) {
    return std::make_unique<ProductAdderT<Product, RealRecord>>(cc, label);
  }
}  // namespace

class SiStripQualityESProducer : public edm::ESProducer {
public:
  SiStripQualityESProducer(const edm::ParameterSet&);
  ~SiStripQualityESProducer() override{};

  std::unique_ptr<SiStripQuality> produce(const SiStripQualityRcd&);

private:
  std::vector<std::unique_ptr<const ProductAdder>> productAdders_;
  edm::ESGetToken<RunInfo, RunInfoRcd> runInfoToken_;

  const double thresholdForReducedGranularity_;
  const bool printDebugOutput_;
  const bool useEmptyRunInfo_;
  const bool reduceGranularity_;
};

SiStripQualityESProducer::SiStripQualityESProducer(const edm::ParameterSet& iConfig)
    : thresholdForReducedGranularity_{iConfig.getParameter<double>("ThresholdForReducedGranularity")},
      printDebugOutput_{iConfig.getParameter<bool>("PrintDebugOutput")},
      useEmptyRunInfo_{iConfig.getParameter<bool>("UseEmptyRunInfo")},
      reduceGranularity_{iConfig.getParameter<bool>("ReduceGranularity")} {
  auto cc = setWhatProduced(this);

  edm::LogInfo("SiStripQualityESProducer") << "ctor";

  bool doRunInfo = false;
  std::string runInfoTagName = "";

  auto toGet = iConfig.getParameter<std::vector<edm::ParameterSet>>("ListOfRecordToMerge");

  for (const auto& toGetPSet : toGet) {
    auto tagName = toGetPSet.getParameter<std::string>("tag");
    auto recordName = toGetPSet.getParameter<std::string>("record");

    edm::LogInfo("SiStripQualityESProducer")
        << "[SiStripQualityESProducer::ctor] Going to get data from record " << recordName << " with tag " << tagName;

    if (recordName == "SiStripBadModuleRcd") {
      productAdders_.emplace_back(make_ProductAdder<SiStripBadStrip, SiStripBadModuleRcd>(cc, tagName));
    } else if (recordName == "SiStripBadFiberRcd") {
      productAdders_.emplace_back(make_ProductAdder<SiStripBadStrip, SiStripBadFiberRcd>(cc, tagName));
    } else if (recordName == "SiStripBadChannelRcd") {
      productAdders_.emplace_back(make_ProductAdder<SiStripBadStrip, SiStripBadChannelRcd>(cc, tagName));
    } else if (recordName == "SiStripBadStripRcd") {
      productAdders_.emplace_back(make_ProductAdder<SiStripBadStrip, SiStripBadStripRcd>(cc, tagName));
    } else if (recordName == "SiStripDetCablingRcd") {
      productAdders_.emplace_back(make_ProductAdder<SiStripDetCabling, SiStripDetCablingRcd>(cc, tagName));
    } else if (recordName == "SiStripDetVOffRcd") {
      productAdders_.emplace_back(make_ProductAdder<SiStripDetVOff, SiStripDetVOffRcd>(cc, tagName));
    } else if (recordName == "RunInfoRcd") {
      runInfoTagName = tagName;
      doRunInfo = true;
    } else {
      // Would it make sense to elevate this to an exception?
      edm::LogError("SiStripQualityESProducer")
          << "[SiStripQualityESProducer::ctor] Skipping the requested data for unexisting record " << recordName
          << " with tag " << tagName << std::endl;
      continue;
    }
  }

  if (doRunInfo) {
    runInfoToken_ = cc.consumes(edm::ESInputTag{"", runInfoTagName});
  }
}

std::unique_ptr<SiStripQuality> SiStripQualityESProducer::produce(const SiStripQualityRcd& iRecord) {
  const auto detInfo =
      SiStripDetInfoFileReader::read(edm::FileInPath{SiStripDetInfoFileReader::kDefaultFile}.fullPath());
  auto quality = std::make_unique<SiStripQuality>(detInfo);
  edm::LogInfo("SiStripQualityESProducer") << "produce called";

  // Set the debug output level
  quality->setPrintDebugOutput(printDebugOutput_);
  // Set the protection against empty RunInfo objects
  quality->setUseEmptyRunInfo(useEmptyRunInfo_);

  for (const auto& adder : productAdders_) {
    adder->add(iRecord, *quality);
  }

  // We do this after all the others so we know it is done after the DetCabling (if any)
  if (runInfoToken_.isInitialized()) {
    quality->add(&iRecord.get(runInfoToken_));
  }

  quality->cleanUp();

  if (reduceGranularity_) {
    quality->ReduceGranularity(thresholdForReducedGranularity_);
    quality->cleanUp(true);
  }

  quality->fillBadComponents();

  return quality;
}

DEFINE_FWK_EVENTSETUP_MODULE(SiStripQualityESProducer);