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_

edm::ESGetToken < SiStripApvSimulationParameters, SiStripApvSimulationParametersRcd >	apvSimulationParametersToken_

edm::ESGetToken < SiStripBadStrip, SiStripBadChannelRcd > const	deadChannelToken_

std::map< unsigned int, size_t >	firstChannelsWithSignal

const double	fracOfEventsToSimAPV_

edm::ESGetToken< SiStripGain, SiStripGainSimRcd > const	gainToken_

bool	includeAPVSimulation_

std::map< unsigned int, size_t >	lastChannelsWithSignal

edm::ESGetToken< SiStripNoises, SiStripNoisesRcd > const	noiseToken_

const TrackerGeometry *	pDD

edm::ESGetToken < TrackerGeometry, TrackerDigiGeometryRecord > const	pDDToken_

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

edm::ESGetToken < SiStripThreshold, SiStripThresholdRcd > const	thresholdToken_

edm::ESGetToken < TrackerTopology, TrackerTopologyRcd >	tTopoToken_

Detailed Description

Definition at line 45 of file PreMixingSiStripWorker.cc.

Member Typedef Documentation

typedef float PreMixingSiStripWorker::Amplitude

private

Definition at line 79 of file PreMixingSiStripWorker.cc.

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

private

Definition at line 106 of file PreMixingSiStripWorker.cc.

typedef SiDigitalConverter::DigitalVecType PreMixingSiStripWorker::DigitalVecType

private

Definition at line 86 of file PreMixingSiStripWorker.cc.

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

private

Definition at line 81 of file PreMixingSiStripWorker.cc.

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

private

Definition at line 82 of file PreMixingSiStripWorker.cc.

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

private

Definition at line 80 of file PreMixingSiStripWorker.cc.

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

private

Definition at line 83 of file PreMixingSiStripWorker.cc.

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

private

Definition at line 84 of file PreMixingSiStripWorker.cc.

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

private

Definition at line 93 of file PreMixingSiStripWorker.cc.

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

private

Definition at line 92 of file PreMixingSiStripWorker.cc.

Constructor & Destructor Documentation

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

Definition at line 153 of file PreMixingSiStripWorker.cc.

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

     : pDDToken_(iC.esConsumes(edm::ESInputTag("", ps.getParameter<std::string>("GeometryType")))),
       deadChannelToken_(iC.esConsumes()),
       gainToken_(iC.esConsumes(edm::ESInputTag("", ps.getParameter<std::string>("Gain")))),
       noiseToken_(iC.esConsumes()),
       thresholdToken_(iC.esConsumes()),
       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")),
       theSiZeroSuppress(new SiStripFedZeroSuppression(theFedAlgo, &iC)),
       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_);
 
   if (includeAPVSimulation_) {
     tTopoToken_ = iC.esConsumes();
     apvSimulationParametersToken_ = iC.esConsumes();
   }
   // 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 = std::make_unique<SiGaussianTailNoiseAdder>(theThreshold);
 }

PreMixingSiStripWorker::~PreMixingSiStripWorker ( )

overridedefault

Member Function Documentation

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

overridevirtual

Implements PreMixingWorker.

Definition at line 292 of file PreMixingSiStripWorker.cc.

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

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

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

overridevirtual

Implements PreMixingWorker.

Definition at line 254 of file PreMixingSiStripWorker.cc.

References SplitLinear::begin, dataset::end, edm::Event::getByLabel(), input, LogDebug, edm::DetSetVector< T >::reserve(), SiHitStorage_, and SistripLabelSig_.

                                                                                   {
   // 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

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

private

Definition at line 230 of file PreMixingSiStripWorker.cc.

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

Referenced by initializeEvent().

                                                                                                          {
   SiStripBadStrip const& deadChannel = iSetup.getData(deadChannelToken_);
 
   unsigned int detId = det->geographicalId().rawId();
   int numStrips = (det->specificTopology()).nstrips();
 
   SiStripBadStrip::Range detBadStripRange = deadChannel.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 = deadChannel.decode(*it);
     for (int strip = fs.firstStrip; strip < fs.firstStrip + fs.range; ++strip)
       badChannels[strip] = true;
   }
   firstChannelsWithSignal[detId] = numStrips;
   lastChannelsWithSignal[detId] = 0;
 }

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

inlineprivate

Definition at line 95 of file PreMixingSiStripWorker.cc.

References signals_.

Referenced by put().

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

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

overridevirtual

Implements PreMixingWorker.

Definition at line 212 of file PreMixingSiStripWorker.cc.

References cms::cuda::assert(), runTheMatrix::const, TrackerGeometry::detUnits(), DMinitializeDetUnit(), edm::EventSetup::getData(), pDD, pDDToken_, DetId::subdetId(), StripSubdetector::TEC, StripSubdetector::TIB, StripSubdetector::TID, and StripSubdetector::TOB.

                                                                                            {
   // initialize individual detectors so we can copy real digitization code:
 
   pDD = &iSetup.getData(pDDToken_);
 
   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);
     }
   }
 }

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

overridevirtual

Implements PreMixingWorker.

Definition at line 354 of file PreMixingSiStripWorker.cc.

References allBadChannels, apv_fCPerElectron_, apv_maxResponse_, apv_mVPerQ_, apv_rate_, APVSaturationFromHIP_, apvSimulationParametersToken_, SplitLinear::begin, makePileupJSON::bx, edm::DetSet< T >::data, TrackerGeometry::detUnits(), dataset::end, funct::exp(), fracOfEventsToSimAPV_, gainToken_, GeomDet::geographicalId(), PileupSummaryInfo::getBunchCrossing(), edm::EventSetup::getData(), edm::RandomNumberGenerator::getEngine(), SiStripNoises::getNoise(), SiStripNoises::getRange(), SiStripGain::getRange(), getSignal(), SiStripGain::getStripGain(), includeAPVSimulation_, StripTopology::localPosition(), log, eostools::move(), gpuVertexFinder::noise, noiseToken_, pDD, PV3DBase< T, PVType, FrameType >::perp(), edm::Event::put(), RPCpg::rate(), DetId::rawId(), SiStripApvSimulationParameters::sampleTEC(), SiStripApvSimulationParameters::sampleTIB(), SiStripApvSimulationParameters::sampleTID(), SiStripApvSimulationParameters::sampleTOB(), signals_, SiHitStorage_, SingleStripNoise, SiRawDigis_, SiStripDigiCollectionDM_, StripGeomDetUnit::specificTopology(), edm::Event::streamID(), digitizers_cfi::strip, ntupleEnum::SubDet, DetId::subdetId(), GeomDet::surface(), SiStripSubdetector::TEC, TrackerTopology::tecWheel(), groupFilesInBlocks::temp, theAffectedAPVmap_, theElectronPerADC, theSiDigitalConverter, theSiNoiseAdder, theSiZeroSuppress, dtDQMClient_cfg::threshold, thresholdToken_, SiStripSubdetector::TIB, TrackerTopology::tibLayer(), SiStripSubdetector::TID, TrackerTopology::tidWheel(), SiStripSubdetector::TOB, TrackerTopology::tobLayer(), Surface::toGlobal(), tTopoToken_, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

                                          {
   // set up machinery to do proper noise adding:
   SiStripGain const& gain = iSetup.getData(gainToken_);
   SiStripNoises const& noise = iSetup.getData(noiseToken_);
   SiStripThreshold const& threshold = iSetup.getData(thresholdToken_);
   //SiStripPedestals const& pedestal = iSetup.getData(pedestalToken_);
   SiStripApvSimulationParameters const* apvSimulationParameters = nullptr;
   TrackerTopology const* tTopo = nullptr;
 
   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) {
     tTopo = &iSetup.getData(tTopoToken_);
     apvSimulationParameters = &iSetup.getData(apvSimulationParametersToken_);
     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 = apvSimulationParameters->sampleTIB(tTopo->tibLayer(detID), detSet_z, nTruePU, engine);
             } else if (SubDet == SiStripSubdetector::TOB) {
               baselineV = apvSimulationParameters->sampleTOB(tTopo->tobLayer(detID), detSet_z, nTruePU, engine);
             } else if (SubDet == SiStripSubdetector::TID) {
               baselineV = apvSimulationParameters->sampleTID(tTopo->tidWheel(detID), detSet_r, nTruePU, engine);
             } else if (SubDet == SiStripSubdetector::TEC) {
               baselineV = apvSimulationParameters->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 = noise.getRange(detID);
       SiStripApvGain::Range detGainRange = gain.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 = gain.getStripGain(iv, detGainRange);
         signal *= theElectronPerADC/gainValue;
         detAmpl[iv] = signal;
         }
         }
         }
       */
 
       //SiStripPedestals::Range detPedestalRange = pedestal.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 = gain.getStripGain(strip, detGainRange);
             noiseRMSv[strip] = (noise.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 = gain.getStripGain(RefStrip, detGainRange);
           float RefnoiseRMS = noise.getNoise(RefStrip, detNoiseRange) * theElectronPerADC / RefgainValue;
 
           theSiNoiseAdder->addNoise(
               detAmpl, firstChannelWithSignal, lastChannelWithSignal, numStrips, RefnoiseRMS, engine);
         }
       }
 
       DigitalVecType digis;
       theSiZeroSuppress->suppress(
           theSiDigitalConverter->convert(detAmpl, &gain, detID), digis, detID, noise, threshold);
 
       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();
 }