Inheritance diagram for QualityTester:

Public Member Functions
	QualityTester (const edm::ParameterSet &ps)
	Constructor. More...

	~QualityTester () override
	Destructor. More...

Public Member Functions inherited from DQMEDHarvester
void	accumulate (edm::Event const &ev, edm::EventSetup const &es) final

void	beginJob () override

void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &) final

void	beginRun (edm::Run const &run, edm::EventSetup const &) override

	DQMEDHarvester (edm::ParameterSet const &iConfig)

	DQMEDHarvester ()

void	endLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) final

void	endLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &es) final

void	endProcessBlockProduce (edm::ProcessBlock &) final

void	endRun (edm::Run const &, edm::EventSetup const &) override

void	endRunProduce (edm::Run &run, edm::EventSetup const &es) final

	~DQMEDHarvester () override=default

Public Member Functions inherited from edm::one::EDProducer< T >
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

bool	wantsInputProcessBlocks () const final

bool	wantsProcessBlocks () const final

Public Member Functions inherited from edm::one::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDProducerBase () override

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector < edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector < edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

	~ProducerBase () noexcept(false) override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector < ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const * > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Protected Member Functions
void	dqmAnalyze (DQMStore::IBooker &, DQMStore::IGetter &, const edm::Event &e, const edm::EventSetup &c) override
	perform the actual quality tests More...

void	dqmEndJob (DQMStore::IBooker &, DQMStore::IGetter &) override

void	dqmEndLuminosityBlock (DQMStore::IBooker &, DQMStore::IGetter &, edm::LuminosityBlock const &lumiSeg, edm::EventSetup const &c) override

void	dqmEndRun (DQMStore::IBooker &, DQMStore::IGetter &, const edm::Run &r, const edm::EventSetup &c) override

Protected Member Functions inherited from edm::ProducerBase
ProducesCollector	producesCollector ()

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

void	resetItemsToGetFrom (BranchType iType)

Private Member Functions
void	configureTests (std::string const &file)

std::unique_ptr< QCriterion >	makeQCriterion (boost::property_tree::ptree const &config)

void	performTests (DQMStore::IGetter &igetter)

Private Attributes
bool	getQualityTestsFromFile

std::string	Label

int	nEvents

int	prescaleFactor

std::vector< std::unique_ptr < QCriterion > >	qtestobjects

bool	qtestOnEndJob

bool	qtestOnEndLumi

bool	qtestOnEndRun

std::vector< std::pair < std::string, QCriterion * > >	qtestpatterns

std::string	reportThreshold

bool	testInEventloop

bool	verboseQT

Additional Inherited Members
Public Types inherited from DQMEDHarvester
typedef dqm::harvesting::DQMStore	DQMStore

typedef dqm::harvesting::MonitorElement	MonitorElement

Public Types inherited from edm::one::EDProducerBase
typedef EDProducerBase	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::one::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Attributes inherited from DQMEDHarvester
DQMStore *	dqmstore_

edm::GetterOfProducts< DQMToken >	jobmegetter_

edm::EDPutTokenT< DQMToken >	jobToken_

edm::GetterOfProducts< DQMToken >	lumimegetter_

edm::EDPutTokenT< DQMToken >	lumiToken_

edm::GetterOfProducts< DQMToken >	runmegetter_

edm::EDPutTokenT< DQMToken >	runToken_

Detailed Description

Definition at line 35 of file QualityTester.cc.

Constructor & Destructor Documentation

QualityTester::QualityTester ( const edm::ParameterSet & ps )

Constructor.

Definition at line 79 of file QualityTester.cc.

References cms::cuda::assert(), configureTests(), edm::FileInPath::fullPath(), getQualityTestsFromFile, edm::ParameterSet::getUntrackedParameter(), Label, nEvents, prescaleFactor, qtestOnEndJob, qtestOnEndLumi, qtestOnEndRun, reportThreshold, AlCaHLTBitMon_QueryRunRegistry::string, testInEventloop, and verboseQT.

                                                       : DQMEDHarvester(ps) {
   prescaleFactor = ps.getUntrackedParameter<int>("prescaleFactor", 1);
   getQualityTestsFromFile = ps.getUntrackedParameter<bool>("getQualityTestsFromFile", true);
   Label = ps.getUntrackedParameter<std::string>("label", "");
   reportThreshold = ps.getUntrackedParameter<std::string>("reportThreshold", "");
   testInEventloop = ps.getUntrackedParameter<bool>("testInEventloop", false);
   qtestOnEndRun = ps.getUntrackedParameter<bool>("qtestOnEndRun", true);
   qtestOnEndJob = ps.getUntrackedParameter<bool>("qtestOnEndJob", false);
   qtestOnEndLumi = ps.getUntrackedParameter<bool>("qtestOnEndLumi", false);
   verboseQT = ps.getUntrackedParameter<bool>("verboseQT", true);
 
   if (getQualityTestsFromFile) {
     edm::FileInPath qtlist = ps.getUntrackedParameter<edm::FileInPath>("qtList");
     configureTests(qtlist.fullPath());
   } else {
     assert(!"Reading from DB no longer supported.");
   }
 
   nEvents = 0;
 }

QualityTester::~QualityTester ( )

override

Destructor.

Definition at line 100 of file QualityTester.cc.

100 {}

Member Function Documentation

void QualityTester::configureTests ( std::string const & file )

private

Definition at line 356 of file QualityTester.cc.

References HLT_FULL_cff::enabled, Exception, makeQCriterion(), eostools::move(), mergeVDriftHistosByStation::name, AlCaHLTBitMon_ParallelJobs::p, qtestobjects, qtestpatterns, AlCaHLTBitMon_QueryRunRegistry::string, and relativeConstraints::value.

Referenced by QualityTester().

                                                         {
   // We read QTests from the config file into this structure, before
   // transforming into the final [(pattern, *qtest), ...] structure.
   struct TestItem {
     std::unique_ptr<QCriterion> qtest;
     std::vector<std::string> pathpatterns;
   };
   std::map<std::string, TestItem> qtestmap;
 
   // read XML using property tree. Should throw on error.
   boost::property_tree::ptree xml;
   boost::property_tree::read_xml(file, xml);
 
   auto it = xml.find("TESTSCONFIGURATION");
   if (it == xml.not_found()) {
     throw cms::Exception("QualityTester") << "QTest XML needs to have a TESTSCONFIGURATION node.";
   }
   auto& testconfig = it->second;
   for (auto& kv : testconfig) {
     // QTEST describes a QTest object (actually QCriterion) with its parameters
     if (kv.first == "QTEST") {
       auto& qtestconfig = kv.second;
       auto name = qtestconfig.get<std::string>("<xmlattr>.name");
       auto value = makeQCriterion(qtestconfig);
       // LINK and QTEST can be in any order, so this element may or may not exist
       qtestmap[name].qtest = std::move(value);
     }  // else
     // LINK associates one ore more QTest referenced by name to a ME path pattern.
     if (kv.first == "LINK") {
       auto& linkconfig = kv.second;
       auto pathpattern = linkconfig.get<std::string>("<xmlattr>.name");
       for (auto& subkv : linkconfig) {
         if (subkv.first == "TestName") {
           std::string testname = subkv.second.data();
           bool enabled = subkv.second.get<bool>("<xmlattr>.activate");
           if (enabled) {
             // LINK and QTEST can be in any order, so this element may or may not exist
             qtestmap[testname].pathpatterns.push_back(pathpattern);
           }
         }
       }
     }
     // else: unknown tag, but that is fine, its XML
   }
 
   // now that we have all the objects created and references resolved, flatten
   // the structure into something more useful for evaluating tests.
   this->qtestobjects.clear();
   this->qtestpatterns.clear();
   for (auto& kv : qtestmap) {
     QCriterion* bareptr = kv.second.qtest.get();
     for (auto& p : kv.second.pathpatterns) {
       this->qtestpatterns.push_back(std::make_pair(p, bareptr));
     }
     this->qtestobjects.push_back(std::move(kv.second.qtest));
   }
   // we could sort the patterns here to allow more performant matching
   // (using a suffix-array to handle the "*" in the beginning)
 }

void QualityTester::dqmAnalyze	(	DQMStore::IBooker &	,
		DQMStore::IGetter &	igetter,
		const edm::Event &	e,
		const edm::EventSetup &	c
	)

overrideprotectedvirtual

perform the actual quality tests

Reimplemented from DQMEDHarvester.

Definition at line 102 of file QualityTester.cc.

References nEvents, performTests(), prescaleFactor, and testInEventloop.

                                                        {
   if (testInEventloop) {
     nEvents++;
     if (prescaleFactor > 0 && nEvents % prescaleFactor == 0) {
       performTests(igetter);
     }
   }
 }

void QualityTester::dqmEndJob	(	DQMStore::IBooker &	,
		DQMStore::IGetter &	igetter
	)

overrideprotectedvirtual

Implements DQMEDHarvester.

Definition at line 133 of file QualityTester.cc.

References performTests(), and qtestOnEndJob.

                                                                         {
   if (qtestOnEndJob)
     performTests(igetter);
 }

void QualityTester::dqmEndLuminosityBlock	(	DQMStore::IBooker &	,
		DQMStore::IGetter &	igetter,
		edm::LuminosityBlock const &	lumiSeg,
		edm::EventSetup const &	c
	)

overrideprotectedvirtual

Reimplemented from DQMEDHarvester.

Definition at line 114 of file QualityTester.cc.

References edm::LuminosityBlockBase::id(), edm::LuminosityBlockID::luminosityBlock(), performTests(), prescaleFactor, qtestOnEndLumi, and testInEventloop.

                                                                         {
   if (!testInEventloop && qtestOnEndLumi) {
     if (prescaleFactor > 0 && lumiSeg.id().luminosityBlock() % prescaleFactor == 0) {
       performTests(igetter);
     }
   }
 }

void QualityTester::dqmEndRun	(	DQMStore::IBooker &	,
		DQMStore::IGetter &	igetter,
		const edm::Run &	r,
		const edm::EventSetup &	c
	)

overrideprotectedvirtual

Reimplemented from DQMEDHarvester.

Definition at line 125 of file QualityTester.cc.

References performTests(), and qtestOnEndRun.

                                                             {
   if (qtestOnEndRun)
     performTests(igetter);
 }

std::unique_ptr< QCriterion > QualityTester::makeQCriterion ( boost::property_tree::ptree const & config )

private

Definition at line 213 of file QualityTester.cc.

References submitPVResolutionJobs::config, QCriterion::ERROR_PROB_THRESHOLD, ContentsXRange::getAlgoName(), ContentsYRange::getAlgoName(), DeadChannel::getAlgoName(), NoisyChannel::getAlgoName(), ContentSigma::getAlgoName(), ContentsWithinExpected::getAlgoName(), MeanWithinExpected::getAlgoName(), CompareToMedian::getAlgoName(), CompareLastFilledBin::getAlgoName(), CheckVariance::getAlgoName(), mergeVDriftHistosByStation::name, AlCaHLTBitMon_QueryRunRegistry::string, ctpps_dqm_sourceclient-live_cfg::test, and QCriterion::WARNING_PROB_THRESHOLD.

Referenced by configureTests().

                                                                                              {
   // For whatever reasons the compiler needs the "template" keyword on ptree::get.
   // To save some noise in the code we have the preprocessor add it everywhere.
 #define get template get
   // TODO: make the parameter names more consistent.
   // TODO: add defaults where it makes sense.
   std::map<std::string,
            std::function<std::unique_ptr<QCriterion>(boost::property_tree::ptree const&, std::string& name)>>
       qtestmakers = {{CheckVariance::getAlgoName(),
                       [](auto const& config, std::string& name) {
                         auto test = std::make_unique<CheckVariance>(name);
                         test->setWarningProb(config.get<float>("warning", QCriterion::WARNING_PROB_THRESHOLD));
                         test->setErrorProb(config.get<float>("error", QCriterion::ERROR_PROB_THRESHOLD));
                         return test;
                       }},
                      {CompareLastFilledBin::getAlgoName(),
                       [](auto const& config, std::string& name) {
                         auto test = std::make_unique<CompareLastFilledBin>(name);
                         test->setWarningProb(config.get<float>("warning", QCriterion::WARNING_PROB_THRESHOLD));
                         test->setErrorProb(config.get<float>("error", QCriterion::ERROR_PROB_THRESHOLD));
                         test->setAverage(config.get<float>("AvVal"));
                         test->setMin(config.get<float>("MinVal"));
                         test->setMax(config.get<float>("MaxVal"));
                         return test;
                       }},
                      {CompareToMedian::getAlgoName(),
                       [](auto const& config, std::string& name) {
                         auto test = std::make_unique<CompareToMedian>(name);
                         test->setWarningProb(config.get<float>("warning", QCriterion::WARNING_PROB_THRESHOLD));
                         test->setErrorProb(config.get<float>("error", QCriterion::ERROR_PROB_THRESHOLD));
                         test->setMin(config.get<float>("MinRel"));
                         test->setMax(config.get<float>("MaxRel"));
                         test->setMinMedian(config.get<float>("MinAbs"));
                         test->setMaxMedian(config.get<float>("MaxAbs"));
                         test->setEmptyBins(config.get<int>("UseEmptyBins"));
                         test->setStatCut(config.get<float>("StatCut", 0));
                         return test;
                       }},
                      {ContentSigma::getAlgoName(),
                       [](auto const& config, std::string& name) {
                         auto test = std::make_unique<ContentSigma>(name);
                         test->setWarningProb(config.get<float>("warning", QCriterion::WARNING_PROB_THRESHOLD));
                         test->setErrorProb(config.get<float>("error", QCriterion::ERROR_PROB_THRESHOLD));
                         test->setNumXblocks(config.get<int>("Xblocks"));
                         test->setNumYblocks(config.get<int>("Yblocks"));
                         test->setNumNeighborsX(config.get<int>("neighboursX"));
                         test->setNumNeighborsY(config.get<int>("neighboursY"));
                         test->setToleranceNoisy(config.get<double>("toleranceNoisy"));
                         test->setToleranceDead(config.get<double>("toleranceDead"));
                         test->setNoisy(config.get<double>("noisy"));
                         test->setDead(config.get<double>("dead"));
                         test->setXMin(config.get<int>("xMin"));
                         test->setXMax(config.get<int>("xMax"));
                         test->setYMin(config.get<int>("yMin"));
                         test->setYMax(config.get<int>("yMax"));
                         return test;
                       }},
                      {ContentsWithinExpected::getAlgoName(),
                       [](auto const& config, std::string& name) {
                         auto test = std::make_unique<ContentsWithinExpected>(name);
                         test->setWarningProb(config.get<float>("warning", QCriterion::WARNING_PROB_THRESHOLD));
                         test->setErrorProb(config.get<float>("error", QCriterion::ERROR_PROB_THRESHOLD));
                         test->setUseEmptyBins(config.get<bool>("useEmptyBins"));
                         test->setMinimumEntries(config.get<int>("minEntries"));
                         test->setMeanTolerance(config.get<float>("toleranceMean"));
                         if (config.get<double>("minMean", 0) || config.get<double>("maxMean", 0))
                           test->setMeanRange(config.get<double>("minMean"), config.get<double>("maxMean"));
                         if (config.get<double>("minRMS", 0) || config.get<double>("maxRMS", 0))
                           test->setRMSRange(config.get<double>("minRMS"), config.get<double>("maxRMS"));
                         return test;
                       }},
                      {ContentsXRange::getAlgoName(),
                       [](auto const& config, std::string& name) {
                         auto test = std::make_unique<ContentsXRange>(name);
                         test->setWarningProb(config.get<float>("warning", QCriterion::WARNING_PROB_THRESHOLD));
                         test->setErrorProb(config.get<float>("error", QCriterion::ERROR_PROB_THRESHOLD));
                         test->setAllowedXRange(config.get<double>("xmin"), config.get<double>("xmax"));
                         return test;
                       }},
                      {ContentsYRange::getAlgoName(),
                       [](auto const& config, std::string& name) {
                         auto test = std::make_unique<ContentsYRange>(name);
                         test->setWarningProb(config.get<float>("warning", QCriterion::WARNING_PROB_THRESHOLD));
                         test->setErrorProb(config.get<float>("error", QCriterion::ERROR_PROB_THRESHOLD));
                         test->setAllowedYRange(config.get<double>("ymin"), config.get<double>("ymax"));
                         test->setUseEmptyBins(config.get<bool>("useEmptyBins"));
                         return test;
                       }},
                      {DeadChannel::getAlgoName(),
                       [](auto const& config, std::string& name) {
                         auto test = std::make_unique<DeadChannel>(name);
                         test->setWarningProb(config.get<float>("warning", QCriterion::WARNING_PROB_THRESHOLD));
                         test->setErrorProb(config.get<float>("error", QCriterion::ERROR_PROB_THRESHOLD));
                         test->setThreshold(config.get<float>("threshold"));
                         return test;
                       }},
                      {MeanWithinExpected::getAlgoName(),
                       [](auto const& config, std::string& name) {
                         auto test = std::make_unique<MeanWithinExpected>(name);
                         test->setWarningProb(config.get<float>("warning", QCriterion::WARNING_PROB_THRESHOLD));
                         test->setErrorProb(config.get<float>("error", QCriterion::ERROR_PROB_THRESHOLD));
                         test->setMinimumEntries(config.get<int>("minEntries", 0));
                         test->setExpectedMean(config.get<double>("mean"));
                         if (config.get<double>("useSigma", 0))
                           test->useSigma(config.get<double>("useSigma"));
                         if (config.get<int>("useRMS", 0))
                           test->useRMS();
                         if (config.get<int>("useRange", 0))
                           test->useRange(config.get<float>("xmin"), config.get<float>("xmax"));
                         return test;
                       }},
                      {NoisyChannel::getAlgoName(), [](auto const& config, std::string& name) {
                         auto test = std::make_unique<NoisyChannel>(name);
                         test->setWarningProb(config.get<float>("warning", QCriterion::WARNING_PROB_THRESHOLD));
                         test->setErrorProb(config.get<float>("error", QCriterion::ERROR_PROB_THRESHOLD));
                         test->setTolerance(config.get<double>("tolerance"));
                         test->setNumNeighbors(config.get<double>("neighbours"));
                         return test;
                       }}};
 #undef get
 
   auto maker = qtestmakers.find(config.get<std::string>("TYPE"));
   // Check if the type is known, error out otherwise.
   if (maker == qtestmakers.end())
     return nullptr;
 
   // The QTest XML format has structure
   // <QTEST><TYPE>QTestClass</TYPE><PARAM name="thing">value</PARAM>...</QTEST>
   // but that is a pain to read with property_tree. So we reorder the structure
   // and add a child "thing" with data "value" for each param to a new tree.
   // Then the qtestmakers can just config.get<type>("thing").
   boost::property_tree::ptree reordered;
   for (auto kv : config) {
     // TODO: case sensitive?
     if (kv.first == "PARAM") {
       reordered.put(kv.second.get<std::string>("<xmlattr>.name"), kv.second.data());
     }
   }
 
   auto name = config.get<std::string>("<xmlattr>.name");
   return maker->second(reordered, name);
 }

void QualityTester::performTests ( DQMStore::IGetter & igetter )

private

Definition at line 138 of file QualityTester.cc.

References cms::cuda::assert(), gather_cfg::cout, Exception, dqm::implementation::IGetter::getAllContents(), QCriterion::getName(), match(), hlt_dqm_clientPB-live_cfg::me, mps_check::msg, mergeVDriftHistosByStation::name, qtestpatterns, alignCSCRings::r, zeeHLT_cff::report, reportThreshold, QCriterion::runTest(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by dqmAnalyze(), dqmEndJob(), dqmEndLuminosityBlock(), and dqmEndRun().

                                                          {
   edm::LogVerbatim("QualityTester") << "Running the Quality Test";
 
   auto mes = igetter.getAllContents("");
 
   for (auto me : mes) {
     std::string name = me->getFullname();
     for (auto& kv : this->qtestpatterns) {
       std::string& pattern = kv.first;
       QCriterion* qtest = kv.second;
       int match = fnmatch(pattern.c_str(), name.c_str(), 0);
       if (match == FNM_NOMATCH)
         continue;
       if (match != 0)
         throw cms::Exception("QualityTester")
             << "Something went wrong with fnmatch: pattern = '" << pattern << "' and string = '" << name << "'";
 
       // name matched, apply test.
       // Using the classic ME API for now.
       QReport* qr;
       DQMNet::QValue* qv;
       me->getQReport(/* create */ true, qtest->getName(), qr, qv);
       assert(qtest);  // null might be valid, maybe replace with if
       assert(qr);
       assert(qv);
       qtest->runTest(me, *qr, *qv);
       // this propagates the result into the DQMNet object flags
       me->syncCoreObject();
     }
   }
 
   if (!reportThreshold.empty()) {
     // map {red, orange, black} -> [QReport message, ...]
     std::map<std::string, std::vector<std::string>> theAlarms;
     // populate from MEs hasError, hasWarning, hasOther
     for (auto me : mes) {
       // TODO: This logic is rather broken and suppresses errors when there
       // are warnings (or suppresses both when there are others. But this is
       // how it always was, and we keep it for now for compatibility.
       std::vector<QReport*> report;
       std::string colour;
       if (me->hasError()) {
         colour = "red";
         report = me->getQErrors();
       }
       if (me->hasWarning()) {
         colour = "orange";
         report = me->getQWarnings();
       }
       if (me->hasOtherReport()) {
         colour = "black";
         report = me->getQOthers();
       }
       for (auto r : report) {
         theAlarms[colour].push_back(r->getMessage());
       }
     }
 
     // writes to stdout, because it alyways wrote to stdout.
     for (auto& theAlarm : theAlarms) {
       const std::string& alarmType = theAlarm.first;
       const std::vector<std::string>& msgs = theAlarm.second;
       if ((reportThreshold == "black") ||
           (reportThreshold == "orange" && (alarmType == "orange" || alarmType == "red")) ||
           (reportThreshold == "red" && alarmType == "red")) {
         std::cout << std::endl;
         std::cout << "Error Type: " << alarmType << std::endl;
         for (auto const& msg : msgs)
           std::cout << msg << std::endl;
       }
     }
     std::cout << std::endl;
   }
 }