QTestConfigure Class Reference

#include <QTestConfigure.h>

Public Member Functions
void	disableTests (const std::vector< std::string > &testsOFFList, DQMStore *bei)
	Disables the Quality Tests in the string list. More...
bool	enableTests (const std::map< std::string, std::map< std::string, std::string > > &tests, DQMStore *bei)
	Creates and defines quality tests. More...
	QTestConfigure ()
	Constructor. More...
std::vector< std::string >	testsReady ()
	Returns the vector containing the names of the quality tests that have been created. More...
	~QTestConfigure ()
	Destructor. More...

Private Member Functions
void	EnableCheckVarianceTest (std::string testName, const std::map< std::string, std::string > &params, DQMStore *bei)
	Creates CheckVariance test. More...
void	EnableComp2Ref2DChi2Test (std::string testName, const std::map< std::string, std::string > &params, DQMStore *bei)
	Creates Comp2Ref2DChi2 test. More...
void	EnableComp2RefChi2Test (std::string testName, const std::map< std::string, std::string > &params, DQMStore *bei)
	Creates Comp2RefChi2 test. More...
void	EnableComp2RefEqualHTest (std::string testName, const std::map< std::string, std::string > &params, DQMStore *bei)
	Creates Comp2RefEqualH test. More...
void	EnableComp2RefKolmogorovTest (std::string testName, const std::map< std::string, std::string > &params, DQMStore *bei)
	Creates EnableComp2RefKolmogorov test. More...
void	EnableCompareLastFilledBinTest (std::string testName, const std::map< std::string, std::string > &params, DQMStore *bei)
	Creates EnableCompareLastFilledBinTest test. More...
void	EnableCompareToMedianTest (std::string testName, const std::map< std::string, std::string > &params, DQMStore *bei)
	Creates ContentsWithinRangeROOT test. More...
void	EnableContentSigmaTest (std::string testName, const std::map< std::string, std::string > &params, DQMStore *bei)
	Creates ContentSigmaROOT test. More...
void	EnableContentsWithinExpectedTest (std::string testName, const std::map< std::string, std::string > &params, DQMStore *bei)
	Creates ContentsWithinRangeROOT test. More...
void	EnableDeadChannelTest (std::string testName, const std::map< std::string, std::string > &params, DQMStore *bei)
	Creates ContentsYRangeASROOT test. More...
void	EnableMeanWithinExpectedTest (std::string testName, const std::map< std::string, std::string > &params, DQMStore *bei)
	Creates MeanWithinExpectedROOT test. More...
void	EnableNoisyChannelTest (std::string testName, const std::map< std::string, std::string > &params, DQMStore *bei)
	Creates NoisyChannelROOT test. More...
void	EnableXRangeTest (std::string testName, const std::map< std::string, std::string > &params, DQMStore *bei)
	Creates ContentsXRangeROOT test. More...
void	EnableYRangeTest (std::string testName, const std::map< std::string, std::string > &params, DQMStore *bei)
	Creates ContentsXRangeASROOT test. More...
const char *	findOrDefault (const std::map< std::string, std::string > &, const char *, const char *) const

Private Attributes
std::vector< std::string >	testsConfigured

Detailed Description

• Class that creates and defined quality tests based on the xml configuration file parsed by QTestConfigurationParser.

  Author

  Ilaria Segoni

Definition at line 20 of file QTestConfigure.h.

Constructor & Destructor Documentation

QTestConfigure::QTestConfigure ( )

inline

Constructor.

Definition at line 25 of file QTestConfigure.h.

{}

QTestConfigure::~QTestConfigure ( )

inline

Destructor.

Definition at line 27 of file QTestConfigure.h.

References disableTests(), enableTests(), genParticles_cff::map, AlCaHLTBitMon_QueryRunRegistry::string, and utils_v2::tests.

{}

Member Function Documentation

void QTestConfigure::disableTests	(	const std::vector< std::string > &	testsOFFList,
		DQMStore *	bei
	)

Disables the Quality Tests in the string list.

Referenced by ~QTestConfigure().

void QTestConfigure::EnableCheckVarianceTest ( std::string  testName, const std::map< std::string, std::string > &  params, DQMStore *  bei  )

private

Creates CheckVariance test.

Definition at line 425 of file QTestConfigure.cc.

References DQMStore::createQTest(), relativeConstraints::error, findOrDefault(), CheckVariance::getAlgoName(), DQMStore::getQCriterion(), QCriterion::setErrorProb(), QCriterion::setWarningProb(), and testsConfigured.

Referenced by enableTests(), and testsReady().

                                       {
  QCriterion * qc1;
  if(! bei->getQCriterion(testName) ){
    testsConfigured.push_back(testName);
    qc1 = bei->createQTest(CheckVariance::getAlgoName(),testName);
  }else{
    qc1 = bei->getQCriterion(testName);
    
  }
  CheckVariance * me_qc1 = (CheckVariance *) qc1;
  
  double warning = atof(findOrDefault(params, "warning", "0"));
  double error   = atof(findOrDefault(params, "error", "0"));
  me_qc1->setWarningProb(warning);
  me_qc1->setErrorProb(error);
}

void QTestConfigure::EnableComp2Ref2DChi2Test ( std::string  testName, const std::map< std::string, std::string > &  params, DQMStore *  bei  )

private

Creates Comp2Ref2DChi2 test.

Definition at line 105 of file QTestConfigure.cc.

References DQMStore::createQTest(), relativeConstraints::error, findOrDefault(), Comp2Ref2DChi2::getAlgoName(), DQMStore::getQCriterion(), QCriterion::setErrorProb(), SimpleTest::setMinimumEntries(), QCriterion::setWarningProb(), and testsConfigured.

Referenced by enableTests(), and testsReady().

                                                             {
  QCriterion * qc1;
  if (! bei->getQCriterion(testName)) {
    testsConfigured.push_back(testName);
    qc1 = bei->createQTest(Comp2Ref2DChi2::getAlgoName(), testName);
  } else {
    qc1 = bei->getQCriterion(testName);
  }
  Comp2Ref2DChi2 * me_qc1 = (Comp2Ref2DChi2 *) qc1;
  double warning = atof(findOrDefault(params, "warning", "0"));
  double error   = atof(findOrDefault(params, "error", "0"));
  int minEntries = atoi(findOrDefault(params, "minEntries", "0"));
  me_qc1->setWarningProb(warning);
  me_qc1->setErrorProb(error);
  if ( minEntries != 0 )
    me_qc1->setMinimumEntries(minEntries);
}

void QTestConfigure::EnableComp2RefChi2Test ( std::string  testName, const std::map< std::string, std::string > &  params, DQMStore *  bei  )

private

Creates Comp2RefChi2 test.

Definition at line 88 of file QTestConfigure.cc.

References DQMStore::createQTest(), relativeConstraints::error, findOrDefault(), Comp2RefChi2::getAlgoName(), DQMStore::getQCriterion(), QCriterion::setErrorProb(), QCriterion::setWarningProb(), and testsConfigured.

Referenced by enableTests(), and testsReady().

                                                           {
  QCriterion * qc1;
  if (! bei->getQCriterion(testName)) {
    testsConfigured.push_back(testName);
    qc1 = bei->createQTest(Comp2RefChi2::getAlgoName(), testName);
  } else {
    qc1 = bei->getQCriterion(testName);
  }
  Comp2RefChi2 * me_qc1 = (Comp2RefChi2 *) qc1;
  double warning = atof(findOrDefault(params, "warning", "0"));
  double error   = atof(findOrDefault(params, "error", "0"));
  me_qc1->setWarningProb(warning);
  me_qc1->setErrorProb(error);
}

void QTestConfigure::EnableComp2RefEqualHTest ( std::string  testName, const std::map< std::string, std::string > &  params, DQMStore *  bei  )

private

Creates Comp2RefEqualH test.

Definition at line 71 of file QTestConfigure.cc.

References DQMStore::createQTest(), relativeConstraints::error, findOrDefault(), Comp2RefEqualH::getAlgoName(), DQMStore::getQCriterion(), QCriterion::setErrorProb(), QCriterion::setWarningProb(), and testsConfigured.

Referenced by enableTests(), and testsReady().

                                                             {
  QCriterion * qc1;
  if (! bei->getQCriterion(testName)) {
    testsConfigured.push_back(testName);
    qc1 = bei->createQTest(Comp2RefEqualH::getAlgoName(), testName);
  } else {
    qc1 = bei->getQCriterion(testName);
  }
  Comp2RefEqualH * me_qc1 = (Comp2RefEqualH *) qc1;
  double warning = atof(findOrDefault(params, "warning", "0"));
  double error   = atof(findOrDefault(params, "error", "0"));
  me_qc1->setWarningProb(warning);
  me_qc1->setErrorProb(error);
}

void QTestConfigure::EnableComp2RefKolmogorovTest ( std::string  testName, const std::map< std::string, std::string > &  params, DQMStore *  bei  )

private

Creates EnableComp2RefKolmogorov test.

Definition at line 125 of file QTestConfigure.cc.

References DQMStore::createQTest(), relativeConstraints::error, findOrDefault(), Comp2RefKolmogorov::getAlgoName(), DQMStore::getQCriterion(), QCriterion::setErrorProb(), QCriterion::setWarningProb(), and testsConfigured.

Referenced by enableTests(), and testsReady().

                                                                 {
  QCriterion * qc1;
  if (! bei->getQCriterion(testName)) {
    testsConfigured.push_back(testName);
    qc1 = bei->createQTest(Comp2RefKolmogorov::getAlgoName(), testName);
  } else {
    qc1 = bei->getQCriterion(testName);
  }
  Comp2RefKolmogorov * me_qc1 = (Comp2RefKolmogorov *) qc1;
  double warning = atof(findOrDefault(params, "warning", "0"));
  double error   = atof(findOrDefault(params, "error", "0"));
  me_qc1->setWarningProb(warning);
  me_qc1->setErrorProb(error);
}

void QTestConfigure::EnableCompareLastFilledBinTest ( std::string  testName, const std::map< std::string, std::string > &  params, DQMStore *  bei  )

private

Creates EnableCompareLastFilledBinTest test.

Definition at line 402 of file QTestConfigure.cc.

References DQMStore::createQTest(), relativeConstraints::error, findOrDefault(), CompareLastFilledBin::getAlgoName(), DQMStore::getQCriterion(), CompareLastFilledBin::setAverage(), QCriterion::setErrorProb(), CompareLastFilledBin::setMax(), CompareLastFilledBin::setMin(), QCriterion::setWarningProb(), and testsConfigured.

Referenced by enableTests(), and testsReady().

                                                                   {
  QCriterion * qc1;
  if (! bei->getQCriterion(testName)) {
    testsConfigured.push_back(testName);
    qc1 = bei->createQTest(CompareLastFilledBin::getAlgoName(), testName);
  } else {
    qc1 = bei->getQCriterion(testName);
  }
  CompareLastFilledBin * me_qc1 = (CompareLastFilledBin *) qc1;

  double warning = atof(findOrDefault(params, "warning", "0"));
  double error   = atof(findOrDefault(params, "error", "0"));
  double avVal   = atof(findOrDefault(params, "AvVal", "0"));
  double minVal  = atof(findOrDefault(params, "MinVal", "0"));
  double maxVal  = atof(findOrDefault(params, "MaxVal", "0"));
  me_qc1->setWarningProb(warning);
  me_qc1->setErrorProb(error);
  me_qc1->setAverage(avVal);
  me_qc1->setMin(minVal);
  me_qc1->setMax(maxVal);
}

void QTestConfigure::EnableCompareToMedianTest ( std::string  testName, const std::map< std::string, std::string > &  params, DQMStore *  bei  )

private

Creates ContentsWithinRangeROOT test.

Creates CompareToMedian test

Definition at line 314 of file QTestConfigure.cc.

References DQMStore::createQTest(), findOrDefault(), CompareToMedian::getAlgoName(), DQMStore::getQCriterion(), CompareToMedian::setEmptyBins(), QCriterion::setErrorProb(), CompareToMedian::setMax(), CompareToMedian::setMaxMedian(), CompareToMedian::setMin(), CompareToMedian::setMinMedian(), CompareToMedian::setStatCut(), QCriterion::setWarningProb(), and testsConfigured.

Referenced by enableTests(), and testsReady().

                                                              {
  QCriterion *qc1;
  if (! bei->getQCriterion(testName)) {
    testsConfigured.push_back(testName);
    qc1 = bei->createQTest(CompareToMedian::getAlgoName(), testName);
  } else {
    qc1 = bei->getQCriterion(testName);
  }
  CompareToMedian* vtm = (CompareToMedian*) qc1;
  vtm->setMin( (double) atof(findOrDefault(params, "MinRel", "0")));
  vtm->setMax( (double) atof(findOrDefault(params, "MaxRel", "0")));
  vtm->setEmptyBins( (int) atoi(findOrDefault(params, "UseEmptyBins", "0")));
  vtm->setMinMedian( (double) atof(findOrDefault(params, "MinAbs", "0")));
  vtm->setMaxMedian( (double) atof(findOrDefault(params, "MaxAbs", "0")));
  vtm->setWarningProb( (double) atof(findOrDefault(params, "warning", "0")));
  vtm->setErrorProb( (double) atof(findOrDefault(params, "error", "0")));
  vtm->setStatCut( (double) atof(findOrDefault(params, "StatCut", "0")));
}

void QTestConfigure::EnableContentSigmaTest ( std::string  testName, const std::map< std::string, std::string > &  params, DQMStore *  bei  )

private

Creates ContentSigmaROOT test.

Definition at line 225 of file QTestConfigure.cc.

References DQMStore::createQTest(), relativeConstraints::error, findOrDefault(), ContentSigma::getAlgoName(), DQMStore::getQCriterion(), createfilelist::int, ContentSigma::setDead(), QCriterion::setErrorProb(), ContentSigma::setNoisy(), ContentSigma::setNumNeighborsX(), ContentSigma::setNumNeighborsY(), ContentSigma::setNumXblocks(), ContentSigma::setNumYblocks(), ContentSigma::setToleranceDead(), ContentSigma::setToleranceNoisy(), QCriterion::setWarningProb(), ContentSigma::setXMax(), ContentSigma::setXMin(), ContentSigma::setYMax(), ContentSigma::setYMin(), testsConfigured, anotherprimaryvertexanalyzer_cfi::xMax, anotherprimaryvertexanalyzer_cfi::xMin, CMSBoostedTauSeedingParameters_cfi::yMax, and CMSBoostedTauSeedingParameters_cfi::yMin.

Referenced by enableTests(), and testsReady().

                                                           {
  QCriterion * qc1;
  if (! bei->getQCriterion(testName)) {
    testsConfigured.push_back(testName);
    qc1 = bei->createQTest(ContentSigma::getAlgoName(), testName);
  } else {
    qc1 = bei->getQCriterion(testName);
  }
  ContentSigma * me_qc1  = (ContentSigma *) qc1;
  unsigned int Xblocks = (unsigned int) atof(findOrDefault(params, "Xblocks", "0"));
  unsigned int Yblocks = (unsigned int) atof(findOrDefault(params, "Yblocks", "0"));
  unsigned int neighborsX = (unsigned int) atof(findOrDefault(params, "neighboursX", "0"));
  unsigned int neighborsY = (unsigned int) atof(findOrDefault(params, "neighboursY", "0"));
  double toleranceNoisy = atof(findOrDefault(params, "toleranceNoisy", "0"));
  double toleranceDead = atof(findOrDefault(params, "toleranceDead", "0"));
  int noisy = atoi(findOrDefault(params, "noisy", "0"));
  int dead = atoi(findOrDefault(params, "dead", "0"));
  unsigned int xMin = (unsigned int) atof(findOrDefault(params, "xMin", "1"));
  unsigned int xMax = (unsigned int) atof(findOrDefault(params, "xMax", "500"));
  unsigned int yMin = (unsigned int) atof(findOrDefault(params, "yMin", "1"));
  unsigned int yMax = (unsigned int) atof(findOrDefault(params, "yMax", "500")); 
  double warning = atof(findOrDefault(params, "warning", "0"));
  double error = atof(findOrDefault(params, "error", "0"));
  me_qc1->setNumXblocks (Xblocks);
  me_qc1->setNumYblocks (Yblocks);
  me_qc1->setNumNeighborsX (neighborsX);
  me_qc1->setNumNeighborsY (neighborsY);
  me_qc1->setToleranceNoisy (toleranceNoisy);
  me_qc1->setToleranceDead (toleranceDead);
  me_qc1->setNoisy (noisy);
  me_qc1->setDead (dead);
  me_qc1->setXMin (xMin);
  me_qc1->setXMax (xMax);
  me_qc1->setYMin (yMin);
  me_qc1->setYMax (yMax); 
  me_qc1->setWarningProb(warning);
  me_qc1->setErrorProb(error);
}

void QTestConfigure::EnableContentsWithinExpectedTest ( std::string  testName, const std::map< std::string, std::string > &  params, DQMStore *  bei  )

private

Creates ContentsWithinRangeROOT test.

Definition at line 365 of file QTestConfigure.cc.

References DQMStore::createQTest(), relativeConstraints::error, findOrDefault(), ContentsWithinExpected::getAlgoName(), DQMStore::getQCriterion(), createfilelist::int, QCriterion::setErrorProb(), ContentsWithinExpected::setMeanRange(), ContentsWithinExpected::setMeanTolerance(), SimpleTest::setMinimumEntries(), ContentsWithinExpected::setRMSRange(), ContentsWithinExpected::setUseEmptyBins(), QCriterion::setWarningProb(), and testsConfigured.

Referenced by enableTests(), and testsReady().

                                                                     {
  QCriterion * qc1;
  if (! bei->getQCriterion(testName)) {
    testsConfigured.push_back(testName);
    qc1 = bei->createQTest(ContentsWithinExpected::getAlgoName(), testName);
  } else {
    qc1 = bei->getQCriterion(testName);
  }
  ContentsWithinExpected * me_qc1 = (ContentsWithinExpected *) qc1;
  unsigned int useEmptyBins = (unsigned int) atof(findOrDefault(params, "useEmptyBins", "0"));
  double warning       = atof(findOrDefault(params, "warning", "0"));
  double error         = atof(findOrDefault(params, "error", "0"));
  double minMean       = atof(findOrDefault(params, "minMean", "0"));
  double maxMean       = atof(findOrDefault(params, "maxMean", "0"));
  double minRMS        = atof(findOrDefault(params, "minRMS", "0"));
  double maxRMS        = atof(findOrDefault(params, "maxRMS", "0"));
  double toleranceMean = atof(findOrDefault(params, "toleranceMean", "0"));
  int minEntries       = atoi(findOrDefault(params, "minEntries", "0"));
  me_qc1->setUseEmptyBins(useEmptyBins);
  me_qc1->setWarningProb(warning);
  me_qc1->setErrorProb(error);

  if ( minMean != 0 || maxMean != 0 )
    me_qc1->setMeanRange(minMean, maxMean);

  if ( minRMS != 0 || maxRMS != 0 )
    me_qc1->setRMSRange(minRMS, maxRMS);

  if ( toleranceMean != 0 )
    me_qc1->setMeanTolerance(toleranceMean);

  if ( minEntries != 0 )
    me_qc1->setMinimumEntries(minEntries);
}

void QTestConfigure::EnableDeadChannelTest ( std::string  testName, const std::map< std::string, std::string > &  params, DQMStore *  bei  )

private

Creates ContentsYRangeASROOT test.

Creates DeadChannelROOT test

Definition at line 184 of file QTestConfigure.cc.

References DQMStore::createQTest(), relativeConstraints::error, findOrDefault(), DeadChannel::getAlgoName(), DQMStore::getQCriterion(), createfilelist::int, QCriterion::setErrorProb(), DeadChannel::setThreshold(), QCriterion::setWarningProb(), testsConfigured, and electronIdCutBased_cfi::threshold.

Referenced by enableTests(), and testsReady().

                                                          {
  QCriterion * qc1;
  if (! bei->getQCriterion(testName)) {
    testsConfigured.push_back(testName);
    qc1 = bei->createQTest(DeadChannel::getAlgoName(), testName);
  } else {
    qc1 = bei->getQCriterion(testName);
  }
  DeadChannel * me_qc1 = ( DeadChannel *) qc1;
  unsigned int threshold =(unsigned int) atof(findOrDefault(params, "threshold", "0"));
  double warning = atof(findOrDefault(params, "warning", "0"));
  double error   = atof(findOrDefault(params, "error", "0"));
  me_qc1->setThreshold(threshold);
  me_qc1->setWarningProb(warning);
  me_qc1->setErrorProb(error);
}

void QTestConfigure::EnableMeanWithinExpectedTest ( std::string  testName, const std::map< std::string, std::string > &  params, DQMStore *  bei  )

private

Creates MeanWithinExpectedROOT test.

Definition at line 268 of file QTestConfigure.cc.

References DQMStore::createQTest(), relativeConstraints::error, findOrDefault(), MeanWithinExpected::getAlgoName(), DQMStore::getQCriterion(), SiStripPI::mean, QCriterion::setErrorProb(), MeanWithinExpected::setExpectedMean(), SimpleTest::setMinimumEntries(), QCriterion::setWarningProb(), testsConfigured, MeanWithinExpected::useRange(), MeanWithinExpected::useRMS(), MeanWithinExpected::useSigma(), TrackerOfflineValidation_Dqm_cff::xmax, and TrackerOfflineValidation_Dqm_cff::xmin.

Referenced by enableTests(), and testsReady().

                                                                 {
  QCriterion * qc1;
  if (! bei->getQCriterion(testName)) {
    testsConfigured.push_back(testName);
    qc1 = bei->createQTest(MeanWithinExpected::getAlgoName(), testName);
  } else {
    qc1 = bei->getQCriterion(testName);
  }
  MeanWithinExpected * me_qc1 = (MeanWithinExpected *) qc1;
  double warning     = atof(findOrDefault(params, "warning", "0"));
  double error       = atof(findOrDefault(params, "error", "0"));
  double mean        = atof(findOrDefault(params, "mean", "0"));
  int minEntries     = atoi(findOrDefault(params, "minEntries", "0"));
  double useRMSVal   = atof(findOrDefault(params, "useRMS", "0"));
  double useSigmaVal = atof(findOrDefault(params, "useSigma", "0"));
  double useRangeVal = atof(findOrDefault(params, "useRange", "0"));
  me_qc1->setWarningProb(warning);
  me_qc1->setErrorProb(error);
  me_qc1->setExpectedMean(mean);

  if (minEntries != 0)
    me_qc1->setMinimumEntries(minEntries);

  if (useRMSVal && useSigmaVal && useRangeVal)
    return;

  if (useRMSVal) {
    me_qc1->useRMS();
    return;
  }

  if (useSigmaVal) {
    me_qc1->useSigma(useSigmaVal);
    return;
  }

  if(useRangeVal) {
    float xmin = atof(findOrDefault(params, "xmin", "0"));
    float xmax = atof(findOrDefault(params, "xmax", "0"));
    me_qc1->useRange(xmin,xmax);
    return;
  }
}

void QTestConfigure::EnableNoisyChannelTest ( std::string  testName, const std::map< std::string, std::string > &  params, DQMStore *  bei  )

private

Creates NoisyChannelROOT test.

Definition at line 203 of file QTestConfigure.cc.

References DQMStore::createQTest(), relativeConstraints::error, findOrDefault(), NoisyChannel::getAlgoName(), DQMStore::getQCriterion(), createfilelist::int, QCriterion::setErrorProb(), NoisyChannel::setNumNeighbors(), NoisyChannel::setTolerance(), QCriterion::setWarningProb(), testsConfigured, and tolerance.

Referenced by enableTests(), and testsReady().

                                                           {
  QCriterion * qc1;
  if (! bei->getQCriterion(testName)) {
    testsConfigured.push_back(testName);
    qc1 = bei->createQTest(NoisyChannel::getAlgoName(), testName);
  } else {
    qc1 = bei->getQCriterion(testName);
  }
  NoisyChannel * me_qc1  = (NoisyChannel *) qc1;
  unsigned int neighbors = (unsigned int) atof(findOrDefault(params, "neighbours", "0"));
  double tolerance = atof(findOrDefault(params, "tolerance", "0"));
  double warning   = atof(findOrDefault(params, "warning", "0"));
  double error     = atof(findOrDefault(params, "error", "0"));
  me_qc1->setNumNeighbors (neighbors);
  me_qc1->setTolerance (tolerance);
  me_qc1->setWarningProb(warning);
  me_qc1->setErrorProb(error);
}

bool QTestConfigure::enableTests	(	const std::map< std::string, std::map< std::string, std::string > > &	tests,
		DQMStore *	bei
	)

Creates and defines quality tests.

Definition at line 28 of file QTestConfigure.cc.

References EnableCheckVarianceTest(), EnableComp2Ref2DChi2Test(), EnableComp2RefChi2Test(), EnableComp2RefEqualHTest(), EnableComp2RefKolmogorovTest(), EnableCompareLastFilledBinTest(), EnableCompareToMedianTest(), EnableContentSigmaTest(), EnableContentsWithinExpectedTest(), EnableDeadChannelTest(), EnableMeanWithinExpectedTest(), EnableNoisyChannelTest(), EnableXRangeTest(), EnableYRangeTest(), Comp2RefEqualH::getAlgoName(), Comp2RefChi2::getAlgoName(), Comp2Ref2DChi2::getAlgoName(), Comp2RefKolmogorov::getAlgoName(), ContentsXRange::getAlgoName(), ContentsYRange::getAlgoName(), DeadChannel::getAlgoName(), NoisyChannel::getAlgoName(), ContentSigma::getAlgoName(), ContentsWithinExpected::getAlgoName(), MeanWithinExpected::getAlgoName(), CompareToMedian::getAlgoName(), CompareLastFilledBin::getAlgoName(), CheckVariance::getAlgoName(), AlCaHLTBitMon_QueryRunRegistry::string, utils_v2::tests, and testsConfigured.

Referenced by QTestHandle::configureTests(), and ~QTestConfigure().

                    {
  testsConfigured.clear();
  std::map<std::string, std::map<std::string, std::string> >::const_iterator itr;
  for (itr = tests.begin(); itr!= tests.end();++itr) {
    const std::map<std::string, std::string> &params= itr->second;

    std::string testName = itr->first;
    std::string testType = params.at("type");

    if(!std::strcmp(testType.c_str(),ContentsXRange::getAlgoName().c_str()))
      this->EnableXRangeTest(testName, params,bei);
    if(!std::strcmp(testType.c_str(),ContentsYRange::getAlgoName().c_str()))
      this->EnableYRangeTest(testName, params,bei);
    if(!std::strcmp(testType.c_str(),DeadChannel::getAlgoName().c_str()))
      this->EnableDeadChannelTest(testName, params,bei);
    if(!std::strcmp(testType.c_str(),NoisyChannel::getAlgoName().c_str()))
      this->EnableNoisyChannelTest(testName, params,bei);
    if(!std::strcmp(testType.c_str(),ContentSigma::getAlgoName().c_str()))
      this->EnableContentSigmaTest(testName, params,bei); 
    if(!std::strcmp(testType.c_str(),MeanWithinExpected::getAlgoName().c_str()))
      this->EnableMeanWithinExpectedTest(testName, params,bei);
    if(!std::strcmp(testType.c_str(),Comp2RefEqualH::getAlgoName().c_str()))
      this->EnableComp2RefEqualHTest(testName, params,bei);
    if(!std::strcmp(testType.c_str(),  Comp2RefChi2::getAlgoName().c_str()))
      this->EnableComp2RefChi2Test(testName, params,bei);
    if(!std::strcmp(testType.c_str(),  Comp2Ref2DChi2::getAlgoName().c_str()))
      this->EnableComp2Ref2DChi2Test(testName, params,bei);
    if(!std::strcmp(testType.c_str(),Comp2RefKolmogorov::getAlgoName().c_str()))
      this->EnableComp2RefKolmogorovTest(testName, params,bei);
    if(!std::strcmp(testType.c_str(),ContentsWithinExpected::getAlgoName().c_str()))
      this->EnableContentsWithinExpectedTest(testName, params, bei);
    if(!std::strcmp(testType.c_str(),CompareToMedian::getAlgoName().c_str()))
      this->EnableCompareToMedianTest(testName, params, bei);
    if(!std::strcmp(testType.c_str(),CompareLastFilledBin::getAlgoName().c_str()))
      this->EnableCompareLastFilledBinTest(testName, params, bei);
    if(!std::strcmp(testType.c_str(),CheckVariance::getAlgoName().c_str()))
      this->EnableCheckVarianceTest(testName, params, bei);
  }
  return false;
}

void QTestConfigure::EnableXRangeTest ( std::string  testName, const std::map< std::string, std::string > &  params, DQMStore *  bei  )

private

Creates ContentsXRangeROOT test.

Definition at line 142 of file QTestConfigure.cc.

References DQMStore::createQTest(), relativeConstraints::error, findOrDefault(), ContentsXRange::getAlgoName(), DQMStore::getQCriterion(), ContentsXRange::setAllowedXRange(), QCriterion::setErrorProb(), QCriterion::setWarningProb(), testsConfigured, TrackerOfflineValidation_Dqm_cff::xmax, and TrackerOfflineValidation_Dqm_cff::xmin.

Referenced by enableTests(), and testsReady().

                                                     {
  QCriterion * qc1;
  if (! bei->getQCriterion(testName)) {
    testsConfigured.push_back(testName);
    qc1 = bei->createQTest(ContentsXRange::getAlgoName(),testName);
  } else {
    qc1 = bei->getQCriterion(testName);
  }
  ContentsXRange * me_qc1 = (ContentsXRange *) qc1;
  double xmin    = atof(findOrDefault(params, "xmin", "0"));
  double xmax    = atof(findOrDefault(params, "xmax", "0"));
  double warning = atof(findOrDefault(params, "warning", "0"));
  double error   = atof(findOrDefault(params, "error", "0"));
  me_qc1->setAllowedXRange(xmin, xmax);
  me_qc1->setWarningProb(warning);
  me_qc1->setErrorProb(error);
}

void QTestConfigure::EnableYRangeTest ( std::string  testName, const std::map< std::string, std::string > &  params, DQMStore *  bei  )

private

Creates ContentsXRangeASROOT test.

Creates ContentsYRangeROOT test

Definition at line 162 of file QTestConfigure.cc.

References DQMStore::createQTest(), relativeConstraints::error, findOrDefault(), ContentsYRange::getAlgoName(), DQMStore::getQCriterion(), createfilelist::int, ContentsYRange::setAllowedYRange(), QCriterion::setErrorProb(), ContentsYRange::setUseEmptyBins(), QCriterion::setWarningProb(), testsConfigured, Phase2TrackerMonitorDigi_cff::ymax, and Phase2TrackerMonitorDigi_cff::ymin.

Referenced by enableTests(), and testsReady().

                                                     {
  QCriterion * qc1;
  if (! bei->getQCriterion(testName)) {
    testsConfigured.push_back(testName);
    qc1 = bei->createQTest(ContentsYRange::getAlgoName(), testName);
  } else {
    qc1 = bei->getQCriterion(testName);
  }
  ContentsYRange * me_qc1 = (ContentsYRange *) qc1;
  double ymin    = atof(findOrDefault(params, "ymin", "0"));
  double ymax    = atof(findOrDefault(params, "ymax", "0"));
  double warning = atof(findOrDefault(params, "warning", "0"));
  double error   = atof(findOrDefault(params, "error", "0"));
  unsigned int useEmptyBins = (unsigned int)atof(findOrDefault(params, "useEmptyBins", "0"));
  me_qc1->setAllowedYRange(ymin, ymax);
  me_qc1->setWarningProb(warning);
  me_qc1->setErrorProb(error);
  me_qc1->setUseEmptyBins(useEmptyBins);
}

const char * QTestConfigure::findOrDefault ( const std::map< std::string, std::string > &  m, const char *  item, const char *  default_value  ) const

private

Definition at line 15 of file QTestConfigure.cc.

References LogDebug, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by EnableCheckVarianceTest(), EnableComp2Ref2DChi2Test(), EnableComp2RefChi2Test(), EnableComp2RefEqualHTest(), EnableComp2RefKolmogorovTest(), EnableCompareLastFilledBinTest(), EnableCompareToMedianTest(), EnableContentSigmaTest(), EnableContentsWithinExpectedTest(), EnableDeadChannelTest(), EnableMeanWithinExpectedTest(), EnableNoisyChannelTest(), EnableXRangeTest(), EnableYRangeTest(), and testsReady().

                                                                             {
  std::map<std::string, std::string>::const_iterator iter;
  if (( iter = m.find(std::string(item))) != m.end()) {
    return (*iter).second.c_str();
  }
  LogDebug("QTestConfigure") << "Warning, using default value for parameter "
                 << item << " with default_value: "
                 << default_value << std::endl;
  return default_value;
}

std::vector<std::string> QTestConfigure::testsReady ( )

inline

Returns the vector containing the names of the quality tests that have been created.

Definition at line 33 of file QTestConfigure.h.

References EnableCheckVarianceTest(), EnableComp2Ref2DChi2Test(), EnableComp2RefChi2Test(), EnableComp2RefEqualHTest(), EnableComp2RefKolmogorovTest(), EnableCompareLastFilledBinTest(), EnableCompareToMedianTest(), EnableContentSigmaTest(), EnableContentsWithinExpectedTest(), EnableDeadChannelTest(), EnableMeanWithinExpectedTest(), EnableNoisyChannelTest(), EnableXRangeTest(), EnableYRangeTest(), findOrDefault(), AlCaHLTBitMon_QueryRunRegistry::string, and testsConfigured.

{return testsConfigured;}

Member Data Documentation

std::vector<std::string> QTestConfigure::testsConfigured

private

Definition at line 110 of file QTestConfigure.h.

Referenced by EnableCheckVarianceTest(), EnableComp2Ref2DChi2Test(), EnableComp2RefChi2Test(), EnableComp2RefEqualHTest(), EnableComp2RefKolmogorovTest(), EnableCompareLastFilledBinTest(), EnableCompareToMedianTest(), EnableContentSigmaTest(), EnableContentsWithinExpectedTest(), EnableDeadChannelTest(), EnableMeanWithinExpectedTest(), EnableNoisyChannelTest(), enableTests(), EnableXRangeTest(), EnableYRangeTest(), and testsReady().