edm::DataMixingHcalDigiWorker Class Reference

#include <DataMixingHcalDigiWorker.h>

Public Member Functions
void	addHcalPileups (const int bcr, const edm::EventPrincipal *, unsigned int EventId, const edm::EventSetup &ES, ModuleCallingContext const *)
void	addHcalSignals (const edm::Event &e, const edm::EventSetup &ES)
	DataMixingHcalDigiWorker ()
	DataMixingHcalDigiWorker (const edm::ParameterSet &ps, edm::ConsumesCollector &&iC)
void	putHcal (edm::Event &e, const edm::EventSetup &ES)
virtual	~DataMixingHcalDigiWorker ()

Private Types
typedef std::multimap< DetId, CaloSamples >	HBHEDigiMap
typedef std::multimap< DetId, CaloSamples >	HFDigiMap
typedef std::multimap< DetId, CaloSamples >	HODigiMap
typedef std::multimap< DetId, CaloSamples >	QIE10DigiMap
typedef std::multimap< DetId, CaloSamples >	QIE11DigiMap
typedef std::multimap< DetId, CaloSamples >	ZDCDigiMap

Private Attributes
bool	DoZDC_
std::string	HBHEDigiCollectionDM_
edm::InputTag	HBHEdigiCollectionSig_
edm::EDGetTokenT< HBHEDigiCollection >	HBHEDigiPToken_
HBHEDigiMap	HBHEDigiStorage_
edm::EDGetTokenT< HBHEDigiCollection >	HBHEDigiToken_
edm::InputTag	HBHEPileInputTag_
std::string	HFDigiCollectionDM_
edm::InputTag	HFdigiCollectionSig_
edm::EDGetTokenT< HFDigiCollection >	HFDigiPToken_
HFDigiMap	HFDigiStorage_
edm::EDGetTokenT< HFDigiCollection >	HFDigiToken_
edm::InputTag	HFPileInputTag_
std::string	HODigiCollectionDM_
edm::InputTag	HOdigiCollectionSig_
edm::EDGetTokenT< HODigiCollection >	HODigiPToken_
HODigiMap	HODigiStorage_
edm::EDGetTokenT< HODigiCollection >	HODigiToken_
edm::InputTag	HOPileInputTag_
std::string	label_
std::string	QIE10DigiCollectionDM_
edm::InputTag	QIE10digiCollectionSig_
edm::EDGetTokenT< QIE10DigiCollection >	QIE10DigiPToken_
QIE10DigiMap	QIE10DigiStorage_
edm::EDGetTokenT< QIE10DigiCollection >	QIE10DigiToken_
edm::InputTag	QIE10PileInputTag_
std::string	QIE11DigiCollectionDM_
edm::InputTag	QIE11digiCollectionSig_
edm::EDGetTokenT< QIE11DigiCollection >	QIE11DigiPToken_
QIE11DigiMap	QIE11DigiStorage_
edm::EDGetTokenT< QIE11DigiCollection >	QIE11DigiToken_
edm::InputTag	QIE11PileInputTag_
std::string	ZDCDigiCollectionDM_
edm::InputTag	ZDCdigiCollectionSig_
edm::EDGetTokenT< ZDCDigiCollection >	ZDCDigiPToken_
ZDCDigiMap	ZDCDigiStorage_
edm::EDGetTokenT< ZDCDigiCollection >	ZDCDigiToken_
edm::InputTag	ZDCPileInputTag_

Detailed Description

Definition at line 40 of file DataMixingHcalDigiWorker.h.

Member Typedef Documentation

HBHEDigiMap

typedef std::multimap<DetId, CaloSamples> edm::DataMixingHcalDigiWorker::HBHEDigiMap

private

Definition at line 100 of file DataMixingHcalDigiWorker.h.

HFDigiMap

typedef std::multimap<DetId, CaloSamples> edm::DataMixingHcalDigiWorker::HFDigiMap

private

Definition at line 101 of file DataMixingHcalDigiWorker.h.

HODigiMap

typedef std::multimap<DetId, CaloSamples> edm::DataMixingHcalDigiWorker::HODigiMap

private

Definition at line 102 of file DataMixingHcalDigiWorker.h.

QIE10DigiMap

typedef std::multimap<DetId, CaloSamples> edm::DataMixingHcalDigiWorker::QIE10DigiMap

private

Definition at line 104 of file DataMixingHcalDigiWorker.h.

QIE11DigiMap

typedef std::multimap<DetId, CaloSamples> edm::DataMixingHcalDigiWorker::QIE11DigiMap

private

Definition at line 105 of file DataMixingHcalDigiWorker.h.

ZDCDigiMap

typedef std::multimap<DetId, CaloSamples> edm::DataMixingHcalDigiWorker::ZDCDigiMap

private

Definition at line 103 of file DataMixingHcalDigiWorker.h.

Constructor & Destructor Documentation

DataMixingHcalDigiWorker() [1/2]

DataMixingHcalDigiWorker::DataMixingHcalDigiWorker

(

)

Definition at line 234 of file DataMixingHcalDigiWorker.cc.

{}

DataMixingHcalDigiWorker() [2/2]

DataMixingHcalDigiWorker::DataMixingHcalDigiWorker ( const edm::ParameterSet &  ps, edm::ConsumesCollector &&  iC  )

explicit

standard constructor

Definition at line 237 of file DataMixingHcalDigiWorker.cc.

      : label_(ps.getParameter<std::string>("Label")) {
    // get the subdetector names
    //    this->getSubdetectorNames();  //something like this may be useful to
    //    check what we are supposed to do...
 
    // declare the products to produce
 
    // Hcal
 
    HBHEdigiCollectionSig_ = ps.getParameter<edm::InputTag>("HBHEdigiCollectionSig");
    HOdigiCollectionSig_ = ps.getParameter<edm::InputTag>("HOdigiCollectionSig");
    HFdigiCollectionSig_ = ps.getParameter<edm::InputTag>("HFdigiCollectionSig");
    ZDCdigiCollectionSig_ = ps.getParameter<edm::InputTag>("ZDCdigiCollectionSig");
    QIE10digiCollectionSig_ = ps.getParameter<edm::InputTag>("QIE10digiCollectionSig");
    QIE11digiCollectionSig_ = ps.getParameter<edm::InputTag>("QIE11digiCollectionSig");
 
    HBHEPileInputTag_ = ps.getParameter<edm::InputTag>("HBHEPileInputTag");
    HOPileInputTag_ = ps.getParameter<edm::InputTag>("HOPileInputTag");
    HFPileInputTag_ = ps.getParameter<edm::InputTag>("HFPileInputTag");
    ZDCPileInputTag_ = ps.getParameter<edm::InputTag>("ZDCPileInputTag");
    QIE10PileInputTag_ = ps.getParameter<edm::InputTag>("QIE10PileInputTag");
    QIE11PileInputTag_ = ps.getParameter<edm::InputTag>("QIE11PileInputTag");
 
    HBHEDigiToken_ = iC.consumes<HBHEDigiCollection>(HBHEdigiCollectionSig_);
    HODigiToken_ = iC.consumes<HODigiCollection>(HOdigiCollectionSig_);
    HFDigiToken_ = iC.consumes<HFDigiCollection>(HFdigiCollectionSig_);
    QIE10DigiToken_ = iC.consumes<QIE10DigiCollection>(QIE10digiCollectionSig_);
    QIE11DigiToken_ = iC.consumes<QIE11DigiCollection>(QIE11digiCollectionSig_);
 
    HBHEDigiPToken_ = iC.consumes<HBHEDigiCollection>(HBHEPileInputTag_);
    HODigiPToken_ = iC.consumes<HODigiCollection>(HOPileInputTag_);
    HFDigiPToken_ = iC.consumes<HFDigiCollection>(HFPileInputTag_);
    QIE10DigiPToken_ = iC.consumes<QIE10DigiCollection>(QIE10PileInputTag_);
    QIE11DigiPToken_ = iC.consumes<QIE11DigiCollection>(QIE11PileInputTag_);
 
    DoZDC_ = false;
    if (!ZDCPileInputTag_.label().empty())
      DoZDC_ = true;
 
    if (DoZDC_) {
      ZDCDigiToken_ = iC.consumes<ZDCDigiCollection>(ZDCdigiCollectionSig_);
      ZDCDigiPToken_ = iC.consumes<ZDCDigiCollection>(ZDCPileInputTag_);
    }
 
    HBHEDigiCollectionDM_ = ps.getParameter<std::string>("HBHEDigiCollectionDM");
    HODigiCollectionDM_ = ps.getParameter<std::string>("HODigiCollectionDM");
    HFDigiCollectionDM_ = ps.getParameter<std::string>("HFDigiCollectionDM");
    ZDCDigiCollectionDM_ = ps.getParameter<std::string>("ZDCDigiCollectionDM");
    QIE10DigiCollectionDM_ = ps.getParameter<std::string>("QIE10DigiCollectionDM");
    QIE11DigiCollectionDM_ = ps.getParameter<std::string>("QIE11DigiCollectionDM");
  }

References DoZDC_, edm::ParameterSet::getParameter(), HBHEDigiCollectionDM_, HBHEdigiCollectionSig_, HBHEDigiPToken_, HBHEDigiToken_, HBHEPileInputTag_, HFDigiCollectionDM_, HFdigiCollectionSig_, HFDigiPToken_, HFDigiToken_, HFPileInputTag_, HODigiCollectionDM_, HOdigiCollectionSig_, HODigiPToken_, HODigiToken_, HOPileInputTag_, edm::InputTag::label(), QIE10DigiCollectionDM_, QIE10digiCollectionSig_, QIE10DigiPToken_, QIE10DigiToken_, QIE10PileInputTag_, QIE11DigiCollectionDM_, QIE11digiCollectionSig_, QIE11DigiPToken_, QIE11DigiToken_, QIE11PileInputTag_, AlCaHLTBitMon_QueryRunRegistry::string, ZDCDigiCollectionDM_, ZDCdigiCollectionSig_, ZDCDigiPToken_, ZDCDigiToken_, and ZDCPileInputTag_.

~DataMixingHcalDigiWorker()

DataMixingHcalDigiWorker::~DataMixingHcalDigiWorker ( )

virtual

Default destructor

Definition at line 291 of file DataMixingHcalDigiWorker.cc.

{}

Member Function Documentation

addHcalPileups()

void DataMixingHcalDigiWorker::addHcalPileups	(	const int	bcr,
		const edm::EventPrincipal *	ep,
		unsigned int	EventId,
		const edm::EventSetup &	ES,
		ModuleCallingContext const *	mcc
	)

Definition at line 353 of file DataMixingHcalDigiWorker.cc.

                                                                                 {
    LogDebug("DataMixingHcalDigiWorker") << "\n===============> adding pileups from event  " << ep->id()
                                         << " for bunchcrossing " << bcr;
 
    // get conditions
    edm::ESHandle<HcalDbService> conditions;
    ES.get<HcalDbRecord>().get(conditions);
 
    convertPileupHcalDigis<HBHEDigiCollection>(*ep, HBHEPileInputTag_, mcc, *conditions, HBHEDigiStorage_);
    convertPileupHcalDigis<HODigiCollection>(*ep, HOPileInputTag_, mcc, *conditions, HODigiStorage_);
    convertPileupHcalDigis<HFDigiCollection>(*ep, HFPileInputTag_, mcc, *conditions, HFDigiStorage_);
    convertPileupHcalDigis<QIE10DigiCollection>(*ep, QIE10PileInputTag_, mcc, *conditions, QIE10DigiStorage_);
    convertPileupHcalDigis<QIE11DigiCollection>(*ep, QIE11PileInputTag_, mcc, *conditions, QIE11DigiStorage_);
 
    // ZDC Next
 
    if (DoZDC_) {
      std::shared_ptr<Wrapper<ZDCDigiCollection> const> ZDCDigisPTR =
          getProductByTag<ZDCDigiCollection>(*ep, ZDCPileInputTag_, mcc);
 
      if (ZDCDigisPTR) {
        const ZDCDigiCollection *ZDCDigis = const_cast<ZDCDigiCollection *>(ZDCDigisPTR->product());
 
        LogDebug("DataMixingHcalDigiWorker") << "total # ZDC digis: " << ZDCDigis->size();
 
        // loop over digis, adding these to the existing maps
        for (ZDCDigiCollection::const_iterator it = ZDCDigis->begin(); it != ZDCDigis->end(); ++it) {
          // calibration, for future reference:  (same block for all Hcal types)
          // ZDC is different
          HcalZDCDetId cell = it->id();
          const HcalQIECoder *channelCoder = conditions->getHcalCoder(cell);
          const HcalQIEShape *shape = conditions->getHcalShape(channelCoder);  // this one is generic
          HcalCoderDb coder(*channelCoder, *shape);
 
          CaloSamples tool;
          coder.adc2fC((*it), tool);
 
          ZDCDigiStorage_.insert(ZDCDigiMap::value_type((it->id()), tool));
 
#ifdef DEBUG
          // Commented out because this does not compile anymore
          // LogDebug("DataMixingHcalDigiWorker") << "processed ZDCDigi with
          // rawId: "
          //                                      << it->id() << "\n"
          //                                      << " digi energy: " <<
          //                                      it->energy();
#endif
        }
      }
    }
  }

References HcalCoderDb::adc2fC(), edm::SortedCollection< T, SORT >::begin(), DoZDC_, edm::SortedCollection< T, SORT >::end(), SiStripBadComponentsDQMServiceTemplate_cfg::ep, edm::EventSetup::get(), edm::get(), HcalDbService::getHcalCoder(), HcalDbService::getHcalShape(), HBHEDigiStorage_, HBHEPileInputTag_, HFDigiStorage_, HFPileInputTag_, HODigiStorage_, HOPileInputTag_, LogDebug, QIE10DigiStorage_, QIE10PileInputTag_, QIE11DigiStorage_, QIE11PileInputTag_, edm::SortedCollection< T, SORT >::size(), ZDCDigiStorage_, and ZDCPileInputTag_.

Referenced by edm::DataMixingModule::pileWorker().

addHcalSignals()

void DataMixingHcalDigiWorker::addHcalSignals	(	const edm::Event &	e,
		const edm::EventSetup &	ES
	)

Definition at line 293 of file DataMixingHcalDigiWorker.cc.

                                                                                          {
    // Calibration stuff will look like this:
    // get conditions
    edm::ESHandle<HcalDbService> conditions;
    ES.get<HcalDbRecord>().get(conditions);
 
    // fill in maps of hits
 
    LogInfo("DataMixingHcalDigiWorker") << "===============> adding MC signals for " << e.id();
    convertSignalHcalDigis<HBHEDigiCollection>(e, HBHEDigiToken_, *conditions, HBHEDigiStorage_);
    convertSignalHcalDigis<HODigiCollection>(e, HODigiToken_, *conditions, HODigiStorage_);
    convertSignalHcalDigis<HFDigiCollection>(e, HFDigiToken_, *conditions, HFDigiStorage_);
    convertSignalHcalDigis<QIE10DigiCollection>(e, QIE10DigiToken_, *conditions, QIE10DigiStorage_);
    convertSignalHcalDigis<QIE11DigiCollection>(e, QIE11DigiToken_, *conditions, QIE11DigiStorage_);
 
    // ZDC next
 
    if (DoZDC_) {
      Handle<ZDCDigiCollection> pZDCDigis;
 
      const ZDCDigiCollection *ZDCDigis = nullptr;
 
      if (e.getByToken(ZDCDigiToken_, pZDCDigis)) {
        ZDCDigis = pZDCDigis.product();  // get a ptr to the product
#ifdef DEBUG
        LogDebug("DataMixingHcalDigiWorker") << "total # ZDC digis: " << ZDCDigis->size();
#endif
      }
 
      if (ZDCDigis) {
        // loop over digis, storing them in a map so we can add pileup later
        for (ZDCDigiCollection::const_iterator it = ZDCDigis->begin(); it != ZDCDigis->end(); ++it) {
          // calibration, for future reference:  (same block for all Hcal types)
          // ZDC is different
          HcalZDCDetId cell = it->id();
          //         const HcalCalibrations&
          //         calibrations=conditions->getHcalCalibrations(cell);
          const HcalQIECoder *channelCoder = conditions->getHcalCoder(cell);
          const HcalQIEShape *shape = conditions->getHcalShape(channelCoder);  // this one is generic
          HcalCoderDb coder(*channelCoder, *shape);
 
          CaloSamples tool;
          coder.adc2fC((*it), tool);
 
          ZDCDigiStorage_.insert(ZDCDigiMap::value_type((it->id()), tool));
 
#ifdef DEBUG
          // Commented out because this does not compile anymore
          // LogDebug("DataMixingHcalDigiWorker") << "processed ZDCDigi with
          // rawId: "
          //                                      << it->id() << "\n"
          //                                      << " digi energy: " <<
          //                                      it->energy();
#endif
        }
      }
    }
 
  }  // end of addHCalSignals

References HcalCoderDb::adc2fC(), edm::SortedCollection< T, SORT >::begin(), DoZDC_, MillePedeFileConverter_cfg::e, edm::SortedCollection< T, SORT >::end(), edm::EventSetup::get(), edm::get(), HcalDbService::getHcalCoder(), HcalDbService::getHcalShape(), HBHEDigiStorage_, HBHEDigiToken_, HFDigiStorage_, HFDigiToken_, HODigiStorage_, HODigiToken_, LogDebug, edm::Handle< T >::product(), QIE10DigiStorage_, QIE10DigiToken_, QIE11DigiStorage_, QIE11DigiToken_, edm::SortedCollection< T, SORT >::size(), ZDCDigiStorage_, and ZDCDigiToken_.

Referenced by edm::DataMixingModule::addSignals().

putHcal()

void DataMixingHcalDigiWorker::putHcal	(	edm::Event &	e,
		const edm::EventSetup &	ES
	)

Definition at line 409 of file DataMixingHcalDigiWorker.cc.

                                                                             {
    edm::ESHandle<HcalDbService> conditions;
    ES.get<HcalDbRecord>().get(conditions);
 
    // collection of digis to put in the event
    std::unique_ptr<HBHEDigiCollection> HBHEdigis = buildHcalDigis<HBHEDigiCollection>(HBHEDigiStorage_, *conditions);
    std::unique_ptr<HODigiCollection> HOdigis = buildHcalDigis<HODigiCollection>(HODigiStorage_, *conditions);
    std::unique_ptr<HFDigiCollection> HFdigis = buildHcalDigis<HFDigiCollection>(HFDigiStorage_, *conditions);
    std::unique_ptr<QIE10DigiCollection> QIE10digis =
        buildHcalDigis<QIE10DigiCollection>(QIE10DigiStorage_, *conditions);
    std::unique_ptr<QIE11DigiCollection> QIE11digis =
        buildHcalDigis<QIE11DigiCollection>(QIE11DigiStorage_, *conditions);
    std::unique_ptr<ZDCDigiCollection> ZDCdigis(new ZDCDigiCollection);
 
    // loop over the maps we have, re-making individual hits or digis if
    // necessary.
    DetId formerID = 0;
    DetId currentID;
 
    double fC_new;
    double fC_old;
    double fC_sum;
 
    // ZDC next...
 
    // loop over the maps we have, re-making individual hits or digis if
    // necessary.
    formerID = 0;
    CaloSamples ZDC_old;
 
    ZDCDigiMap::const_iterator iZDCchk;
 
    for (ZDCDigiMap::const_iterator iZDC = ZDCDigiStorage_.begin(); iZDC != ZDCDigiStorage_.end(); ++iZDC) {
      currentID = iZDC->first;
 
      if (currentID == formerID) {  // we have to add these digis together
 
        // loop over digi samples in each CaloSample
        unsigned int sizenew = (iZDC->second).size();
        unsigned int sizeold = ZDC_old.size();
 
        unsigned int max_samp = std::max(sizenew, sizeold);
 
        CaloSamples ZDC_bigger(currentID, max_samp);
 
        bool usenew = false;
 
        if (sizenew > sizeold)
          usenew = true;
 
        // samples from different events can be of different lengths - sum all
        // that overlap.
 
        for (unsigned int isamp = 0; isamp < max_samp; isamp++) {
          if (isamp < sizenew) {
            fC_new = (iZDC->second)[isamp];
          } else {
            fC_new = 0;
          }
 
          if (isamp < sizeold) {
            fC_old = ZDC_old[isamp];
          } else {
            fC_old = 0;
          }
 
          // add values
          fC_sum = fC_new + fC_old;
 
          if (usenew) {
            ZDC_bigger[isamp] = fC_sum;
          } else {
            ZDC_old[isamp] = fC_sum;
          }  // overwrite old sample, adding new info
        }
        if (usenew)
          ZDC_old = ZDC_bigger;  // save new, larger sized sample in "old" slot
 
      } else {
        if (formerID > 0) {
          // make new digi
          ZDCdigis->push_back(ZDCDataFrame(formerID));
 
          // set up information to convert back
 
          HcalZDCDetId cell = ZDC_old.id();
          const HcalQIECoder *channelCoder = conditions->getHcalCoder(cell);
          const HcalQIEShape *shape = conditions->getHcalShape(channelCoder);  // this one is generic
          HcalCoderDb coder(*channelCoder, *shape);
 
          unsigned int sizeold = ZDC_old.size();
          for (unsigned int isamp = 0; isamp < sizeold; isamp++) {
            coder.fC2adc(ZDC_old, (ZDCdigis->back()),
                         1);  // as per simulation, capid=1
          }
        }
        // save pointers for next iteration
        formerID = currentID;
        ZDC_old = iZDC->second;
      }
 
      iZDCchk = iZDC;
      if ((++iZDCchk) == ZDCDigiStorage_.end()) {  // make sure not to lose the last one
        // make new digi
        ZDCdigis->push_back(ZDCDataFrame(currentID));
 
        // set up information to convert back
 
        HcalZDCDetId cell = (iZDC->second).id();
        const HcalQIECoder *channelCoder = conditions->getHcalCoder(cell);
        const HcalQIEShape *shape = conditions->getHcalShape(channelCoder);  // this one is generic
        HcalCoderDb coder(*channelCoder, *shape);
 
        unsigned int sizeold = (iZDC->second).size();
        for (unsigned int isamp = 0; isamp < sizeold; isamp++) {
          coder.fC2adc(ZDC_old, (ZDCdigis->back()),
                       1);  // as per simulation, capid=1
        }
      }
    }
 
    // done merging
 
    // put the collection of recunstructed hits in the event
    LogInfo("DataMixingHcalDigiWorker") << "total # HBHE Merged digis: " << HBHEdigis->size();
    LogInfo("DataMixingHcalDigiWorker") << "total # HO Merged digis: " << HOdigis->size();
    LogInfo("DataMixingHcalDigiWorker") << "total # HF Merged digis: " << HFdigis->size();
    LogInfo("DataMixingHcalDigiWorker") << "total # QIE10 Merged digis: " << QIE10digis->size();
    LogInfo("DataMixingHcalDigiWorker") << "total # QIE11 Merged digis: " << QIE11digis->size();
    LogInfo("DataMixingHcalDigiWorker") << "total # ZDC Merged digis: " << ZDCdigis->size();
 
    e.put(std::move(HBHEdigis), HBHEDigiCollectionDM_);
    e.put(std::move(HOdigis), HODigiCollectionDM_);
    e.put(std::move(HFdigis), HFDigiCollectionDM_);
    e.put(std::move(QIE10digis), QIE10DigiCollectionDM_);
    e.put(std::move(QIE11digis), QIE11DigiCollectionDM_);
    e.put(std::move(ZDCdigis), ZDCDigiCollectionDM_);
 
    // clear local storage after this event
    HBHEDigiStorage_.clear();
    HODigiStorage_.clear();
    HFDigiStorage_.clear();
    QIE10DigiStorage_.clear();
    QIE11DigiStorage_.clear();
    ZDCDigiStorage_.clear();
  }

References MillePedeFileConverter_cfg::e, HcalCoderDb::fC2adc(), edm::EventSetup::get(), edm::get(), HcalDbService::getHcalCoder(), HcalDbService::getHcalShape(), HBHEDigiCollectionDM_, HBHEDigiStorage_, HFDigiCollectionDM_, HFDigiStorage_, HODigiCollectionDM_, HODigiStorage_, CaloSamples::id(), SiStripPI::max, eostools::move(), QIE10DigiCollectionDM_, QIE10DigiStorage_, QIE11DigiCollectionDM_, QIE11DigiStorage_, CaloSamples::size(), findQualityFiles::size, ZDCDigiCollectionDM_, and ZDCDigiStorage_.

Referenced by edm::DataMixingModule::put().

Member Data Documentation

DoZDC_

bool edm::DataMixingHcalDigiWorker::DoZDC_

private

Definition at line 114 of file DataMixingHcalDigiWorker.h.

Referenced by addHcalPileups(), addHcalSignals(), and DataMixingHcalDigiWorker().

HBHEDigiCollectionDM_

std::string edm::DataMixingHcalDigiWorker::HBHEDigiCollectionDM_

private

Definition at line 90 of file DataMixingHcalDigiWorker.h.

Referenced by DataMixingHcalDigiWorker(), and putHcal().

HBHEdigiCollectionSig_

edm::InputTag edm::DataMixingHcalDigiWorker::HBHEdigiCollectionSig_

private

Definition at line 62 of file DataMixingHcalDigiWorker.h.

Referenced by DataMixingHcalDigiWorker().

HBHEDigiPToken_

edm::EDGetTokenT<HBHEDigiCollection> edm::DataMixingHcalDigiWorker::HBHEDigiPToken_

private

Definition at line 83 of file DataMixingHcalDigiWorker.h.

Referenced by DataMixingHcalDigiWorker().

HBHEDigiStorage_

HBHEDigiMap edm::DataMixingHcalDigiWorker::HBHEDigiStorage_

private

Definition at line 107 of file DataMixingHcalDigiWorker.h.

Referenced by addHcalPileups(), addHcalSignals(), and putHcal().

HBHEDigiToken_

edm::EDGetTokenT<HBHEDigiCollection> edm::DataMixingHcalDigiWorker::HBHEDigiToken_

private

Definition at line 76 of file DataMixingHcalDigiWorker.h.

Referenced by addHcalSignals(), and DataMixingHcalDigiWorker().

HBHEPileInputTag_

edm::InputTag edm::DataMixingHcalDigiWorker::HBHEPileInputTag_

private

Definition at line 69 of file DataMixingHcalDigiWorker.h.

Referenced by addHcalPileups(), and DataMixingHcalDigiWorker().

HFDigiCollectionDM_

std::string edm::DataMixingHcalDigiWorker::HFDigiCollectionDM_

private

Definition at line 93 of file DataMixingHcalDigiWorker.h.

Referenced by DataMixingHcalDigiWorker(), and putHcal().

HFdigiCollectionSig_

edm::InputTag edm::DataMixingHcalDigiWorker::HFdigiCollectionSig_

private

Definition at line 64 of file DataMixingHcalDigiWorker.h.

Referenced by DataMixingHcalDigiWorker().

HFDigiPToken_

edm::EDGetTokenT<HFDigiCollection> edm::DataMixingHcalDigiWorker::HFDigiPToken_

private

Definition at line 85 of file DataMixingHcalDigiWorker.h.

Referenced by DataMixingHcalDigiWorker().

HFDigiStorage_

HFDigiMap edm::DataMixingHcalDigiWorker::HFDigiStorage_

private

Definition at line 108 of file DataMixingHcalDigiWorker.h.

Referenced by addHcalPileups(), addHcalSignals(), and putHcal().

HFDigiToken_

edm::EDGetTokenT<HFDigiCollection> edm::DataMixingHcalDigiWorker::HFDigiToken_

private

Definition at line 78 of file DataMixingHcalDigiWorker.h.

Referenced by addHcalSignals(), and DataMixingHcalDigiWorker().

HFPileInputTag_

edm::InputTag edm::DataMixingHcalDigiWorker::HFPileInputTag_

private

Definition at line 71 of file DataMixingHcalDigiWorker.h.

Referenced by addHcalPileups(), and DataMixingHcalDigiWorker().

HODigiCollectionDM_

std::string edm::DataMixingHcalDigiWorker::HODigiCollectionDM_

private

Definition at line 92 of file DataMixingHcalDigiWorker.h.

Referenced by DataMixingHcalDigiWorker(), and putHcal().

HOdigiCollectionSig_

edm::InputTag edm::DataMixingHcalDigiWorker::HOdigiCollectionSig_

private

Definition at line 63 of file DataMixingHcalDigiWorker.h.

Referenced by DataMixingHcalDigiWorker().

HODigiPToken_

edm::EDGetTokenT<HODigiCollection> edm::DataMixingHcalDigiWorker::HODigiPToken_

private

Definition at line 84 of file DataMixingHcalDigiWorker.h.

Referenced by DataMixingHcalDigiWorker().

HODigiStorage_

HODigiMap edm::DataMixingHcalDigiWorker::HODigiStorage_

private

Definition at line 109 of file DataMixingHcalDigiWorker.h.

Referenced by addHcalPileups(), addHcalSignals(), and putHcal().

HODigiToken_

edm::EDGetTokenT<HODigiCollection> edm::DataMixingHcalDigiWorker::HODigiToken_

private

Definition at line 77 of file DataMixingHcalDigiWorker.h.

Referenced by addHcalSignals(), and DataMixingHcalDigiWorker().

HOPileInputTag_

edm::InputTag edm::DataMixingHcalDigiWorker::HOPileInputTag_

private

Definition at line 70 of file DataMixingHcalDigiWorker.h.

Referenced by addHcalPileups(), and DataMixingHcalDigiWorker().

label_

std::string edm::DataMixingHcalDigiWorker::label_

private

Definition at line 116 of file DataMixingHcalDigiWorker.h.

Referenced by SequenceTypes.DummyModule::__repr__(), Mixins._Labelable::_findDependencies(), and Mixins._Labelable::setLabel().

QIE10DigiCollectionDM_

std::string edm::DataMixingHcalDigiWorker::QIE10DigiCollectionDM_

private

Definition at line 95 of file DataMixingHcalDigiWorker.h.

Referenced by DataMixingHcalDigiWorker(), and putHcal().

QIE10digiCollectionSig_

edm::InputTag edm::DataMixingHcalDigiWorker::QIE10digiCollectionSig_

private

Definition at line 66 of file DataMixingHcalDigiWorker.h.

Referenced by DataMixingHcalDigiWorker().

QIE10DigiPToken_

edm::EDGetTokenT<QIE10DigiCollection> edm::DataMixingHcalDigiWorker::QIE10DigiPToken_

private

Definition at line 87 of file DataMixingHcalDigiWorker.h.

Referenced by DataMixingHcalDigiWorker().

QIE10DigiStorage_

QIE10DigiMap edm::DataMixingHcalDigiWorker::QIE10DigiStorage_

private

Definition at line 111 of file DataMixingHcalDigiWorker.h.

Referenced by addHcalPileups(), addHcalSignals(), and putHcal().

QIE10DigiToken_

edm::EDGetTokenT<QIE10DigiCollection> edm::DataMixingHcalDigiWorker::QIE10DigiToken_

private

Definition at line 80 of file DataMixingHcalDigiWorker.h.

Referenced by addHcalSignals(), and DataMixingHcalDigiWorker().

QIE10PileInputTag_

edm::InputTag edm::DataMixingHcalDigiWorker::QIE10PileInputTag_

private

Definition at line 73 of file DataMixingHcalDigiWorker.h.

Referenced by addHcalPileups(), and DataMixingHcalDigiWorker().

QIE11DigiCollectionDM_

std::string edm::DataMixingHcalDigiWorker::QIE11DigiCollectionDM_

private

Definition at line 97 of file DataMixingHcalDigiWorker.h.

Referenced by DataMixingHcalDigiWorker(), and putHcal().

QIE11digiCollectionSig_

edm::InputTag edm::DataMixingHcalDigiWorker::QIE11digiCollectionSig_

private

Definition at line 67 of file DataMixingHcalDigiWorker.h.

Referenced by DataMixingHcalDigiWorker().

QIE11DigiPToken_

edm::EDGetTokenT<QIE11DigiCollection> edm::DataMixingHcalDigiWorker::QIE11DigiPToken_

private

Definition at line 88 of file DataMixingHcalDigiWorker.h.

Referenced by DataMixingHcalDigiWorker().

QIE11DigiStorage_

QIE11DigiMap edm::DataMixingHcalDigiWorker::QIE11DigiStorage_

private

Definition at line 112 of file DataMixingHcalDigiWorker.h.

Referenced by addHcalPileups(), addHcalSignals(), and putHcal().

QIE11DigiToken_

edm::EDGetTokenT<QIE11DigiCollection> edm::DataMixingHcalDigiWorker::QIE11DigiToken_

private

Definition at line 81 of file DataMixingHcalDigiWorker.h.

Referenced by addHcalSignals(), and DataMixingHcalDigiWorker().

QIE11PileInputTag_

edm::InputTag edm::DataMixingHcalDigiWorker::QIE11PileInputTag_

private

Definition at line 74 of file DataMixingHcalDigiWorker.h.

Referenced by addHcalPileups(), and DataMixingHcalDigiWorker().

ZDCDigiCollectionDM_

std::string edm::DataMixingHcalDigiWorker::ZDCDigiCollectionDM_

private

Definition at line 94 of file DataMixingHcalDigiWorker.h.

Referenced by DataMixingHcalDigiWorker(), and putHcal().

ZDCdigiCollectionSig_

edm::InputTag edm::DataMixingHcalDigiWorker::ZDCdigiCollectionSig_

private

Definition at line 65 of file DataMixingHcalDigiWorker.h.

Referenced by DataMixingHcalDigiWorker().

ZDCDigiPToken_

edm::EDGetTokenT<ZDCDigiCollection> edm::DataMixingHcalDigiWorker::ZDCDigiPToken_

private

Definition at line 86 of file DataMixingHcalDigiWorker.h.

Referenced by DataMixingHcalDigiWorker().

ZDCDigiStorage_

ZDCDigiMap edm::DataMixingHcalDigiWorker::ZDCDigiStorage_

private

Definition at line 110 of file DataMixingHcalDigiWorker.h.

Referenced by addHcalPileups(), addHcalSignals(), and putHcal().

ZDCDigiToken_

edm::EDGetTokenT<ZDCDigiCollection> edm::DataMixingHcalDigiWorker::ZDCDigiToken_

private

Definition at line 79 of file DataMixingHcalDigiWorker.h.

Referenced by addHcalSignals(), and DataMixingHcalDigiWorker().

ZDCPileInputTag_

edm::InputTag edm::DataMixingHcalDigiWorker::ZDCPileInputTag_

private

Definition at line 72 of file DataMixingHcalDigiWorker.h.

Referenced by addHcalPileups(), and DataMixingHcalDigiWorker().