#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

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

private

Definition at line 100 of file DataMixingHcalDigiWorker.h.

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

private

Definition at line 101 of file DataMixingHcalDigiWorker.h.

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

private

Definition at line 102 of file DataMixingHcalDigiWorker.h.

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

private

Definition at line 104 of file DataMixingHcalDigiWorker.h.

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

private

Definition at line 105 of file DataMixingHcalDigiWorker.h.

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

private

Definition at line 103 of file DataMixingHcalDigiWorker.h.

Constructor & Destructor Documentation

DataMixingHcalDigiWorker::DataMixingHcalDigiWorker ( )

Definition at line 234 of file DataMixingHcalDigiWorker.cc.

234 {}

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

explicit

standard constructor

Definition at line 237 of file DataMixingHcalDigiWorker.cc.

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

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

DataMixingHcalDigiWorker::~DataMixingHcalDigiWorker ( )

virtual

Default destructor

Definition at line 291 of file DataMixingHcalDigiWorker.cc.

291 {}

Member Function Documentation

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.

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

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

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

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

Definition at line 293 of file DataMixingHcalDigiWorker.cc.

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

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

                                                                                           {
     // 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

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

Definition at line 409 of file DataMixingHcalDigiWorker.cc.

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

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

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