edm::DataMixingHcalWorker Class Reference

#include <DataMixingHcalWorker.h>

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

Private Types
typedef std::multimap< DetId, HBHERecHit >	HBHERecHitMap
typedef std::multimap< DetId, HFRecHit >	HFRecHitMap
typedef std::multimap< DetId, HORecHit >	HORecHitMap
typedef std::multimap< DetId, ZDCRecHit >	ZDCRecHitMap

Private Attributes
edm::InputTag	HBHEPileRecHitInputTag_
std::string	HBHERecHitCollectionDM_
edm::InputTag	HBHErechitCollectionSig_
edm::EDGetTokenT< HBHERecHitCollection >	HBHERecHitPToken_
HBHERecHitMap	HBHERecHitStorage_
edm::EDGetTokenT< HBHERecHitCollection >	HBHERecHitToken_
edm::InputTag	HFPileRecHitInputTag_
std::string	HFRecHitCollectionDM_
edm::InputTag	HFrechitCollectionSig_
edm::EDGetTokenT< HFRecHitCollection >	HFRecHitPToken_
HFRecHitMap	HFRecHitStorage_
edm::EDGetTokenT< HFRecHitCollection >	HFRecHitToken_
edm::InputTag	HOPileRecHitInputTag_
std::string	HORecHitCollectionDM_
edm::InputTag	HOrechitCollectionSig_
edm::EDGetTokenT< HORecHitCollection >	HORecHitPToken_
HORecHitMap	HORecHitStorage_
edm::EDGetTokenT< HORecHitCollection >	HORecHitToken_
std::string	label_
edm::InputTag	ZDCPileRecHitInputTag_
std::string	ZDCRecHitCollectionDM_
edm::InputTag	ZDCrechitCollectionSig_
edm::EDGetTokenT< ZDCRecHitCollection >	ZDCRecHitPToken_
ZDCRecHitMap	ZDCRecHitStorage_
edm::EDGetTokenT< ZDCRecHitCollection >	ZDCRecHitToken_

Detailed Description

Definition at line 33 of file DataMixingHcalWorker.h.

Member Typedef Documentation

HBHERecHitMap

typedef std::multimap<DetId, HBHERecHit> edm::DataMixingHcalWorker::HBHERecHitMap

private

Definition at line 84 of file DataMixingHcalWorker.h.

HFRecHitMap

typedef std::multimap<DetId, HFRecHit> edm::DataMixingHcalWorker::HFRecHitMap

private

Definition at line 85 of file DataMixingHcalWorker.h.

HORecHitMap

typedef std::multimap<DetId, HORecHit> edm::DataMixingHcalWorker::HORecHitMap

private

Definition at line 86 of file DataMixingHcalWorker.h.

ZDCRecHitMap

typedef std::multimap<DetId, ZDCRecHit> edm::DataMixingHcalWorker::ZDCRecHitMap

private

Definition at line 87 of file DataMixingHcalWorker.h.

Constructor & Destructor Documentation

DataMixingHcalWorker() [1/2]

DataMixingHcalWorker::DataMixingHcalWorker

(

)

Definition at line 21 of file DataMixingHcalWorker.cc.

{}

DataMixingHcalWorker() [2/2]

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

explicit

standard constructor

Definition at line 24 of file DataMixingHcalWorker.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
 
    HBHErechitCollectionSig_ = ps.getParameter<edm::InputTag>("HBHEProducerSig");
    HOrechitCollectionSig_ = ps.getParameter<edm::InputTag>("HOProducerSig");
    HFrechitCollectionSig_ = ps.getParameter<edm::InputTag>("HFProducerSig");
    ZDCrechitCollectionSig_ = ps.getParameter<edm::InputTag>("ZDCrechitCollectionSig");
 
    HBHEPileRecHitInputTag_ = ps.getParameter<edm::InputTag>("HBHEPileRecHitInputTag");
    HOPileRecHitInputTag_ = ps.getParameter<edm::InputTag>("HOPileRecHitInputTag");
    HFPileRecHitInputTag_ = ps.getParameter<edm::InputTag>("HFPileRecHitInputTag");
    ZDCPileRecHitInputTag_ = ps.getParameter<edm::InputTag>("ZDCPileRecHitInputTag");
 
    HBHERecHitCollectionDM_ = ps.getParameter<std::string>("HBHERecHitCollectionDM");
    HORecHitCollectionDM_ = ps.getParameter<std::string>("HORecHitCollectionDM");
    HFRecHitCollectionDM_ = ps.getParameter<std::string>("HFRecHitCollectionDM");
    ZDCRecHitCollectionDM_ = ps.getParameter<std::string>("ZDCRecHitCollectionDM");
 
    HBHERecHitToken_ = iC.consumes<HBHERecHitCollection>(HBHErechitCollectionSig_);
    HORecHitToken_ = iC.consumes<HORecHitCollection>(HOrechitCollectionSig_);
    HFRecHitToken_ = iC.consumes<HFRecHitCollection>(HFrechitCollectionSig_);
 
    HBHERecHitPToken_ = iC.consumes<HBHERecHitCollection>(HBHEPileRecHitInputTag_);
    HORecHitPToken_ = iC.consumes<HORecHitCollection>(HOPileRecHitInputTag_);
    HFRecHitPToken_ = iC.consumes<HFRecHitCollection>(HFPileRecHitInputTag_);
 
    ZDCRecHitToken_ = iC.consumes<ZDCRecHitCollection>(ZDCrechitCollectionSig_);
    ZDCRecHitPToken_ = iC.consumes<ZDCRecHitCollection>(ZDCPileRecHitInputTag_);
  }

References edm::ParameterSet::getParameter(), HBHEPileRecHitInputTag_, HBHERecHitCollectionDM_, HBHErechitCollectionSig_, HBHERecHitPToken_, HBHERecHitToken_, HFPileRecHitInputTag_, HFRecHitCollectionDM_, HFrechitCollectionSig_, HFRecHitPToken_, HFRecHitToken_, HOPileRecHitInputTag_, HORecHitCollectionDM_, HOrechitCollectionSig_, HORecHitPToken_, HORecHitToken_, AlCaHLTBitMon_QueryRunRegistry::string, ZDCPileRecHitInputTag_, ZDCRecHitCollectionDM_, ZDCrechitCollectionSig_, ZDCRecHitPToken_, and ZDCRecHitToken_.

~DataMixingHcalWorker()

DataMixingHcalWorker::~DataMixingHcalWorker ( )

virtual

Default destructor

Definition at line 64 of file DataMixingHcalWorker.cc.

{}

Member Function Documentation

addHcalPileups()

void DataMixingHcalWorker::addHcalPileups	(	const int	bcr,
		const edm::EventPrincipal *	ep,
		unsigned int	EventId,
		ModuleCallingContext const *	mcc
	)

Definition at line 171 of file DataMixingHcalWorker.cc.

                                                                             {
    LogDebug("DataMixingHcalWorker") << "\n===============> adding pileups from event  " << ep->id()
                                     << " for bunchcrossing " << bcr;
 
    // fill in maps of hits; same code as addSignals, except now applied to the
    // pileup events
 
    // HBHE first
 
    std::shared_ptr<Wrapper<HBHERecHitCollection> const> HBHERecHitsPTR =
        getProductByTag<HBHERecHitCollection>(*ep, HBHEPileRecHitInputTag_, mcc);
 
    if (HBHERecHitsPTR) {
      const HBHERecHitCollection *HBHERecHits = const_cast<HBHERecHitCollection *>(HBHERecHitsPTR->product());
 
      LogDebug("DataMixingEMWorker") << "total # HBHE rechits: " << HBHERecHits->size();
 
      // loop over rechits, adding these to the existing maps
      for (HBHERecHitCollection::const_iterator it = HBHERecHits->begin(); it != HBHERecHits->end(); ++it) {
        HBHERecHitStorage_.insert(HBHERecHitMap::value_type((it->id()), *it));
 
#ifdef DEBUG
        LogDebug("DataMixingEMWorker") << "processed HBHERecHit with rawId: " << it->id().rawId() << "\n"
                                       << " rechit energy: " << it->energy();
#endif
      }
    }
 
    // HO Next
 
    std::shared_ptr<Wrapper<HORecHitCollection> const> HORecHitsPTR =
        getProductByTag<HORecHitCollection>(*ep, HOPileRecHitInputTag_, mcc);
 
    if (HORecHitsPTR) {
      const HORecHitCollection *HORecHits = const_cast<HORecHitCollection *>(HORecHitsPTR->product());
 
      LogDebug("DataMixingEMWorker") << "total # HO rechits: " << HORecHits->size();
 
      // loop over rechits, adding these to the existing maps
      for (HORecHitCollection::const_iterator it = HORecHits->begin(); it != HORecHits->end(); ++it) {
        HORecHitStorage_.insert(HORecHitMap::value_type((it->id()), *it));
 
#ifdef DEBUG
        LogDebug("DataMixingEMWorker") << "processed HORecHit with rawId: " << it->id().rawId() << "\n"
                                       << " rechit energy: " << it->energy();
#endif
      }
    }
 
    // HF Next
 
    std::shared_ptr<Wrapper<HFRecHitCollection> const> HFRecHitsPTR =
        getProductByTag<HFRecHitCollection>(*ep, HFPileRecHitInputTag_, mcc);
 
    if (HFRecHitsPTR) {
      const HFRecHitCollection *HFRecHits = const_cast<HFRecHitCollection *>(HFRecHitsPTR->product());
 
      LogDebug("DataMixingEMWorker") << "total # HF rechits: " << HFRecHits->size();
 
      // loop over rechits, adding these to the existing maps
      for (HFRecHitCollection::const_iterator it = HFRecHits->begin(); it != HFRecHits->end(); ++it) {
        HFRecHitStorage_.insert(HFRecHitMap::value_type((it->id()), *it));
 
#ifdef DEBUG
        LogDebug("DataMixingEMWorker") << "processed HFRecHit with rawId: " << it->id().rawId() << "\n"
                                       << " rechit energy: " << it->energy();
#endif
      }
    }
 
    // ZDC Next
 
    std::shared_ptr<Wrapper<ZDCRecHitCollection> const> ZDCRecHitsPTR =
        getProductByTag<ZDCRecHitCollection>(*ep, ZDCPileRecHitInputTag_, mcc);
 
    if (ZDCRecHitsPTR) {
      const ZDCRecHitCollection *ZDCRecHits = const_cast<ZDCRecHitCollection *>(ZDCRecHitsPTR->product());
 
      LogDebug("DataMixingEMWorker") << "total # ZDC rechits: " << ZDCRecHits->size();
 
      // loop over rechits, adding these to the existing maps
      for (ZDCRecHitCollection::const_iterator it = ZDCRecHits->begin(); it != ZDCRecHits->end(); ++it) {
        ZDCRecHitStorage_.insert(ZDCRecHitMap::value_type((it->id()), *it));
 
#ifdef DEBUG
        LogDebug("DataMixingEMWorker") << "processed ZDCRecHit with rawId: " << it->id().rawId() << "\n"
                                       << " rechit energy: " << it->energy();
#endif
      }
    }
  }

References edm::SortedCollection< T, SORT >::begin(), edm::SortedCollection< T, SORT >::end(), SiStripBadComponentsDQMServiceTemplate_cfg::ep, HBHEPileRecHitInputTag_, egHLT::errCodes::HBHERecHits, HBHERecHitStorage_, HFPileRecHitInputTag_, egHLT::errCodes::HFRecHits, HFRecHitStorage_, HOPileRecHitInputTag_, HORecHitStorage_, LogDebug, edm::SortedCollection< T, SORT >::size(), ZDCPileRecHitInputTag_, and ZDCRecHitStorage_.

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

addHcalSignals()

void DataMixingHcalWorker::addHcalSignals

(

const edm::Event &

e

)

Definition at line 66 of file DataMixingHcalWorker.cc.

                                                             {
    // fill in maps of hits
 
    LogInfo("DataMixingHcalWorker") << "===============> adding MC signals for " << e.id();
 
    // HBHE first
 
    Handle<HBHERecHitCollection> pHBHERecHits;
 
    const HBHERecHitCollection *HBHERecHits = nullptr;
 
    if (e.getByToken(HBHERecHitToken_, pHBHERecHits)) {
      HBHERecHits = pHBHERecHits.product();  // get a ptr to the product
      LogDebug("DataMixingHcalWorker") << "total # HBHE rechits: " << HBHERecHits->size();
    }
 
    if (HBHERecHits) {
      // loop over rechits, storing them in a map so we can add pileup later
      for (HBHERecHitCollection::const_iterator it = HBHERecHits->begin(); it != HBHERecHits->end(); ++it) {
        HBHERecHitStorage_.insert(HBHERecHitMap::value_type((it->id()), *it));
 
#ifdef DEBUG
        LogDebug("DataMixingHcalWorker") << "processed HBHERecHit with rawId: " << it->id() << "\n"
                                         << " rechit energy: " << it->energy();
#endif
      }
    }
 
    // HO next
 
    Handle<HORecHitCollection> pHORecHits;
 
    const HORecHitCollection *HORecHits = nullptr;
 
    if (e.getByToken(HORecHitToken_, pHORecHits)) {
      HORecHits = pHORecHits.product();  // get a ptr to the product
#ifdef DEBUG
      LogDebug("DataMixingHcalWorker") << "total # HO rechits: " << HORecHits->size();
#endif
    }
 
    if (HORecHits) {
      // loop over rechits, storing them in a map so we can add pileup later
      for (HORecHitCollection::const_iterator it = HORecHits->begin(); it != HORecHits->end(); ++it) {
        HORecHitStorage_.insert(HORecHitMap::value_type((it->id()), *it));
 
#ifdef DEBUG
        LogDebug("DataMixingHcalWorker") << "processed HORecHit with rawId: " << it->id() << "\n"
                                         << " rechit energy: " << it->energy();
#endif
      }
    }
 
    // HF next
 
    Handle<HFRecHitCollection> pHFRecHits;
 
    const HFRecHitCollection *HFRecHits = nullptr;
 
    if (e.getByToken(HFRecHitToken_, pHFRecHits)) {
      HFRecHits = pHFRecHits.product();  // get a ptr to the product
#ifdef DEBUG
      LogDebug("DataMixingHcalWorker") << "total # HF rechits: " << HFRecHits->size();
#endif
    }
 
    if (HFRecHits) {
      // loop over rechits, storing them in a map so we can add pileup later
      for (HFRecHitCollection::const_iterator it = HFRecHits->begin(); it != HFRecHits->end(); ++it) {
        HFRecHitStorage_.insert(HFRecHitMap::value_type((it->id()), *it));
 
#ifdef DEBUG
        LogDebug("DataMixingHcalWorker") << "processed HFRecHit with rawId: " << it->id() << "\n"
                                         << " rechit energy: " << it->energy();
#endif
      }
    }
 
    // ZDC next
 
    Handle<ZDCRecHitCollection> pZDCRecHits;
 
    const ZDCRecHitCollection *ZDCRecHits = nullptr;
 
    if (e.getByToken(ZDCRecHitToken_, pZDCRecHits)) {
      ZDCRecHits = pZDCRecHits.product();  // get a ptr to the product
#ifdef DEBUG
      LogDebug("DataMixingHcalWorker") << "total # ZDC rechits: " << ZDCRecHits->size();
#endif
    }
 
    if (ZDCRecHits) {
      // loop over rechits, storing them in a map so we can add pileup later
      for (ZDCRecHitCollection::const_iterator it = ZDCRecHits->begin(); it != ZDCRecHits->end(); ++it) {
        ZDCRecHitStorage_.insert(ZDCRecHitMap::value_type((it->id()), *it));
 
#ifdef DEBUG
        LogDebug("DataMixingHcalWorker") << "processed ZDCRecHit with rawId: " << it->id() << "\n"
                                         << " rechit energy: " << it->energy();
#endif
      }
    }
 
  }  // end of addEMSignals

References edm::SortedCollection< T, SORT >::begin(), MillePedeFileConverter_cfg::e, edm::SortedCollection< T, SORT >::end(), egHLT::errCodes::HBHERecHits, HBHERecHitStorage_, HBHERecHitToken_, egHLT::errCodes::HFRecHits, HFRecHitStorage_, HFRecHitToken_, HORecHitStorage_, HORecHitToken_, LogDebug, edm::Handle< T >::product(), edm::SortedCollection< T, SORT >::size(), ZDCRecHitStorage_, and ZDCRecHitToken_.

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

putHcal()

void DataMixingHcalWorker::putHcal

(

edm::Event &

e

)

Definition at line 266 of file DataMixingHcalWorker.cc.

                                                {
    // collection of rechits to put in the event
    std::unique_ptr<HBHERecHitCollection> HBHErechits(new HBHERecHitCollection);
    std::unique_ptr<HORecHitCollection> HOrechits(new HORecHitCollection);
    std::unique_ptr<HFRecHitCollection> HFrechits(new HFRecHitCollection);
    std::unique_ptr<ZDCRecHitCollection> ZDCrechits(new ZDCRecHitCollection);
 
    // loop over the maps we have, re-making individual hits or rechits if
    // necessary.
    DetId formerID = 0;
    DetId currentID;
    float ESum = 0.;
    float HBTime = 0.;
 
    // HB first...
 
    HBHERecHitMap::const_iterator iHBchk;
 
    for (HBHERecHitMap::const_iterator iHB = HBHERecHitStorage_.begin(); iHB != HBHERecHitStorage_.end(); ++iHB) {
      currentID = iHB->first;
 
      if (currentID == formerID) {  // we have to add these rechits together
 
        ESum += (iHB->second).energy();
 
      } else {
        if (formerID > 0) {
          // cutoff for ESum?
          HBHERecHit aHit(formerID, ESum, HBTime);
          HBHErechits->push_back(aHit);
        }
        // save pointers for next iteration
        formerID = currentID;
        ESum = (iHB->second).energy();
        HBTime = (iHB->second).time();  // take time of first hit in sequence - is this ok?
      }
 
      iHBchk = iHB;
      if ((++iHBchk) == HBHERecHitStorage_.end()) {  // make sure not to lose the last one
        HBHERecHit aHit(formerID, ESum, HBTime);
        HBHErechits->push_back(aHit);
      }
    }
 
    // HO next...
 
    // loop over the maps we have, re-making individual hits or rechits if
    // necessary.
    formerID = 0;
    ESum = 0.;
    float HOTime = 0.;
 
    HORecHitMap::const_iterator iHOchk;
 
    for (HORecHitMap::const_iterator iHO = HORecHitStorage_.begin(); iHO != HORecHitStorage_.end(); ++iHO) {
      currentID = iHO->first;
 
      if (currentID == formerID) {  // we have to add these rechits together
 
        ESum += (iHO->second).energy();
 
      } else {
        if (formerID > 0) {
          // cutoff for ESum?
          HORecHit aHit(formerID, ESum, HOTime);
          HOrechits->push_back(aHit);
        }
        // save pointers for next iteration
        formerID = currentID;
        ESum = (iHO->second).energy();
        HOTime = (iHO->second).time();  // take time of first hit in sequence - is this ok?
      }
 
      iHOchk = iHO;
      if ((++iHOchk) == HORecHitStorage_.end()) {  // make sure not to lose the last one
        HORecHit aHit(formerID, ESum, HOTime);
        HOrechits->push_back(aHit);
      }
    }
 
    // HF next...
 
    // loop over the maps we have, re-making individual hits or rechits if
    // necessary.
    formerID = 0;
    ESum = 0.;
    float HFTime = 0.;
 
    HFRecHitMap::const_iterator iHFchk;
 
    for (HFRecHitMap::const_iterator iHF = HFRecHitStorage_.begin(); iHF != HFRecHitStorage_.end(); ++iHF) {
      currentID = iHF->first;
 
      if (currentID == formerID) {  // we have to add these rechits together
 
        ESum += (iHF->second).energy();
 
      } else {
        if (formerID > 0) {
          // cutoff for ESum?
          HFRecHit aHit(formerID, ESum, HFTime);
          HFrechits->push_back(aHit);
        }
        // save pointers for next iteration
        formerID = currentID;
        ESum = (iHF->second).energy();
        HFTime = (iHF->second).time();  // take time of first hit in sequence - is this ok?
      }
 
      iHFchk = iHF;
      if ((++iHFchk) == HFRecHitStorage_.end()) {  // make sure not to lose the last one
        HFRecHit aHit(formerID, ESum, HBTime);
        HFrechits->push_back(aHit);
      }
    }
 
    // ZDC next...
 
    // loop over the maps we have, re-making individual hits or rechits if
    // necessary.
    formerID = 0;
    ESum = 0.;
    float ZDCTime = 0.;
    float lowGainEnergy = 0;
    ZDCRecHit ZOldHit;
 
    ZDCRecHitMap::const_iterator iZDCchk;
 
    for (ZDCRecHitMap::const_iterator iZDC = ZDCRecHitStorage_.begin(); iZDC != ZDCRecHitStorage_.end(); ++iZDC) {
      currentID = iZDC->first;
 
      if (currentID == formerID) {  // we have to add these rechits together
 
        ESum += (iZDC->second).energy();
 
      } else {
        if (formerID > 0) {
          // cutoff for ESum?
          ZDCRecHit aHit(formerID, ESum, ZDCTime, lowGainEnergy);
          ZDCrechits->push_back(aHit);
        }
        // save pointers for next iteration
        formerID = currentID;
        ESum = (iZDC->second).energy();
        lowGainEnergy = (iZDC->second).lowGainEnergy();
        ZDCTime = (iZDC->second).time();  // take time of first hit in sequence - is this ok?
      }
 
      iZDCchk = iZDC;
      if ((++iZDCchk) == ZDCRecHitStorage_.end()) {  // make sure not to lose the last one
        ZDCRecHit aHit(formerID, ESum, HBTime, lowGainEnergy);
        ZDCrechits->push_back(aHit);
      }
    }
 
    // done merging
 
    // put the collection of recunstructed hits in the event
    LogInfo("DataMixingHcalWorker") << "total # HBHE Merged rechits: " << HBHErechits->size();
    LogInfo("DataMixingHcalWorker") << "total # HO Merged rechits: " << HOrechits->size();
    LogInfo("DataMixingHcalWorker") << "total # HF Merged rechits: " << HFrechits->size();
    LogInfo("DataMixingHcalWorker") << "total # ZDC Merged rechits: " << ZDCrechits->size();
 
    e.put(std::move(HBHErechits), HBHERecHitCollectionDM_);
    e.put(std::move(HOrechits), HORecHitCollectionDM_);
    e.put(std::move(HFrechits), HFRecHitCollectionDM_);
    e.put(std::move(ZDCrechits), ZDCRecHitCollectionDM_);
 
    // clear local storage after this event
    HBHERecHitStorage_.clear();
    HORecHitStorage_.clear();
    HFRecHitStorage_.clear();
    ZDCRecHitStorage_.clear();
  }

References MillePedeFileConverter_cfg::e, HCALHighEnergyHPDFilter_cfi::energy, HBHERecHitCollectionDM_, HBHERecHitStorage_, HFRecHitCollectionDM_, HFRecHitStorage_, HORecHitCollectionDM_, HORecHitStorage_, eostools::move(), protons_cff::time, ZDCRecHitCollectionDM_, and ZDCRecHitStorage_.

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

Member Data Documentation

HBHEPileRecHitInputTag_

edm::InputTag edm::DataMixingHcalWorker::HBHEPileRecHitInputTag_

private

Definition at line 60 of file DataMixingHcalWorker.h.

Referenced by addHcalPileups(), and DataMixingHcalWorker().

HBHERecHitCollectionDM_

std::string edm::DataMixingHcalWorker::HBHERecHitCollectionDM_

private

Definition at line 75 of file DataMixingHcalWorker.h.

Referenced by DataMixingHcalWorker(), and putHcal().

HBHErechitCollectionSig_

edm::InputTag edm::DataMixingHcalWorker::HBHErechitCollectionSig_

private

Definition at line 51 of file DataMixingHcalWorker.h.

Referenced by DataMixingHcalWorker().

HBHERecHitPToken_

edm::EDGetTokenT<HBHERecHitCollection> edm::DataMixingHcalWorker::HBHERecHitPToken_

private

Definition at line 70 of file DataMixingHcalWorker.h.

Referenced by DataMixingHcalWorker().

HBHERecHitStorage_

HBHERecHitMap edm::DataMixingHcalWorker::HBHERecHitStorage_

private

Definition at line 89 of file DataMixingHcalWorker.h.

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

HBHERecHitToken_

edm::EDGetTokenT<HBHERecHitCollection> edm::DataMixingHcalWorker::HBHERecHitToken_

private

Definition at line 65 of file DataMixingHcalWorker.h.

Referenced by addHcalSignals(), and DataMixingHcalWorker().

HFPileRecHitInputTag_

edm::InputTag edm::DataMixingHcalWorker::HFPileRecHitInputTag_

private

Definition at line 62 of file DataMixingHcalWorker.h.

Referenced by addHcalPileups(), and DataMixingHcalWorker().

HFRecHitCollectionDM_

std::string edm::DataMixingHcalWorker::HFRecHitCollectionDM_

private

Definition at line 79 of file DataMixingHcalWorker.h.

Referenced by DataMixingHcalWorker(), and putHcal().

HFrechitCollectionSig_

edm::InputTag edm::DataMixingHcalWorker::HFrechitCollectionSig_

private

Definition at line 55 of file DataMixingHcalWorker.h.

Referenced by DataMixingHcalWorker().

HFRecHitPToken_

edm::EDGetTokenT<HFRecHitCollection> edm::DataMixingHcalWorker::HFRecHitPToken_

private

Definition at line 72 of file DataMixingHcalWorker.h.

Referenced by DataMixingHcalWorker().

HFRecHitStorage_

HFRecHitMap edm::DataMixingHcalWorker::HFRecHitStorage_

private

Definition at line 90 of file DataMixingHcalWorker.h.

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

HFRecHitToken_

edm::EDGetTokenT<HFRecHitCollection> edm::DataMixingHcalWorker::HFRecHitToken_

private

Definition at line 67 of file DataMixingHcalWorker.h.

Referenced by addHcalSignals(), and DataMixingHcalWorker().

HOPileRecHitInputTag_

edm::InputTag edm::DataMixingHcalWorker::HOPileRecHitInputTag_

private

Definition at line 61 of file DataMixingHcalWorker.h.

Referenced by addHcalPileups(), and DataMixingHcalWorker().

HORecHitCollectionDM_

std::string edm::DataMixingHcalWorker::HORecHitCollectionDM_

private

Definition at line 77 of file DataMixingHcalWorker.h.

Referenced by DataMixingHcalWorker(), and putHcal().

HOrechitCollectionSig_

edm::InputTag edm::DataMixingHcalWorker::HOrechitCollectionSig_

private

Definition at line 53 of file DataMixingHcalWorker.h.

Referenced by DataMixingHcalWorker().

HORecHitPToken_

edm::EDGetTokenT<HORecHitCollection> edm::DataMixingHcalWorker::HORecHitPToken_

private

Definition at line 71 of file DataMixingHcalWorker.h.

Referenced by DataMixingHcalWorker().

HORecHitStorage_

HORecHitMap edm::DataMixingHcalWorker::HORecHitStorage_

private

Definition at line 91 of file DataMixingHcalWorker.h.

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

HORecHitToken_

edm::EDGetTokenT<HORecHitCollection> edm::DataMixingHcalWorker::HORecHitToken_

private

Definition at line 66 of file DataMixingHcalWorker.h.

Referenced by addHcalSignals(), and DataMixingHcalWorker().

label_

std::string edm::DataMixingHcalWorker::label_

private

Definition at line 96 of file DataMixingHcalWorker.h.

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

ZDCPileRecHitInputTag_

edm::InputTag edm::DataMixingHcalWorker::ZDCPileRecHitInputTag_

private

Definition at line 63 of file DataMixingHcalWorker.h.

Referenced by addHcalPileups(), and DataMixingHcalWorker().

ZDCRecHitCollectionDM_

std::string edm::DataMixingHcalWorker::ZDCRecHitCollectionDM_

private

Definition at line 81 of file DataMixingHcalWorker.h.

Referenced by DataMixingHcalWorker(), and putHcal().

ZDCrechitCollectionSig_

edm::InputTag edm::DataMixingHcalWorker::ZDCrechitCollectionSig_

private

Definition at line 57 of file DataMixingHcalWorker.h.

Referenced by DataMixingHcalWorker().

ZDCRecHitPToken_

edm::EDGetTokenT<ZDCRecHitCollection> edm::DataMixingHcalWorker::ZDCRecHitPToken_

private

Definition at line 73 of file DataMixingHcalWorker.h.

Referenced by DataMixingHcalWorker().

ZDCRecHitStorage_

ZDCRecHitMap edm::DataMixingHcalWorker::ZDCRecHitStorage_

private

Definition at line 92 of file DataMixingHcalWorker.h.

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

ZDCRecHitToken_

edm::EDGetTokenT<ZDCRecHitCollection> edm::DataMixingHcalWorker::ZDCRecHitToken_

private

Definition at line 68 of file DataMixingHcalWorker.h.

Referenced by addHcalSignals(), and DataMixingHcalWorker().