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)
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
std::bitset< 112 >	badStripWord_
std::bitset< 112 >	badWireWord_
edm::ESWatcher< CSCDBGainsRcd >	gainsWatcher_
CSCDetId	idOfBadChannelWords_
edm::ESHandle< CSCIndexerBase >	indexer_
edm::ESHandle< CSCChannelMapperBase >	mapper_
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 48 of file CSCConditions.h.

Member Enumeration Documentation

elayers

enum CSCConditions::elayers

private

Enumerator
MAX_LAYERS

Definition at line 184 of file CSCConditions.h.

{ MAX_LAYERS = 3240 };

Constructor & Destructor Documentation

CSCConditions()

CSCConditions::CSCConditions ( const edm::ParameterSet &  ps )

explicit

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

References edm::ParameterSet::getParameter(), readBadChambers_, readBadChannels_, useGasGainCorrections_, and useTimingCorrections_.

~CSCConditions()

CSCConditions::~CSCConditions

(

)

Definition at line 64 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 337 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 352 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 92 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 95 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 325 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 402 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 314 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 302 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 253 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 263 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 119 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 143 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 182 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 229 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 59 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 390 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 98 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 66 of file CSCConditions.cc.

                                                           {
  // Algorithms
  es.get<CSCIndexerRecord>().get(indexer_);
  es.get<CSCChannelMapperRecord>().get(mapper_);
 
  // Strip gains
  es.get<CSCDBGainsRcd>().get(theGains);
  // Strip X-talk
  es.get<CSCDBCrosstalkRcd>().get(theCrosstalk);
  // Strip pedestals
  es.get<CSCDBPedestalsRcd>().get(thePedestals);
  // Strip autocorrelation noise matrix
  es.get<CSCDBNoiseMatrixRcd>().get(theNoiseMatrix);
 
  if (useTimingCorrections()) {
    // Buckeye chip speeds
    es.get<CSCDBChipSpeedCorrectionRcd>().get(theChipCorrections);
    // Cable lengths from chambers to peripheral crate and additional chamber
    // level timing correction
    es.get<CSCChamberTimeCorrectionsRcd>().get(theChamberTimingCorrections);
  }
 
  if (readBadChannels()) {
    // Bad strip channels
    es.get<CSCBadStripsRcd>().get(theBadStrips);
    // Bad wiregroup channels
    es.get<CSCBadWiresRcd>().get(theBadWires);
 
    //@@    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
    es.get<CSCBadChambersRcd>().get(theBadChambers);
  }
 
  if (useGasGainCorrections()) {
    es.get<CSCDBGasGainCorrectionRcd>().get(theGasGainCorrections);
  }
 
  //  print();
}

References edm::ESWatcher< T >::check(), gainsWatcher_, edm::EventSetup::get(), get, indexer_, mapper_, 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 215 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 273 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 285 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 237 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 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_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 410 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 406 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 109 of file CSCConditions.h.

{ return readBadChambers_; }

References readBadChambers_.

Referenced by initializeEvent(), and isInBadChamber().

readBadChannels()

bool CSCConditions::readBadChannels ( ) const

inline

did we request reading bad channel info from db?

Definition at line 106 of file CSCConditions.h.

{ return readBadChannels_; }

References readBadChannels_.

Referenced by 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 139 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 127 of file CSCConditions.h.

{ return useGasGainCorrections_; }

References useGasGainCorrections_.

Referenced by gasGainCorrection(), and initializeEvent().

useTimingCorrections()

bool CSCConditions::useTimingCorrections ( ) const

inline

did we request reading timing correction info from db?

Definition at line 112 of file CSCConditions.h.

{ return useTimingCorrections_; }

References useTimingCorrections_.

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

Member Data Documentation

badStripWord_

std::bitset<112> CSCConditions::badStripWord_

private

Definition at line 172 of file CSCConditions.h.

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

badWireWord_

std::bitset<112> CSCConditions::badWireWord_

private

Definition at line 173 of file CSCConditions.h.

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

gainsWatcher_

edm::ESWatcher<CSCDBGainsRcd> CSCConditions::gainsWatcher_

private

Definition at line 178 of file CSCConditions.h.

Referenced by initializeEvent().

idOfBadChannelWords_

CSCDetId CSCConditions::idOfBadChannelWords_

private

Definition at line 171 of file CSCConditions.h.

Referenced by idOfBadChannelWords(), and setIdOfBadChannelWords().

indexer_

edm::ESHandle<CSCIndexerBase> CSCConditions::indexer_

private

Definition at line 156 of file CSCConditions.h.

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

mapper_

edm::ESHandle<CSCChannelMapperBase> CSCConditions::mapper_

private

Definition at line 157 of file CSCConditions.h.

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

readBadChambers_

bool CSCConditions::readBadChambers_

private

Definition at line 163 of file CSCConditions.h.

Referenced by CSCConditions(), and readBadChambers().

readBadChannels_

bool CSCConditions::readBadChannels_

private

Definition at line 161 of file CSCConditions.h.

Referenced by CSCConditions(), and readBadChannels().

theAverageGain

float CSCConditions::theAverageGain

mutableprivate

Definition at line 175 of file CSCConditions.h.

Referenced by averageGain(), and initializeEvent().

theBadChambers

edm::ESHandle<CSCBadChambers> CSCConditions::theBadChambers

private

Definition at line 149 of file CSCConditions.h.

Referenced by initializeEvent(), and isInBadChamber().

theBadStrips

edm::ESHandle<CSCBadStrips> CSCConditions::theBadStrips

private

Definition at line 147 of file CSCConditions.h.

Referenced by fillBadStripWord(), and initializeEvent().

theBadWires

edm::ESHandle<CSCBadWires> CSCConditions::theBadWires

private

Definition at line 148 of file CSCConditions.h.

Referenced by fillBadWireWord(), and initializeEvent().

theChamberTimingCorrections

edm::ESHandle<CSCChamberTimeCorrections> CSCConditions::theChamberTimingCorrections

private

Definition at line 151 of file CSCConditions.h.

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

theChipCorrections

edm::ESHandle<CSCDBChipSpeedCorrection> CSCConditions::theChipCorrections

private

Definition at line 150 of file CSCConditions.h.

Referenced by chipCorrection(), and initializeEvent().

theCrosstalk

edm::ESHandle<CSCDBCrosstalk> CSCConditions::theCrosstalk

private

Definition at line 144 of file CSCConditions.h.

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

theGains

edm::ESHandle<CSCDBGains> CSCConditions::theGains

private

Definition at line 143 of file CSCConditions.h.

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

theGasGainCorrections

edm::ESHandle<CSCDBGasGainCorrection> CSCConditions::theGasGainCorrections

private

Definition at line 152 of file CSCConditions.h.

Referenced by gasGainCorrection(), and initializeEvent().

theNoiseMatrix

edm::ESHandle<CSCDBNoiseMatrix> CSCConditions::theNoiseMatrix

private

Definition at line 146 of file CSCConditions.h.

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

thePedestals

edm::ESHandle<CSCDBPedestals> CSCConditions::thePedestals

private

Definition at line 145 of file CSCConditions.h.

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

useGasGainCorrections_

bool CSCConditions::useGasGainCorrections_

private

Definition at line 167 of file CSCConditions.h.

Referenced by CSCConditions(), and useGasGainCorrections().

useTimingCorrections_

bool CSCConditions::useTimingCorrections_

private

Definition at line 165 of file CSCConditions.h.

Referenced by CSCConditions(), and useTimingCorrections().