|
|
|
#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, CLHEP::HepRandomEngine &) | |
| std::vector< StripDigiSimLink > | make_link () |
| void | run (edm::DetSet< SiStripDigi > &, edm::DetSet< SiStripRawDigi > &, const std::vector< std::pair< const PSimHit *, int > > &, StripGeomDetUnit *, GlobalVector, float, edm::ESHandle< SiStripGain > &, edm::ESHandle< SiStripThreshold > &, edm::ESHandle< SiStripNoises > &, edm::ESHandle< SiStripPedestals > &, edm::ESHandle< SiStripBadStrip > &, const TrackerTopology *tTopo) |
| void | setParticleDataTable (const ParticleDataTable *pardt) |
| ~DigiSimLinkAlgorithm () | |
Private Member Functions | |
| void | push_link (const DigitalVecType &, const HitToDigisMapType &, const HitCounterToDigisMapType &, const std::vector< double > &, unsigned int) |
| void | push_link_raw (const DigitalRawVecType &, const HitToDigisMapType &, const HitCounterToDigisMapType &, const std::vector< double > &, 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< double > | detAmpl |
| DigitalVecType | digis |
| size_t | firstChannelWithSignal |
| double | inefficiency |
| size_t | lastChannelWithSignal |
| std::vector< StripDigiSimLink > | link_coll |
| size_t | localFirstChannel |
| size_t | localLastChannel |
| std::vector< double > | locAmpl |
| bool | noise |
| int | numStrips |
| const ParticleData * | particle |
| const ParticleDataTable * | pdt |
| bool | peakMode |
| double | pedOffset |
| DigitalRawVecType | rawdigis |
| bool | RealPedestals |
| CLHEP::HepRandomEngine & | rndEngine |
| bool | SingleStripNoise |
| int | strip |
| DigiSimLinkPileUpSignals * | theDigiSimLinkPileUpSignals |
| double | theElectronPerADC |
| int | theFedAlgo |
| CLHEP::RandFlat * | theFlatDistribution |
| SiTrivialDigitalConverter * | theSiDigitalConverter |
| SiHitDigitizer * | theSiHitDigitizer |
| SiGaussianTailNoiseAdder * | theSiNoiseAdder |
| SiStripFedZeroSuppression * | theSiZeroSuppress |
| double | theThreshold |
| double | theTOFCutForDeconvolution |
| double | theTOFCutForPeak |
| double | tofCut |
| bool | zeroSuppression |
Definition at line 41 of file DigiSimLinkAlgorithm.h.
| typedef float DigiSimLinkAlgorithm::Amplitude |
Definition at line 48 of file DigiSimLinkAlgorithm.h.
Definition at line 44 of file DigiSimLinkAlgorithm.h.
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.
Definition at line 45 of file DigiSimLinkAlgorithm.h.
| DigiSimLinkAlgorithm::DigiSimLinkAlgorithm | ( | const edm::ParameterSet & | conf, |
| CLHEP::HepRandomEngine & | eng | ||
| ) |
Definition at line 19 of file DigiSimLinkAlgorithm.cc.
References APVSaturationFromHIP, APVSaturationProb, BaselineShift, cmnRMStec, cmnRMStib, cmnRMStid, cmnRMStob, CommonModeNoise, conf_, cosmicShift, inefficiency, noise, peakMode, pedOffset, RealPedestals, rndEngine, SingleStripNoise, theDigiSimLinkPileUpSignals, theElectronPerADC, theFedAlgo, theFlatDistribution, theSiDigitalConverter, theSiHitDigitizer, theSiNoiseAdder, theSiZeroSuppress, theThreshold, theTOFCutForDeconvolution, theTOFCutForPeak, tofCut, and zeroSuppression.
: conf_(conf),rndEngine(eng){ 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"); 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_,rndEngine); theDigiSimLinkPileUpSignals = new DigiSimLinkPileUpSignals(); theSiNoiseAdder = new SiGaussianTailNoiseAdder(theThreshold,rndEngine); theSiDigitalConverter = new SiTrivialDigitalConverter(theElectronPerADC); theSiZeroSuppress = new SiStripFedZeroSuppression(theFedAlgo); theFlatDistribution = new CLHEP::RandFlat(rndEngine, 0., 1.); }
| DigiSimLinkAlgorithm::~DigiSimLinkAlgorithm | ( | ) |
Definition at line 60 of file DigiSimLinkAlgorithm.cc.
References theDigiSimLinkPileUpSignals, theFlatDistribution, theSiDigitalConverter, theSiHitDigitizer, theSiNoiseAdder, and theSiZeroSuppress.
{
delete theSiHitDigitizer;
delete theDigiSimLinkPileUpSignals;
delete theSiNoiseAdder;
delete theSiDigitalConverter;
delete theSiZeroSuppress;
delete theFlatDistribution;
//delete particle;
//delete pdt;
}
| std::vector<StripDigiSimLink> DigiSimLinkAlgorithm::make_link | ( | ) | [inline] |
Definition at line 65 of file DigiSimLinkAlgorithm.h.
References link_coll.
Referenced by DigiSimLinkProducer::produce().
{ return link_coll; }
| void DigiSimLinkAlgorithm::push_link | ( | const DigitalVecType & | digis, |
| const HitToDigisMapType & | htd, | ||
| const HitCounterToDigisMapType & | hctd, | ||
| const std::vector< double > & | afterNoise, | ||
| unsigned int | detID | ||
| ) | [private] |
Definition at line 298 of file DigiSimLinkAlgorithm.cc.
References linker::i, and link_coll.
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< double > & | afterNoise, | ||
| unsigned int | detID | ||
| ) | [private] |
Definition at line 342 of file DigiSimLinkAlgorithm.cc.
References linker::i, and link_coll.
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 * | 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 | ||
| ) |
Definition at line 74 of file DigiSimLinkAlgorithm.cc.
References DigiSimLinkPileUpSignals::add(), SiGaussianTailNoiseAdder::addBaselineShift(), SiGaussianTailNoiseAdder::addCMNoise(), SiGaussianTailNoiseAdder::addNoise(), SiGaussianTailNoiseAdder::addNoiseVR(), SiGaussianTailNoiseAdder::addPedestals(), APVSaturationFromHIP, APVSaturationProb, BaselineShift, cmnRMStec, cmnRMStib, cmnRMStid, cmnRMStob, CommonModeNoise, SiTrivialDigitalConverter::convert(), SiTrivialDigitalConverter::convertRaw(), cosmicShift, detAmpl, digis, DigiSimLinkPileUpSignals::dumpCounterLink(), DigiSimLinkPileUpSignals::dumpLink(), firstChannelWithSignal, inefficiency, lastChannelWithSignal, localFirstChannel, localLastChannel, locAmpl, noise, numStrips, particle, pdt, pedOffset, SiHitDigitizer::processHit(), push_link(), push_link_raw(), rawdigis, RealPedestals, DigiSimLinkPileUpSignals::reset(), SingleStripNoise, strip, theDigiSimLinkPileUpSignals, theElectronPerADC, theFlatDistribution, theSiDigitalConverter, theSiHitDigitizer, theSiNoiseAdder, theSiZeroSuppress, tofCut, 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(theFlatDistribution->fire()>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);
//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(theFlatDistribution->fire()<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);
}
}
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);
}
//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);
}
//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 68 of file DigiSimLinkAlgorithm.h.
References pdt, SiHitDigitizer::setParticleDataTable(), and theSiHitDigitizer.
Referenced by DigiSimLinkProducer::produce().
{
theSiHitDigitizer->setParticleDataTable(pardt);
pdt= pardt;
}
bool DigiSimLinkAlgorithm::APVSaturationFromHIP [private] |
Definition at line 88 of file DigiSimLinkAlgorithm.h.
Referenced by DigiSimLinkAlgorithm(), and run().
double DigiSimLinkAlgorithm::APVSaturationProb [private] |
Definition at line 81 of file DigiSimLinkAlgorithm.h.
Referenced by DigiSimLinkAlgorithm(), and run().
bool DigiSimLinkAlgorithm::BaselineShift [private] |
Definition at line 87 of file DigiSimLinkAlgorithm.h.
Referenced by DigiSimLinkAlgorithm(), and run().
double DigiSimLinkAlgorithm::cmnRMStec [private] |
Definition at line 80 of file DigiSimLinkAlgorithm.h.
Referenced by DigiSimLinkAlgorithm(), and run().
double DigiSimLinkAlgorithm::cmnRMStib [private] |
Definition at line 77 of file DigiSimLinkAlgorithm.h.
Referenced by DigiSimLinkAlgorithm(), and run().
double DigiSimLinkAlgorithm::cmnRMStid [private] |
Definition at line 79 of file DigiSimLinkAlgorithm.h.
Referenced by DigiSimLinkAlgorithm(), and run().
double DigiSimLinkAlgorithm::cmnRMStob [private] |
Definition at line 78 of file DigiSimLinkAlgorithm.h.
Referenced by DigiSimLinkAlgorithm(), and run().
bool DigiSimLinkAlgorithm::CommonModeNoise [private] |
Definition at line 86 of file DigiSimLinkAlgorithm.h.
Referenced by DigiSimLinkAlgorithm(), and run().
edm::ParameterSet DigiSimLinkAlgorithm::conf_ [private] |
Definition at line 74 of file DigiSimLinkAlgorithm.h.
Referenced by DigiSimLinkAlgorithm().
double DigiSimLinkAlgorithm::cosmicShift [private] |
Definition at line 99 of file DigiSimLinkAlgorithm.h.
Referenced by DigiSimLinkAlgorithm(), and run().
std::vector<double> DigiSimLinkAlgorithm::detAmpl [private] |
Definition at line 111 of file DigiSimLinkAlgorithm.h.
Referenced by run().
DigitalVecType DigiSimLinkAlgorithm::digis [private] |
Definition at line 123 of file DigiSimLinkAlgorithm.h.
Referenced by run().
size_t DigiSimLinkAlgorithm::firstChannelWithSignal [private] |
Definition at line 103 of file DigiSimLinkAlgorithm.h.
Referenced by run().
double DigiSimLinkAlgorithm::inefficiency [private] |
Definition at line 100 of file DigiSimLinkAlgorithm.h.
Referenced by DigiSimLinkAlgorithm(), and run().
size_t DigiSimLinkAlgorithm::lastChannelWithSignal [private] |
Definition at line 104 of file DigiSimLinkAlgorithm.h.
Referenced by run().
std::vector<StripDigiSimLink> DigiSimLinkAlgorithm::link_coll [private] |
Definition at line 125 of file DigiSimLinkAlgorithm.h.
Referenced by make_link(), push_link(), and push_link_raw().
size_t DigiSimLinkAlgorithm::localFirstChannel [private] |
Definition at line 105 of file DigiSimLinkAlgorithm.h.
Referenced by run().
size_t DigiSimLinkAlgorithm::localLastChannel [private] |
Definition at line 106 of file DigiSimLinkAlgorithm.h.
Referenced by run().
std::vector<double> DigiSimLinkAlgorithm::locAmpl [private] |
Definition at line 109 of file DigiSimLinkAlgorithm.h.
Referenced by run().
bool DigiSimLinkAlgorithm::noise [private] |
Definition at line 83 of file DigiSimLinkAlgorithm.h.
Referenced by DigiSimLinkAlgorithm(), and run().
int DigiSimLinkAlgorithm::numStrips [private] |
Definition at line 95 of file DigiSimLinkAlgorithm.h.
Referenced by run().
const ParticleData* DigiSimLinkAlgorithm::particle [private] |
Definition at line 114 of file DigiSimLinkAlgorithm.h.
Referenced by run().
const ParticleDataTable* DigiSimLinkAlgorithm::pdt [private] |
Definition at line 113 of file DigiSimLinkAlgorithm.h.
Referenced by run(), and setParticleDataTable().
bool DigiSimLinkAlgorithm::peakMode [private] |
Definition at line 82 of file DigiSimLinkAlgorithm.h.
Referenced by DigiSimLinkAlgorithm().
double DigiSimLinkAlgorithm::pedOffset [private] |
Definition at line 101 of file DigiSimLinkAlgorithm.h.
Referenced by DigiSimLinkAlgorithm(), and run().
Definition at line 124 of file DigiSimLinkAlgorithm.h.
Referenced by run().
bool DigiSimLinkAlgorithm::RealPedestals [private] |
Definition at line 84 of file DigiSimLinkAlgorithm.h.
Referenced by DigiSimLinkAlgorithm(), and run().
CLHEP::HepRandomEngine& DigiSimLinkAlgorithm::rndEngine [private] |
Definition at line 121 of file DigiSimLinkAlgorithm.h.
Referenced by DigiSimLinkAlgorithm().
bool DigiSimLinkAlgorithm::SingleStripNoise [private] |
Definition at line 85 of file DigiSimLinkAlgorithm.h.
Referenced by DigiSimLinkAlgorithm(), and run().
int DigiSimLinkAlgorithm::strip [private] |
Definition at line 96 of file DigiSimLinkAlgorithm.h.
Referenced by run().
Definition at line 117 of file DigiSimLinkAlgorithm.h.
Referenced by DigiSimLinkAlgorithm(), run(), and ~DigiSimLinkAlgorithm().
double DigiSimLinkAlgorithm::theElectronPerADC [private] |
Definition at line 75 of file DigiSimLinkAlgorithm.h.
Referenced by DigiSimLinkAlgorithm(), and run().
int DigiSimLinkAlgorithm::theFedAlgo [private] |
Definition at line 90 of file DigiSimLinkAlgorithm.h.
Referenced by DigiSimLinkAlgorithm().
CLHEP::RandFlat* DigiSimLinkAlgorithm::theFlatDistribution [private] |
Definition at line 126 of file DigiSimLinkAlgorithm.h.
Referenced by DigiSimLinkAlgorithm(), run(), and ~DigiSimLinkAlgorithm().
Definition at line 119 of file DigiSimLinkAlgorithm.h.
Referenced by DigiSimLinkAlgorithm(), run(), and ~DigiSimLinkAlgorithm().
Definition at line 116 of file DigiSimLinkAlgorithm.h.
Referenced by DigiSimLinkAlgorithm(), run(), setParticleDataTable(), and ~DigiSimLinkAlgorithm().
Definition at line 118 of file DigiSimLinkAlgorithm.h.
Referenced by DigiSimLinkAlgorithm(), run(), and ~DigiSimLinkAlgorithm().
SiStripFedZeroSuppression* DigiSimLinkAlgorithm::theSiZeroSuppress [private] |
Definition at line 120 of file DigiSimLinkAlgorithm.h.
Referenced by DigiSimLinkAlgorithm(), run(), and ~DigiSimLinkAlgorithm().
double DigiSimLinkAlgorithm::theThreshold [private] |
Definition at line 76 of file DigiSimLinkAlgorithm.h.
Referenced by DigiSimLinkAlgorithm().
double DigiSimLinkAlgorithm::theTOFCutForDeconvolution [private] |
Definition at line 93 of file DigiSimLinkAlgorithm.h.
Referenced by DigiSimLinkAlgorithm().
double DigiSimLinkAlgorithm::theTOFCutForPeak [private] |
Definition at line 92 of file DigiSimLinkAlgorithm.h.
Referenced by DigiSimLinkAlgorithm().
double DigiSimLinkAlgorithm::tofCut [private] |
Definition at line 94 of file DigiSimLinkAlgorithm.h.
Referenced by DigiSimLinkAlgorithm(), and run().
bool DigiSimLinkAlgorithm::zeroSuppression [private] |
Definition at line 91 of file DigiSimLinkAlgorithm.h.
Referenced by DigiSimLinkAlgorithm(), and run().
1.7.3