Inheritance diagram for PreMixingSiPixelWorker:

Public Member Functions
void	addPileups (PileUpEventPrincipal const &, edm::EventSetup const &es) override

void	addSignals (edm::Event const &e, edm::EventSetup const &es) override

void	initializeEvent (edm::Event const &e, edm::EventSetup const &c) override

	PreMixingSiPixelWorker (const edm::ParameterSet &ps, edm::ProducesCollector, edm::ConsumesCollector &&iC)

void	put (edm::Event &e, edm::EventSetup const &iSetup, std::vector< PileupSummaryInfo > const &ps, int bs) override

	~PreMixingSiPixelWorker () override=default

Public Member Functions inherited from PreMixingWorker
virtual void	beginLuminosityBlock (edm::LuminosityBlock const &iLumi, edm::EventSetup const &iSetup)

virtual void	beginRun (edm::Run const &iRun, edm::EventSetup const &iSetup)

virtual void	endRun ()

virtual void	finalizeBunchCrossing (edm::Event &iEvent, edm::EventSetup const &iSetup, int bunchCrossing)

virtual void	initializeBunchCrossing (edm::Event const &iEvent, edm::EventSetup const &iSetup, int bunchCrossing)

	PreMixingWorker ()=default

virtual	~PreMixingWorker ()=default

Private Types
typedef int	Amplitude

typedef std::multimap< int, PixelDigi >	OneDetectorMap

typedef std::map< uint32_t, OneDetectorMap >	SiGlobalIndex

typedef std::map< int, Amplitude, std::less< int > >	signal_map_type

typedef std::map< uint32_t, signal_map_type >	signalMaps

Private Attributes
SiPixelDigitizerAlgorithm	digitizer_

bool	firstFinalizeEvent_ = true

bool	firstInitializeEvent_ = true

const edm::ESGetToken < TrackerGeometry, TrackerDigiGeometryRecord >	pDDToken_

edm::InputTag	pixeldigi_collectionPile_

edm::InputTag	pixeldigi_collectionSig_

std::string	PixelDigiCollectionDM_

edm::EDGetTokenT < edm::DetSetVector< PixelDigi > >	PixelDigiPToken_

edm::EDGetTokenT < edm::DetSetVector< PixelDigi > >	PixelDigiToken_

SiGlobalIndex	SiHitStorage_

const edm::ESGetToken < TrackerTopology, TrackerTopologyRcd >	tTopoToken_

Detailed Description

Definition at line 40 of file PreMixingSiPixelWorker.cc.

Member Typedef Documentation

typedef int PreMixingSiPixelWorker::Amplitude

private

Definition at line 65 of file PreMixingSiPixelWorker.cc.

typedef std::multimap<int, PixelDigi> PreMixingSiPixelWorker::OneDetectorMap

private

Definition at line 70 of file PreMixingSiPixelWorker.cc.

typedef std::map<uint32_t, OneDetectorMap> PreMixingSiPixelWorker::SiGlobalIndex

private

Definition at line 71 of file PreMixingSiPixelWorker.cc.

typedef std::map<int, Amplitude, std::less<int> > PreMixingSiPixelWorker::signal_map_type

private

Definition at line 66 of file PreMixingSiPixelWorker.cc.

typedef std::map<uint32_t, signal_map_type> PreMixingSiPixelWorker::signalMaps

private

Definition at line 67 of file PreMixingSiPixelWorker.cc.

Constructor & Destructor Documentation

PreMixingSiPixelWorker::PreMixingSiPixelWorker	(	const edm::ParameterSet &	ps,
		edm::ProducesCollector	producesCollector,
		edm::ConsumesCollector &&	iC
	)

Definition at line 80 of file PreMixingSiPixelWorker.cc.

References edm::ParameterSet::getParameter(), pixeldigi_collectionPile_, pixeldigi_collectionSig_, PixelDigiCollectionDM_, PixelDigiPToken_, PixelDigiToken_, edm::ProducesCollector::produces(), SiHitStorage_, and AlCaHLTBitMon_QueryRunRegistry::string.

     : tTopoToken_(iC.esConsumes()),
       pDDToken_(iC.esConsumes(edm::ESInputTag("", ps.getParameter<std::string>("PixGeometryType")))),
       digitizer_(ps, iC) {
   // declare the products to produce
 
   pixeldigi_collectionSig_ = ps.getParameter<edm::InputTag>("pixeldigiCollectionSig");
   pixeldigi_collectionPile_ = ps.getParameter<edm::InputTag>("pixeldigiCollectionPile");
   PixelDigiCollectionDM_ = ps.getParameter<std::string>("PixelDigiCollectionDM");
 
   PixelDigiToken_ = iC.consumes<edm::DetSetVector<PixelDigi>>(pixeldigi_collectionSig_);
   PixelDigiPToken_ = iC.consumes<edm::DetSetVector<PixelDigi>>(pixeldigi_collectionPile_);
 
   producesCollector.produces<edm::DetSetVector<PixelDigi>>(PixelDigiCollectionDM_);
   producesCollector.produces<PixelFEDChannelCollection>(PixelDigiCollectionDM_);
 
   // clear local storage for this event
   SiHitStorage_.clear();
 }

PreMixingSiPixelWorker::~PreMixingSiPixelWorker ( )

overridedefault

Member Function Documentation

void PreMixingSiPixelWorker::addPileups	(	PileUpEventPrincipal const &	pep,
		edm::EventSetup const &	es
	)

overridevirtual

Implements PreMixingWorker.

Definition at line 143 of file PreMixingSiPixelWorker.cc.

References SplitLinear::begin, PileUpEventPrincipal::bunchCrossing(), dataset::end, PileUpEventPrincipal::getByLabel(), edm::EventPrincipal::id(), input, edm::HandleBase::isValid(), LogDebug, pixeldigi_collectionPile_, PileUpEventPrincipal::principal(), and SiHitStorage_.

                                                                                                 {
   LogDebug("PreMixingSiPixelWorker") << "\n===============> adding pileups from event  " << pep.principal().id()
                                      << " for bunchcrossing " << pep.bunchCrossing();
 
   // fill in maps of hits; same code as addSignals, except now applied to the pileup events
 
   edm::Handle<edm::DetSetVector<PixelDigi>> inputHandle;
   pep.getByLabel(pixeldigi_collectionPile_, inputHandle);
 
   if (inputHandle.isValid()) {
     const auto& input = *inputHandle;
 
     //loop on all detsets (detectorIDs) inside the input collection
     edm::DetSetVector<PixelDigi>::const_iterator DSViter = input.begin();
     for (; DSViter != input.end(); DSViter++) {
 #ifdef DEBUG
       LogDebug("PreMixingSiPixelWorker") << "Pileups: Processing DetID " << DSViter->id;
 #endif
 
       uint32_t detID = DSViter->id;
       edm::DetSet<PixelDigi>::const_iterator begin = (DSViter->data).begin();
       edm::DetSet<PixelDigi>::const_iterator end = (DSViter->data).end();
       edm::DetSet<PixelDigi>::const_iterator icopy;
 
       // find correct local map (or new one) for this detector ID
 
       SiGlobalIndex::const_iterator itest;
 
       itest = SiHitStorage_.find(detID);
 
       if (itest != SiHitStorage_.end()) {  // this detID already has hits, add to existing map
 
         OneDetectorMap LocalMap = itest->second;
 
         // fill in local map with extra channels
         for (icopy = begin; icopy != end; icopy++) {
           LocalMap.insert(OneDetectorMap::value_type((icopy->channel()), *icopy));
         }
 
         SiHitStorage_[detID] = LocalMap;
 
       } else {  // fill local storage with this information, put in global collection
 
         OneDetectorMap LocalMap;
 
         for (icopy = begin; icopy != end; icopy++) {
           LocalMap.insert(OneDetectorMap::value_type((icopy->channel()), *icopy));
         }
 
         SiHitStorage_.insert(SiGlobalIndex::value_type(detID, LocalMap));
       }
     }
   }
 }

void PreMixingSiPixelWorker::addSignals	(	edm::Event const &	e,
		edm::EventSetup const &	es
	)

overridevirtual

Implements PreMixingWorker.

Definition at line 112 of file PreMixingSiPixelWorker.cc.

References SplitLinear::begin, dataset::end, edm::Event::getByToken(), edm::EventBase::id(), input, LogDebug, PixelDigiToken_, and SiHitStorage_.

                                                                                   {
   // fill in maps of hits
 
   LogDebug("PreMixingSiPixelWorker") << "===============> adding MC signals for " << e.id();
 
   edm::Handle<edm::DetSetVector<PixelDigi>> input;
 
   if (e.getByToken(PixelDigiToken_, input)) {
     //loop on all detsets (detectorIDs) inside the input collection
     edm::DetSetVector<PixelDigi>::const_iterator DSViter = input->begin();
     for (; DSViter != input->end(); DSViter++) {
 #ifdef DEBUG
       LogDebug("PreMixingSiPixelWorker") << "Processing DetID " << DSViter->id;
 #endif
 
       uint32_t detID = DSViter->id;
       edm::DetSet<PixelDigi>::const_iterator begin = (DSViter->data).begin();
       edm::DetSet<PixelDigi>::const_iterator end = (DSViter->data).end();
       edm::DetSet<PixelDigi>::const_iterator icopy;
 
       OneDetectorMap LocalMap;
 
       for (icopy = begin; icopy != end; icopy++) {
         LocalMap.insert(OneDetectorMap::value_type((icopy->channel()), *icopy));
       }
 
       SiHitStorage_.insert(SiGlobalIndex::value_type(detID, LocalMap));
     }
   }
 }  // end of addSiPixelSignals

void PreMixingSiPixelWorker::initializeEvent	(	edm::Event const &	e,
		edm::EventSetup const &	c
	)

overridevirtual

Implements PreMixingWorker.

Definition at line 104 of file PreMixingSiPixelWorker.cc.

References digitizer_, firstInitializeEvent_, SiPixelDigitizerAlgorithm::init(), and SiPixelDigitizerAlgorithm::initializeEvent().

                                                                                            {
   if (firstInitializeEvent_) {
     digitizer_.init(iSetup);
     firstInitializeEvent_ = false;
   }
   digitizer_.initializeEvent();
 }

void PreMixingSiPixelWorker::put	(	edm::Event &	e,
		edm::EventSetup const &	iSetup,
		std::vector< PileupSummaryInfo > const &	ps,
		int	bs
	)

overridevirtual

Implements PreMixingWorker.

Definition at line 198 of file PreMixingSiPixelWorker.cc.

References gpuClustering::adc, SiPixelDigitizerAlgorithm::calculateInstlumiFactor(), SiPixelDigitizerAlgorithm::chooseScenario(), SiPixelDigitizerAlgorithm::digitize(), digitizer_, Exception, firstFinalizeEvent_, edm::EventSetup::getData(), edm::RandomNumberGenerator::getEngine(), SiPixelDigitizerAlgorithm::init_DynIneffDB(), SiPixelDigitizerAlgorithm::killBadFEDChannels(), eostools::move(), pDDToken_, PixelDigiCollectionDM_, edm::Event::put(), SiPixelDigitizerAlgorithm::setSimAccumulator(), SiHitStorage_, edm::Event::streamID(), and tTopoToken_.

                                          {
   // collection of Digis to put in the event
 
   std::vector<edm::DetSet<PixelDigi>> vPixelDigi;
 
   // loop through our collection of detectors, merging hits and putting new ones in the output
   signalMaps signal;
 
   // big loop over Detector IDs:
 
   for (SiGlobalIndex::const_iterator IDet = SiHitStorage_.begin(); IDet != SiHitStorage_.end(); IDet++) {
     uint32_t detID = IDet->first;
 
     OneDetectorMap LocalMap = IDet->second;
 
     signal_map_type Signals;
     Signals.clear();
 
     //counter variables
     int formerPixel = -1;
     int currentPixel;
     int ADCSum = 0;
 
     OneDetectorMap::const_iterator iLocalchk;
 
     for (OneDetectorMap::const_iterator iLocal = LocalMap.begin(); iLocal != LocalMap.end(); ++iLocal) {
       currentPixel = iLocal->first;
 
       if (currentPixel == formerPixel) {  // we have to add these digis together
         ADCSum += (iLocal->second).adc();
       } else {
         if (formerPixel != -1) {  // ADC info stolen from SiStrips...
           if (ADCSum > 511)
             ADCSum = 255;
           else if (ADCSum > 253 && ADCSum < 512)
             ADCSum = 254;
 
           Signals.insert(std::make_pair(formerPixel, ADCSum));
         }
         // save pointers for next iteration
         formerPixel = currentPixel;
         ADCSum = (iLocal->second).adc();
       }
 
       iLocalchk = iLocal;
       if ((++iLocalchk) == LocalMap.end()) {  //make sure not to lose the last one
         if (ADCSum > 511)
           ADCSum = 255;
         else if (ADCSum > 253 && ADCSum < 512)
           ADCSum = 254;
         Signals.insert(std::make_pair(formerPixel, ADCSum));
       }
 
     }  // end of loop over one detector
 
     // stick this into the global vector of detector info
     signal.insert(std::make_pair(detID, Signals));
 
   }  // end of big loop over all detector IDs
 
   // put the collection of digis in the event
   edm::LogInfo("PreMixingSiPixelWorker") << "total # Merged Pixels: " << signal.size();
 
   std::vector<edm::DetSet<PixelDigi>> theDigiVector;
 
   // Load inefficiency constants (1st pass), set pileup information.
   if (firstFinalizeEvent_) {
     digitizer_.init_DynIneffDB(iSetup);
     firstFinalizeEvent_ = false;
   }
 
   digitizer_.calculateInstlumiFactor(ps, bs);
   digitizer_.setSimAccumulator(signal);
 
   edm::Service<edm::RandomNumberGenerator> rng;
   CLHEP::HepRandomEngine* engine = &rng->getEngine(e.streamID());
 
   auto const& pDD = iSetup.getData(pDDToken_);
   const TrackerTopology* tTopo = &iSetup.getData(tTopoToken_);
 
   if (digitizer_.killBadFEDChannels()) {
     std::unique_ptr<PixelFEDChannelCollection> PixelFEDChannelCollection_ = digitizer_.chooseScenario(ps, engine);
     if (PixelFEDChannelCollection_ == nullptr) {
       throw cms::Exception("NullPointerError") << "PixelFEDChannelCollection not set in chooseScenario function.\n";
     }
     e.put(std::move(PixelFEDChannelCollection_), PixelDigiCollectionDM_);
   }
 
   for (const auto& iu : pDD.detUnits()) {
     if (iu->type().isTrackerPixel()) {
       edm::DetSet<PixelDigi> collector(iu->geographicalId().rawId());
       edm::DetSet<PixelDigiSimLink> linkcollector(
           iu->geographicalId().rawId());  // ignored as DigiSimLinks are combined separately
 
       digitizer_.digitize(dynamic_cast<const PixelGeomDetUnit*>(iu), collector.data, linkcollector.data, tTopo, engine);
       if (!collector.data.empty()) {
         theDigiVector.push_back(std::move(collector));
       }
     }
   }
 
   e.put(std::make_unique<edm::DetSetVector<PixelDigi>>(theDigiVector), PixelDigiCollectionDM_);
 
   // clear local storage for this event
   SiHitStorage_.clear();
 }