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
bool	hasAbilityToProduceInLumis () const final
bool	hasAbilityToProduceInRuns () 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(), 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 139 of file HcalRawToDigi.cc.

{ }  

Member Function Documentation

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

static

Definition at line 141 of file HcalRawToDigi.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addUntracked(), 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 167 of file HcalRawToDigi.cc.

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_, electronicsMapLabel_, FEDRawDataCollection::FEDData(), fedUnpackList_, HcalDataFrameFilter::filter(), filter_, edm::EventSetup::get(), edm::Event::getByToken(), photonIsolationHIProducer_cfi::hbhe, HcalUnpacker::Collections::hbheCont, AnalysisDataFormats_SUSYBSMObjects::hc, photonIsolationHIProducer_cfi::hf, HcalUnpacker::Collections::hfCont, photonIsolationHIProducer_cfi::ho, HcalUnpacker::Collections::hoCont, mps_fire::i, info(), 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, parseEventContent::prod, edm::ESHandle< T >::product(), edm::Event::put(), 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(), GlobalPosition_Frontier_DevDB_cff::tag, tok_data_, HcalUnpacker::Collections::tpCont, HcalUnpacker::Collections::tphoCont, HcalUnpacker::Collections::ttp, HcalUnpacker::Collections::umnio, HcalUnpacker::unpack(), unpackCalib_, unpacker_, unpackTTP_, unpackUMNio_, unpackZDC_, cms::Exception::what(), hcalSimParameters_cfi::zdc, and HcalUnpacker::Collections::zdcCont.

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

  }
}

Member Data Documentation

const bool HcalRawToDigi::complainEmptyData_

private

Definition at line 53 of file HcalRawToDigi.h.

Referenced by produce().

std::string HcalRawToDigi::electronicsMapLabel_

private

Definition at line 55 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi(), and produce().

const int HcalRawToDigi::expectedOrbitMessageTime_

private

Definition at line 54 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi().

std::vector<int> HcalRawToDigi::fedUnpackList_

private

Definition at line 40 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi(), and produce().

HcalDataFrameFilter HcalRawToDigi::filter_

private

Definition at line 39 of file HcalRawToDigi.h.

Referenced by produce().

const int HcalRawToDigi::firstFED_

private

Definition at line 41 of file HcalRawToDigi.h.

std::vector<int> HcalRawToDigi::saveQIE10DataNSamples_

private

Definition at line 46 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi().

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

private

Definition at line 47 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi().

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

private

Definition at line 59 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi(), and produce().

std::vector<int> HcalRawToDigi::saveQIE11DataNSamples_

private

Definition at line 50 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi().

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

private

Definition at line 51 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi().

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

private

Definition at line 60 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi(), and produce().

const bool HcalRawToDigi::silent_

private

Definition at line 53 of file HcalRawToDigi.h.

Referenced by produce().

struct HcalRawToDigi::Statistics HcalRawToDigi::stats_

private

Referenced by HcalRawToDigi(), and produce().

edm::EDGetTokenT<FEDRawDataCollection> HcalRawToDigi::tok_data_

private

Definition at line 37 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi(), and produce().

const bool HcalRawToDigi::unpackCalib_

private

Definition at line 42 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi(), and produce().

HcalUnpacker HcalRawToDigi::unpacker_

private

Definition at line 38 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi(), and produce().

const int HcalRawToDigi::unpackerMode_

private

Definition at line 54 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi().

const bool HcalRawToDigi::unpackTTP_

private

Definition at line 42 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi(), and produce().

bool HcalRawToDigi::unpackUMNio_

private

Definition at line 43 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi(), and produce().

const bool HcalRawToDigi::unpackZDC_

private

Definition at line 42 of file HcalRawToDigi.h.

Referenced by HcalRawToDigi(), and produce().