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 ( const std::string & name )

inline

Definition at line 222 of file QTest.h.

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

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

Member Function Documentation

static std::string NoisyChannel::getAlgoName ( )

inlinestatic

Definition at line 227 of file QTest.h.

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

227 { 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 375 of file QTest.cc.

References pat::helper::ParametrizationHelper::dimension(), and 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 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

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

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.

References dqmiodumpmetadata::n, and numNeighbors_.

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

References rangeInitialized_, and tolerance_.

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

Member Data Documentation

unsigned NoisyChannel::numNeighbors_

protected

Definition at line 260 of file QTest.h.

Referenced by NoisyChannel(), and setNumNeighbors().

bool NoisyChannel::rangeInitialized_

protected

Definition at line 262 of file QTest.h.

Referenced by NoisyChannel(), and setTolerance().

float NoisyChannel::tolerance_

protected

Definition at line 259 of file QTest.h.

Referenced by setTolerance().

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation