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

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

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

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

ContentSigma::numNeighborsX_

unsigned numNeighborsX_

Definition: QTest.h:459

void ContentSigma::setNumNeighborsY ( unsigned ncy )

inline

Definition at line 407 of file QTest.h.

Referenced by QTestConfigure::EnableContentSigmaTest().

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

ContentSigma::numNeighborsY_

unsigned numNeighborsY_

Definition: QTest.h:461

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

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

ContentSigma::numXblocks_

unsigned numXblocks_

Definition: QTest.h:457

void ContentSigma::setNumYblocks ( unsigned ncy )

inline

Definition at line 405 of file QTest.h.

Referenced by QTestConfigure::EnableContentSigmaTest().

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

ContentSigma::numYblocks_

unsigned numYblocks_

Definition: QTest.h:458

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 h, and 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.

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation