edm::DataMixingHcalWorker Class Reference

#include <DataMixingHcalWorker.h>

Public Member Functions
void	addHcalPileups (const int bcr, const edm::EventPrincipal *, unsigned int EventId, ModuleCallingContext const *)
void	addHcalSignals (const edm::Event &e)
	DataMixingHcalWorker ()
	DataMixingHcalWorker (const edm::ParameterSet &ps, edm::ConsumesCollector &&iC)
void	putHcal (edm::Event &e)
virtual	~DataMixingHcalWorker ()

Private Types
typedef std::multimap< DetId, HBHERecHit >	HBHERecHitMap
typedef std::multimap< DetId, HFRecHit >	HFRecHitMap
typedef std::multimap< DetId, HORecHit >	HORecHitMap
typedef std::multimap< DetId, ZDCRecHit >	ZDCRecHitMap

Private Attributes
edm::InputTag	HBHEPileRecHitInputTag_
std::string	HBHERecHitCollectionDM_
edm::InputTag	HBHErechitCollectionSig_
edm::EDGetTokenT< HBHERecHitCollection >	HBHERecHitPToken_
HBHERecHitMap	HBHERecHitStorage_
edm::EDGetTokenT< HBHERecHitCollection >	HBHERecHitToken_
edm::InputTag	HFPileRecHitInputTag_
std::string	HFRecHitCollectionDM_
edm::InputTag	HFrechitCollectionSig_
edm::EDGetTokenT< HFRecHitCollection >	HFRecHitPToken_
HFRecHitMap	HFRecHitStorage_
edm::EDGetTokenT< HFRecHitCollection >	HFRecHitToken_
edm::InputTag	HOPileRecHitInputTag_
std::string	HORecHitCollectionDM_
edm::InputTag	HOrechitCollectionSig_
edm::EDGetTokenT< HORecHitCollection >	HORecHitPToken_
HORecHitMap	HORecHitStorage_
edm::EDGetTokenT< HORecHitCollection >	HORecHitToken_
std::string	label_
edm::InputTag	ZDCPileRecHitInputTag_
std::string	ZDCRecHitCollectionDM_
edm::InputTag	ZDCrechitCollectionSig_
edm::EDGetTokenT< ZDCRecHitCollection >	ZDCRecHitPToken_
ZDCRecHitMap	ZDCRecHitStorage_
edm::EDGetTokenT< ZDCRecHitCollection >	ZDCRecHitToken_

Detailed Description

Definition at line 35 of file DataMixingHcalWorker.h.

Member Typedef Documentation

typedef std::multimap<DetId, HBHERecHit> edm::DataMixingHcalWorker::HBHERecHitMap

private

Definition at line 82 of file DataMixingHcalWorker.h.

typedef std::multimap<DetId, HFRecHit> edm::DataMixingHcalWorker::HFRecHitMap

private

Definition at line 83 of file DataMixingHcalWorker.h.

typedef std::multimap<DetId, HORecHit> edm::DataMixingHcalWorker::HORecHitMap

private

Definition at line 84 of file DataMixingHcalWorker.h.

typedef std::multimap<DetId, ZDCRecHit> edm::DataMixingHcalWorker::ZDCRecHitMap

private

Definition at line 85 of file DataMixingHcalWorker.h.

Constructor & Destructor Documentation

DataMixingHcalWorker::DataMixingHcalWorker

(

)

Definition at line 28 of file DataMixingHcalWorker.cc.

{ } 

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

explicit

standard constructor

Definition at line 31 of file DataMixingHcalWorker.cc.

References edm::ParameterSet::getParameter(), HBHEPileRecHitInputTag_, HBHERecHitCollectionDM_, HBHErechitCollectionSig_, HBHERecHitPToken_, HBHERecHitToken_, HFPileRecHitInputTag_, HFRecHitCollectionDM_, HFrechitCollectionSig_, HFRecHitPToken_, HFRecHitToken_, HOPileRecHitInputTag_, HORecHitCollectionDM_, HOrechitCollectionSig_, HORecHitPToken_, HORecHitToken_, AlCaHLTBitMon_QueryRunRegistry::string, ZDCPileRecHitInputTag_, ZDCRecHitCollectionDM_, ZDCrechitCollectionSig_, ZDCRecHitPToken_, and ZDCRecHitToken_.

                                                                                                  : 
                                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 

    HBHErechitCollectionSig_  = ps.getParameter<edm::InputTag>("HBHEProducerSig");
    HOrechitCollectionSig_    = ps.getParameter<edm::InputTag>("HOProducerSig");
    HFrechitCollectionSig_    = ps.getParameter<edm::InputTag>("HFProducerSig");
    ZDCrechitCollectionSig_   = ps.getParameter<edm::InputTag>("ZDCrechitCollectionSig");

    HBHEPileRecHitInputTag_ = ps.getParameter<edm::InputTag>("HBHEPileRecHitInputTag");
    HOPileRecHitInputTag_ = ps.getParameter<edm::InputTag>("HOPileRecHitInputTag");
    HFPileRecHitInputTag_ = ps.getParameter<edm::InputTag>("HFPileRecHitInputTag");
    ZDCPileRecHitInputTag_ = ps.getParameter<edm::InputTag>("ZDCPileRecHitInputTag");

    HBHERecHitCollectionDM_ = ps.getParameter<std::string>("HBHERecHitCollectionDM");
    HORecHitCollectionDM_   = ps.getParameter<std::string>("HORecHitCollectionDM");
    HFRecHitCollectionDM_   = ps.getParameter<std::string>("HFRecHitCollectionDM");
    ZDCRecHitCollectionDM_  = ps.getParameter<std::string>("ZDCRecHitCollectionDM");

    HBHERecHitToken_ = iC.consumes<HBHERecHitCollection>(HBHErechitCollectionSig_);
    HORecHitToken_ = iC.consumes<HORecHitCollection>(HOrechitCollectionSig_);
    HFRecHitToken_ = iC.consumes<HFRecHitCollection>(HFrechitCollectionSig_);

    HBHERecHitPToken_ = iC.consumes<HBHERecHitCollection>(HBHEPileRecHitInputTag_);
    HORecHitPToken_ = iC.consumes<HORecHitCollection>(HOPileRecHitInputTag_);
    HFRecHitPToken_ = iC.consumes<HFRecHitCollection>(HFPileRecHitInputTag_);


    ZDCRecHitToken_ = iC.consumes<ZDCRecHitCollection>(ZDCrechitCollectionSig_);
    ZDCRecHitPToken_ = iC.consumes<ZDCRecHitCollection>(ZDCPileRecHitInputTag_);

  }

DataMixingHcalWorker::~DataMixingHcalWorker ( )

virtual

Default destructor

Definition at line 73 of file DataMixingHcalWorker.cc.

                                              { 
  }  

Member Function Documentation

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

Definition at line 205 of file DataMixingHcalWorker.cc.

References edm::SortedCollection< T, SORT >::begin(), edm::SortedCollection< T, SORT >::end(), HBHEPileRecHitInputTag_, egHLT::errCodes::HBHERecHits, HBHERecHitStorage_, HFPileRecHitInputTag_, egHLT::errCodes::HFRecHits, HFRecHitStorage_, HOPileRecHitInputTag_, HORecHitStorage_, edm::EventPrincipal::id(), LogDebug, edm::SortedCollection< T, SORT >::size(), ZDCPileRecHitInputTag_, and ZDCRecHitStorage_.

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

                                                                             {
  
    LogDebug("DataMixingHcalWorker") <<"\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

    // HBHE first

    std::shared_ptr<Wrapper<HBHERecHitCollection>  const> HBHERecHitsPTR =
      getProductByTag<HBHERecHitCollection>(*ep, HBHEPileRecHitInputTag_, mcc);

    if(HBHERecHitsPTR ) {

      const HBHERecHitCollection*  HBHERecHits = const_cast< HBHERecHitCollection * >(HBHERecHitsPTR->product());

      LogDebug("DataMixingEMWorker") << "total # HBHE rechits: " << HBHERecHits->size();

      // loop over rechits, adding these to the existing maps                                                     
      for(HBHERecHitCollection::const_iterator it  = HBHERecHits->begin();
          it != HBHERecHits->end(); ++it) {

        HBHERecHitStorage_.insert(HBHERecHitMap::value_type( (it->id()), *it ));

#ifdef DEBUG
        LogDebug("DataMixingEMWorker") << "processed HBHERecHit with rawId: "
                       << it->id().rawId() << "\n"
                       << " rechit energy: " << it->energy();
#endif
      }
    }

    // HO Next

    std::shared_ptr<Wrapper<HORecHitCollection>  const> HORecHitsPTR =
      getProductByTag<HORecHitCollection>(*ep, HOPileRecHitInputTag_, mcc);

    if(HORecHitsPTR ) {

      const HORecHitCollection*  HORecHits = const_cast< HORecHitCollection * >(HORecHitsPTR->product());

      LogDebug("DataMixingEMWorker") << "total # HO rechits: " << HORecHits->size();

      // loop over rechits, adding these to the existing maps                                                     
      for(HORecHitCollection::const_iterator it  = HORecHits->begin();
          it != HORecHits->end(); ++it) {

        HORecHitStorage_.insert(HORecHitMap::value_type( (it->id()), *it ));

#ifdef DEBUG
        LogDebug("DataMixingEMWorker") << "processed HORecHit with rawId: "
                       << it->id().rawId() << "\n"
                       << " rechit energy: " << it->energy();
#endif
      }
    }

    // HF Next

    std::shared_ptr<Wrapper<HFRecHitCollection>  const> HFRecHitsPTR =
      getProductByTag<HFRecHitCollection>(*ep, HFPileRecHitInputTag_, mcc);

    if(HFRecHitsPTR ) {

      const HFRecHitCollection*  HFRecHits = const_cast< HFRecHitCollection * >(HFRecHitsPTR->product());

      LogDebug("DataMixingEMWorker") << "total # HF rechits: " << HFRecHits->size();

      // loop over rechits, adding these to the existing maps                                                     
      for(HFRecHitCollection::const_iterator it  = HFRecHits->begin();
          it != HFRecHits->end(); ++it) {

        HFRecHitStorage_.insert(HFRecHitMap::value_type( (it->id()), *it ));

#ifdef DEBUG
        LogDebug("DataMixingEMWorker") << "processed HFRecHit with rawId: "
                       << it->id().rawId() << "\n"
                       << " rechit energy: " << it->energy();
#endif
      }
    }

    // ZDC Next

    std::shared_ptr<Wrapper<ZDCRecHitCollection>  const> ZDCRecHitsPTR =
      getProductByTag<ZDCRecHitCollection>(*ep, ZDCPileRecHitInputTag_, mcc);

    if(ZDCRecHitsPTR ) {

      const ZDCRecHitCollection*  ZDCRecHits = const_cast< ZDCRecHitCollection * >(ZDCRecHitsPTR->product());

      LogDebug("DataMixingEMWorker") << "total # ZDC rechits: " << ZDCRecHits->size();

      // loop over rechits, adding these to the existing maps                                                     
      for(ZDCRecHitCollection::const_iterator it  = ZDCRecHits->begin();
          it != ZDCRecHits->end(); ++it) {

        ZDCRecHitStorage_.insert(ZDCRecHitMap::value_type( (it->id()), *it ));

#ifdef DEBUG
        LogDebug("DataMixingEMWorker") << "processed ZDCRecHit with rawId: "
                       << it->id().rawId() << "\n"
                       << " rechit energy: " << it->energy();
#endif
      }
    }


  }

void DataMixingHcalWorker::addHcalSignals

(

const edm::Event &

e

)

Definition at line 76 of file DataMixingHcalWorker.cc.

References edm::SortedCollection< T, SORT >::begin(), edm::SortedCollection< T, SORT >::end(), edm::Event::getByToken(), egHLT::errCodes::HBHERecHits, HBHERecHitStorage_, HBHERecHitToken_, egHLT::errCodes::HFRecHits, HFRecHitStorage_, HFRecHitToken_, HORecHitStorage_, HORecHitToken_, edm::EventBase::id(), LogDebug, edm::Handle< T >::product(), edm::SortedCollection< T, SORT >::size(), ZDCRecHitStorage_, and ZDCRecHitToken_.

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

                                                             { 
    // fill in maps of hits

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

    // HBHE first

   Handle< HBHERecHitCollection > pHBHERecHits;

   const HBHERecHitCollection*  HBHERecHits = nullptr;

   if( e.getByToken( HBHERecHitToken_, pHBHERecHits) ) {
     HBHERecHits = pHBHERecHits.product(); // get a ptr to the product
     LogDebug("DataMixingHcalWorker") << "total # HBHE rechits: " << HBHERecHits->size();
   } 
   
 
   if (HBHERecHits)
     {
       // loop over rechits, storing them in a map so we can add pileup later
       for(HBHERecHitCollection::const_iterator it  = HBHERecHits->begin(); 
       it != HBHERecHits->end(); ++it) {

     HBHERecHitStorage_.insert(HBHERecHitMap::value_type( ( it->id() ), *it ));
     
#ifdef DEBUG     
         LogDebug("DataMixingHcalWorker") << "processed HBHERecHit with rawId: "
                      << it->id() << "\n"
                      << " rechit energy: " << it->energy();
#endif

       }
     }

   // HO next

   Handle< HORecHitCollection > pHORecHits;

   const HORecHitCollection*  HORecHits = nullptr;

   if( e.getByToken( HORecHitToken_, pHORecHits) ){
     HORecHits = pHORecHits.product(); // get a ptr to the product
#ifdef DEBUG
     LogDebug("DataMixingHcalWorker") << "total # HO rechits: " << HORecHits->size();
#endif
   } 
   
 
   if (HORecHits)
     {
       // loop over rechits, storing them in a map so we can add pileup later
       for(HORecHitCollection::const_iterator it  = HORecHits->begin(); 
       it != HORecHits->end(); ++it) {

     HORecHitStorage_.insert(HORecHitMap::value_type( ( it->id() ), *it ));
     
#ifdef DEBUG     
         LogDebug("DataMixingHcalWorker") << "processed HORecHit with rawId: "
                      << it->id() << "\n"
                      << " rechit energy: " << it->energy();
#endif

       }
     }

   // HF next

   Handle< HFRecHitCollection > pHFRecHits;

   const HFRecHitCollection*  HFRecHits = nullptr;

   if( e.getByToken( HFRecHitToken_, pHFRecHits) ) {
     HFRecHits = pHFRecHits.product(); // get a ptr to the product
#ifdef DEBUG
     LogDebug("DataMixingHcalWorker") << "total # HF rechits: " << HFRecHits->size();
#endif
   } 
   
 
   if (HFRecHits)
     {
       // loop over rechits, storing them in a map so we can add pileup later
       for(HFRecHitCollection::const_iterator it  = HFRecHits->begin(); 
       it != HFRecHits->end(); ++it) {

     HFRecHitStorage_.insert(HFRecHitMap::value_type( ( it->id() ), *it ));
     
#ifdef DEBUG     
         LogDebug("DataMixingHcalWorker") << "processed HFRecHit with rawId: "
                      << it->id() << "\n"
                      << " rechit energy: " << it->energy();
#endif

       }
     }

   // ZDC next

   Handle< ZDCRecHitCollection > pZDCRecHits;

   const ZDCRecHitCollection*  ZDCRecHits = nullptr;

   if( e.getByToken( ZDCRecHitToken_, pZDCRecHits) ) {
     ZDCRecHits = pZDCRecHits.product(); // get a ptr to the product
#ifdef DEBUG
     LogDebug("DataMixingHcalWorker") << "total # ZDC rechits: " << ZDCRecHits->size();
#endif
   } 
   
 
   if (ZDCRecHits)
     {
       // loop over rechits, storing them in a map so we can add pileup later
       for(ZDCRecHitCollection::const_iterator it  = ZDCRecHits->begin();   
       it != ZDCRecHits->end(); ++it) {

     ZDCRecHitStorage_.insert(ZDCRecHitMap::value_type( ( it->id() ), *it ));
     
#ifdef DEBUG     
         LogDebug("DataMixingHcalWorker") << "processed ZDCRecHit with rawId: "
                      << it->id() << "\n"
                      << " rechit energy: " << it->energy();
#endif

       }
     }
    
  } // end of addEMSignals

void DataMixingHcalWorker::putHcal

(

edm::Event &

e

)

Definition at line 315 of file DataMixingHcalWorker.cc.

References HBHERecHitCollectionDM_, HBHERecHitStorage_, HFRecHitCollectionDM_, HFRecHitStorage_, HORecHitCollectionDM_, HORecHitStorage_, eostools::move(), edm::Event::put(), ntuplemaker::time, ZDCRecHitCollectionDM_, and ZDCRecHitStorage_.

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

                                                {

    // collection of rechits to put in the event
    std::unique_ptr< HBHERecHitCollection > HBHErechits( new HBHERecHitCollection );
    std::unique_ptr< HORecHitCollection > HOrechits( new HORecHitCollection );
    std::unique_ptr< HFRecHitCollection > HFrechits( new HFRecHitCollection );
    std::unique_ptr< ZDCRecHitCollection > ZDCrechits( new ZDCRecHitCollection );

    // loop over the maps we have, re-making individual hits or rechits if necessary.
    DetId formerID = 0;
    DetId currentID;
    float ESum = 0.;
    float HBTime = 0.;

    // HB first...

    HBHERecHitMap::const_iterator iHBchk;

    for(HBHERecHitMap::const_iterator iHB  = HBHERecHitStorage_.begin();
    iHB != HBHERecHitStorage_.end(); ++iHB) {

      currentID = iHB->first; 

      if (currentID == formerID) { // we have to add these rechits together

    ESum+=(iHB->second).energy();  

      }
      else {
    if(formerID>0) {
      // cutoff for ESum?                                                                                 
      HBHERecHit aHit(formerID, ESum, HBTime);
      HBHErechits->push_back( aHit );
    }
    //save pointers for next iteration                                                                    
    formerID = currentID;
    ESum = (iHB->second).energy();
    HBTime = (iHB->second).time();  // take time of first hit in sequence - is this ok?
      }

      iHBchk = iHB;
      if((++iHBchk) == HBHERecHitStorage_.end()) {  //make sure not to lose the last one  
        HBHERecHit aHit(formerID, ESum, HBTime);
        HBHErechits->push_back( aHit );
      }
    }

    // HO next...

    // loop over the maps we have, re-making individual hits or rechits if necessary.
    formerID = 0;
    ESum = 0.;
    float HOTime = 0.;

    HORecHitMap::const_iterator iHOchk;

    for(HORecHitMap::const_iterator iHO  = HORecHitStorage_.begin();
    iHO != HORecHitStorage_.end(); ++iHO) {

      currentID = iHO->first; 

      if (currentID == formerID) { // we have to add these rechits together

    ESum+=(iHO->second).energy();  

      }
      else {
    if(formerID>0) {
      // cutoff for ESum?                                                                                 
      HORecHit aHit(formerID, ESum, HOTime);
      HOrechits->push_back( aHit );
    }
    //save pointers for next iteration                                                                    
    formerID = currentID;
    ESum = (iHO->second).energy();
    HOTime = (iHO->second).time();  // take time of first hit in sequence - is this ok?
      }

      iHOchk = iHO;
      if((++iHOchk) == HORecHitStorage_.end()) {  //make sure not to lose the last one  
        HORecHit aHit(formerID, ESum, HOTime);
        HOrechits->push_back( aHit );
      }
    }


    // HF next...

    // loop over the maps we have, re-making individual hits or rechits if necessary.
    formerID = 0;
    ESum = 0.;
    float HFTime = 0.;
    HFRecHit HFOldHit;

    HFRecHitMap::const_iterator iHFchk;

    for(HFRecHitMap::const_iterator iHF  = HFRecHitStorage_.begin();
    iHF != HFRecHitStorage_.end(); ++iHF) {

      currentID = iHF->first; 

      if (currentID == formerID) { // we have to add these rechits together

    ESum+=(iHF->second).energy();  

      }
      else {
    if(formerID>0) {
      // cutoff for ESum?                                                                                 
      HFRecHit aHit(formerID, ESum, HFTime);
      HFrechits->push_back( aHit );
    }
    //save pointers for next iteration                                                                    
    formerID = currentID;
    ESum = (iHF->second).energy();
    HFTime = (iHF->second).time();  // take time of first hit in sequence - is this ok?
      }

      iHFchk = iHF;
      if((++iHFchk) == HFRecHitStorage_.end()) {  //make sure not to lose the last one  
        HFRecHit aHit(formerID, ESum, HBTime);
        HFrechits->push_back( aHit );
      }
    }

    // ZDC next...

    // loop over the maps we have, re-making individual hits or rechits if necessary.
    formerID = 0;
    ESum = 0.;
    float ZDCTime = 0.;
    float lowGainEnergy = 0;
    ZDCRecHit ZOldHit;

    ZDCRecHitMap::const_iterator iZDCchk;

    for(ZDCRecHitMap::const_iterator iZDC  = ZDCRecHitStorage_.begin();
    iZDC != ZDCRecHitStorage_.end(); ++iZDC) {

      currentID = iZDC->first; 

      if (currentID == formerID) { // we have to add these rechits together

    ESum+=(iZDC->second).energy();  
    
      }
      else {
    if(formerID>0) {
      // cutoff for ESum?                                                                                 
      ZDCRecHit aHit(formerID, ESum, ZDCTime, lowGainEnergy);
      ZDCrechits->push_back( aHit );
    }
    //save pointers for next iteration                                                                    
    formerID = currentID;
    ESum = (iZDC->second).energy();
    lowGainEnergy = (iZDC->second).lowGainEnergy();
    ZDCTime = (iZDC->second).time();  // take time of first hit in sequence - is this ok?
      }
      
      iZDCchk = iZDC;
      if((++iZDCchk) == ZDCRecHitStorage_.end()) {  //make sure not to lose the last one  
    ZDCRecHit aHit(formerID, ESum, HBTime, lowGainEnergy);
    ZDCrechits->push_back( aHit );
      }
    } 
  
   //done merging

    // put the collection of recunstructed hits in the event   
    LogInfo("DataMixingHcalWorker") << "total # HBHE Merged rechits: " << HBHErechits->size() ;
    LogInfo("DataMixingHcalWorker") << "total # HO Merged rechits: " << HOrechits->size() ;
    LogInfo("DataMixingHcalWorker") << "total # HF Merged rechits: " << HFrechits->size() ;
    LogInfo("DataMixingHcalWorker") << "total # ZDC Merged rechits: " << ZDCrechits->size() ;

    e.put(std::move(HBHErechits), HBHERecHitCollectionDM_ );
    e.put(std::move(HOrechits), HORecHitCollectionDM_ );
    e.put(std::move(HFrechits), HFRecHitCollectionDM_ );
    e.put(std::move(ZDCrechits), ZDCRecHitCollectionDM_ );

    // clear local storage after this event
    HBHERecHitStorage_.clear();
    HORecHitStorage_.clear();
    HFRecHitStorage_.clear();
    ZDCRecHitStorage_.clear();

  }

Member Data Documentation

edm::InputTag edm::DataMixingHcalWorker::HBHEPileRecHitInputTag_

private

Definition at line 62 of file DataMixingHcalWorker.h.

Referenced by addHcalPileups(), and DataMixingHcalWorker().

std::string edm::DataMixingHcalWorker::HBHERecHitCollectionDM_

private

Definition at line 77 of file DataMixingHcalWorker.h.

Referenced by DataMixingHcalWorker(), and putHcal().

edm::InputTag edm::DataMixingHcalWorker::HBHErechitCollectionSig_

private

Definition at line 57 of file DataMixingHcalWorker.h.

Referenced by DataMixingHcalWorker().

edm::EDGetTokenT<HBHERecHitCollection> edm::DataMixingHcalWorker::HBHERecHitPToken_

private

Definition at line 72 of file DataMixingHcalWorker.h.

Referenced by DataMixingHcalWorker().

HBHERecHitMap edm::DataMixingHcalWorker::HBHERecHitStorage_

private

Definition at line 87 of file DataMixingHcalWorker.h.

Referenced by addHcalPileups(), addHcalSignals(), and putHcal().

edm::EDGetTokenT<HBHERecHitCollection> edm::DataMixingHcalWorker::HBHERecHitToken_

private

Definition at line 67 of file DataMixingHcalWorker.h.

Referenced by addHcalSignals(), and DataMixingHcalWorker().

edm::InputTag edm::DataMixingHcalWorker::HFPileRecHitInputTag_

private

Definition at line 64 of file DataMixingHcalWorker.h.

Referenced by addHcalPileups(), and DataMixingHcalWorker().

std::string edm::DataMixingHcalWorker::HFRecHitCollectionDM_

private

Definition at line 79 of file DataMixingHcalWorker.h.

Referenced by DataMixingHcalWorker(), and putHcal().

edm::InputTag edm::DataMixingHcalWorker::HFrechitCollectionSig_

private

Definition at line 59 of file DataMixingHcalWorker.h.

Referenced by DataMixingHcalWorker().

edm::EDGetTokenT<HFRecHitCollection> edm::DataMixingHcalWorker::HFRecHitPToken_

private

Definition at line 74 of file DataMixingHcalWorker.h.

Referenced by DataMixingHcalWorker().

HFRecHitMap edm::DataMixingHcalWorker::HFRecHitStorage_

private

Definition at line 88 of file DataMixingHcalWorker.h.

Referenced by addHcalPileups(), addHcalSignals(), and putHcal().

edm::EDGetTokenT<HFRecHitCollection> edm::DataMixingHcalWorker::HFRecHitToken_

private

Definition at line 69 of file DataMixingHcalWorker.h.

Referenced by addHcalSignals(), and DataMixingHcalWorker().

edm::InputTag edm::DataMixingHcalWorker::HOPileRecHitInputTag_

private

Definition at line 63 of file DataMixingHcalWorker.h.

Referenced by addHcalPileups(), and DataMixingHcalWorker().

std::string edm::DataMixingHcalWorker::HORecHitCollectionDM_

private

Definition at line 78 of file DataMixingHcalWorker.h.

Referenced by DataMixingHcalWorker(), and putHcal().

edm::InputTag edm::DataMixingHcalWorker::HOrechitCollectionSig_

private

Definition at line 58 of file DataMixingHcalWorker.h.

Referenced by DataMixingHcalWorker().

edm::EDGetTokenT<HORecHitCollection> edm::DataMixingHcalWorker::HORecHitPToken_

private

Definition at line 73 of file DataMixingHcalWorker.h.

Referenced by DataMixingHcalWorker().

HORecHitMap edm::DataMixingHcalWorker::HORecHitStorage_

private

Definition at line 89 of file DataMixingHcalWorker.h.

Referenced by addHcalPileups(), addHcalSignals(), and putHcal().

edm::EDGetTokenT<HORecHitCollection> edm::DataMixingHcalWorker::HORecHitToken_

private

Definition at line 68 of file DataMixingHcalWorker.h.

Referenced by addHcalSignals(), and DataMixingHcalWorker().

std::string edm::DataMixingHcalWorker::label_

private

Definition at line 95 of file DataMixingHcalWorker.h.

Referenced by SequenceTypes.DummyModule::__repr__(), Mixins._Labelable::_findDependencies(), and Mixins._Labelable::setLabel().

edm::InputTag edm::DataMixingHcalWorker::ZDCPileRecHitInputTag_

private

Definition at line 65 of file DataMixingHcalWorker.h.

Referenced by addHcalPileups(), and DataMixingHcalWorker().

std::string edm::DataMixingHcalWorker::ZDCRecHitCollectionDM_

private

Definition at line 80 of file DataMixingHcalWorker.h.

Referenced by DataMixingHcalWorker(), and putHcal().

edm::InputTag edm::DataMixingHcalWorker::ZDCrechitCollectionSig_

private

Definition at line 60 of file DataMixingHcalWorker.h.

Referenced by DataMixingHcalWorker().

edm::EDGetTokenT<ZDCRecHitCollection> edm::DataMixingHcalWorker::ZDCRecHitPToken_

private

Definition at line 75 of file DataMixingHcalWorker.h.

Referenced by DataMixingHcalWorker().

ZDCRecHitMap edm::DataMixingHcalWorker::ZDCRecHitStorage_

private

Definition at line 90 of file DataMixingHcalWorker.h.

Referenced by addHcalPileups(), addHcalSignals(), and putHcal().

edm::EDGetTokenT<ZDCRecHitCollection> edm::DataMixingHcalWorker::ZDCRecHitToken_

private

Definition at line 70 of file DataMixingHcalWorker.h.

Referenced by addHcalSignals(), and DataMixingHcalWorker().