edm::DataMixingEMDigiWorker Class Reference

#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_
edm::ESGetToken< EcalGainRatios, EcalGainRatiosRcd >	grToken_
std::string	label_
edm::ESGetToken< EcalPedestals, EcalPedestalsRcd >	pedToken_

Detailed Description

Definition at line 45 of file DataMixingEMDigiWorker.h.

Member Typedef Documentation

EBDigiMap

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

private

Definition at line 102 of file DataMixingEMDigiWorker.h.

EEDigiMap

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

private

Definition at line 103 of file DataMixingEMDigiWorker.h.

ESDigiMap

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

private

Definition at line 104 of file DataMixingEMDigiWorker.h.

Constructor & Destructor Documentation

DataMixingEMDigiWorker() [1/2]

DataMixingEMDigiWorker::DataMixingEMDigiWorker

(

)

Definition at line 26 of file DataMixingEMDigiWorker.cc.

{}

DataMixingEMDigiWorker() [2/2]

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

explicit

standard constructor

Definition at line 29 of file DataMixingEMDigiWorker.cc.

References EBDigiCollectionDM_, EBDigiPileToken_, EBDigiToken_, EBPileInputTag_, EBProducerSig_, EEDigiCollectionDM_, EEDigiPileToken_, EEDigiToken_, EEPileInputTag_, EEProducerSig_, ESDigiCollectionDM_, ESDigiPileToken_, ESDigiToken_, ESPileInputTag_, ESProducerSig_, edm::ParameterSet::getParameter(), grToken_, pedToken_, 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");

    pedToken_ = iC.esConsumes<EcalPedestals, EcalPedestalsRcd>();
    grToken_ = iC.esConsumes<EcalGainRatios, EcalGainRatiosRcd>();
  }

~DataMixingEMDigiWorker()

DataMixingEMDigiWorker::~DataMixingEMDigiWorker ( )

virtual

Default destructor

Definition at line 64 of file DataMixingEMDigiWorker.cc.

{}

Member Function Documentation

addEMPileups()

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

Definition at line 148 of file DataMixingEMDigiWorker.cc.

References edm::DataFrameContainer::begin(), EBDigiStorage_, EBPileInputTag_, EEDigiStorage_, EEPileInputTag_, edm::DataFrameContainer::end(), ecalHexDisplay_cfg::ep, ESDigiStorage_, ESPileInputTag_, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, 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
      }
    }
  }

addEMSignals()

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

Definition at line 66 of file DataMixingEMDigiWorker.cc.

References edm::DataFrameContainer::begin(), MillePedeFileConverter_cfg::e, EBDigiStorage_, EBDigiToken_, EEDigiStorage_, EEDigiToken_, edm::DataFrameContainer::end(), ESDigiStorage_, ESDigiToken_, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, 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

GetGainRatios()

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 554 of file DataMixingEMDigiWorker.cc.

References ALCARECOPPSCalTrackBasedSel_cff::detid, EcalMGPAGainRatio::gain12Over6(), EcalMGPAGainRatio::gain6Over1(), edm::EventSetup::getHandle(), and grToken_.

Referenced by putEM().

                                                                                                          {
    std::vector<float> gainRatios(3);
    // get gain ratios
    const auto &grHandle = ES.getHandle(grToken_);
    EcalMGPAGainRatio theRatio = (*grHandle)[detid];

    gainRatios[0] = 1.;
    gainRatios[1] = theRatio.gain12Over6();
    gainRatios[2] = theRatio.gain6Over1() * theRatio.gain12Over6();

    return gainRatios;
  }

GetPedestals()

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 528 of file DataMixingEMDigiWorker.cc.

References ALCARECOPPSCalTrackBasedSel_cff::detid, EcalCondObjectContainer< T >::end(), EcalCondObjectContainer< T >::find(), edm::EventSetup::getHandle(), EcalCondObjectContainer< T >::getMap(), and pedToken_.

Referenced by putEM().

                                                                                                         {
    std::vector<float> pedeStals(3);

    // get pedestals
    const auto &pedHandle = ES.getHandle(pedToken_);

    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;
  }

putEM()

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

Definition at line 226 of file DataMixingEMDigiWorker.cc.

References gpuClustering::adc, edm::DataFrame::begin(), data, MillePedeFileConverter_cfg::e, EBDigiCollectionDM_, EBDigiStorage_, EEDigiCollectionDM_, EEDigiStorage_, ESDigiCollectionDM_, ESDigiStorage_, EcalDataFrame::frame(), ecalLiteDTU::gainId(), GetGainRatios(), GetPedestals(), createfilelist::int, WZElectronSkims53X_cff::max, SiStripPI::min, eostools::move(), ecalGpuTask_cfi::sample, ESDataFrame::setSample(), EcalDataFrame::setSample(), ESDataFrame::size(), and EcalDataFrame::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();
  }

Member Data Documentation

EBDigiCollectionDM_

std::string edm::DataMixingEMDigiWorker::EBDigiCollectionDM_

private

Definition at line 95 of file DataMixingEMDigiWorker.h.

Referenced by DataMixingEMDigiWorker(), and putEM().

EBdigiCollectionSig_

edm::InputTag edm::DataMixingEMDigiWorker::EBdigiCollectionSig_

private

Definition at line 76 of file DataMixingEMDigiWorker.h.

EBDigiPileToken_

edm::EDGetTokenT<EBDigiCollection> edm::DataMixingEMDigiWorker::EBDigiPileToken_

private

Definition at line 91 of file DataMixingEMDigiWorker.h.

Referenced by DataMixingEMDigiWorker().

EBDigiStorage_

EBDigiMap edm::DataMixingEMDigiWorker::EBDigiStorage_

private

Definition at line 106 of file DataMixingEMDigiWorker.h.

Referenced by addEMPileups(), addEMSignals(), and putEM().

EBDigiToken_

edm::EDGetTokenT<EBDigiCollection> edm::DataMixingEMDigiWorker::EBDigiToken_

private

Definition at line 87 of file DataMixingEMDigiWorker.h.

Referenced by addEMSignals(), and DataMixingEMDigiWorker().

EBPileInputTag_

edm::InputTag edm::DataMixingEMDigiWorker::EBPileInputTag_

private

Definition at line 83 of file DataMixingEMDigiWorker.h.

Referenced by addEMPileups(), and DataMixingEMDigiWorker().

EBProducerSig_

edm::InputTag edm::DataMixingEMDigiWorker::EBProducerSig_

private

Definition at line 72 of file DataMixingEMDigiWorker.h.

Referenced by DataMixingEMDigiWorker().

EEDigiCollectionDM_

std::string edm::DataMixingEMDigiWorker::EEDigiCollectionDM_

private

Definition at line 97 of file DataMixingEMDigiWorker.h.

Referenced by DataMixingEMDigiWorker(), and putEM().

EEdigiCollectionSig_

edm::InputTag edm::DataMixingEMDigiWorker::EEdigiCollectionSig_

private

Definition at line 78 of file DataMixingEMDigiWorker.h.

EEDigiPileToken_

edm::EDGetTokenT<EEDigiCollection> edm::DataMixingEMDigiWorker::EEDigiPileToken_

private

Definition at line 92 of file DataMixingEMDigiWorker.h.

Referenced by DataMixingEMDigiWorker().

EEDigiStorage_

EEDigiMap edm::DataMixingEMDigiWorker::EEDigiStorage_

private

Definition at line 107 of file DataMixingEMDigiWorker.h.

Referenced by addEMPileups(), addEMSignals(), and putEM().

EEDigiToken_

edm::EDGetTokenT<EEDigiCollection> edm::DataMixingEMDigiWorker::EEDigiToken_

private

Definition at line 88 of file DataMixingEMDigiWorker.h.

Referenced by addEMSignals(), and DataMixingEMDigiWorker().

EEPileInputTag_

edm::InputTag edm::DataMixingEMDigiWorker::EEPileInputTag_

private

Definition at line 84 of file DataMixingEMDigiWorker.h.

Referenced by addEMPileups(), and DataMixingEMDigiWorker().

EEProducerSig_

edm::InputTag edm::DataMixingEMDigiWorker::EEProducerSig_

private

Definition at line 73 of file DataMixingEMDigiWorker.h.

Referenced by DataMixingEMDigiWorker().

ESDigiCollectionDM_

std::string edm::DataMixingEMDigiWorker::ESDigiCollectionDM_

private

Definition at line 99 of file DataMixingEMDigiWorker.h.

Referenced by DataMixingEMDigiWorker(), and putEM().

ESdigiCollectionSig_

edm::InputTag edm::DataMixingEMDigiWorker::ESdigiCollectionSig_

private

Definition at line 80 of file DataMixingEMDigiWorker.h.

ESDigiPileToken_

edm::EDGetTokenT<ESDigiCollection> edm::DataMixingEMDigiWorker::ESDigiPileToken_

private

Definition at line 93 of file DataMixingEMDigiWorker.h.

Referenced by DataMixingEMDigiWorker().

ESDigiStorage_

ESDigiMap edm::DataMixingEMDigiWorker::ESDigiStorage_

private

Definition at line 108 of file DataMixingEMDigiWorker.h.

Referenced by addEMPileups(), addEMSignals(), and putEM().

ESDigiToken_

edm::EDGetTokenT<ESDigiCollection> edm::DataMixingEMDigiWorker::ESDigiToken_

private

Definition at line 89 of file DataMixingEMDigiWorker.h.

Referenced by addEMSignals(), and DataMixingEMDigiWorker().

ESPileInputTag_

edm::InputTag edm::DataMixingEMDigiWorker::ESPileInputTag_

private

Definition at line 85 of file DataMixingEMDigiWorker.h.

Referenced by addEMPileups(), and DataMixingEMDigiWorker().

ESProducerSig_

edm::InputTag edm::DataMixingEMDigiWorker::ESProducerSig_

private

Definition at line 74 of file DataMixingEMDigiWorker.h.

Referenced by DataMixingEMDigiWorker().

grToken_

edm::ESGetToken<EcalGainRatios, EcalGainRatiosRcd> edm::DataMixingEMDigiWorker::grToken_

private

Definition at line 115 of file DataMixingEMDigiWorker.h.

Referenced by DataMixingEMDigiWorker(), and GetGainRatios().

label_

std::string edm::DataMixingEMDigiWorker::label_

private

Definition at line 112 of file DataMixingEMDigiWorker.h.

Referenced by Modules.SwitchProducer::__addParameter(), SequenceTypes.DummyModule::__repr__(), Modules.SwitchProducer::__setattr__(), Mixins._Labelable::_findDependencies(), and Mixins._Labelable::setLabel().

pedToken_

edm::ESGetToken<EcalPedestals, EcalPedestalsRcd> edm::DataMixingEMDigiWorker::pedToken_

private

Definition at line 114 of file DataMixingEMDigiWorker.h.

Referenced by DataMixingEMDigiWorker(), and GetPedestals().