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
	average gain over entire CSC system (logically const although must be cached here). More...
const std::bitset< 80 > &	badStripWord (const CSCDetId &id) const
	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
	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
	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
	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	fillBadStripWords ()
	fill bad channel words More...
void	fillBadWireWords ()
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
	gas gain correction as a function of detId (w/layer), strip, and wire channels 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
	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
	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 Attributes
std::vector< std::bitset< 80 > >	badStripWords
std::vector< std::bitset< 112 > >	badWireWords
edm::ESWatcher< CSCDBGainsRcd >	gainsWatcher_
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 46 of file CSCConditions.h.

Member Enumeration Documentation

enum CSCConditions::elayers

private

Enumerator
MAX_LAYERS

Definition at line 162 of file CSCConditions.h.

{ MAX_LAYERS = 3240 };

Constructor & Destructor Documentation

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

explicit

Definition at line 36 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(),
  indexer_(0), mapper_(0),
  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 55 of file CSCConditions.cc.

{}

Member Function Documentation

float CSCConditions::anodeBXoffset

(

const CSCDetId &

detId

)

const

anode bx offset in bx given detId of chamber

Definition at line 304 of file CSCConditions.cc.

References cmsHarvester::index, indexer_, edm::ESHandleBase::isValid(), mapper_, theChamberTimingCorrections, and useTimingCorrections().

Referenced by CSCRecoConditions::anodeBXoffset().

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

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

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

(

const CSCDetId &

id

)

const

bad channel words per CSCLayer - 1 bit per channel

Definition at line 316 of file CSCConditions.cc.

References badStripWords, indexer_, and mapper_.

Referenced by CSCRecoConditions::badStrip().

                                                                           {
  //@@ NOT YET THOUGHT THROUGH FOR UNGANGED ME11A

  CSCDetId idraw  = mapper_->rawCSCDetId( id );
  return badStripWords[indexer_->layerIndex(idraw) - 1];
}

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

(

const CSCDetId &

id

)

const

Definition at line 323 of file CSCConditions.cc.

References badWireWords, indexer_, and mapper_.

Referenced by CSCRecoConditions::badWireWord().

                                                                           {
  //@@ NEED TO THINK ABOUT THIS SINCE ME11A & ME11B SHARE A COMMON WIRE PLANE
  //@@ SHOULD WE JUST USE ME11B?

  CSCDetId idraw  = mapper_->rawCSCDetId( id );
  return badWireWords[indexer_->layerIndex(idraw) - 1];
}

float CSCConditions::chamberTimingCorrection

(

const CSCDetId &

detId

)

const

chamber timing correction in ns given detId of chamber

Definition at line 289 of file CSCConditions.cc.

References cmsHarvester::index, indexer_, edm::ESHandleBase::isValid(), mapper_, theChamberTimingCorrections, and useTimingCorrections().

Referenced by CSCRecoConditions::chamberTimingCorrection().

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

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

feedthrough for external access

Definition at line 385 of file CSCConditions.cc.

References mapper_.

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

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

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

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

Definition at line 276 of file CSCConditions.cc.

References cmsHarvester::index, indexer_, edm::ESHandleBase::isValid(), mapper_, theChipCorrections, and useTimingCorrections().

Referenced by CSCRecoConditions::chipCorrection().

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

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

References cmsHarvester::index, indexer_, edm::ESHandleBase::isValid(), mapper_, and theCrosstalk.

Referenced by CSCRecoConditions::crossTalk().

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

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

crosstalk intercept for left and right

Definition at line 212 of file CSCConditions.cc.

References cmsHarvester::index, indexer_, edm::ESHandleBase::isValid(), mapper_, and theCrosstalk.

Referenced by CSCDbStripConditions::crosstalk().

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

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

crosstalk slope for left and right

Definition at line 224 of file CSCConditions.cc.

References cmsHarvester::index, indexer_, edm::ESHandleBase::isValid(), mapper_, and theCrosstalk.

Referenced by CSCDbStripConditions::crosstalk().

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

void CSCConditions::fillBadStripWords

(

)

fill bad channel words

Definition at line 111 of file CSCConditions.cc.

References badStripWords, Reference_intrackfit_cff::endcap, i, indexer_, j, MAX_LAYERS, readBadChannels(), relativeConstraints::ring, dqm_diff::start, relativeConstraints::station, and theBadStrips.

Referenced by initializeEvent().

                                     {
  //@@ NOT YET THOUGHT THROUGH FOR UNGANGED ME11A

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

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

References badWireWords, Reference_intrackfit_cff::endcap, i, indexer_, j, 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

    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

gain per channel

Definition at line 183 of file CSCConditions.cc.

References cmsHarvester::index, indexer_, edm::ESHandleBase::isValid(), mapper_, and theGains.

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

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

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

inline

overall calibration precision

Definition at line 58 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 channels

Definition at line 372 of file CSCConditions.cc.

References cmsHarvester::index, indexer_, edm::ESHandleBase::isValid(), mapper_, theGasGainCorrections, and useGasGainCorrections().

Referenced by CSCRecoConditions::gasGainCorrection().

{
  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.;
  }
}

void CSCConditions::initializeEvent

(

const edm::EventSetup &

es

)

fetch database content via EventSetup

Definition at line 57 of file CSCConditions.cc.

References edm::ESWatcher< T >::check(), fillBadStripWords(), fillBadWireWords(), gainsWatcher_, edm::EventSetup::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().

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

bool CSCConditions::isInBadChamber

(

const CSCDetId &

id

)

const

Is the gven chamber flagged as bad?

Definition at line 172 of file CSCConditions.cc.

References cmsHarvester::index, indexer_, mapper_, readBadChambers(), and theBadChambers.

Referenced by CSCDbStripConditions::isInBadChamber().

                                                             {
  //@@ NOT YET THOUGHT THROUGH FOR UNGANGED ME11A

  if ( readBadChambers() )  {
    CSCDetId idraw  = mapper_->rawCSCDetId( id );
    int index = indexer_->chamberIndex( idraw );
    return theBadChambers->isInBadChamber( index );
  }
  else return false;
}

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

raw noise matrix (unscaled short int elements)

Definition at line 235 of file CSCConditions.cc.

References cmsHarvester::index, indexer_, edm::ESHandleBase::isValid(), mapper_, and theNoiseMatrix.

Referenced by noiseMatrixElements().

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

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 247 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, 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();
}

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

static ped in ADC counts

Definition at line 192 of file CSCConditions.cc.

References cmsHarvester::index, indexer_, edm::ESHandleBase::isValid(), mapper_, and thePedestals.

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

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

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

static ped rms in ADC counts

Definition at line 202 of file CSCConditions.cc.

References cmsHarvester::index, indexer_, edm::ESHandleBase::isValid(), mapper_, and thePedestals.

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

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

void CSCConditions::print

(

void

)

const

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

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

Definition at line 388 of file CSCConditions.cc.

References mapper_.

Referenced by CSCRecoConditions::badStrip().

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

bool CSCConditions::readBadChambers ( ) const

inline

did we request reading bad chamber info from db?

Definition at line 101 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 98 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 117 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 104 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 151 of file CSCConditions.h.

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

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

private

Definition at line 152 of file CSCConditions.h.

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

edm::ESWatcher<CSCDBGainsRcd> CSCConditions::gainsWatcher_

private

Definition at line 156 of file CSCConditions.h.

Referenced by initializeEvent().

edm::ESHandle<CSCIndexerBase> CSCConditions::indexer_

private

Definition at line 140 of file CSCConditions.h.

Referenced by anodeBXoffset(), badStripWord(), badWireWord(), chamberTimingCorrection(), chipCorrection(), crossTalk(), crosstalkIntercept(), crosstalkSlope(), fillBadStripWords(), fillBadWireWords(), gain(), gasGainCorrection(), initializeEvent(), isInBadChamber(), noiseMatrix(), pedestal(), and pedestalSigma().

edm::ESHandle<CSCChannelMapperBase> CSCConditions::mapper_

private

Definition at line 141 of file CSCConditions.h.

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

bool CSCConditions::readBadChambers_

private

Definition at line 146 of file CSCConditions.h.

Referenced by CSCConditions(), and readBadChambers().

bool CSCConditions::readBadChannels_

private

Definition at line 145 of file CSCConditions.h.

Referenced by CSCConditions(), and readBadChannels().

float CSCConditions::theAverageGain

mutableprivate

Definition at line 154 of file CSCConditions.h.

Referenced by averageGain(), and initializeEvent().

edm::ESHandle<CSCBadChambers> CSCConditions::theBadChambers

private

Definition at line 133 of file CSCConditions.h.

Referenced by initializeEvent(), and isInBadChamber().

edm::ESHandle<CSCBadStrips> CSCConditions::theBadStrips

private

Definition at line 131 of file CSCConditions.h.

Referenced by fillBadStripWords(), and initializeEvent().

edm::ESHandle<CSCBadWires> CSCConditions::theBadWires

private

Definition at line 132 of file CSCConditions.h.

Referenced by fillBadWireWords(), and initializeEvent().

edm::ESHandle<CSCChamberTimeCorrections> CSCConditions::theChamberTimingCorrections

private

Definition at line 135 of file CSCConditions.h.

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

edm::ESHandle<CSCDBChipSpeedCorrection> CSCConditions::theChipCorrections

private

Definition at line 134 of file CSCConditions.h.

Referenced by chipCorrection(), and initializeEvent().

edm::ESHandle<CSCDBCrosstalk> CSCConditions::theCrosstalk

private

Definition at line 128 of file CSCConditions.h.

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

edm::ESHandle<CSCDBGains> CSCConditions::theGains

private

Definition at line 127 of file CSCConditions.h.

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

edm::ESHandle<CSCDBGasGainCorrection> CSCConditions::theGasGainCorrections

private

Definition at line 136 of file CSCConditions.h.

Referenced by gasGainCorrection(), and initializeEvent().

edm::ESHandle<CSCDBNoiseMatrix> CSCConditions::theNoiseMatrix

private

Definition at line 130 of file CSCConditions.h.

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

edm::ESHandle<CSCDBPedestals> CSCConditions::thePedestals

private

Definition at line 129 of file CSCConditions.h.

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

bool CSCConditions::useGasGainCorrections_

private

Definition at line 148 of file CSCConditions.h.

Referenced by CSCConditions(), and useGasGainCorrections().

bool CSCConditions::useTimingCorrections_

private

Definition at line 147 of file CSCConditions.h.

Referenced by CSCConditions(), and useTimingCorrections().