NoisyChannel Class Reference

Check if any channels are noisy compared to neighboring ones. More...

#include <QTest.h>

Inheritance diagram for NoisyChannel:

Public Member Functions
	NoisyChannel (const std::string &name)
float	runTest (const MonitorElement *me) override
void	setNumNeighbors (unsigned n)
void	setTolerance (float percentage)
Public Member Functions inherited from SimpleTest
std::vector< DQMChannel >	getBadChannels () const override
	get vector of channels that failed test (not always relevant!) More...
void	setMinimumEntries (unsigned n)
	set minimum # of entries needed More...
	SimpleTest (const std::string &name, bool keepBadChannels=false)
Public Member Functions inherited from QCriterion
std::string	algoName () const
	get algorithm name More...
std::string	getMessage () const
	get message attached to test More...
std::string	getName () const
	get name of quality test More...
int	getStatus () const
	(class should be created by DQMStore class) More...
void	setErrorProb (float prob)
void	setWarningProb (float prob)
	set probability limit for warning and error (default: 90% and 50%) More...

Static Public Member Functions
static std::string	getAlgoName ()

Protected Member Functions
double	getAverage (int bin, const TH1 *h) const
double	getAverage2D (int binX, int binY, const TH2 *h) const
Protected Member Functions inherited from SimpleTest
void	setMessage () override
	set status & message after test has run More...
Protected Member Functions inherited from QCriterion
void	init ()
	initialize values More...
	QCriterion (std::string qtname)
float	runTest (const MonitorElement *me, QReport &qr, DQMNet::QValue &qv)
void	setAlgoName (std::string name)
	set algorithm name More...
void	setVerbose (int verbose)
	probability limits for warnings, errors More...
virtual	~QCriterion ()=default

Protected Attributes
unsigned	numNeighbors_
bool	rangeInitialized_
float	tolerance_
Protected Attributes inherited from SimpleTest
std::vector< DQMChannel >	badChannels_
bool	keepBadChannels_
unsigned	minEntries_
Protected Attributes inherited from QCriterion
std::string	algoName_
	name of quality test More...
float	errorProb_
std::string	message_
	quality test status More...
float	prob_
	name of algorithm More...
std::string	qtname_
int	status_
int	verbose_
float	warningProb_
	message attached to test More...

Detailed Description

Check if any channels are noisy compared to neighboring ones.

Definition at line 334 of file QTest.h.

Constructor & Destructor Documentation

NoisyChannel::NoisyChannel ( const std::string &  name )

inline

Definition at line 337 of file QTest.h.

References QCriterion::setAlgoName().

                                      : SimpleTest(name,true)
  {
    rangeInitialized_ = false;
    numNeighbors_ = 1;
    setAlgoName(getAlgoName());
  }

Member Function Documentation

static std::string NoisyChannel::getAlgoName ( )

inlinestatic

Definition at line 343 of file QTest.h.

References QCriterion::runTest().

Referenced by QTestConfigure::EnableNoisyChannelTest(), QTestConfigure::enableTests(), and QTestParameterNames::QTestParameterNames().

{ return "NoisyChannel"; }

double NoisyChannel::getAverage ( int  bin, const TH1 *  h  ) const

protected

get average for bin under consideration (see description of method setNumNeighbors)

Definition at line 987 of file QTest.cc.

References pat::helper::ParametrizationHelper::dimension(), and plotBeamSpotDB::first.

{
  int first = 1;                              // Do NOT use underflow bin
  int ncx  = h->GetXaxis()->GetNbins();       // Do NOT use overflow bin
  double sum = 0;
  int bin_start, bin_end;
  int add_right = 0;
  int add_left = 0;
  
  bin_start = bin - numNeighbors_;            // First bin in integral
  bin_end = bin + numNeighbors_;              // Last bin in integral

  if (bin_start < first) {                    // If neighbors take you outside of histogram range shift integral right
    add_right = first - bin_start;            // How much to shift remembering we are not using underflow
    bin_start = first;                        // Remember to reset the starting bin
    bin_end += add_right;
    if (bin_end > ncx) bin_end = ncx;         // If the test would be larger than histogram just sum histogram without overflow
  }
  
  if (bin_end > ncx) {                        // Now we make sure doesn't run off right edge of histogram
    add_left = bin_end - ncx;
    bin_end = ncx;
    bin_start -= add_left;
    if (bin_start < first) bin_start = first; // If the test would be larger than histogram just sum histogram without underflow
  }
  
  sum += h->Integral(bin_start, bin_end);
  sum -= h->GetBinContent(bin);

  int dimension = 2 * numNeighbors_ + 1;
  if ( dimension > h->GetNbinsX() ) dimension = h->GetNbinsX();

  return sum / (dimension - 1);
}

double NoisyChannel::getAverage2D ( int  binX, int  binY, const TH2 *  h  ) const

protected

Do NOT use underflow or overflow bins

Definition at line 1022 of file QTest.cc.

{
  int firstX = 1;
  int firstY = 1;
  double sum = 0;
  int ncx = h2->GetXaxis()->GetNbins();
  int ncy = h2->GetYaxis()->GetNbins();
  
  int neighborsX, neighborsY;                     // Convert unsigned input to int so we can use comparators
  neighborsX = numNeighbors_;
  neighborsY = numNeighbors_;
  int bin_startX, bin_endX;
  int add_rightX = 0;                             // Start shifts at 0
  int add_leftX = 0;
  int bin_startY, bin_endY;
  int add_topY = 0;
  int add_downY = 0;
  
  bin_startX = binX - neighborsX;                 // First bin in X
  bin_endX = binX + neighborsX;                   // Last bin in X
  
  if (bin_startX < firstX) {                      // If neighbors take you outside of histogram range shift integral right
    add_rightX = firstX - bin_startX;             // How much to shift remembering we are no using underflow
    bin_startX = firstX;                          // Remember to reset the starting bin
    bin_endX += add_rightX;
    if (bin_endX > ncx) bin_endX = ncx;
  }   
  
  if (bin_endX > ncx) {                           // Now we make sure doesn't run off right edge of histogram
    add_leftX = bin_endX - ncx;
    bin_endX = ncx;
    bin_startX -= add_leftX;
    if (bin_startX < firstX) bin_startX = firstX; // If the test would be larger than histogram just sum histogram without underflow
  }
  
  bin_startY = binY - neighborsY;             // First bin in Y
  bin_endY = binY + neighborsY;           // Last bin in Y
  
  if (bin_startY < firstY) {                      // If neighbors take you outside of histogram range shift integral up
    add_topY = firstY - bin_startY;               // How much to shift remembering we are no using underflow
    bin_startY = firstY;                          // Remember to reset the starting bin
    bin_endY += add_topY;
    if (bin_endY > ncy) bin_endY = ncy;
  }    
  
  if (bin_endY > ncy){                            // Now we make sure doesn't run off top edge of histogram
    add_downY = bin_endY - ncy;
    bin_endY = ncy;
    bin_startY -= add_downY;
    if (bin_startY < firstY) bin_startY = firstY; // If the test would be larger than histogram just sum histogram without underflow
  }
  
  sum += h2->Integral(bin_startX, bin_endX, bin_startY, bin_endY);
  sum -= h2->GetBinContent(binX, binY);

  int dimensionX = 2 * neighborsX + 1;
  int dimensionY = 2 * neighborsY + 1;
  
  if ( dimensionX > h2->GetNbinsX() ) dimensionX = h2->GetNbinsX();
  if ( dimensionY > h2->GetNbinsY() ) dimensionY = h2->GetNbinsY();
  
  return sum / (dimensionX * dimensionY - 1);     // Average is sum over the # of bins used

} // End getAverage2D

float NoisyChannel::runTest ( const MonitorElement *  me )

overridevirtual

Reimplemented from QCriterion.

Definition at line 859 of file QTest.cc.

References funct::abs(), stringResolutionProvider_cfi::bin, officialStyle::chan, relmon_rootfiles_spy::contents, gather_cfg::cout, MonitorElement::DQM_KIND_TH1D, MonitorElement::DQM_KIND_TH1F, MonitorElement::DQM_KIND_TH1S, MonitorElement::DQM_KIND_TH2D, MonitorElement::DQM_KIND_TH2F, MonitorElement::DQM_KIND_TH2S, cmsPerfPublish::fail(), plotBeamSpotDB::first, MonitorElement::getFullname(), MonitorElement::getRootObject(), MonitorElement::getTH1D(), MonitorElement::getTH1F(), MonitorElement::getTH1S(), MonitorElement::getTH2D(), MonitorElement::getTH2F(), MonitorElement::getTH2S(), MonitorElement::kind(), plotBeamSpotDB::last, and pileupCalc::nbins.

{
  badChannels_.clear();
  if (!me) 
    return -1;
  if (!me->getRootObject()) 
    return -1; 
  TH1* h=nullptr;//initialize histogram pointer
  TH2* h2=nullptr;//initialize histogram pointer  

  if (verbose_>1) 
    std::cout << "QTest:" << getAlgoName() << "::runTest called on " 
              << me-> getFullname() << "\n";

  int nbins=0;
  int nbinsX=0, nbinsY=0; 
  //-- TH1F
  if (me->kind()==MonitorElement::DQM_KIND_TH1F)
  { 
    nbins = me->getTH1F()->GetXaxis()->GetNbins(); 
    h  = me->getTH1F(); // access Test histo
  } 
  //-- TH1S
  else if (me->kind()==MonitorElement::DQM_KIND_TH1S)
  { 
    nbins = me->getTH1S()->GetXaxis()->GetNbins(); 
    h  = me->getTH1S(); // access Test histo
  } 
  //-- TH1D
  else if (me->kind()==MonitorElement::DQM_KIND_TH1D)
  { 
    nbins = me->getTH1D()->GetXaxis()->GetNbins(); 
    h  = me->getTH1D(); // access Test histo
  } 
  //-- TH2
  else if (me->kind()==MonitorElement::DQM_KIND_TH2F)
  {  
    nbinsX = me->getTH2F()->GetXaxis()->GetNbins(); 
    nbinsY = me->getTH2F()->GetYaxis()->GetNbins();
    h2  = me->getTH2F(); // access Test histo
  } 
  //-- TH2
  else if (me->kind()==MonitorElement::DQM_KIND_TH2S)
  { 
    nbinsX = me->getTH2S()->GetXaxis()->GetNbins();
    nbinsY = me->getTH2S()->GetYaxis()->GetNbins();
    h2  = me->getTH2S(); // access Test histo
  } 
  //-- TH2
  else if (me->kind()==MonitorElement::DQM_KIND_TH2D)
  { 
    nbinsX = me->getTH2F()->GetXaxis()->GetNbins();
    nbinsY = me->getTH2F()->GetYaxis()->GetNbins();
    h2  = me->getTH2D(); // access Test histo
  } 
  else 
  {  
    if (verbose_>0) 
      std::cout << "QTest:NoisyChannel"
        << " ME " << me->getFullname() 
        << " does not contain TH1F/TH1S/TH1D or TH2F/TH2S/TH2D, exiting\n"; 
    return -1;
  }

  //--  QUALITY TEST itself 

  // do NOT use underflow bin
  int first = 1;
  // do NOT use overflow bin
  int last  = nbins;
  int lastX  = nbinsX, lastY  = nbinsY;
  // bins outside Y-range
  int fail = 0;
  int bin;
  int binX, binY;
  if (h != nullptr) {
  if ( !rangeInitialized_ || !h->GetXaxis() ){
    return 1; // all channels are accepted if tolerance has not been set 
  }
    for (bin = first; bin <= last; ++bin)
    {
      double contents = h->GetBinContent(bin);
      double average = getAverage(bin, h);
      bool failure = false;
      if (average != 0)
         failure = (((contents-average)/std::abs(average)) > tolerance_);

      if (failure)
      {
        ++fail;
        DQMChannel chan(bin, 0, 0, contents, h->GetBinError(bin));
        badChannels_.push_back(chan);
      }
    }

    // return fraction of bins that passed test
    return 1.*(nbins - fail)/nbins;
    }
    else if (h2 !=nullptr ) { 
    for (binY = first; binY <= lastY; ++binY) {
      for (binX = first; binX <= lastX; ++binX) {
        double contents = h2->GetBinContent(binX, binY);
        double average = getAverage2D(binX, binY, h2);
        bool failure = false;
        if (average != 0)
           failure = (((contents-average)/std::abs(average)) > tolerance_);
        if (failure)
        {
          ++fail;
          DQMChannel chan(binX, 0, 0, contents, h2->GetBinError(binX));
          badChannels_.push_back(chan);
        }
      }//end x loop
    }//end y loop
    // return fraction of bins that passed test
    return 1.*((nbinsX * nbinsY) - fail)/(nbinsX * nbinsY);
  }//end nullptr conditional
  else
  {
    if (verbose_>0)
      std::cout << "QTest:NoisyChannel"
                << " TH1/TH2F are NULL, exiting\n";
    return -1;
  }
}

void NoisyChannel::setNumNeighbors ( unsigned  n )

inline

set # of neighboring channels for calculating average to be used for comparison with channel under consideration; use 1 for considering bin+1 and bin-1 (default), use 2 for considering bin+1,bin-1, bin+2,bin-2, etc; Will use rollover when bin+i or bin-i is beyond histogram limits (e.g. for histogram with N bins, bin N+1 corresponds to bin 1, and bin -1 corresponds to bin N)

Definition at line 353 of file QTest.h.

References gen::n.

Referenced by QTestConfigure::EnableNoisyChannelTest().

{ if (n > 0) numNeighbors_ = n; }

void NoisyChannel::setTolerance ( float  percentage )

inline

set (percentage) tolerance for considering a channel noisy; eg. if tolerance = 20%, a channel will be noisy if (contents-average)/|average| > 20%; average is calculated from neighboring channels (also see method setNumNeighbors)

Definition at line 359 of file QTest.h.

References stringResolutionProvider_cfi::bin.

Referenced by QTestConfigure::EnableNoisyChannelTest().

  {
    if (percentage >=0)
    {
      tolerance_ = percentage;
      rangeInitialized_ = true;
    }
  }

Member Data Documentation

unsigned NoisyChannel::numNeighbors_

protected

Definition at line 375 of file QTest.h.

bool NoisyChannel::rangeInitialized_

protected

Definition at line 377 of file QTest.h.

float NoisyChannel::tolerance_

protected

Definition at line 374 of file QTest.h.