Check the sigma of each bin against the rest of the chamber by a factor of tolerance/. More...

#include <QTest.h>

Inheritance diagram for ContentSigma:

Public Member Functions
	ContentSigma (const std::string &name)

float	runTest (const MonitorElement *me) override

void	setDead (bool dead)

void	setNoisy (bool noisy)

void	setNumNeighborsX (unsigned ncx)

void	setNumNeighborsY (unsigned ncy)

void	setNumXblocks (unsigned ncx)

void	setNumYblocks (unsigned ncy)

void	setToleranceDead (float factorDead)

void	setToleranceNoisy (float factorNoisy)

void	setXMax (unsigned xMax)

void	setXMin (unsigned xMin)

void	setYMax (unsigned yMax)

void	setYMin (unsigned yMin)

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	getNeighborSigma (double average, unsigned groupx, unsigned groupy, unsigned Xblocks, unsigned Yblocks, unsigned neighborsX, unsigned neighborsY, const TH1 *h) const

double	getNeighborSum (unsigned groupx, unsigned groupy, unsigned Xblocks, unsigned Yblocks, unsigned neighborsX, unsigned neighborsY, const TH1 *h) const
	for each bin get sum of the surrounding neighbors More...

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
bool	dead_

bool	noisy_

unsigned	numNeighborsX_

unsigned	numNeighborsY_

unsigned	numXblocks_

unsigned	numYblocks_

bool	rangeInitialized_

float	toleranceDead_

float	toleranceNoisy_

unsigned	xMax_

unsigned	xMin_

unsigned	yMax_

unsigned	yMin_

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 the sigma of each bin against the rest of the chamber by a factor of tolerance/.

Definition at line 267 of file QTest.h.

Constructor & Destructor Documentation

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

inline

Definition at line 269 of file QTest.h.

References getAlgoName(), numNeighborsX_, numNeighborsY_, numXblocks_, numYblocks_, rangeInitialized_, and QCriterion::setAlgoName().

                                       : SimpleTest(name, true) {
     rangeInitialized_ = false;
     numXblocks_ = 1;
     numYblocks_ = 1;
     numNeighborsX_ = 1;
     numNeighborsY_ = 1;
     setAlgoName(getAlgoName());
   }

Member Function Documentation

static std::string ContentSigma::getAlgoName ( )

inlinestatic

Definition at line 277 of file QTest.h.

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

277 { return "ContentSigma"; }

double ContentSigma::getNeighborSigma	(	double	average,
		unsigned	groupx,
		unsigned	groupy,
		unsigned	Xblocks,
		unsigned	Yblocks,
		unsigned	neighborsX,
		unsigned	neighborsY,
		const TH1 *	h
	)		const

protected

Definition at line 775 of file QTest.cc.

References HLT_FULL_cff::yMax, and HLT_FULL_cff::yMin.

                                                           {
   double sigma = 0;
   unsigned nbinsX = h->GetXaxis()->GetNbins();
   unsigned nbinsY = h->GetYaxis()->GetNbins();
   unsigned xMin = 1;
   unsigned yMin = 1;
   unsigned xMax = nbinsX;
   unsigned yMax = nbinsY;
   unsigned Xbinnum = 1;
   unsigned Ybinnum = 1;
   double block_sum;
 
   if (xMin_ != 0 && xMax_ != 0) {
     if ((xMax_ <= nbinsX) && (xMin_ <= xMax_)) {
       nbinsX = xMax_ - xMin_ + 1;
       xMax = xMax_;
       xMin = xMin_;
     }
   }
   if (yMin_ != 0 && yMax_ != 0) {
     if ((yMax_ <= nbinsY) && (yMin_ <= yMax_)) {
       nbinsY = yMax_ - yMin_ + 1;
       yMax = yMax_;
       yMin = yMin_;
     }
   }
   if (Xblocks == 999) {
     Xblocks = nbinsX;
   }
   if (Yblocks == 999) {
     Yblocks = nbinsY;
   }
 
   Xbinnum = nbinsX / Xblocks;
   Ybinnum = nbinsY / Yblocks;
 
   unsigned xLow, xHi, yLow, yHi;
   for (unsigned x_block_count = 0; x_block_count <= 2 * neighborsX; ++x_block_count) {
     for (unsigned y_block_count = 0; y_block_count <= 2 * neighborsY; ++y_block_count) {
       //Sum over blocks. Need to find standard deviation of average of blocksums. Set up low and hi values similar to sum but for blocks now.
       if (groupx + x_block_count > neighborsX) {
         xLow = (groupx + x_block_count - neighborsX) * Xbinnum + xMin;
         if (xLow < xMin) {
           xLow = xMin;
         }
       } else {
         xLow = xMin;
       }
       xHi = xLow + Xbinnum;
       if (xHi > xMax) {
         xHi = xMax;
       }
       if (groupy + y_block_count > neighborsY) {
         yLow = (groupy + y_block_count - neighborsY) * Ybinnum + yMin;
         if (yLow < yMin) {
           yLow = yMin;
         }
       } else {
         yLow = yMin;
       }
       yHi = yLow + Ybinnum;
       if (yHi > yMax) {
         yHi = yMax;
       }
       block_sum = 0;
       for (unsigned x_block_bin = xLow; x_block_bin <= xHi; ++x_block_bin) {
         for (unsigned y_block_bin = yLow; y_block_bin <= yHi; ++y_block_bin) {
           block_sum += h->GetBinContent(x_block_bin, y_block_bin);
         }
       }
       sigma += (average - block_sum) * (average - block_sum);  //will sqrt and divide by sqrt(N-1) outside of function
     }
   }
   return sigma;
 }

double ContentSigma::getNeighborSum	(	unsigned	groupx,
		unsigned	groupy,
		unsigned	Xblocks,
		unsigned	Yblocks,
		unsigned	neighborsX,
		unsigned	neighborsY,
		const TH1 *	h
	)		const

protected

for each bin get sum of the surrounding neighbors

Definition at line 695 of file QTest.cc.

References HLT_FULL_cff::yMax, and HLT_FULL_cff::yMin.

                                                         {
   double sum = 0;
   unsigned nbinsX = h->GetXaxis()->GetNbins();
   unsigned nbinsY = h->GetYaxis()->GetNbins();
   unsigned xMin = 1;
   unsigned yMin = 1;
   unsigned xMax = nbinsX;
   unsigned yMax = nbinsY;
   unsigned Xbinnum = 1;
   unsigned Ybinnum = 1;
 
   //give users option for automatic mininum and maximum selection by inputting 0 to any of the parameters
   // check that user's parameters are completely in agreement with histogram
   // for instance, if inputted xMax is out of range xMin will automatically be ignored
   if (xMin_ != 0 && xMax_ != 0) {
     if ((xMax_ <= nbinsX) && (xMin_ <= xMax_)) {
       nbinsX = xMax_ - xMin_ + 1;
       xMax = xMax_;  // do NOT use overflow bin
       xMin = xMin_;  // do NOT use underflow bin
     }
   }
   if (yMin_ != 0 && yMax_ != 0) {
     if ((yMax_ <= nbinsY) && (yMin_ <= yMax_)) {
       nbinsY = yMax_ - yMin_ + 1;
       yMax = yMax_;
       yMin = yMin_;
     }
   }
 
   if (Xblocks == 999) {  //Check to see if blocks should be ignored
     Xblocks = nbinsX;
   }
   if (Yblocks == 999) {
     Yblocks = nbinsY;
   }
 
   Xbinnum = nbinsX / Xblocks;
   Ybinnum = nbinsY / Yblocks;
 
   unsigned xLow, xHi, yLow, yHi;  //Define the neighbor blocks edges to be summed
   if (groupx > neighborsX) {
     xLow = (groupx - neighborsX) * Xbinnum + xMin;
     if (xLow < xMin) {
       xLow = xMin;  //If the neigbor block would go outside the histogram edge, set it the edge
     }
   } else {
     xLow = xMin;
   }
   xHi = (groupx + 1 + neighborsX) * Xbinnum + xMin;
   if (xHi > xMax) {
     xHi = xMax;
   }
   if (groupy > neighborsY) {
     yLow = (groupy - neighborsY) * Ybinnum + yMin;
     if (yLow < yMin) {
       yLow = yMin;
     }
   } else {
     yLow = yMin;
   }
   yHi = (groupy + 1 + neighborsY) * Ybinnum + yMin;
   if (yHi > yMax) {
     yHi = yMax;
   }
 
   for (unsigned xbin = xLow; xbin <= xHi; ++xbin) {  //now sum over all the bins
     for (unsigned ybin = yLow; ybin <= yHi; ++ybin) {
       sum += h->GetBinContent(xbin, ybin);
     }
   }
   return sum;
 }

float ContentSigma::runTest ( const MonitorElement * me )

overridevirtual

Reimplemented from QCriterion.

Definition at line 488 of file QTest.cc.

                                                     {
   badChannels_.clear();
   if (!me)
     return -1;
   if (!me->getRootObject())
     return -1;
   TH1* h = nullptr;  //initialize histogram pointer
 
   if (verbose_ > 1)
     std::cout << "QTest:" << getAlgoName() << "::runTest called on " << me->getFullname() << "\n";
 
   unsigned nbinsX;
   unsigned nbinsY;
 
   //-- TH1F
   if (me->kind() == MonitorElement::Kind::TH1F) {
     nbinsX = me->getTH1F()->GetXaxis()->GetNbins();
     nbinsY = me->getTH1F()->GetYaxis()->GetNbins();
     h = me->getTH1F();  // access Test histo
   }
   //-- TH1S
   else if (me->kind() == MonitorElement::Kind::TH1S) {
     nbinsX = me->getTH1S()->GetXaxis()->GetNbins();
     nbinsY = me->getTH1S()->GetYaxis()->GetNbins();
     h = me->getTH1S();  // access Test histo
   }
   //-- TH1D
   else if (me->kind() == MonitorElement::Kind::TH1D) {
     nbinsX = me->getTH1D()->GetXaxis()->GetNbins();
     nbinsY = me->getTH1D()->GetYaxis()->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();
     h = me->getTH2F();  // access Test histo
   }
   //-- TH2
   else if (me->kind() == MonitorElement::Kind::TH2S) {
     nbinsX = me->getTH2S()->GetXaxis()->GetNbins();
     nbinsY = me->getTH2S()->GetYaxis()->GetNbins();
     h = me->getTH2S();  // access Test histo
   }
   //-- TH2
   else if (me->kind() == MonitorElement::Kind::TH2D) {
     nbinsX = me->getTH2D()->GetXaxis()->GetNbins();
     nbinsY = me->getTH2D()->GetYaxis()->GetNbins();
     h = me->getTH2D();  // access Test histo
   } else {
     if (verbose_ > 0)
       std::cout << "QTest:ContentSigma"
                 << " ME " << me->getFullname() << " does not contain TH1F/TH1S/TH1D or TH2F/TH2S/TH2D, exiting\n";
     return -1;
   }
 
   //--  QUALITY TEST itself
 
   if (!rangeInitialized_ || !h->GetXaxis())
     return 1;  // all channels are accepted if tolerance has not been set
 
   int fail = 0;       // initialize bin failure count
   unsigned xMin = 1;  //initialize minimums and maximums with expected values
   unsigned yMin = 1;
   unsigned xMax = nbinsX;
   unsigned yMax = nbinsY;
   unsigned XBlocks = numXblocks_;  //Initialize xml inputs blocks and neighbors
   unsigned YBlocks = numYblocks_;
   unsigned neighborsX = numNeighborsX_;
   unsigned neighborsY = numNeighborsY_;
   unsigned Xbinnum = 1;
   unsigned Ybinnum = 1;
   unsigned XWidth = 0;
   unsigned YWidth = 0;
 
   if (neighborsX == 999) {
     neighborsX = 0;
   }
   if (neighborsY == 999) {
     neighborsY = 0;
   }
 
   //give users option for automatic mininum and maximum selection by inputting 0 to any of the parameters
   // check that user's parameters are completely in agreement with histogram
   // for instance, if inputted xMax is out of range xMin will automatically be ignored
   if (xMin_ != 0 && xMax_ != 0) {
     if ((xMax_ <= nbinsX) && (xMin_ <= xMax_)) {  // rescale area of histogram being analyzed
       nbinsX = xMax_ - xMin_ + 1;
       xMax = xMax_;  // do NOT use overflow bin
       xMin = xMin_;  // do NOT use underflow bin
     }
   }
   //give users option for automatic mininum and maximum selection by inputting 0 to any of the parameters
   if (yMin_ != 0 && yMax_ != 0) {
     if ((yMax_ <= nbinsY) && (yMin_ <= yMax_)) {
       nbinsY = yMax_ - yMin_ + 1;
       yMax = yMax_;
       yMin = yMin_;
     }
   }
 
   if (neighborsX * 2 >= nbinsX) {  //make sure neighbor check does not overlap with bin under consideration
     if (nbinsX % 2 == 0) {
       neighborsX = nbinsX / 2 - 1;  //set neighbors for no overlap
     } else {
       neighborsX = (nbinsX - 1) / 2;
     }
   }
 
   if (neighborsY * 2 >= nbinsY) {
     if (nbinsY % 2 == 0) {
       neighborsY = nbinsY / 2 - 1;
     } else {
       neighborsY = (nbinsY - 1) / 2;
     }
   }
 
   if (XBlocks == 999) {  //Setting 999 prevents blocks and does quality tests by bins only
     XBlocks = nbinsX;
   }
   if (YBlocks == 999) {
     YBlocks = nbinsY;
   }
 
   Xbinnum = nbinsX / XBlocks;
   Ybinnum = nbinsY / YBlocks;
   for (unsigned groupx = 0; groupx < XBlocks; ++groupx) {  //Test over all the blocks
     for (unsigned groupy = 0; groupy < YBlocks; ++groupy) {
       double blocksum = 0;
       for (unsigned binx = 0; binx < Xbinnum; ++binx) {  //Sum the contents of the block in question
         for (unsigned biny = 0; biny < Ybinnum; ++biny) {
           if (groupx * Xbinnum + xMin + binx <= xMax && groupy * Ybinnum + yMin + biny <= yMax) {
             blocksum += abs(h->GetBinContent(groupx * Xbinnum + xMin + binx, groupy * Ybinnum + yMin + biny));
           }
         }
       }
 
       double sum = getNeighborSum(groupx, groupy, XBlocks, YBlocks, neighborsX, neighborsY, h);
       sum -= blocksum;  //remove center block to test
 
       if (neighborsX > groupx) {  //Find correct average at the edges
         XWidth = neighborsX + groupx + 1;
       } else if (neighborsX > (XBlocks - (groupx + 1))) {
         XWidth = (XBlocks - groupx) + neighborsX;
       } else {
         XWidth = 2 * neighborsX + 1;
       }
       if (neighborsY > groupy) {
         YWidth = neighborsY + groupy + 1;
       } else if (neighborsY > (YBlocks - (groupy + 1))) {
         YWidth = (YBlocks - groupy) + neighborsY;
       } else {
         YWidth = 2 * neighborsY + 1;
       }
 
       double average = sum / (XWidth * YWidth - 1);
       double sigma = getNeighborSigma(average, groupx, groupy, XBlocks, YBlocks, neighborsX, neighborsY, h);
       //get rid of block being tested just like we did with the average
       sigma -= (average - blocksum) * (average - blocksum);
       double sigma_2 = sqrt(sigma) / sqrt(XWidth * YWidth - 2);  //N-1 where N=XWidth*YWidth - 1
       double sigma_real = sigma_2 / (XWidth * YWidth - 1);
       //double avg_uncrt = average*sqrt(sum)/sum;//Obsolete now(Chad Freer)
       double avg_uncrt = 3 * sigma_real;
 
       double probNoisy = ROOT::Math::poisson_cdf_c(blocksum - 1, average + avg_uncrt);
       double probDead = ROOT::Math::poisson_cdf(blocksum, average - avg_uncrt);
       double thresholdNoisy = ROOT::Math::normal_cdf_c(toleranceNoisy_);
       double thresholdDead = ROOT::Math::normal_cdf(-1 * toleranceDead_);
 
       int failureNoisy = 0;
       int failureDead = 0;
 
       if (average != 0) {
         if (noisy_ && dead_) {
           if (blocksum > average) {
             failureNoisy = probNoisy < thresholdNoisy;
           } else {
             failureDead = probDead < thresholdDead;
           }
         } else if (noisy_) {
           if (blocksum > average) {
             failureNoisy = probNoisy < thresholdNoisy;
           }
         } else if (dead_) {
           if (blocksum < average) {
             failureDead = probDead < thresholdDead;
           }
         } else {
           std::cout << "No test type selected!\n";
         }
         //Following lines useful for debugging using verbose (Chad Freer)
         //string histName = h->GetName();
         //if (histName == "emtfTrackBX") {
         //   std::printf("Chad says: %i XBlocks, %i XBlocks, %f Blocksum, %f Average", XBlocks,YBlocks,blocksum,average);}
       }
 
       if (failureNoisy || failureDead) {
         ++fail;
         //DQMChannel chan(groupx*Xbinnum+xMin+binx, 0, 0, blocksum, h->GetBinError(groupx*Xbinnum+xMin+binx));
         //badChannels_.push_back(chan);
       }
     }
   }
   return 1. * ((XBlocks * YBlocks) - fail) / (XBlocks * YBlocks);
 }

void ContentSigma::setDead ( bool dead )

inline

Definition at line 320 of file QTest.h.

References dead_.

320 { dead_ = dead; }

ContentSigma::dead_

bool dead_

Definition: QTest.h:347

void ContentSigma::setNoisy ( bool noisy )

inline

Definition at line 319 of file QTest.h.

References noisy_.

319 { noisy_ = noisy; }

ContentSigma::noisy_

bool noisy_

Definition: QTest.h:346

void ContentSigma::setNumNeighborsX ( unsigned ncx )

inline

Definition at line 295 of file QTest.h.

References numNeighborsX_.

                                       {
     if (ncx > 0)
       numNeighborsX_ = ncx;
   }

void ContentSigma::setNumNeighborsY ( unsigned ncy )

inline

Definition at line 299 of file QTest.h.

References numNeighborsY_.

                                       {
     if (ncy > 0)
       numNeighborsY_ = ncy;
   }

void ContentSigma::setNumXblocks ( unsigned ncx )

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

References numXblocks_.

                                    {
     if (ncx > 0)
       numXblocks_ = ncx;
   }

void ContentSigma::setNumYblocks ( unsigned ncy )

inline

Definition at line 291 of file QTest.h.

References numYblocks_.

                                    {
     if (ncy > 0)
       numYblocks_ = ncy;
   }

void ContentSigma::setToleranceDead ( float factorDead )

inline

Definition at line 313 of file QTest.h.

References rangeInitialized_, and toleranceDead_.

                                           {
     if (factorDead >= 0) {
       toleranceDead_ = factorDead;
       rangeInitialized_ = true;
     }
   }

void ContentSigma::setToleranceNoisy ( float factorNoisy )

inline

set factor tolerance for considering a channel noisy or dead; eg. if tolerance = 1, channel will be noisy if (content - 1 x sigma) > chamber_avg or channel will be dead if (content - 1 x sigma) < chamber_avg

Definition at line 307 of file QTest.h.

References rangeInitialized_, and toleranceNoisy_.

                                             {
     if (factorNoisy >= 0) {
       toleranceNoisy_ = factorNoisy;
       rangeInitialized_ = true;
     }
   }