Inheritance diagram for PreMixingSiStripWorker:

Classes
class	StrictWeakOrdering

class	StrictWeakRawOrdering

Public Member Functions
void	addPileups (PileUpEventPrincipal const &pep, 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

	PreMixingSiStripWorker (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

	~PreMixingSiStripWorker () 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 float	Amplitude

typedef std::multimap< uint32_t, std::bitset< 6 > >	APVMap

typedef SiDigitalConverter::DigitalVecType	DigitalVecType

typedef std::vector< SiStripDigi >	OneDetectorMap

typedef std::vector< RawDigi >	OneDetectorRawMap

typedef std::pair< uint16_t, Amplitude >	RawDigi

typedef std::map< uint32_t, OneDetectorMap >	SiGlobalIndex

typedef std::map< uint32_t, OneDetectorRawMap >	SiGlobalRawIndex

typedef std::map< uint32_t, SignalMapType >	signalMaps

typedef std::map< int, Amplitude >	SignalMapType

Private Member Functions
void	DMinitializeDetUnit (StripGeomDetUnit const *det, const edm::EventSetup &iSetup)

const SignalMapType *	getSignal (uint32_t detID) const

Private Attributes
std::map< unsigned int, std::vector< bool > >	allBadChannels

std::map< unsigned int, std::vector< bool > >	allHIPChannels

const double	apv_fCPerElectron_

const double	apv_maxResponse_

const double	apv_mVPerQ_

const double	apv_rate_

bool	APVSaturationFromHIP_

std::map< unsigned int, size_t >	firstChannelsWithSignal

const double	fracOfEventsToSimAPV_

std::string	gainLabel

std::string	geometryType

bool	includeAPVSimulation_

std::map< unsigned int, size_t >	lastChannelsWithSignal

edm::ESHandle< TrackerGeometry >	pDD

bool	peakMode

signalMaps	signals_

SiGlobalIndex	SiHitStorage_

bool	SingleStripNoise

SiGlobalRawIndex	SiRawDigis_

edm::InputTag	SistripAPVLabelSig_

std::string	SistripAPVListDM_

edm::InputTag	SiStripAPVPileInputTag_

std::string	SiStripDigiCollectionDM_

edm::InputTag	SistripLabelSig_

edm::InputTag	SiStripPileInputTag_

APVMap	theAffectedAPVmap_

double	theElectronPerADC

int	theFedAlgo

std::unique_ptr< SiTrivialDigitalConverter >	theSiDigitalConverter

std::unique_ptr< SiGaussianTailNoiseAdder >	theSiNoiseAdder

std::unique_ptr< SiStripFedZeroSuppression >	theSiZeroSuppress

double	theThreshold

Detailed Description

Definition at line 45 of file PreMixingSiStripWorker.cc.

Member Typedef Documentation

◆ Amplitude

typedef float PreMixingSiStripWorker::Amplitude

private

Definition at line 70 of file PreMixingSiStripWorker.cc.

◆ APVMap

typedef std::multimap<uint32_t, std::bitset<6> > PreMixingSiStripWorker::APVMap

private

Definition at line 97 of file PreMixingSiStripWorker.cc.

◆ DigitalVecType

typedef SiDigitalConverter::DigitalVecType PreMixingSiStripWorker::DigitalVecType

private

Definition at line 77 of file PreMixingSiStripWorker.cc.

◆ OneDetectorMap

typedef std::vector<SiStripDigi> PreMixingSiStripWorker::OneDetectorMap

private

Definition at line 72 of file PreMixingSiStripWorker.cc.

◆ OneDetectorRawMap

typedef std::vector<RawDigi> PreMixingSiStripWorker::OneDetectorRawMap

private

Definition at line 73 of file PreMixingSiStripWorker.cc.

◆ RawDigi

typedef std::pair<uint16_t, Amplitude> PreMixingSiStripWorker::RawDigi

private

Definition at line 71 of file PreMixingSiStripWorker.cc.

◆ SiGlobalIndex

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

private

Definition at line 74 of file PreMixingSiStripWorker.cc.

◆ SiGlobalRawIndex

typedef std::map<uint32_t, OneDetectorRawMap> PreMixingSiStripWorker::SiGlobalRawIndex

private

Definition at line 75 of file PreMixingSiStripWorker.cc.

◆ signalMaps

typedef std::map<uint32_t, SignalMapType> PreMixingSiStripWorker::signalMaps

private

Definition at line 84 of file PreMixingSiStripWorker.cc.

◆ SignalMapType

typedef std::map<int, Amplitude> PreMixingSiStripWorker::SignalMapType

private

Definition at line 83 of file PreMixingSiStripWorker.cc.

Constructor & Destructor Documentation

◆ PreMixingSiStripWorker()

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

Definition at line 146 of file PreMixingSiStripWorker.cc.

     : gainLabel(ps.getParameter<std::string>("Gain")),
       SingleStripNoise(ps.getParameter<bool>("SingleStripNoise")),
       peakMode(ps.getParameter<bool>("APVpeakmode")),
       theThreshold(ps.getParameter<double>("NoiseSigmaThreshold")),
       theElectronPerADC(ps.getParameter<double>(peakMode ? "electronPerAdcPeak" : "electronPerAdcDec")),
       APVSaturationFromHIP_(ps.getParameter<bool>("APVSaturationFromHIP")),
       theFedAlgo(ps.getParameter<int>("FedAlgorithm_PM")),
       geometryType(ps.getParameter<std::string>("GeometryType")),
       theSiZeroSuppress(new SiStripFedZeroSuppression(theFedAlgo)),
       theSiDigitalConverter(new SiTrivialDigitalConverter(theElectronPerADC, false)),  // no premixing
       includeAPVSimulation_(ps.getParameter<bool>("includeAPVSimulation")),
       fracOfEventsToSimAPV_(ps.getParameter<double>("fracOfEventsToSimAPV")),
       apv_maxResponse_(ps.getParameter<double>("apv_maxResponse")),
       apv_rate_(ps.getParameter<double>("apv_rate")),
       apv_mVPerQ_(ps.getParameter<double>("apv_mVPerQ")),
       apv_fCPerElectron_(ps.getParameter<double>("apvfCPerElectron"))
  
 {
   // declare the products to produce
  
   SistripLabelSig_ = ps.getParameter<edm::InputTag>("SistripLabelSig");
   SiStripPileInputTag_ = ps.getParameter<edm::InputTag>("SiStripPileInputTag");
  
   SiStripDigiCollectionDM_ = ps.getParameter<std::string>("SiStripDigiCollectionDM");
   SistripAPVListDM_ = ps.getParameter<std::string>("SiStripAPVListDM");
  
   producesCollector.produces<edm::DetSetVector<SiStripDigi>>(SiStripDigiCollectionDM_);
   producesCollector.produces<bool>(SiStripDigiCollectionDM_ + "SimulatedAPVDynamicGain");
  
   if (APVSaturationFromHIP_) {
     SistripAPVLabelSig_ = ps.getParameter<edm::InputTag>("SistripAPVLabelSig");
     SiStripAPVPileInputTag_ = ps.getParameter<edm::InputTag>("SistripAPVPileInputTag");
     iC.consumes<std::vector<std::pair<int, std::bitset<6>>>>(SistripAPVLabelSig_);
   }
   iC.consumes<edm::DetSetVector<SiStripDigi>>(SistripLabelSig_);
   // clear local storage for this event
   SiHitStorage_.clear();
  
   edm::Service<edm::RandomNumberGenerator> rng;
   if (!rng.isAvailable()) {
     throw cms::Exception("Psiguration") << "SiStripDigitizer requires the RandomNumberGeneratorService\n"
                                            "which is not present in the psiguration file.  You must add the service\n"
                                            "in the configuration file or remove the modules that require it.";
   }
  
   theSiNoiseAdder.reset(new SiGaussianTailNoiseAdder(theThreshold));
 }

References APVSaturationFromHIP_, Exception, edm::ParameterSet::getParameter(), edm::Service< T >::isAvailable(), edm::ProducesCollector::produces(), SiHitStorage_, SistripAPVLabelSig_, SistripAPVListDM_, SiStripAPVPileInputTag_, SiStripDigiCollectionDM_, SistripLabelSig_, SiStripPileInputTag_, AlCaHLTBitMon_QueryRunRegistry::string, theSiNoiseAdder, and theThreshold.

◆ ~PreMixingSiStripWorker()

PreMixingSiStripWorker::~PreMixingSiStripWorker ( )

overridedefault

Member Function Documentation

◆ addPileups()

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

overridevirtual

Implements PreMixingWorker.

Definition at line 278 of file PreMixingSiStripWorker.cc.

                                                                                                 {
   LogDebug("PreMixingSiStripWorker") << "\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<SiStripDigi>> inputHandle;
   pep.getByLabel(SiStripPileInputTag_, inputHandle);
  
   if (inputHandle.isValid()) {
     const auto& input = *inputHandle;
  
     OneDetectorMap LocalMap;
  
     //loop on all detsets (detectorIDs) inside the input collection
     edm::DetSetVector<SiStripDigi>::const_iterator DSViter = input.begin();
     for (; DSViter != input.end(); DSViter++) {
 #ifdef DEBUG
       LogDebug("PreMixingSiStripWorker") << "Pileups: Processing DetID " << DSViter->id;
 #endif
  
       // find correct local map (or new one) for this detector ID
  
       SiGlobalIndex::const_iterator itest;
  
       itest = SiHitStorage_.find(DSViter->id);
  
       if (itest != SiHitStorage_.end()) {  // this detID already has hits, add to existing map
  
         LocalMap = itest->second;
  
         // fill in local map with extra channels
         LocalMap.insert(LocalMap.end(), (DSViter->data).begin(), (DSViter->data).end());
         std::stable_sort(LocalMap.begin(), LocalMap.end(), PreMixingSiStripWorker::StrictWeakOrdering());
         SiHitStorage_[DSViter->id] = LocalMap;
  
       } else {  // fill local storage with this information, put in global collection
  
         LocalMap.clear();
         LocalMap.reserve((DSViter->data).size());
         LocalMap.insert(LocalMap.end(), (DSViter->data).begin(), (DSViter->data).end());
  
         SiHitStorage_.insert(SiGlobalIndex::value_type(DSViter->id, LocalMap));
       }
     }
  
     if (APVSaturationFromHIP_) {
       edm::Handle<std::vector<std::pair<int, std::bitset<6>>>> inputAPVHandle;
       pep.getByLabel(SiStripAPVPileInputTag_, inputAPVHandle);
  
       if (inputAPVHandle.isValid()) {
         const auto& APVinput = inputAPVHandle;
  
         std::vector<std::pair<int, std::bitset<6>>>::const_iterator entry = APVinput->begin();
         for (; entry != APVinput->end(); entry++) {
           theAffectedAPVmap_.insert(APVMap::value_type(entry->first, entry->second));
         }
       }
     }
   }
 }

References APVSaturationFromHIP_, begin, PileUpEventPrincipal::bunchCrossing(), end, mps_splice::entry, PileUpEventPrincipal::getByLabel(), edm::EventPrincipal::id(), input, edm::HandleBase::isValid(), LogDebug, PileUpEventPrincipal::principal(), SiHitStorage_, SiStripAPVPileInputTag_, SiStripPileInputTag_, and theAffectedAPVmap_.

◆ addSignals()

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

overridevirtual

Implements PreMixingWorker.

Definition at line 240 of file PreMixingSiStripWorker.cc.

                                                                                   {
   // fill in maps of hits
  
   edm::Handle<edm::DetSetVector<SiStripDigi>> input;
  
   if (e.getByLabel(SistripLabelSig_, input)) {
     OneDetectorMap LocalMap;
  
     //loop on all detsets (detectorIDs) inside the input collection
     edm::DetSetVector<SiStripDigi>::const_iterator DSViter = input->begin();
     for (; DSViter != input->end(); DSViter++) {
 #ifdef DEBUG
       LogDebug("PreMixingSiStripWorker") << "Processing DetID " << DSViter->id;
 #endif
  
       LocalMap.clear();
       LocalMap.reserve((DSViter->data).size());
       LocalMap.insert(LocalMap.end(), (DSViter->data).begin(), (DSViter->data).end());
  
       SiHitStorage_.insert(SiGlobalIndex::value_type(DSViter->id, LocalMap));
     }
   }
  
   // keep here for future reference.  In current implementation, HIP killing is done once in PU file
   /*  if(APVSaturationFromHIP_) {
       edm::Handle<std::vector<std::pair<int,std::bitset<6>> > >  APVinput;
  
       if( e.getByLabel(SistripAPVLabelSig_,APVinput) ) {
  
       std::vector<std::pair<int,std::bitset<6>> >::const_iterator entry = APVinput->begin();
       for( ; entry != APVinput->end(); entry++) {
       theAffectedAPVmap_.insert(APVMap::value_type(entry->first, entry->second));
       }
       }
       } */
  
 }  // end of addSiStripSignals

References begin, MillePedeFileConverter_cfg::e, end, input, LogDebug, edm::DetSetVector< T >::reserve(), SiHitStorage_, and SistripLabelSig_.

◆ DMinitializeDetUnit()

void PreMixingSiStripWorker::DMinitializeDetUnit	(	StripGeomDetUnit const *	det,
		const edm::EventSetup &	iSetup
	)

private

Definition at line 215 of file PreMixingSiStripWorker.cc.

                                                                                                          {
   edm::ESHandle<SiStripBadStrip> deadChannelHandle;
   iSetup.get<SiStripBadChannelRcd>().get(deadChannelHandle);
  
   unsigned int detId = det->geographicalId().rawId();
   int numStrips = (det->specificTopology()).nstrips();
  
   SiStripBadStrip::Range detBadStripRange = deadChannelHandle->getRange(detId);
   //storing the bad strip of the the module. the module is not removed but just signal put to 0
   std::vector<bool>& badChannels = allBadChannels[detId];
   std::vector<bool>& hipChannels = allHIPChannels[detId];
   badChannels.clear();
   badChannels.insert(badChannels.begin(), numStrips, false);
   hipChannels.clear();
   hipChannels.insert(hipChannels.begin(), numStrips, false);
  
   for (SiStripBadStrip::ContainerIterator it = detBadStripRange.first; it != detBadStripRange.second; ++it) {
     SiStripBadStrip::data fs = deadChannelHandle->decode(*it);
     for (int strip = fs.firstStrip; strip < fs.firstStrip + fs.range; ++strip)
       badChannels[strip] = true;
   }
   firstChannelsWithSignal[detId] = numStrips;
   lastChannelsWithSignal[detId] = 0;
 }

References allBadChannels, allHIPChannels, SiStripBadStrip::decode(), firstChannelsWithSignal, SiStripBadStrip::data::firstStrip, GeomDet::geographicalId(), edm::EventSetup::get(), get, SiStripBadStrip::getRange(), lastChannelsWithSignal, SiStripBadStrip::data::range, DetId::rawId(), StripGeomDetUnit::specificTopology(), and digitizers_cfi::strip.

Referenced by initializeEvent().

◆ getSignal()

const SignalMapType* PreMixingSiStripWorker::getSignal ( uint32_t detID ) const

inlineprivate

Definition at line 86 of file PreMixingSiStripWorker.cc.

                                                        {
     auto where = signals_.find(detID);
     if (where == signals_.end()) {
       return nullptr;
     }
     return &where->second;
   }

References signals_.

Referenced by put().

◆ initializeEvent()

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

overridevirtual

Implements PreMixingWorker.

Definition at line 197 of file PreMixingSiStripWorker.cc.

                                                                                            {
   // initialize individual detectors so we can copy real digitization code:
  
   iSetup.get<TrackerDigiGeometryRecord>().get(geometryType, pDD);
  
   for (auto iu = pDD->detUnits().begin(); iu != pDD->detUnits().end(); ++iu) {
     unsigned int detId = (*iu)->geographicalId().rawId();
     DetId idet = DetId(detId);
     unsigned int isub = idet.subdetId();
     if ((isub == StripSubdetector::TIB) || (isub == StripSubdetector::TID) || (isub == StripSubdetector::TOB) ||
         (isub == StripSubdetector::TEC)) {
       auto stripdet = dynamic_cast<StripGeomDetUnit const*>((*iu));
       assert(stripdet != nullptr);
       DMinitializeDetUnit(stripdet, iSetup);
     }
   }
 }

References cms::cuda::assert(), TrackerGeometry::detUnits(), DMinitializeDetUnit(), geometryType, edm::EventSetup::get(), get, pDD, DetId::subdetId(), StripSubdetector::TEC, StripSubdetector::TIB, StripSubdetector::TID, and StripSubdetector::TOB.

◆ put()

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

overridevirtual

Implements PreMixingWorker.

Definition at line 340 of file PreMixingSiStripWorker.cc.

                                          {
   // set up machinery to do proper noise adding:
   edm::ESHandle<SiStripGain> gainHandle;
   edm::ESHandle<SiStripNoises> noiseHandle;
   edm::ESHandle<SiStripThreshold> thresholdHandle;
   edm::ESHandle<SiStripPedestals> pedestalHandle;
   edm::ESHandle<SiStripBadStrip> deadChannelHandle;
   edm::ESHandle<SiStripApvSimulationParameters> apvSimulationParametersHandle;
   edm::ESHandle<TrackerTopology> tTopo;
   iSetup.get<SiStripGainSimRcd>().get(gainLabel, gainHandle);
   iSetup.get<SiStripNoisesRcd>().get(noiseHandle);
   iSetup.get<SiStripThresholdRcd>().get(thresholdHandle);
   iSetup.get<SiStripPedestalsRcd>().get(pedestalHandle);
  
   edm::Service<edm::RandomNumberGenerator> rng;
   CLHEP::HepRandomEngine* engine = &rng->getEngine(e.streamID());
  
   const bool simulateAPVInThisEvent = includeAPVSimulation_ && (CLHEP::RandFlat::shoot(engine) < fracOfEventsToSimAPV_);
   float nTruePU = 0.;  // = ps.getTrueNumInteractions();
   if (simulateAPVInThisEvent) {
     iSetup.get<TrackerTopologyRcd>().get(tTopo);
     iSetup.get<SiStripApvSimulationParametersRcd>().get(apvSimulationParametersHandle);
     const auto it = std::find_if(
         std::begin(ps), std::end(ps), [](const PileupSummaryInfo& bxps) { return bxps.getBunchCrossing() == 0; });
     if (it != std::begin(ps)) {
       nTruePU = it->getTrueNumInteractions();
     } else {
       edm::LogWarning("PreMixingSiStripWorker") << "Could not find PileupSummaryInfo for current bunch crossing";
       nTruePU = std::begin(ps)->getTrueNumInteractions();
     }
   }
  
   std::map<int, std::bitset<6>> DeadAPVList;
   DeadAPVList.clear();
  
   // First, have to convert all ADC counts to raw pulse heights so that values can be added properly
   // In PreMixing, pulse heights are saved with ADC = sqrt(9.0*PulseHeight) - have to undo.
  
   // This is done here because it's the only place we have access to EventSetup
   // Simultaneously, merge lists of hit channels in each DetId.
   // Signal Digis are in the list first, have to merge lists of hit strips on the fly,
   // add signals on duplicates later
  
   OneDetectorRawMap LocalRawMap;
  
   // Now, loop over hits and add them to the map in the proper sorted order
   // Note: We are assuming that the hits from the Signal events have been created in
   // "PreMix" mode, rather than in the standard ADC conversion routines.  If not, this
   // doesn't work at all.
  
   // At the moment, both Signal and Reconstituted PU hits have the same compression algorithm.
   // If this were different, and one needed gains, the conversion back to pulse height can only
   // be done in this routine.  So, yes, there is an extra loop over hits here in the current code,
   // because, in principle, one could convert to pulse height during the read/store phase.
  
   for (SiGlobalIndex::const_iterator IDet = SiHitStorage_.begin(); IDet != SiHitStorage_.end(); IDet++) {
     uint32_t detID = IDet->first;
  
     OneDetectorMap LocalMap = IDet->second;
  
     //loop over hit strips for this DetId, do conversion to pulse height, store.
  
     LocalRawMap.clear();
  
     OneDetectorMap::const_iterator iLocal = LocalMap.begin();
     for (; iLocal != LocalMap.end(); ++iLocal) {
       uint16_t currentStrip = iLocal->strip();
       float signal = float(iLocal->adc());
       if (iLocal->adc() == 1022)
         signal = 1500.;  // average values for overflows
       if (iLocal->adc() == 1023)
         signal = 3000.;
  
       //convert signals back to raw counts
  
       float ReSignal = signal * signal / 9.0;  // The PreMixing conversion is adc = sqrt(9.0*pulseHeight)
  
       RawDigi NewRawDigi = std::make_pair(currentStrip, ReSignal);
  
       LocalRawMap.push_back(NewRawDigi);
     }
  
     // save information for this detiD into global map
     SiRawDigis_.insert(SiGlobalRawIndex::value_type(detID, LocalRawMap));
   }
  
   // If we are killing APVs, merge list of dead ones before we digitize
  
   int NumberOfBxBetweenHIPandEvent = 1e3;
  
   if (APVSaturationFromHIP_) {
     // calculate affected BX parameter
  
     bool HasAtleastOneAffectedAPV = false;
     while (!HasAtleastOneAffectedAPV) {
       for (int bx = floor(300.0 / 25.0); bx > 0; bx--) {  //Reminder: make these numbers not hard coded!!
         float temp = CLHEP::RandFlat::shoot(engine) < 0.5 ? 1 : 0;
         if (temp == 1 && bx < NumberOfBxBetweenHIPandEvent) {
           NumberOfBxBetweenHIPandEvent = bx;
           HasAtleastOneAffectedAPV = true;
         }
       }
     }
  
     APVMap::const_iterator iAPVchk;
     uint32_t formerID = 0;
     uint32_t currentID;
     std::bitset<6> NewAPVBits;
  
     for (APVMap::const_iterator iAPV = theAffectedAPVmap_.begin(); iAPV != theAffectedAPVmap_.end(); ++iAPV) {
       currentID = iAPV->first;
  
       if (currentID == formerID) {  // we have to OR these
         for (int ibit = 0; ibit < 6; ++ibit) {
           NewAPVBits[ibit] = NewAPVBits[ibit] || (iAPV->second)[ibit];
         }
       } else {
         DeadAPVList[currentID] = NewAPVBits;
         //save pointers for next iteration
         formerID = currentID;
         NewAPVBits = iAPV->second;
       }
  
       iAPVchk = iAPV;
       if ((++iAPVchk) == theAffectedAPVmap_.end()) {  //make sure not to lose the last one
         DeadAPVList[currentID] = NewAPVBits;
       }
     }
   }
   //
  
   //  Ok, done with merging raw signals and APVs - now add signals on duplicate strips
  
   // collection of Digis to put in the event
   std::vector<edm::DetSet<SiStripDigi>> vSiStripDigi;
  
   // loop through our collection of detectors, merging hits and making a new list of "signal" digis
  
   // clear some temporary storage for later digitization:
  
   signals_.clear();
  
   // big loop over Detector IDs:
   for (SiGlobalRawIndex::const_iterator IDet = SiRawDigis_.begin(); IDet != SiRawDigis_.end(); IDet++) {
     uint32_t detID = IDet->first;
  
     SignalMapType Signals;
     Signals.clear();
  
     OneDetectorRawMap LocalMap = IDet->second;
  
     //counter variables
     int formerStrip = -1;
     int currentStrip;
     float ADCSum = 0;
  
     //loop over hit strips for this DetId, add duplicates
  
     OneDetectorRawMap::const_iterator iLocalchk;
     OneDetectorRawMap::const_iterator iLocal = LocalMap.begin();
     for (; iLocal != LocalMap.end(); ++iLocal) {
       currentStrip = iLocal->first;  // strip is first element
  
       if (currentStrip == formerStrip) {  // we have to add these digis together
  
         ADCSum += iLocal->second;  // raw pulse height is second element.
       } else {
         if (formerStrip != -1) {
           Signals.insert(std::make_pair(formerStrip, ADCSum));
         }
         // save pointers for next iteration
         formerStrip = currentStrip;
         ADCSum = iLocal->second;  // lone ADC
       }
  
       iLocalchk = iLocal;
       if ((++iLocalchk) == LocalMap.end()) {  //make sure not to lose the last one
         Signals.insert(std::make_pair(formerStrip, ADCSum));
       }
     }
     // save merged map:
     signals_.insert(std::make_pair(detID, Signals));
   }
  
   //Now, do noise, zero suppression, take into account bad channels, etc.
   // This section stolen from SiStripDigitizerAlgorithm
   // must loop over all detIds in the tracker to get all of the noise added properly.
   for (const auto& iu : pDD->detUnits()) {
     const StripGeomDetUnit* sgd = dynamic_cast<const StripGeomDetUnit*>(iu);
     if (sgd != nullptr) {
       uint32_t detID = sgd->geographicalId().rawId();
  
       edm::DetSet<SiStripDigi> SSD(detID);  // Make empty collection with this detector ID
  
       int numStrips = (sgd->specificTopology()).nstrips();
  
       // see if there is some signal on this detector
  
       const SignalMapType* theSignal(getSignal(detID));
  
       std::vector<float> detAmpl(numStrips, 0.);
       if (theSignal) {
         for (const auto& amp : *theSignal) {
           detAmpl[amp.first] = amp.second;
         }
       }
  
       //removing signal from the dead (and HIP effected) strips
       std::vector<bool>& badChannels = allBadChannels[detID];
  
       for (int strip = 0; strip < numStrips; ++strip) {
         if (badChannels[strip])
           detAmpl[strip] = 0.;
       }
  
       if (simulateAPVInThisEvent) {
         // Get index in apv baseline distributions corresponding to z of detSet and PU
         const StripTopology* topol = dynamic_cast<const StripTopology*>(&(sgd->specificTopology()));
         LocalPoint localPos = topol->localPosition(0);
         GlobalPoint globalPos = sgd->surface().toGlobal(Local3DPoint(localPos.x(), localPos.y(), localPos.z()));
         float detSet_z = fabs(globalPos.z());
         float detSet_r = globalPos.perp();
  
         const uint32_t SubDet = DetId(detID).subdetId();
         // Simulate APV response for each strip
         for (int strip = 0; strip < numStrips; ++strip) {
           if (detAmpl[strip] > 0) {
             // Convert charge from electrons to fC
             double stripCharge = detAmpl[strip] * apv_fCPerElectron_;
  
             // Get APV baseline
             double baselineV = 0;
             if (SubDet == SiStripSubdetector::TIB) {
               baselineV = apvSimulationParametersHandle->sampleTIB(tTopo->tibLayer(detID), detSet_z, nTruePU, engine);
             } else if (SubDet == SiStripSubdetector::TOB) {
               baselineV = apvSimulationParametersHandle->sampleTOB(tTopo->tobLayer(detID), detSet_z, nTruePU, engine);
             } else if (SubDet == SiStripSubdetector::TID) {
               baselineV = apvSimulationParametersHandle->sampleTID(tTopo->tidWheel(detID), detSet_r, nTruePU, engine);
             } else if (SubDet == SiStripSubdetector::TEC) {
               baselineV = apvSimulationParametersHandle->sampleTEC(tTopo->tecWheel(detID), detSet_r, nTruePU, engine);
             }
             // Fitted parameters from G Hall/M Raymond
             double maxResponse = apv_maxResponse_;
             double rate = apv_rate_;
  
             double outputChargeInADC = 0;
             if (baselineV < apv_maxResponse_) {
               // Convert V0 into baseline charge
               double baselineQ = -1.0 * rate * log(2 * maxResponse / (baselineV + maxResponse) - 1);
  
               // Add charge deposited in this BX
               double newStripCharge = baselineQ + stripCharge;
  
               // Apply APV response
               double signalV = 2 * maxResponse / (1 + exp(-1.0 * newStripCharge / rate)) - maxResponse;
               double gain = signalV - baselineV;
  
               // Convert gain (mV) to charge (assuming linear region of APV) and then to electrons
               double outputCharge = gain / apv_mVPerQ_;
               outputChargeInADC = outputCharge / apv_fCPerElectron_;
             }
  
             // Output charge back to original container
             detAmpl[strip] = outputChargeInADC;
           }
         }
       }
  
       if (APVSaturationFromHIP_) {
         std::bitset<6>& bs = DeadAPVList[detID];
  
         if (bs.any()) {
           // Here below is the scaling function which describes the evolution of the baseline (i.e. how the charge is suppressed).
           // This must be replaced as soon as we have a proper modeling of the baseline evolution from VR runs
           float Shift =
               1 - NumberOfBxBetweenHIPandEvent / floor(300.0 / 25.0);  //Reminder: make these numbers not hardcoded!!
           float randomX = CLHEP::RandFlat::shoot(engine);
           float scalingValue = (randomX - Shift) * 10.0 / 7.0 - 3.0 / 7.0;
  
           for (int strip = 0; strip < numStrips; ++strip) {
             if (!badChannels[strip] && bs[strip / 128] == 1) {
               detAmpl[strip] *= scalingValue > 0 ? scalingValue : 0.0;
             }
           }
         }
       }
  
       SiStripNoises::Range detNoiseRange = noiseHandle->getRange(detID);
       SiStripApvGain::Range detGainRange = gainHandle->getRange(detID);
  
       // Gain conversion is already done during signal adding
       //convert our signals back to raw counts so that we can add noise properly:
  
       /*
         if(theSignal) {
         for(unsigned int iv = 0; iv!=detAmpl.size(); iv++) {
         float signal = detAmpl[iv];
         if(signal > 0) {
         float gainValue = gainHandle->getStripGain(iv, detGainRange);
         signal *= theElectronPerADC/gainValue;
         detAmpl[iv] = signal;
         }
         }
         }
       */
  
       //SiStripPedestals::Range detPedestalRange = pedestalHandle->getRange(detID);
  
       // -----------------------------------------------------------
  
       size_t firstChannelWithSignal = 0;
       size_t lastChannelWithSignal = numStrips;
  
       if (SingleStripNoise) {
         std::vector<float> noiseRMSv;
         noiseRMSv.clear();
         noiseRMSv.insert(noiseRMSv.begin(), numStrips, 0.);
         for (int strip = 0; strip < numStrips; ++strip) {
           if (!badChannels[strip]) {
             float gainValue = gainHandle->getStripGain(strip, detGainRange);
             noiseRMSv[strip] = (noiseHandle->getNoise(strip, detNoiseRange)) * theElectronPerADC / gainValue;
           }
         }
         theSiNoiseAdder->addNoiseVR(detAmpl, noiseRMSv, engine);
       } else {
         int RefStrip = int(numStrips / 2.);
         while (RefStrip < numStrips &&
                badChannels[RefStrip]) {  //if the refstrip is bad, I move up to when I don't find it
           RefStrip++;
         }
         if (RefStrip < numStrips) {
           float RefgainValue = gainHandle->getStripGain(RefStrip, detGainRange);
           float RefnoiseRMS = noiseHandle->getNoise(RefStrip, detNoiseRange) * theElectronPerADC / RefgainValue;
  
           theSiNoiseAdder->addNoise(
               detAmpl, firstChannelWithSignal, lastChannelWithSignal, numStrips, RefnoiseRMS, engine);
         }
       }
  
       DigitalVecType digis;
       theSiZeroSuppress->suppress(
           theSiDigitalConverter->convert(detAmpl, gainHandle, detID), digis, detID, noiseHandle, thresholdHandle);
  
       SSD.data = digis;
  
       // stick this into the global vector of detector info
       vSiStripDigi.push_back(SSD);
  
     }  // end of loop over one detector
  
   }  // end of big loop over all detector IDs
  
   // put the collection of digis in the event
   edm::LogInfo("PreMixingSiStripWorker") << "total # Merged strips: " << vSiStripDigi.size();
  
   // make new digi collection
  
   std::unique_ptr<edm::DetSetVector<SiStripDigi>> MySiStripDigis(new edm::DetSetVector<SiStripDigi>(vSiStripDigi));
  
   // put collection
  
   e.put(std::move(MySiStripDigis), SiStripDigiCollectionDM_);
   e.put(std::make_unique<bool>(simulateAPVInThisEvent), SiStripDigiCollectionDM_ + "SimulatedAPVDynamicGain");
  
   // clear local storage for this event
   SiHitStorage_.clear();
   SiRawDigis_.clear();
   signals_.clear();
 }

References allBadChannels, apv_fCPerElectron_, apv_maxResponse_, apv_mVPerQ_, apv_rate_, APVSaturationFromHIP_, begin, cms::cuda::bs, simKBmtfDigis_cfi::bx, edm::DetSet< T >::data, TrackerGeometry::detUnits(), MillePedeFileConverter_cfg::e, SiPixelPhase1Clusters_cfi::e3, end, JetChargeProducer_cfi::exp, dqmMemoryStats::float, fracOfEventsToSimAPV_, PedestalClient_cfi::gain, gainLabel, GeomDet::geographicalId(), edm::EventSetup::get(), get, PileupSummaryInfo::getBunchCrossing(), edm::RandomNumberGenerator::getEngine(), SiStripNoises::getNoise(), SiStripNoises::getRange(), SiStripGain::getRange(), getSignal(), SiStripGain::getStripGain(), includeAPVSimulation_, createfilelist::int, StripTopology::localPosition(), dqm-mbProfile::log, eostools::move(), pDD, PV3DBase< T, PVType, FrameType >::perp(), RPCpg::rate(), DetId::rawId(), SiStripApvSimulationParameters::sampleTEC(), SiStripApvSimulationParameters::sampleTIB(), SiStripApvSimulationParameters::sampleTID(), SiStripApvSimulationParameters::sampleTOB(), signals_, SiHitStorage_, SingleStripNoise, SiRawDigis_, SiStripDigiCollectionDM_, StripGeomDetUnit::specificTopology(), digitizers_cfi::strip, ntupleEnum::SubDet, DetId::subdetId(), GeomDet::surface(), SiStripSubdetector::TEC, TrackerTopology::tecWheel(), groupFilesInBlocks::temp, theAffectedAPVmap_, theElectronPerADC, theSiDigitalConverter, theSiNoiseAdder, theSiZeroSuppress, SiStripSubdetector::TIB, TrackerTopology::tibLayer(), SiStripSubdetector::TID, TrackerTopology::tidWheel(), SiStripSubdetector::TOB, TrackerTopology::tobLayer(), Surface::toGlobal(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Member Data Documentation

◆ allBadChannels

std::map<unsigned int, std::vector<bool> > PreMixingSiStripWorker::allBadChannels

private

Definition at line 119 of file PreMixingSiStripWorker.cc.

Referenced by DMinitializeDetUnit(), and put().

◆ allHIPChannels

std::map<unsigned int, std::vector<bool> > PreMixingSiStripWorker::allHIPChannels

private

Definition at line 121 of file PreMixingSiStripWorker.cc.

Referenced by DMinitializeDetUnit().

◆ apv_fCPerElectron_

const double PreMixingSiStripWorker::apv_fCPerElectron_

private

Definition at line 131 of file PreMixingSiStripWorker.cc.

Referenced by put().

◆ apv_maxResponse_

const double PreMixingSiStripWorker::apv_maxResponse_

private

Definition at line 128 of file PreMixingSiStripWorker.cc.

Referenced by put().

◆ apv_mVPerQ_

const double PreMixingSiStripWorker::apv_mVPerQ_

private

Definition at line 130 of file PreMixingSiStripWorker.cc.

Referenced by put().

◆ apv_rate_

const double PreMixingSiStripWorker::apv_rate_

private

Definition at line 129 of file PreMixingSiStripWorker.cc.

Referenced by put().

◆ APVSaturationFromHIP_

bool PreMixingSiStripWorker::APVSaturationFromHIP_

private

Definition at line 108 of file PreMixingSiStripWorker.cc.

Referenced by addPileups(), PreMixingSiStripWorker(), and put().

◆ firstChannelsWithSignal

std::map<unsigned int, size_t> PreMixingSiStripWorker::firstChannelsWithSignal

private

Definition at line 123 of file PreMixingSiStripWorker.cc.

Referenced by DMinitializeDetUnit().

◆ fracOfEventsToSimAPV_

const double PreMixingSiStripWorker::fracOfEventsToSimAPV_

private

Definition at line 127 of file PreMixingSiStripWorker.cc.

Referenced by put().

◆ gainLabel

std::string PreMixingSiStripWorker::gainLabel

private

Definition at line 103 of file PreMixingSiStripWorker.cc.

Referenced by put().

◆ geometryType

std::string PreMixingSiStripWorker::geometryType

private

Definition at line 110 of file PreMixingSiStripWorker.cc.

Referenced by initializeEvent().

◆ includeAPVSimulation_

bool PreMixingSiStripWorker::includeAPVSimulation_

private

Definition at line 126 of file PreMixingSiStripWorker.cc.

Referenced by put().

◆ lastChannelsWithSignal

std::map<unsigned int, size_t> PreMixingSiStripWorker::lastChannelsWithSignal

private

Definition at line 124 of file PreMixingSiStripWorker.cc.

Referenced by DMinitializeDetUnit().

◆ pDD

edm::ESHandle<TrackerGeometry> PreMixingSiStripWorker::pDD

private

Definition at line 116 of file PreMixingSiStripWorker.cc.

Referenced by initializeEvent(), and put().

◆ peakMode

bool PreMixingSiStripWorker::peakMode

private

Definition at line 105 of file PreMixingSiStripWorker.cc.

◆ signals_

signalMaps PreMixingSiStripWorker::signals_

private

Definition at line 94 of file PreMixingSiStripWorker.cc.

Referenced by getSignal(), and put().

◆ SiHitStorage_

SiGlobalIndex PreMixingSiStripWorker::SiHitStorage_

private

Definition at line 79 of file PreMixingSiStripWorker.cc.

Referenced by addPileups(), addSignals(), PreMixingSiStripWorker(), and put().

◆ SingleStripNoise

bool PreMixingSiStripWorker::SingleStripNoise

private

Definition at line 104 of file PreMixingSiStripWorker.cc.

Referenced by put().

◆ SiRawDigis_

SiGlobalRawIndex PreMixingSiStripWorker::SiRawDigis_

private

Definition at line 80 of file PreMixingSiStripWorker.cc.

Referenced by put().

◆ SistripAPVLabelSig_

edm::InputTag PreMixingSiStripWorker::SistripAPVLabelSig_

private

Definition at line 64 of file PreMixingSiStripWorker.cc.

Referenced by PreMixingSiStripWorker().

◆ SistripAPVListDM_

std::string PreMixingSiStripWorker::SistripAPVListDM_

private

Definition at line 66 of file PreMixingSiStripWorker.cc.

Referenced by PreMixingSiStripWorker().

◆ SiStripAPVPileInputTag_

edm::InputTag PreMixingSiStripWorker::SiStripAPVPileInputTag_

private

Definition at line 65 of file PreMixingSiStripWorker.cc.

Referenced by addPileups(), and PreMixingSiStripWorker().

◆ SiStripDigiCollectionDM_

std::string PreMixingSiStripWorker::SiStripDigiCollectionDM_

private

Definition at line 62 of file PreMixingSiStripWorker.cc.

Referenced by PreMixingSiStripWorker(), and put().

◆ SistripLabelSig_

edm::InputTag PreMixingSiStripWorker::SistripLabelSig_

private

Definition at line 60 of file PreMixingSiStripWorker.cc.

Referenced by addSignals(), and PreMixingSiStripWorker().

◆ SiStripPileInputTag_

edm::InputTag PreMixingSiStripWorker::SiStripPileInputTag_

private

Definition at line 61 of file PreMixingSiStripWorker.cc.

Referenced by addPileups(), and PreMixingSiStripWorker().

◆ theAffectedAPVmap_

APVMap PreMixingSiStripWorker::theAffectedAPVmap_

private

Definition at line 99 of file PreMixingSiStripWorker.cc.

Referenced by addPileups(), and put().

◆ theElectronPerADC

double PreMixingSiStripWorker::theElectronPerADC

private

Definition at line 107 of file PreMixingSiStripWorker.cc.

Referenced by put().

◆ theFedAlgo

int PreMixingSiStripWorker::theFedAlgo

private

Definition at line 109 of file PreMixingSiStripWorker.cc.

◆ theSiDigitalConverter

std::unique_ptr<SiTrivialDigitalConverter> PreMixingSiStripWorker::theSiDigitalConverter

private

Definition at line 114 of file PreMixingSiStripWorker.cc.

Referenced by put().

◆ theSiNoiseAdder

std::unique_ptr<SiGaussianTailNoiseAdder> PreMixingSiStripWorker::theSiNoiseAdder

private

Definition at line 112 of file PreMixingSiStripWorker.cc.

Referenced by PreMixingSiStripWorker(), and put().

◆ theSiZeroSuppress

std::unique_ptr<SiStripFedZeroSuppression> PreMixingSiStripWorker::theSiZeroSuppress

private

Definition at line 113 of file PreMixingSiStripWorker.cc.

Referenced by put().

◆ theThreshold

double PreMixingSiStripWorker::theThreshold

private

Definition at line 106 of file PreMixingSiStripWorker.cc.

Referenced by PreMixingSiStripWorker().

Classes

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ Amplitude

◆ APVMap

◆ DigitalVecType

◆ OneDetectorMap

◆ OneDetectorRawMap

◆ RawDigi

◆ SiGlobalIndex

◆ SiGlobalRawIndex

◆ signalMaps

◆ SignalMapType

Constructor & Destructor Documentation

◆ PreMixingSiStripWorker()

◆ ~PreMixingSiStripWorker()

Member Function Documentation

◆ addPileups()

◆ addSignals()

◆ DMinitializeDetUnit()

◆ getSignal()

◆ initializeEvent()

◆ put()

Member Data Documentation

◆ allBadChannels

◆ allHIPChannels

◆ apv_fCPerElectron_

◆ apv_maxResponse_

◆ apv_mVPerQ_

◆ apv_rate_

◆ APVSaturationFromHIP_

◆ firstChannelsWithSignal

◆ fracOfEventsToSimAPV_

◆ gainLabel

◆ geometryType

◆ includeAPVSimulation_

◆ lastChannelsWithSignal

◆ pDD

◆ peakMode

◆ signals_

◆ SiHitStorage_

◆ SingleStripNoise

◆ SiRawDigis_

◆ SistripAPVLabelSig_

◆ SistripAPVListDM_

◆ SiStripAPVPileInputTag_

◆ SiStripDigiCollectionDM_

◆ SistripLabelSig_

◆ SiStripPileInputTag_

◆ theAffectedAPVmap_

◆ theElectronPerADC

◆ theFedAlgo

◆ theSiDigitalConverter

◆ theSiNoiseAdder

◆ theSiZeroSuppress

◆ theThreshold