#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 43 of file DataMixingHcalDigiWorker.h.

Member Typedef Documentation

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

private

Definition at line 101 of file DataMixingHcalDigiWorker.h.

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

private

Definition at line 102 of file DataMixingHcalDigiWorker.h.

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

private

Definition at line 103 of file DataMixingHcalDigiWorker.h.

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

private

Definition at line 105 of file DataMixingHcalDigiWorker.h.

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

private

Definition at line 106 of file DataMixingHcalDigiWorker.h.

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

private

Definition at line 104 of file DataMixingHcalDigiWorker.h.

Constructor & Destructor Documentation

DataMixingHcalDigiWorker::DataMixingHcalDigiWorker ( )

Definition at line 208 of file DataMixingHcalDigiWorker.cc.

208 { }

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

explicit

standard constructor

Definition at line 211 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() != "") 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 268 of file DataMixingHcalDigiWorker.cc.

268 {

269 }

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 335 of file DataMixingHcalDigiWorker.cc.

References HcalCoderDb::adc2fC(), edm::SortedCollection< T, SORT >::begin(), DoZDC_, edm::SortedCollection< T, SORT >::end(), 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 271 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 = 0;
 
      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 391 of file DataMixingHcalDigiWorker.cc.

References HcalCoderDb::fC2adc(), edm::EventSetup::get(), HcalDbService::getHcalCoder(), HcalDbService::getHcalShape(), HBHEDigiCollectionDM_, HBHEDigiStorage_, HFDigiCollectionDM_, HFDigiStorage_, HODigiCollectionDM_, HODigiStorage_, CaloSamples::id(), hpstanc_transforms::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();
 
   }