#include <DataMixingSiPixelMCDigiWorker.h>

Classes
struct	PixelEfficiencies

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

void	addSiPixelSignals (const edm::Event &e)

	DataMixingSiPixelMCDigiWorker ()

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

void	init_DynIneffDB (const edm::EventSetup &, const unsigned int &)

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

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

void	setPileupInfo (const std::vector< PileupSummaryInfo > &ps, const int &bs)

virtual	~DataMixingSiPixelMCDigiWorker ()

Private Types
typedef int	Amplitude

typedef std::multimap< int, PixelDigi >	OneDetectorMap

typedef std::map< uint32_t, OneDetectorMap >	SiGlobalIndex

typedef signal_map_type::const_iterator	signal_map_const_iterator

typedef signal_map_type::iterator	signal_map_iterator

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

typedef std::map< uint32_t, signal_map_type >	signalMaps

Private Attributes
signalMaps	_signal

const bool	AddPixelInefficiency

bool	FirstCall_

const std::string	geometryType_

std::string	label_

const int	NumberOfBarrelLayers

const int	NumberOfEndcapDisks

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_

PixelEfficiencies	pixelEff_

SiGlobalIndex	SiHitStorage_

edm::ESHandle< SiPixelDynamicInefficiency >	SiPixelDynamicInefficiency_

Detailed Description

Definition at line 53 of file DataMixingSiPixelMCDigiWorker.h.

Member Typedef Documentation

typedef int edm::DataMixingSiPixelMCDigiWorker::Amplitude

private

Definition at line 132 of file DataMixingSiPixelMCDigiWorker.h.

typedef std::multimap<int, PixelDigi> edm::DataMixingSiPixelMCDigiWorker::OneDetectorMap

private

Definition at line 141 of file DataMixingSiPixelMCDigiWorker.h.

typedef std::map<uint32_t, OneDetectorMap> edm::DataMixingSiPixelMCDigiWorker::SiGlobalIndex

private

Definition at line 142 of file DataMixingSiPixelMCDigiWorker.h.

typedef signal_map_type::const_iterator edm::DataMixingSiPixelMCDigiWorker::signal_map_const_iterator

private

Definition at line 135 of file DataMixingSiPixelMCDigiWorker.h.

typedef signal_map_type::iterator edm::DataMixingSiPixelMCDigiWorker::signal_map_iterator

private

Definition at line 134 of file DataMixingSiPixelMCDigiWorker.h.

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

private

Definition at line 133 of file DataMixingSiPixelMCDigiWorker.h.

typedef std::map<uint32_t, signal_map_type> edm::DataMixingSiPixelMCDigiWorker::signalMaps

private

Definition at line 136 of file DataMixingSiPixelMCDigiWorker.h.

Constructor & Destructor Documentation

edm::DataMixingSiPixelMCDigiWorker::DataMixingSiPixelMCDigiWorker ( )

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

explicit

standard constructor

Definition at line 42 of file DataMixingSiPixelMCDigiWorker.cc.

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

                                                                                                                     : 
     label_(ps.getParameter<std::string>("Label")),
     geometryType_(ps.getParameter<std::string>("GeometryType")),
     // get external parameters:
     // To account for upgrade geometries do not assume the number 
     // of layers or disks.
     NumberOfBarrelLayers(ps.exists("NumPixelBarrel")?ps.getParameter<int>("NumPixelBarrel"):3),
     NumberOfEndcapDisks(ps.exists("NumPixelEndcap")?ps.getParameter<int>("NumPixelEndcap"):2),
     //theInstLumiScaleFactor(ps.getParameter<double>("theInstLumiScaleFactor")), //For dynamic inefficiency PU scaling
     //bunchScaleAt25(ps.getParameter<double>("bunchScaleAt25")), //For dynamic inefficiency bunchspace scaling
     // Control the pixel inefficiency
     AddPixelInefficiency(ps.getParameter<bool>("AddPixelInefficiency")),
     pixelEff_(ps, AddPixelInefficiency,NumberOfBarrelLayers,NumberOfEndcapDisks)
   {                                                         
 
     // 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
 
     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_);
 
     // clear local storage for this event                                                                     
     SiHitStorage_.clear();
 
     FirstCall_ = true;
 
   }

DataMixingSiPixelMCDigiWorker::~DataMixingSiPixelMCDigiWorker ( )

virtual

Default destructor

Definition at line 78 of file DataMixingSiPixelMCDigiWorker.cc.

78 {

79 }

Member Function Documentation

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

Definition at line 318 of file DataMixingSiPixelMCDigiWorker.cc.

References begin, edm::DetSetVector< T >::begin(), end, edm::DetSetVector< T >::end(), edm::EventPrincipal::id(), input, LogDebug, pixeldigi_collectionPile_, and SiHitStorage_.

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

                                                                                    {
   
     LogDebug("DataMixingSiPixelMCDigiWorker") <<"\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
 
     std::shared_ptr<Wrapper<edm::DetSetVector<PixelDigi> >  const> inputPTR =
       getProductByTag<edm::DetSetVector<PixelDigi> >(*ep, pixeldigi_collectionPile_, mcc);
 
     if(inputPTR ) {
 
       const edm::DetSetVector<PixelDigi>  *input = const_cast< edm::DetSetVector<PixelDigi> * >(inputPTR->product());
 
 
 
       //   Handle< edm::DetSetVector<PixelDigi> >  input;
 
       //   if( e->getByLabel(pixeldigi_collectionPile_,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("DataMixingSiPixelMCDigiWorker")  << "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 DataMixingSiPixelMCDigiWorker::addSiPixelSignals ( const edm::Event & e )

Definition at line 282 of file DataMixingSiPixelMCDigiWorker.cc.

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

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

                                                                          { 
     // fill in maps of hits
 
     LogDebug("DataMixingSiPixelMCDigiWorker")<<"===============> adding MC signals for "<<e.id();
 
     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("DataMixingSiPixelMCDigiWorker")  << "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 DataMixingSiPixelMCDigiWorker::init_DynIneffDB	(	const edm::EventSetup &	es,
		const unsigned int &	bunchspace
	)

Definition at line 217 of file DataMixingSiPixelMCDigiWorker.cc.

References AddPixelInefficiency, edm::DataMixingSiPixelMCDigiWorker::PixelEfficiencies::FromConfig, edm::EventSetup::get(), edm::DataMixingSiPixelMCDigiWorker::PixelEfficiencies::init_from_db(), pDD, pixelEff_, and SiPixelDynamicInefficiency_.

Referenced by putSiPixel().

                                                                                                           {
   if (AddPixelInefficiency&&!pixelEff_.FromConfig) {
     if (bunchspace == 50) es.get<SiPixelDynamicInefficiencyRcd>().get("50ns",SiPixelDynamicInefficiency_);
     else es.get<SiPixelDynamicInefficiencyRcd>().get(SiPixelDynamicInefficiency_);
     pixelEff_.init_from_db(pDD, SiPixelDynamicInefficiency_);
   }
 }

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

virtual

Definition at line 83 of file DataMixingSiPixelMCDigiWorker.cc.

References geometryType_, edm::EventSetup::get(), and pDD.

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

                                                                                                     {   
 
     iSetup.get<TrackerDigiGeometryRecord>().get(geometryType_, pDD); 
     //edm::ESHandle<TrackerTopology> tTopoHand;
     //iSetup.get<IdealGeometryRecord>().get(tTopoHand);
     //const TrackerTopology *tTopo=tTopoHand.product();
   }                    

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

Definition at line 386 of file DataMixingSiPixelMCDigiWorker.cc.

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

                                                                                                                                     {
 
     // 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
 
     _signal.clear();
 
     // 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));
         //PixelDigi aHit(formerPixel, ADCSum);
         //SPD.push_back( aHit );      
       }
       // 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));
       //SPD.push_back( PixelDigi(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   
     LogInfo("DataMixingSiPixelMCDigiWorker") << "total # Merged Pixels: " << _signal.size() ;
 
     // Now, we have to run Lumi-Dependent efficiency calculation on the merged pixels.
     // This is the only place where we have the PreMixed pileup information so that we can calculate
     // the instantaneous luminosity and do the dynamic inefficiency.
 
     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();
 
     // Load inefficiency constants (1st pass), set pileup information.
 
     if(FirstCall_) {
       init_DynIneffDB(iSetup, bs);
       FirstCall_ = false;
     }
 
     setPileupInfo(ps, bs);
 
     for( const auto& iu : pDD->detUnits()) {
       
       if(iu->type().isTrackerPixel()) {
 
     //
     const PixelGeomDetUnit* pixdet = dynamic_cast<const PixelGeomDetUnit*>(iu);
     uint32_t detID = pixdet->geographicalId().rawId();
 
     // fetch merged hits for this detID
 
     signal_map_type& theSignal = _signal[detID];
 
     // if we have some hits...
     if(!theSignal.empty()) {
 
       edm::DetSet<PixelDigi> SPD(detID);  // make empty vector with this detID so we can push back digis at the end 
 
       const PixelTopology* topol=&pixdet->specificTopology();
       int numColumns = topol->ncolumns();  // det module number of cols&rows
       int numRows = topol->nrows();
 
       // do inefficiency calculation, drop some pixel hits
 
       // Predefined efficiencies
       double pixelEfficiency  = 1.0;
       double columnEfficiency = 1.0;
       double chipEfficiency   = 1.0;
 
       if (pixelEff_.FromConfig) {
         // setup the chip indices conversion
         if    (pixdet->subDetector()==GeomDetEnumerators::SubDetector::PixelBarrel ||
            pixdet->subDetector()==GeomDetEnumerators::SubDetector::P1PXB ||
                    pixdet->subDetector()==GeomDetEnumerators::SubDetector::P2PXB){// barrel layers
           int layerIndex=tTopo->layer(detID);
           pixelEfficiency  = pixelEff_.thePixelEfficiency[layerIndex-1];
           columnEfficiency = pixelEff_.thePixelColEfficiency[layerIndex-1];
           chipEfficiency   = pixelEff_.thePixelChipEfficiency[layerIndex-1];
           //std::cout <<"Using BPix columnEfficiency = "<<columnEfficiency<< " for layer = "<<layerIndex <<"\n";
           // This should never happen, but only check if it is not an upgrade geometry
           if (NumberOfBarrelLayers==3){
         if(numColumns>416)  LogWarning ("Pixel Geometry") <<" wrong columns in barrel "<<numColumns;
         if(numRows>160)  LogWarning ("Pixel Geometry") <<" wrong rows in barrel "<<numRows;
         
         int ladder=tTopo->pxbLadder(detID);
         int module=tTopo->pxbModule(detID);
         if (module<=4) module=5-module;
         else module-=4;
         
         columnEfficiency *= pixelEff_.theLadderEfficiency_BPix[layerIndex-1][ladder-1]*pixelEff_.theModuleEfficiency_BPix[layerIndex-1][module-1]*pixelEff_.pu_scale[layerIndex-1];
           }
         } else if(pixdet->subDetector()==GeomDetEnumerators::SubDetector::PixelEndcap ||
               pixdet->subDetector()==GeomDetEnumerators::SubDetector::P1PXEC ||
               pixdet->subDetector()==GeomDetEnumerators::SubDetector::P2PXEC){                // forward disks
     
           unsigned int diskIndex=tTopo->layer(detID)+pixelEff_.FPixIndex; // Use diskIndex-1 later to stay consistent with BPix
           unsigned int panelIndex=tTopo->pxfPanel(detID);
           unsigned int moduleIndex=tTopo->pxfModule(detID);
           //if (pixelEff_.FPixIndex>diskIndex-1){throw cms::Exception("Configuration") <<"SiPixelDigitizer is using the wrong efficiency value. index = "
           //                                                                       <<diskIndex-1<<" , MinIndex = "<<pixelEff_.FPixIndex<<" ... "<<tTopo->pxfDisk(detID);}
           pixelEfficiency  = pixelEff_.thePixelEfficiency[diskIndex-1];
           columnEfficiency = pixelEff_.thePixelColEfficiency[diskIndex-1];
           chipEfficiency   = pixelEff_.thePixelChipEfficiency[diskIndex-1];
           //std::cout <<"Using FPix columnEfficiency = "<<columnEfficiency<<" for Disk = "<< tTopo->pxfDisk(detID)<<"\n";
           // Sometimes the forward pixels have wrong size,
           // this crashes the index conversion, so exit, but only check if it is not an upgrade geometry
           if (NumberOfBarrelLayers==3){  // whether it is the present or the phase 1 detector can be checked using GeomDetEnumerators::SubDetector
         if(numColumns>260 || numRows>160) {
           if(numColumns>260)  LogWarning ("Pixel Geometry") <<" wrong columns in endcaps "<<numColumns;
           if(numRows>160)  LogWarning ("Pixel Geometry") <<" wrong rows in endcaps "<<numRows;
           return;
         }
         if ((panelIndex==1 && (moduleIndex==1 || moduleIndex==2)) || (panelIndex==2 && moduleIndex==1)) { //inner modules
           columnEfficiency*=pixelEff_.theInnerEfficiency_FPix[diskIndex-1]*pixelEff_.pu_scale[3];
         } else { //outer modules
           columnEfficiency*=pixelEff_.theOuterEfficiency_FPix[diskIndex-1]*pixelEff_.pu_scale[4];
         }
           } // current detector, forward
         } else if(pixdet->subDetector()==GeomDetEnumerators::SubDetector::P2OTB ||pixdet->subDetector()==GeomDetEnumerators::SubDetector::P2OTEC) {
           // If phase 2 outer tracker, hardcoded values as they have been so far
           pixelEfficiency  = 0.999;
           columnEfficiency = 0.999;
           chipEfficiency   = 0.999;
         } // if barrel/forward
       } else { // Load precomputed factors from Database
         pixelEfficiency  = pixelEff_.PixelGeomFactors.at(detID);
         columnEfficiency = pixelEff_.ColGeomFactors.at(detID)*pixelEff_.pu_scale[pixelEff_.iPU.at(detID)];
         chipEfficiency   = pixelEff_.ChipGeomFactors.at(detID);
       }
   
 #ifdef TP_DEBUG
       LogDebug ("Pixel Digitizer") << " enter pixel_inefficiency " << pixelEfficiency << " "
                        << columnEfficiency << " " << chipEfficiency;
 #endif
   
       // Initilize the index converter
       //PixelIndices indexConverter(numColumns,numRows);
       std::unique_ptr<PixelIndices> pIndexConverter(new PixelIndices(numColumns,numRows));
 
 
       int chipIndex = 0;
       int rowROC = 0;
       int colROC = 0;
       std::map<int, int, std::less<int> >chips, columns;
       std::map<int, int, std::less<int> >::iterator iter;
   
       // Find out the number of columns and rocs hits
       // Loop over hit pixels, amplitude in electrons, channel = coded row,col
       for (signal_map_const_iterator i = theSignal.begin(); i != theSignal.end(); ++i) {
     
         int chan = i->first;
         std::pair<int,int> ip = PixelDigi::channelToPixel(chan);
         int row = ip.first;  // X in row
         int col = ip.second; // Y is in col
         //transform to ROC index coordinates
         pIndexConverter->transformToROC(col,row,chipIndex,colROC,rowROC);
         int dColInChip = pIndexConverter->DColumn(colROC); // get ROC dcol from ROC col
         //dcol in mod
         int dColInDet = pIndexConverter->DColumnInModule(dColInChip,chipIndex);
     
         chips[chipIndex]++;
         columns[dColInDet]++;
       }
   
       // Delete some ROC hits.
       for ( iter = chips.begin(); iter != chips.end() ; iter++ ) {
         //float rand  = RandFlat::shoot();
         float rand  = CLHEP::RandFlat::shoot(engine);
         if( rand > chipEfficiency ) chips[iter->first]=0;
       }
   
       // Delete some Dcol hits.
       for ( iter = columns.begin(); iter != columns.end() ; iter++ ) {
         //float rand  = RandFlat::shoot();
         float rand  = CLHEP::RandFlat::shoot(engine);
         if( rand > columnEfficiency ) columns[iter->first]=0;
       }
   
       // Now loop again over pixels to kill some of them.
       // Loop over hit pixels, amplitude in electrons, channel = coded row,col
       for(signal_map_iterator i = theSignal.begin();i != theSignal.end(); ++i) {
     
         //    int chan = i->first;
         std::pair<int,int> ip = PixelDigi::channelToPixel(i->first);//get pixel pos
         int row = ip.first;  // X in row
         int col = ip.second; // Y is in col
         //transform to ROC index coordinates
         pIndexConverter->transformToROC(col,row,chipIndex,colROC,rowROC);
         int dColInChip = pIndexConverter->DColumn(colROC); //get ROC dcol from ROC col
         //dcol in mod
         int dColInDet = pIndexConverter->DColumnInModule(dColInChip,chipIndex);
     
         //float rand  = RandFlat::shoot();
         float rand  = CLHEP::RandFlat::shoot(engine);
         if( chips[chipIndex]==0 || columns[dColInDet]==0
         || rand>pixelEfficiency ) {
           // make pixel amplitude =0, pixel will be lost at clusterization
           i->second=(0.); // reset amplitude
         } // end if
         //Make a new Digi:
 
         // Don't put in digis that have been killed:
         if(i->second > 0.) {
           SPD.push_back( PixelDigi(i->first, i->second) );     
         }
       } // end pixel loop
       // push back vector here of one detID
       
       vPixelDigi.push_back(SPD);
     }
       }
     }// end of loop over detectors
 
     // make new digi collection
     
     std::unique_ptr< edm::DetSetVector<PixelDigi> > MyPixelDigis(new edm::DetSetVector<PixelDigi>(vPixelDigi) );
 
     // put collection
 
     e.put(std::move(MyPixelDigis), PixelDigiCollectionDM_ );
 
     // clear local storage for this event
     SiHitStorage_.clear();
   }

void DataMixingSiPixelMCDigiWorker::setPileupInfo	(	const std::vector< PileupSummaryInfo > &	ps,
		const int &	bs
	)

Definition at line 660 of file DataMixingSiPixelMCDigiWorker.cc.

References mps_fire::i, gen::n, AlCaHLTBitMon_ParallelJobs::p, pixelEff_, edm::DataMixingSiPixelMCDigiWorker::PixelEfficiencies::pu_scale, edm::DataMixingSiPixelMCDigiWorker::PixelEfficiencies::theInstLumiScaleFactor, and edm::DataMixingSiPixelMCDigiWorker::PixelEfficiencies::thePUEfficiency.

Referenced by putSiPixel().

                                                                                                                  {
 
   //double bunchScale=1.0;
   //if (bunchSpacing==25) bunchScale=bunchScaleAt25;
   
   int p = -1;
   for ( unsigned int i=0; i<ps.size(); i++) 
     if ( ps[i].getBunchCrossing() == 0 ) 
       p=i;
 
   if ( p>=0 ) {
     for (size_t i=0, n = pixelEff_.thePUEfficiency.size(); i<n; i++) {
       double instlumi = ps[p].getTrueNumInteractions()*pixelEff_.theInstLumiScaleFactor;
       double instlumi_pow=1.;
       pixelEff_.pu_scale[i] = 0;
       for  (size_t j=0; j<pixelEff_.thePUEfficiency[i].size(); j++){
     pixelEff_.pu_scale[i]+=instlumi_pow*pixelEff_.thePUEfficiency[i][j];
     instlumi_pow*=instlumi;
       }
     }
   }
 
 } //this sets pu_scale