#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
	the average time-of-flight from the interaction point to the given detector More...

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 ( const edm::ParameterSet & p )

explicit

configurable parameters

Definition at line 23 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 ( )

override

Definition at line 56 of file CSCStripElectronicsSim.cc.

References doCrosstalk_, and theCrosstalkGenerator.

                                                 {
   if(doCrosstalk_) {
     delete theCrosstalkGenerator;
   }
 }

Member Function Documentation

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

private

Definition at line 372 of file CSCStripElectronicsSim.cc.

References CSCBaseElectronicsSim::nElements, 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);
     }
   }
 }

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

private

Definition at line 400 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);
 
 }

float CSCStripElectronicsSim::calculateAmpResponse ( float t ) const

overrideprivatevirtual

Implements CSCBaseElectronicsSim.

Definition at line 87 of file CSCStripElectronicsSim.cc.

References CSCStripAmpResponse::calculateAmpResponse(), and theAmpResponse.

 {
   return theAmpResponse.calculateAmpResponse(t);
 }

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

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

private

calculates the comparator reading, including saturation and offsets

Definition at line 109 of file CSCStripElectronicsSim.cc.

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

Referenced by runComparator().

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

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

Definition at line 420 of file CSCStripElectronicsSim.cc.

References CSCBaseElectronicsSim::addLinks(), CSCChamberSpecs::chamberType(), CSCBaseElectronicsSim::channelIndex(), doSaturation(), muonCSCDigis_cfi::gain, CSCAnalogSignal::getValue(), CSCBaseElectronicsSim::layerId(), LogTrace, nScaBins_, muonCSCDigis_cfi::pedestal, CSCStripConditions::pedestal(), sca_time_bin_size, CSCStripConditions::smearedGain(), lumiQTWidget::t, cscNeutronWriter_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") << newDigi;
 }

void CSCStripElectronicsSim::doSaturation ( CSCStripDigi & digi )

private

Definition at line 450 of file CSCStripElectronicsSim.cc.

References CSCStripDigi::getADCCounts(), 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);
 }

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

Definition at line 330 of file CSCStripElectronicsSim.cc.

References addCrosstalk(), doCrosstalk_, fillStripDigis(), getKeyStripsFromMC(), CSCBaseElectronicsSim::layerId(), 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);
 }

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

Definition at line 460 of file CSCStripElectronicsSim.cc.

References CSCDetId::chamberId(), fillStripDigis(), getKeyStrips(), 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);
 }

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

private

Definition at line 354 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());
 }

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

private

finds the key strips from these comparators

Definition at line 229 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;
 }

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

private

get ths strips that have detector hits

Definition at line 248 of file CSCStripElectronicsSim.cc.

References plotBeamSpotDB::first, mps_fire::result, CSCBaseElectronicsSim::theDetectorHitMap, and create_public_lumi_plots::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;
 }

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

private

void CSCStripElectronicsSim::initParameters ( )

overrideprivatevirtual

initialization for each layer

Implements CSCBaseElectronicsSim.

Definition at line 62 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);
 
 }  

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

overridevirtual

Reimplemented from CSCBaseElectronicsSim.

Definition at line 93 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;
 }

int CSCStripElectronicsSim::readoutElement ( int strip ) const

overrideprivatevirtual

Implements CSCBaseElectronicsSim.

Definition at line 82 of file CSCStripElectronicsSim.cc.

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

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

                                                           {
   return theLayerGeometry->channel(strip);
 }

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

private

Definition at line 118 of file CSCStripElectronicsSim.cc.

References comparatorReading(), CSCBaseElectronicsSim::find(), CSCAnalogSignal::getValue(), CSCBaseElectronicsSim::nElements, convertSQLitetoXML_cfg::output, readoutElement(), 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().

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

void CSCStripElectronicsSim::selfTest ( ) const

private

Definition at line 487 of file CSCStripElectronicsSim.cc.

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