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
	get test status More...
void	init ()
	initialize values More...
	QCriterion (std::string qtname)
float	runTest (const MonitorElement *me, QReport &qr, DQMNet::QValue &qv)
void	setErrorProb (float prob)
void	setWarningProb (float prob)
	set probability limit for warning and error (default: 90% and 50%) More...
virtual	~QCriterion ()=default

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	setAlgoName (std::string name)
	set algorithm name More...
void	setVerbose (int verbose)
	probability limits for warnings, errors More...

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

Additional Inherited Members
Public Types inherited from QCriterion
typedef dqm::legacy::MonitorElement	MonitorElement
	(class should be created by DQMStore class) More...
Static Public Attributes inherited from QCriterion
static const float	ERROR_PROB_THRESHOLD = 0.50
static const float	WARNING_PROB_THRESHOLD = 0.90
	default "probability" values for setting warnings & errors when running tests More...

Detailed Description

Check if any channels are noisy compared to neighboring ones.

Definition at line 220 of file QTest.h.

Constructor & Destructor Documentation

NoisyChannel()

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

inline

Definition at line 222 of file QTest.h.

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

References getAlgoName(), numNeighbors_, rangeInitialized_, and QCriterion::setAlgoName().

Member Function Documentation

getAlgoName()

static std::string NoisyChannel::getAlgoName ( )

inlinestatic

Definition at line 227 of file QTest.h.

{ return "NoisyChannel"; }

Referenced by QualityTester::makeQCriterion(), and NoisyChannel().

getAverage()

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

protected

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

Definition at line 375 of file QTest.cc.

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

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

getAverage2D()

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

protected

Do NOT use underflow or overflow bins

Definition at line 412 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

runTest()

float NoisyChannel::runTest ( const MonitorElement *  me )

overridevirtual

Reimplemented from QCriterion.

Definition at line 263 of file QTest.cc.

                                                    {
  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::Kind::TH1F) {
    nbins = me->getTH1F()->GetXaxis()->GetNbins();
    h = me->getTH1F();  // access Test histo
  }
  //-- TH1S
  else if (me->kind() == MonitorElement::Kind::TH1S) {
    nbins = me->getTH1S()->GetXaxis()->GetNbins();
    h = me->getTH1S();  // access Test histo
  }
  //-- TH1D
  else if (me->kind() == MonitorElement::Kind::TH1D) {
    nbins = me->getTH1D()->GetXaxis()->GetNbins();
    h = me->getTH1D();  // access Test histo
  }
  //-- TH2
  else if (me->kind() == MonitorElement::Kind::TH2F) {
    nbinsX = me->getTH2F()->GetXaxis()->GetNbins();
    nbinsY = me->getTH2F()->GetYaxis()->GetNbins();
    h2 = me->getTH2F();  // access Test histo
  }
  //-- TH2
  else if (me->kind() == MonitorElement::Kind::TH2S) {
    nbinsX = me->getTH2S()->GetXaxis()->GetNbins();
    nbinsY = me->getTH2S()->GetYaxis()->GetNbins();
    h2 = me->getTH2S();  // access Test histo
  }
  //-- TH2
  else if (me->kind() == MonitorElement::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;
  }
}

References funct::abs(), PDRates::average, newFWLiteAna::bin, officialStyle::chan, relmon_rootfiles_spy::contents, gather_cfg::cout, first, dqmdumpme::last, hlt_dqm_clientPB-live_cfg::me, LaserClient_cfi::nbins, hlt_dqm_clientPB-live_cfg::nbinsX, hlt_dqm_clientPB-live_cfg::nbinsY, MonitorElementData::TH1D, MonitorElementData::TH1F, MonitorElementData::TH1S, MonitorElementData::TH2D, MonitorElementData::TH2F, and MonitorElementData::TH2S.

setNumNeighbors()

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 237 of file QTest.h.

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

References dqmiodumpmetadata::n, and numNeighbors_.

setTolerance()

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 246 of file QTest.h.

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

References rangeInitialized_, and tolerance_.

Member Data Documentation

numNeighbors_

unsigned NoisyChannel::numNeighbors_

protected

Definition at line 260 of file QTest.h.

Referenced by NoisyChannel(), and setNumNeighbors().

rangeInitialized_

bool NoisyChannel::rangeInitialized_

protected

Definition at line 262 of file QTest.h.

Referenced by NoisyChannel(), and setTolerance().

tolerance_

float NoisyChannel::tolerance_

protected

Definition at line 259 of file QTest.h.

Referenced by setTolerance().