HcalRawToDigi Class Reference

#include <HcalRawToDigi.h>

Inheritance diagram for HcalRawToDigi:

Classes
struct	Statistics

Public Member Functions
	HcalRawToDigi (const edm::ParameterSet &ps)
void	produce (edm::Event &, const edm::EventSetup &) override
	~HcalRawToDigi () override
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
	EDProducer (const EDProducer &)=delete
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final
const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Attributes
const bool	complainEmptyData_
std::string	electronicsMapLabel_
const int	expectedOrbitMessageTime_
std::vector< int >	fedUnpackList_
HcalDataFrameFilter	filter_
const int	firstFED_
std::vector< int >	saveQIE10DataNSamples_
std::vector< std::string >	saveQIE10DataTags_
std::unordered_map< int, std::string >	saveQIE10Info_
std::vector< int >	saveQIE11DataNSamples_
std::vector< std::string >	saveQIE11DataTags_
std::unordered_map< int, std::string >	saveQIE11Info_
const bool	silent_
struct HcalRawToDigi::Statistics	stats_
edm::EDGetTokenT< FEDRawDataCollection >	tok_data_
edm::ESGetToken< HcalDbService, HcalDbRecord >	tok_dbService_
edm::ESGetToken< HcalElectronicsMap, HcalElectronicsMapRcd >	tok_electronicsMap_
const bool	unpackCalib_
HcalUnpacker	unpacker_
const int	unpackerMode_
const bool	unpackTTP_
bool	unpackUMNio_
const bool	unpackZDC_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >
using	GlobalCache = typename CacheTypes::GlobalCache
using	HasAbility = AbilityChecker< T... >
using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
using	RunCache = typename CacheTypes::RunCache
using	RunContext = RunContextT< RunCache, GlobalCache >
using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

HcalRawToDigi is the EDProducer subclass which runs the Hcal Unpack algorithm.

Author

Jeremiah Mans

Version

1st Version June 10, 2005

Definition at line 32 of file HcalRawToDigi.h.

Constructor & Destructor Documentation

HcalRawToDigi()

HcalRawToDigi::HcalRawToDigi ( const edm::ParameterSet &  ps )

explicit

Definition at line 12 of file HcalRawToDigi.cc.

    : unpacker_(conf.getUntrackedParameter<int>("HcalFirstFED", int(FEDNumbering::MINHCALFEDID)),
                conf.getParameter<int>("firstSample"),
                conf.getParameter<int>("lastSample")),
      filter_(
          conf.getParameter<bool>("FilterDataQuality"), conf.getParameter<bool>("FilterDataQuality"), false, 0, 0, -1),
      fedUnpackList_(conf.getUntrackedParameter<std::vector<int>>("FEDs", std::vector<int>())),
      firstFED_(conf.getUntrackedParameter<int>("HcalFirstFED", FEDNumbering::MINHCALFEDID)),
      unpackCalib_(conf.getUntrackedParameter<bool>("UnpackCalib", false)),
      unpackZDC_(conf.getUntrackedParameter<bool>("UnpackZDC", false)),
      unpackTTP_(conf.getUntrackedParameter<bool>("UnpackTTP", false)),
      unpackUMNio_(conf.getUntrackedParameter<bool>("UnpackUMNio", false)),
      saveQIE10DataNSamples_(conf.getUntrackedParameter<std::vector<int>>("saveQIE10DataNSamples", std::vector<int>())),
      saveQIE10DataTags_(
          conf.getUntrackedParameter<std::vector<std::string>>("saveQIE10DataTags", std::vector<std::string>())),
      saveQIE11DataNSamples_(conf.getUntrackedParameter<std::vector<int>>("saveQIE11DataNSamples", std::vector<int>())),
      saveQIE11DataTags_(
          conf.getUntrackedParameter<std::vector<std::string>>("saveQIE11DataTags", std::vector<std::string>())),
      silent_(conf.getUntrackedParameter<bool>("silent", true)),
      complainEmptyData_(conf.getUntrackedParameter<bool>("ComplainEmptyData", false)),
      unpackerMode_(conf.getUntrackedParameter<int>("UnpackerMode", 0)),
      expectedOrbitMessageTime_(conf.getUntrackedParameter<int>("ExpectedOrbitMessageTime", -1)) {
  electronicsMapLabel_ = conf.getParameter<std::string>("ElectronicsMap");
  tok_data_ = consumes<FEDRawDataCollection>(conf.getParameter<edm::InputTag>("InputLabel"));
  tok_dbService_ = esConsumes<HcalDbService, HcalDbRecord>();
  tok_electronicsMap_ =
      esConsumes<HcalElectronicsMap, HcalElectronicsMapRcd>(edm::ESInputTag("", electronicsMapLabel_));
 
  if (fedUnpackList_.empty()) {
    // VME range for back-compatibility
    for (int i = FEDNumbering::MINHCALFEDID; i <= FEDNumbering::MAXHCALFEDID; i++)
      fedUnpackList_.push_back(i);
 
    // uTCA range
    for (int i = FEDNumbering::MINHCALuTCAFEDID; i <= FEDNumbering::MAXHCALuTCAFEDID; i++)
      fedUnpackList_.push_back(i);
  }
 
  unpacker_.setExpectedOrbitMessageTime(expectedOrbitMessageTime_);
  unpacker_.setMode(unpackerMode_);
  std::ostringstream ss;
  for (unsigned int i = 0; i < fedUnpackList_.size(); i++)
    ss << fedUnpackList_[i] << " ";
  edm::LogInfo("HCAL") << "HcalRawToDigi will unpack FEDs ( " << ss.str() << ")";
 
  // products produced...
  produces<HBHEDigiCollection>();
  produces<HFDigiCollection>();
  produces<HODigiCollection>();
  produces<HcalTrigPrimDigiCollection>();
  produces<HOTrigPrimDigiCollection>();
  produces<HcalUnpackerReport>();
  if (unpackCalib_)
    produces<HcalCalibDigiCollection>();
  if (unpackZDC_)
    produces<ZDCDigiCollection>();
  if (unpackTTP_)
    produces<HcalTTPDigiCollection>();
  if (unpackUMNio_)
    produces<HcalUMNioDigi>();
  produces<QIE10DigiCollection>();
  produces<QIE11DigiCollection>();
 
  produces<QIE10DigiCollection>("ZDC");
  produces<QIE10DigiCollection>("LASERMON");
 
  // Print a warning if an already
  // used tag was requested
  if (std::find(saveQIE10DataTags_.begin(), saveQIE10DataTags_.end(), "ZDC") != saveQIE10DataTags_.end()) {
    edm::LogWarning("HcalRawToDigi")
        << "Cannot create an additional QIE10 sample with name ZDC, it is already created!  It must be removed along "
           "with the corresponding entry in saveQIE10DataNSamples"
        << std::endl;
    saveQIE10DataTags_.clear();
    saveQIE10DataNSamples_.clear();
  }
  // Print a warning if an already
  // used tag was requested
  if (std::find(saveQIE10DataTags_.begin(), saveQIE10DataTags_.end(), "LASERMON") != saveQIE10DataTags_.end()) {
    edm::LogWarning("HcalRawToDigi")
        << "Cannot create an additional QIE10 sample with name LASERMON, it is already created!  It must be removed "
           "along with the corresponding entry in saveQIE10DataNSamples"
        << std::endl;
    saveQIE10DataTags_.clear();
    saveQIE10DataNSamples_.clear();
  }
 
  // Print a warning if the two vectors
  // for additional qie10 or qie11 data
  // are not the same length
  if (saveQIE10DataTags_.size() != saveQIE10DataNSamples_.size()) {
    edm::LogWarning("HcalRawToDigi")
        << "The saveQIE10DataTags and saveQIE10DataNSamples inputs must be the same length!  These will be ignored"
        << std::endl;
    saveQIE10DataTags_.clear();
    saveQIE10DataNSamples_.clear();
  }
  if (saveQIE11DataTags_.size() != saveQIE11DataNSamples_.size()) {
    edm::LogWarning("HcalRawToDigi")
        << "The saveQIE11DataTags and saveQIE11DataNSamples inputs must be the same length!  These will be ignored"
        << std::endl;
    saveQIE11DataTags_.clear();
    saveQIE11DataNSamples_.clear();
  }
 
  // If additional qie10 samples were requested,
  // declare that we will produce this collection
  // with the given tag.  Also store the map
  // from nSamples to tag for later use
  for (unsigned idx = 0; idx < saveQIE10DataNSamples_.size(); ++idx) {
    int nsamples = saveQIE10DataNSamples_[idx];
    std::string tag = saveQIE10DataTags_[idx];
 
    produces<QIE10DigiCollection>(tag);
 
    saveQIE10Info_[nsamples] = tag;
  }
 
  // If additional qie11 samples were requested,
  // declare that we will produce this collection
  // with the given tag.  Also store the map
  // from nSamples to tag for later use
  for (unsigned idx = 0; idx < saveQIE11DataNSamples_.size(); ++idx) {
    int nsamples = saveQIE11DataNSamples_[idx];
    std::string tag = saveQIE11DataTags_[idx];
 
    produces<QIE11DigiCollection>(tag);
 
    saveQIE11Info_[nsamples] = tag;
  }
 
  memset(&stats_, 0, sizeof(stats_));
}

References electronicsMapLabel_, expectedOrbitMessageTime_, fedUnpackList_, spr::find(), edm::ParameterSet::getParameter(), mps_fire::i, heavyIonCSV_trainingSettings::idx, FEDNumbering::MAXHCALFEDID, FEDNumbering::MAXHCALuTCAFEDID, FEDNumbering::MINHCALFEDID, FEDNumbering::MINHCALuTCAFEDID, saveQIE10DataNSamples_, saveQIE10DataTags_, saveQIE10Info_, saveQIE11DataNSamples_, saveQIE11DataTags_, saveQIE11Info_, HcalUnpacker::setExpectedOrbitMessageTime(), HcalUnpacker::setMode(), contentValuesCheck::ss, stats_, AlCaHLTBitMon_QueryRunRegistry::string, makeGlobalPositionRcd_cfg::tag, tok_data_, tok_dbService_, tok_electronicsMap_, unpackCalib_, unpacker_, unpackerMode_, unpackTTP_, unpackUMNio_, and unpackZDC_.

~HcalRawToDigi()

HcalRawToDigi::~HcalRawToDigi ( )

override

Definition at line 147 of file HcalRawToDigi.cc.

{}

Member Function Documentation

fillDescriptions()

void HcalRawToDigi::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions )

static

Definition at line 149 of file HcalRawToDigi.cc.

                                                                               {
  edm::ParameterSetDescription desc;
  desc.addUntracked<int>("HcalFirstFED", int(FEDNumbering::MINHCALFEDID));
  desc.add<int>("firstSample", 0);
  desc.add<int>("lastSample", 9);
  desc.add<bool>("FilterDataQuality", true);
  desc.addUntracked<std::vector<int>>("FEDs", std::vector<int>());
  desc.addUntracked<bool>("UnpackZDC", true);
  desc.addUntracked<bool>("UnpackCalib", true);
  desc.addUntracked<bool>("UnpackUMNio", true);
  desc.addUntracked<bool>("UnpackTTP", true);
  desc.addUntracked<bool>("silent", true);
  desc.addUntracked<std::vector<int>>("saveQIE10DataNSamples", std::vector<int>());
  desc.addUntracked<std::vector<std::string>>("saveQIE10DataTags", std::vector<std::string>());
  desc.addUntracked<std::vector<int>>("saveQIE11DataNSamples", std::vector<int>());
  desc.addUntracked<std::vector<std::string>>("saveQIE11DataTags", std::vector<std::string>());
  desc.addUntracked<bool>("ComplainEmptyData", false);
  desc.addUntracked<int>("UnpackerMode", 0);
  desc.addUntracked<int>("ExpectedOrbitMessageTime", -1);
  desc.add<edm::InputTag>("InputLabel", edm::InputTag("rawDataCollector"));
  desc.add<std::string>("ElectronicsMap", "");
  descriptions.add("hcalRawToDigi", desc);
}

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, HLT_FULL_cff::InputTag, createfilelist::int, FEDNumbering::MINHCALFEDID, and AlCaHLTBitMon_QueryRunRegistry::string.

produce()

void HcalRawToDigi::produce ( edm::Event &  e, const edm::EventSetup &  es  )

override

calib

zdc

umnio

Definition at line 174 of file HcalRawToDigi.cc.

                                                                {
  // Step A: Get Inputs
  edm::Handle<FEDRawDataCollection> rawraw;
  e.getByToken(tok_data_, rawraw);
  // get the mapping
  edm::ESHandle<HcalDbService> pSetup = es.getHandle(tok_dbService_);
  edm::ESHandle<HcalElectronicsMap> item = es.getHandle(tok_electronicsMap_);
  const HcalElectronicsMap* readoutMap = item.product();
  filter_.setConditions(pSetup.product());
 
  // Step B: Create empty output  : three vectors for three classes...
  std::vector<HBHEDataFrame> hbhe;
  std::vector<HODataFrame> ho;
  std::vector<HFDataFrame> hf;
  std::vector<HcalTriggerPrimitiveDigi> htp;
  std::vector<HcalCalibDataFrame> hc;
  std::vector<ZDCDataFrame> zdc;
  std::vector<HcalTTPDigi> ttp;
  std::vector<HOTriggerPrimitiveDigi> hotp;
  HcalUMNioDigi umnio;
  auto report = std::make_unique<HcalUnpackerReport>();
 
  // Heuristics: use ave+(max-ave)/8
  if (stats_.max_hbhe > 0)
    hbhe.reserve(stats_.ave_hbhe + (stats_.max_hbhe - stats_.ave_hbhe) / 8);
  if (stats_.max_ho > 0)
    ho.reserve(stats_.ave_ho + (stats_.max_ho - stats_.ave_ho) / 8);
  if (stats_.max_hf > 0)
    hf.reserve(stats_.ave_hf + (stats_.max_hf - stats_.ave_hf) / 8);
  if (stats_.max_calib > 0)
    hc.reserve(stats_.ave_calib + (stats_.max_calib - stats_.ave_calib) / 8);
  if (stats_.max_tp > 0)
    htp.reserve(stats_.ave_tp + (stats_.max_tp - stats_.ave_tp) / 8);
  if (stats_.max_tpho > 0)
    hotp.reserve(stats_.ave_tpho + (stats_.max_tpho - stats_.ave_tpho) / 8);
 
  if (unpackZDC_)
    zdc.reserve(24);
 
  HcalUnpacker::Collections colls;
  colls.hbheCont = &hbhe;
  colls.hoCont = &ho;
  colls.hfCont = &hf;
  colls.tpCont = &htp;
  colls.tphoCont = &hotp;
  colls.calibCont = &hc;
  colls.zdcCont = &zdc;
  colls.umnio = &umnio;
  if (unpackTTP_)
    colls.ttp = &ttp;
 
  // make an entry for each additional qie10 collection that is requested
  for (const auto& info : saveQIE10Info_) {
    colls.qie10Addtl[info.first] = new QIE10DigiCollection(info.first);
  }
 
  // make an entry for each additional qie11 collection that is requested
  for (const auto& info : saveQIE11Info_) {
    colls.qie11Addtl[info.first] = new QIE11DigiCollection(info.first);
  }
 
  // Step C: unpack all requested FEDs
  for (std::vector<int>::const_iterator i = fedUnpackList_.begin(); i != fedUnpackList_.end(); i++) {
    const FEDRawData& fed = rawraw->FEDData(*i);
    if (fed.size() == 0) {
      if (complainEmptyData_) {
        if (!silent_)
          edm::LogWarning("EmptyData") << "No data for FED " << *i;
        report->addError(*i);
      }
    } else if (fed.size() < 8 * 3) {
      if (!silent_)
        edm::LogWarning("EmptyData") << "Tiny data " << fed.size() << " for FED " << *i;
      report->addError(*i);
    } else {
      try {
        unpacker_.unpack(fed, *readoutMap, colls, *report, silent_);
        report->addUnpacked(*i);
      } catch (cms::Exception& e) {
        if (!silent_)
          edm::LogWarning("Unpacking error") << e.what();
        report->addError(*i);
      } catch (...) {
        if (!silent_)
          edm::LogWarning("Unpacking exception");
        report->addError(*i);
      }
    }
  }
 
  // gather statistics
  stats_.max_hbhe = std::max(stats_.max_hbhe, (int)hbhe.size());
  stats_.ave_hbhe = (stats_.ave_hbhe * stats_.n + hbhe.size()) / (stats_.n + 1);
  stats_.max_ho = std::max(stats_.max_ho, (int)ho.size());
  stats_.ave_ho = (stats_.ave_ho * stats_.n + ho.size()) / (stats_.n + 1);
  stats_.max_hf = std::max(stats_.max_hf, (int)hf.size());
  stats_.ave_hf = (stats_.ave_hf * stats_.n + hf.size()) / (stats_.n + 1);
  stats_.max_tp = std::max(stats_.max_tp, (int)htp.size());
  stats_.ave_tp = (stats_.ave_tp * stats_.n + htp.size()) / (stats_.n + 1);
  stats_.max_tpho = std::max(stats_.max_tpho, (int)hotp.size());
  stats_.ave_tpho = (stats_.ave_tpho * stats_.n + hotp.size()) / (stats_.n + 1);
  stats_.max_calib = std::max(stats_.max_calib, (int)hc.size());
  stats_.ave_calib = (stats_.ave_calib * stats_.n + hc.size()) / (stats_.n + 1);
 
  stats_.n++;
 
  // check HF duplication
  std::unordered_set<uint32_t> cacheForHFdup;
  unsigned int cntHFdup = 0;
  for (auto& hf_digi : hf) {
    if (!cacheForHFdup.insert(hf_digi.id().rawId()).second)
      cntHFdup++;
  }
  if (cntHFdup)
    edm::LogError("HcalRawToDigi") << "Duplicated HF digis found for " << cntHFdup << " times" << std::endl;
 
  // Check that additional QIE10 and QIE11 collections
  // do not duplicate the default collections
  for (const auto& addtl : colls.qie10Addtl) {
    if (addtl.second->samples() == colls.qie10->samples()) {
      std::string tag = saveQIE10Info_[addtl.second->samples()];
      edm::LogWarning("HcalRawToDigi") << "QIE10 data requested to be stored in tag " << tag
                                       << " is already stored in the default QIE10 collection.  "
                                       << "To avoid duplicating, remove the tag " << tag
                                       << " from the saveQIE10DataTags and the value of " << addtl.second->samples()
                                       << " from the saveQIE10DataNSamples "
                                       << "configurables to HcalRawToDigi" << std::endl;
    }
  }
  for (const auto& addtl : colls.qie11Addtl) {
    if (addtl.second->samples() == colls.qie11->samples()) {
      std::string tag = saveQIE11Info_[addtl.second->samples()];
      edm::LogWarning("HcalRawToDigi") << "QIE11 data requested to be stored in tag " << tag
                                       << " is already stored in the default QIE11 collection.  "
                                       << "To avoid duplicating, remove the tag " << tag
                                       << " from the saveQIE11DataTags and the value of " << addtl.second->samples()
                                       << " from the saveQIE11DataNSamples "
                                       << "configurables to HcalRawToDigi" << std::endl;
    }
  }
 
  // Step B: encapsulate vectors in actual collections
  auto hbhe_prod = std::make_unique<HBHEDigiCollection>();
  auto hf_prod = std::make_unique<HFDigiCollection>();
  auto ho_prod = std::make_unique<HODigiCollection>();
  auto htp_prod = std::make_unique<HcalTrigPrimDigiCollection>();
  auto hotp_prod = std::make_unique<HOTrigPrimDigiCollection>();
  // make qie10 collection if it wasn't made in theunpacker
  if (colls.qie10 == nullptr) {
    colls.qie10 = new QIE10DigiCollection();
  }
  std::unique_ptr<QIE10DigiCollection> qie10_prod(colls.qie10);
 
  // make qie10ZDC collection if it wasn't made in theunpacker
  if (colls.qie10ZDC == nullptr) {
    colls.qie10ZDC = new QIE10DigiCollection();
  }
  std::unique_ptr<QIE10DigiCollection> qie10ZDC_prod(colls.qie10ZDC);
 
  // make qie10Lasermon collection if it wasn't made in theunpacker
  if (colls.qie10Lasermon == nullptr) {
    colls.qie10Lasermon = new QIE10DigiCollection();
  }
  std::unique_ptr<QIE10DigiCollection> qie10Lasermon_prod(colls.qie10Lasermon);
 
  if (colls.qie11 == nullptr) {
    colls.qie11 = new QIE11DigiCollection();
  }
  std::unique_ptr<QIE11DigiCollection> qie11_prod(colls.qie11);
 
  // follow the procedure for other collections.  Copy the unpacked
  // data so that it can be filtered and sorted
  std::unordered_map<int, std::unique_ptr<QIE10DigiCollection>> qie10_prodAddtl;
  std::unordered_map<int, std::unique_ptr<QIE11DigiCollection>> qie11_prodAddtl;
  for (const auto& orig : colls.qie10Addtl) {
    qie10_prodAddtl[orig.first] = std::unique_ptr<QIE10DigiCollection>(orig.second);
  }
  for (const auto& orig : colls.qie11Addtl) {
    qie11_prodAddtl[orig.first] = std::unique_ptr<QIE11DigiCollection>(orig.second);
  }
 
  hbhe_prod->swap_contents(hbhe);
  if (!cntHFdup)
    hf_prod->swap_contents(hf);
  ho_prod->swap_contents(ho);
  htp_prod->swap_contents(htp);
  hotp_prod->swap_contents(hotp);
 
  // Step C2: filter FEDs, if required
  if (filter_.active()) {
    HBHEDigiCollection filtered_hbhe = filter_.filter(*hbhe_prod, *report);
    HODigiCollection filtered_ho = filter_.filter(*ho_prod, *report);
    HFDigiCollection filtered_hf = filter_.filter(*hf_prod, *report);
    QIE10DigiCollection filtered_qie10 = filter_.filter(*qie10_prod, *report);
    QIE11DigiCollection filtered_qie11 = filter_.filter(*qie11_prod, *report);
 
    hbhe_prod->swap(filtered_hbhe);
    ho_prod->swap(filtered_ho);
    hf_prod->swap(filtered_hf);
    qie10_prod->swap(filtered_qie10);
    qie11_prod->swap(filtered_qie11);
 
    // apply filter to additional collections
    for (auto& prod : qie10_prodAddtl) {
      QIE10DigiCollection filtered_qie10 = filter_.filter(*(prod.second), *report);
      prod.second->swap(filtered_qie10);
    }
 
    for (auto& prod : qie11_prodAddtl) {
      QIE11DigiCollection filtered_qie11 = filter_.filter(*(prod.second), *report);
      prod.second->swap(filtered_qie11);
    }
  }
 
  // Step D: Put outputs into event
  // just until the sorting is proven
  hbhe_prod->sort();
  ho_prod->sort();
  hf_prod->sort();
  htp_prod->sort();
  hotp_prod->sort();
  qie10_prod->sort();
  qie10ZDC_prod->sort();
  qie10Lasermon_prod->sort();
  qie11_prod->sort();
 
  // sort the additional collections
  for (auto& prod : qie10_prodAddtl) {
    prod.second->sort();
  }
  for (auto& prod : qie11_prodAddtl) {
    prod.second->sort();
  }
 
  e.put(std::move(hbhe_prod));
  e.put(std::move(ho_prod));
  e.put(std::move(hf_prod));
  e.put(std::move(htp_prod));
  e.put(std::move(hotp_prod));
  e.put(std::move(qie10_prod));
  e.put(std::move(qie10ZDC_prod), "ZDC");
  e.put(std::move(qie10Lasermon_prod), "LASERMON");
  e.put(std::move(qie11_prod));
 
  // put the qie10 and qie11 collections into the event
  for (auto& prod : qie10_prodAddtl) {
    std::string tag = saveQIE10Info_[prod.first];
    e.put(std::move(prod.second), tag);
  }
 
  for (auto& prod : qie11_prodAddtl) {
    std::string tag = saveQIE11Info_[prod.first];
    e.put(std::move(prod.second), tag);
  }
 
  if (unpackCalib_) {
    auto hc_prod = std::make_unique<HcalCalibDigiCollection>();
    hc_prod->swap_contents(hc);
 
    if (filter_.active()) {
      HcalCalibDigiCollection filtered_calib = filter_.filter(*hc_prod, *report);
      hc_prod->swap(filtered_calib);
    }
 
    hc_prod->sort();
    e.put(std::move(hc_prod));
  }
 
  if (unpackZDC_) {
    auto prod = std::make_unique<ZDCDigiCollection>();
    prod->swap_contents(zdc);
 
    if (filter_.active()) {
      ZDCDigiCollection filtered_zdc = filter_.filter(*prod, *report);
      prod->swap(filtered_zdc);
    }
 
    prod->sort();
    e.put(std::move(prod));
  }
 
  if (unpackTTP_) {
    auto prod = std::make_unique<HcalTTPDigiCollection>();
    prod->swap_contents(ttp);
 
    prod->sort();
    e.put(std::move(prod));
  }
  e.put(std::move(report));
  if (unpackUMNio_) {
    if (colls.umnio != nullptr) {
      e.put(std::make_unique<HcalUMNioDigi>(umnio));
    }
  }
}

References HcalDataFrameFilter::active(), HcalRawToDigi::Statistics::ave_calib, HcalRawToDigi::Statistics::ave_hbhe, HcalRawToDigi::Statistics::ave_hf, HcalRawToDigi::Statistics::ave_ho, HcalRawToDigi::Statistics::ave_tp, HcalRawToDigi::Statistics::ave_tpho, HcalUnpacker::Collections::calibCont, complainEmptyData_, MillePedeFileConverter_cfg::e, FEDRawDataCollection::FEDData(), fedUnpackList_, HcalDataFrameFilter::filter(), filter_, edm::EventSetup::getHandle(), photonIsolationHIProducer_cfi::hbhe, HcalUnpacker::Collections::hbheCont, photonIsolationHIProducer_cfi::hf, HcalUnpacker::Collections::hfCont, photonIsolationHIProducer_cfi::ho, HcalUnpacker::Collections::hoCont, mps_fire::i, info(), B2GTnPMonitor_cfi::item, SiStripPI::max, HcalRawToDigi::Statistics::max_calib, HcalRawToDigi::Statistics::max_hbhe, HcalRawToDigi::Statistics::max_hf, HcalRawToDigi::Statistics::max_ho, HcalRawToDigi::Statistics::max_tp, HcalRawToDigi::Statistics::max_tpho, eostools::move(), HcalRawToDigi::Statistics::n, dumpMFGeometry_cfg::prod, edm::ESHandle< T >::product(), HcalUnpacker::Collections::qie10, HcalUnpacker::Collections::qie10Addtl, HcalUnpacker::Collections::qie10Lasermon, HcalUnpacker::Collections::qie10ZDC, HcalUnpacker::Collections::qie11, HcalUnpacker::Collections::qie11Addtl, edmIntegrityCheck::report, HcalDataFrameContainer< Digi >::samples(), saveQIE10Info_, saveQIE11Info_, edm::second(), HcalDataFrameFilter::setConditions(), silent_, FEDRawData::size(), stats_, AlCaHLTBitMon_QueryRunRegistry::string, edm::SortedCollection< T, SORT >::swap(), makeGlobalPositionRcd_cfg::tag, tok_data_, tok_dbService_, tok_electronicsMap_, HcalUnpacker::Collections::tpCont, HcalUnpacker::Collections::tphoCont, HcalUnpacker::Collections::ttp, HcalUnpacker::Collections::umnio, HcalUnpacker::unpack(), unpackCalib_, unpacker_, unpackTTP_, unpackUMNio_, unpackZDC_, hcalSimParameters_cfi::zdc, and HcalUnpacker::Collections::zdcCont.

Member Data Documentation

complainEmptyData_

const bool HcalRawToDigi::complainEmptyData_

private

Definition at line 58 of file HcalRawToDigi.h.

Referenced by produce().

electronicsMapLabel_

std::string HcalRawToDigi::electronicsMapLabel_

private

Definition at line 60 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi().

expectedOrbitMessageTime_

const int HcalRawToDigi::expectedOrbitMessageTime_

private

Definition at line 59 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi().

fedUnpackList_

std::vector<int> HcalRawToDigi::fedUnpackList_

private

Definition at line 45 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi(), and produce().

filter_

HcalDataFrameFilter HcalRawToDigi::filter_

private

Definition at line 44 of file HcalRawToDigi.h.

Referenced by produce().

firstFED_

const int HcalRawToDigi::firstFED_

private

Definition at line 46 of file HcalRawToDigi.h.

saveQIE10DataNSamples_

std::vector<int> HcalRawToDigi::saveQIE10DataNSamples_

private

Definition at line 51 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi().

saveQIE10DataTags_

std::vector<std::string> HcalRawToDigi::saveQIE10DataTags_

private

Definition at line 52 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi().

saveQIE10Info_

std::unordered_map<int, std::string> HcalRawToDigi::saveQIE10Info_

private

Definition at line 64 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi(), and produce().

saveQIE11DataNSamples_

std::vector<int> HcalRawToDigi::saveQIE11DataNSamples_

private

Definition at line 55 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi().

saveQIE11DataTags_

std::vector<std::string> HcalRawToDigi::saveQIE11DataTags_

private

Definition at line 56 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi().

saveQIE11Info_

std::unordered_map<int, std::string> HcalRawToDigi::saveQIE11Info_

private

Definition at line 65 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi(), and produce().

silent_

const bool HcalRawToDigi::silent_

private

Definition at line 58 of file HcalRawToDigi.h.

Referenced by produce().

stats_

struct HcalRawToDigi::Statistics HcalRawToDigi::stats_

private

Referenced by HcalRawToDigi(), and produce().

tok_data_

edm::EDGetTokenT<FEDRawDataCollection> HcalRawToDigi::tok_data_

private

Definition at line 40 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi(), and produce().

tok_dbService_

edm::ESGetToken<HcalDbService, HcalDbRecord> HcalRawToDigi::tok_dbService_

private

Definition at line 41 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi(), and produce().

tok_electronicsMap_

edm::ESGetToken<HcalElectronicsMap, HcalElectronicsMapRcd> HcalRawToDigi::tok_electronicsMap_

private

Definition at line 42 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi(), and produce().

unpackCalib_

const bool HcalRawToDigi::unpackCalib_

private

Definition at line 47 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi(), and produce().

unpacker_

HcalUnpacker HcalRawToDigi::unpacker_

private

Definition at line 43 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi(), and produce().

unpackerMode_

const int HcalRawToDigi::unpackerMode_

private

Definition at line 59 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi().

unpackTTP_

const bool HcalRawToDigi::unpackTTP_

private

Definition at line 47 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi(), and produce().

unpackUMNio_

bool HcalRawToDigi::unpackUMNio_

private

Definition at line 48 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi(), and produce().

unpackZDC_

const bool HcalRawToDigi::unpackZDC_

private

Definition at line 47 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi(), and produce().