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::ProducerBase &producer, 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 std::string	geometryType_

edm::ESHandle< TrackerGeometry >	pDD

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_

Detailed Description

Definition at line 41 of file PreMixingSiPixelWorker.cc.

Member Typedef Documentation

typedef int PreMixingSiPixelWorker::Amplitude

private

Definition at line 66 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 67 of file PreMixingSiPixelWorker.cc.

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

private

Definition at line 68 of file PreMixingSiPixelWorker.cc.

Constructor & Destructor Documentation

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

Definition at line 82 of file PreMixingSiPixelWorker.cc.

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

                                                                                                                               :
   digitizer_(ps),
   geometryType_(ps.getParameter<std::string>("PixGeometryType"))
 {                                                         
   // 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_);
 
   producer.produces< edm::DetSetVector<PixelDigi> > (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 150 of file PreMixingSiPixelWorker.cc.

References begin, PileUpEventPrincipal::bunchCrossing(), 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 114 of file PreMixingSiPixelWorker.cc.

References begin, 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 103 of file PreMixingSiPixelWorker.cc.

References digitizer_, firstInitializeEvent_, geometryType_, edm::EventSetup::get(), SiPixelDigitizerAlgorithm::init(), SiPixelDigitizerAlgorithm::initializeEvent(), and pDD.

                                                                                            {    
   iSetup.get<TrackerDigiGeometryRecord>().get(geometryType_, pDD);
   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 210 of file PreMixingSiPixelWorker.cc.

References ecalMGPA::adc(), SiPixelDigitizerAlgorithm::calculateInstlumiFactor(), DEFINE_PREMIXING_WORKER, TrackerGeometry::detUnits(), SiPixelDigitizerAlgorithm::digitize(), digitizer_, firstFinalizeEvent_, edm::EventSetup::get(), edm::RandomNumberGenerator::getEngine(), SiPixelDigitizerAlgorithm::init_DynIneffDB(), eostools::move(), pDD, PixelDigiCollectionDM_, edm::ESHandle< T >::product(), edm::Event::put(), SiPixelDigitizerAlgorithm::setSimAccumulator(), SiHitStorage_, and edm::Event::streamID().

                                                                                                                          {
 
   // 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, bs);
     firstFinalizeEvent_ = false;
   }
 
   digitizer_.calculateInstlumiFactor(ps, bs);
   digitizer_.setSimAccumulator(signal);
 
   edm::Service<edm::RandomNumberGenerator> rng;
   CLHEP::HepRandomEngine* engine = &rng->getEngine(e.streamID());
 
   edm::ESHandle<TrackerTopology> tTopoHand;
   iSetup.get<TrackerTopologyRcd>().get(tTopoHand);
   const TrackerTopology *tTopo=tTopoHand.product();
   
   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();
 }