DigiSimLinkAlgorithm Class Reference

#include <DigiSimLinkAlgorithm.h>

Public Types
typedef float	Amplitude
typedef SiDigitalConverter::DigitalRawVecType	DigitalRawVecType
typedef SiDigitalConverter::DigitalVecType	DigitalVecType
typedef std::map< int, float, std::less< int > >	hit_map_type
typedef DigiSimLinkPileUpSignals::HitCounterToDigisMapType	HitCounterToDigisMapType
typedef DigiSimLinkPileUpSignals::HitToDigisMapType	HitToDigisMapType

Public Member Functions
	DigiSimLinkAlgorithm (const edm::ParameterSet &conf)
std::vector< StripDigiSimLink >	make_link ()
void	run (edm::DetSet< SiStripDigi > &, edm::DetSet< SiStripRawDigi > &, const std::vector< std::pair< const PSimHit *, int > > &, StripGeomDetUnit const *, GlobalVector, float, edm::ESHandle< SiStripGain > &, edm::ESHandle< SiStripThreshold > &, edm::ESHandle< SiStripNoises > &, edm::ESHandle< SiStripPedestals > &, edm::ESHandle< SiStripBadStrip > &, const TrackerTopology *tTopo, CLHEP::HepRandomEngine *)
void	setParticleDataTable (const ParticleDataTable *pardt)
	~DigiSimLinkAlgorithm ()

Private Member Functions
void	push_link (const DigitalVecType &, const HitToDigisMapType &, const HitCounterToDigisMapType &, const std::vector< float > &, unsigned int)
void	push_link_raw (const DigitalRawVecType &, const HitToDigisMapType &, const HitCounterToDigisMapType &, const std::vector< float > &, unsigned int)

Private Attributes
bool	APVSaturationFromHIP
double	APVSaturationProb
bool	BaselineShift
double	cmnRMStec
double	cmnRMStib
double	cmnRMStid
double	cmnRMStob
bool	CommonModeNoise
edm::ParameterSet	conf_
double	cosmicShift
std::vector< float >	detAmpl
DigitalVecType	digis
size_t	firstChannelWithSignal
double	inefficiency
size_t	lastChannelWithSignal
std::vector< StripDigiSimLink >	link_coll
size_t	localFirstChannel
size_t	localLastChannel
std::vector< float >	locAmpl
bool	noise
int	numStrips
const ParticleData *	particle
const ParticleDataTable *	pdt
bool	peakMode
double	pedOffset
bool	PreMixing_
DigitalRawVecType	rawdigis
bool	RealPedestals
bool	SingleStripNoise
int	strip
DigiSimLinkPileUpSignals *	theDigiSimLinkPileUpSignals
double	theElectronPerADC
int	theFedAlgo
SiTrivialDigitalConverter *	theSiDigitalConverter
SiHitDigitizer *	theSiHitDigitizer
SiGaussianTailNoiseAdder *	theSiNoiseAdder
SiStripFedZeroSuppression *	theSiZeroSuppress
double	theThreshold
double	theTOFCutForDeconvolution
double	theTOFCutForPeak
double	tofCut
bool	zeroSuppression

Detailed Description

Definition at line 41 of file DigiSimLinkAlgorithm.h.

Member Typedef Documentation

Amplitude

typedef float DigiSimLinkAlgorithm::Amplitude

Definition at line 48 of file DigiSimLinkAlgorithm.h.

DigitalRawVecType

typedef SiDigitalConverter::DigitalRawVecType DigiSimLinkAlgorithm::DigitalRawVecType

Definition at line 44 of file DigiSimLinkAlgorithm.h.

DigitalVecType

typedef SiDigitalConverter::DigitalVecType DigiSimLinkAlgorithm::DigitalVecType

Definition at line 43 of file DigiSimLinkAlgorithm.h.

hit_map_type

typedef std::map<int, float, std::less<int> > DigiSimLinkAlgorithm::hit_map_type

Definition at line 47 of file DigiSimLinkAlgorithm.h.

HitCounterToDigisMapType

typedef DigiSimLinkPileUpSignals::HitCounterToDigisMapType DigiSimLinkAlgorithm::HitCounterToDigisMapType

Definition at line 46 of file DigiSimLinkAlgorithm.h.

HitToDigisMapType

typedef DigiSimLinkPileUpSignals::HitToDigisMapType DigiSimLinkAlgorithm::HitToDigisMapType

Definition at line 45 of file DigiSimLinkAlgorithm.h.

Constructor & Destructor Documentation

DigiSimLinkAlgorithm()

DigiSimLinkAlgorithm::DigiSimLinkAlgorithm

(

const edm::ParameterSet &

conf

)

Definition at line 20 of file DigiSimLinkAlgorithm.cc.

References APVSaturationFromHIP, APVSaturationProb, BaselineShift, cmnRMStec, cmnRMStib, cmnRMStid, cmnRMStob, CommonModeNoise, conf_, cosmicShift, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), inefficiency, createfilelist::int, LogDebug, noise, peakMode, pedOffset, PreMixing_, RealPedestals, SingleStripNoise, theDigiSimLinkPileUpSignals, theElectronPerADC, theFedAlgo, theSiDigitalConverter, theSiHitDigitizer, theSiNoiseAdder, theSiZeroSuppress, theThreshold, theTOFCutForDeconvolution, theTOFCutForPeak, tofCut, and zeroSuppression.

                                                                      : conf_(conf) {
  theThreshold = conf_.getParameter<double>("NoiseSigmaThreshold");
  theFedAlgo = conf_.getParameter<int>("FedAlgorithm");
  peakMode = conf_.getParameter<bool>("APVpeakmode");
  theElectronPerADC = conf_.getParameter<double>(peakMode ? "electronPerAdcPeak" : "electronPerAdcDec");
  noise = conf_.getParameter<bool>("Noise");
  zeroSuppression = conf_.getParameter<bool>("ZeroSuppression");
  theTOFCutForPeak = conf_.getParameter<double>("TOFCutForPeak");
  theTOFCutForDeconvolution = conf_.getParameter<double>("TOFCutForDeconvolution");
  cosmicShift = conf_.getUntrackedParameter<double>("CosmicDelayShift");
  inefficiency = conf_.getParameter<double>("Inefficiency");
  RealPedestals = conf_.getParameter<bool>("RealPedestals");
  SingleStripNoise = conf_.getParameter<bool>("SingleStripNoise");
  CommonModeNoise = conf_.getParameter<bool>("CommonModeNoise");
  BaselineShift = conf_.getParameter<bool>("BaselineShift");
  APVSaturationFromHIP = conf_.getParameter<bool>("APVSaturationFromHIP");
  APVSaturationProb = conf_.getParameter<double>("APVSaturationProb");
  cmnRMStib = conf_.getParameter<double>("cmnRMStib");
  cmnRMStob = conf_.getParameter<double>("cmnRMStob");
  cmnRMStid = conf_.getParameter<double>("cmnRMStid");
  cmnRMStec = conf_.getParameter<double>("cmnRMStec");
  pedOffset = (unsigned int)conf_.getParameter<double>("PedestalsOffset");
  PreMixing_ = conf_.getParameter<bool>("PreMixingMode");
  if (peakMode) {
    tofCut = theTOFCutForPeak;
    LogDebug("StripDigiInfo") << "APVs running in peak mode (poor time resolution)";
  } else {
    tofCut = theTOFCutForDeconvolution;
    LogDebug("StripDigiInfo") << "APVs running in deconvolution mode (good time resolution)";
  };

  theSiHitDigitizer = new SiHitDigitizer(conf_);
  theDigiSimLinkPileUpSignals = new DigiSimLinkPileUpSignals();
  theSiNoiseAdder = new SiGaussianTailNoiseAdder(theThreshold);
  theSiDigitalConverter = new SiTrivialDigitalConverter(theElectronPerADC, PreMixing_);
  theSiZeroSuppress = new SiStripFedZeroSuppression(theFedAlgo, nullptr);
}

~DigiSimLinkAlgorithm()

DigiSimLinkAlgorithm::~DigiSimLinkAlgorithm

(

)

Definition at line 58 of file DigiSimLinkAlgorithm.cc.

References theDigiSimLinkPileUpSignals, theSiDigitalConverter, theSiHitDigitizer, theSiNoiseAdder, and theSiZeroSuppress.

                                            {
  delete theSiHitDigitizer;
  delete theDigiSimLinkPileUpSignals;
  delete theSiNoiseAdder;
  delete theSiDigitalConverter;
  delete theSiZeroSuppress;
  //delete particle;
  //delete pdt;
}

Member Function Documentation

make_link()

std::vector<StripDigiSimLink> DigiSimLinkAlgorithm::make_link ( )

inline

Definition at line 72 of file DigiSimLinkAlgorithm.h.

References link_coll.

{ return link_coll; }

push_link()

void DigiSimLinkAlgorithm::push_link ( const DigitalVecType &  digis, const HitToDigisMapType &  htd, const HitCounterToDigisMapType &  hctd, const std::vector< float > &  afterNoise, unsigned int  detID  )

private

Definition at line 316 of file DigiSimLinkAlgorithm.cc.

References digis, HLT_2022v11_cff::fraction, mps_fire::i, link_coll, remoteMonitoring_LASER_era2018_cfg::threshold, and trackerHitRTTI::vector.

Referenced by run().

                                                         {
  link_coll.clear();
  for (DigitalVecType::const_iterator i = digis.begin(); i != digis.end(); i++) {
    // Instead of checking the validity of the links against the digis,
    //  let's loop over digis and push the corresponding link
    HitToDigisMapType::const_iterator mi(htd.find(i->strip()));
    if (mi == htd.end())
      continue;
    HitCounterToDigisMapType::const_iterator cmi(hctd.find(i->strip()));
    std::map<const PSimHit*, Amplitude> totalAmplitudePerSimHit;
    for (std::vector<std::pair<const PSimHit*, Amplitude> >::const_iterator simul = (*mi).second.begin();
         simul != (*mi).second.end();
         simul++) {
      totalAmplitudePerSimHit[(*simul).first] += (*simul).second;
    }

    //--- include the noise as well
    double totalAmplitude1 = afterNoise[(*mi).first];

    //--- digisimlink
    int sim_counter = 0;
    for (std::map<const PSimHit*, Amplitude>::const_iterator iter = totalAmplitudePerSimHit.begin();
         iter != totalAmplitudePerSimHit.end();
         iter++) {
      float threshold = 0.;
      float fraction = (*iter).second / totalAmplitude1;
      if (fraction >= threshold) {
        // Noise fluctuation could make fraction>1. Unphysical, set it by hand = 1.
        if (fraction > 1.)
          fraction = 1.;
        for (std::vector<std::pair<const PSimHit*, int> >::const_iterator simcount = (*cmi).second.begin();
             simcount != (*cmi).second.end();
             ++simcount) {
          if ((*iter).first == (*simcount).first)
            sim_counter = (*simcount).second;
        }
        link_coll.push_back(StripDigiSimLink((*mi).first,                 //channel
                                             ((*iter).first)->trackId(),  //simhit trackId
                                             sim_counter,                 //simhit counter
                                             ((*iter).first)->eventId(),  //simhit eventId
                                             fraction));                  //fraction
      }
    }
  }
}

push_link_raw()

void DigiSimLinkAlgorithm::push_link_raw ( const DigitalRawVecType &  digis, const HitToDigisMapType &  htd, const HitCounterToDigisMapType &  hctd, const std::vector< float > &  afterNoise, unsigned int  detID  )

private

Definition at line 366 of file DigiSimLinkAlgorithm.cc.

References digis, HLT_2022v11_cff::fraction, mps_fire::i, link_coll, remoteMonitoring_LASER_era2018_cfg::threshold, and trackerHitRTTI::vector.

Referenced by run().

                                                             {
  link_coll.clear();
  int nstrip = -1;
  for (DigitalRawVecType::const_iterator i = digis.begin(); i != digis.end(); i++) {
    nstrip++;
    // Instead of checking the validity of the links against the digis,
    //  let's loop over digis and push the corresponding link
    HitToDigisMapType::const_iterator mi(htd.find(nstrip));
    HitCounterToDigisMapType::const_iterator cmi(hctd.find(nstrip));
    if (mi == htd.end())
      continue;
    std::map<const PSimHit*, Amplitude> totalAmplitudePerSimHit;
    for (std::vector<std::pair<const PSimHit*, Amplitude> >::const_iterator simul = (*mi).second.begin();
         simul != (*mi).second.end();
         simul++) {
      totalAmplitudePerSimHit[(*simul).first] += (*simul).second;
    }

    //--- include the noise as well
    double totalAmplitude1 = afterNoise[(*mi).first];

    //--- digisimlink
    int sim_counter_raw = 0;
    for (std::map<const PSimHit*, Amplitude>::const_iterator iter = totalAmplitudePerSimHit.begin();
         iter != totalAmplitudePerSimHit.end();
         iter++) {
      float threshold = 0.;
      float fraction = (*iter).second / totalAmplitude1;
      if (fraction >= threshold) {
        //Noise fluctuation could make fraction>1. Unphysical, set it by hand.
        if (fraction > 1.)
          fraction = 1.;
        //add counter information
        for (std::vector<std::pair<const PSimHit*, int> >::const_iterator simcount = (*cmi).second.begin();
             simcount != (*cmi).second.end();
             ++simcount) {
          if ((*iter).first == (*simcount).first)
            sim_counter_raw = (*simcount).second;
        }
        link_coll.push_back(StripDigiSimLink((*mi).first,                 //channel
                                             ((*iter).first)->trackId(),  //simhit trackId
                                             sim_counter_raw,             //simhit counter
                                             ((*iter).first)->eventId(),  //simhit eventId
                                             fraction));                  //fraction
      }
    }
  }
}

run()

void DigiSimLinkAlgorithm::run	(	edm::DetSet< SiStripDigi > &	outdigi,
		edm::DetSet< SiStripRawDigi > &	outrawdigi,
		const std::vector< std::pair< const PSimHit *, int > > &	input,
		StripGeomDetUnit const *	det,
		GlobalVector	bfield,
		float	langle,
		edm::ESHandle< SiStripGain > &	gainHandle,
		edm::ESHandle< SiStripThreshold > &	thresholdHandle,
		edm::ESHandle< SiStripNoises > &	noiseHandle,
		edm::ESHandle< SiStripPedestals > &	pedestalHandle,
		edm::ESHandle< SiStripBadStrip > &	deadChannelHandle,
		const TrackerTopology *	tTopo,
		CLHEP::HepRandomEngine *	engine
	)

Definition at line 71 of file DigiSimLinkAlgorithm.cc.

References DigiSimLinkPileUpSignals::add(), SiGaussianTailNoiseAdder::addBaselineShift(), SiGaussianTailNoiseAdder::addCMNoise(), SiGaussianTailNoiseAdder::addNoise(), SiGaussianTailNoiseAdder::addNoiseVR(), SiGaussianTailNoiseAdder::addPedestals(), APVSaturationFromHIP, APVSaturationProb, BaselineShift, ALCARECOTkAlJpsiMuMu_cff::charge, cmnRMStec, cmnRMStib, cmnRMStid, cmnRMStob, CommonModeNoise, SiTrivialDigitalConverter::convert(), SiTrivialDigitalConverter::convertRaw(), cosmicShift, gather_cfg::cout, edm::DetSet< T >::data, SiStripBadStrip::decode(), detAmpl, digis, DigiSimLinkPileUpSignals::dumpCounterLink(), DigiSimLinkPileUpSignals::dumpLink(), fastSimProducer_cff::energyLoss, firstChannelWithSignal, compareTotals::fs, GeomDet::geographicalId(), SiStripNoises::getNoise(), SiStripPedestals::getPed(), SiStripNoises::getRange(), SiStripPedestals::getRange(), SiStripBadStrip::getRange(), SiStripGain::getRange(), SiStripGain::getStripGain(), inefficiency, input, createfilelist::int, lastChannelWithSignal, localFirstChannel, localLastChannel, locAmpl, mag(), noise, numStrips, particle, PbPb_ZMuSkimMuonDPG_cff::particleType, HiggsValidation_cfi::pdg_id, pdt, pedOffset, SiHitDigitizer::processHit(), edm::ESHandle< T >::product(), push_link(), push_link_raw(), rawdigis, DetId::rawId(), RealPedestals, DigiSimLinkPileUpSignals::reset(), SingleStripNoise, StripGeomDetUnit::specificTopology(), strip, ntupleEnum::SubDet, DetId::subdetId(), SiStripFedZeroSuppression::suppress(), GeomDet::surface(), theDigiSimLinkPileUpSignals, theElectronPerADC, theSiDigitalConverter, theSiHitDigitizer, theSiNoiseAdder, theSiZeroSuppress, tofCut, Surface::toGlobal(), and zeroSuppression.

                                                             {
  theDigiSimLinkPileUpSignals->reset();
  unsigned int detID = det->geographicalId().rawId();
  SiStripNoises::Range detNoiseRange = noiseHandle->getRange(detID);
  SiStripApvGain::Range detGainRange = gainHandle->getRange(detID);
  SiStripPedestals::Range detPedestalRange = pedestalHandle->getRange(detID);
  SiStripBadStrip::Range detBadStripRange = deadChannelHandle->getRange(detID);
  numStrips = (det->specificTopology()).nstrips();

  //stroing the bad stip of the the module. the module is not removed but just signal put to 0
  std::vector<bool> badChannels;
  badChannels.clear();
  badChannels.insert(badChannels.begin(), numStrips, false);
  SiStripBadStrip::data fs;
  for (SiStripBadStrip::ContainerIterator it = detBadStripRange.first; it != detBadStripRange.second; ++it) {
    fs = deadChannelHandle->decode(*it);
    for (int strip = fs.firstStrip; strip < fs.firstStrip + fs.range; ++strip)
      badChannels[strip] = true;
  }

  // local amplitude of detector channels (from processed PSimHit)
  //  locAmpl.clear();
  detAmpl.clear();
  //  locAmpl.insert(locAmpl.begin(),numStrips,0.);
  // total amplitude of detector channels
  detAmpl.insert(detAmpl.begin(), numStrips, 0.);

  firstChannelWithSignal = numStrips;
  lastChannelWithSignal = 0;

  // First: loop on the SimHits
  std::vector<std::pair<const PSimHit*, int> >::const_iterator simHitIter = input.begin();
  std::vector<std::pair<const PSimHit*, int> >::const_iterator simHitIterEnd = input.end();
  if (CLHEP::RandFlat::shoot(engine) > inefficiency) {
    for (; simHitIter != simHitIterEnd; ++simHitIter) {
      locAmpl.clear();
      locAmpl.insert(locAmpl.begin(), numStrips, 0.);
      // check TOF
      if (std::fabs(((*simHitIter).first)->tof() - cosmicShift -
                    det->surface().toGlobal(((*simHitIter).first)->localPosition()).mag() / 30.) < tofCut &&
          ((*simHitIter).first)->energyLoss() > 0) {
        localFirstChannel = numStrips;
        localLastChannel = 0;
        // process the hit
        theSiHitDigitizer->processHit(
            ((*simHitIter).first), *det, bfield, langle, locAmpl, localFirstChannel, localLastChannel, tTopo, engine);

        //APV Killer to simulate HIP effect
        //------------------------------------------------------

        if (APVSaturationFromHIP && !zeroSuppression) {
          int pdg_id = ((*simHitIter).first)->particleType();
          particle = pdt->particle(pdg_id);
          if (particle != nullptr) {
            float charge = particle->charge();
            bool isHadron = particle->isHadron();
            if (charge != 0 && isHadron) {
              if (CLHEP::RandFlat::shoot(engine) < APVSaturationProb) {
                int FirstAPV = localFirstChannel / 128;
                int LastAPV = localLastChannel / 128;
                std::cout << "-------------------HIP--------------" << std::endl;
                std::cout << "Killing APVs " << FirstAPV << " - " << LastAPV << " " << detID << std::endl;
                for (int strip = FirstAPV * 128; strip < LastAPV * 128 + 128; ++strip)
                  badChannels[strip] = true;  //doing like that I remove the signal information only after the
                                              //stip that got the HIP but it remains the signal of the previous
                                              //one. I'll make a further loop to remove all signal
              }
            }
          }
        }

        theDigiSimLinkPileUpSignals->add(
            locAmpl, localFirstChannel, localLastChannel, ((*simHitIter).first), (*simHitIter).second);

        // sum signal on strips
        for (size_t iChannel = localFirstChannel; iChannel < localLastChannel; iChannel++) {
          if (locAmpl[iChannel] > 0.) {
            //if(!badChannels[iChannel]) detAmpl[iChannel]+=locAmpl[iChannel];
            //locAmpl[iChannel]=0;
            detAmpl[iChannel] += locAmpl[iChannel];
          }
        }
        if (firstChannelWithSignal > localFirstChannel)
          firstChannelWithSignal = localFirstChannel;
        if (lastChannelWithSignal < localLastChannel)
          lastChannelWithSignal = localLastChannel;
      }
    }
  }

  //removing signal from the dead (and HIP effected) strips
  for (int strip = 0; strip < numStrips; ++strip)
    if (badChannels[strip])
      detAmpl[strip] = 0;

  const DigiSimLinkPileUpSignals::HitToDigisMapType& theLink(theDigiSimLinkPileUpSignals->dumpLink());
  const DigiSimLinkPileUpSignals::HitCounterToDigisMapType& theCounterLink(
      theDigiSimLinkPileUpSignals->dumpCounterLink());

  if (zeroSuppression) {
    if (noise) {
      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 noiseRMS = noiseHandle->getNoise(RefStrip, detNoiseRange);
        float gainValue = gainHandle->getStripGain(RefStrip, detGainRange);
        theSiNoiseAdder->addNoise(detAmpl,
                                  firstChannelWithSignal,
                                  lastChannelWithSignal,
                                  numStrips,
                                  noiseRMS * theElectronPerADC / gainValue,
                                  engine);
      }
    }
    digis.clear();
    theSiZeroSuppress->suppress(theSiDigitalConverter->convert(detAmpl, gainHandle.product(), detID),
                                digis,
                                detID,
                                *noiseHandle,
                                *thresholdHandle);
    push_link(digis, theLink, theCounterLink, detAmpl, detID);
    outdigi.data = digis;
  }

  if (!zeroSuppression) {
    //if(noise){
    // the constant pedestal offset is needed because
    //   negative adc counts are not allowed in case
    //   Pedestal and CMN subtraction is performed.
    //   The pedestal value read from the conditions
    //   is pedValue and after the pedestal subtraction
    //   the baseline is zero. The Common Mode Noise
    //   is not subtracted from the negative adc counts
    //   channels. Adding pedOffset the baseline is set
    //   to pedOffset after pedestal subtraction and CMN
    //   is subtracted to all the channels since none of
    //   them has negative adc value. The pedOffset is
    //   treated as a constant component in the CMN
    //   estimation and subtracted as CMN.

    //calculating the charge deposited on each APV and subtracting the shift
    //------------------------------------------------------
    if (BaselineShift) {
      theSiNoiseAdder->addBaselineShift(detAmpl, badChannels);
    }

    //Adding the strip noise
    //------------------------------------------------------
    if (noise) {
      std::vector<float> noiseRMSv;
      noiseRMSv.clear();
      noiseRMSv.insert(noiseRMSv.begin(), numStrips, 0.);

      if (SingleStripNoise) {
        for (int strip = 0; strip < numStrips; ++strip) {
          if (!badChannels[strip])
            noiseRMSv[strip] = (noiseHandle->getNoise(strip, detNoiseRange)) * theElectronPerADC;
        }

      } else {
        int RefStrip = 0;  //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 noiseRMS = noiseHandle->getNoise(RefStrip, detNoiseRange) * theElectronPerADC;
          for (int strip = 0; strip < numStrips; ++strip) {
            if (!badChannels[strip])
              noiseRMSv[strip] = noiseRMS;
          }
        }
      }

      theSiNoiseAdder->addNoiseVR(detAmpl, noiseRMSv, engine);
    }

    //adding the CMN
    //------------------------------------------------------
    if (CommonModeNoise) {
      float cmnRMS = 0.;
      DetId detId(detID);
      uint32_t SubDet = detId.subdetId();
      if (SubDet == 3) {
        cmnRMS = cmnRMStib;
      } else if (SubDet == 4) {
        cmnRMS = cmnRMStid;
      } else if (SubDet == 5) {
        cmnRMS = cmnRMStob;
      } else if (SubDet == 6) {
        cmnRMS = cmnRMStec;
      }
      cmnRMS *= theElectronPerADC;
      theSiNoiseAdder->addCMNoise(detAmpl, cmnRMS, badChannels, engine);
    }

    //Adding the pedestals
    //------------------------------------------------------

    std::vector<float> vPeds;
    vPeds.clear();
    vPeds.insert(vPeds.begin(), numStrips, 0.);

    if (RealPedestals) {
      for (int strip = 0; strip < numStrips; ++strip) {
        if (!badChannels[strip])
          vPeds[strip] = (pedestalHandle->getPed(strip, detPedestalRange) + pedOffset) * theElectronPerADC;
      }
    } else {
      for (int strip = 0; strip < numStrips; ++strip) {
        if (!badChannels[strip])
          vPeds[strip] = pedOffset * theElectronPerADC;
      }
    }

    theSiNoiseAdder->addPedestals(detAmpl, vPeds);

    //if(!RealPedestals&&!CommonModeNoise&&!noise&&!BaselineShift&&!APVSaturationFromHIP){
    //  edm::LogWarning("DigiSimLinkAlgorithm")<<"You are running the digitizer without Noise generation and without applying Zero Suppression. ARE YOU SURE???";
    //}else{

    rawdigis.clear();
    rawdigis = theSiDigitalConverter->convertRaw(detAmpl, gainHandle.product(), detID);
    push_link_raw(rawdigis, theLink, theCounterLink, detAmpl, detID);
    outrawdigi.data = rawdigis;

    //}
  }
}

setParticleDataTable()

void DigiSimLinkAlgorithm::setParticleDataTable ( const ParticleDataTable *  pardt )

inline

Definition at line 75 of file DigiSimLinkAlgorithm.h.

References pdt, SiHitDigitizer::setParticleDataTable(), and theSiHitDigitizer.

                                                            {
    theSiHitDigitizer->setParticleDataTable(pardt);
    pdt = pardt;
  }

Member Data Documentation

APVSaturationFromHIP

bool DigiSimLinkAlgorithm::APVSaturationFromHIP

private

Definition at line 95 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

APVSaturationProb

double DigiSimLinkAlgorithm::APVSaturationProb

private

Definition at line 88 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

BaselineShift

bool DigiSimLinkAlgorithm::BaselineShift

private

Definition at line 94 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

cmnRMStec

double DigiSimLinkAlgorithm::cmnRMStec

private

Definition at line 87 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

cmnRMStib

double DigiSimLinkAlgorithm::cmnRMStib

private

Definition at line 84 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

cmnRMStid

double DigiSimLinkAlgorithm::cmnRMStid

private

Definition at line 86 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

cmnRMStob

double DigiSimLinkAlgorithm::cmnRMStob

private

Definition at line 85 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

CommonModeNoise

bool DigiSimLinkAlgorithm::CommonModeNoise

private

Definition at line 93 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

conf_

edm::ParameterSet DigiSimLinkAlgorithm::conf_

private

Definition at line 81 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm().

cosmicShift

double DigiSimLinkAlgorithm::cosmicShift

private

Definition at line 106 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

detAmpl

std::vector<float> DigiSimLinkAlgorithm::detAmpl

private

Definition at line 119 of file DigiSimLinkAlgorithm.h.

Referenced by run().

digis

DigitalVecType DigiSimLinkAlgorithm::digis

private

Definition at line 130 of file DigiSimLinkAlgorithm.h.

Referenced by push_link(), push_link_raw(), and run().

firstChannelWithSignal

size_t DigiSimLinkAlgorithm::firstChannelWithSignal

private

Definition at line 111 of file DigiSimLinkAlgorithm.h.

Referenced by run().

inefficiency

double DigiSimLinkAlgorithm::inefficiency

private

Definition at line 107 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

lastChannelWithSignal

size_t DigiSimLinkAlgorithm::lastChannelWithSignal

private

Definition at line 112 of file DigiSimLinkAlgorithm.h.

Referenced by run().

link_coll

std::vector<StripDigiSimLink> DigiSimLinkAlgorithm::link_coll

private

Definition at line 132 of file DigiSimLinkAlgorithm.h.

Referenced by make_link(), push_link(), and push_link_raw().

localFirstChannel

size_t DigiSimLinkAlgorithm::localFirstChannel

private

Definition at line 113 of file DigiSimLinkAlgorithm.h.

Referenced by run().

localLastChannel

size_t DigiSimLinkAlgorithm::localLastChannel

private

Definition at line 114 of file DigiSimLinkAlgorithm.h.

Referenced by run().

locAmpl

std::vector<float> DigiSimLinkAlgorithm::locAmpl

private

Definition at line 117 of file DigiSimLinkAlgorithm.h.

Referenced by run().

noise

bool DigiSimLinkAlgorithm::noise

private

Definition at line 90 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

numStrips

int DigiSimLinkAlgorithm::numStrips

private

Definition at line 102 of file DigiSimLinkAlgorithm.h.

Referenced by run().

particle

const ParticleData* DigiSimLinkAlgorithm::particle

private

Definition at line 122 of file DigiSimLinkAlgorithm.h.

Referenced by run().

pdt

const ParticleDataTable* DigiSimLinkAlgorithm::pdt

private

Definition at line 121 of file DigiSimLinkAlgorithm.h.

Referenced by run(), and setParticleDataTable().

peakMode

bool DigiSimLinkAlgorithm::peakMode

private

Definition at line 89 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm().

pedOffset

double DigiSimLinkAlgorithm::pedOffset

private

Definition at line 108 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

PreMixing_

bool DigiSimLinkAlgorithm::PreMixing_

private

Definition at line 109 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm().

rawdigis

DigitalRawVecType DigiSimLinkAlgorithm::rawdigis

private

Definition at line 131 of file DigiSimLinkAlgorithm.h.

Referenced by run().

RealPedestals

bool DigiSimLinkAlgorithm::RealPedestals

private

Definition at line 91 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

SingleStripNoise

bool DigiSimLinkAlgorithm::SingleStripNoise

private

Definition at line 92 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

strip

int DigiSimLinkAlgorithm::strip

private

Definition at line 103 of file DigiSimLinkAlgorithm.h.

Referenced by run().

theDigiSimLinkPileUpSignals

DigiSimLinkPileUpSignals* DigiSimLinkAlgorithm::theDigiSimLinkPileUpSignals

private

Definition at line 125 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), run(), and ~DigiSimLinkAlgorithm().

theElectronPerADC

double DigiSimLinkAlgorithm::theElectronPerADC

private

Definition at line 82 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

theFedAlgo

int DigiSimLinkAlgorithm::theFedAlgo

private

Definition at line 97 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm().

theSiDigitalConverter

SiTrivialDigitalConverter* DigiSimLinkAlgorithm::theSiDigitalConverter

private

Definition at line 127 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), run(), and ~DigiSimLinkAlgorithm().

theSiHitDigitizer

SiHitDigitizer* DigiSimLinkAlgorithm::theSiHitDigitizer

private

Definition at line 124 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), run(), setParticleDataTable(), and ~DigiSimLinkAlgorithm().

theSiNoiseAdder

SiGaussianTailNoiseAdder* DigiSimLinkAlgorithm::theSiNoiseAdder

private

Definition at line 126 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), run(), and ~DigiSimLinkAlgorithm().

theSiZeroSuppress

SiStripFedZeroSuppression* DigiSimLinkAlgorithm::theSiZeroSuppress

private

Definition at line 128 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), run(), and ~DigiSimLinkAlgorithm().

theThreshold

double DigiSimLinkAlgorithm::theThreshold

private

Definition at line 83 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm().

theTOFCutForDeconvolution

double DigiSimLinkAlgorithm::theTOFCutForDeconvolution

private

Definition at line 100 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm().

theTOFCutForPeak

double DigiSimLinkAlgorithm::theTOFCutForPeak

private

Definition at line 99 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm().

tofCut

double DigiSimLinkAlgorithm::tofCut

private

Definition at line 101 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

zeroSuppression

bool DigiSimLinkAlgorithm::zeroSuppression

private

Definition at line 98 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().