#include <DataMixingEMDigiWorker.h>

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

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

	DataMixingEMDigiWorker ()

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

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

virtual	~DataMixingEMDigiWorker ()

Private Types
typedef std::multimap< DetId, EBDataFrame >	EBDigiMap

typedef std::multimap< DetId, EEDataFrame >	EEDigiMap

typedef std::multimap< DetId, ESDataFrame >	ESDigiMap

Private Member Functions
const std::vector< float >	GetGainRatios (const edm::EventSetup &ES, const DetId &detid)
	retrieve gain ratios for that detid [0]=g12, [1]=g6, [2]=g12 More...

const std::vector< float >	GetPedestals (const edm::EventSetup &ES, const DetId &detid)
	retrieve pedestals for that detid [0]=g12, [1]=g6, [2]=g12 More...

Private Attributes
std::string	EBDigiCollectionDM_

edm::InputTag	EBdigiCollectionSig_

edm::EDGetTokenT< EBDigiCollection >	EBDigiPileToken_

EBDigiMap	EBDigiStorage_

edm::EDGetTokenT< EBDigiCollection >	EBDigiToken_

edm::InputTag	EBPileInputTag_

edm::InputTag	EBProducerSig_

std::string	EEDigiCollectionDM_

edm::InputTag	EEdigiCollectionSig_

edm::EDGetTokenT< EEDigiCollection >	EEDigiPileToken_

EEDigiMap	EEDigiStorage_

edm::EDGetTokenT< EEDigiCollection >	EEDigiToken_

edm::InputTag	EEPileInputTag_

edm::InputTag	EEProducerSig_

std::string	ESDigiCollectionDM_

edm::InputTag	ESdigiCollectionSig_

edm::EDGetTokenT< ESDigiCollection >	ESDigiPileToken_

ESDigiMap	ESDigiStorage_

edm::EDGetTokenT< ESDigiCollection >	ESDigiToken_

edm::InputTag	ESPileInputTag_

edm::InputTag	ESProducerSig_

std::string	label_

Detailed Description

Definition at line 40 of file DataMixingEMDigiWorker.h.

Member Typedef Documentation

typedef std::multimap<DetId, EBDataFrame> edm::DataMixingEMDigiWorker::EBDigiMap

private

Definition at line 97 of file DataMixingEMDigiWorker.h.

typedef std::multimap<DetId, EEDataFrame> edm::DataMixingEMDigiWorker::EEDigiMap

private

Definition at line 98 of file DataMixingEMDigiWorker.h.

typedef std::multimap<DetId, ESDataFrame> edm::DataMixingEMDigiWorker::ESDigiMap

private

Definition at line 99 of file DataMixingEMDigiWorker.h.

Constructor & Destructor Documentation

DataMixingEMDigiWorker::DataMixingEMDigiWorker ( )

Definition at line 30 of file DataMixingEMDigiWorker.cc.

30 {}

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

explicit

standard constructor

Definition at line 33 of file DataMixingEMDigiWorker.cc.

References EBDigiCollectionDM_, EBDigiPileToken_, EBDigiToken_, EBPileInputTag_, EBProducerSig_, EEDigiCollectionDM_, EEDigiPileToken_, EEDigiToken_, EEPileInputTag_, EEProducerSig_, ESDigiCollectionDM_, ESDigiPileToken_, ESDigiToken_, ESPileInputTag_, ESProducerSig_, 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>("EBdigiProducerSig");
     EEProducerSig_ = ps.getParameter<edm::InputTag>("EEdigiProducerSig");
     ESProducerSig_ = ps.getParameter<edm::InputTag>("ESdigiProducerSig");
 
     EBDigiToken_ = iC.consumes<EBDigiCollection>(EBProducerSig_);
     EEDigiToken_ = iC.consumes<EEDigiCollection>(EEProducerSig_);
     ESDigiToken_ = iC.consumes<ESDigiCollection>(ESProducerSig_);
 
     EBPileInputTag_ = ps.getParameter<edm::InputTag>("EBPileInputTag");
     EEPileInputTag_ = ps.getParameter<edm::InputTag>("EEPileInputTag");
     ESPileInputTag_ = ps.getParameter<edm::InputTag>("ESPileInputTag");
 
     EBDigiPileToken_ = iC.consumes<EBDigiCollection>(EBPileInputTag_);
     EEDigiPileToken_ = iC.consumes<EEDigiCollection>(EEPileInputTag_);
     ESDigiPileToken_ = iC.consumes<ESDigiCollection>(ESPileInputTag_);
 
     EBDigiCollectionDM_ = ps.getParameter<std::string>("EBDigiCollectionDM");
     EEDigiCollectionDM_ = ps.getParameter<std::string>("EEDigiCollectionDM");
     ESDigiCollectionDM_ = ps.getParameter<std::string>("ESDigiCollectionDM");
   }

DataMixingEMDigiWorker::~DataMixingEMDigiWorker ( )

virtual

Default destructor

Definition at line 65 of file DataMixingEMDigiWorker.cc.

65 {}

Member Function Documentation

void DataMixingEMDigiWorker::addEMPileups	(	const int	bcr,
		const edm::EventPrincipal *	ep,
		unsigned int	EventId,
		const edm::EventSetup &	ES,
		ModuleCallingContext const *	mcc
	)

Definition at line 149 of file DataMixingEMDigiWorker.cc.

References edm::DataFrameContainer::begin(), EBDigiStorage_, EBPileInputTag_, EEDigiStorage_, EEPileInputTag_, edm::DataFrameContainer::end(), ESDigiStorage_, ESPileInputTag_, edm::EventPrincipal::id(), LogDebug, and edm::DataFrameContainer::size().

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

                                                                              {
     LogInfo("DataMixingEMDigiWorker") << "\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<EBDigiCollection> const> EBDigisPTR =
         getProductByTag<EBDigiCollection>(*ep, EBPileInputTag_, mcc);
 
     if (EBDigisPTR) {
       const EBDigiCollection *EBDigis = const_cast<EBDigiCollection *>(EBDigisPTR->product());
 
       LogDebug("DataMixingEMDigiWorker") << "total # EB digis: " << EBDigis->size();
 
       // loop over digis, adding these to the existing maps
       for (EBDigiCollection::const_iterator it = EBDigis->begin(); it != EBDigis->end(); ++it) {
         EBDigiStorage_.insert(EBDigiMap::value_type((it->id()), *it));
 
 #ifdef DEBUG
         // Commented out because this does not compile anymore
         // LogDebug("DataMixingEMDigiWorker") << "processed EBDigi with rawId: "
         //                                    << it->id().rawId() << "\n"
         //                                    << " digi energy: " << it->energy();
 #endif
       }
     }
 
     // EE Next
 
     std::shared_ptr<Wrapper<EEDigiCollection> const> EEDigisPTR =
         getProductByTag<EEDigiCollection>(*ep, EEPileInputTag_, mcc);
 
     if (EEDigisPTR) {
       const EEDigiCollection *EEDigis = const_cast<EEDigiCollection *>(EEDigisPTR->product());
 
       LogDebug("DataMixingEMDigiWorker") << "total # EE digis: " << EEDigis->size();
 
       for (EEDigiCollection::const_iterator it = EEDigis->begin(); it != EEDigis->end(); ++it) {
         EEDigiStorage_.insert(EEDigiMap::value_type((it->id()), *it));
 
 #ifdef DEBUG
         // Commented out because this does not compile anymore
         // LogDebug("DataMixingEMDigiWorker") << "processed EEDigi with rawId: "
         //                                    << it->id().rawId() << "\n"
         //                                    << " digi energy: " << it->energy();
 #endif
       }
     }
     // ES Next
 
     std::shared_ptr<Wrapper<ESDigiCollection> const> ESDigisPTR =
         getProductByTag<ESDigiCollection>(*ep, ESPileInputTag_, mcc);
 
     if (ESDigisPTR) {
       const ESDigiCollection *ESDigis = const_cast<ESDigiCollection *>(ESDigisPTR->product());
 
       LogDebug("DataMixingEMDigiWorker") << "total # ES digis: " << ESDigis->size();
 
       for (ESDigiCollection::const_iterator it = ESDigis->begin(); it != ESDigis->end(); ++it) {
         ESDigiStorage_.insert(ESDigiMap::value_type((it->id()), *it));
 
 #ifdef DEBUG
         // Commented out because this does not compile anymore
         // LogDebug("DataMixingEMDigiWorker") << "processed ESDigi with rawId: "
         //                                    << it->id().rawId() << "\n"
         //                                    << " digi energy: " << it->energy();
 #endif
       }
     }
   }

void DataMixingEMDigiWorker::addEMSignals	(	const edm::Event &	e,
		const edm::EventSetup &	ES
	)

Definition at line 67 of file DataMixingEMDigiWorker.cc.

References edm::DataFrameContainer::begin(), EBDigiStorage_, EBDigiToken_, EEDigiStorage_, EEDigiToken_, edm::DataFrameContainer::end(), ESDigiStorage_, ESDigiToken_, edm::Event::getByToken(), edm::EventBase::id(), LogDebug, edm::Handle< T >::product(), and edm::DataFrameContainer::size().

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

                                                                                       {
     // fill in maps of hits
 
     LogInfo("DataMixingEMDigiWorker") << "===============> adding MC signals for " << e.id();
 
     // EB first
 
     Handle<EBDigiCollection> pEBDigis;
 
     const EBDigiCollection *EBDigis = nullptr;
 
     if (e.getByToken(EBDigiToken_, pEBDigis)) {
       EBDigis = pEBDigis.product();  // get a ptr to the product
       LogDebug("DataMixingEMDigiWorker") << "total # EB digis: " << EBDigis->size();
     }
 
     if (EBDigis) {
       // loop over digis, storing them in a map so we can add pileup later
 
       for (EBDigiCollection::const_iterator it = EBDigis->begin(); it != EBDigis->end(); ++it) {
         EBDigiStorage_.insert(EBDigiMap::value_type((it->id()), *it));
 #ifdef DEBUG
         // Commented out because this does not compile anymore
         // LogDebug("DataMixingEMDigiWorker") << "processed EBDigi with rawId: "
         //                                    << it->id().rawId() << "\n"
         //                                    << " digi energy: " << it->energy();
 #endif
       }
     }
 
     // EE next
 
     Handle<EEDigiCollection> pEEDigis;
 
     const EEDigiCollection *EEDigis = nullptr;
 
     if (e.getByToken(EEDigiToken_, pEEDigis)) {
       EEDigis = pEEDigis.product();  // get a ptr to the product
       LogDebug("DataMixingEMDigiWorker") << "total # EE digis: " << EEDigis->size();
     }
 
     if (EEDigis) {
       // loop over digis, storing them in a map so we can add pileup later
       for (EEDigiCollection::const_iterator it = EEDigis->begin(); it != EEDigis->end(); ++it) {
         EEDigiStorage_.insert(EEDigiMap::value_type((it->id()), *it));
 #ifdef DEBUG
         // Commented out because this does not compile anymore
         // LogDebug("DataMixingEMDigiWorker") << "processed EEDigi with rawId: "
         //                                    << it->id().rawId() << "\n"
         //                                    << " digi energy: " << it->energy();
 #endif
       }
     }
     // ES next
 
     Handle<ESDigiCollection> pESDigis;
 
     const ESDigiCollection *ESDigis = nullptr;
 
     if (e.getByToken(ESDigiToken_, pESDigis)) {
       ESDigis = pESDigis.product();  // get a ptr to the product
 #ifdef DEBUG
       LogDebug("DataMixingEMDigiWorker") << "total # ES digis: " << ESDigis->size();
 #endif
     }
 
     if (ESDigis) {
       // loop over digis, storing them in a map so we can add pileup later
       for (ESDigiCollection::const_iterator it = ESDigis->begin(); it != ESDigis->end(); ++it) {
         ESDigiStorage_.insert(ESDigiMap::value_type((it->id()), *it));
 
 #ifdef DEBUG
         // Commented out because this does not compile anymore
         // LogDebug("DataMixingEMDigiWorker") << "processed ESDigi with rawId: "
         //                                    << it->id().rawId() << "\n"
         //                                    << " digi energy: " << it->energy();
 #endif
       }
     }
 
   }  // end of addEMSignals

const std::vector< float > DataMixingEMDigiWorker::GetGainRatios	(	const edm::EventSetup &	ES,
		const DetId &	detid
	)

private

retrieve gain ratios for that detid [0]=g12, [1]=g6, [2]=g12

Definition at line 556 of file DataMixingEMDigiWorker.cc.

References EcalMGPAGainRatio::gain12Over6(), EcalMGPAGainRatio::gain6Over1(), and edm::EventSetup::get().

Referenced by putEM().

                                                                                                           {
     std::vector<float> gainRatios(3);
     // get gain ratios
     edm::ESHandle<EcalGainRatios> grHandle;
     ES.get<EcalGainRatiosRcd>().get(grHandle);
     EcalMGPAGainRatio theRatio = (*grHandle)[detid];
 
     gainRatios[0] = 1.;
     gainRatios[1] = theRatio.gain12Over6();
     gainRatios[2] = theRatio.gain6Over1() * theRatio.gain12Over6();
 
     return gainRatios;
   }

const std::vector< float > DataMixingEMDigiWorker::GetPedestals	(	const edm::EventSetup &	ES,
		const DetId &	detid
	)

private

retrieve pedestals for that detid [0]=g12, [1]=g6, [2]=g12

Definition at line 529 of file DataMixingEMDigiWorker.cc.

References EcalCondObjectContainer< T >::end(), EcalCondObjectContainer< T >::find(), edm::EventSetup::get(), EcalCondObjectContainer< T >::getMap(), EcalPedestal::mean_x1, EcalPedestal::mean_x12, EcalPedestal::mean_x6, and edm::ESHandle< T >::product().

Referenced by putEM().

                                                                                                          {
     std::vector<float> pedeStals(3);
 
     // get pedestals
     edm::ESHandle<EcalPedestals> pedHandle;
     ES.get<EcalPedestalsRcd>().get(pedHandle);
 
     const EcalPedestalsMap &pedMap = pedHandle.product()->getMap();  // map of pedestals
     EcalPedestalsMapIterator pedIter;                                // pedestal iterator
     EcalPedestals::Item aped;                                        // pedestal object for a single xtal
 
     pedIter = pedMap.find(detid);
     if (pedIter != pedMap.end()) {
       aped = (*pedIter);
       pedeStals[0] = aped.mean_x12;
       pedeStals[1] = aped.mean_x6;
       pedeStals[2] = aped.mean_x1;
     } else {
       edm::LogError("DataMixingMissingInput") << "Cannot find pedestals";
       pedeStals[0] = 0;
       pedeStals[1] = 0;
       pedeStals[2] = 0;
     }
 
     return pedeStals;
   }

void DataMixingEMDigiWorker::putEM	(	edm::Event &	e,
		const edm::EventSetup &	ES
	)

Definition at line 227 of file DataMixingEMDigiWorker.cc.

References ecalMGPA::adc(), edm::DataFrame::begin(), data, EBDigiCollectionDM_, EBDigiStorage_, EEDigiCollectionDM_, EEDigiStorage_, ESDigiCollectionDM_, ESDigiStorage_, EcalDataFrame::frame(), ecalMGPA::gainId(), GetGainRatios(), GetPedestals(), createfilelist::int, SiStripPI::max, min(), eostools::move(), edm::Event::put(), particleFlowDisplacedVertex_cfi::ratio, simplePhotonAnalyzer_cfi::sample, ESDataFrame::setSample(), EcalDataFrame::setSample(), ESDataFrame::size(), EcalDataFrame::size(), and findQualityFiles::size.

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

                                                                          {
     // collection of digis to put in the event
     std::unique_ptr<EBDigiCollection> EBdigis(new EBDigiCollection);
     std::unique_ptr<EEDigiCollection> EEdigis(new EEDigiCollection);
     std::unique_ptr<ESDigiCollection> ESdigis(new ESDigiCollection);
 
     // loop over the maps we have, re-making individual hits or digis if
     // necessary.
     DetId formerID = 0;
     DetId currentID;
 
     EBDataFrame EB_old;
 
     int gain_new = 0;
     int gain_old = 0;
     int gain_consensus = 0;
     int adc_new;
     int adc_old;
     int adc_sum;
     uint16_t data;
 
     // EB first...
 
     EBDigiMap::const_iterator iEBchk;
 
     for (EBDigiMap::const_iterator iEB = EBDigiStorage_.begin(); iEB != EBDigiStorage_.end(); iEB++) {
       currentID = iEB->first;
 
       if (currentID == formerID) {  // we have to add these digis together
         /*
       cout<< " Adding signals " << EBDetId(currentID).ieta() << " "
                                 << EBDetId(currentID).iphi() << std::endl;
 
       cout << 1 << " " ;
       for (int i=0; i<10;++i)  std::cout << EB_old[i].adc()<<
       "["<<EB_old[i].gainId()<< "] " ; std::cout << std::endl;
 
       cout << 2 << " " ;
       for (int i=0; i<10;++i)  std::cout << (iEB->second)[i].adc()<<
       "["<<(iEB->second)[i].gainId()<< "] " ; std::cout << std::endl;
       */
         // loop over digi samples in each DataFrame
         unsigned int sizenew = (iEB->second).size();
         unsigned int sizeold = EB_old.size();
 
         unsigned int max_samp = std::max(sizenew, sizeold);
 
         // samples from different events can be of different lengths - sum all
         // that overlap.
         // check to see if gains match - if not, scale smaller cell down.
 
         int sw_gain_consensus = 0;
 
         for (unsigned int isamp = 0; isamp < max_samp; isamp++) {
           if (isamp < sizenew) {
             gain_new = (iEB->second)[isamp].gainId();
             adc_new = (iEB->second)[isamp].adc();
           } else {
             adc_new = 0;
           }
 
           if (isamp < sizeold) {
             gain_old = EB_old[isamp].gainId();
             adc_old = EB_old[isamp].adc();
           } else {
             adc_old = 0;
           }
 
           const std::vector<float> pedeStals = GetPedestals(ES, currentID);
           const std::vector<float> gainRatios = GetGainRatios(ES, currentID);
 
           if (adc_new > 0 && adc_old > 0) {
             if (gain_old == gain_new) {  // we're happy - easy case
               gain_consensus = gain_old;
             } else {  // lower gain sample has more energy
 
               if (gain_old < gain_new) {  // old has higher gain than new, scale to lower gain
 
                 float ratio = gainRatios[gain_new - 1] / gainRatios[gain_old - 1];
                 adc_old = (int)round((adc_old - pedeStals[gain_old - 1]) / ratio + pedeStals[gain_new - 1]);
                 gain_consensus = gain_new;
               } else {  // scale to old (lower) gain
                 float ratio = gainRatios[gain_old - 1] / gainRatios[gain_new - 1];
                 adc_new = (int)round((adc_new - pedeStals[gain_new - 1]) / ratio + pedeStals[gain_old - 1]);
                 gain_consensus = gain_old;
               }
             }
           }
 
           // add values, but don't count pedestals twice
           adc_sum = adc_new + adc_old - (int)round(pedeStals[gain_consensus - 1]);
 
           // if we are now saturating that gain, switch to the next
           if (adc_sum > 4096) {
             if (gain_consensus < 3) {
               double ratio = gainRatios[gain_consensus] / gainRatios[gain_consensus - 1];
               adc_sum = (int)round((adc_sum - pedeStals[gain_consensus - 1]) / ratio + pedeStals[gain_consensus]);
               sw_gain_consensus = ++gain_consensus;
             } else
               adc_sum = 4096;
           }
 
           // furthermore, make sure we don't decrease our gain once we've switched
           // up in case go back
           if (gain_consensus < sw_gain_consensus) {
             double ratio = gainRatios[sw_gain_consensus - 1] / gainRatios[gain_consensus - 1];
             adc_sum = (int)round((adc_sum - pedeStals[gain_consensus - 1]) / ratio + pedeStals[sw_gain_consensus - 1]);
             gain_consensus = sw_gain_consensus;
           }
 
           EcalMGPASample sample(adc_sum, gain_consensus);
           EB_old.setSample(isamp,
                            sample);  // overwrite old sample, adding new info
         }                            // for sample
 
       }  // if current = former
       else {
         if (formerID > 0) {
           EBdigis->push_back(formerID, EB_old.frame().begin());
         }
         // save pointers for next iteration
         formerID = currentID;
         EB_old = iEB->second;
       }
 
       iEBchk = iEB;
       if ((++iEBchk) == EBDigiStorage_.end()) {  // make sure not to lose the last one
         EBdigis->push_back(currentID, (iEB->second).frame().begin());
       }
     }
 
     // EE next...
 
     formerID = 0;
     EEDataFrame EE_old;
 
     EEDigiMap::const_iterator iEEchk;
 
     for (EEDigiMap::const_iterator iEE = EEDigiStorage_.begin(); iEE != EEDigiStorage_.end(); iEE++) {
       currentID = iEE->first;
 
       if (currentID == formerID) {  // we have to add these digis together
 
         // loop over digi samples in each DataFrame
         unsigned int sizenew = (iEE->second).size();
         unsigned int sizeold = EE_old.size();
 
         unsigned int max_samp = std::max(sizenew, sizeold);
 
         // samples from different events can be of different lengths - sum all
         // that overlap.
         // check to see if gains match - if not, scale smaller cell down.
 
         for (unsigned int isamp = 0; isamp < max_samp; isamp++) {
           if (isamp < sizenew) {
             gain_new = (iEE->second)[isamp].gainId();
             adc_new = (iEE->second)[isamp].adc();
           } else {
             adc_new = 0;
           }
 
           if (isamp < sizeold) {
             gain_old = EE_old[isamp].gainId();
             adc_old = EE_old[isamp].adc();
           } else {
             adc_old = 0;
           }
 
           const std::vector<float> pedeStals = GetPedestals(ES, currentID);
           const std::vector<float> gainRatios = GetGainRatios(ES, currentID);
 
           if (adc_new > 0 && adc_old > 0) {
             if (gain_old == gain_new) {  // we're happy - easy case
               gain_consensus = gain_old;
             } else {  // lower gain sample has more energy
 
               if (gain_old < gain_new) {  // old has higher gain than new, scale to lower gain
 
                 float ratio = gainRatios[gain_new - 1] / gainRatios[gain_old - 1];
                 adc_old = (int)round((adc_old - pedeStals[gain_old - 1]) / ratio + pedeStals[gain_new - 1]);
                 gain_consensus = gain_new;
               } else {  // scale to old (lower) gain
                 float ratio = gainRatios[gain_old - 1] / gainRatios[gain_new - 1];
                 adc_new = (int)round((adc_new - pedeStals[gain_new - 1]) / ratio + pedeStals[gain_old - 1]);
                 gain_consensus = gain_old;
               }
             }
           }
 
           // add values, but don't count pedestals twice
           adc_sum = adc_new + adc_old - (int)round(pedeStals[gain_consensus - 1]);
 
           // if the sum saturates this gain, switch
           if (adc_sum > 4096) {
             if (gain_consensus < 3) {
               double ratio = gainRatios[gain_consensus] / gainRatios[gain_consensus - 1];
               adc_sum = (int)round((adc_sum - pedeStals[gain_consensus - 1]) / ratio + pedeStals[gain_consensus]);
               ++gain_consensus;
             } else
               adc_sum = 4096;
           }
 
           EcalMGPASample sample(adc_sum, gain_consensus);
           EE_old.setSample(isamp, sample);
         }
 
       } else {
         if (formerID > 0) {
           EEdigis->push_back(formerID, EE_old.frame().begin());
         }
         // save pointers for next iteration
         formerID = currentID;
         EE_old = iEE->second;
       }
 
       iEEchk = iEE;
       if ((++iEEchk) == EEDigiStorage_.end()) {  // make sure not to lose the last one
         EEdigis->push_back(currentID, (iEE->second).frame().begin());
       }
     }
 
     // ES next...
 
     formerID = 0;
     ESDataFrame ES_old;
 
     ESDigiMap::const_iterator iESchk;
 
     for (ESDigiMap::const_iterator iES = ESDigiStorage_.begin(); iES != ESDigiStorage_.end(); iES++) {
       currentID = iES->first;
 
       if (currentID == formerID) {  // we have to add these digis together
 
         // loop over digi samples in each DataFrame
         unsigned int sizenew = (iES->second).size();
         unsigned int sizeold = ES_old.size();
         uint16_t rawdat = 0;
         unsigned int max_samp = std::max(sizenew, sizeold);
 
         // samples from different events can be of different lengths - sum all
         // that overlap.
         // check to see if gains match - if not, scale smaller cell down.
 
         for (unsigned int isamp = 0; isamp < max_samp; isamp++) {
           if (isamp < sizenew) {
             adc_new = (iES->second)[isamp].adc();
             rawdat = (iES->second)[isamp].raw();
           } else {
             adc_new = 0;
           }
 
           if (isamp < sizeold) {
             adc_old = ES_old[isamp].adc();
             rawdat = ES_old[isamp].raw();
           } else {
             adc_old = 0;
           }
 
           // add values
           adc_sum = adc_new + adc_old;
           // make data word of gain, rawdata
           adc_sum = std::min(adc_sum, 4095);   // first 12 bits of (uint)
           data = adc_sum + (rawdat & 0xF000);  // data is 14 bit word with gain as MSBs
           ES_old.setSample(isamp, data);
         }
 
       } else {
         if (formerID > 0) {
           ESdigis->push_back(ES_old);
         }
         // save pointers for next iteration
         formerID = currentID;
         ES_old = iES->second;
       }
 
       iESchk = iES;
       if ((++iESchk) == ESDigiStorage_.end()) {  // make sure not to lose the last one
         ESdigis->push_back(iES->second);
         //  ESDataFrame df( (*ESdigis)->back() );
         // for(int isamp=0; isamp<(iES->second).size(); isamp++) {
         //  df.setSample(isamp,(iES->second).data[isamp]);
         //  }
       }
     }
 
     // done merging
 
     // put the collection of reconstructed hits in the event
     LogInfo("DataMixingEMDigiWorker") << "total # EB Merged digis: " << EBdigis->size();
     LogInfo("DataMixingEMDigiWorker") << "total # EE Merged digis: " << EEdigis->size();
     LogInfo("DataMixingEMDigiWorker") << "total # ES Merged digis: " << ESdigis->size();
 
     e.put(std::move(EBdigis), EBDigiCollectionDM_);
     e.put(std::move(EEdigis), EEDigiCollectionDM_);
     e.put(std::move(ESdigis), ESDigiCollectionDM_);
 
     // clear local storage after this event
 
     EBDigiStorage_.clear();
     EEDigiStorage_.clear();
     ESDigiStorage_.clear();
   }