CMS 3D CMS Logo
QTestConfigure.cc
Go to the documentation of this file.
1 
7 #include "FWCore/MessageLogger/interface/MessageLogger.h"
8 #include "DQMServices/ClientConfig/interface/QTestConfigure.h"
9 #include "DQMServices/Core/interface/QTest.h"
10 #include "DQMServices/Core/interface/DQMStore.h"
11 #include <cstring>
12 #include <cstdlib>
13 
14 
15 const char * QTestConfigure::findOrDefault(const std::map<std::string, std::string> &m,
16  const char * item,
17  const char * default_value) const {
18  std::map<std::string, std::string>::const_iterator iter;
19  if (( iter = m.find(std::string(item))) != m.end()) {
20  return (*iter).second.c_str();
21  }
22  LogDebug("QTestConfigure") << "Warning, using default value for parameter "
23  << item << " with default_value: "
24  << default_value << std::endl;
25  return default_value;
26 }
27 
28 bool QTestConfigure::enableTests(
29  const std::map<std::string, std::map<std::string, std::string> > & tests,
30  DQMStore * bei) {
31  testsConfigured.clear();
32  std::map<std::string, std::map<std::string, std::string> >::const_iterator itr;
33  for (itr = tests.begin(); itr!= tests.end();++itr) {
34  const std::map<std::string, std::string> &params= itr->second;
35 
36  std::string testName = itr->first;
37  std::string testType = params.at("type");
38 
39  if(!std::strcmp(testType.c_str(),ContentsXRange::getAlgoName().c_str()))
40  this->EnableXRangeTest(testName, params,bei);
41  if(!std::strcmp(testType.c_str(),ContentsYRange::getAlgoName().c_str()))
42  this->EnableYRangeTest(testName, params,bei);
43  if(!std::strcmp(testType.c_str(),DeadChannel::getAlgoName().c_str()))
44  this->EnableDeadChannelTest(testName, params,bei);
45  if(!std::strcmp(testType.c_str(),NoisyChannel::getAlgoName().c_str()))
46  this->EnableNoisyChannelTest(testName, params,bei);
47  if(!std::strcmp(testType.c_str(),ContentSigma::getAlgoName().c_str()))
48  this->EnableContentSigmaTest(testName, params,bei);
49  if(!std::strcmp(testType.c_str(),MeanWithinExpected::getAlgoName().c_str()))
50  this->EnableMeanWithinExpectedTest(testName, params,bei);
51  if(!std::strcmp(testType.c_str(),Comp2RefEqualH::getAlgoName().c_str()))
52  this->EnableComp2RefEqualHTest(testName, params,bei);
53  if(!std::strcmp(testType.c_str(), Comp2RefChi2::getAlgoName().c_str()))
54  this->EnableComp2RefChi2Test(testName, params,bei);
55  if(!std::strcmp(testType.c_str(), Comp2Ref2DChi2::getAlgoName().c_str()))
56  this->EnableComp2Ref2DChi2Test(testName, params,bei);
57  if(!std::strcmp(testType.c_str(),Comp2RefKolmogorov::getAlgoName().c_str()))
58  this->EnableComp2RefKolmogorovTest(testName, params,bei);
59  if(!std::strcmp(testType.c_str(),ContentsWithinExpected::getAlgoName().c_str()))
60  this->EnableContentsWithinExpectedTest(testName, params, bei);
61  if(!std::strcmp(testType.c_str(),CompareToMedian::getAlgoName().c_str()))
62  this->EnableCompareToMedianTest(testName, params, bei);
63  if(!std::strcmp(testType.c_str(),CompareLastFilledBin::getAlgoName().c_str()))
64  this->EnableCompareLastFilledBinTest(testName, params, bei);
65  if(!std::strcmp(testType.c_str(),CheckVariance::getAlgoName().c_str()))
66  this->EnableCheckVarianceTest(testName, params, bei);
67  }
68  return false;
69 }
70 
71 void QTestConfigure::EnableComp2RefEqualHTest(std::string testName,
72  const std::map<std::string, std::string> & params,
73  DQMStore *bei) {
74  QCriterion * qc1;
75  if (! bei->getQCriterion(testName)) {
76  testsConfigured.push_back(testName);
77  qc1 = bei->createQTest(Comp2RefEqualH::getAlgoName(), testName);
78  } else {
79  qc1 = bei->getQCriterion(testName);
80  }
81  Comp2RefEqualH * me_qc1 = (Comp2RefEqualH *) qc1;
82  double warning = atof(findOrDefault(params, "warning", "0"));
83  double error = atof(findOrDefault(params, "error", "0"));
84  me_qc1->setWarningProb(warning);
85  me_qc1->setErrorProb(error);
86 }
87 
88 void QTestConfigure::EnableComp2RefChi2Test(std::string testName,
89  const std::map<std::string, std::string> & params,
90  DQMStore *bei) {
91  QCriterion * qc1;
92  if (! bei->getQCriterion(testName)) {
93  testsConfigured.push_back(testName);
94  qc1 = bei->createQTest(Comp2RefChi2::getAlgoName(), testName);
95  } else {
96  qc1 = bei->getQCriterion(testName);
97  }
98  Comp2RefChi2 * me_qc1 = (Comp2RefChi2 *) qc1;
99  double warning = atof(findOrDefault(params, "warning", "0"));
100  double error = atof(findOrDefault(params, "error", "0"));
101  me_qc1->setWarningProb(warning);
102  me_qc1->setErrorProb(error);
103 }
104 
105 void QTestConfigure::EnableComp2Ref2DChi2Test(std::string testName,
106  const std::map<std::string, std::string> & params,
107  DQMStore *bei) {
108  QCriterion * qc1;
109  if (! bei->getQCriterion(testName)) {
110  testsConfigured.push_back(testName);
111  qc1 = bei->createQTest(Comp2Ref2DChi2::getAlgoName(), testName);
112  } else {
113  qc1 = bei->getQCriterion(testName);
114  }
115  Comp2Ref2DChi2 * me_qc1 = (Comp2Ref2DChi2 *) qc1;
116  double warning = atof(findOrDefault(params, "warning", "0"));
117  double error = atof(findOrDefault(params, "error", "0"));
118  int minEntries = atoi(findOrDefault(params, "minEntries", "0"));
119  me_qc1->setWarningProb(warning);
120  me_qc1->setErrorProb(error);
121  if ( minEntries != 0 )
122  me_qc1->setMinimumEntries(minEntries);
123 }
124 
125 void QTestConfigure::EnableComp2RefKolmogorovTest(std::string testName,
126  const std::map<std::string, std::string> & params,
127  DQMStore *bei) {
128  QCriterion * qc1;
129  if (! bei->getQCriterion(testName)) {
130  testsConfigured.push_back(testName);
131  qc1 = bei->createQTest(Comp2RefKolmogorov::getAlgoName(), testName);
132  } else {
133  qc1 = bei->getQCriterion(testName);
134  }
135  Comp2RefKolmogorov * me_qc1 = (Comp2RefKolmogorov *) qc1;
136  double warning = atof(findOrDefault(params, "warning", "0"));
137  double error = atof(findOrDefault(params, "error", "0"));
138  me_qc1->setWarningProb(warning);
139  me_qc1->setErrorProb(error);
140 }
141 
142 void QTestConfigure::EnableXRangeTest(std::string testName,
143  const std::map<std::string, std::string> & params,
144  DQMStore *bei) {
145  QCriterion * qc1;
146  if (! bei->getQCriterion(testName)) {
147  testsConfigured.push_back(testName);
148  qc1 = bei->createQTest(ContentsXRange::getAlgoName(),testName);
149  } else {
150  qc1 = bei->getQCriterion(testName);
151  }
152  ContentsXRange * me_qc1 = (ContentsXRange *) qc1;
153  double xmin = atof(findOrDefault(params, "xmin", "0"));
154  double xmax = atof(findOrDefault(params, "xmax", "0"));
155  double warning = atof(findOrDefault(params, "warning", "0"));
156  double error = atof(findOrDefault(params, "error", "0"));
157  me_qc1->setAllowedXRange(xmin, xmax);
158  me_qc1->setWarningProb(warning);
159  me_qc1->setErrorProb(error);
160 }
161 
162 void QTestConfigure::EnableYRangeTest(std::string testName,
163  const std::map<std::string, std::string> & params,
164  DQMStore *bei) {
165  QCriterion * qc1;
166  if (! bei->getQCriterion(testName)) {
167  testsConfigured.push_back(testName);
168  qc1 = bei->createQTest(ContentsYRange::getAlgoName(), testName);
169  } else {
170  qc1 = bei->getQCriterion(testName);
171  }
172  ContentsYRange * me_qc1 = (ContentsYRange *) qc1;
173  double ymin = atof(findOrDefault(params, "ymin", "0"));
174  double ymax = atof(findOrDefault(params, "ymax", "0"));
175  double warning = atof(findOrDefault(params, "warning", "0"));
176  double error = atof(findOrDefault(params, "error", "0"));
177  unsigned int useEmptyBins = (unsigned int)atof(findOrDefault(params, "useEmptyBins", "0"));
178  me_qc1->setAllowedYRange(ymin, ymax);
179  me_qc1->setWarningProb(warning);
180  me_qc1->setErrorProb(error);
181  me_qc1->setUseEmptyBins(useEmptyBins);
182 }
183 
184 void QTestConfigure::EnableDeadChannelTest(std::string testName,
185  const std::map<std::string, std::string> & params,
186  DQMStore *bei) {
187  QCriterion * qc1;
188  if (! bei->getQCriterion(testName)) {
189  testsConfigured.push_back(testName);
190  qc1 = bei->createQTest(DeadChannel::getAlgoName(), testName);
191  } else {
192  qc1 = bei->getQCriterion(testName);
193  }
194  DeadChannel * me_qc1 = ( DeadChannel *) qc1;
195  unsigned int threshold =(unsigned int) atof(findOrDefault(params, "threshold", "0"));
196  double warning = atof(findOrDefault(params, "warning", "0"));
197  double error = atof(findOrDefault(params, "error", "0"));
198  me_qc1->setThreshold(threshold);
199  me_qc1->setWarningProb(warning);
200  me_qc1->setErrorProb(error);
201 }
202 
203 void QTestConfigure::EnableNoisyChannelTest(std::string testName,
204  const std::map<std::string, std::string> & params,
205  DQMStore *bei) {
206  QCriterion * qc1;
207  if (! bei->getQCriterion(testName)) {
208  testsConfigured.push_back(testName);
209  qc1 = bei->createQTest(NoisyChannel::getAlgoName(), testName);
210  } else {
211  qc1 = bei->getQCriterion(testName);
212  }
213  NoisyChannel * me_qc1 = (NoisyChannel *) qc1;
214  unsigned int neighbors = (unsigned int) atof(findOrDefault(params, "neighbours", "0"));
215  double tolerance = atof(findOrDefault(params, "tolerance", "0"));
216  double warning = atof(findOrDefault(params, "warning", "0"));
217  double error = atof(findOrDefault(params, "error", "0"));
218  me_qc1->setNumNeighbors (neighbors);
219  me_qc1->setTolerance (tolerance);
220  me_qc1->setWarningProb(warning);
221  me_qc1->setErrorProb(error);
222 }
223 
224 //================ContentSigma (Emma Yeager and Chad Freer)=====================//
225 void QTestConfigure::EnableContentSigmaTest(std::string testName,
226  const std::map<std::string, std::string> & params,
227  DQMStore *bei) {
228  QCriterion * qc1;
229  if (! bei->getQCriterion(testName)) {
230  testsConfigured.push_back(testName);
231  qc1 = bei->createQTest(ContentSigma::getAlgoName(), testName);
232  } else {
233  qc1 = bei->getQCriterion(testName);
234  }
235  ContentSigma * me_qc1 = (ContentSigma *) qc1;
236  unsigned int Xblocks = (unsigned int) atof(findOrDefault(params, "Xblocks", "0"));
237  unsigned int Yblocks = (unsigned int) atof(findOrDefault(params, "Yblocks", "0"));
238  unsigned int neighborsX = (unsigned int) atof(findOrDefault(params, "neighboursX", "0"));
239  unsigned int neighborsY = (unsigned int) atof(findOrDefault(params, "neighboursY", "0"));
240  double toleranceNoisy = atof(findOrDefault(params, "toleranceNoisy", "0"));
241  double toleranceDead = atof(findOrDefault(params, "toleranceDead", "0"));
242  int noisy = atoi(findOrDefault(params, "noisy", "0"));
243  int dead = atoi(findOrDefault(params, "dead", "0"));
244  unsigned int xMin = (unsigned int) atof(findOrDefault(params, "xMin", "1"));
245  unsigned int xMax = (unsigned int) atof(findOrDefault(params, "xMax", "500"));
246  unsigned int yMin = (unsigned int) atof(findOrDefault(params, "yMin", "1"));
247  unsigned int yMax = (unsigned int) atof(findOrDefault(params, "yMax", "500"));
248  double warning = atof(findOrDefault(params, "warning", "0"));
249  double error = atof(findOrDefault(params, "error", "0"));
250  me_qc1->setNumXblocks (Xblocks);
251  me_qc1->setNumYblocks (Yblocks);
252  me_qc1->setNumNeighborsX (neighborsX);
253  me_qc1->setNumNeighborsY (neighborsY);
254  me_qc1->setToleranceNoisy (toleranceNoisy);
255  me_qc1->setToleranceDead (toleranceDead);
256  me_qc1->setNoisy (noisy);
257  me_qc1->setDead (dead);
258  me_qc1->setXMin (xMin);
259  me_qc1->setXMax (xMax);
260  me_qc1->setYMin (yMin);
261  me_qc1->setYMax (yMax);
262  me_qc1->setWarningProb(warning);
263  me_qc1->setErrorProb(error);
264 }
265 
266 //==========================================================================//
267 
268 void QTestConfigure::EnableMeanWithinExpectedTest(std::string testName,
269  const std::map<std::string, std::string> & params,
270  DQMStore *bei) {
271  QCriterion * qc1;
272  if (! bei->getQCriterion(testName)) {
273  testsConfigured.push_back(testName);
274  qc1 = bei->createQTest(MeanWithinExpected::getAlgoName(), testName);
275  } else {
276  qc1 = bei->getQCriterion(testName);
277  }
278  MeanWithinExpected * me_qc1 = (MeanWithinExpected *) qc1;
279  double warning = atof(findOrDefault(params, "warning", "0"));
280  double error = atof(findOrDefault(params, "error", "0"));
281  double mean = atof(findOrDefault(params, "mean", "0"));
282  int minEntries = atoi(findOrDefault(params, "minEntries", "0"));
283  double useRMSVal = atof(findOrDefault(params, "useRMS", "0"));
284  double useSigmaVal = atof(findOrDefault(params, "useSigma", "0"));
285  double useRangeVal = atof(findOrDefault(params, "useRange", "0"));
286  me_qc1->setWarningProb(warning);
287  me_qc1->setErrorProb(error);
288  me_qc1->setExpectedMean(mean);
289 
290  if (minEntries != 0)
291  me_qc1->setMinimumEntries(minEntries);
292 
293  if (useRMSVal && useSigmaVal && useRangeVal)
294  return;
295 
296  if (useRMSVal) {
297  me_qc1->useRMS();
298  return;
299  }
300 
301  if (useSigmaVal) {
302  me_qc1->useSigma(useSigmaVal);
303  return;
304  }
305 
306  if(useRangeVal) {
307  float xmin = atof(findOrDefault(params, "xmin", "0"));
308  float xmax = atof(findOrDefault(params, "xmax", "0"));
309  me_qc1->useRange(xmin,xmax);
310  return;
311  }
312 }
313 
314 void QTestConfigure::EnableCompareToMedianTest(std::string testName,
315  const std::map<std::string, std::string> & params,
316  DQMStore *bei) {
317  QCriterion *qc1;
318  if (! bei->getQCriterion(testName)) {
319  testsConfigured.push_back(testName);
320  qc1 = bei->createQTest(CompareToMedian::getAlgoName(), testName);
321  } else {
322  qc1 = bei->getQCriterion(testName);
323  }
324  CompareToMedian* vtm = (CompareToMedian*) qc1;
325  vtm->setMin( (double) atof(findOrDefault(params, "MinRel", "0")));
326  vtm->setMax( (double) atof(findOrDefault(params, "MaxRel", "0")));
327  vtm->setEmptyBins( (int) atoi(findOrDefault(params, "UseEmptyBins", "0")));
328  vtm->setMinMedian( (double) atof(findOrDefault(params, "MinAbs", "0")));
329  vtm->setMaxMedian( (double) atof(findOrDefault(params, "MaxAbs", "0")));
330  vtm->setWarningProb( (double) atof(findOrDefault(params, "warning", "0")));
331  vtm->setErrorProb( (double) atof(findOrDefault(params, "error", "0")));
332  vtm->setStatCut( (double) atof(findOrDefault(params, "StatCut", "0")));
333 }
334 
335 /*
336  void QTestConfigure::EnableMostProbableLandauTest(
337  const std::string &roTEST_NAME,
338  std::map<std::string, std::string> &roMParams,
339  DQMStore *bei) {
340 
341  // Create QTest or Get already assigned one
342  MostProbableLandau *poQTest = 0;
343  if( QCriterion *poQCriteration = bei->getQCriterion( roTEST_NAME)) {
344  // Current already assigned to given ME.
345  poQTest = dynamic_cast<MostProbableLandau *>( poQCriteration);
346  } else {
347  // Test does not exist: create one
348  testsConfigured.push_back( roTEST_NAME);
349  poQCriteration = bei->createQTest( MostProbableLandau::getAlgoName(),
350  roTEST_NAME);
351 
352  poQTest = dynamic_cast<MostProbableLandau *>( poQCriteration);
353  }
354 
355  // Set probabilities thresholds.
356  poQTest->setErrorProb ( atof( roMfindOrDefault(params, "error", "0") );
357  poQTest->setWarningProb ( atof( roMfindOrDefault(params, "warning", "0") );
358  poQTest->setXMin ( atof( roMfindOrDefault(params, "xmin", "0") );
359  poQTest->setXMax ( atof( roMfindOrDefault(params, "xmax", "0") );
360  poQTest->setNormalization( atof( roMfindOrDefault(params, "normalization", "0") );
361  poQTest->setMostProbable ( atof( roMfindOrDefault(params, "mostprobable", "0") );
362  poQTest->setSigma ( atof( roMfindOrDefault(params, "sigma", "0") );
363  }
364 */
365 void QTestConfigure::EnableContentsWithinExpectedTest(std::string testName,
366  const std::map<std::string, std::string> & params,
367  DQMStore *bei) {
368  QCriterion * qc1;
369  if (! bei->getQCriterion(testName)) {
370  testsConfigured.push_back(testName);
371  qc1 = bei->createQTest(ContentsWithinExpected::getAlgoName(), testName);
372  } else {
373  qc1 = bei->getQCriterion(testName);
374  }
375  ContentsWithinExpected * me_qc1 = (ContentsWithinExpected *) qc1;
376  unsigned int useEmptyBins = (unsigned int) atof(findOrDefault(params, "useEmptyBins", "0"));
377  double warning = atof(findOrDefault(params, "warning", "0"));
378  double error = atof(findOrDefault(params, "error", "0"));
379  double minMean = atof(findOrDefault(params, "minMean", "0"));
380  double maxMean = atof(findOrDefault(params, "maxMean", "0"));
381  double minRMS = atof(findOrDefault(params, "minRMS", "0"));
382  double maxRMS = atof(findOrDefault(params, "maxRMS", "0"));
383  double toleranceMean = atof(findOrDefault(params, "toleranceMean", "0"));
384  int minEntries = atoi(findOrDefault(params, "minEntries", "0"));
385  me_qc1->setUseEmptyBins(useEmptyBins);
386  me_qc1->setWarningProb(warning);
387  me_qc1->setErrorProb(error);
388 
389  if ( minMean != 0 || maxMean != 0 )
390  me_qc1->setMeanRange(minMean, maxMean);
391 
392  if ( minRMS != 0 || maxRMS != 0 )
393  me_qc1->setRMSRange(minRMS, maxRMS);
394 
395  if ( toleranceMean != 0 )
396  me_qc1->setMeanTolerance(toleranceMean);
397 
398  if ( minEntries != 0 )
399  me_qc1->setMinimumEntries(minEntries);
400 }
401 
402 void QTestConfigure::EnableCompareLastFilledBinTest(std::string testName,
403  const std::map<std::string, std::string> & params,
404  DQMStore *bei) {
405  QCriterion * qc1;
406  if (! bei->getQCriterion(testName)) {
407  testsConfigured.push_back(testName);
408  qc1 = bei->createQTest(CompareLastFilledBin::getAlgoName(), testName);
409  } else {
410  qc1 = bei->getQCriterion(testName);
411  }
412  CompareLastFilledBin * me_qc1 = (CompareLastFilledBin *) qc1;
413 
414  double warning = atof(findOrDefault(params, "warning", "0"));
415  double error = atof(findOrDefault(params, "error", "0"));
416  double avVal = atof(findOrDefault(params, "AvVal", "0"));
417  double minVal = atof(findOrDefault(params, "MinVal", "0"));
418  double maxVal = atof(findOrDefault(params, "MaxVal", "0"));
419  me_qc1->setWarningProb(warning);
420  me_qc1->setErrorProb(error);
421  me_qc1->setAverage(avVal);
422  me_qc1->setMin(minVal);
423  me_qc1->setMax(maxVal);
424 }
425 void QTestConfigure::EnableCheckVarianceTest(std::string testName,
426  const std::map<std::string, std::string>& params,
427  DQMStore *bei){
428  QCriterion * qc1;
429  if(! bei->getQCriterion(testName) ){
430  testsConfigured.push_back(testName);
431  qc1 = bei->createQTest(CheckVariance::getAlgoName(),testName);
432  }else{
433  qc1 = bei->getQCriterion(testName);
434 
435  }
436  CheckVariance * me_qc1 = (CheckVariance *) qc1;
437 
438  double warning = atof(findOrDefault(params, "warning", "0"));
439  double error = atof(findOrDefault(params, "error", "0"));
440  me_qc1->setWarningProb(warning);
441  me_qc1->setErrorProb(error);
442 }
443 
444 /* void QTestConfigure::EnableContentsWithinExpectedASTest(std::string testName, std::map<std::string, std::string> params, DQMStore *bei){
445 
446 QCriterion * qc1;
447 if(! bei->getQCriterion(testName) ){
448 testsConfigured.push_back(testName);
449 qc1 = bei->createQTest(ContentsWithinExpectedAS::getAlgoName(),testName);
450 }else{
451 qc1 = bei->getQCriterion(testName);
452 }
453 ContentsWithinExpectedAS * me_qc1 = (ContentsWithinExpectedAS *) qc1;
454 
455 double warning=atof(findOrDefault(params, "warning", "0");
456 double error=atof(findOrDefault(params, "error", "0");
457 me_qc1->setWarningProb(warning);
458 me_qc1->setErrorProb(error);
459 
460 double minCont=atof(findOrDefault(params, "minCont", "0");
461 double maxCont=atof(findOrDefault(params, "maxCont", "0");
462 if ( minCont != 0 || maxCont != 0 ) me_qc1->setContentsRange(minCont, maxCont);
463 
464 
465 } */
466 
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:503
QCriterion::setErrorProb
void setErrorProb(float prob)
Definition: QTest.h:65
DQMStore::getQCriterion
QCriterion * getQCriterion(const std::string &qtname) const
Definition: DQMStore.cc:3264
Comp2RefChi2::getAlgoName
static std::string getAlgoName()
Definition: QTest.h:193
CompareToMedian::setStatCut
void setStatCut(float cut)
Definition: QTest.h:743
QTestConfigure::EnableContentSigmaTest
void EnableContentSigmaTest(std::string testName, const std::map< std::string, std::string > &params, DQMStore *bei)
Creates ContentSigmaROOT test.
Definition: QTestConfigure.cc:225
ContentSigma::setDead
void setDead(bool dead)
Definition: QTest.h:431
DeadChannel
test that histogram contents are above Ymin
Definition: QTest.h:308
ContentsYRange::setUseEmptyBins
void setUseEmptyBins(unsigned int useEmptyBins)
Definition: QTest.h:292
CompareToMedian::setMin
void setMin(float min)
Definition: QTest.h:738
ContentSigma::setXMax
void setXMax(unsigned xMax)
Definition: QTest.h:438
TrackerOfflineValidation_Dqm_cff.xmin
xmin
Definition: TrackerOfflineValidation_Dqm_cff.py:10
ContentsXRange::setAllowedXRange
virtual void setAllowedXRange(double xmin, double xmax)
set allowed range in X-axis (default values: histogram&#39;s X-range)
Definition: QTest.h:268
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
QTestConfigure::EnableNoisyChannelTest
void EnableNoisyChannelTest(std::string testName, const std::map< std::string, std::string > &params, DQMStore *bei)
Creates NoisyChannelROOT test.
Definition: QTestConfigure.cc:203
ContentsWithinExpected::setRMSRange
void setRMSRange(double xmin, double xmax)
set expected value for mean
Definition: QTest.cc:1711
CMSBoostedTauSeedingParameters_cfi.yMin
yMin
Definition: CMSBoostedTauSeedingParameters_cfi.py:10
MeanWithinExpected::useSigma
void useSigma(double expectedSigma)
Definition: QTest.cc:1824
Phase2TrackerMonitorDigi_cff.ymin
ymin
Definition: Phase2TrackerMonitorDigi_cff.py:21
QTestConfigure::EnableYRangeTest
void EnableYRangeTest(std::string testName, const std::map< std::string, std::string > &params, DQMStore *bei)
Creates ContentsXRangeASROOT test.
Definition: QTestConfigure.cc:162
CompareToMedian::setMax
void setMax(float max)
Definition: QTest.h:739
QTestConfigure::EnableComp2Ref2DChi2Test
void EnableComp2Ref2DChi2Test(std::string testName, const std::map< std::string, std::string > &params, DQMStore *bei)
Creates Comp2Ref2DChi2 test.
Definition: QTestConfigure.cc:105
QTestConfigure::EnableCompareToMedianTest
void EnableCompareToMedianTest(std::string testName, const std::map< std::string, std::string > &params, DQMStore *bei)
Creates ContentsWithinRangeROOT test.
Definition: QTestConfigure.cc:314
CompareLastFilledBin::setMin
void setMin(float min)
Definition: QTest.h:787
Comp2RefKolmogorov::getAlgoName
static std::string getAlgoName()
Definition: QTest.h:249
NoisyChannel::setNumNeighbors
void setNumNeighbors(unsigned n)
Definition: QTest.h:353
MeanWithinExpected
Algorithm for testing if histogram&#39;s mean value is near expected value.
Definition: QTest.h:516
QTestConfigure::EnableCheckVarianceTest
void EnableCheckVarianceTest(std::string testName, const std::map< std::string, std::string > &params, DQMStore *bei)
Creates CheckVariance test.
Definition: QTestConfigure.cc:425
NoisyChannel
Check if any channels are noisy compared to neighboring ones.
Definition: QTest.h:334
Comp2Ref2DChi2::getAlgoName
static std::string getAlgoName()
Definition: QTest.h:221
electronIdCutBased_cfi.threshold
threshold
Definition: electronIdCutBased_cfi.py:6
CompareToMedian::getAlgoName
static std::string getAlgoName()
Definition: QTest.h:735
anotherprimaryvertexanalyzer_cfi.xMin
xMin
Definition: anotherprimaryvertexanalyzer_cfi.py:12
ContentSigma::setYMax
void setYMax(unsigned yMax)
Definition: QTest.h:444
MeanWithinExpected::getAlgoName
static std::string getAlgoName()
Definition: QTest.h:523
ContentSigma::setYMin
void setYMin(unsigned yMin)
Definition: QTest.h:441
CompareToMedian::setEmptyBins
void setEmptyBins(int eB)
Definition: QTest.h:740
QTestConfigure::EnableComp2RefEqualHTest
void EnableComp2RefEqualHTest(std::string testName, const std::map< std::string, std::string > &params, DQMStore *bei)
Creates Comp2RefEqualH test.
Definition: QTestConfigure.cc:71
QTestConfigure::testsConfigured
std::vector< std::string > testsConfigured
Definition: QTestConfigure.h:110
QTestConfigure::EnableXRangeTest
void EnableXRangeTest(std::string testName, const std::map< std::string, std::string > &params, DQMStore *bei)
Creates ContentsXRangeROOT test.
Definition: QTestConfigure.cc:142
QTestConfigure::EnableMeanWithinExpectedTest
void EnableMeanWithinExpectedTest(std::string testName, const std::map< std::string, std::string > &params, DQMStore *bei)
Creates MeanWithinExpectedROOT test.
Definition: QTestConfigure.cc:268
ContentsXRange::getAlgoName
static std::string getAlgoName()
Definition: QTest.h:264
NoisyChannel::setTolerance
void setTolerance(float percentage)
Definition: QTest.h:359
QTestConfigure::findOrDefault
const char * findOrDefault(const std::map< std::string, std::string > &, const char *, const char *) const
Definition: QTestConfigure.cc:15
SimpleTest::setMinimumEntries
void setMinimumEntries(unsigned n)
set minimum # of entries needed
Definition: QTest.h:146
Phase2TrackerMonitorDigi_cff.ymax
ymax
Definition: Phase2TrackerMonitorDigi_cff.py:22
MeanWithinExpected::setExpectedMean
void setExpectedMean(double mean)
Definition: QTest.h:526
ContentsWithinExpected::setUseEmptyBins
void setUseEmptyBins(unsigned int useEmptyBins)
Definition: QTest.h:487
CompareToMedian::setMaxMedian
void setMaxMedian(float max)
Definition: QTest.h:741
MeanWithinExpected::useRange
void useRange(double xmin, double xmax)
Definition: QTest.cc:1814
ContentSigma::setNumNeighborsX
void setNumNeighborsX(unsigned ncx)
Definition: QTest.h:406
genParticles_cff.map
map
Definition: genParticles_cff.py:11
ContentSigma::setToleranceNoisy
void setToleranceNoisy(float factorNoisy)
Definition: QTest.h:412
ContentSigma
Check the sigma of each bin against the rest of the chamber by a factor of tolerance/.
Definition: QTest.h:382
ContentsWithinExpected::getAlgoName
static std::string getAlgoName()
Definition: QTest.h:484
TrackerOfflineValidation_Dqm_cff.xmax
xmax
Definition: TrackerOfflineValidation_Dqm_cff.py:11
ContentSigma::setNumYblocks
void setNumYblocks(unsigned ncy)
Definition: QTest.h:405
QCriterion::setWarningProb
void setWarningProb(float prob)
set probability limit for warning and error (default: 90% and 50%)
Definition: QTest.h:64
anotherprimaryvertexanalyzer_cfi.xMax
xMax
Definition: anotherprimaryvertexanalyzer_cfi.py:12
DeadChannel::getAlgoName
static std::string getAlgoName()
Definition: QTest.h:316
Comp2RefKolmogorov
Comparison to reference using the Kolmogorov algorithm.
Definition: QTest.h:242
utils_v2.tests
tests
Definition: utils_v2.py:385
CompareLastFilledBin::setMax
void setMax(float max)
Definition: QTest.h:788
ContentsWithinExpected::setMeanRange
void setMeanRange(double xmin, double xmax)
set expected value for mean
Definition: QTest.cc:1699
CheckVariance::getAlgoName
static std::string getAlgoName()
get algorithm name
Definition: QTest.h:845
QTestConfigure::EnableDeadChannelTest
void EnableDeadChannelTest(std::string testName, const std::map< std::string, std::string > &params, DQMStore *bei)
Creates ContentsYRangeASROOT test.
Definition: QTestConfigure.cc:184
ContentSigma::setNoisy
void setNoisy(bool noisy)
Definition: QTest.h:428
QTestConfigure::enableTests
bool enableTests(const std::map< std::string, std::map< std::string, std::string > > &tests, DQMStore *bei)
Creates and defines quality tests.
Definition: QTestConfigure.cc:28
ContentSigma::setNumNeighborsY
void setNumNeighborsY(unsigned ncy)
Definition: QTest.h:407
QTestConfigure::EnableComp2RefKolmogorovTest
void EnableComp2RefKolmogorovTest(std::string testName, const std::map< std::string, std::string > &params, DQMStore *bei)
Creates EnableComp2RefKolmogorov test.
Definition: QTestConfigure.cc:125
DQMStore::createQTest
QCriterion * createQTest(const std::string &algoname, const std::string &qtname)
Definition: DQMStore.cc:3275
ContentSigma::setXMin
void setXMin(unsigned xMin)
Definition: QTest.h:435
ContentSigma::getAlgoName
static std::string getAlgoName()
Definition: QTest.h:394
ContentsWithinExpected::setMeanTolerance
void setMeanTolerance(float fracTolerance)
set (fractional) tolerance for mean
Definition: QTest.h:494
Comp2RefEqualH::getAlgoName
static std::string getAlgoName()
Definition: QTest.h:180
DeadChannel::setThreshold
void setThreshold(double ymin)
set Ymin (inclusive) threshold for "dead" channel (default: 0)
Definition: QTest.h:320
ContentSigma::setNumXblocks
void setNumXblocks(unsigned ncx)
Definition: QTest.h:404
CompareLastFilledBin::setAverage
void setAverage(float average)
Definition: QTest.h:786
ContentSigma::setToleranceDead
void setToleranceDead(float factorDead)
Definition: QTest.h:420
QTestConfigure::EnableContentsWithinExpectedTest
void EnableContentsWithinExpectedTest(std::string testName, const std::map< std::string, std::string > &params, DQMStore *bei)
Creates ContentsWithinRangeROOT test.
Definition: QTestConfigure.cc:365
ContentsYRange::setAllowedYRange
virtual void setAllowedYRange(double ymin, double ymax)
Definition: QTest.h:293
CMSBoostedTauSeedingParameters_cfi.yMax
yMax
Definition: CMSBoostedTauSeedingParameters_cfi.py:11
QTestConfigure::EnableCompareLastFilledBinTest
void EnableCompareLastFilledBinTest(std::string testName, const std::map< std::string, std::string > &params, DQMStore *bei)
Creates EnableCompareLastFilledBinTest test.
Definition: QTestConfigure.cc:402
NoisyChannel::getAlgoName
static std::string getAlgoName()
Definition: QTest.h:343
CompareToMedian::setMinMedian
void setMinMedian(float min)
Definition: QTest.h:742
ContentsYRange::getAlgoName
static std::string getAlgoName()
Definition: QTest.h:289
QTestConfigure::EnableComp2RefChi2Test
void EnableComp2RefChi2Test(std::string testName, const std::map< std::string, std::string > &params, DQMStore *bei)
Creates Comp2RefChi2 test.
Definition: QTestConfigure.cc:88
CompareLastFilledBin::getAlgoName
static std::string getAlgoName()
Definition: QTest.h:783
Generated for CMSSW Reference Manual by doxygen 1.8.11