---

edm::DataMixingEMWorker Class Reference

#include <SimGeneral/DataMixingModule/plugins/DataMixingEMWorker.h>

List of all members.

Public Member Functions
void	addEMPileups (const int bcr, edm::Event *, unsigned int EventId)
void	addEMSignals (const edm::Event &e)
	DataMixingEMWorker (const edm::ParameterSet &ps)
	standard constructor
	DataMixingEMWorker ()
void	putEM (edm::Event &e)
virtual	~DataMixingEMWorker ()
	Default destructor.
Private Types
typedef std::multimap< DetId, EcalRecHit >	EBRecHitMap
typedef std::multimap< DetId, EcalRecHit >	EERecHitMap
typedef std::multimap< DetId, EcalRecHit >	ESRecHitMap
Private Attributes
edm::InputTag	EBProducer_
edm::InputTag	EBrechitCollection_
std::string	EBRecHitCollectionDM_
EBRecHitMap	EBRecHitStorage_
edm::InputTag	EEProducer_
edm::InputTag	EErechitCollection_
std::string	EERecHitCollectionDM_
EERecHitMap	EERecHitStorage_
edm::InputTag	ESProducer_
edm::InputTag	ESrechitCollection_
std::string	ESRecHitCollectionDM_
ESRecHitMap	ESRecHitStorage_
std::string	label_
Selector *	sel_

---

Detailed Description

Definition at line 36 of file DataMixingEMWorker.h.

---

Member Typedef Documentation

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

Definition at line 67 of file DataMixingEMWorker.h.

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

Definition at line 68 of file DataMixingEMWorker.h.

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

Definition at line 69 of file DataMixingEMWorker.h.

---

Constructor & Destructor Documentation

DataMixingEMWorker::DataMixingEMWorker

(

)

Definition at line 27 of file DataMixingEMWorker.cc.

{ sel_=0;}

DataMixingEMWorker::DataMixingEMWorker

(

const edm::ParameterSet &

ps

)

[explicit]

standard constructor

Definition at line 30 of file DataMixingEMWorker.cc.

References EBProducer_, EBrechitCollection_, EBRecHitCollectionDM_, EEProducer_, EErechitCollection_, EERecHitCollectionDM_, ESProducer_, ESrechitCollection_, ESRecHitCollectionDM_, edm::ParameterSet::getParameter(), label_, and sel_.

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

    // create input selector
    if (label_.size()>0){
      sel_=new Selector( ModuleLabelSelector(label_));
    }
    else {
      sel_=new Selector( MatchAllSelector());
    }

    // declare the products to produce, retrieve

    EBProducer_ = ps.getParameter<edm::InputTag>("EBProducer");
    EEProducer_ = ps.getParameter<edm::InputTag>("EEProducer");
    ESProducer_ = ps.getParameter<edm::InputTag>("ESProducer");
    EBrechitCollection_ = ps.getParameter<edm::InputTag>("EBrechitCollection");
    EErechitCollection_ = ps.getParameter<edm::InputTag>("EErechitCollection");
    ESrechitCollection_ = ps.getParameter<edm::InputTag>("ESrechitCollection");
    EBRecHitCollectionDM_        = ps.getParameter<std::string>("EBRecHitCollectionDM");
    EERecHitCollectionDM_        = ps.getParameter<std::string>("EERecHitCollectionDM");
    ESRecHitCollectionDM_        = ps.getParameter<std::string>("ESRecHitCollectionDM");
   //   nMaxPrintout_            = ps.getUntrackedParameter<int>("nMaxPrintout",10);

   //EBalgo_ = new EcalRecHitSimpleAlgo();
   //EEalgo_ = new EcalRecHitSimpleAlgo();

   // don't think I can "produce" in a sub-class...

   //produces< EBRecHitCollection >(EBRecHitCollectionDM_);
   //produces< EERecHitCollection >(EERecHitCollectionDM_);

  }

DataMixingEMWorker::~DataMixingEMWorker

(

)

[virtual]

Default destructor.

Definition at line 71 of file DataMixingEMWorker.cc.

                                          { 
    delete sel_;
    sel_=0;
  }  

---

Member Function Documentation

void DataMixingEMWorker::addEMPileups	(	const int	bcr,
		edm::Event *	e,
		unsigned int	EventId
	)

Definition at line 170 of file DataMixingEMWorker.cc.

References edm::SortedCollection< T, SORT >::begin(), edm::SortedCollection< T, SORT >::end(), edm::Event::getByLabel(), edm::Event::id(), it, LogDebug, edm::Handle< T >::product(), and edm::SortedCollection< T, SORT >::size().

                                                                                     {
  
    LogInfo("DataMixingEMWorker") <<"\n===============> adding pileups from event  "<<e->id()<<" for bunchcrossing "<<bcr;

    // fill in maps of hits; same code as addSignals, except now applied to the pileup events

    // EB first

   Handle< EBRecHitCollection > pEBRecHits;
   const EBRecHitCollection*  EBRecHits = 0;

  
   if( e->getByLabel(EBProducer_.label(),EBrechitCollection_.label(), pEBRecHits) ){
     EBRecHits = pEBRecHits.product(); // get a ptr to the product
#ifdef DEBUG
     LogDebug("DataMixingEMWorker") << "total # EB rechits: " << EBRecHits->size();
#endif
   } 
   
 
   if (EBRecHits)
     {
       // loop over rechits, 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

   Handle< EERecHitCollection > pEERecHits;
   const EERecHitCollection*  EERecHits = 0;

   
   if( e->getByLabel( EEProducer_.label(),EErechitCollection_.label(), pEERecHits) ){
     EERecHits = pEERecHits.product(); // get a ptr to the product
#ifdef DEBUG
     LogDebug("DataMixingEMWorker") << "total # EE rechits: " << EERecHits->size();
#endif
   }
   
 
   if (EERecHits)
     {
       // loop over rechits, 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

   Handle< ESRecHitCollection > pESRecHits;
   const ESRecHitCollection*  ESRecHits = 0;

   
   if( e->getByLabel( ESProducer_.label(),ESrechitCollection_.label(), 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, 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 76 of file DataMixingEMWorker.cc.

References edm::SortedCollection< T, SORT >::begin(), edm::SortedCollection< T, SORT >::end(), edm::Event::getByLabel(), edm::Event::id(), it, LogDebug, edm::Handle< T >::product(), and edm::SortedCollection< T, SORT >::size().

                                                         { 
    // fill in maps of hits

    LogInfo("DataMixingEMWorker")<<"===============> adding MC signals for "<<e.id();

    // EB first

   Handle< EBRecHitCollection > pEBRecHits;

   const EBRecHitCollection*  EBRecHits = 0;

   if(e.getByLabel(EBProducer_.label(),EBrechitCollection_.label(), 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 = 0;

   
   if(e.getByLabel(EEProducer_.label(),EErechitCollection_.label(), 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 = 0;

   
   if(e.getByLabel( ESProducer_.label(),ESrechitCollection_.label(), 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 266 of file DataMixingEMWorker.cc.

References relval_parameters_module::energy, and edm::Event::put().

                                            {

    // collection of rechits to put in the event
    std::auto_ptr< EBRecHitCollection > EBrechits( new EBRecHitCollection );
    std::auto_ptr< EERecHitCollection > EErechits( new EERecHitCollection );
    std::auto_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.;
    EcalRecHit OldHit;
    int nmatch=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
        nmatch++;                  // use this to avoid using the "count" function
        ESum+=(iEB->second).energy();          // on every element...

        iEBchk = iEB;
        if((iEBchk++) == EBRecHitStorage_.end()) {  //make sure not to lose the last one
          EcalRecHit aHit(formerID, ESum, EBTime);
          EBrechits->push_back( aHit );   
          // reset energy sum, nmatch
          ESum = 0 ;
          nmatch=0;       
        }
      }
      else {
        if(nmatch>0) {
          EcalRecHit aHit(formerID, ESum, EBTime);
          EBrechits->push_back( aHit );   
          // reset energy sum, nmatch
          ESum = 0 ;
          nmatch=0;       
        }
        else {
          if(formerID>0) EBrechits->push_back( OldHit );
        }
        
        iEBchk = iEB;
        if((iEBchk++) == EBRecHitStorage_.end()) {  //make sure not to lose the last one
          EBrechits->push_back( iEB->second );
        }

        // save pointers for next iteration
        OldHit = iEB->second;
        formerID = currentID;
        ESum = (iEB->second).energy();
        EBTime = (iEB->second).time();  // take time of first hit in sequence - is this ok?
      }
    }

    // EE next...

    // loop over the maps we have, re-making individual hits or digis if necessary.
    formerID = 0;
    ESum = 0.;
    float EETime = 0.;
    
    nmatch=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
        nmatch++;                  // use this to avoid using the "count" function
        ESum+=(iEE->second).energy();          // on every element...

        iEEchk = iEE;
        if((iEEchk++) == EERecHitStorage_.end()) {  //make sure not to lose the last one
          EcalRecHit aHit(formerID, ESum, EETime);
          EErechits->push_back( aHit );   
          // reset energy sum, nmatch
          ESum = 0 ;
          nmatch=0;       
        }
      }
      else {
        if(nmatch>0) {
          EcalRecHit aHit(formerID, ESum, EETime);
          EErechits->push_back( aHit );   
          // reset energy sum, nmatch
          ESum = 0 ;
          nmatch=0;       
        }
        else {
          if(formerID>0) EErechits->push_back( OldHit );
        }
        
        iEEchk = iEE;
        if((iEEchk++) == EERecHitStorage_.end()) {  //make sure not to lose the last one
          EErechits->push_back( iEE->second );
        }

        // save pointers for next iteration
        OldHit = iEE->second;
        formerID = currentID;
        ESum = (iEE->second).energy();
        EETime = (iEE->second).time();  // take time of first hit in sequence - is this ok?
      }
    }

    // ES next...

    // loop over the maps we have, re-making individual hits or digis if necessary.
    formerID = 0;
    ESum = 0.;
    float ESTime = 0.;
    nmatch=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
        nmatch++;                  // use this to avoid using the "count" function
        ESum+=(iES->second).energy();          // on every element...

        iESchk = iES;
        if((iESchk++) == ESRecHitStorage_.end()) {  //make sure not to lose the last one
          EcalRecHit aHit(formerID, ESum, ESTime);
          ESrechits->push_back( aHit );   
          // reset energy sum, nmatch
          ESum = 0 ;
          nmatch=0;       
        }
      }
      else {
        if(nmatch>0) {
          EcalRecHit aHit(formerID, ESum, ESTime);
          ESrechits->push_back( aHit );   
          // reset energy sum, nmatch
          ESum = 0 ;
          nmatch=0;       
        }
        else {
          if(formerID>0) ESrechits->push_back( OldHit );
        }
        
        iESchk = iES;
        if((iESchk++) == ESRecHitStorage_.end()) {  //make sure not to lose the last one
          ESrechits->push_back( iES->second );
        }

        // save pointers for next iteration
        OldHit = iES->second;
        formerID = currentID;
        ESum = (iES->second).energy();
        ESTime = (iES->second).time();  // take time of first hit in sequence - is this ok?
      }
    }

    // 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( EBrechits, EBRecHitCollectionDM_ );
    e.put( EErechits, EERecHitCollectionDM_ );
    e.put( ESrechits, ESRecHitCollectionDM_ );
    
    // clear local storage after this event

    EBRecHitStorage_.clear();
    EERecHitStorage_.clear();
    ESRecHitStorage_.clear();

  }

---

Member Data Documentation

edm::InputTag edm::DataMixingEMWorker::EBProducer_ [private]

Definition at line 56 of file DataMixingEMWorker.h.

Referenced by DataMixingEMWorker().

edm::InputTag edm::DataMixingEMWorker::EBrechitCollection_ [private]

Definition at line 60 of file DataMixingEMWorker.h.

Referenced by DataMixingEMWorker().

std::string edm::DataMixingEMWorker::EBRecHitCollectionDM_ [private]

Definition at line 63 of file DataMixingEMWorker.h.

Referenced by DataMixingEMWorker().

EBRecHitMap edm::DataMixingEMWorker::EBRecHitStorage_ [private]

Definition at line 71 of file DataMixingEMWorker.h.

edm::InputTag edm::DataMixingEMWorker::EEProducer_ [private]

Definition at line 57 of file DataMixingEMWorker.h.

Referenced by DataMixingEMWorker().

edm::InputTag edm::DataMixingEMWorker::EErechitCollection_ [private]

Definition at line 61 of file DataMixingEMWorker.h.

Referenced by DataMixingEMWorker().

std::string edm::DataMixingEMWorker::EERecHitCollectionDM_ [private]

Definition at line 64 of file DataMixingEMWorker.h.

Referenced by DataMixingEMWorker().

EERecHitMap edm::DataMixingEMWorker::EERecHitStorage_ [private]

Definition at line 72 of file DataMixingEMWorker.h.

edm::InputTag edm::DataMixingEMWorker::ESProducer_ [private]

Definition at line 58 of file DataMixingEMWorker.h.

Referenced by DataMixingEMWorker().

edm::InputTag edm::DataMixingEMWorker::ESrechitCollection_ [private]

Definition at line 62 of file DataMixingEMWorker.h.

Referenced by DataMixingEMWorker().

std::string edm::DataMixingEMWorker::ESRecHitCollectionDM_ [private]

Definition at line 65 of file DataMixingEMWorker.h.

Referenced by DataMixingEMWorker().

ESRecHitMap edm::DataMixingEMWorker::ESRecHitStorage_ [private]

Definition at line 73 of file DataMixingEMWorker.h.

std::string edm::DataMixingEMWorker::label_ [private]

Definition at line 79 of file DataMixingEMWorker.h.

Referenced by DataMixingEMWorker().

Selector* edm::DataMixingEMWorker::sel_ [private]

Definition at line 78 of file DataMixingEMWorker.h.

Referenced by DataMixingEMWorker().

---

The documentation for this class was generated from the following files:

• SimGeneral/DataMixingModule/plugins/DataMixingEMWorker.h
• SimGeneral/DataMixingModule/plugins/DataMixingEMWorker.cc

---