#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 >	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	ZDCDigiCollectionDM_

edm::InputTag	ZDCdigiCollectionSig_

edm::EDGetTokenT < ZDCDigiCollection >	ZDCDigiPToken_

ZDCDigiMap	ZDCDigiStorage_

edm::EDGetTokenT < ZDCDigiCollection >	ZDCDigiToken_

edm::InputTag	ZDCPileInputTag_

Detailed Description

Definition at line 41 of file DataMixingHcalDigiWorker.h.

Member Typedef Documentation

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

private

Definition at line 89 of file DataMixingHcalDigiWorker.h.

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

private

Definition at line 90 of file DataMixingHcalDigiWorker.h.

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

private

Definition at line 91 of file DataMixingHcalDigiWorker.h.

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

private

Definition at line 92 of file DataMixingHcalDigiWorker.h.

Constructor & Destructor Documentation

DataMixingHcalDigiWorker::DataMixingHcalDigiWorker ( )

Definition at line 136 of file DataMixingHcalDigiWorker.cc.

136 { }

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

explicit

standard constructor

Definition at line 139 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(), 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");
 
     HBHEPileInputTag_ = ps.getParameter<edm::InputTag>("HBHEPileInputTag");
     HOPileInputTag_ = ps.getParameter<edm::InputTag>("HOPileInputTag");
     HFPileInputTag_ = ps.getParameter<edm::InputTag>("HFPileInputTag");
     ZDCPileInputTag_ = ps.getParameter<edm::InputTag>("ZDCPileInputTag");
 
     HBHEDigiToken_ = iC.consumes<HBHEDigiCollection>(HBHEdigiCollectionSig_);
     HODigiToken_ = iC.consumes<HODigiCollection>(HOdigiCollectionSig_);
     HFDigiToken_ = iC.consumes<HFDigiCollection>(HFdigiCollectionSig_);
 
     HBHEDigiPToken_ = iC.consumes<HBHEDigiCollection>(HBHEPileInputTag_);
     HODigiPToken_ = iC.consumes<HODigiCollection>(HOPileInputTag_);
     HFDigiPToken_ = iC.consumes<HFDigiCollection>(HFPileInputTag_);
 
     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");
 
 
   }

DataMixingHcalDigiWorker::~DataMixingHcalDigiWorker ( )

virtual

Default destructor

Definition at line 187 of file DataMixingHcalDigiWorker.cc.

187 {

188 }

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 253 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, 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_);
 
 
     // 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 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
     }
       }
     }
 
 
   }

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

Definition at line 190 of file DataMixingHcalDigiWorker.cc.

References HcalCoderDb::adc2fC(), edm::SortedCollection< T, SORT >::begin(), DoZDC_, alignCSCRings::e, edm::SortedCollection< T, SORT >::end(), edm::EventSetup::get(), HBHEDigiStorage_, HBHEDigiToken_, HFDigiStorage_, HFDigiToken_, HODigiStorage_, HODigiToken_, edm::EventBase::id(), LogDebug, edm::Handle< T >::product(), 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_);
 
 
 
    // 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 310 of file DataMixingHcalDigiWorker.cc.

References HcalCoderDb::fC2adc(), edm::EventSetup::get(), HBHEDigiCollectionDM_, HBHEDigiStorage_, HFDigiCollectionDM_, HFDigiStorage_, HODigiCollectionDM_, HODigiStorage_, CaloSamples::id(), bookConverter::max, edm::Event::put(), 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::auto_ptr< HBHEDigiCollection > HBHEdigis = buildHcalDigis<HBHEDigiCollection> (HBHEDigiStorage_, *conditions);
     std::auto_ptr< HODigiCollection > HOdigis = buildHcalDigis<HODigiCollection> (HODigiStorage_, *conditions);
     std::auto_ptr< HFDigiCollection > HFdigis = buildHcalDigis<HFDigiCollection> (HFDigiStorage_, *conditions);
     std::auto_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 # ZDC Merged digis: " << ZDCdigis->size() ;
 
 
     // make empty collections for now:
     std::auto_ptr<HBHEUpgradeDigiCollection> hbheupgradeResult(new HBHEUpgradeDigiCollection());
     std::auto_ptr<HFUpgradeDigiCollection> hfupgradeResult(new HFUpgradeDigiCollection());
 
 
     e.put( HBHEdigis, HBHEDigiCollectionDM_ );
     e.put( HOdigis, HODigiCollectionDM_ );
     e.put( HFdigis, HFDigiCollectionDM_ );
     e.put( ZDCdigis, ZDCDigiCollectionDM_ );
     e.put( hbheupgradeResult, "HBHEUpgradeDigiCollection" );
     e.put( hfupgradeResult, "HFUpgradeDigiCollection" );
 
     // clear local storage after this event
     HBHEDigiStorage_.clear();
     HODigiStorage_.clear();
     HFDigiStorage_.clear();
     ZDCDigiStorage_.clear();
 
   }