#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.

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_.

     : 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_));
 }

◆ ~HcalRawToDigi()

HcalRawToDigi::~HcalRawToDigi ( )

override

Definition at line 147 of file HcalRawToDigi.cc.

147 {}

Member Function Documentation

◆ fillDescriptions()

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

static

Definition at line 149 of file HcalRawToDigi.cc.

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

                                                                                {
   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);
 }

◆ 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));
     }
   }
 }