CMS 3D CMS Logo
Public Member Functions | Private Types | Private Attributes

CSCConditions Class Reference

#include <CSCConditions.h>

List of all members.

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).
const std::bitset< 80 > & badStripWord (const CSCDetId &id) const
 return bad channel words per CSCLayer - 1 bit per channel
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
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
void fillBadWireWords ()
float gain (const CSCDetId &detId, int channel) const
 channels count from 1
float gainSigma (const CSCDetId &detId, int channel) const
 total calibration precision
float gasGainCorrection (const CSCDetId &detId, int strip, int wire) const
 gas gain correction as a function of detId (w/layer), strip, and wire
void initializeEvent (const edm::EventSetup &es)
 fetch the maps from the database
bool isInBadChamber (const CSCDetId &id) const
 Is the gven chamber flagged as bad?
const CSCDBNoiseMatrix::Item & noiseMatrix (const CSCDetId &detId, int channel) const
 return raw noise matrix (unscaled short int elements)
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)
float pedestal (const CSCDetId &detId, int channel) const
 in ADC counts
float pedestalSigma (const CSCDetId &detId, int channel) const
void print () const
bool readBadChambers () const
 did we request reading bad chamber info from db?
bool readBadChannels () const
 did we request reading bad channel info from db?
bool useGasGainCorrections () const
 did we request reading gas gain correction info from db?
bool useTimingCorrections () const
 did we request reading timing correction info from db?
 ~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, dqm_diff::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, dqm_diff::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(), and CSCRecoConditions::gain().

{
  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 [mutable, private]

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

Generated for CMSSW Reference Manual by doxygen 1.7.3