ContentSigma Class Reference

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

Detailed Description

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

Definition at line 382 of file QTest.h.

Constructor & Destructor Documentation

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

inline

Definition at line 385 of file QTest.h.

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

References QCriterion::runTest().

Referenced by QTestConfigure::EnableContentSigmaTest(), and QTestConfigure::enableTests().

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

References anotherprimaryvertexanalyzer_cfi::xMax, anotherprimaryvertexanalyzer_cfi::xMin, CMSBoostedTauSeedingParameters_cfi::yMax, and CMSBoostedTauSeedingParameters_cfi::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 1306 of file QTest.cc.

References anotherprimaryvertexanalyzer_cfi::xMax, anotherprimaryvertexanalyzer_cfi::xMin, CMSBoostedTauSeedingParameters_cfi::yMax, and CMSBoostedTauSeedingParameters_cfi::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;

   if (xMin_ != 0 && xMax_ != 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 ((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 1093 of file QTest.cc.

References funct::abs(), 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(), MonitorElement::getFullname(), MonitorElement::getRootObject(), MonitorElement::getTH1D(), MonitorElement::getTH1F(), MonitorElement::getTH1S(), MonitorElement::getTH2D(), MonitorElement::getTH2F(), MonitorElement::getTH2S(), MonitorElement::kind(), mathSSE::sqrt(), anotherprimaryvertexanalyzer_cfi::xMax, anotherprimaryvertexanalyzer_cfi::xMin, CMSBoostedTauSeedingParameters_cfi::yMax, and CMSBoostedTauSeedingParameters_cfi::yMin.

{
  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::DQM_KIND_TH1F)
  { 
    nbinsX = me->getTH1F()->GetXaxis()->GetNbins(); 
    nbinsY = me->getTH1F()->GetYaxis()->GetNbins(); 
    h  = me->getTH1F(); // access Test histo
  } 
  //-- TH1S
  else if (me->kind()==MonitorElement::DQM_KIND_TH1S)
  { 
    nbinsX = me->getTH1S()->GetXaxis()->GetNbins(); 
    nbinsY = me->getTH1S()->GetYaxis()->GetNbins(); 
    h  = me->getTH1S(); // access Test histo
  } 
  //-- TH1D
  else if (me->kind()==MonitorElement::DQM_KIND_TH1D)
  { 
    nbinsX = me->getTH1D()->GetXaxis()->GetNbins(); 
    nbinsY = me->getTH1D()->GetYaxis()->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(); 
    h  = me->getTH2F(); // access Test histo
  } 
  //-- TH2
  else if (me->kind()==MonitorElement::DQM_KIND_TH2S)
  { 
    nbinsX = me->getTH2S()->GetXaxis()->GetNbins(); 
    nbinsY = me->getTH2S()->GetYaxis()->GetNbins(); 
    h  = me->getTH2S(); // access Test histo
  } 
  //-- TH2
  else if (me->kind()==MonitorElement::DQM_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;
   }
   
   if (xMin_ != 0 && xMax_ != 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 ((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
      }
   }
   if (yMin_ != 0 && yMax_ != 0) {              //give users option for automatic mininum and maximum selection by inputting 0 to any of the parameters
      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);
     sigma -= (average-blocksum) * (average-blocksum);          //get rid of block being tested just like we did with the average
     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 431 of file QTest.h.

Referenced by QTestConfigure::EnableContentSigmaTest().

                          { 
    dead_ = dead; 
  }

void ContentSigma::setNoisy ( bool  noisy )

inline

Definition at line 428 of file QTest.h.

Referenced by QTestConfigure::EnableContentSigmaTest().

                            { 
    noisy_ = noisy; 
  }

void ContentSigma::setNumNeighborsX ( unsigned  ncx )

inline

Definition at line 406 of file QTest.h.

Referenced by QTestConfigure::EnableContentSigmaTest().

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

void ContentSigma::setNumNeighborsY ( unsigned  ncy )

inline

Definition at line 407 of file QTest.h.

Referenced by QTestConfigure::EnableContentSigmaTest().

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

Referenced by QTestConfigure::EnableContentSigmaTest().

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

void ContentSigma::setNumYblocks ( unsigned  ncy )

inline

Definition at line 405 of file QTest.h.

Referenced by QTestConfigure::EnableContentSigmaTest().

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

void ContentSigma::setToleranceDead ( float  factorDead )

inline

Definition at line 420 of file QTest.h.

Referenced by QTestConfigure::EnableContentSigmaTest().

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

Referenced by QTestConfigure::EnableContentSigmaTest().

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

void ContentSigma::setXMax ( unsigned  xMax )

inline

Definition at line 438 of file QTest.h.

References anotherprimaryvertexanalyzer_cfi::xMax.

Referenced by QTestConfigure::EnableContentSigmaTest().

                                {
        xMax_ = xMax;
    }

void ContentSigma::setXMin ( unsigned  xMin )

inline

Definition at line 435 of file QTest.h.

References anotherprimaryvertexanalyzer_cfi::xMin.

Referenced by QTestConfigure::EnableContentSigmaTest().

                                {
        xMin_ = xMin;
    }

void ContentSigma::setYMax ( unsigned  yMax )

inline

Definition at line 444 of file QTest.h.

References CMSBoostedTauSeedingParameters_cfi::yMax.

Referenced by QTestConfigure::EnableContentSigmaTest().

                                {
        yMax_ = yMax;
    } 

void ContentSigma::setYMin ( unsigned  yMin )

inline

Definition at line 441 of file QTest.h.

References CMSBoostedTauSeedingParameters_cfi::yMin.

Referenced by QTestConfigure::EnableContentSigmaTest().

                                {
        yMin_ = yMin;
    }

Member Data Documentation

bool ContentSigma::dead_

protected

Definition at line 454 of file QTest.h.

bool ContentSigma::noisy_

protected

Definition at line 454 of file QTest.h.

unsigned ContentSigma::numNeighborsX_

protected

Definition at line 459 of file QTest.h.

unsigned ContentSigma::numNeighborsY_

protected

Definition at line 461 of file QTest.h.

unsigned ContentSigma::numXblocks_

protected

Definition at line 457 of file QTest.h.

unsigned ContentSigma::numYblocks_

protected

Definition at line 458 of file QTest.h.

bool ContentSigma::rangeInitialized_

protected

Definition at line 463 of file QTest.h.

float ContentSigma::toleranceDead_

protected

Definition at line 456 of file QTest.h.

float ContentSigma::toleranceNoisy_

protected

Definition at line 455 of file QTest.h.

unsigned ContentSigma::xMax_

protected

Definition at line 465 of file QTest.h.

unsigned ContentSigma::xMin_

protected

Definition at line 464 of file QTest.h.

unsigned ContentSigma::yMax_

protected

Definition at line 467 of file QTest.h.

unsigned ContentSigma::yMin_

protected

Definition at line 466 of file QTest.h.