PreMixingSiStripWorker Class Reference

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::ProducerBase &producer, 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
bool	APVSaturationFromHIP_
std::map< unsigned int, size_t >	firstChannelsWithSignal
std::string	gainLabel
std::string	geometryType
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 42 of file PreMixingSiStripWorker.cc.

Member Typedef Documentation

typedef float PreMixingSiStripWorker::Amplitude

private

Definition at line 68 of file PreMixingSiStripWorker.cc.

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

private

Definition at line 95 of file PreMixingSiStripWorker.cc.

typedef SiDigitalConverter::DigitalVecType PreMixingSiStripWorker::DigitalVecType

private

Definition at line 75 of file PreMixingSiStripWorker.cc.

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

private

Definition at line 70 of file PreMixingSiStripWorker.cc.

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

private

Definition at line 71 of file PreMixingSiStripWorker.cc.

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

private

Definition at line 69 of file PreMixingSiStripWorker.cc.

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

private

Definition at line 72 of file PreMixingSiStripWorker.cc.

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

private

Definition at line 73 of file PreMixingSiStripWorker.cc.

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

private

Definition at line 82 of file PreMixingSiStripWorker.cc.

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

private

Definition at line 81 of file PreMixingSiStripWorker.cc.

Constructor & Destructor Documentation

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

Definition at line 138 of file PreMixingSiStripWorker.cc.

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

                                                                                                                              : 
  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

{                                                         
  // 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");

  producer.produces< edm::DetSetVector<SiStripDigi> > (SiStripDigiCollectionDM_);

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

PreMixingSiStripWorker::~PreMixingSiStripWorker ( )

overridedefault

Member Function Documentation

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

overridevirtual

Implements PreMixingWorker.

Definition at line 271 of file PreMixingSiStripWorker.cc.

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_.

                                                                                                {
  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 229 of file PreMixingSiStripWorker.cc.

References begin, 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 203 of file PreMixingSiStripWorker.cc.

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

Referenced by initializeEvent().

                                                                                                           { 

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

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

inlineprivate

Definition at line 84 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 181 of file PreMixingSiStripWorker.cc.

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

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

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

overridevirtual

Implements PreMixingWorker.

Definition at line 337 of file PreMixingSiStripWorker.cc.

References allBadChannels, APVSaturationFromHIP_, edm::DetSet< T >::data, DEFINE_PREMIXING_WORKER, TrackerGeometry::detUnits(), SiPixelPhase1TrackClustersV_cfi::e3, objects.autophobj::float, gainLabel, GeomDet::geographicalId(), edm::EventSetup::get(), edm::RandomNumberGenerator::getEngine(), SiStripNoises::getNoise(), SiStripNoises::getRange(), SiStripGain::getRange(), getSignal(), SiStripGain::getStripGain(), createfilelist::int, eostools::move(), pDD, edm::Event::put(), DetId::rawId(), signals_, SiHitStorage_, SingleStripNoise, SiRawDigis_, SiStripDigiCollectionDM_, StripGeomDetUnit::specificTopology(), edm::Event::streamID(), digitizers_cfi::strip, groupFilesInBlocks::temp, theAffectedAPVmap_, theElectronPerADC, theSiDigitalConverter, theSiNoiseAdder, and theSiZeroSuppress.

                                                                                                                         {

  // 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;
  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());

  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(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_ );

  // clear local storage for this event
  SiHitStorage_.clear();
  SiRawDigis_.clear();
  signals_.clear();
}

Member Data Documentation

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

private

Definition at line 117 of file PreMixingSiStripWorker.cc.

Referenced by DMinitializeDetUnit(), and put().

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

private

Definition at line 119 of file PreMixingSiStripWorker.cc.

Referenced by DMinitializeDetUnit().

bool PreMixingSiStripWorker::APVSaturationFromHIP_

private

Definition at line 106 of file PreMixingSiStripWorker.cc.

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

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

private

Definition at line 121 of file PreMixingSiStripWorker.cc.

Referenced by DMinitializeDetUnit().

std::string PreMixingSiStripWorker::gainLabel

private

Definition at line 101 of file PreMixingSiStripWorker.cc.

Referenced by put().

std::string PreMixingSiStripWorker::geometryType

private

Definition at line 108 of file PreMixingSiStripWorker.cc.

Referenced by initializeEvent().

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

private

Definition at line 122 of file PreMixingSiStripWorker.cc.

Referenced by DMinitializeDetUnit().

edm::ESHandle<TrackerGeometry> PreMixingSiStripWorker::pDD

private

Definition at line 114 of file PreMixingSiStripWorker.cc.

Referenced by initializeEvent(), and put().

bool PreMixingSiStripWorker::peakMode

private

Definition at line 103 of file PreMixingSiStripWorker.cc.

signalMaps PreMixingSiStripWorker::signals_

private

Definition at line 92 of file PreMixingSiStripWorker.cc.

Referenced by getSignal(), and put().

SiGlobalIndex PreMixingSiStripWorker::SiHitStorage_

private

Definition at line 77 of file PreMixingSiStripWorker.cc.

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

bool PreMixingSiStripWorker::SingleStripNoise

private

Definition at line 102 of file PreMixingSiStripWorker.cc.

Referenced by put().

SiGlobalRawIndex PreMixingSiStripWorker::SiRawDigis_

private

Definition at line 78 of file PreMixingSiStripWorker.cc.

Referenced by put().

edm::InputTag PreMixingSiStripWorker::SistripAPVLabelSig_

private

Definition at line 61 of file PreMixingSiStripWorker.cc.

Referenced by PreMixingSiStripWorker().

std::string PreMixingSiStripWorker::SistripAPVListDM_

private

Definition at line 63 of file PreMixingSiStripWorker.cc.

Referenced by PreMixingSiStripWorker().

edm::InputTag PreMixingSiStripWorker::SiStripAPVPileInputTag_

private

Definition at line 62 of file PreMixingSiStripWorker.cc.

Referenced by addPileups(), and PreMixingSiStripWorker().

std::string PreMixingSiStripWorker::SiStripDigiCollectionDM_

private

Definition at line 59 of file PreMixingSiStripWorker.cc.

Referenced by PreMixingSiStripWorker(), and put().

edm::InputTag PreMixingSiStripWorker::SistripLabelSig_

private

Definition at line 57 of file PreMixingSiStripWorker.cc.

Referenced by addSignals(), and PreMixingSiStripWorker().

edm::InputTag PreMixingSiStripWorker::SiStripPileInputTag_

private

Definition at line 58 of file PreMixingSiStripWorker.cc.

Referenced by addPileups(), and PreMixingSiStripWorker().

APVMap PreMixingSiStripWorker::theAffectedAPVmap_

private

Definition at line 97 of file PreMixingSiStripWorker.cc.

Referenced by addPileups(), and put().

double PreMixingSiStripWorker::theElectronPerADC

private

Definition at line 105 of file PreMixingSiStripWorker.cc.

Referenced by put().

int PreMixingSiStripWorker::theFedAlgo

private

Definition at line 107 of file PreMixingSiStripWorker.cc.

std::unique_ptr<SiTrivialDigitalConverter> PreMixingSiStripWorker::theSiDigitalConverter

private

Definition at line 112 of file PreMixingSiStripWorker.cc.

Referenced by put().

std::unique_ptr<SiGaussianTailNoiseAdder> PreMixingSiStripWorker::theSiNoiseAdder

private

Definition at line 110 of file PreMixingSiStripWorker.cc.

Referenced by PreMixingSiStripWorker(), and put().

std::unique_ptr<SiStripFedZeroSuppression> PreMixingSiStripWorker::theSiZeroSuppress

private

Definition at line 111 of file PreMixingSiStripWorker.cc.

Referenced by put().

double PreMixingSiStripWorker::theThreshold

private

Definition at line 104 of file PreMixingSiStripWorker.cc.

Referenced by PreMixingSiStripWorker().