#include <CSCStripElectronicsSim.h>

Inheritance diagram for CSCStripElectronicsSim:

Public Member Functions
void	createDigi (int istrip, const CSCAnalogSignal &signal, std::vector< CSCStripDigi > &result, CLHEP::HepRandomEngine *)

	CSCStripElectronicsSim (const edm::ParameterSet &p)
	configurable parameters More...

void	fillDigis (CSCStripDigiCollection &digis, CSCComparatorDigiCollection &comparators, CLHEP::HepRandomEngine *)

void	fillMissingLayer (const CSCLayer layer, const CSCComparatorDigiCollection &comparators, CSCStripDigiCollection &digis, CLHEP::HepRandomEngine )

CSCAnalogSignal	makeNoiseSignal (int element, CLHEP::HepRandomEngine *) override

void	setStripConditions (CSCStripConditions *cond)

	~CSCStripElectronicsSim () override

Public Member Functions inherited from CSCBaseElectronicsSim
const DigiSimLinks &	digiSimLinks () const

void	setLayerId (const CSCDetId &id)
	for standalone apps who don't calculate it from the geometry More...

void	simulate (const CSCLayer layer, const std::vector< CSCDetectorHit > &inputHits, CLHEP::HepRandomEngine )

virtual	~CSCBaseElectronicsSim ()

Private Member Functions
void	addCrosstalk (CLHEP::HepRandomEngine *)

void	addCrosstalk (const CSCAnalogSignal &signal, int thisStrip, int otherStrip, CLHEP::HepRandomEngine *)

float	calculateAmpResponse (float t) const override

std::list< int >	channelsToRead (const std::list< int > &keyStrips, int window) const

float	comparatorReading (const CSCAnalogSignal &signal, float time, CLHEP::HepRandomEngine *) const
	calculates the comparator reading, including saturation and offsets More...

void	doSaturation (CSCStripDigi &digi)

void	fillStripDigis (const std::list< int > &keyStrips, CSCStripDigiCollection &digis, CLHEP::HepRandomEngine *)

std::list< int >	getKeyStrips (const std::vector< CSCComparatorDigi > &comparators) const
	finds the key strips from these comparators More...

std::list< int >	getKeyStripsFromMC () const
	get ths strips that have detector hits More...

void	getReadoutRange (int inputStrip, int &minStrip, int &maxStrip)

void	initParameters () override
	initialization for each layer More...

int	readoutElement (int strip) const override

void	runComparator (std::vector< CSCComparatorDigi > &result, CLHEP::HepRandomEngine *)

void	selfTest () const

Private Attributes
bool	doCrosstalk_

bool	doSuppression_

int	nScaBins_

int	sca_peak_bin

float	sca_time_bin_size

CSCStripAmpResponse	theAmpResponse

float	theAverageTimeOfFlight

int	theComparatorClockJump

float	theComparatorDeadTime

float	theComparatorNoise

float	theComparatorRMSOffset

double	theComparatorSamplingTime

float	theComparatorSaturation

float	theComparatorThreshold

double	theComparatorTimeBinOffset

double	theComparatorTimeOffset

float	theComparatorWait

CSCCrosstalkGenerator *	theCrosstalkGenerator

float	theDaqDeadTime

std::vector< double >	theSCATimingOffsets

CSCStripConditions *	theStripConditions

float	theTimingOffset

Additional Inherited Members
Public Types inherited from CSCBaseElectronicsSim
typedef std::map< int, CSCAnalogSignal, std::less< int > >	CSCSignalMap

typedef edm::DetSet< StripDigiSimLink >	DigiSimLinks

Protected Types inherited from CSCBaseElectronicsSim
enum	{ NONE, CONSERVATIVE, RADICAL }

typedef std::multimap< int, CSCDetectorHit, std::less< int > >	DetectorHitMap

Protected Member Functions inherited from CSCBaseElectronicsSim
CSCAnalogSignal &	add (const CSCAnalogSignal &, CLHEP::HepRandomEngine *)

virtual void	addLinks (int channelIndex)

void	addNoise (CLHEP::HepRandomEngine *)

CSCAnalogSignal	amplifySignal (const CSCDetectorHit &)

double	averageTimeOfFlight (const DetId &detId) const

virtual int	channelIndex (int channel) const
	lets users map channels to different indices for links More...

void	combineAnalogSignals (const std::vector< CSCAnalogSignal > &)

	CSCBaseElectronicsSim (const edm::ParameterSet &p)

void	fillAmpResponse ()

CSCAnalogSignal &	find (int element, CLHEP::HepRandomEngine *)

CSCDetId	layerId () const
	the CSCDetId corresponding to the current layer More...

void	setLayer (const CSCLayer *layer)

void	setNoise (float rmsNoise, float noiseSigmaThreshold)

void	setSignalTimeRange (double startTime, double stopTime)

virtual float	signalDelay (int element, float pos) const

Protected Attributes inherited from CSCBaseElectronicsSim
bool	doNoise_

int	nElements

CSCAnalogSignal	theAmpResponse

float	theBunchSpacing

std::vector< double >	theBunchTimingOffsets

DetectorHitMap	theDetectorHitMap

DigiSimLinks	theDigiSimLinks

const CSCLayer *	theLayer

const CSCLayerGeometry *	theLayerGeometry

CSCDetId	theLayerId

bool	theNoiseWasAdded

int	theNumberOfSamples

int	theOffsetOfBxZero

float	thePeakTimeSigma

float	theSamplingTime

int	theShapingTime

CSCSignalMap	theSignalMap

std::vector< double >	theSignalPropagationSpeed

float	theSignalStartTime

float	theSignalStopTime

const CSCChamberSpecs *	theSpecs

std::vector< double >	theTimingCalibrationError

Detailed Description

Model the readout electronics chain for EMU CSC strips

Author: Rick Wilkinson

Definition at line 28 of file CSCStripElectronicsSim.h.

Constructor & Destructor Documentation

◆ CSCStripElectronicsSim()

CSCStripElectronicsSim::CSCStripElectronicsSim ( const edm::ParameterSet & p )

explicit

configurable parameters

Definition at line 25 of file CSCStripElectronicsSim.cc.

References doCrosstalk_, CSCBaseElectronicsSim::fillAmpResponse(), and theCrosstalkGenerator.

     : CSCBaseElectronicsSim(p),
       theAmpResponse(theShapingTime, CSCStripAmpResponse::RADICAL),
       theComparatorThreshold(20.),
       theComparatorNoise(0.),
       theComparatorRMSOffset(2.),
       theComparatorSaturation(1057.),
       theComparatorWait(50.),
       theComparatorDeadTime(100.),
       theDaqDeadTime(200.),
       theTimingOffset(0.),
       nScaBins_(p.getParameter<int>("nScaBins")),
       doSuppression_(p.getParameter<bool>("doSuppression")),
       doCrosstalk_(p.getParameter<bool>("doCrosstalk")),
       theStripConditions(nullptr),
       theCrosstalkGenerator(nullptr),
       theComparatorClockJump(2),
       sca_time_bin_size(50.),
       sca_peak_bin(p.getParameter<int>("scaPeakBin")),
       theComparatorTimeBinOffset(p.getParameter<double>("comparatorTimeBinOffset")),
       theComparatorTimeOffset(p.getParameter<double>("comparatorTimeOffset")),
       theComparatorSamplingTime(p.getParameter<double>("comparatorSamplingTime")),
       theSCATimingOffsets(p.getParameter<std::vector<double>>("scaTimingOffsets")) {
   if (doCrosstalk_) {
     theCrosstalkGenerator = new CSCCrosstalkGenerator();
   }
 
   fillAmpResponse();
 }

◆ ~CSCStripElectronicsSim()

CSCStripElectronicsSim::~CSCStripElectronicsSim ( )

override

Definition at line 55 of file CSCStripElectronicsSim.cc.

References doCrosstalk_, and theCrosstalkGenerator.

                                                 {
   if (doCrosstalk_) {
     delete theCrosstalkGenerator;
   }
 }

Member Function Documentation

◆ addCrosstalk() [1/2]

void CSCStripElectronicsSim::addCrosstalk ( CLHEP::HepRandomEngine * engine )

private

Definition at line 322 of file CSCStripElectronicsSim.cc.

References CSCBaseElectronicsSim::nElements, jetUpdater_cfi::sort, SortSignalsByTotal(), and CSCBaseElectronicsSim::theSignalMap.

Referenced by fillDigis().

                                                                       {
   // this is needed so we can add a noise signal to the map
   // without messing up any iterators
   std::vector<CSCAnalogSignal> realSignals;
   realSignals.reserve(theSignalMap.size());
   CSCSignalMap::iterator mapI = theSignalMap.begin(), mapEnd = theSignalMap.end();
   for (; mapI != mapEnd; ++mapI) {
     realSignals.push_back((*mapI).second);
   }
   sort(realSignals.begin(), realSignals.end(), SortSignalsByTotal);
   std::vector<CSCAnalogSignal>::iterator realSignalItr = realSignals.begin(), realSignalsEnd = realSignals.end();
   for (; realSignalItr != realSignalsEnd; ++realSignalItr) {
     int thisStrip = (*realSignalItr).getElement();
     // add it to each neighbor
     if (thisStrip > 1) {
       int otherStrip = thisStrip - 1;
       addCrosstalk(*realSignalItr, thisStrip, otherStrip, engine);
     }
     if (thisStrip < nElements) {
       int otherStrip = thisStrip + 1;
       addCrosstalk(*realSignalItr, thisStrip, otherStrip, engine);
     }
   }
 }

◆ addCrosstalk() [2/2]

void CSCStripElectronicsSim::addCrosstalk	(	const CSCAnalogSignal &	signal,
		int	thisStrip,
		int	otherStrip,
		CLHEP::HepRandomEngine *	engine
	)

private

Definition at line 347 of file CSCStripElectronicsSim.cc.

References CSCStripConditions::crosstalk(), CSCBaseElectronicsSim::find(), CSCCrosstalkGenerator::getCrosstalk(), CSCBaseElectronicsSim::layerId(), TrapezoidalPlaneBounds::length(), readoutElement(), CSCCrosstalkGenerator::setParameters(), CSCAnalogSignal::superimpose(), theCrosstalkGenerator, CSCBaseElectronicsSim::theLayerGeometry, and theStripConditions.

                                                                         {
   float capacitiveCrosstalk, resistiveCrosstalk;
   bool leftRight = (otherStrip > thisStrip);
   theStripConditions->crosstalk(
       layerId(), thisStrip, theLayerGeometry->length(), leftRight, capacitiveCrosstalk, resistiveCrosstalk);
   theCrosstalkGenerator->setParameters(capacitiveCrosstalk, 0., resistiveCrosstalk);
   CSCAnalogSignal crosstalkSignal(theCrosstalkGenerator->getCrosstalk(signal));
   find(readoutElement(otherStrip), engine).superimpose(crosstalkSignal);
 
   // Now subtract the crosstalk signal from the original signal
   crosstalkSignal *= -1.;
   find(thisStrip, engine).superimpose(crosstalkSignal);
 }

◆ calculateAmpResponse()

float CSCStripElectronicsSim::calculateAmpResponse ( float t ) const

overrideprivatevirtual

Implements CSCBaseElectronicsSim.

Definition at line 79 of file CSCStripElectronicsSim.cc.

References CSCStripAmpResponse::calculateAmpResponse(), submitPVValidationJobs::t, and theAmpResponse.

79 { return theAmpResponse.calculateAmpResponse(t); }

submitPVValidationJobs.t

string t

Definition: submitPVValidationJobs.py:649

CSCStripAmpResponse::calculateAmpResponse

float calculateAmpResponse(float t) const

Definition: CSCStripAmpResponse.cc:11

CSCStripElectronicsSim::theAmpResponse

CSCStripAmpResponse theAmpResponse

Definition: CSCStripElectronicsSim.h:58

◆ channelsToRead()

std::list< int > CSCStripElectronicsSim::channelsToRead	(	const std::list< int > &	keyStrips,
		int	window
	)		const

private

finds what strips to read. Will either take 5 strips around the keystrip, or the whole CFEB, based on doSuppression_

Definition at line 240 of file CSCStripElectronicsSim.cc.

References doSuppression_, mps_fire::i, CSCBaseElectronicsSim::nElements, readoutElement(), mps_fire::result, and svgfig::window().

Referenced by fillStripDigis(), and selfTest().

                                                                                                    {
   std::list<int> result;
   std::list<int>::const_iterator keyStripItr = keyStrips.begin();
   if (doSuppression_) {
     for (; keyStripItr != keyStrips.end(); ++keyStripItr) {
       // pick the five strips around the comparator
       for (int istrip = (*keyStripItr) - window; istrip <= (*keyStripItr) + window; ++istrip) {
         if (istrip > 0 && istrip <= nElements) {
           result.push_back(readoutElement(istrip));
         }
       }
     }
     result.sort();
     result.unique();
   } else {
     // read the whole CFEB, 16 strips
     std::list<int> cfebsToRead;
     for (; keyStripItr != keyStrips.end(); ++keyStripItr) {
       int cfeb = (readoutElement(*keyStripItr) - 1) / 16;
       cfebsToRead.push_back(cfeb);
       int remainder = (readoutElement(*keyStripItr) - 1) % 16;
       // if we're within 3 strips of an edge, take neighboring CFEB, too
       if (remainder < window && cfeb != 0) {
         cfebsToRead.push_back(cfeb - 1);
       }
       // the 'readouElement' makes it so that ME1/1 has just one CFEB
       int maxCFEBs = readoutElement(nElements) / 16 - 1;
       if (remainder >= 16 - window && cfeb != maxCFEBs) {
         cfebsToRead.push_back(cfeb + 1);
       }
     }
     cfebsToRead.sort();
     cfebsToRead.unique();
 
     // now convert the CFEBS to strips
     for (std::list<int>::const_iterator cfebItr = cfebsToRead.begin(); cfebItr != cfebsToRead.end(); ++cfebItr) {
       for (int i = 1; i <= 16; ++i) {
         result.push_back((*cfebItr) * 16 + i);
       }
     }
   }
   return result;
 }

◆ comparatorReading()

float CSCStripElectronicsSim::comparatorReading	(	const CSCAnalogSignal &	signal,
		float	time,
		CLHEP::HepRandomEngine *	engine
	)		const

private

calculates the comparator reading, including saturation and offsets

Definition at line 96 of file CSCStripElectronicsSim.cc.

References CSCAnalogSignal::getValue(), SiStripPI::min, theComparatorRMSOffset, theComparatorSaturation, and hcalRecHitTable_cff::time.

Referenced by runComparator().

                                                                                     {
   return std::min(signal.getValue(time), theComparatorSaturation) +
          theComparatorRMSOffset * CLHEP::RandGaussQ::shoot(engine);
 }

◆ createDigi()

void CSCStripElectronicsSim::createDigi	(	int	istrip,
		const CSCAnalogSignal &	signal,
		std::vector< CSCStripDigi > &	result,
		CLHEP::HepRandomEngine *	engine
	)

Definition at line 364 of file CSCStripElectronicsSim.cc.

References CSCBaseElectronicsSim::addLinks(), CSCChamberSpecs::chamberType(), nano_mu_digi_cff::chamberType, CSCBaseElectronicsSim::channelIndex(), doSaturation(), PedestalClient_cfi::gain, CSCAnalogSignal::getValue(), CSCBaseElectronicsSim::layerId(), LogTrace, nScaBins_, CSCStripConditions::pedestal(), EcalCondDBWriter_cfi::pedestal, mps_fire::result, sca_time_bin_size, CSCStripConditions::smearedGain(), submitPVValidationJobs::t, FrontierCondition_GT_autoExpress_cfi::t0, theAverageTimeOfFlight, theSCATimingOffsets, CSCBaseElectronicsSim::theSignalStartTime, CSCBaseElectronicsSim::theSpecs, theStripConditions, CSCBaseElectronicsSim::theTimingCalibrationError, and hcalSimParameters_cfi::timeSmearing.

Referenced by fillStripDigis().

                                                                       {
   // fill in the sca information
   std::vector<int> scaCounts(nScaBins_);
 
   float pedestal = theStripConditions->pedestal(layerId(), channel);
   float gain = theStripConditions->smearedGain(layerId(), channel, engine);
   int chamberType = theSpecs->chamberType();
   float timeSmearing = CLHEP::RandGaussQ::shoot(engine) * theTimingCalibrationError[chamberType];
   // undo the correction for TOF, instead, using some nominal
   // value from ME2/1
   float t0 = theSignalStartTime + theSCATimingOffsets[chamberType] + timeSmearing + 29. - theAverageTimeOfFlight;
   for (int scaBin = 0; scaBin < nScaBins_; ++scaBin) {
     float t = t0 + scaBin * sca_time_bin_size;
     scaCounts[scaBin] = static_cast<int>(pedestal + signal.getValue(t) * gain);
   }
   CSCStripDigi newDigi(channel, scaCounts);
 
   // do saturation of 12-bit ADC
   doSaturation(newDigi);
 
   result.push_back(newDigi);
   addLinks(channelIndex(channel));
   LogTrace("CSCStripElectronicsSim") << "CSCStripElectronicsSim: CSCStripDigi " << newDigi;
 }

◆ doSaturation()

void CSCStripElectronicsSim::doSaturation ( CSCStripDigi & digi )

private

Definition at line 392 of file CSCStripElectronicsSim.cc.

References CSCStripDigi::getADCCounts(), SiStripPI::min, and CSCStripDigi::setADCCounts().

Referenced by createDigi().

                                                             {
   std::vector<int> scaCounts(digi.getADCCounts());
   for (unsigned scaBin = 0; scaBin < scaCounts.size(); ++scaBin) {
     scaCounts[scaBin] = std::min(scaCounts[scaBin], 4095);
   }
   digi.setADCCounts(scaCounts);
 }

◆ fillDigis()

void CSCStripElectronicsSim::fillDigis	(	CSCStripDigiCollection &	digis,
		CSCComparatorDigiCollection &	comparators,
		CLHEP::HepRandomEngine *	engine
	)

Definition at line 288 of file CSCStripElectronicsSim.cc.

References addCrosstalk(), doCrosstalk_, fillStripDigis(), getKeyStripsFromMC(), CSCBaseElectronicsSim::layerId(), FastTimerService_cff::range, and runComparator().

Referenced by CSCDigitizer::doAction().

                                                                      {
   if (doCrosstalk_) {
     addCrosstalk(engine);
   }
 
   std::vector<CSCComparatorDigi> comparatorOutputs;
   runComparator(comparatorOutputs, engine);
   // copy these to the result
   if (!comparatorOutputs.empty()) {
     CSCComparatorDigiCollection::Range range(comparatorOutputs.begin(), comparatorOutputs.end());
     comparators.put(range, layerId());
   }
 
   // std::list<int> keyStrips = getKeyStrips(comparatorOutputs);
   std::list<int> keyStrips = getKeyStripsFromMC();
   fillStripDigis(keyStrips, digis, engine);
 }

◆ fillMissingLayer()

void CSCStripElectronicsSim::fillMissingLayer	(	const CSCLayer *	layer,
		const CSCComparatorDigiCollection &	comparators,
		CSCStripDigiCollection &	digis,
		CLHEP::HepRandomEngine *	engine
	)

Definition at line 400 of file CSCStripElectronicsSim.cc.

References CSCDetId::chamberId(), fillStripDigis(), getKeyStrips(), nano_mu_digi_cff::layer, CSCBaseElectronicsSim::setLayer(), CSCBaseElectronicsSim::theLayerId, and CSCBaseElectronicsSim::theSignalMap.

Referenced by CSCDigitizer::doAction().

                                                                             {
   theSignalMap.clear();
   setLayer(layer);
   CSCDetId chamberId(theLayerId.chamberId());
   // find all comparator key strips in this chamber
   std::list<int> chamberKeyStrips;
   for (CSCComparatorDigiCollection::DigiRangeIterator comparatorItr = comparators.begin();
        comparatorItr != comparators.end();
        ++comparatorItr) {
     // could be more efficient
     if (CSCDetId((*comparatorItr).first).chamberId() == chamberId) {
       std::vector<CSCComparatorDigi> layerComparators((*comparatorItr).second.first, (*comparatorItr).second.second);
       std::list<int> layerKeyStrips = getKeyStrips(layerComparators);
       chamberKeyStrips.insert(chamberKeyStrips.end(), layerKeyStrips.begin(), layerKeyStrips.end());
     }
   }
   chamberKeyStrips.sort();
   chamberKeyStrips.unique();
   fillStripDigis(chamberKeyStrips, digis, engine);
 }

◆ fillStripDigis()

void CSCStripElectronicsSim::fillStripDigis	(	const std::list< int > &	keyStrips,
		CSCStripDigiCollection &	digis,
		CLHEP::HepRandomEngine *	engine
	)

private

Definition at line 308 of file CSCStripElectronicsSim.cc.

References channelsToRead(), createDigi(), CSCBaseElectronicsSim::find(), and CSCBaseElectronicsSim::layerId().

Referenced by fillDigis(), and fillMissingLayer().

                                                                           {
   std::list<int> stripsToDo = channelsToRead(keyStrips, 3);
   std::vector<CSCStripDigi> stripDigis;
   stripDigis.reserve(stripsToDo.size());
   for (std::list<int>::const_iterator stripItr = stripsToDo.begin(); stripItr != stripsToDo.end(); ++stripItr) {
     createDigi(*stripItr, find(*stripItr, engine), stripDigis, engine);
   }
 
   CSCStripDigiCollection::Range stripRange(stripDigis.begin(), stripDigis.end());
   digis.put(stripRange, layerId());
 }

◆ getKeyStrips()

std::list< int > CSCStripElectronicsSim::getKeyStrips ( const std::vector< CSCComparatorDigi > & comparators ) const

private

finds the key strips from these comparators

Definition at line 209 of file CSCStripElectronicsSim.cc.

References funct::abs(), mps_fire::result, and CSCBaseElectronicsSim::theOffsetOfBxZero.

Referenced by fillMissingLayer().

                                                                                                        {
   std::list<int> result;
   for (std::vector<CSCComparatorDigi>::const_iterator compItr = comparators.begin(); compItr != comparators.end();
        ++compItr) {
     if (std::abs(compItr->getTimeBin() - theOffsetOfBxZero) <= 2) {
       result.push_back(compItr->getStrip());
     }
   }
   // need sort for unique to work.
   result.sort();
   result.unique();
   return result;
 }

◆ getKeyStripsFromMC()

std::list< int > CSCStripElectronicsSim::getKeyStripsFromMC ( ) const

private

get ths strips that have detector hits

Definition at line 223 of file CSCStripElectronicsSim.cc.

References dqmdumpme::first, mps_fire::result, CSCBaseElectronicsSim::theDetectorHitMap, and HcalDetIdTransform::transform().

Referenced by fillDigis().

                                                               {
   // assumes the detector hit map is filled
   std::list<int> result;
   transform(theDetectorHitMap.begin(),
             theDetectorHitMap.end(),
             //   back_inserter(result),
             //   boost::bind(&DetectorHitMap::value_type::first,_1));
             // suggested code from Chris Jones
             back_inserter(result),
             std::bind(&DetectorHitMap::value_type::first, std::placeholders::_1));
   //  back_inserter(result), [](DetectorHitMap::value_type const& iValue) {
   //  return iValue.first; } );
   result.sort();
   result.unique();
   return result;
 }

◆ getReadoutRange()

void CSCStripElectronicsSim::getReadoutRange	(	int	inputStrip,
		int &	minStrip,
		int &	maxStrip
	)

private

◆ initParameters()

void CSCStripElectronicsSim::initParameters ( )

overrideprivatevirtual

initialization for each layer

Implements CSCBaseElectronicsSim.

Definition at line 61 of file CSCStripElectronicsSim.cc.

                                             {
   nElements = theLayerGeometry->numberOfStrips();
   theComparatorThreshold = 20.;
   // selfTest();
 
   // calculate the offset to the peak
   float averageDistance = theLayer->surface().position().mag();
   theAverageTimeOfFlight = averageDistance * cm / c_light;  // Units of c_light: mm/ns
   int chamberType = theSpecs->chamberType();
   theTimingOffset = theShapingTime + theAverageTimeOfFlight + theBunchTimingOffsets[chamberType];
   // TODO make sure config gets overridden
   theSignalStartTime = theTimingOffset - (sca_peak_bin - 1) * sca_time_bin_size;
   theSignalStopTime = theSignalStartTime + nScaBins_ * sca_time_bin_size;
   theNumberOfSamples = nScaBins_ * static_cast<int>(sca_time_bin_size / theSamplingTime);
 }

◆ makeNoiseSignal()

CSCAnalogSignal CSCStripElectronicsSim::makeNoiseSignal	(	int	element,
		CLHEP::HepRandomEngine *	engine
	)

overridevirtual

Reimplemented from CSCBaseElectronicsSim.

Definition at line 81 of file CSCStripElectronicsSim.cc.

References CSCBaseElectronicsSim::doNoise_, CSCAnalogSignal::getValue(), CSCBaseElectronicsSim::layerId(), CSCStripConditions::noisify(), nScaBins_, sca_time_bin_size, CSCBaseElectronicsSim::theNumberOfSamples, CSCBaseElectronicsSim::theSamplingTime, CSCBaseElectronicsSim::theSignalStartTime, and theStripConditions.

                                                                                                  {
   std::vector<float> noiseBins(nScaBins_);
   CSCAnalogSignal tmpSignal(element, sca_time_bin_size, noiseBins);
   if (doNoise_) {
     theStripConditions->noisify(layerId(), tmpSignal, engine);
   }
   // now rebin it
   std::vector<float> binValues(theNumberOfSamples);
   for (int ibin = 0; ibin < theNumberOfSamples; ++ibin) {
     binValues[ibin] = tmpSignal.getValue(ibin * theSamplingTime);
   }
   CSCAnalogSignal finalSignal(element, theSamplingTime, binValues, 0., theSignalStartTime);
   return finalSignal;
 }

◆ readoutElement()

int CSCStripElectronicsSim::readoutElement ( int strip ) const

overrideprivatevirtual

Implements CSCBaseElectronicsSim.

Definition at line 77 of file CSCStripElectronicsSim.cc.

References CSCLayerGeometry::channel(), nano_mu_digi_cff::strip, and CSCBaseElectronicsSim::theLayerGeometry.

Referenced by addCrosstalk(), channelsToRead(), runComparator(), and selfTest().

77 { return theLayerGeometry->channel(strip); }

CSCBaseElectronicsSim::theLayerGeometry

const CSCLayerGeometry * theLayerGeometry

Definition: CSCBaseElectronicsSim.h:114

nano_mu_digi_cff.strip

strip

Definition: nano_mu_digi_cff.py:38

CSCLayerGeometry::channel

int channel(int strip) const

Definition: CSCLayerGeometry.h:112

◆ runComparator()

void CSCStripElectronicsSim::runComparator	(	std::vector< CSCComparatorDigi > &	result,
		CLHEP::HepRandomEngine *	engine
	)

private

Definition at line 103 of file CSCStripElectronicsSim.cc.

References comparatorReading(), CSCBaseElectronicsSim::find(), reco::JetExtendedAssociation::getValue(), CSCBaseElectronicsSim::nElements, readoutElement(), mps_fire::result, jetUpdater_cfi::sort, nano_mu_digi_cff::strip, CSCBaseElectronicsSim::theBunchSpacing, theComparatorDeadTime, theComparatorSamplingTime, theComparatorThreshold, theComparatorTimeBinOffset, theComparatorTimeOffset, theComparatorWait, CSCBaseElectronicsSim::theOffsetOfBxZero, CSCBaseElectronicsSim::theSignalMap, CSCBaseElectronicsSim::theSignalStartTime, CSCBaseElectronicsSim::theSignalStopTime, theTimingOffset, and hcalRecHitTable_cff::time.

Referenced by fillDigis().

                                                                                                              {
   // first, make a list of all the comparators we actually
   // need to run
   std::list<int> comparatorsWithSignal;
   CSCSignalMap::iterator signalMapItr;
   for (signalMapItr = theSignalMap.begin(); signalMapItr != theSignalMap.end(); ++signalMapItr) {
     // Elements in signal map count from 1
     // 1,2->0,  3,4->1,  5,6->2, ...
     comparatorsWithSignal.push_back(((*signalMapItr).first - 1) / 2);
   }
   // no need to sort
   comparatorsWithSignal.unique();
   for (std::list<int>::iterator listItr = comparatorsWithSignal.begin(); listItr != comparatorsWithSignal.end();
        ++listItr) {
     int iComparator = *listItr;
     // find signal1 and signal2
     // iComparator counts from 0
     // icomp =0->1,2,  =1->3,4,  =2->5,6, ...
     const CSCAnalogSignal &signal1 = find(readoutElement(iComparator * 2 + 1), engine);
     const CSCAnalogSignal &signal2 = find(readoutElement(iComparator * 2 + 2), engine);
     for (float time = theSignalStartTime + theComparatorTimeOffset; time < theSignalStopTime - theComparatorWait;
          time += theComparatorSamplingTime) {
       if (comparatorReading(signal1, time, engine) > theComparatorThreshold ||
           comparatorReading(signal2, time, engine) > theComparatorThreshold) {
         // wait a bit, so we can run the comparator at the signal peak
         float comparatorTime = time;
         time += theComparatorWait;
 
         float height1 = comparatorReading(signal1, time, engine);
         float height2 = comparatorReading(signal2, time, engine);
         int output = 0;
         int strip = 0;
         // distrip logic; comparator output is for pairs of strips:
         // hit  bin  dec
         // x--- 100   4
         // -x-- 101   5
         // --x- 110   6
         // ---x 111   7
         // just to prevent a copy
         const CSCAnalogSignal *mainSignal = nullptr;
         // pick the higher of the two strips in the pair
         if (height1 > height2) {
           mainSignal = &signal1;
           float leftStrip = 0.;
           if (iComparator > 0) {
             leftStrip = comparatorReading(find(readoutElement(iComparator * 2), engine), time, engine);
           }
           // if this strip is higher than either of its neighbors, make a
           // comparator digi
           if (leftStrip < height1 && height1 > theComparatorThreshold) {
             output = (leftStrip < height2);
             strip = iComparator * 2 + 1;
           }
         } else {
           mainSignal = &signal2;
           float rightStrip = 0.;
           if (iComparator * 2 + 3 <= nElements) {
             rightStrip = comparatorReading(find(readoutElement(iComparator * 2 + 3), engine), time, engine);
           }
           if (rightStrip < height2 && height2 > theComparatorThreshold) {
             output = (height1 < rightStrip);
             strip = iComparator * 2 + 2;
           }
         }
         if (strip != 0) {
           float bxFloat =
               (comparatorTime - theTimingOffset) / theBunchSpacing + theComparatorTimeBinOffset + theOffsetOfBxZero;
 
           // Comparator digi as of Nov-2006 adapted to real data: time word has
           // 16 bits with set bit flagging appropriate bunch crossing, and bx 0
           // corresponding to 9th bit i.e.
 
           //      1st bit set (bit 0) <-> bx -9
           //      2nd              1  <-> bx -8
           //      ...           ...       ....
           //      8th              9  <-> bx  0
           //      9th             10  <-> bx +1
           //      ...           ...       ....
           //     16th             15  <-> bx +6
 
           // Parameter theOffsetOfBxZero = 9 @@WARNING! This offset may be
           // changed (hardware)!
 
           int timeWord = 0;  // and this will remain if too early or late
           if ((bxFloat >= 0) && (bxFloat < 16))
             timeWord = (1 << static_cast<int>(bxFloat));  // set appropriate bit
 
           CSCComparatorDigi newDigi(strip, output, timeWord);
           result.push_back(newDigi);
         }
 
         // wait for the comparator to reset
         time += theComparatorDeadTime;
         // really should be zero, but strip signal doesn't go negative yet
         float resetThreshold = 1;
         while (time < theSignalStopTime && mainSignal->getValue(time) > resetThreshold) {
           time += theComparatorSamplingTime;
         }
 
       }  // if over threshold
     }    // loop over time samples
   }      // loop over comparators
   // sort by time
   sort(result.begin(), result.end());
 }

◆ selfTest()

void CSCStripElectronicsSim::selfTest ( ) const

private

Definition at line 424 of file CSCStripElectronicsSim.cc.

References cms::cuda::assert(), channelsToRead(), doSuppression_, CSCBaseElectronicsSim::nElements, and readoutElement().

                                             {
   // make sure the zero suppression algorithms work
   std::list<int> keyStrips, stripsRead;
   //
   bool isGanged = (readoutElement(nElements) == 16);
   keyStrips.push_back(readoutElement(19));
   keyStrips.push_back(readoutElement(30));
   keyStrips.push_back(readoutElement(32));
   stripsRead = channelsToRead(keyStrips, 3);
   if (doSuppression_) {
     unsigned int expectedSize = isGanged ? 10 : 12;
     assert(stripsRead.size() == expectedSize);
     assert(stripsRead.front() == readoutElement(17));
   } else {
     unsigned int expectedSize = isGanged ? 16 : 48;
     assert(stripsRead.size() == expectedSize);
     assert(stripsRead.front() == 1);
   }
 }

◆ setStripConditions()

void CSCStripElectronicsSim::setStripConditions ( CSCStripConditions * cond )

inline

Definition at line 42 of file CSCStripElectronicsSim.h.

References theStripConditions.

Referenced by CSCDigitizer::setStripConditions().

42 { theStripConditions = cond; }

CSCStripElectronicsSim::theStripConditions

CSCStripConditions * theStripConditions

Definition: CSCStripElectronicsSim.h:103

cond

Member Data Documentation

◆ doCrosstalk_

bool CSCStripElectronicsSim::doCrosstalk_

private

Definition at line 102 of file CSCStripElectronicsSim.h.

Referenced by CSCStripElectronicsSim(), fillDigis(), and ~CSCStripElectronicsSim().

◆ doSuppression_

bool CSCStripElectronicsSim::doSuppression_

private

Definition at line 101 of file CSCStripElectronicsSim.h.

Referenced by channelsToRead(), and selfTest().

◆ nScaBins_

int CSCStripElectronicsSim::nScaBins_

private

Definition at line 100 of file CSCStripElectronicsSim.h.

Referenced by createDigi(), initParameters(), and makeNoiseSignal().

◆ sca_peak_bin

int CSCStripElectronicsSim::sca_peak_bin

private

Definition at line 111 of file CSCStripElectronicsSim.h.

Referenced by initParameters().

◆ sca_time_bin_size

float CSCStripElectronicsSim::sca_time_bin_size

private

Definition at line 108 of file CSCStripElectronicsSim.h.

Referenced by createDigi(), initParameters(), and makeNoiseSignal().

◆ theAmpResponse

CSCStripAmpResponse CSCStripElectronicsSim::theAmpResponse

private

Definition at line 58 of file CSCStripElectronicsSim.h.

Referenced by calculateAmpResponse().

◆ theAverageTimeOfFlight

float CSCStripElectronicsSim::theAverageTimeOfFlight

private

Definition at line 121 of file CSCStripElectronicsSim.h.

Referenced by createDigi(), and initParameters().

◆ theComparatorClockJump

int CSCStripElectronicsSim::theComparatorClockJump

private

Definition at line 106 of file CSCStripElectronicsSim.h.

◆ theComparatorDeadTime

float CSCStripElectronicsSim::theComparatorDeadTime

private

Definition at line 95 of file CSCStripElectronicsSim.h.

Referenced by runComparator().

◆ theComparatorNoise

float CSCStripElectronicsSim::theComparatorNoise

private

Definition at line 89 of file CSCStripElectronicsSim.h.

◆ theComparatorRMSOffset

float CSCStripElectronicsSim::theComparatorRMSOffset

private

Definition at line 90 of file CSCStripElectronicsSim.h.

Referenced by comparatorReading().

◆ theComparatorSamplingTime

double CSCStripElectronicsSim::theComparatorSamplingTime

private

Definition at line 116 of file CSCStripElectronicsSim.h.

Referenced by runComparator().

◆ theComparatorSaturation

float CSCStripElectronicsSim::theComparatorSaturation

private

Definition at line 92 of file CSCStripElectronicsSim.h.

Referenced by comparatorReading().

◆ theComparatorThreshold

float CSCStripElectronicsSim::theComparatorThreshold

private

Definition at line 88 of file CSCStripElectronicsSim.h.

Referenced by initParameters(), and runComparator().

◆ theComparatorTimeBinOffset

double CSCStripElectronicsSim::theComparatorTimeBinOffset

private

Definition at line 113 of file CSCStripElectronicsSim.h.

Referenced by runComparator().

◆ theComparatorTimeOffset

double CSCStripElectronicsSim::theComparatorTimeOffset

private

Definition at line 115 of file CSCStripElectronicsSim.h.

Referenced by runComparator().

◆ theComparatorWait

float CSCStripElectronicsSim::theComparatorWait

private

Definition at line 94 of file CSCStripElectronicsSim.h.

Referenced by runComparator().

◆ theCrosstalkGenerator

CSCCrosstalkGenerator* CSCStripElectronicsSim::theCrosstalkGenerator

private

Definition at line 104 of file CSCStripElectronicsSim.h.

Referenced by addCrosstalk(), CSCStripElectronicsSim(), and ~CSCStripElectronicsSim().

◆ theDaqDeadTime

float CSCStripElectronicsSim::theDaqDeadTime

private

Definition at line 96 of file CSCStripElectronicsSim.h.

◆ theSCATimingOffsets

std::vector<double> CSCStripElectronicsSim::theSCATimingOffsets

private

Definition at line 118 of file CSCStripElectronicsSim.h.

Referenced by createDigi().

◆ theStripConditions

CSCStripConditions* CSCStripElectronicsSim::theStripConditions

private

Definition at line 103 of file CSCStripElectronicsSim.h.

Referenced by addCrosstalk(), createDigi(), makeNoiseSignal(), and setStripConditions().

◆ theTimingOffset

float CSCStripElectronicsSim::theTimingOffset

private

Definition at line 98 of file CSCStripElectronicsSim.h.

Referenced by initParameters(), and runComparator().

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ CSCStripElectronicsSim()

◆ ~CSCStripElectronicsSim()

Member Function Documentation

◆ addCrosstalk() [1/2]

◆ addCrosstalk() [2/2]

◆ calculateAmpResponse()

◆ channelsToRead()

◆ comparatorReading()

◆ createDigi()

◆ doSaturation()

◆ fillDigis()

◆ fillMissingLayer()

◆ fillStripDigis()

◆ getKeyStrips()

◆ getKeyStripsFromMC()

◆ getReadoutRange()

◆ initParameters()

◆ makeNoiseSignal()

◆ readoutElement()

◆ runComparator()

◆ selfTest()

◆ setStripConditions()

Member Data Documentation

◆ doCrosstalk_

◆ doSuppression_

◆ nScaBins_

◆ sca_peak_bin

◆ sca_time_bin_size

◆ theAmpResponse

◆ theAverageTimeOfFlight

◆ theComparatorClockJump

◆ theComparatorDeadTime

◆ theComparatorNoise

◆ theComparatorRMSOffset

◆ theComparatorSamplingTime

◆ theComparatorSaturation

◆ theComparatorThreshold

◆ theComparatorTimeBinOffset

◆ theComparatorTimeOffset

◆ theComparatorWait

◆ theCrosstalkGenerator

◆ theDaqDeadTime

◆ theSCATimingOffsets

◆ theStripConditions

◆ theTimingOffset