#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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

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_

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<>
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	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 29 of file HcalRawToDigi.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 14 of file HcalRawToDigi.cc.

References electronicsMapLabel_, expectedOrbitMessageTime_, fedUnpackList_, spr::find(), edm::ParameterSet::getParameter(), mps_fire::i, training_settings::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, GlobalPosition_Frontier_DevDB_cff::tag, tok_data_, 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"));
 
   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 ( )

override

Definition at line 146 of file HcalRawToDigi.cc.

146 {}

Member Function Documentation

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

static

Definition at line 148 of file HcalRawToDigi.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addUntracked(), HLT_2018_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);
 }

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

override

calib

zdc

umnio

Definition at line 173 of file HcalRawToDigi.cc.

Referenced by JSONExport.JsonExport::export(), HTMLExport.HTMLExport::export(), and HTMLExport.HTMLExportStatic::export().

                                                                 {
   // Step A: Get Inputs
   edm::Handle<FEDRawDataCollection> rawraw;
   e.getByToken(tok_data_, rawraw);
   // get the mapping
   edm::ESHandle<HcalDbService> pSetup;
   es.get<HcalDbRecord>().get(pSetup);
   edm::ESHandle<HcalElectronicsMap> item;
   es.get<HcalElectronicsMapRcd>().get(electronicsMapLabel_, item);
   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));
     }
   }
 }