#include <DataMixingMuonWorker.h>

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

void	addMuonSignals (const edm::Event &e)

	DataMixingMuonWorker ()

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

void	putMuon (edm::Event &e)

virtual	~DataMixingMuonWorker ()

Private Attributes
std::string	CSCComparatorDigiCollectionDM_

edm::InputTag	CSCCompdigi_collectionSig_

edm::EDGetTokenT < CSCComparatorDigiCollection >	CSCCompDigiPToken_

edm::EDGetTokenT < CSCComparatorDigiCollection >	CSCCompDigiToken_

edm::InputTag	CSCCompPileInputTag_

edm::InputTag	CSCDigiTagSig_

edm::InputTag	CSCstripdigi_collectionSig_

std::string	CSCStripDigiCollectionDM_

edm::EDGetTokenT < CSCStripDigiCollection >	CSCStripDigiPToken_

edm::EDGetTokenT < CSCStripDigiCollection >	CSCStripDigiToken_

edm::InputTag	CSCStripPileInputTag_

edm::InputTag	CSCwiredigi_collectionSig_

std::string	CSCWireDigiCollectionDM_

edm::EDGetTokenT < CSCWireDigiCollection >	CSCWireDigiPToken_

edm::EDGetTokenT < CSCWireDigiCollection >	CSCWireDigiToken_

edm::InputTag	CSCWirePileInputTag_

edm::InputTag	DTdigi_collectionSig_

std::string	DTDigiCollectionDM_

edm::EDGetTokenT < DTDigiCollection >	DTDigiPToken_

edm::InputTag	DTDigiTagSig_

edm::EDGetTokenT < DTDigiCollection >	DTDigiToken_

edm::InputTag	DTPileInputTag_

std::string	label_

CSCComparatorDigiCollection *	OurCSCComparatorDigis_

CSCStripDigiCollection *	OurCSCStripDigis_

CSCWireDigiCollection *	OurCSCWireDigis_

DTDigiCollection *	OurDTDigis_

RPCDigiCollection *	OurRPCDigis_

edm::InputTag	RPCdigi_collectionSig_

std::string	RPCDigiCollectionDM_

edm::EDGetTokenT < RPCDigiCollection >	RPCDigiPToken_

edm::InputTag	RPCDigiTagSig_

edm::EDGetTokenT < RPCDigiCollection >	RPCDigiToken_

edm::InputTag	RPCPileInputTag_

Detailed Description

Definition at line 43 of file DataMixingMuonWorker.h.

Constructor & Destructor Documentation

DataMixingMuonWorker::DataMixingMuonWorker ( )

Definition at line 28 of file DataMixingMuonWorker.cc.

28 { }

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

explicit

standard constructor

Definition at line 31 of file DataMixingMuonWorker.cc.

References CSCComparatorDigiCollectionDM_, CSCCompdigi_collectionSig_, CSCCompDigiPToken_, CSCCompDigiToken_, CSCCompPileInputTag_, CSCstripdigi_collectionSig_, CSCStripDigiCollectionDM_, CSCStripDigiPToken_, CSCStripDigiToken_, CSCStripPileInputTag_, CSCwiredigi_collectionSig_, CSCWireDigiCollectionDM_, CSCWireDigiPToken_, CSCWireDigiToken_, CSCWirePileInputTag_, DTDigiCollectionDM_, DTDigiPToken_, DTDigiTagSig_, DTDigiToken_, DTPileInputTag_, edm::ParameterSet::getParameter(), RPCDigiCollectionDM_, RPCDigiPToken_, RPCDigiTagSig_, RPCDigiToken_, RPCPileInputTag_, 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
 
     DTDigiTagSig_           = ps.getParameter<edm::InputTag>("DTDigiTagSig");
     RPCDigiTagSig_          = ps.getParameter<edm::InputTag>("RPCDigiTagSig");
 
     CSCstripdigi_collectionSig_   = ps.getParameter<edm::InputTag>("CSCstripdigiCollectionSig");
     CSCwiredigi_collectionSig_    = ps.getParameter<edm::InputTag>("CSCwiredigiCollectionSig");
     CSCCompdigi_collectionSig_    = ps.getParameter<edm::InputTag>("CSCCompdigiCollectionSig");
 
     DTDigiToken_ = iC.consumes<DTDigiCollection>(DTDigiTagSig_);
     CSCStripDigiToken_ = iC.consumes<CSCStripDigiCollection>(CSCstripdigi_collectionSig_);
     CSCWireDigiToken_ = iC.consumes<CSCWireDigiCollection>(CSCwiredigi_collectionSig_);
     CSCCompDigiToken_ = iC.consumes<CSCComparatorDigiCollection>(CSCCompdigi_collectionSig_);
     RPCDigiToken_ = iC.consumes<RPCDigiCollection>(RPCDigiTagSig_);
 
     DTPileInputTag_       = ps.getParameter<edm::InputTag>("DTPileInputTag");
     RPCPileInputTag_      = ps.getParameter<edm::InputTag>("RPCPileInputTag");
     CSCWirePileInputTag_  = ps.getParameter<edm::InputTag>("CSCWirePileInputTag");
     CSCStripPileInputTag_ = ps.getParameter<edm::InputTag>("CSCStripPileInputTag");
     CSCCompPileInputTag_  = ps.getParameter<edm::InputTag>("CSCCompPileInputTag");
 
     DTDigiPToken_ = iC.consumes<DTDigiCollection>(DTPileInputTag_);
     CSCStripDigiPToken_ = iC.consumes<CSCStripDigiCollection>(CSCStripPileInputTag_);
     CSCWireDigiPToken_ = iC.consumes<CSCWireDigiCollection>(CSCWirePileInputTag_);
     CSCCompDigiPToken_ = iC.consumes<CSCComparatorDigiCollection>(CSCCompPileInputTag_);
     RPCDigiPToken_ = iC.consumes<RPCDigiCollection>(RPCPileInputTag_);
 
 
     // outputs:
 
     DTDigiCollectionDM_  = ps.getParameter<std::string>("DTDigiCollectionDM");
     RPCDigiCollectionDM_ = ps.getParameter<std::string>("RPCDigiCollectionDM");
     CSCStripDigiCollectionDM_ = ps.getParameter<std::string>("CSCStripDigiCollectionDM");
     CSCWireDigiCollectionDM_  = ps.getParameter<std::string>("CSCWireDigiCollectionDM");
     CSCComparatorDigiCollectionDM_  = ps.getParameter<std::string>("CSCComparatorDigiCollectionDM");
 
 
   }

DataMixingMuonWorker::~DataMixingMuonWorker ( )

virtual

Default destructor

Definition at line 80 of file DataMixingMuonWorker.cc.

80 {

81 }

Member Function Documentation

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

Definition at line 237 of file DataMixingMuonWorker.cc.

References CSCCompPileInputTag_, CSCStripPileInputTag_, CSCWirePileInputTag_, DTPileInputTag_, edm::EventPrincipal::id(), LogDebug, OurCSCComparatorDigis_, OurCSCStripDigis_, OurCSCWireDigis_, OurDTDigis_, OurRPCDigis_, and RPCPileInputTag_.

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

                                                                              {
   
     LogDebug("DataMixingMuonWorker") <<"\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
 
     // DT
     // 
     // Get the digis from the event
 
    std::shared_ptr<Wrapper<DTDigiCollection>  const> DTDigisPTR = 
      getProductByTag<DTDigiCollection>(*ep, DTPileInputTag_, mcc);
  
    if(DTDigisPTR ) {
 
      const DTDigiCollection*  DTDigis = const_cast< DTDigiCollection * >(DTDigisPTR->product());
 
      DTDigiCollection::DigiRangeIterator DTLayerIt;
      for (DTLayerIt = DTDigis->begin(); DTLayerIt != DTDigis->end(); ++DTLayerIt) {
     // The layerId
     const DTLayerId& layerId = (*DTLayerIt).first;
 
     // Get the iterators over the Digis associated with this LayerId
     const DTDigiCollection::Range& range = (*DTLayerIt).second;
 
 
     OurDTDigis_->put(range, layerId);
       
       }
     }
     // RPC
     // 
 
     // Get the digis from the event
 
 
    std::shared_ptr<Wrapper<RPCDigiCollection>  const> RPCDigisPTR = 
      getProductByTag<RPCDigiCollection>(*ep, RPCPileInputTag_, mcc);
  
    if(RPCDigisPTR ) {
 
      const RPCDigiCollection*  RPCDigis = const_cast< RPCDigiCollection * >(RPCDigisPTR->product());
 
      RPCDigiCollection::DigiRangeIterator RPCLayerIt;
      for (RPCLayerIt = RPCDigis->begin(); RPCLayerIt != RPCDigis->end(); ++RPCLayerIt) {
     // The layerId
     const RPCDetId& layerId = (*RPCLayerIt).first;
 
     // Get the iterators over the digis associated with this LayerId
     const RPCDigiCollection::Range& range = (*RPCLayerIt).second;
 
     OurRPCDigis_->put(range, layerId);
       
       }
     }
 
     // CSCStrip
     // 
 
     // Get the digis from the event
 
    std::shared_ptr<Wrapper<CSCStripDigiCollection>  const> CSCStripDigisPTR = 
      getProductByTag<CSCStripDigiCollection>(*ep, CSCStripPileInputTag_, mcc);
  
    if(CSCStripDigisPTR ) {
 
      const CSCStripDigiCollection*  CSCStripDigis = const_cast< CSCStripDigiCollection * >(CSCStripDigisPTR->product());
 
      CSCStripDigiCollection::DigiRangeIterator CSCStripLayerIt;
      for (CSCStripLayerIt = CSCStripDigis->begin(); CSCStripLayerIt != CSCStripDigis->end(); ++CSCStripLayerIt) {
     // The layerId
     const CSCDetId& layerId = (*CSCStripLayerIt).first;
 
     // Get the iterators over the digis associated with this LayerId
     const CSCStripDigiCollection::Range& range = (*CSCStripLayerIt).second;
 
     //std::cout << " Pileup CSC layer " << (*CSCStripLayerIt).first << std::endl;
 
     //for(CSCStripDigiCollection::const_iterator dtdigi=range.first; dtdigi!=range.second; dtdigi++){
     //  std::cout << "Digi " << (*dtdigi) << std::endl;
     //  }
 
     OurCSCStripDigis_->put(range, layerId);
       
       }
     }
 
     // CSCWire
     // 
 
     // Get the digis from the event
 
    std::shared_ptr<Wrapper<CSCWireDigiCollection>  const> CSCWireDigisPTR = 
      getProductByTag<CSCWireDigiCollection>(*ep, CSCWirePileInputTag_, mcc);
  
    if(CSCWireDigisPTR ) {
 
      const CSCWireDigiCollection*  CSCWireDigis = const_cast< CSCWireDigiCollection * >(CSCWireDigisPTR->product());
 
      CSCWireDigiCollection::DigiRangeIterator CSCWireLayerIt;
      for (CSCWireLayerIt = CSCWireDigis->begin(); CSCWireLayerIt != CSCWireDigis->end(); ++CSCWireLayerIt) {
     // The layerId
     const CSCDetId& layerId = (*CSCWireLayerIt).first;
 
     // Get the iterators over the digis associated with this LayerId
     const CSCWireDigiCollection::Range& range = (*CSCWireLayerIt).second;
 
     OurCSCWireDigis_->put(range, layerId);
       
       }
     }
 
    // CSCComparators
    //
 
    // Get the digis from the event
 
    std::shared_ptr<Wrapper<CSCComparatorDigiCollection>  const> CSCComparatorDigisPTR =
      getProductByTag<CSCComparatorDigiCollection>(*ep, CSCCompPileInputTag_, mcc);
 
    if(CSCComparatorDigisPTR ) {
 
      const CSCComparatorDigiCollection*  CSCComparatorDigis = const_cast< CSCComparatorDigiCollection * >(CSCComparatorDigisPTR->product());
 
      CSCComparatorDigiCollection::DigiRangeIterator CSCComparatorLayerIt;
      for (CSCComparatorLayerIt = CSCComparatorDigis->begin(); CSCComparatorLayerIt != CSCComparatorDigis->end(); ++CSCComparatorLayerIt) {
        // The layerId
        const CSCDetId& layerId = (*CSCComparatorLayerIt).first;
 
        // Get the iterators over the digis associated with this LayerId
        const CSCComparatorDigiCollection::Range& range = (*CSCComparatorLayerIt).second;
 
        OurCSCComparatorDigis_->put(range, layerId);
 
      }
    }
 
 
   }

void DataMixingMuonWorker::addMuonSignals ( const edm::Event & e )

Definition at line 83 of file DataMixingMuonWorker.cc.

References CSCCompDigiToken_, CSCStripDigiToken_, CSCWireDigiToken_, DTDigiToken_, edm::Event::getByToken(), edm::EventBase::id(), LogDebug, OurCSCComparatorDigis_, OurCSCStripDigis_, OurCSCWireDigis_, OurDTDigis_, OurRPCDigis_, edm::Handle< T >::product(), and RPCDigiToken_.

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

                                                              { 
     // fill in maps of hits
 
     LogDebug("DataMixingMuonWorker")<<"===============> adding MC signals for "<<e.id();
 
     // DT
     // 
 
     OurDTDigis_ = new DTDigiCollection();
     Handle<DTDigiCollection> pDTdigis; 
 
     // Get the digis from the event
     if( e.getByToken(DTDigiToken_, pDTdigis) ) {
 
     //    LogInfo("DataMixingMuonWorker") << "total # DT Digis: " << DTdigis->size();
 
     // Loop over digis, copying them to our own local storage
       const DTDigiCollection* DTdigis = pDTdigis.product();
       DTDigiCollection::DigiRangeIterator DLayerIt;
       for (DLayerIt = DTdigis->begin(); DLayerIt != DTdigis->end(); ++DLayerIt) {
     // The layerId
     const DTLayerId& layerId = (*DLayerIt).first;
 
     // Get the iterators over the digis associated with this LayerId
     const DTDigiCollection::Range& range = (*DLayerIt).second;
 
     OurDTDigis_->put(range, layerId);
       }
     }
     // RPC
     // 
 
     OurRPCDigis_ = new RPCDigiCollection();
 
     // Get the digis from the event
     Handle<RPCDigiCollection> pRPCdigis; 
 
     if( e.getByToken(RPCDigiToken_, pRPCdigis) ) {
 
     // Loop over digis, copying them to our own local storage
 
       const RPCDigiCollection* RPCdigis = pRPCdigis.product();
       RPCDigiCollection::DigiRangeIterator RLayerIt;
       for (RLayerIt = RPCdigis->begin(); RLayerIt != RPCdigis->end(); ++RLayerIt) {
     // The layerId
     const RPCDetId& layerId = (*RLayerIt).first;
 
     // Get the iterators over the digis associated with this LayerId
     const RPCDigiCollection::Range& range = (*RLayerIt).second;
 
     OurRPCDigis_->put(range, layerId);
       
       }
     }
     // CSCStrip
     // 
 
     OurCSCStripDigis_ = new CSCStripDigiCollection();
 
     // Get the digis from the event
     Handle<CSCStripDigiCollection> pCSCStripdigis; 
 
     if( e.getByToken(CSCStripDigiToken_, pCSCStripdigis) ) {
 
     //if(pCSCStripdigis.isValid() ) { std::cout << "Signal: have CSCStripDigis" << std::endl;}
     //else { std::cout << "Signal: NO CSCStripDigis" << std::endl;}
 
 
     // Loop over digis, copying them to our own local storage
 
       const CSCStripDigiCollection* CSCStripdigis = pCSCStripdigis.product();
       CSCStripDigiCollection::DigiRangeIterator CSLayerIt;
       for (CSLayerIt = CSCStripdigis->begin(); CSLayerIt != CSCStripdigis->end(); ++CSLayerIt) {
     // The layerId
     const CSCDetId& layerId = (*CSLayerIt).first;
 
     // Get the iterators over the digis associated with this LayerId
     const CSCStripDigiCollection::Range& range = (*CSLayerIt).second;
 
     //std::cout << " Signal CSC layer " << (*CSLayerIt).first << std::endl;
 
     //for(CSCStripDigiCollection::const_iterator dtdigi=range.first; dtdigi!=range.second; dtdigi++){
     //  std::cout << "Digi " << (*dtdigi) << std::endl;
     //}
 
 
     OurCSCStripDigis_->put(range, layerId);
       }
     }
     // CSCWire
     // 
 
     OurCSCWireDigis_ = new CSCWireDigiCollection();
 
     // Get the digis from the event
     Handle<CSCWireDigiCollection> pCSCWiredigis; 
 
     if( e.getByToken(CSCWireDigiToken_, pCSCWiredigis) ) {
    
 
     //if(pCSCWiredigis.isValid() ) { std::cout << "Signal: have CSCWireDigis" << std::endl;}
     //else { std::cout << "Signal: NO CSCWireDigis" << std::endl;}
     
     // Loop over digis, copying them to our own local storage
 
       const CSCWireDigiCollection* CSCWiredigis = pCSCWiredigis.product();
       CSCWireDigiCollection::DigiRangeIterator CWLayerIt;
       for (CWLayerIt = CSCWiredigis->begin(); CWLayerIt != CSCWiredigis->end(); ++CWLayerIt) {
     // The layerId
     const CSCDetId& layerId = (*CWLayerIt).first;
 
     // Get the iterators over the digis associated with this LayerId
     const CSCWireDigiCollection::Range& range = (*CWLayerIt).second;
 
     OurCSCWireDigis_->put(range, layerId);
       
       }
     }
 
     // CSCComparators
     // 
 
     OurCSCComparatorDigis_ = new CSCComparatorDigiCollection();
 
     // Get the digis from the event
     Handle<CSCComparatorDigiCollection> pCSCComparatordigis; 
 
     //std::cout << "CSCComp label: " << CSCDigiTagSig_.label() << " " << CSCCompdigi_collectionSig_.label() << std::endl;
 
     if( e.getByToken(CSCCompDigiToken_, pCSCComparatordigis) ) {
    
 
       //if(pCSCComparatordigis.isValid() ) { std::cout << "Signal: have CSCComparatorDigis" << std::endl;}
       //else { std::cout << "Signal: NO CSCComparatorDigis" << std::endl;}
     
     // Loop over digis, copying them to our own local storage
 
       const CSCComparatorDigiCollection* CSCComparatordigis = pCSCComparatordigis.product();
       CSCComparatorDigiCollection::DigiRangeIterator CWLayerIt;
       for (CWLayerIt = CSCComparatordigis->begin(); CWLayerIt != CSCComparatordigis->end(); ++CWLayerIt) {
     // The layerId
     const CSCDetId& layerId = (*CWLayerIt).first;
 
     // Get the iterators over the digis associated with this LayerId
     const CSCComparatorDigiCollection::Range& range = (*CWLayerIt).second;
 
     OurCSCComparatorDigis_->put(range, layerId);
       
       }
     }
 
     
   } // end of addMuonSignals

void DataMixingMuonWorker::putMuon ( edm::Event & e )

Definition at line 378 of file DataMixingMuonWorker.cc.

References edm::check(), prof2calltree::count, CSCComparatorDigiCollectionDM_, CSCStripDigiCollectionDM_, CSCWireDigiCollectionDM_, cond::persistency::duplicate(), OurCSCComparatorDigis_, OurCSCStripDigis_, OurCSCWireDigis_, OurDTDigis_, OurRPCDigis_, and edm::Event::put().

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

                                                 {
 
     // collections of digis to put in the event
     std::auto_ptr< DTDigiCollection > DTDigiMerge( new DTDigiCollection );
     std::auto_ptr< RPCDigiCollection > RPCDigiMerge( new RPCDigiCollection );
     std::auto_ptr< CSCStripDigiCollection > CSCStripDigiMerge( new CSCStripDigiCollection );
     std::auto_ptr< CSCWireDigiCollection > CSCWireDigiMerge( new CSCWireDigiCollection );
     std::auto_ptr< CSCComparatorDigiCollection > CSCComparatorDigiMerge( new CSCComparatorDigiCollection );
 
     // Loop over DT digis, copying them from our own local storage
 
     DTDigiCollection::DigiRangeIterator DLayerIt;
     for (DLayerIt = OurDTDigis_->begin(); DLayerIt != OurDTDigis_->end(); ++DLayerIt) {
       // The layerId
       const DTLayerId& layerId = (*DLayerIt).first;
 
       // Get the iterators over the digis associated with this LayerId
       const DTDigiCollection::Range& range = (*DLayerIt).second;
 
 
       DTDigiMerge->put(range, layerId);
       
     }
 
     // Loop over RPC digis, copying them from our own local storage
 
     RPCDigiCollection::DigiRangeIterator RLayerIt;
     for (RLayerIt = OurRPCDigis_->begin(); RLayerIt != OurRPCDigis_->end(); ++RLayerIt) {
       // The layerId
       const RPCDetId& layerId = (*RLayerIt).first;
 
       // Get the iterators over the digis associated with this LayerId
       const RPCDigiCollection::Range& range = (*RLayerIt).second;
 
       RPCDigiMerge->put(range, layerId);
       
     }
     // Loop over CSCStrip digis, copying them from our own local storage
 
     CSCStripDigiCollection::DigiRangeIterator CSLayerIt;
     for (CSLayerIt = OurCSCStripDigis_->begin(); CSLayerIt != OurCSCStripDigis_->end(); ++CSLayerIt) {
       // The layerId
       const CSCDetId& layerId = (*CSLayerIt).first;
 
       // Get the iterators over the digis associated with this LayerId
       const CSCStripDigiCollection::Range& range = (*CSLayerIt).second;
 
       std::vector<CSCStripDigi> NewDigiList;
 
       std::vector<int> StripList;
       std::vector<CSCStripDigiCollection::const_iterator> StripPointer;
 
       for(CSCStripDigiCollection::const_iterator dtdigi=range.first; dtdigi!=range.second; ++dtdigi){
         //std::cout << "Digi " << (*dtdigi).getStrip() << std::endl;
     StripList.push_back( (*dtdigi).getStrip() );
     StripPointer.push_back( dtdigi );
       }
 
       int PrevStrip = -1;
       std::vector<int> DuplicateList;
 
       std::vector<CSCStripDigiCollection::const_iterator>::const_iterator StripPtr = StripPointer.begin();
 
       for( std::vector<int>::const_iterator istrip = StripList.begin(); istrip !=StripList.end(); ++istrip) {
        
     const int CurrentStrip = *(istrip);
     
     if(CurrentStrip > PrevStrip) { 
       PrevStrip = CurrentStrip; 
 
       int dupl_count;
       dupl_count = std::count(StripList.begin(), StripList.end(), CurrentStrip);
       if(dupl_count > 1) {
         std::vector<int>::const_iterator  duplicate = istrip;
         ++duplicate;
         std::vector<CSCStripDigiCollection::const_iterator>::const_iterator DuplPointer = StripPtr;
         ++DuplPointer;
         for( ; duplicate!=StripList.end(); ++duplicate) {
           if( (*duplicate) == CurrentStrip ) {
 
         //      std::cout << " Duplicate of current " << CurrentStrip << " found at " << (duplicate - StripList.begin()) << std::endl;
 
         DuplicateList.push_back(CurrentStrip);
 
         std::vector<int> pileup_adc = (**DuplPointer).getADCCounts();
         std::vector<int> signal_adc = (**StripPtr).getADCCounts();
 
         std::vector<int>::const_iterator minplace;
         
         minplace = std::min_element(pileup_adc.begin(), pileup_adc.end());
 
         int minvalue = (*minplace);
         
         std::vector<int> new_adc;
 
         std::vector<int>::const_iterator newsig = signal_adc.begin();
 
         for(std::vector<int>::const_iterator ibin = pileup_adc.begin(); ibin!=pileup_adc.end(); ++ibin) {
           new_adc.push_back((*newsig)+(*ibin)-minvalue);
 
           ++newsig;
         }
 
         CSCStripDigi newDigi(CurrentStrip, new_adc);
         NewDigiList.push_back(newDigi);
           }
           ++DuplPointer;
         }
       }
       else { NewDigiList.push_back(**StripPtr); }
     }  // if strips monotonically increasing...  Haven't hit duplicates yet
     else { // reached end of signal digis, or there was no overlap
       PrevStrip = 1000;  // now into pileup signals, stop looking forward for duplicates
 
       // check if this digi was in the duplicate list
       int check;
       check = std::count(DuplicateList.begin(), DuplicateList.end(), CurrentStrip);
       if(check == 0) NewDigiList.push_back(**StripPtr);
     }
     ++StripPtr;
       }
 
       CSCStripDigiCollection::Range stripRange(NewDigiList.begin(), NewDigiList.end());
 
       CSCStripDigiMerge->put(stripRange, layerId);
 
     }
     // Loop over CSCStrip digis, copying them from our own local storage
 
     CSCWireDigiCollection::DigiRangeIterator CWLayerIt;
     for (CWLayerIt = OurCSCWireDigis_->begin(); CWLayerIt != OurCSCWireDigis_->end(); ++CWLayerIt) {
       // The layerId
       const CSCDetId& layerId = (*CWLayerIt).first;
 
       // Get the iterators over the digis associated with this LayerId
       const CSCWireDigiCollection::Range& range = (*CWLayerIt).second;
 
       CSCWireDigiMerge->put(range, layerId);
       
     }
 
     // Loop over CSCComparator digis, copying them from our own local storage
 
     CSCComparatorDigiCollection::DigiRangeIterator CCLayerIt;
     for (CCLayerIt = OurCSCComparatorDigis_->begin(); CCLayerIt != OurCSCComparatorDigis_->end(); ++CCLayerIt) {
       // The layerId
       const CSCDetId& layerId = (*CCLayerIt).first;
 
       // Get the iterators over the digis associated with this LayerId
       const CSCComparatorDigiCollection::Range& range = (*CCLayerIt).second;
 
       CSCComparatorDigiMerge->put(range, layerId);
       
     }
 
 
     // put the collection of recunstructed hits in the event   
     //    LogDebug("DataMixingMuonWorker") << "total # DT Merged Digis: " << DTDigiMerge->size() ;
     //    LogDebug("DataMixingMuonWorker") << "total # RPC Merged Digis: " << RPCDigiMerge->size() ;
     //    LogDebug("DataMixingMuonWorker") << "total # CSCStrip Merged Digis: " << CSCStripDigiMerge->size() ;
     //    LogDebug("DataMixingMuonWorker") << "total # CSCWire Merged Digis: " << CSCWireDigiMerge->size() ;
 
     e.put( DTDigiMerge );
     e.put( RPCDigiMerge );
     e.put( CSCStripDigiMerge, CSCStripDigiCollectionDM_ );
     e.put( CSCWireDigiMerge, CSCWireDigiCollectionDM_ );
     e.put( CSCComparatorDigiMerge, CSCComparatorDigiCollectionDM_ );
 
     // clear local storage for this event
     delete OurDTDigis_;
     delete OurRPCDigis_;
     delete OurCSCStripDigis_;
     delete OurCSCWireDigis_;
     delete OurCSCComparatorDigis_;
 
   }