QTestConfigure Class Reference

#include <QTestConfigure.h>

Public Types
typedef dqm::harvesting::DQMStore	DQMStore
typedef dqm::harvesting::MonitorElement	MonitorElement

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	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 19 of file QTestConfigure.h.

Member Typedef Documentation

typedef dqm::harvesting::DQMStore QTestConfigure::DQMStore

Definition at line 21 of file QTestConfigure.h.

typedef dqm::harvesting::MonitorElement QTestConfigure::MonitorElement

Definition at line 22 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 343 of file QTestConfigure.cc.

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

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::EnableCompareLastFilledBinTest ( std::string  testName, const std::map< std::string, std::string > &  params, DQMStore *  bei  )

private

Creates EnableCompareLastFilledBinTest test.

Definition at line 320 of file QTestConfigure.cc.

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

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 232 of file QTestConfigure.cc.

References dqm::dqmstoreimpl::DQMStore::createQTest(), findOrDefault(), CompareToMedian::getAlgoName(), dqm::dqmstoreimpl::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 143 of file QTestConfigure.cc.

References dqm::dqmstoreimpl::DQMStore::createQTest(), relativeConstraints::error, findOrDefault(), ContentSigma::getAlgoName(), dqm::dqmstoreimpl::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, MessageLogger_cfi::warning, multiplicitycorr_cfi::xMax, photonAnalyzer_cfi::xMin, multiplicitycorr_cfi::yMax, and photonAnalyzer_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 283 of file QTestConfigure.cc.

References dqm::dqmstoreimpl::DQMStore::createQTest(), relativeConstraints::error, findOrDefault(), ContentsWithinExpected::getAlgoName(), dqm::dqmstoreimpl::DQMStore::getQCriterion(), createfilelist::int, dtFineDelayCorr_cfi::minEntries, QCriterion::setErrorProb(), ContentsWithinExpected::setMeanRange(), ContentsWithinExpected::setMeanTolerance(), SimpleTest::setMinimumEntries(), ContentsWithinExpected::setRMSRange(), ContentsWithinExpected::setUseEmptyBins(), QCriterion::setWarningProb(), testsConfigured, PedestalClient_cfi::toleranceMean, and MessageLogger_cfi::warning.

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 102 of file QTestConfigure.cc.

References dqm::dqmstoreimpl::DQMStore::createQTest(), relativeConstraints::error, findOrDefault(), DeadChannel::getAlgoName(), dqm::dqmstoreimpl::DQMStore::getQCriterion(), createfilelist::int, QCriterion::setErrorProb(), DeadChannel::setThreshold(), QCriterion::setWarningProb(), testsConfigured, MessageLogger_cff::threshold, and MessageLogger_cfi::warning.

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 186 of file QTestConfigure.cc.

References dqm::dqmstoreimpl::DQMStore::createQTest(), relativeConstraints::error, findOrDefault(), MeanWithinExpected::getAlgoName(), dqm::dqmstoreimpl::DQMStore::getQCriterion(), SiStripPI::mean, dtFineDelayCorr_cfi::minEntries, QCriterion::setErrorProb(), MeanWithinExpected::setExpectedMean(), SimpleTest::setMinimumEntries(), QCriterion::setWarningProb(), testsConfigured, MeanWithinExpected::useRange(), MeanWithinExpected::useRMS(), MeanWithinExpected::useSigma(), MessageLogger_cfi::warning, 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 121 of file QTestConfigure.cc.

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

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 26 of file QTestConfigure.cc.

References EnableCheckVarianceTest(), EnableCompareLastFilledBinTest(), EnableCompareToMedianTest(), EnableContentSigmaTest(), EnableContentsWithinExpectedTest(), EnableDeadChannelTest(), EnableMeanWithinExpectedTest(), EnableNoisyChannelTest(), EnableXRangeTest(), EnableYRangeTest(), ContentsXRange::getAlgoName(), ContentsYRange::getAlgoName(), DeadChannel::getAlgoName(), NoisyChannel::getAlgoName(), ContentSigma::getAlgoName(), ContentsWithinExpected::getAlgoName(), MeanWithinExpected::getAlgoName(), CompareToMedian::getAlgoName(), CompareLastFilledBin::getAlgoName(), CheckVariance::getAlgoName(), CalibrationSummaryClient_cfi::params, AlCaHLTBitMon_QueryRunRegistry::string, L1TBPTX_cfi::testName, 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(), 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 60 of file QTestConfigure.cc.

References dqm::dqmstoreimpl::DQMStore::createQTest(), relativeConstraints::error, findOrDefault(), ContentsXRange::getAlgoName(), dqm::dqmstoreimpl::DQMStore::getQCriterion(), ContentsXRange::setAllowedXRange(), QCriterion::setErrorProb(), QCriterion::setWarningProb(), testsConfigured, MessageLogger_cfi::warning, 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 80 of file QTestConfigure.cc.

References dqm::dqmstoreimpl::DQMStore::createQTest(), relativeConstraints::error, findOrDefault(), ContentsYRange::getAlgoName(), dqm::dqmstoreimpl::DQMStore::getQCriterion(), createfilelist::int, ContentsYRange::setAllowedYRange(), QCriterion::setErrorProb(), ContentsYRange::setUseEmptyBins(), QCriterion::setWarningProb(), testsConfigured, MessageLogger_cfi::warning, L1TOccupancyClient_cfi::ymax, and L1TOccupancyClient_cfi::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 14 of file QTestConfigure.cc.

References LogDebug, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by EnableCheckVarianceTest(), 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(), EnableCompareLastFilledBinTest(), EnableCompareToMedianTest(), EnableContentSigmaTest(), EnableContentsWithinExpectedTest(), EnableDeadChannelTest(), EnableMeanWithinExpectedTest(), EnableNoisyChannelTest(), EnableXRangeTest(), EnableYRangeTest(), findOrDefault(), CalibrationSummaryClient_cfi::params, AlCaHLTBitMon_QueryRunRegistry::string, L1TBPTX_cfi::testName, and testsConfigured.

{ return testsConfigured; }

Member Data Documentation

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

private

Definition at line 81 of file QTestConfigure.h.

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