CSCConditions Class Reference

#include <CSCConditions.h>

Public Member Functions
float	anodeBXoffset (const CSCDetId &detId) const
float	averageGain () const
	average gain over entire CSC system (logically const although must be cached here). More...
const std::bitset< 80 > &	badStripWord (const CSCDetId &id) const
	return bad channel words per CSCLayer - 1 bit per channel More...
const std::bitset< 112 > &	badWireWord (const CSCDetId &id) const
float	chamberTimingCorrection (const CSCDetId &detId) const
float	chipCorrection (const CSCDetId &detId, int channel) const
void	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 More...
float	crosstalkIntercept (const CSCDetId &detId, int channel, bool leftRight) const
float	crosstalkSlope (const CSCDetId &detId, int channel, bool leftRight) const
	CSCConditions (const edm::ParameterSet &ps)
void	fillBadStripWords ()
	fill bad channel words More...
void	fillBadWireWords ()
float	gain (const CSCDetId &detId, int channel) const
	channels count from 1 More...
float	gainSigma (const CSCDetId &detId, int channel) const
	total calibration precision More...
float	gasGainCorrection (const CSCDetId &detId, int strip, int wire) const
	gas gain correction as a function of detId (w/layer), strip, and wire More...
void	initializeEvent (const edm::EventSetup &es)
	fetch the maps from the database 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
	return raw noise matrix (unscaled short int elements) More...
void	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) More...
float	pedestal (const CSCDetId &detId, int channel) const
	in ADC counts More...
float	pedestalSigma (const CSCDetId &detId, int channel) const
void	print () 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 Attributes
std::vector< std::bitset< 80 > >	badStripWords
std::vector< std::bitset< 112 > >	badWireWords
edm::ESWatcher< CSCDBGainsRcd >	gainsWatcher_
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

Definition at line 35 of file CSCConditions.h.

Member Enumeration Documentation

enum CSCConditions::elayers

private

Enumerator
MAX_LAYERS

Definition at line 135 of file CSCConditions.h.

{ MAX_LAYERS = 3240 };

Constructor & Destructor Documentation

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

explicit

Definition at line 22 of file CSCConditions.cc.

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

: theGains(),
  theCrosstalk(),
  thePedestals(),
  theNoiseMatrix(),
  theBadStrips(),
  theBadWires(),
  theBadChambers(),
  theChipCorrections(),
  theChamberTimingCorrections(),
  theGasGainCorrections(),
  readBadChannels_(false), readBadChambers_(false),useTimingCorrections_(false),useGasGainCorrections_(false),
  theAverageGain( -1.0 )
{
  readBadChannels_ = ps.getParameter<bool>("readBadChannels");
  readBadChambers_ = ps.getParameter<bool>("readBadChambers");
  useTimingCorrections_ = ps.getParameter<bool>("CSCUseTimingCorrections");
  useGasGainCorrections_ = ps.getParameter<bool>("CSCUseGasGainCorrections");
  // set size to hold all layers, using enum defined in .h
  badStripWords.resize( MAX_LAYERS, 0 );
  badWireWords.resize( MAX_LAYERS, 0 );
}

CSCConditions::~CSCConditions

(

)

Definition at line 46 of file CSCConditions.cc.

{
}

Member Function Documentation

float CSCConditions::anodeBXoffset

(

const CSCDetId &

detId

)

const

Definition at line 310 of file CSCConditions.cc.

References edm::ESHandleBase::isValid(), theChamberTimingCorrections, and useTimingCorrections().

Referenced by CSCRecoConditions::anodeBXoffset().

{
  if ( useTimingCorrections() ){
    assert(theChamberTimingCorrections.isValid());
    return float ( theChamberTimingCorrections->item(detId).anode_bx_offset*1./theChamberTimingCorrections->factor_precision);
  }
  else
    return 0;
}

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 334 of file CSCConditions.cc.

References theAverageGain, and theGains.

Referenced by CSCRecoConditions::averageGain().

                                       {

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

const std::bitset< 80 > & CSCConditions::badStripWord

(

const CSCDetId &

id

)

const

return bad channel words per CSCLayer - 1 bit per channel

Definition at line 320 of file CSCConditions.cc.

References badStripWords, and CSCIndexer::layerIndex().

Referenced by CSCRecoConditions::badStrip().

                                                                           {
  CSCIndexer indexer;
  return badStripWords[indexer.layerIndex(id) - 1];
}

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

(

const CSCDetId &

id

)

const

Definition at line 325 of file CSCConditions.cc.

References badWireWords, and CSCIndexer::layerIndex().

Referenced by CSCRecoConditions::badWireWord().

                                                                           {
  CSCIndexer indexer;
  return badWireWords[indexer.layerIndex(id) - 1]; 
}

float CSCConditions::chamberTimingCorrection

(

const CSCDetId &

detId

)

const

Definition at line 298 of file CSCConditions.cc.

References edm::ESHandleBase::isValid(), theChamberTimingCorrections, and useTimingCorrections().

Referenced by CSCRecoConditions::chamberTimingCorrection().

{
  if ( useTimingCorrections() ){
    assert(theChamberTimingCorrections.isValid());
    return float ( theChamberTimingCorrections->item(detId).cfeb_tmb_skew_delay*1./theChamberTimingCorrections->factor_precision
           + theChamberTimingCorrections->item(detId).cfeb_timing_corr*1./theChamberTimingCorrections->factor_precision
           + (theChamberTimingCorrections->item(detId).cfeb_cable_delay*25.)
);
  }
  else
    return 0;
}

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

Definition at line 286 of file CSCConditions.cc.

References CSCIndexer::chipIndex(), edm::ESHandleBase::isValid(), theChipCorrections, and useTimingCorrections().

Referenced by CSCRecoConditions::chipCorrection().

{
  if ( useTimingCorrections() ){
    assert(theChipCorrections.isValid());
    CSCIndexer indexer;
    int chip = indexer.chipIndex(stripChannel); //Converts 1-80(64) in a layer to 1-5(4), expects ME1/1a to be channel 65-80
    //printf("CSCCondition  e:%d s:%d r:%d c:%d l:%d strip:%d chip: %d\n",detId.endcap(),detId.station(), detId.ring(),detId.chamber(),detId.layer(),stripChannel,chip);
    return float ( theChipCorrections->item(detId,chip).speedCorr )/theChipCorrections->factor_speedCorr;
  }
  else
    return 0;
}

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 277 of file CSCConditions.cc.

References edm::ESHandleBase::isValid(), and theCrosstalk.

Referenced by CSCRecoConditions::crossTalk().

                                                                                           {
  assert(theCrosstalk.isValid());
  const CSCDBCrosstalk::Item & item = theCrosstalk->item(id, channel);
  ct[0] = float ( item.xtalk_slope_left )/theCrosstalk->factor_slope;
  ct[1] = float ( item.xtalk_intercept_left )/theCrosstalk->factor_intercept;
  ct[2] = float ( item.xtalk_slope_right )/theCrosstalk->factor_slope;
  ct[3] = float ( item.xtalk_intercept_right )/theCrosstalk->factor_intercept;
}

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

Definition at line 233 of file CSCConditions.cc.

References edm::ESHandleBase::isValid(), and theCrosstalk.

Referenced by CSCDbStripConditions::crosstalk().

{
  assert(theCrosstalk.isValid());
  const CSCDBCrosstalk::Item & item = theCrosstalk->item(detId, channel);

  // resistive fraction is at the peak, where t=0
  return leftRight ? float ( item.xtalk_intercept_right )/theCrosstalk->factor_intercept 
                   : float ( item.xtalk_intercept_left )/theCrosstalk->factor_intercept ;
}

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

Definition at line 244 of file CSCConditions.cc.

References edm::ESHandleBase::isValid(), and theCrosstalk.

Referenced by CSCDbStripConditions::crosstalk().

{
  assert(theCrosstalk.isValid());
  const CSCDBCrosstalk::Item & item = theCrosstalk->item(detId, channel);

  // resistive fraction is at the peak, where t=0
  return leftRight ? float ( item.xtalk_slope_right )/theCrosstalk->factor_slope
                   : float ( item.xtalk_slope_left )/theCrosstalk->factor_slope ;
}

void CSCConditions::fillBadStripWords

(

)

fill bad channel words

Definition at line 100 of file CSCConditions.cc.

References badStripWords, CSCIndexer::detIdFromChamberIndex(), Reference_intrackfit_cff::endcap, i, j, CSCIndexer::layerIndex(), MAX_LAYERS, readBadChannels(), relativeConstraints::ring, errorMatrix2Lands_multiChannel::start, relativeConstraints::station, and theBadStrips.

Referenced by initializeEvent().

                                     {
  // reset existing values
  badStripWords.assign( MAX_LAYERS, 0 );
  if ( readBadChannels() ) {
    // unpack what we've read from theBadStrips

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

    CSCIndexer indexer;

    for ( size_t i=0; i<theBadStrips->chambers.size(); ++i ) { // loop over bad chambers
      int indexc = theBadStrips->chambers[i].chamber_index;
      int start =  theBadStrips->chambers[i].pointer;  // where this chamber's bad channels start in vector<BadChannel>
      int nbad  =  theBadStrips->chambers[i].bad_channels;

      CSCDetId id = indexer.detIdFromChamberIndex( indexc ); // We need this to build layer index (1-2808)

      for ( int j=start-1; j<start-1+nbad; ++j ) { // bad channels in this chamber
        short lay  = theBadStrips->channels[j].layer;    // value 1-6
        short chan = theBadStrips->channels[j].channel;  // value 1-80
    //    short f1 = theBadStrips->channels[j].flag1;
    //    short f2 = theBadStrips->channels[j].flag2;
    //    short f3 = theBadStrips->channels[j].flag3;
        int indexl = indexer.layerIndex( id.endcap(), id.station(), id.ring(), id.chamber(), lay );
        badStripWords[indexl-1].set( chan-1, 1 ); // set bit 0-79 in 80-bit bitset representing this layer
      } // j
    } // i

  } 
}

void CSCConditions::fillBadWireWords

(

)

Definition at line 134 of file CSCConditions.cc.

References badWireWords, CSCIndexer::detIdFromChamberIndex(), Reference_intrackfit_cff::endcap, i, j, CSCIndexer::layerIndex(), MAX_LAYERS, readBadChannels(), relativeConstraints::ring, errorMatrix2Lands_multiChannel::start, relativeConstraints::station, and theBadWires.

Referenced by initializeEvent().

                                    {
  // reset existing values
  badWireWords.assign( MAX_LAYERS, 0 );
  if ( readBadChannels() ) {
    // unpack what we've read from theBadWires
    CSCIndexer indexer;

    for ( size_t i=0; i<theBadWires->chambers.size(); ++i ) { // loop over bad chambers
      int indexc = theBadWires->chambers[i].chamber_index;
      int start =  theBadWires->chambers[i].pointer;  // where this chamber's bad channels start in vector<BadChannel>
      int nbad  =  theBadWires->chambers[i].bad_channels;

      CSCDetId id = indexer.detIdFromChamberIndex( indexc ); // We need this to build layer index (1-2808)

      for ( int j=start-1; j<start-1+nbad; ++j ) { // bad channels in this chamber
        short lay  = theBadWires->channels[j].layer;    // value 1-6
        short chan = theBadWires->channels[j].channel;  // value 1-80
    //    short f1 = theBadWires->channels[j].flag1;
    //    short f2 = theBadWires->channels[j].flag2;
    //    short f3 = theBadWires->channels[j].flag3;
        int indexl = indexer.layerIndex( id.endcap(), id.station(), id.ring(), id.chamber(), lay );
        badWireWords[indexl-1].set( chan-1, 1 ); // set bit 0-111 in 112-bit bitset representing this layer
      } // j
    } // i

  } 
}

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

channels count from 1

Definition at line 212 of file CSCConditions.cc.

References edm::ESHandleBase::isValid(), and theGains.

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

{
  assert(theGains.isValid());
  return float( theGains->item(detId, channel).gain_slope )/theGains->factor_gain;
}

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

inline

total calibration precision

Definition at line 47 of file CSCConditions.h.

{return 0.005;}

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

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

Definition at line 371 of file CSCConditions.cc.

References edm::ESHandleBase::isValid(), theGasGainCorrections, and useGasGainCorrections().

Referenced by CSCRecoConditions::gasGainCorrection().

{
  if ( useGasGainCorrections() ){
    assert(theGasGainCorrections.isValid());
    //printf("CSCCondition  e:%d s:%d r:%d c:%d l:%d strip:%d wire:%d\n",detId.endcap(),detId.station(),detId.ring(),detId.chamber(),detId.layer(),strip,wiregroup);
    return float ( theGasGainCorrections->item(detId,strip,wiregroup).gainCorr );

  } else {
    return 1.;
  }
}

void CSCConditions::initializeEvent

(

const edm::EventSetup &

es

)

fetch the maps from the database

Definition at line 50 of file CSCConditions.cc.

References edm::ESWatcher< T >::check(), fillBadStripWords(), fillBadWireWords(), gainsWatcher_, edm::EventSetup::get(), readBadChambers(), readBadChannels(), theAverageGain, theBadChambers, theBadStrips, theBadWires, theChamberTimingCorrections, theChipCorrections, theCrosstalk, theGains, theGasGainCorrections, theNoiseMatrix, thePedestals, useGasGainCorrections(), and useTimingCorrections().

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

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

bool CSCConditions::isInBadChamber

(

const CSCDetId &

id

)

const

Is the gven chamber flagged as bad?

Definition at line 162 of file CSCConditions.cc.

References readBadChambers(), and theBadChambers.

Referenced by CSCDbStripConditions::isInBadChamber().

                                                             {
  if ( readBadChambers() )  return theBadChambers->isInBadChamber( id );
  else return false;
}

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

return raw noise matrix (unscaled short int elements)

Definition at line 254 of file CSCConditions.cc.

References edm::ESHandleBase::isValid(), and theNoiseMatrix.

Referenced by noiseMatrixElements().

{
  assert(theNoiseMatrix.isValid());
  return theNoiseMatrix->item(detId, channel);
}

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 260 of file CSCConditions.cc.

References noiseMatrix(), and theNoiseMatrix.

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

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

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

in ADC counts

Definition at line 219 of file CSCConditions.cc.

References edm::ESHandleBase::isValid(), and thePedestals.

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

{
  assert(thePedestals.isValid());
  return float ( thePedestals->item(detId, channel).ped )/thePedestals->factor_ped;
}

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

Definition at line 226 of file CSCConditions.cc.

References edm::ESHandleBase::isValid(), and thePedestals.

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

{
  assert(thePedestals.isValid());
  return float ( thePedestals->item(detId, channel).rms )/thePedestals->factor_rms;
}

void CSCConditions::print

(

void

)

const

Definition at line 167 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;
  }
*/
}

bool CSCConditions::readBadChambers ( ) const

inline

did we request reading bad chamber info from db?

Definition at line 87 of file CSCConditions.h.

References readBadChambers_.

Referenced by initializeEvent(), and isInBadChamber().

{ return readBadChambers_; }

bool CSCConditions::readBadChannels ( ) const

inline

did we request reading bad channel info from db?

Definition at line 84 of file CSCConditions.h.

References readBadChannels_.

Referenced by fillBadStripWords(), fillBadWireWords(), and initializeEvent().

{ return readBadChannels_; }

bool CSCConditions::useGasGainCorrections ( ) const

inline

did we request reading gas gain correction info from db?

Definition at line 103 of file CSCConditions.h.

References useGasGainCorrections_.

Referenced by gasGainCorrection(), and initializeEvent().

{ return useGasGainCorrections_; }

bool CSCConditions::useTimingCorrections ( ) const

inline

did we request reading timing correction info from db?

Definition at line 90 of file CSCConditions.h.

References useTimingCorrections_.

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

{ return useTimingCorrections_; }

Member Data Documentation

std::vector< std::bitset<80> > CSCConditions::badStripWords

private

Definition at line 124 of file CSCConditions.h.

Referenced by badStripWord(), CSCConditions(), and fillBadStripWords().

std::vector< std::bitset<112> > CSCConditions::badWireWords

private

Definition at line 125 of file CSCConditions.h.

Referenced by badWireWord(), CSCConditions(), and fillBadWireWords().

edm::ESWatcher<CSCDBGainsRcd> CSCConditions::gainsWatcher_

private

Definition at line 129 of file CSCConditions.h.

Referenced by initializeEvent().

bool CSCConditions::readBadChambers_

private

Definition at line 119 of file CSCConditions.h.

Referenced by CSCConditions(), and readBadChambers().

bool CSCConditions::readBadChannels_

private

Definition at line 118 of file CSCConditions.h.

Referenced by CSCConditions(), and readBadChannels().

float CSCConditions::theAverageGain

mutableprivate

Definition at line 127 of file CSCConditions.h.

Referenced by averageGain(), and initializeEvent().

edm::ESHandle<CSCBadChambers> CSCConditions::theBadChambers

private

Definition at line 113 of file CSCConditions.h.

Referenced by initializeEvent(), and isInBadChamber().

edm::ESHandle<CSCBadStrips> CSCConditions::theBadStrips

private

Definition at line 111 of file CSCConditions.h.

Referenced by fillBadStripWords(), and initializeEvent().

edm::ESHandle<CSCBadWires> CSCConditions::theBadWires

private

Definition at line 112 of file CSCConditions.h.

Referenced by fillBadWireWords(), and initializeEvent().

edm::ESHandle<CSCChamberTimeCorrections> CSCConditions::theChamberTimingCorrections

private

Definition at line 115 of file CSCConditions.h.

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

edm::ESHandle<CSCDBChipSpeedCorrection> CSCConditions::theChipCorrections

private

Definition at line 114 of file CSCConditions.h.

Referenced by chipCorrection(), and initializeEvent().

edm::ESHandle<CSCDBCrosstalk> CSCConditions::theCrosstalk

private

Definition at line 108 of file CSCConditions.h.

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

edm::ESHandle<CSCDBGains> CSCConditions::theGains

private

Definition at line 107 of file CSCConditions.h.

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

edm::ESHandle<CSCDBGasGainCorrection> CSCConditions::theGasGainCorrections

private

Definition at line 116 of file CSCConditions.h.

Referenced by gasGainCorrection(), and initializeEvent().

edm::ESHandle<CSCDBNoiseMatrix> CSCConditions::theNoiseMatrix

private

Definition at line 110 of file CSCConditions.h.

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

edm::ESHandle<CSCDBPedestals> CSCConditions::thePedestals

private

Definition at line 109 of file CSCConditions.h.

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

bool CSCConditions::useGasGainCorrections_

private

Definition at line 121 of file CSCConditions.h.

Referenced by CSCConditions(), and useGasGainCorrections().

bool CSCConditions::useTimingCorrections_

private

Definition at line 120 of file CSCConditions.h.

Referenced by CSCConditions(), and useTimingCorrections().