#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

typedef float DigiSimLinkAlgorithm::Amplitude

Definition at line 48 of file DigiSimLinkAlgorithm.h.

typedef SiDigitalConverter::DigitalRawVecType DigiSimLinkAlgorithm::DigitalRawVecType

Definition at line 44 of file DigiSimLinkAlgorithm.h.

typedef SiDigitalConverter::DigitalVecType DigiSimLinkAlgorithm::DigitalVecType

Definition at line 43 of file DigiSimLinkAlgorithm.h.

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

Definition at line 47 of file DigiSimLinkAlgorithm.h.

typedef DigiSimLinkPileUpSignals::HitCounterToDigisMapType DigiSimLinkAlgorithm::HitCounterToDigisMapType

Definition at line 46 of file DigiSimLinkAlgorithm.h.

typedef DigiSimLinkPileUpSignals::HitToDigisMapType DigiSimLinkAlgorithm::HitToDigisMapType

Definition at line 45 of file DigiSimLinkAlgorithm.h.

Constructor & Destructor Documentation

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, 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 ( )

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

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

inline

Definition at line 72 of file DigiSimLinkAlgorithm.h.

References link_coll.

72 { return link_coll; }

DigiSimLinkAlgorithm::link_coll

std::vector< StripDigiSimLink > link_coll

Definition: DigiSimLinkAlgorithm.h:132

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 HLT_FULL_cff::fraction, mps_fire::i, link_coll, dtDQMClient_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
       }
     }
   }
 }

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 HLT_FULL_cff::fraction, mps_fire::i, link_coll, dtDQMClient_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
       }
     }
   }
 }

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, RecoTauCleanerPlugins::charge, cmnRMStec, cmnRMStib, cmnRMStid, cmnRMStob, CommonModeNoise, SiTrivialDigitalConverter::convert(), SiTrivialDigitalConverter::convertRaw(), cosmicShift, gather_cfg::cout, edm::DetSet< T >::data, detAmpl, digis, DigiSimLinkPileUpSignals::dumpCounterLink(), DigiSimLinkPileUpSignals::dumpLink(), firstChannelWithSignal, SiStripBadStrip::data::firstStrip, compareTotals::fs, GeomDet::geographicalId(), inefficiency, input, lastChannelWithSignal, localFirstChannel, localLastChannel, locAmpl, mag(), noise, numStrips, particle, HLT_FULL_cff::particleType, pdt, pedOffset, SiHitDigitizer::processHit(), edm::ESHandle< class >::product(), push_link(), push_link_raw(), SiStripBadStrip::data::range, 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;
 
     //}
   }
 }

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

bool DigiSimLinkAlgorithm::APVSaturationFromHIP

private

Definition at line 95 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

double DigiSimLinkAlgorithm::APVSaturationProb

private

Definition at line 88 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

bool DigiSimLinkAlgorithm::BaselineShift

private

Definition at line 94 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

double DigiSimLinkAlgorithm::cmnRMStec

private

Definition at line 87 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

double DigiSimLinkAlgorithm::cmnRMStib

private

Definition at line 84 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

double DigiSimLinkAlgorithm::cmnRMStid

private

Definition at line 86 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

double DigiSimLinkAlgorithm::cmnRMStob

private

Definition at line 85 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

bool DigiSimLinkAlgorithm::CommonModeNoise

private

Definition at line 93 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

edm::ParameterSet DigiSimLinkAlgorithm::conf_

private

Definition at line 81 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm().

double DigiSimLinkAlgorithm::cosmicShift

private

Definition at line 106 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

std::vector<float> DigiSimLinkAlgorithm::detAmpl

private

Definition at line 119 of file DigiSimLinkAlgorithm.h.

Referenced by run().

DigitalVecType DigiSimLinkAlgorithm::digis

private

Definition at line 130 of file DigiSimLinkAlgorithm.h.

Referenced by run().

size_t DigiSimLinkAlgorithm::firstChannelWithSignal

private

Definition at line 111 of file DigiSimLinkAlgorithm.h.

Referenced by run().

double DigiSimLinkAlgorithm::inefficiency

private

Definition at line 107 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

size_t DigiSimLinkAlgorithm::lastChannelWithSignal

private

Definition at line 112 of file DigiSimLinkAlgorithm.h.

Referenced by run().

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().

size_t DigiSimLinkAlgorithm::localFirstChannel

private

Definition at line 113 of file DigiSimLinkAlgorithm.h.

Referenced by run().

size_t DigiSimLinkAlgorithm::localLastChannel

private

Definition at line 114 of file DigiSimLinkAlgorithm.h.

Referenced by run().

std::vector<float> DigiSimLinkAlgorithm::locAmpl

private

Definition at line 117 of file DigiSimLinkAlgorithm.h.

Referenced by run().

bool DigiSimLinkAlgorithm::noise

private

Definition at line 90 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

int DigiSimLinkAlgorithm::numStrips

private

Definition at line 102 of file DigiSimLinkAlgorithm.h.

Referenced by run().

const ParticleData* DigiSimLinkAlgorithm::particle

private

Definition at line 122 of file DigiSimLinkAlgorithm.h.

Referenced by run().

const ParticleDataTable* DigiSimLinkAlgorithm::pdt

private

Definition at line 121 of file DigiSimLinkAlgorithm.h.

Referenced by run(), and setParticleDataTable().

bool DigiSimLinkAlgorithm::peakMode

private

Definition at line 89 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm().

double DigiSimLinkAlgorithm::pedOffset

private

Definition at line 108 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

bool DigiSimLinkAlgorithm::PreMixing_

private

Definition at line 109 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm().

DigitalRawVecType DigiSimLinkAlgorithm::rawdigis

private

Definition at line 131 of file DigiSimLinkAlgorithm.h.

Referenced by run().

bool DigiSimLinkAlgorithm::RealPedestals

private

Definition at line 91 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

bool DigiSimLinkAlgorithm::SingleStripNoise

private

Definition at line 92 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

int DigiSimLinkAlgorithm::strip

private

Definition at line 103 of file DigiSimLinkAlgorithm.h.

Referenced by run().

DigiSimLinkPileUpSignals* DigiSimLinkAlgorithm::theDigiSimLinkPileUpSignals

private

Definition at line 125 of file DigiSimLinkAlgorithm.h.

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

double DigiSimLinkAlgorithm::theElectronPerADC

private

Definition at line 82 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

int DigiSimLinkAlgorithm::theFedAlgo

private

Definition at line 97 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm().

SiTrivialDigitalConverter* DigiSimLinkAlgorithm::theSiDigitalConverter

private

Definition at line 127 of file DigiSimLinkAlgorithm.h.

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

SiHitDigitizer* DigiSimLinkAlgorithm::theSiHitDigitizer

private

Definition at line 124 of file DigiSimLinkAlgorithm.h.

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

SiGaussianTailNoiseAdder* DigiSimLinkAlgorithm::theSiNoiseAdder

private

Definition at line 126 of file DigiSimLinkAlgorithm.h.

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

SiStripFedZeroSuppression* DigiSimLinkAlgorithm::theSiZeroSuppress

private

Definition at line 128 of file DigiSimLinkAlgorithm.h.

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

double DigiSimLinkAlgorithm::theThreshold

private

Definition at line 83 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm().

double DigiSimLinkAlgorithm::theTOFCutForDeconvolution

private

Definition at line 100 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm().

double DigiSimLinkAlgorithm::theTOFCutForPeak

private

Definition at line 99 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm().

double DigiSimLinkAlgorithm::tofCut

private

Definition at line 101 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

bool DigiSimLinkAlgorithm::zeroSuppression

private

Definition at line 98 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation