CSCConditions Class Reference

#include <CSCConditions.h>

Public Member Functions
float	anodeBXoffset (const CSCDetId &detId) const
	anode bx offset in bx given detId of chamber More...
float	averageGain () const
const std::bitset< 112 > &	badStripWord () const
	bad strip channel word for a CSCLayer - 1 bit per channel More...
const std::bitset< 112 > &	badWireWord () const
	bad wiregroup channel word for a CSCLayer - 1 bit per channel More...
float	chamberTimingCorrection (const CSCDetId &detId) const
	chamber timing correction in ns given detId of chamber More...
int	channelFromStrip (const CSCDetId &id, int geomStrip) const
	feedthrough for external access More...
float	chipCorrection (const CSCDetId &detId, int channel) const
	chip speed correction in ns given detId (w/layer) and strip channel More...
void	crossTalk (const CSCDetId &id, int channel, std::vector< float > &ct) const
float	crosstalkIntercept (const CSCDetId &detId, int channel, bool leftRight) const
	crosstalk intercept for left and right More...
float	crosstalkSlope (const CSCDetId &detId, int channel, bool leftRight) const
	crosstalk slope for left and right More...
	CSCConditions (const edm::ParameterSet &ps, edm::ConsumesCollector)
void	fillBadChannelWords (const CSCDetId &id)
float	gain (const CSCDetId &detId, int channel) const
	gain per channel More...
float	gainSigma (const CSCDetId &detId, int channel) const
	overall calibration precision More...
float	gasGainCorrection (const CSCDetId &detId, int strip, int wire) const
const CSCDetId &	idOfBadChannelWords () const
	the offline CSCDetId of current bad channel words More...
void	initializeEvent (const edm::EventSetup &es)
	fetch database content via EventSetup More...
bool	isInBadChamber (const CSCDetId &id) const
	Is the gven chamber flagged as bad? More...
const CSCDBNoiseMatrix::Item &	noiseMatrix (const CSCDetId &detId, int channel) const
	raw noise matrix (unscaled short int elements) More...
void	noiseMatrixElements (const CSCDetId &id, int channel, std::vector< float > &me) const
float	pedestal (const CSCDetId &detId, int channel) const
	static ped in ADC counts More...
float	pedestalSigma (const CSCDetId &detId, int channel) const
	static ped rms in ADC counts More...
void	print () const
int	rawStripChannel (const CSCDetId &id, int geomChannel) const
bool	readBadChambers () const
	did we request reading bad chamber info from db? More...
bool	readBadChannels () const
	did we request reading bad channel info from db? More...
bool	useGasGainCorrections () const
	did we request reading gas gain correction info from db? More...
bool	useTimingCorrections () const
	did we request reading timing correction info from db? More...
	~CSCConditions ()

Private Types
enum	elayers { MAX_LAYERS = 3240 }

Private Member Functions
void	fillBadStripWord (const CSCDetId &id)
	fill bad channel words for offline id More...
void	fillBadWireWord (const CSCDetId &id)
void	setIdOfBadChannelWords (const CSCDetId &id)

Private Attributes
edm::ESGetToken< CSCBadChambers, CSCBadChambersRcd >	badChambersToken_
edm::ESGetToken< CSCBadStrips, CSCBadStripsRcd >	badStripsToken_
std::bitset< 112 >	badStripWord_
edm::ESGetToken< CSCBadWires, CSCBadWiresRcd >	badWiresToken_
std::bitset< 112 >	badWireWord_
edm::ESGetToken< CSCChamberTimeCorrections, CSCChamberTimeCorrectionsRcd >	chamberTimingCorrectionsToken_
edm::ESGetToken< CSCDBChipSpeedCorrection, CSCDBChipSpeedCorrectionRcd >	chipCorrectionsToken_
edm::ESGetToken< CSCDBCrosstalk, CSCDBCrosstalkRcd >	crosstalkToken_
edm::ESGetToken< CSCDBGains, CSCDBGainsRcd >	gainsToken_
edm::ESWatcher< CSCDBGainsRcd >	gainsWatcher_
edm::ESGetToken< CSCDBGasGainCorrection, CSCDBGasGainCorrectionRcd >	gasGainCorrectionsToken_
CSCDetId	idOfBadChannelWords_
edm::ESHandle< CSCIndexerBase >	indexer_
edm::ESGetToken< CSCIndexerBase, CSCIndexerRecord >	indexerToken_
edm::ESHandle< CSCChannelMapperBase >	mapper_
edm::ESGetToken< CSCChannelMapperBase, CSCChannelMapperRecord >	mapperToken_
edm::ESGetToken< CSCDBNoiseMatrix, CSCDBNoiseMatrixRcd >	noiseMatrixToken_
edm::ESGetToken< CSCDBPedestals, CSCDBPedestalsRcd >	pedestalsToken_
bool	readBadChambers_
bool	readBadChannels_
float	theAverageGain
edm::ESHandle< CSCBadChambers >	theBadChambers
edm::ESHandle< CSCBadStrips >	theBadStrips
edm::ESHandle< CSCBadWires >	theBadWires
edm::ESHandle< CSCChamberTimeCorrections >	theChamberTimingCorrections
edm::ESHandle< CSCDBChipSpeedCorrection >	theChipCorrections
edm::ESHandle< CSCDBCrosstalk >	theCrosstalk
edm::ESHandle< CSCDBGains >	theGains
edm::ESHandle< CSCDBGasGainCorrection >	theGasGainCorrections
edm::ESHandle< CSCDBNoiseMatrix >	theNoiseMatrix
edm::ESHandle< CSCDBPedestals >	thePedestals
bool	useGasGainCorrections_
bool	useTimingCorrections_

Detailed Description

Encapsulates a user interface into the CSC conditions

Author

Rick Wilkinson

Tim Cox

Interfaces generally use "channels" which count from 1 and are 'geometric' i.e. in the order matching local coordinates. This is the channel labelling in CSCStripDigi (and CSCWireDigi) after internal corrections within CSCRawToDigi.

The input CSCDetId is also 'geometric channel level' i.e. ME11A has its own CSCDetId even in the ganged case,

Ganged ME1a channels are 1-16 (and unganged, of course, 1-48)

From CMSSW 61X, this class also handles separate algorithm versions for indexing the conditions data and for mapping between online and offline channel labelling.

Definition at line 58 of file CSCConditions.h.

Member Enumeration Documentation

elayers

enum CSCConditions::elayers

private

Enumerator
MAX_LAYERS

Definition at line 208 of file CSCConditions.h.

{ MAX_LAYERS = 3240 };

Constructor & Destructor Documentation

CSCConditions()

CSCConditions::CSCConditions ( const edm::ParameterSet &  ps, edm::ConsumesCollector  cc  )

explicit

Definition at line 25 of file CSCConditions.cc.

    : theGains(),
      theCrosstalk(),
      thePedestals(),
      theNoiseMatrix(),
      theBadStrips(),
      theBadWires(),
      theBadChambers(),
      theChipCorrections(),
      theChamberTimingCorrections(),
      theGasGainCorrections(),
      indexer_(nullptr),
      mapper_(nullptr),
      readBadChannels_(false),
      readBadChambers_(false),
      useTimingCorrections_(false),
      useGasGainCorrections_(false),
      idOfBadChannelWords_(CSCDetId()),
      badStripWord_(0),
      badWireWord_(0),
      theAverageGain(-1.0) {
  readBadChannels_ = ps.getParameter<bool>("readBadChannels");
  readBadChambers_ = ps.getParameter<bool>("readBadChambers");
  useTimingCorrections_ = ps.getParameter<bool>("CSCUseTimingCorrections");
  useGasGainCorrections_ = ps.getParameter<bool>("CSCUseGasGainCorrections");
  indexerToken_ = cc.esConsumes<CSCIndexerBase, CSCIndexerRecord>();
  mapperToken_ = cc.esConsumes<CSCChannelMapperBase, CSCChannelMapperRecord>();
  gainsToken_ = cc.esConsumes<CSCDBGains, CSCDBGainsRcd>();
  crosstalkToken_ = cc.esConsumes<CSCDBCrosstalk, CSCDBCrosstalkRcd>();
  pedestalsToken_ = cc.esConsumes<CSCDBPedestals, CSCDBPedestalsRcd>();
  noiseMatrixToken_ = cc.esConsumes<CSCDBNoiseMatrix, CSCDBNoiseMatrixRcd>();
  if (useTimingCorrections()) {
    chipCorrectionsToken_ = cc.esConsumes<CSCDBChipSpeedCorrection, CSCDBChipSpeedCorrectionRcd>();
    chamberTimingCorrectionsToken_ = cc.esConsumes<CSCChamberTimeCorrections, CSCChamberTimeCorrectionsRcd>();
  }
  if (readBadChannels()) {
    badStripsToken_ = cc.esConsumes<CSCBadStrips, CSCBadStripsRcd>();
    badWiresToken_ = cc.esConsumes<CSCBadWires, CSCBadWiresRcd>();
  }
  if (readBadChambers()) {
    badChambersToken_ = cc.esConsumes<CSCBadChambers, CSCBadChambersRcd>();
  }
  if (useGasGainCorrections()) {
    gasGainCorrectionsToken_ = cc.esConsumes<CSCDBGasGainCorrection, CSCDBGasGainCorrectionRcd>();
  }
}

References badChambersToken_, badStripsToken_, badWiresToken_, chamberTimingCorrectionsToken_, chipCorrectionsToken_, crosstalkToken_, gainsToken_, gasGainCorrectionsToken_, edm::ParameterSet::getParameter(), indexerToken_, mapperToken_, noiseMatrixToken_, pedestalsToken_, readBadChambers(), readBadChambers_, readBadChannels(), readBadChannels_, useGasGainCorrections(), useGasGainCorrections_, useTimingCorrections(), and useTimingCorrections_.

~CSCConditions()

CSCConditions::~CSCConditions

(

)

Definition at line 72 of file CSCConditions.cc.

{}

Member Function Documentation

anodeBXoffset()

float CSCConditions::anodeBXoffset

(

const CSCDetId &

detId

)

const

anode bx offset in bx given detId of chamber

Definition at line 345 of file CSCConditions.cc.

                                                           {
  if (useTimingCorrections()) {
    assert(theChamberTimingCorrections.isValid());
    CSCDetId idraw = mapper_->rawCSCDetId(id);
    int index = indexer_->chamberIndex(idraw) - 1;  // NOTE THE MINUS ONE!
    return float(theChamberTimingCorrections->item(index).anode_bx_offset * 1. /
                 theChamberTimingCorrections->precision());
  } else
    return 0;
}

References CSCChamberTimeCorrections::ChamberTimeCorrections::anode_bx_offset, cms::cuda::assert(), CSCIndexerBase::chamberIndex(), dqmMemoryStats::float, indexer_, edm::ESHandleBase::isValid(), CSCChamberTimeCorrections::item(), mapper_, CSCChamberTimeCorrections::precision(), CSCChannelMapperBase::rawCSCDetId(), theChamberTimingCorrections, and useTimingCorrections().

Referenced by CSCRecoConditions::anodeBXoffset().

averageGain()

float CSCConditions::averageGain

(

)

const

average gain over entire CSC system (logically const although must be cached here).

Return average strip gain for full CSC system. Lazy evaluation. Restrict averaging to gains between 5 and 10, and require average is between 6 or 9 otherwise fix it to 7.5. These values came from Dominique and Stan,

Definition at line 360 of file CSCConditions.cc.

                                       {
  const float loEdge = 5.0;           // consider gains above this
  const float hiEdge = 10.0;          // consider gains below this
  const float loLimit = 6.0;          // lowest acceptable average gain
  const float hiLimit = 9.0;          // highest acceptable average gain
  const float expectedAverage = 7.5;  // default average gain
 
  if (theAverageGain > 0.)
    return theAverageGain;  // only recalculate if necessary
 
  int n_strip = 0;
  float gain_tot = 0.;
 
  CSCDBGains::GainContainer::const_iterator it;
  for (it = theGains->gains.begin(); it != theGains->gains.end(); ++it) {
    float the_gain = float(it->gain_slope) / theGains->scale();
    if (the_gain > loEdge && the_gain < hiEdge) {
      gain_tot += the_gain;
      ++n_strip;
    }
  }
 
  // Average gain
  if (n_strip > 0) {
    theAverageGain = gain_tot / n_strip;
  }
 
  // Average gain has been around 7.5 in real data
  if (theAverageGain < loLimit || theAverageGain > hiLimit) {
    //    LogTrace("CSC") << "Average CSC strip gain = "
    //                    << theAverageGain << "  is reset to expected value "
    //                    << expectedAverage;
    theAverageGain = expectedAverage;
  }
 
  return theAverageGain;
}

References dqmMemoryStats::float, CSCDBGains::gains, CSCDBGains::scale(), theAverageGain, and theGains.

Referenced by CSCRecoConditions::averageGain().

badStripWord()

const std::bitset<112>& CSCConditions::badStripWord ( ) const

inline

bad strip channel word for a CSCLayer - 1 bit per channel

Definition at line 102 of file CSCConditions.h.

{ return badStripWord_; }

References badStripWord_.

Referenced by CSCRecoConditions::badStrip().

badWireWord()

const std::bitset<112>& CSCConditions::badWireWord ( ) const

inline

bad wiregroup channel word for a CSCLayer - 1 bit per channel

Definition at line 105 of file CSCConditions.h.

{ return badWireWord_; }

References badWireWord_.

Referenced by CSCRecoConditions::badWireWord().

chamberTimingCorrection()

float CSCConditions::chamberTimingCorrection

(

const CSCDetId &

detId

)

const

chamber timing correction in ns given detId of chamber

Definition at line 333 of file CSCConditions.cc.

                                                                     {
  if (useTimingCorrections()) {
    assert(theChamberTimingCorrections.isValid());
    CSCDetId idraw = mapper_->rawCSCDetId(id);
    int index = indexer_->chamberIndex(idraw) - 1;  // NOTE THE MINUS ONE!
    return float(
        theChamberTimingCorrections->item(index).cfeb_tmb_skew_delay * 1. / theChamberTimingCorrections->precision() +
        theChamberTimingCorrections->item(index).cfeb_timing_corr * 1. / theChamberTimingCorrections->precision() +
        (theChamberTimingCorrections->item(index).cfeb_cable_delay * 25.));
  } else
    return 0;
}

References cms::cuda::assert(), CSCChamberTimeCorrections::ChamberTimeCorrections::cfeb_cable_delay, CSCChamberTimeCorrections::ChamberTimeCorrections::cfeb_timing_corr, CSCChamberTimeCorrections::ChamberTimeCorrections::cfeb_tmb_skew_delay, CSCIndexerBase::chamberIndex(), dqmMemoryStats::float, indexer_, edm::ESHandleBase::isValid(), CSCChamberTimeCorrections::item(), mapper_, CSCChamberTimeCorrections::precision(), CSCChannelMapperBase::rawCSCDetId(), theChamberTimingCorrections, and useTimingCorrections().

Referenced by CSCRecoConditions::chamberTimingCorrection().

channelFromStrip()

int CSCConditions::channelFromStrip	(	const CSCDetId &	id,
		int	geomStrip
	)		const

feedthrough for external access

Definition at line 410 of file CSCConditions.cc.

                                                                           {
  return mapper_->channelFromStrip(id, geomStrip);
}

References CSCChannelMapperBase::channelFromStrip(), and mapper_.

Referenced by CSCRecoConditions::badStrip(), CSCRecoConditions::chipCorrection(), CSCRecoConditions::crossTalk(), CSCRecoConditions::gasGainCorrection(), CSCRecoConditions::noiseMatrix(), and CSCRecoConditions::stripWeight().

chipCorrection()

float CSCConditions::chipCorrection	(	const CSCDetId &	detId,
		int	channel
	)		const

chip speed correction in ns given detId (w/layer) and strip channel

Definition at line 322 of file CSCConditions.cc.

                                                                             {
  if (useTimingCorrections()) {
    assert(theChipCorrections.isValid());
    CSCDetId idraw = mapper_->rawCSCDetId(id);
    int iraw = mapper_->rawStripChannel(id, geomChannel);
    int ichip = indexer_->chipIndex(iraw);              // converts 1-80 to 1-5 (chip#, CFEB#)
    int index = indexer_->chipIndex(idraw, ichip) - 1;  // NOTE THE MINUS ONE!
    return float(theChipCorrections->value(index)) / theChipCorrections->scale();
  } else
    return 0;
}

References cms::cuda::assert(), CSCIndexerBase::chipIndex(), dqmMemoryStats::float, indexer_, edm::ESHandleBase::isValid(), mapper_, CSCChannelMapperBase::rawCSCDetId(), CSCChannelMapperBase::rawStripChannel(), CSCDBChipSpeedCorrection::scale(), theChipCorrections, useTimingCorrections(), and CSCDBChipSpeedCorrection::value().

Referenced by CSCRecoConditions::chipCorrection().

crossTalk()

void CSCConditions::crossTalk	(	const CSCDetId &	id,
		int	channel,
		std::vector< float > &	ct
	)		const

fill vector (dim 4, must be allocated by caller) with crosstalk sl, il, sr, ir

Definition at line 310 of file CSCConditions.cc.

                                                                                             {
  assert(theCrosstalk.isValid());
  CSCDetId idraw = mapper_->rawCSCDetId(id);
  int iraw = mapper_->rawStripChannel(id, geomChannel);
  int index = indexer_->stripChannelIndex(idraw, iraw) - 1;  // NOTE THE MINUS ONE!
 
  ct[0] = float(theCrosstalk->lslope(index)) / theCrosstalk->sscale();
  ct[1] = float(theCrosstalk->linter(index)) / theCrosstalk->iscale();
  ct[2] = float(theCrosstalk->rslope(index)) / theCrosstalk->sscale();
  ct[3] = float(theCrosstalk->rinter(index)) / theCrosstalk->iscale();
}

References cms::cuda::assert(), dqmMemoryStats::float, indexer_, CSCDBCrosstalk::iscale(), edm::ESHandleBase::isValid(), CSCDBCrosstalk::linter(), CSCDBCrosstalk::lslope(), mapper_, CSCChannelMapperBase::rawCSCDetId(), CSCChannelMapperBase::rawStripChannel(), CSCDBCrosstalk::rinter(), CSCDBCrosstalk::rslope(), CSCDBCrosstalk::sscale(), CSCIndexerBase::stripChannelIndex(), and theCrosstalk.

Referenced by CSCRecoConditions::crossTalk().

crosstalkIntercept()

float CSCConditions::crosstalkIntercept	(	const CSCDetId &	detId,
		int	channel,
		bool	leftRight
	)		const

crosstalk intercept for left and right

Definition at line 261 of file CSCConditions.cc.

                                                                                                 {
  assert(theCrosstalk.isValid());
  CSCDetId idraw = mapper_->rawCSCDetId(id);
  int iraw = mapper_->rawStripChannel(id, geomChannel);
  int index = indexer_->stripChannelIndex(idraw, iraw) - 1;  // NOTE THE MINUS ONE!
  // resistive fraction is at the peak, where t=0
  return leftRight ? float(theCrosstalk->rinter(index)) / theCrosstalk->iscale()
                   : float(theCrosstalk->linter(index)) / theCrosstalk->iscale();
}

References cms::cuda::assert(), dqmMemoryStats::float, indexer_, CSCDBCrosstalk::iscale(), edm::ESHandleBase::isValid(), CSCDBCrosstalk::linter(), mapper_, CSCChannelMapperBase::rawCSCDetId(), CSCChannelMapperBase::rawStripChannel(), CSCDBCrosstalk::rinter(), CSCIndexerBase::stripChannelIndex(), and theCrosstalk.

Referenced by CSCDbStripConditions::crosstalk().

crosstalkSlope()

float CSCConditions::crosstalkSlope	(	const CSCDetId &	detId,
		int	channel,
		bool	leftRight
	)		const

crosstalk slope for left and right

Definition at line 271 of file CSCConditions.cc.

                                                                                             {
  assert(theCrosstalk.isValid());
  CSCDetId idraw = mapper_->rawCSCDetId(id);
  int iraw = mapper_->rawStripChannel(id, geomChannel);
  int index = indexer_->stripChannelIndex(idraw, iraw) - 1;  // NOTE THE MINUS ONE!
  // resistive fraction is at the peak, where t=0
  return leftRight ? float(theCrosstalk->rslope(index)) / theCrosstalk->sscale()
                   : float(theCrosstalk->lslope(index)) / theCrosstalk->sscale();
}

References cms::cuda::assert(), dqmMemoryStats::float, indexer_, edm::ESHandleBase::isValid(), CSCDBCrosstalk::lslope(), mapper_, CSCChannelMapperBase::rawCSCDetId(), CSCChannelMapperBase::rawStripChannel(), CSCDBCrosstalk::rslope(), CSCDBCrosstalk::sscale(), CSCIndexerBase::stripChannelIndex(), and theCrosstalk.

Referenced by CSCDbStripConditions::crosstalk().

fillBadChannelWords()

void CSCConditions::fillBadChannelWords

(

const CSCDetId &

id

)

Fill bad channel words - one for strips, one for wires, for an offline CSCDetId

Definition at line 127 of file CSCConditions.cc.

                                                          {
  // input CSCDetId is expected to be an offline value i.e. different for ME1/1A
  // and ME1/1B
 
  // Only update content if necessary
  if (id != idOfBadChannelWords()) {
    // store offline CSCDetId for the two bad channel words
    setIdOfBadChannelWords(id);
 
    // reset to all zeroes
    badStripWord_.reset();
    badWireWord_.reset();
 
    if (readBadChannels()) {
      // convert to online CSCDetId since that is how conditions data are stored
      CSCDetId idraw = mapper_->rawCSCDetId(id);
      fillBadStripWord(idraw);
      fillBadWireWord(idraw);
    }
  }
}

References badStripWord_, badWireWord_, fillBadStripWord(), fillBadWireWord(), idOfBadChannelWords(), mapper_, CSCChannelMapperBase::rawCSCDetId(), readBadChannels(), and setIdOfBadChannelWords().

Referenced by CSCRecoConditions::fillBadChannelWords().

fillBadStripWord()

void CSCConditions::fillBadStripWord ( const CSCDetId &  id )

private

fill bad channel words for offline id

Next function private.

Definition at line 151 of file CSCConditions.cc.

                                                       {
  // Input CSCDetId is expected to be a 'raw' value
 
  // Find linear index of chamber for input CSCDetId
  int inputIndex = indexer_->chamberIndex(id);
  short inputLayer = id.layer();
 
  // Does this chamber occur in bad channel list? If so, unpack its bad channels
 
  // chambers is a vector<BadChamber>
  // channels is a vector<BadChannel>
  // Each BadChamber contains its index (1-468 or 540 w. ME42), the no. of bad
  // channels, and the index within vector<BadChannel> where this chamber's bad
  // channels start.
 
  for (size_t i = 0; i < theBadStrips->chambers.size(); ++i) {  // loop over bad chambers
    int indexc = theBadStrips->chambers[i].chamber_index;
    if (indexc != inputIndex)
      continue;  // next iteration if not a match
 
    int start = theBadStrips->chambers[i].pointer;
    int nbad = theBadStrips->chambers[i].bad_channels;
 
    for (int j = start - 1; j < start - 1 + nbad; ++j) {  // bad channels in this chamber
      short lay = theBadStrips->channels[j].layer;        // value 1-6
      if (lay != inputLayer)
        continue;
 
      short chan = theBadStrips->channels[j].channel;  // value 1-80 (->112 for unganged ME1/1A)
      // Flags so far unused (and unset in conditins data)
      //    short f1 = theBadStrips->channels[j].flag1;
      //    short f2 = theBadStrips->channels[j].flag2;
      //    short f3 = theBadStrips->channels[j].flag3;
      badStripWord_.set(chan - 1, true);  // set bit 0-79 (111) in 80 (112)-bit
                                          // bitset representing this layer
    }                                     // j
  }                                       // i
}

References badStripWord_, CSCIndexerBase::chamberIndex(), CSCBadStrips::chambers, officialStyle::chan, CSCBadStrips::channels, mps_fire::i, indexer_, dqmiolumiharvest::j, and theBadStrips.

Referenced by fillBadChannelWords().

fillBadWireWord()

void CSCConditions::fillBadWireWord ( const CSCDetId &  id )

private

Definition at line 190 of file CSCConditions.cc.

                                                      {
  // Input CSCDetId is expected to be a 'raw' value
 
  // Find linear index of chamber for input CSCDetId
  int inputIndex = indexer_->chamberIndex(id);
  short inputLayer = id.layer();
 
  // unpack what we've read from theBadWires
 
  for (size_t i = 0; i < theBadWires->chambers.size(); ++i) {  // loop over bad chambers
    int indexc = theBadWires->chambers[i].chamber_index;
 
    if (indexc != inputIndex)
      continue;  // next iteration if not a match
 
    int start = theBadWires->chambers[i].pointer;
    int nbad = theBadWires->chambers[i].bad_channels;
 
    for (int j = start - 1; j < start - 1 + nbad; ++j) {  // bad channels in this chamber
      short lay = theBadWires->channels[j].layer;         // value 1-6
      if (lay != inputLayer)
        continue;
 
      short chan = theBadWires->channels[j].channel;  // value 1-112
      //    short f1 = theBadWires->channels[j].flag1;
      //    short f2 = theBadWires->channels[j].flag2;
      //    short f3 = theBadWires->channels[j].flag3;
      badWireWord_.set(chan - 1,
                       true);  // set bit 0-111 in 112-bit bitset representing this layer
    }                          // j
  }                            // i
}

References badWireWord_, CSCIndexerBase::chamberIndex(), CSCBadWires::chambers, officialStyle::chan, CSCBadWires::channels, mps_fire::i, indexer_, dqmiolumiharvest::j, and theBadWires.

Referenced by fillBadChannelWords().

gain()

float CSCConditions::gain	(	const CSCDetId &	detId,
		int	channel
	)		const

gain per channel

Definition at line 237 of file CSCConditions.cc.

                                                                   {
  assert(theGains.isValid());
  CSCDetId idraw = mapper_->rawCSCDetId(id);
  int iraw = mapper_->rawStripChannel(id, geomChannel);
  int index = indexer_->stripChannelIndex(idraw, iraw) - 1;  // NOTE THE MINUS ONE!
  return float(theGains->gain(index)) / theGains->scale();
}

References cms::cuda::assert(), dqmMemoryStats::float, CSCDBGains::gain(), indexer_, edm::ESHandleBase::isValid(), mapper_, CSCChannelMapperBase::rawCSCDetId(), CSCChannelMapperBase::rawStripChannel(), CSCDBGains::scale(), CSCIndexerBase::stripChannelIndex(), and theGains.

Referenced by CSCDbStripConditions::gain(), and CSCRecoConditions::gain().

gainSigma()

float CSCConditions::gainSigma ( const CSCDetId &  detId, int  channel  ) const

inline

overall calibration precision

Definition at line 69 of file CSCConditions.h.

{ return 0.005; }

gasGainCorrection()

float CSCConditions::gasGainCorrection	(	const CSCDetId &	detId,
		int	strip,
		int	wire
	)		const

gas gain correction as a function of detId (w/layer), strip, and wire channels

Definition at line 398 of file CSCConditions.cc.

                                                                                                {
  if (useGasGainCorrections()) {
    assert(theGasGainCorrections.isValid());
    CSCDetId idraw = mapper_->rawCSCDetId(id);
    int iraw = mapper_->rawStripChannel(id, geomChannel);
    int index = indexer_->gasGainIndex(idraw, iraw, iwiregroup) - 1;  // NOTE THE MINUS ONE!
    return float(theGasGainCorrections->value(index));
  } else {
    return 1.;
  }
}

References cms::cuda::assert(), dqmMemoryStats::float, CSCIndexerBase::gasGainIndex(), indexer_, edm::ESHandleBase::isValid(), mapper_, CSCChannelMapperBase::rawCSCDetId(), CSCChannelMapperBase::rawStripChannel(), theGasGainCorrections, useGasGainCorrections(), and CSCDBGasGainCorrection::value().

Referenced by CSCRecoConditions::gasGainCorrection().

idOfBadChannelWords()

const CSCDetId& CSCConditions::idOfBadChannelWords ( ) const

inline

the offline CSCDetId of current bad channel words

Definition at line 108 of file CSCConditions.h.

{ return idOfBadChannelWords_; }

References idOfBadChannelWords_.

Referenced by CSCRecoConditions::badStrip(), and fillBadChannelWords().

initializeEvent()

void CSCConditions::initializeEvent

(

const edm::EventSetup &

es

)

fetch database content via EventSetup

Definition at line 74 of file CSCConditions.cc.

                                                           {
  // Algorithms
  indexer_ = es.getHandle(indexerToken_);
  mapper_ = es.getHandle(mapperToken_);
 
  // Strip gains
  theGains = es.getHandle(gainsToken_);
  // Strip X-talk
  theCrosstalk = es.getHandle(crosstalkToken_);
  // Strip pedestals
  thePedestals = es.getHandle(pedestalsToken_);
  // Strip autocorrelation noise matrix
  theNoiseMatrix = es.getHandle(noiseMatrixToken_);
 
  if (useTimingCorrections()) {
    // Buckeye chip speeds
    theChipCorrections = es.getHandle(chipCorrectionsToken_);
    // Cable lengths from chambers to peripheral crate and additional chamber
    // level timing correction
    theChamberTimingCorrections = es.getHandle(chamberTimingCorrectionsToken_);
  }
 
  if (readBadChannels()) {
    // Bad strip channels
    theBadStrips = es.getHandle(badStripsToken_);
    // Bad wiregroup channels
    theBadWires = es.getHandle(badWiresToken_);
 
    //@@    if( badStripsWatcher_.check( es ) ) {
    //      fillBadStripWords();
    //@@    }
    //@@    if( badWiresWatcher_.check( es ) ) {
    //      fillBadWireWords();
    //@    }
  }
 
  // Has GainsRcd changed?
  if (gainsWatcher_.check(es)) {  // Yes...
    theAverageGain = -1.0;        // ...reset, so next access will recalculate it
  }
 
  if (readBadChambers()) {
    // Entire bad chambers
    theBadChambers = es.getHandle(badChambersToken_);
  }
 
  if (useGasGainCorrections()) {
    theGasGainCorrections = es.getHandle(gasGainCorrectionsToken_);
  }
 
  //  print();
}

References badChambersToken_, badStripsToken_, badWiresToken_, chamberTimingCorrectionsToken_, edm::ESWatcher< T >::check(), chipCorrectionsToken_, crosstalkToken_, gainsToken_, gainsWatcher_, gasGainCorrectionsToken_, edm::EventSetup::getHandle(), indexer_, indexerToken_, mapper_, mapperToken_, noiseMatrixToken_, pedestalsToken_, readBadChambers(), readBadChannels(), theAverageGain, theBadChambers, theBadStrips, theBadWires, theChamberTimingCorrections, theChipCorrections, theCrosstalk, theGains, theGasGainCorrections, theNoiseMatrix, thePedestals, useGasGainCorrections(), and useTimingCorrections().

Referenced by CSCDbStripConditions::initializeEvent(), and CSCRecoConditions::initializeEvent().

isInBadChamber()

bool CSCConditions::isInBadChamber

(

const CSCDetId &

id

)

const

Is the gven chamber flagged as bad?

Definition at line 223 of file CSCConditions.cc.

                                                           {
  //@@ We do not consider the possibility of having ME1/1A & ME1/1B
  // independently 'bad'.
  //@@ To do that we would need to define separate chamber indexes for ME1/1A &
  // ME1/1B.
 
  if (readBadChambers()) {
    CSCDetId idraw = mapper_->rawCSCDetId(id);
    int index = indexer_->chamberIndex(idraw);
    return theBadChambers->isInBadChamber(index);
  } else
    return false;
}

References CSCIndexerBase::chamberIndex(), indexer_, CSCBadChambers::isInBadChamber(), mapper_, CSCChannelMapperBase::rawCSCDetId(), readBadChambers(), and theBadChambers.

Referenced by CSCDbStripConditions::isInBadChamber().

noiseMatrix()

const CSCDBNoiseMatrix::Item & CSCConditions::noiseMatrix	(	const CSCDetId &	detId,
		int	channel
	)		const

raw noise matrix (unscaled short int elements)

Definition at line 281 of file CSCConditions.cc.

                                                                                                {
  //@@ BEWARE - THIS FUNCTION DOES NOT APPLY SCALE FACTOR USED IN PACKING VALUES
  // IN CONDITIONS DATA
  //@@ MAY BE AN ERROR? WHO WOULD WANT ACCESS WITHOUT IT?
 
  assert(theNoiseMatrix.isValid());
  CSCDetId idraw = mapper_->rawCSCDetId(id);
  int iraw = mapper_->rawStripChannel(id, geomChannel);
  int index = indexer_->stripChannelIndex(idraw, iraw) - 1;  // NOTE THE MINUS ONE!
  return theNoiseMatrix->item(index);
}

References cms::cuda::assert(), indexer_, edm::ESHandleBase::isValid(), CSCDBNoiseMatrix::item(), mapper_, CSCChannelMapperBase::rawCSCDetId(), CSCChannelMapperBase::rawStripChannel(), CSCIndexerBase::stripChannelIndex(), and theNoiseMatrix.

Referenced by noiseMatrixElements().

noiseMatrixElements()

void CSCConditions::noiseMatrixElements	(	const CSCDetId &	id,
		int	channel,
		std::vector< float > &	me
	)		const

fill vector (dim 12, must be allocated by caller) with noise matrix elements (scaled to float)

Definition at line 293 of file CSCConditions.cc.

                                                                                                       {
  assert(me.size() > 11);
  const CSCDBNoiseMatrix::Item &item = noiseMatrix(id, geomChannel);  // i.e. the function above
  me[0] = float(item.elem33) / theNoiseMatrix->scale();
  me[1] = float(item.elem34) / theNoiseMatrix->scale();
  me[2] = float(item.elem35) / theNoiseMatrix->scale();
  me[3] = float(item.elem44) / theNoiseMatrix->scale();
  me[4] = float(item.elem45) / theNoiseMatrix->scale();
  me[5] = float(item.elem46) / theNoiseMatrix->scale();
  me[6] = float(item.elem55) / theNoiseMatrix->scale();
  me[7] = float(item.elem56) / theNoiseMatrix->scale();
  me[8] = float(item.elem57) / theNoiseMatrix->scale();
  me[9] = float(item.elem66) / theNoiseMatrix->scale();
  me[10] = float(item.elem67) / theNoiseMatrix->scale();
  me[11] = float(item.elem77) / theNoiseMatrix->scale();
}

References cms::cuda::assert(), dqmMemoryStats::float, B2GTnPMonitor_cfi::item, hlt_dqm_clientPB-live_cfg::me, noiseMatrix(), CSCDBNoiseMatrix::scale(), and theNoiseMatrix.

Referenced by CSCDbStripConditions::fetchNoisifier(), and CSCRecoConditions::noiseMatrix().

pedestal()

float CSCConditions::pedestal	(	const CSCDetId &	detId,
		int	channel
	)		const

static ped in ADC counts

Definition at line 245 of file CSCConditions.cc.

                                                                       {
  assert(thePedestals.isValid());
  CSCDetId idraw = mapper_->rawCSCDetId(id);
  int iraw = mapper_->rawStripChannel(id, geomChannel);
  int index = indexer_->stripChannelIndex(idraw, iraw) - 1;  // NOTE THE MINUS ONE!
  return float(thePedestals->pedestal(index)) / thePedestals->scale_ped();
}

References cms::cuda::assert(), dqmMemoryStats::float, indexer_, edm::ESHandleBase::isValid(), mapper_, CSCDBPedestals::pedestal(), CSCChannelMapperBase::rawCSCDetId(), CSCChannelMapperBase::rawStripChannel(), CSCDBPedestals::scale_ped(), CSCIndexerBase::stripChannelIndex(), and thePedestals.

Referenced by CSCDbStripConditions::pedestal(), and CSCRecoConditions::pedestal().

pedestalSigma()

float CSCConditions::pedestalSigma	(	const CSCDetId &	detId,
		int	channel
	)		const

static ped rms in ADC counts

Definition at line 253 of file CSCConditions.cc.

                                                                            {
  assert(thePedestals.isValid());
  CSCDetId idraw = mapper_->rawCSCDetId(id);
  int iraw = mapper_->rawStripChannel(id, geomChannel);
  int index = indexer_->stripChannelIndex(idraw, iraw) - 1;  // NOTE THE MINUS ONE!
  return float(thePedestals->pedestal_rms(index)) / thePedestals->scale_rms();
}

References cms::cuda::assert(), dqmMemoryStats::float, indexer_, edm::ESHandleBase::isValid(), mapper_, CSCDBPedestals::pedestal_rms(), CSCChannelMapperBase::rawCSCDetId(), CSCChannelMapperBase::rawStripChannel(), CSCDBPedestals::scale_rms(), CSCIndexerBase::stripChannelIndex(), and thePedestals.

Referenced by CSCDbStripConditions::pedestalSigma(), and CSCRecoConditions::pedestalSigma().

print()

void CSCConditions::print

(

void

)

const

Definition at line 418 of file CSCConditions.cc.

{
  /*
    std::cout << "SIZES: GAINS: " << theGains->gains.size()
              << "   PEDESTALS: " << thePedestals->pedestals.size()
              << "   NOISES "  << theNoiseMatrix->matrix.size() << std::endl;;
 
    std::map< int,std::vector<CSCDBGains::Item> >::const_iterator layerGainsItr
    = theGains->gains.begin(), lastGain = theGains->gains.end(); for( ;
    layerGainsItr != lastGain; ++layerGainsItr)
    {
      std::cout << "GAIN " << layerGainsItr->first
                << " STRIPS " << layerGainsItr->second.size() << " "
                << layerGainsItr->second[0].gain_slope
                << " " << layerGainsItr->second[0].gain_intercept << std::endl;
    }
 
    std::map< int,std::vector<CSCDBPedestals::Item> >::const_iterator
    pedestalItr = thePedestals->pedestals.begin(), lastPedestal =
    thePedestals->pedestals.end(); for( ; pedestalItr != lastPedestal;
    ++pedestalItr)
    {
      std::cout << "PEDS " << pedestalItr->first << " "
                << " STRIPS " << pedestalItr->second.size() << " ";
      for(int i = 1; i < 80; ++i)
      {
         std::cout << pedestalItr->second[i-1].rms << " " ;
       }
       std::cout << std::endl;
    }
 
    std::map< int,std::vector<CSCDBCrosstalk::Item> >::const_iterator
    crosstalkItr = theCrosstalk->crosstalk.begin(), lastCrosstalk =
    theCrosstalk->crosstalk.end(); for( ; crosstalkItr != lastCrosstalk;
    ++crosstalkItr)
    {
      std::cout << "XTALKS " << crosstalkItr->first
        << " STRIPS " << crosstalkItr->second.size() << " "
       << crosstalkItr->second[5].xtalk_slope_left << " "
       << crosstalkItr->second[5].xtalk_slope_right << " "
       << crosstalkItr->second[5].xtalk_intercept_left << " "
       << crosstalkItr->second[5].xtalk_intercept_right << std::endl;
    }
  */
}

rawStripChannel()

int CSCConditions::rawStripChannel	(	const CSCDetId &	id,
		int	geomChannel
	)		const

Definition at line 414 of file CSCConditions.cc.

                                                                            {
  return mapper_->rawStripChannel(id, geomChannel);
}

References mapper_, and CSCChannelMapperBase::rawStripChannel().

Referenced by CSCRecoConditions::badStrip().

readBadChambers()

bool CSCConditions::readBadChambers ( ) const

inline

did we request reading bad chamber info from db?

Definition at line 119 of file CSCConditions.h.

{ return readBadChambers_; }

References readBadChambers_.

Referenced by CSCConditions(), initializeEvent(), and isInBadChamber().

readBadChannels()

bool CSCConditions::readBadChannels ( ) const

inline

did we request reading bad channel info from db?

Definition at line 116 of file CSCConditions.h.

{ return readBadChannels_; }

References readBadChannels_.

Referenced by CSCConditions(), fillBadChannelWords(), and initializeEvent().

setIdOfBadChannelWords()

void CSCConditions::setIdOfBadChannelWords ( const CSCDetId &  id )

inlineprivate

Set id for current content of bad channel words - this is offline id i.e. separate for ME11A & ME11B

Definition at line 149 of file CSCConditions.h.

{ idOfBadChannelWords_ = id; }

References triggerObjects_cff::id, and idOfBadChannelWords_.

Referenced by fillBadChannelWords().

useGasGainCorrections()

bool CSCConditions::useGasGainCorrections ( ) const

inline

did we request reading gas gain correction info from db?

Definition at line 137 of file CSCConditions.h.

{ return useGasGainCorrections_; }

References useGasGainCorrections_.

Referenced by CSCConditions(), gasGainCorrection(), and initializeEvent().

useTimingCorrections()

bool CSCConditions::useTimingCorrections ( ) const

inline

did we request reading timing correction info from db?

Definition at line 122 of file CSCConditions.h.

{ return useTimingCorrections_; }

References useTimingCorrections_.

Referenced by anodeBXoffset(), chamberTimingCorrection(), chipCorrection(), CSCConditions(), and initializeEvent().

Member Data Documentation

badChambersToken_

edm::ESGetToken<CSCBadChambers, CSCBadChambersRcd> CSCConditions::badChambersToken_

private

Definition at line 176 of file CSCConditions.h.

Referenced by CSCConditions(), and initializeEvent().

badStripsToken_

edm::ESGetToken<CSCBadStrips, CSCBadStripsRcd> CSCConditions::badStripsToken_

private

Definition at line 174 of file CSCConditions.h.

Referenced by CSCConditions(), and initializeEvent().

badStripWord_

std::bitset<112> CSCConditions::badStripWord_

private

Definition at line 196 of file CSCConditions.h.

Referenced by badStripWord(), fillBadChannelWords(), and fillBadStripWord().

badWiresToken_

edm::ESGetToken<CSCBadWires, CSCBadWiresRcd> CSCConditions::badWiresToken_

private

Definition at line 175 of file CSCConditions.h.

Referenced by CSCConditions(), and initializeEvent().

badWireWord_

std::bitset<112> CSCConditions::badWireWord_

private

Definition at line 197 of file CSCConditions.h.

Referenced by badWireWord(), fillBadChannelWords(), and fillBadWireWord().

chamberTimingCorrectionsToken_

edm::ESGetToken<CSCChamberTimeCorrections, CSCChamberTimeCorrectionsRcd> CSCConditions::chamberTimingCorrectionsToken_

private

Definition at line 178 of file CSCConditions.h.

Referenced by CSCConditions(), and initializeEvent().

chipCorrectionsToken_

edm::ESGetToken<CSCDBChipSpeedCorrection, CSCDBChipSpeedCorrectionRcd> CSCConditions::chipCorrectionsToken_

private

Definition at line 177 of file CSCConditions.h.

Referenced by CSCConditions(), and initializeEvent().

crosstalkToken_

edm::ESGetToken<CSCDBCrosstalk, CSCDBCrosstalkRcd> CSCConditions::crosstalkToken_

private

Definition at line 171 of file CSCConditions.h.

Referenced by CSCConditions(), and initializeEvent().

gainsToken_

edm::ESGetToken<CSCDBGains, CSCDBGainsRcd> CSCConditions::gainsToken_

private

Definition at line 170 of file CSCConditions.h.

Referenced by CSCConditions(), and initializeEvent().

gainsWatcher_

edm::ESWatcher<CSCDBGainsRcd> CSCConditions::gainsWatcher_

private

Definition at line 202 of file CSCConditions.h.

Referenced by initializeEvent().

gasGainCorrectionsToken_

edm::ESGetToken<CSCDBGasGainCorrection, CSCDBGasGainCorrectionRcd> CSCConditions::gasGainCorrectionsToken_

private

Definition at line 179 of file CSCConditions.h.

Referenced by CSCConditions(), and initializeEvent().

idOfBadChannelWords_

CSCDetId CSCConditions::idOfBadChannelWords_

private

Definition at line 195 of file CSCConditions.h.

Referenced by idOfBadChannelWords(), and setIdOfBadChannelWords().

indexer_

edm::ESHandle<CSCIndexerBase> CSCConditions::indexer_

private

Definition at line 166 of file CSCConditions.h.

Referenced by anodeBXoffset(), chamberTimingCorrection(), chipCorrection(), crossTalk(), crosstalkIntercept(), crosstalkSlope(), fillBadStripWord(), fillBadWireWord(), gain(), gasGainCorrection(), initializeEvent(), isInBadChamber(), noiseMatrix(), pedestal(), and pedestalSigma().

indexerToken_

edm::ESGetToken<CSCIndexerBase, CSCIndexerRecord> CSCConditions::indexerToken_

private

Definition at line 180 of file CSCConditions.h.

Referenced by CSCConditions(), and initializeEvent().

mapper_

edm::ESHandle<CSCChannelMapperBase> CSCConditions::mapper_

private

Definition at line 167 of file CSCConditions.h.

Referenced by anodeBXoffset(), chamberTimingCorrection(), channelFromStrip(), chipCorrection(), crossTalk(), crosstalkIntercept(), crosstalkSlope(), fillBadChannelWords(), gain(), gasGainCorrection(), initializeEvent(), isInBadChamber(), noiseMatrix(), pedestal(), pedestalSigma(), and rawStripChannel().

mapperToken_

edm::ESGetToken<CSCChannelMapperBase, CSCChannelMapperRecord> CSCConditions::mapperToken_

private

Definition at line 181 of file CSCConditions.h.

Referenced by CSCConditions(), and initializeEvent().

noiseMatrixToken_

edm::ESGetToken<CSCDBNoiseMatrix, CSCDBNoiseMatrixRcd> CSCConditions::noiseMatrixToken_

private

Definition at line 173 of file CSCConditions.h.

Referenced by CSCConditions(), and initializeEvent().

pedestalsToken_

edm::ESGetToken<CSCDBPedestals, CSCDBPedestalsRcd> CSCConditions::pedestalsToken_

private

Definition at line 172 of file CSCConditions.h.

Referenced by CSCConditions(), and initializeEvent().

readBadChambers_

bool CSCConditions::readBadChambers_

private

Definition at line 187 of file CSCConditions.h.

Referenced by CSCConditions(), and readBadChambers().

readBadChannels_

bool CSCConditions::readBadChannels_

private

Definition at line 185 of file CSCConditions.h.

Referenced by CSCConditions(), and readBadChannels().

theAverageGain

float CSCConditions::theAverageGain

mutableprivate

Definition at line 199 of file CSCConditions.h.

Referenced by averageGain(), and initializeEvent().

theBadChambers

edm::ESHandle<CSCBadChambers> CSCConditions::theBadChambers

private

Definition at line 159 of file CSCConditions.h.

Referenced by initializeEvent(), and isInBadChamber().

theBadStrips

edm::ESHandle<CSCBadStrips> CSCConditions::theBadStrips

private

Definition at line 157 of file CSCConditions.h.

Referenced by fillBadStripWord(), and initializeEvent().

theBadWires

edm::ESHandle<CSCBadWires> CSCConditions::theBadWires

private

Definition at line 158 of file CSCConditions.h.

Referenced by fillBadWireWord(), and initializeEvent().

theChamberTimingCorrections

edm::ESHandle<CSCChamberTimeCorrections> CSCConditions::theChamberTimingCorrections

private

Definition at line 161 of file CSCConditions.h.

Referenced by anodeBXoffset(), chamberTimingCorrection(), and initializeEvent().

theChipCorrections

edm::ESHandle<CSCDBChipSpeedCorrection> CSCConditions::theChipCorrections

private

Definition at line 160 of file CSCConditions.h.

Referenced by chipCorrection(), and initializeEvent().

theCrosstalk

edm::ESHandle<CSCDBCrosstalk> CSCConditions::theCrosstalk

private

Definition at line 154 of file CSCConditions.h.

Referenced by crossTalk(), crosstalkIntercept(), crosstalkSlope(), and initializeEvent().

theGains

edm::ESHandle<CSCDBGains> CSCConditions::theGains

private

Definition at line 153 of file CSCConditions.h.

Referenced by averageGain(), gain(), and initializeEvent().

theGasGainCorrections

edm::ESHandle<CSCDBGasGainCorrection> CSCConditions::theGasGainCorrections

private

Definition at line 162 of file CSCConditions.h.

Referenced by gasGainCorrection(), and initializeEvent().

theNoiseMatrix

edm::ESHandle<CSCDBNoiseMatrix> CSCConditions::theNoiseMatrix

private

Definition at line 156 of file CSCConditions.h.

Referenced by initializeEvent(), noiseMatrix(), and noiseMatrixElements().

thePedestals

edm::ESHandle<CSCDBPedestals> CSCConditions::thePedestals

private

Definition at line 155 of file CSCConditions.h.

Referenced by initializeEvent(), pedestal(), and pedestalSigma().

useGasGainCorrections_

bool CSCConditions::useGasGainCorrections_

private

Definition at line 191 of file CSCConditions.h.

Referenced by CSCConditions(), and useGasGainCorrections().

useTimingCorrections_

bool CSCConditions::useTimingCorrections_

private

Definition at line 189 of file CSCConditions.h.

Referenced by CSCConditions(), and useTimingCorrections().