#include <DataMixingEMWorker.h>

Public Member Functions
void	addEMPileups (const int bcr, const edm::EventPrincipal , unsigned int EventId, ModuleCallingContext const )

void	addEMSignals (const edm::Event &e)

	DataMixingEMWorker ()

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

void	putEM (edm::Event &e)

virtual	~DataMixingEMWorker ()

Private Types
typedef std::multimap< DetId, EcalRecHit >	EBRecHitMap

typedef std::multimap< DetId, EcalRecHit >	EERecHitMap

typedef std::multimap< DetId, EcalRecHit >	ESRecHitMap

Private Attributes
edm::InputTag	EBPileRecHitInputTag_

edm::EDGetTokenT< EBRecHitCollection >	EBPileRecHitToken_

edm::InputTag	EBProducerSig_

std::string	EBRecHitCollectionDM_

edm::InputTag	EBrechitCollectionSig_

EBRecHitMap	EBRecHitStorage_

edm::EDGetTokenT< EBRecHitCollection >	EBRecHitToken_

edm::InputTag	EEPileRecHitInputTag_

edm::EDGetTokenT< EERecHitCollection >	EEPileRecHitToken_

edm::InputTag	EEProducerSig_

std::string	EERecHitCollectionDM_

edm::InputTag	EErechitCollectionSig_

EERecHitMap	EERecHitStorage_

edm::EDGetTokenT< EERecHitCollection >	EERecHitToken_

edm::InputTag	ESPileRecHitInputTag_

edm::EDGetTokenT< ESRecHitCollection >	ESPileRecHitToken_

edm::InputTag	ESProducerSig_

std::string	ESRecHitCollectionDM_

edm::InputTag	ESrechitCollectionSig_

ESRecHitMap	ESRecHitStorage_

edm::EDGetTokenT< ESRecHitCollection >	ESRecHitToken_

std::string	label_

Detailed Description

Definition at line 39 of file DataMixingEMWorker.h.

Member Typedef Documentation

typedef std::multimap<DetId, EcalRecHit> edm::DataMixingEMWorker::EBRecHitMap

private

Definition at line 86 of file DataMixingEMWorker.h.

typedef std::multimap<DetId, EcalRecHit> edm::DataMixingEMWorker::EERecHitMap

private

Definition at line 87 of file DataMixingEMWorker.h.

typedef std::multimap<DetId, EcalRecHit> edm::DataMixingEMWorker::ESRecHitMap

private

Definition at line 88 of file DataMixingEMWorker.h.

Constructor & Destructor Documentation

DataMixingEMWorker::DataMixingEMWorker ( )

Definition at line 28 of file DataMixingEMWorker.cc.

28 { }

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

explicit

standard constructor

Definition at line 31 of file DataMixingEMWorker.cc.

References EBPileRecHitInputTag_, EBPileRecHitToken_, EBProducerSig_, EBRecHitCollectionDM_, EBrechitCollectionSig_, EBRecHitToken_, EEPileRecHitInputTag_, EEPileRecHitToken_, EEProducerSig_, EERecHitCollectionDM_, EErechitCollectionSig_, EERecHitToken_, ESPileRecHitInputTag_, ESPileRecHitToken_, ESProducerSig_, ESRecHitCollectionDM_, ESrechitCollectionSig_, ESRecHitToken_, edm::ParameterSet::getParameter(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                               : 
                                 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, retrieve
 
     EBProducerSig_ = ps.getParameter<edm::InputTag>("EBProducerSig");
     EEProducerSig_ = ps.getParameter<edm::InputTag>("EEProducerSig");
     ESProducerSig_ = ps.getParameter<edm::InputTag>("ESProducerSig");
 
     EBRecHitToken_ = iC.consumes<EBRecHitCollection>(EBProducerSig_);
     EERecHitToken_ = iC.consumes<EERecHitCollection>(EEProducerSig_);
     ESRecHitToken_ = iC.consumes<ESRecHitCollection>(ESProducerSig_);
 
 
     EBrechitCollectionSig_ = ps.getParameter<edm::InputTag>("EBrechitCollectionSig");
     EErechitCollectionSig_ = ps.getParameter<edm::InputTag>("EErechitCollectionSig");
     ESrechitCollectionSig_ = ps.getParameter<edm::InputTag>("ESrechitCollectionSig");
 
     EBPileRecHitInputTag_ = ps.getParameter<edm::InputTag>("EBPileRecHitInputTag");
     EEPileRecHitInputTag_ = ps.getParameter<edm::InputTag>("EEPileRecHitInputTag");
     ESPileRecHitInputTag_ = ps.getParameter<edm::InputTag>("ESPileRecHitInputTag");
 
     EBPileRecHitToken_ = iC.consumes<EBRecHitCollection>(EBPileRecHitInputTag_);
     EEPileRecHitToken_ = iC.consumes<EERecHitCollection>(EEPileRecHitInputTag_);
     ESPileRecHitToken_ = iC.consumes<ESRecHitCollection>(ESPileRecHitInputTag_);
 
 
     EBRecHitCollectionDM_        = ps.getParameter<std::string>("EBRecHitCollectionDM");
     EERecHitCollectionDM_        = ps.getParameter<std::string>("EERecHitCollectionDM");
     ESRecHitCollectionDM_        = ps.getParameter<std::string>("ESRecHitCollectionDM");
 
   }

DataMixingEMWorker::~DataMixingEMWorker ( )

virtual

Default destructor

Definition at line 71 of file DataMixingEMWorker.cc.

71 {

72 }

Member Function Documentation

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

Definition at line 168 of file DataMixingEMWorker.cc.

References edm::SortedCollection< T, SORT >::begin(), EBPileRecHitInputTag_, egHLT::errCodes::EBRecHits, EBRecHitStorage_, EEPileRecHitInputTag_, egHLT::errCodes::EERecHits, EERecHitStorage_, edm::SortedCollection< T, SORT >::end(), ESPileRecHitInputTag_, ESRecHitStorage_, edm::EventPrincipal::id(), LogDebug, and edm::SortedCollection< T, SORT >::size().

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

                                                                          {
   
     LogInfo("DataMixingEMWorker") <<"\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
 
     // EB first
 
     std::shared_ptr<Wrapper<EBRecHitCollection>  const> EBRecHitsPTR =
       getProductByTag<EBRecHitCollection>(*ep, EBPileRecHitInputTag_, mcc);
 
     if(EBRecHitsPTR ) {
 
       const EBRecHitCollection*  EBRecHits = const_cast< EBRecHitCollection * >(EBRecHitsPTR->product());
 
       LogDebug("DataMixingEMWorker") << "total # EB rechits: " << EBRecHits->size();
 
       // loop over digis, adding these to the existing maps                                         
       for(EBRecHitCollection::const_iterator it  = EBRecHits->begin();
       it != EBRecHits->end(); ++it) {
 
     EBRecHitStorage_.insert(EBRecHitMap::value_type( (it->id()), *it ));
 
 #ifdef DEBUG
     LogDebug("DataMixingEMWorker") << "processed EBRecHit with rawId: "
                        << it->id().rawId() << "\n"
                        << " rechit energy: " << it->energy();
 #endif
       }
     }
 
     // EE Next
 
     std::shared_ptr<Wrapper<EERecHitCollection>  const> EERecHitsPTR =
       getProductByTag<EERecHitCollection>(*ep, EEPileRecHitInputTag_, mcc);
 
     if(EERecHitsPTR ) {
 
       const EERecHitCollection*  EERecHits = const_cast< EERecHitCollection * >(EERecHitsPTR->product());
 
       LogDebug("DataMixingEMWorker") << "total # EE rechits: " << EERecHits->size();
 
       // loop over digis, adding these to the existing maps                                         
       for(EERecHitCollection::const_iterator it  = EERecHits->begin();
           it != EERecHits->end(); ++it) {
 
         EERecHitStorage_.insert(EERecHitMap::value_type( (it->id()), *it ));
 
 #ifdef DEBUG
         LogDebug("DataMixingEMWorker") << "processed EERecHit with rawId: "
                        << it->id().rawId() << "\n"
                        << " rechit energy: " << it->energy();
 #endif
       }
     }
 
     // ES Next
 
     std::shared_ptr<Wrapper<ESRecHitCollection>  const> ESRecHitsPTR =
       getProductByTag<ESRecHitCollection>(*ep, ESPileRecHitInputTag_, mcc);
 
     if(ESRecHitsPTR ) {
 
       const ESRecHitCollection*  ESRecHits = const_cast< ESRecHitCollection * >(ESRecHitsPTR->product());
 
       LogDebug("DataMixingEMWorker") << "total # ES rechits: " << ESRecHits->size();
 
       // loop over digis, adding these to the existing maps                                         
       for(ESRecHitCollection::const_iterator it  = ESRecHits->begin();
           it != ESRecHits->end(); ++it) {
 
         ESRecHitStorage_.insert(ESRecHitMap::value_type( (it->id()), *it ));
 
 #ifdef DEBUG
         LogDebug("DataMixingEMWorker") << "processed ESRecHit with rawId: "
                        << it->id().rawId() << "\n"
                        << " rechit energy: " << it->energy();
 #endif
       }
     }
 
 
   }

void DataMixingEMWorker::addEMSignals ( const edm::Event & e )

Definition at line 74 of file DataMixingEMWorker.cc.

References edm::SortedCollection< T, SORT >::begin(), egHLT::errCodes::EBRecHits, EBRecHitStorage_, EBRecHitToken_, egHLT::errCodes::EERecHits, EERecHitStorage_, EERecHitToken_, edm::SortedCollection< T, SORT >::end(), ESRecHitStorage_, ESRecHitToken_, edm::Event::getByToken(), edm::EventBase::id(), LogDebug, edm::Handle< T >::product(), and edm::SortedCollection< T, SORT >::size().

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

                                                          { 
     // fill in maps of hits
 
     LogInfo("DataMixingEMWorker")<<"===============> adding MC signals for "<<e.id();
 
     // EB first
 
    Handle< EBRecHitCollection > pEBRecHits;
 
    const EBRecHitCollection*  EBRecHits = nullptr;
 
    if(e.getByToken(EBRecHitToken_, pEBRecHits) ){
      EBRecHits = pEBRecHits.product(); // get a ptr to the product
      LogDebug("DataMixingEMWorker") << "total # EB rechits: " << EBRecHits->size();
    }
    
  
    if (EBRecHits)
      {
        // loop over rechits, storing them in a map so we can add pileup later
        for(EBRecHitCollection::const_iterator it  = EBRecHits->begin(); 
        it != EBRecHits->end(); ++it) {
 
      EBRecHitStorage_.insert(EBRecHitMap::value_type( ( it->id() ), *it ));
      
          LogDebug("DataMixingEMWorker") << "processed EBRecHit with rawId: "
                       << it->id().rawId() << "\n"
                       << " rechit energy: " << it->energy();
 
        }
      }
 
    // EE next
 
    Handle< EERecHitCollection > pEERecHits;
 
    const EERecHitCollection*  EERecHits = nullptr;
 
    
    if(e.getByToken(EERecHitToken_, pEERecHits) ){
      EERecHits = pEERecHits.product(); // get a ptr to the product
      LogDebug("DataMixingEMWorker") << "total # EE rechits: " << EERecHits->size();
    } 
    
  
    if (EERecHits)
      {
        // loop over rechits, storing them in a map so we can add pileup later
        for(EERecHitCollection::const_iterator it  = EERecHits->begin(); 
        it != EERecHits->end(); ++it) {
 
      EERecHitStorage_.insert(EERecHitMap::value_type( ( it->id() ), *it ));
 #ifdef DEBUG     
      LogDebug("DataMixingEMWorker") << "processed EERecHit with rawId: "
                       << it->id().rawId() << "\n"
                       << " rechit energy: " << it->energy();
 #endif
 
        }
      }
    // ES next
 
    Handle< ESRecHitCollection > pESRecHits;
 
    const ESRecHitCollection*  ESRecHits = nullptr;
 
    
    if(e.getByToken( ESRecHitToken_, pESRecHits) ){
      ESRecHits = pESRecHits.product(); // get a ptr to the product
 #ifdef DEBUG
      LogDebug("DataMixingEMWorker") << "total # ES rechits: " << ESRecHits->size();
 #endif
    } 
    
  
    if (ESRecHits)
      {
        // loop over rechits, storing them in a map so we can add pileup later
        for(ESRecHitCollection::const_iterator it  = ESRecHits->begin(); 
        it != ESRecHits->end(); ++it) {
 
      ESRecHitStorage_.insert(ESRecHitMap::value_type( ( it->id() ), *it ));
      
 #ifdef DEBUG     
          LogDebug("DataMixingEMWorker") << "processed ESRecHit with rawId: "
                       << it->id().rawId() << "\n"
                       << " rechit energy: " << it->energy();
 #endif
 
        }
      }
     
   } // end of addEMSignals

void DataMixingEMWorker::putEM ( edm::Event & e )

Definition at line 253 of file DataMixingEMWorker.cc.

References EBRecHitCollectionDM_, EBRecHitStorage_, EERecHitCollectionDM_, EERecHitStorage_, ESRecHitCollectionDM_, ESRecHitStorage_, eostools::move(), edm::Event::put(), and ntuplemaker::time.

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

                                             {
 
     // collection of rechits to put in the event
     std::unique_ptr< EBRecHitCollection > EBrechits( new EBRecHitCollection );
     std::unique_ptr< EERecHitCollection > EErechits( new EERecHitCollection );
     std::unique_ptr< ESRecHitCollection > ESrechits( new ESRecHitCollection );
 
     // loop over the maps we have, re-making individual hits or digis if necessary.
     DetId formerID = 0;
     DetId currentID;
     float ESum = 0.;
     float EBTime = 0.;
 
     // EB first...
 
     EBRecHitMap::const_iterator iEBchk;
 
     for(EBRecHitMap::const_iterator iEB  = EBRecHitStorage_.begin();
     iEB != EBRecHitStorage_.end(); ++iEB) {
 
       currentID = iEB->first; 
 
       if (currentID == formerID) { // we have to add these rechits together
 
     ESum+=(iEB->second).energy(); 
       }
       else {
       if(formerID>0) {
         // cutoff for ESum?
         EcalRecHit aHit(formerID, ESum, EBTime);
         EBrechits->push_back( aHit );
       }
       //save pointers for next iteration
       formerID = currentID;
       ESum = (iEB->second).energy();
       EBTime = (iEB->second).time();  // take time of first hit in sequence - is this ok?
       }
 
       iEBchk = iEB;
       if((++iEBchk) == EBRecHitStorage_.end()) {  //make sure not to lose the last one
     EcalRecHit aHit(formerID, ESum, EBTime);
     EBrechits->push_back( aHit );     
       }
     }
 
     // EE next...
 
     // loop over the maps we have, re-making individual hits or digis if necessary.
     formerID = 0;
     ESum = 0.;
     float EETime = 0.;
     
     EERecHitMap::const_iterator iEEchk;
 
     for(EERecHitMap::const_iterator iEE  = EERecHitStorage_.begin();
     iEE != EERecHitStorage_.end(); ++iEE) {
 
       currentID = iEE->first; 
 
       if (currentID == formerID) { // we have to add these rechits together
 
     ESum+=(iEE->second).energy(); 
       }
       else {
       if(formerID>0) {
         // cutoff for ESum?
         EcalRecHit aHit(formerID, ESum, EETime);
         EErechits->push_back( aHit );
       }
       //save pointers for next iteration
       formerID = currentID;
       ESum = (iEE->second).energy();
       EETime = (iEE->second).time();  // take time of first hit in sequence - is this ok?
       }
 
       iEEchk = iEE;
       if((++iEEchk) == EERecHitStorage_.end()) {  //make sure not to lose the last one
     EcalRecHit aHit(formerID, ESum, EETime);
     EErechits->push_back( aHit );     
       }
     }
 
     // ES next...
 
     // loop over the maps we have, re-making individual hits or digis if necessary.
     formerID = 0;
     ESum = 0.;
     float ESTime = 0.;
 
     ESRecHitMap::const_iterator iESchk;
 
     for(ESRecHitMap::const_iterator iES  = ESRecHitStorage_.begin();
     iES != ESRecHitStorage_.end(); ++iES) {
 
       currentID = iES->first; 
 
       if (currentID == formerID) { // we have to add these rechits together
 
     ESum+=(iES->second).energy(); 
       }
       else {
       if(formerID>0) {
         // cutoff for ESum?
         EcalRecHit aHit(formerID, ESum, ESTime);
         ESrechits->push_back( aHit );
       }
       //save pointers for next iteration
       formerID = currentID;
       ESum = (iES->second).energy();
       ESTime = (iES->second).time();  // take time of first hit in sequence - is this ok?
       }
 
       iESchk = iES;
       if((++iESchk) == ESRecHitStorage_.end()) {  //make sure not to lose the last one
     EcalRecHit aHit(formerID, ESum, ESTime);
     ESrechits->push_back( aHit );     
       }
     }
 
     // done merging
 
     // put the collection of reconstructed hits in the event   
     LogInfo("DataMixingEMWorker") << "total # EB Merged rechits: " << EBrechits->size() ;
     LogInfo("DataMixingEMWorker") << "total # EE Merged rechits: " << EErechits->size() ;
     LogInfo("DataMixingEMWorker") << "total # ES Merged rechits: " << ESrechits->size() ;
 
     e.put(std::move(EBrechits), EBRecHitCollectionDM_ );
     e.put(std::move(EErechits), EERecHitCollectionDM_ );
     e.put(std::move(ESrechits), ESRecHitCollectionDM_ );
     
     // clear local storage after this event
 
     EBRecHitStorage_.clear();
     EERecHitStorage_.clear();
     ESRecHitStorage_.clear();
 
   }