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

inline

Definition at line 269 of file QTest.h.

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

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

Member Function Documentation

getAlgoName()

static std::string ContentSigma::getAlgoName ( )

inlinestatic

Definition at line 277 of file QTest.h.

{ return "ContentSigma"; }

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

getNeighborSigma()

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.

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

References hlt_dqm_clientPB-live_cfg::nbinsX, hlt_dqm_clientPB-live_cfg::nbinsY, multiplicitycorr_cfi::xMax, photonAnalyzer_cfi::xMin, multiplicitycorr_cfi::yMax, and photonAnalyzer_cfi::yMin.

getNeighborSum()

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.

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

References hlt_dqm_clientPB-live_cfg::nbinsX, hlt_dqm_clientPB-live_cfg::nbinsY, multiplicitycorr_cfi::xMax, photonAnalyzer_cfi::xMin, multiplicitycorr_cfi::yMax, and photonAnalyzer_cfi::yMin.

runTest()

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

References funct::abs(), gather_cfg::cout, hlt_dqm_clientPB-live_cfg::me, hlt_dqm_clientPB-live_cfg::nbinsX, hlt_dqm_clientPB-live_cfg::nbinsY, mathSSE::sqrt(), MonitorElementData::TH1D, MonitorElementData::TH1F, MonitorElementData::TH1S, MonitorElementData::TH2D, MonitorElementData::TH2F, MonitorElementData::TH2S, multiplicitycorr_cfi::xMax, photonAnalyzer_cfi::xMin, multiplicitycorr_cfi::yMax, and photonAnalyzer_cfi::yMin.

setDead()

void ContentSigma::setDead ( bool  dead )

inline

Definition at line 320 of file QTest.h.

{ dead_ = dead; }

References dead_.

setNoisy()

void ContentSigma::setNoisy ( bool  noisy )

inline

Definition at line 319 of file QTest.h.

{ noisy_ = noisy; }

References noisy_.

setNumNeighborsX()

void ContentSigma::setNumNeighborsX ( unsigned  ncx )

inline

Definition at line 295 of file QTest.h.

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

References numNeighborsX_.

setNumNeighborsY()

void ContentSigma::setNumNeighborsY ( unsigned  ncy )

inline

Definition at line 299 of file QTest.h.

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

References numNeighborsY_.

setNumXblocks()

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.

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

References numXblocks_.

setNumYblocks()

void ContentSigma::setNumYblocks ( unsigned  ncy )

inline

Definition at line 291 of file QTest.h.

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

References numYblocks_.

setToleranceDead()

void ContentSigma::setToleranceDead ( float  factorDead )

inline

Definition at line 313 of file QTest.h.

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

References rangeInitialized_, and toleranceDead_.

setToleranceNoisy()

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.

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

References rangeInitialized_, and toleranceNoisy_.

setXMax()

void ContentSigma::setXMax ( unsigned  xMax )

inline

Definition at line 323 of file QTest.h.

{ xMax_ = xMax; }

References multiplicitycorr_cfi::xMax, and xMax_.

setXMin()

void ContentSigma::setXMin ( unsigned  xMin )

inline

Definition at line 322 of file QTest.h.

{ xMin_ = xMin; }

References photonAnalyzer_cfi::xMin, and xMin_.

setYMax()

void ContentSigma::setYMax ( unsigned  yMax )

inline

Definition at line 325 of file QTest.h.

{ yMax_ = yMax; }

References multiplicitycorr_cfi::yMax, and yMax_.

setYMin()

void ContentSigma::setYMin ( unsigned  yMin )

inline

Definition at line 324 of file QTest.h.

{ yMin_ = yMin; }

References photonAnalyzer_cfi::yMin, and yMin_.

Member Data Documentation

dead_

bool ContentSigma::dead_

protected

Definition at line 347 of file QTest.h.

Referenced by setDead().

noisy_

bool ContentSigma::noisy_

protected

Definition at line 346 of file QTest.h.

Referenced by setNoisy().

numNeighborsX_

unsigned ContentSigma::numNeighborsX_

protected

Definition at line 352 of file QTest.h.

Referenced by ContentSigma(), and setNumNeighborsX().

numNeighborsY_

unsigned ContentSigma::numNeighborsY_

protected

Definition at line 354 of file QTest.h.

Referenced by ContentSigma(), and setNumNeighborsY().

numXblocks_

unsigned ContentSigma::numXblocks_

protected

Definition at line 350 of file QTest.h.

Referenced by ContentSigma(), and setNumXblocks().

numYblocks_

unsigned ContentSigma::numYblocks_

protected

Definition at line 351 of file QTest.h.

Referenced by ContentSigma(), and setNumYblocks().

rangeInitialized_

bool ContentSigma::rangeInitialized_

protected

Definition at line 356 of file QTest.h.

Referenced by ContentSigma(), setToleranceDead(), and setToleranceNoisy().

toleranceDead_

float ContentSigma::toleranceDead_

protected

Definition at line 349 of file QTest.h.

Referenced by setToleranceDead().

toleranceNoisy_

float ContentSigma::toleranceNoisy_

protected

Definition at line 348 of file QTest.h.

Referenced by setToleranceNoisy().

xMax_

unsigned ContentSigma::xMax_

protected

Definition at line 358 of file QTest.h.

Referenced by setXMax().

xMin_

unsigned ContentSigma::xMin_

protected

Definition at line 357 of file QTest.h.

Referenced by setXMin().

yMax_

unsigned ContentSigma::yMax_

protected

Definition at line 360 of file QTest.h.

Referenced by setYMax().

yMin_

unsigned ContentSigma::yMin_

protected

Definition at line 359 of file QTest.h.

Referenced by setYMin().