#include <CSCWireElectronicsSim.h>

Inheritance diagram for CSCWireElectronicsSim:

Public Member Functions
	CSCWireElectronicsSim (const edm::ParameterSet &p)
	configurable parameters More...

void	fillDigis (CSCWireDigiCollection &digis, CLHEP::HepRandomEngine *)

void	setFraction (float newFraction)

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
float	calculateAmpResponse (float t) const

virtual int	channelIndex (int channel) const
	we code strip indices from 1-80, and wire indices start at 100 More...

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

virtual int	readoutElement (int element) const

virtual float	timeOfFlightCalibration (int wireGroup) const

Private Attributes
float	theFraction

float	theWireNoise

float	theWireThreshold

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

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

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

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 wires

Author: Rick Wilkinson

Definition at line 21 of file CSCWireElectronicsSim.h.

Constructor & Destructor Documentation

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

configurable parameters

Definition at line 16 of file CSCWireElectronicsSim.cc.

References CSCBaseElectronicsSim::fillAmpResponse().

  : CSCBaseElectronicsSim(p),
    theFraction(0.5),
    theWireNoise(0.0),
    theWireThreshold(0.)
 {
   fillAmpResponse();
 }

Member Function Documentation

float CSCWireElectronicsSim::calculateAmpResponse ( float t ) const

privatevirtual

Implements CSCBaseElectronicsSim.

Definition at line 163 of file CSCWireElectronicsSim.cc.

References create_public_lumi_plots::exp, p1, and funct::pow().

                                                                {
   static const float fC_by_ns = 1000000;
   static const float resistor = 20000;
   static const float amplifier_pole               = 1/7.5;
   static const float fastest_chamber_exp_risetime = 10.;
   static const float p0=amplifier_pole;
   static const float p1=1/fastest_chamber_exp_risetime;
 
   static const float dp = p0 - p1;
 
   // ENABLE DISC:
 
   static const float norm = -12 * resistor * p1 * pow(p0/dp, 4) / fC_by_ns;
 
   float enable_disc_volts = norm*(  exp(-p0*t) *(1          +
                          t*dp       +
                          pow(t*dp,2)/2 +
                          pow(t*dp,3)/6  )
                     - exp(-p1*t) );
   static const float collectionFraction = 0.12;
   static const float igain = 1./0.005; // volts per fC
   return enable_disc_volts * igain * collectionFraction;
 }                                                                               

virtual int CSCWireElectronicsSim::channelIndex ( int channel ) const

inlineprivatevirtual

we code strip indices from 1-80, and wire indices start at 100

Reimplemented from CSCBaseElectronicsSim.

Definition at line 43 of file CSCWireElectronicsSim.h.

Referenced by fillDigis().

43 {return channel+100;}

void CSCWireElectronicsSim::fillDigis	(	CSCWireDigiCollection &	digis,
		CLHEP::HepRandomEngine *	engine
	)

Definition at line 38 of file CSCWireElectronicsSim.cc.

Referenced by CSCDigitizer::doAction().

                                                                                                  {
 
   if(theSignalMap.empty()) {
     return;
   }
 
   // Loop over analog signals, run the fractional discriminator on each one,
   // and save the DIGI in the layer.
   for(CSCSignalMap::iterator mapI = theSignalMap.begin(),
       lastSignal = theSignalMap.end();
       mapI != lastSignal; ++mapI) 
   {
     int wireGroup = (*mapI).first;
     const CSCAnalogSignal & signal = (*mapI).second;
     LogTrace("CSCWireElectronicsSim") << "CSCWireElectronicsSim: dump of wire signal follows... " 
        <<  signal;
     int signalSize = signal.getSize();
 
     int timeWord = 0; // and this will remain if too early or late (<bx-6 or >bx+9)
 
     // the way we handle noise in this chamber is by randomly varying
     // the threshold
     float threshold = theWireThreshold;
     if (doNoise_) {
       threshold += CLHEP::RandGaussQ::shoot(engine) * theWireNoise;
     }
     for(int ibin = 0; ibin < signalSize; ++ibin)
     {
       if(signal.getBinValue(ibin) > threshold) 
       {
         // jackpot.  Now define this signal as everything up until
         // the signal goes below zero.
         int lastbin = signalSize;
         int i;
         for(i = ibin; i < signalSize; ++i) {
           if(signal.getBinValue(i) < 0.) {
             lastbin = i;
             break;
           }
         }
 
         float qMax = 0.0;
         // in this loop, find the max charge and the 'fifth' electron arrival
         for ( i = ibin; i < lastbin; ++i)
         {
           float next_charge = signal.getBinValue(i);
           if(next_charge > qMax) {
             qMax = next_charge;
           }
         }
      
         int bin_firing_FD = 0;
         for ( i = ibin; i < lastbin; ++i)
         {
           if( signal.getBinValue(i) >= qMax * theFraction )
           {
              bin_firing_FD = i;
          //@@ Long-standing but unlikely minor bug, I (Tim) think - following 'break' was missing...
          //@@ ... So if both ibins 0 and 1 could fire FD, we'd flag the firing bin as 1 not 0
          //@@ (since the above test was restricted to bin_firing_FD==0 too).
          break;
           }
         } 
 
         float tofOffset = timeOfFlightCalibration(wireGroup);
         int chamberType = theSpecs->chamberType();
 
         // Note that CSCAnalogSignal::superimpose does not reset theTimeOffset to the earliest
     // of the two signal's time offsets. If it did then we could handle signals from any
     // time range e.g. form pileup events many bx's from the signal bx (bx=0).
     // But then we would be wastefully storing signals over times which we can never
     // see in the real detector, because only hits within a few bx's of bx=0 are read out.
     // Instead, the working time range for wire hits is always started from
     // theSignalStartTime, set as a parameter in the config file.
     // On the other hand, if any of the overlapped CSCAnalogSignals happens to have
         // a timeOffset earlier than theSignalStartTime (which is currently set to -100 ns)
     // then we're in trouble. For pileup events this would mean events from collisions
     // earlier than 4 bx before the signal bx.
 
         float fdTime = theSignalStartTime + theSamplingTime*bin_firing_FD;
         if(doNoise_) {
           fdTime += theTimingCalibrationError[chamberType] * CLHEP::RandGaussQ::shoot(engine);
         }
 
         float bxFloat = (fdTime - tofOffset- theBunchTimingOffsets[chamberType]) / theBunchSpacing
                            + theOffsetOfBxZero;
         int bxInt = static_cast<int>(bxFloat);
         if(bxFloat >= 0 && bxFloat < 16)
         {
            timeWord |= (1 << bxInt );
            // discriminator stays high for 35 ns
            if(bxFloat-bxInt > 0.6) 
            {
              timeWord |= (1 << (bxInt+1) );
            }
         }
 
         // Wire digi as of Oct-2006 adapted to real data: time word has 16 bits with set bit
         // flagging appropriate bunch crossing, and bx 0 corresponding to the 7th bit, 'bit 6':
   
         //      1st bit set (bit 0) <-> bx -6
         //      2nd              1  <-> bx -5
         //      ...           ...       ....
         //      7th              6  <-> bx  0
         //      8th              7  <-> bx +1
         //      ...           ...       ....
         //     16th             15  <-> bx +9
 
         // skip over all the time bins used for this digi
         ibin = lastbin;
       } // if over threshold
     } // loop over time bins in signal
 
     // Only create a wire digi if there is a wire hit within [-6 bx, +9 bx]
     if(timeWord != 0)
     {
       CSCWireDigi newDigi(wireGroup, timeWord);
       LogTrace("CSCWireElectronicsSim") << newDigi;
       digis.insertDigi(layerId(), newDigi);
       addLinks(channelIndex(wireGroup));
     }
   } // loop over wire signals   
 }

void CSCWireElectronicsSim::initParameters ( )

privatevirtual

initialization for each layer

Implements CSCBaseElectronicsSim.

Definition at line 26 of file CSCWireElectronicsSim.cc.

References e_SI, CSCBaseElectronicsSim::nElements, CSCLayerGeometry::numberOfWireGroups(), funct::pow(), CSCBaseElectronicsSim::theLayerGeometry, CSCBaseElectronicsSim::theShapingTime, CSCBaseElectronicsSim::theSpecs, theWireNoise, theWireThreshold, and CSCChamberSpecs::wireNoise().

                                            {
   nElements = theLayerGeometry->numberOfWireGroups();
   theWireNoise = theSpecs->wireNoise(theShapingTime)
                 * e_SI * pow(10.0,15);
   theWireThreshold = theWireNoise * 8;
 }

int CSCWireElectronicsSim::readoutElement ( int element ) const

privatevirtual

Implements CSCBaseElectronicsSim.

Definition at line 34 of file CSCWireElectronicsSim.cc.

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

                                                            {
   return theLayerGeometry->wireGroup(element);
 }

void CSCWireElectronicsSim::setFraction ( float newFraction )

inline

Definition at line 27 of file CSCWireElectronicsSim.h.

References theFraction.

27 {theFraction = newFraction;};

CSCWireElectronicsSim::theFraction

float theFraction

Definition: CSCWireElectronicsSim.h:48

float CSCWireElectronicsSim::timeOfFlightCalibration ( int wireGroup ) const

privatevirtual

Definition at line 188 of file CSCWireElectronicsSim.cc.

References CSCLayer::centerOfWireGroup(), LogTrace, PV3DBase< T, PVType, FrameType >::mag(), CSCLayerGeometry::numberOfWireGroups(), CSCBaseElectronicsSim::theLayer, and CSCBaseElectronicsSim::theLayerGeometry.

Referenced by fillDigis().

                                                                         {
   // calibration is done for groups of 8 wire groups, facetiously
   // called wireGroupGroups
   int middleWireGroup = wireGroup - wireGroup%8 + 4;
   int numberOfWireGroups = theLayerGeometry->numberOfWireGroups();
   if(middleWireGroup > numberOfWireGroups) 
      middleWireGroup = numberOfWireGroups;
 
   GlobalPoint centerOfGroupGroup = theLayer->centerOfWireGroup(middleWireGroup);
   float averageDist = centerOfGroupGroup.mag();
   float averageTOF  = averageDist * cm / c_light; // Units of c_light: mm/ns
 
   LogTrace("CSCWireElectronicsSim") << "CSCWireElectronicsSim: TofCalib  wg = " << wireGroup << 
        " mid wg = " << middleWireGroup << 
        " av dist = " << averageDist << 
       " av tof = " << averageTOF;
   
   return averageTOF;
 }