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

DigiSimLinkAlgorithm::~DigiSimLinkAlgorithm ( )

Definition at line 59 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 66 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkProducer::produce().

66 { return link_coll; }

DigiSimLinkAlgorithm::link_coll

std::vector< StripDigiSimLink > link_coll

Definition: DigiSimLinkAlgorithm.h:127

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 297 of file DigiSimLinkAlgorithm.cc.

References dedxEstimators_cff::fraction, mps_fire::i, link_coll, and electronIdCutBased_cfi::threshold.

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 341 of file DigiSimLinkAlgorithm.cc.

References dedxEstimators_cff::fraction, mps_fire::i, link_coll, and electronIdCutBased_cfi::threshold.

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 72 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(), firstChannelWithSignal, SiStripBadStrip::data::firstStrip, GeomDet::geographicalId(), SiStripNoises::getNoise(), SiStripPedestals::getPed(), SiStripNoises::getRange(), SiStripPedestals::getRange(), SiStripGain::getRange(), SiStripBadStrip::getRange(), SiStripGain::getStripGain(), inefficiency, input, createfilelist::int, lastChannelWithSignal, localFirstChannel, localLastChannel, locAmpl, mag(), noise, NULL, numStrips, particle, objects.autophobj::particleType, HiggsValidation_cfi::pdg_id, pdt, pedOffset, SiHitDigitizer::processHit(), 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.

Referenced by DigiSimLinkProducer::produce().

                                                              {
   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 != NULL){
                 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, 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, detID);
     push_link_raw(rawdigis, theLink, theCounterLink, detAmpl,detID);
     outrawdigi.data = rawdigis;
     
     //}
   }
 }

void DigiSimLinkAlgorithm::setParticleDataTable ( const ParticleDataTable * pardt )

inline

Definition at line 69 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkProducer::produce().

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

Member Data Documentation

bool DigiSimLinkAlgorithm::APVSaturationFromHIP

private

Definition at line 89 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

double DigiSimLinkAlgorithm::APVSaturationProb

private

Definition at line 82 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

bool DigiSimLinkAlgorithm::BaselineShift

private

Definition at line 88 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

double DigiSimLinkAlgorithm::cmnRMStec

private

Definition at line 81 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

double DigiSimLinkAlgorithm::cmnRMStib

private

Definition at line 78 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

double DigiSimLinkAlgorithm::cmnRMStid

private

Definition at line 80 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

double DigiSimLinkAlgorithm::cmnRMStob

private

Definition at line 79 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

bool DigiSimLinkAlgorithm::CommonModeNoise

private

Definition at line 87 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

edm::ParameterSet DigiSimLinkAlgorithm::conf_

private

Definition at line 75 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm().

double DigiSimLinkAlgorithm::cosmicShift

private

Definition at line 100 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

std::vector<float> DigiSimLinkAlgorithm::detAmpl

private

Definition at line 114 of file DigiSimLinkAlgorithm.h.

Referenced by run().

DigitalVecType DigiSimLinkAlgorithm::digis

private

Definition at line 125 of file DigiSimLinkAlgorithm.h.

Referenced by run().

size_t DigiSimLinkAlgorithm::firstChannelWithSignal

private

Definition at line 106 of file DigiSimLinkAlgorithm.h.

Referenced by run().

double DigiSimLinkAlgorithm::inefficiency

private

Definition at line 101 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

size_t DigiSimLinkAlgorithm::lastChannelWithSignal

private

Definition at line 107 of file DigiSimLinkAlgorithm.h.

Referenced by run().

std::vector<StripDigiSimLink> DigiSimLinkAlgorithm::link_coll

private

Definition at line 127 of file DigiSimLinkAlgorithm.h.

Referenced by push_link(), and push_link_raw().

size_t DigiSimLinkAlgorithm::localFirstChannel

private

Definition at line 108 of file DigiSimLinkAlgorithm.h.

Referenced by run().

size_t DigiSimLinkAlgorithm::localLastChannel

private

Definition at line 109 of file DigiSimLinkAlgorithm.h.

Referenced by run().

std::vector<float> DigiSimLinkAlgorithm::locAmpl

private

Definition at line 112 of file DigiSimLinkAlgorithm.h.

Referenced by run().

bool DigiSimLinkAlgorithm::noise

private

Definition at line 84 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

int DigiSimLinkAlgorithm::numStrips

private

Definition at line 96 of file DigiSimLinkAlgorithm.h.

Referenced by run().

const ParticleData* DigiSimLinkAlgorithm::particle

private

Definition at line 117 of file DigiSimLinkAlgorithm.h.

Referenced by run().

const ParticleDataTable* DigiSimLinkAlgorithm::pdt

private

Definition at line 116 of file DigiSimLinkAlgorithm.h.

Referenced by run().

bool DigiSimLinkAlgorithm::peakMode

private

Definition at line 83 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm().

double DigiSimLinkAlgorithm::pedOffset

private

Definition at line 102 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

bool DigiSimLinkAlgorithm::PreMixing_

private

Definition at line 103 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm().

DigitalRawVecType DigiSimLinkAlgorithm::rawdigis

private

Definition at line 126 of file DigiSimLinkAlgorithm.h.

Referenced by run().

bool DigiSimLinkAlgorithm::RealPedestals

private

Definition at line 85 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

bool DigiSimLinkAlgorithm::SingleStripNoise

private

Definition at line 86 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

int DigiSimLinkAlgorithm::strip

private

Definition at line 97 of file DigiSimLinkAlgorithm.h.

Referenced by run().

DigiSimLinkPileUpSignals* DigiSimLinkAlgorithm::theDigiSimLinkPileUpSignals

private

Definition at line 120 of file DigiSimLinkAlgorithm.h.

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

double DigiSimLinkAlgorithm::theElectronPerADC

private

Definition at line 76 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

int DigiSimLinkAlgorithm::theFedAlgo

private

Definition at line 91 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm().

SiTrivialDigitalConverter* DigiSimLinkAlgorithm::theSiDigitalConverter

private

Definition at line 122 of file DigiSimLinkAlgorithm.h.

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

SiHitDigitizer* DigiSimLinkAlgorithm::theSiHitDigitizer

private

Definition at line 119 of file DigiSimLinkAlgorithm.h.

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

SiGaussianTailNoiseAdder* DigiSimLinkAlgorithm::theSiNoiseAdder

private

Definition at line 121 of file DigiSimLinkAlgorithm.h.

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

SiStripFedZeroSuppression* DigiSimLinkAlgorithm::theSiZeroSuppress

private

Definition at line 123 of file DigiSimLinkAlgorithm.h.

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

double DigiSimLinkAlgorithm::theThreshold

private

Definition at line 77 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm().

double DigiSimLinkAlgorithm::theTOFCutForDeconvolution

private

Definition at line 94 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm().

double DigiSimLinkAlgorithm::theTOFCutForPeak

private

Definition at line 93 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm().

double DigiSimLinkAlgorithm::tofCut

private

Definition at line 95 of file DigiSimLinkAlgorithm.h.

Referenced by DigiSimLinkAlgorithm(), and run().

bool DigiSimLinkAlgorithm::zeroSuppression

private

Definition at line 92 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