CSCStripElectronicsSim Class Reference

#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 23 of file CSCStripElectronicsSim.cc.

    : 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();
}

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

~CSCStripElectronicsSim()

CSCStripElectronicsSim::~CSCStripElectronicsSim ( )

override

Definition at line 53 of file CSCStripElectronicsSim.cc.

                                                {
  if (doCrosstalk_) {
    delete theCrosstalkGenerator;
  }
}

References doCrosstalk_, and theCrosstalkGenerator.

Member Function Documentation

addCrosstalk() [1/2]

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

private

Definition at line 320 of file CSCStripElectronicsSim.cc.

                                                                      {
  // 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);
    }
  }
}

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

Referenced by fillDigis().

addCrosstalk() [2/2]

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

private

Definition at line 345 of file CSCStripElectronicsSim.cc.

                                                                        {
  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);
}

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

calculateAmpResponse()

float CSCStripElectronicsSim::calculateAmpResponse ( float  t ) const

overrideprivatevirtual

Implements CSCBaseElectronicsSim.

Definition at line 77 of file CSCStripElectronicsSim.cc.

{ return theAmpResponse.calculateAmpResponse(t); }

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

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 238 of file CSCStripElectronicsSim.cc.

                                                                                                   {
  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;
}

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

Referenced by fillStripDigis(), and selfTest().

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 94 of file CSCStripElectronicsSim.cc.

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

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

Referenced by runComparator().

createDigi()

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

Definition at line 362 of file CSCStripElectronicsSim.cc.

                                                                      {
  // 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") << newDigi;
}

References CSCBaseElectronicsSim::addLinks(), CSCChamberSpecs::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(), OrderedSet::t, FrontierCondition_GT_autoExpress_cfi::t0, theAverageTimeOfFlight, theSCATimingOffsets, CSCBaseElectronicsSim::theSignalStartTime, CSCBaseElectronicsSim::theSpecs, theStripConditions, CSCBaseElectronicsSim::theTimingCalibrationError, and hcalSimParameters_cfi::timeSmearing.

Referenced by fillStripDigis().

doSaturation()

void CSCStripElectronicsSim::doSaturation ( CSCStripDigi &  digi )

private

Definition at line 390 of file CSCStripElectronicsSim.cc.

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

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

Referenced by createDigi().

fillDigis()

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

Definition at line 286 of file CSCStripElectronicsSim.cc.

                                                                     {
  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);
}

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

Referenced by CSCDigitizer::doAction().

fillMissingLayer()

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

Definition at line 398 of file CSCStripElectronicsSim.cc.

                                                                            {
  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);
}

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

Referenced by CSCDigitizer::doAction().

fillStripDigis()

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

private

Definition at line 306 of file CSCStripElectronicsSim.cc.

                                                                          {
  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());
}

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

Referenced by fillDigis(), and fillMissingLayer().

getKeyStrips()

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

private

finds the key strips from these comparators

Definition at line 207 of file CSCStripElectronicsSim.cc.

                                                                                                       {
  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;
}

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

Referenced by fillMissingLayer().

getKeyStripsFromMC()

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

private

get ths strips that have detector hits

Definition at line 221 of file CSCStripElectronicsSim.cc.

                                                              {
  // 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;
}

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

Referenced by fillDigis().

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 59 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);
}

References CSCChamberSpecs::chamberType(), PV3DBase< T, PVType, FrameType >::mag(), CSCBaseElectronicsSim::nElements, nScaBins_, CSCLayerGeometry::numberOfStrips(), GloballyPositioned< T >::position(), sca_peak_bin, sca_time_bin_size, GeomDet::surface(), theAverageTimeOfFlight, CSCBaseElectronicsSim::theBunchTimingOffsets, theComparatorThreshold, CSCBaseElectronicsSim::theLayer, CSCBaseElectronicsSim::theLayerGeometry, CSCBaseElectronicsSim::theNumberOfSamples, CSCBaseElectronicsSim::theSamplingTime, CSCBaseElectronicsSim::theShapingTime, CSCBaseElectronicsSim::theSignalStartTime, CSCBaseElectronicsSim::theSignalStopTime, CSCBaseElectronicsSim::theSpecs, and theTimingOffset.

makeNoiseSignal()

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

overridevirtual

Reimplemented from CSCBaseElectronicsSim.

Definition at line 79 of file CSCStripElectronicsSim.cc.

                                                                                                 {
  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;
}

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

readoutElement()

int CSCStripElectronicsSim::readoutElement ( int  strip ) const

overrideprivatevirtual

Implements CSCBaseElectronicsSim.

Definition at line 75 of file CSCStripElectronicsSim.cc.

{ return theLayerGeometry->channel(strip); }

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

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

runComparator()

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

private

Definition at line 101 of file CSCStripElectronicsSim.cc.

                                                                                                             {
  // 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());
}

References comparatorReading(), CSCBaseElectronicsSim::find(), reco::JetExtendedAssociation::getValue(), CSCBaseElectronicsSim::nElements, convertSQLitetoXML_cfg::output, readoutElement(), mps_fire::result, digitizers_cfi::strip, CSCBaseElectronicsSim::theBunchSpacing, theComparatorDeadTime, theComparatorSamplingTime, theComparatorThreshold, theComparatorTimeBinOffset, theComparatorTimeOffset, theComparatorWait, CSCBaseElectronicsSim::theOffsetOfBxZero, CSCBaseElectronicsSim::theSignalMap, CSCBaseElectronicsSim::theSignalStartTime, CSCBaseElectronicsSim::theSignalStopTime, theTimingOffset, and ntuplemaker::time.

Referenced by fillDigis().

selfTest()

void CSCStripElectronicsSim::selfTest ( ) const

private

Definition at line 422 of file CSCStripElectronicsSim.cc.

                                            {
  // 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);
  }
}

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

setStripConditions()

void CSCStripElectronicsSim::setStripConditions ( CSCStripConditions *  cond )

inline

Definition at line 42 of file CSCStripElectronicsSim.h.

{ theStripConditions = cond; }

References theStripConditions.

Referenced by CSCDigitizer::setStripConditions().

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