Inheritance diagram for DQMGenericClient:

Classes
struct	CDOption

struct	EfficOption

struct	NoFlowOption

struct	NormOption

struct	ProfileOption

struct	ResolOption

Public Types
enum	EfficType { EfficType::none = 0, EfficType::efficiency, EfficType::fakerate, EfficType::simpleratio }

Public Member Functions
void	computeEfficiency (DQMStore::IBooker &ibooker, DQMStore::IGetter &igetter, const std::string &startDir, const std::string &efficMEName, const std::string &efficMETitle, const std::string &recoMEName, const std::string &simMEName, const EfficType type=EfficType::efficiency, const bool makeProfile=false)

void	computeProfile (DQMStore::IBooker &ibooker, DQMStore::IGetter &igetter, const std::string &startDir, const std::string &profileMEName, const std::string &profileMETitle, const std::string &srcMEName)

void	computeResolution (DQMStore::IBooker &ibooker, DQMStore::IGetter &igetter, const std::string &startDir, const std::string &fitMEPrefix, const std::string &fitMETitlePrefix, const std::string &srcMEName)

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

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

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

	DQMGenericClient (const edm::ParameterSet &pset)

void	limitedFit (MonitorElement srcME, MonitorElement meanME, MonitorElement *sigmaME)

void	makeCumulativeDist (DQMStore::IBooker &ibooker, DQMStore::IGetter &igetter, const std::string &startDir, const std::string &cdName, bool ascending=true)

void	makeNoFlowDist (DQMStore::IBooker &ibooker, DQMStore::IGetter &igetter, const std::string &startDir, const std::string &cdName)

void	normalizeToEntries (DQMStore::IBooker &ibooker, DQMStore::IGetter &igetter, const std::string &startDir, const std::string &histName, const std::string &normHistName)

	~DQMGenericClient () override

Private Member Functions
void	findAllSubdirectories (DQMStore::IBooker &ibooker, DQMStore::IGetter &igetter, std::string dir, std::set< std::string > *myList, const TString &pattern)

void	generic_eff (TH1 denom, TH1 numer, MonitorElement *efficiencyHist, const EfficType type=EfficType::efficiency)

void	makeAllPlots (DQMStore::IBooker &, DQMStore::IGetter &)

void	removeMEIfBooked (const std::string &meName, DQMStore::IGetter &igetter)

Private Attributes
std::vector< CDOption >	cdOptions_

std::vector< EfficOption >	efficOptions_

bool	isWildcardUsed_

bool	makeGlobalEffPlot_

TPRegexp	metacharacters_

std::vector< NoFlowOption >	noFlowOptions_

TPRegexp	nonPerlWildcard_

std::vector< NormOption >	normOptions_

std::string	outputFileName_

std::vector< ProfileOption >	profileOptions_

bool	resLimitedFit_

std::vector< ResolOption >	resolOptions_

bool	runOnEndJob_

bool	runOnEndLumi_

std::vector< std::string >	subDirs_

DQMStore *	theDQM

unsigned int	verbose_

Detailed Description

Definition at line 35 of file DQMGenericClient.cc.

Member Enumeration Documentation

◆ EfficType

enum DQMGenericClient::EfficType

strong

Enumerator
none
efficiency
fakerate
simpleratio

Definition at line 47 of file DQMGenericClient.cc.

47 { none = 0, efficiency, fakerate, simpleratio };

Constructor & Destructor Documentation

◆ DQMGenericClient()

DQMGenericClient::DQMGenericClient ( const edm::ParameterSet & pset )

Definition at line 240 of file DQMGenericClient.cc.

     : metacharacters_("[\\^\\$\\.\\*\\+\\?\\|\\(\\)\\{\\}\\[\\]]"), nonPerlWildcard_("\\w\\*|^\\*") {
   typedef std::vector<edm::ParameterSet> VPSet;
   typedef std::vector<std::string> vstring;
   typedef boost::escaped_list_separator<char> elsc;
  
   elsc commonEscapes("\\", " \t", "\'");
  
   verbose_ = pset.getUntrackedParameter<unsigned int>("verbose", 0);
   runOnEndLumi_ = pset.getUntrackedParameter<bool>("runOnEndLumi", false);
   runOnEndJob_ = pset.getUntrackedParameter<bool>("runOnEndJob", true);
   makeGlobalEffPlot_ = pset.getUntrackedParameter<bool>("makeGlobalEffienciesPlot", true);
  
   // Parse efficiency commands
   vstring effCmds = pset.getParameter<vstring>("efficiency");
   for (vstring::const_iterator effCmd = effCmds.begin(); effCmd != effCmds.end(); ++effCmd) {
     if (effCmd->empty())
       continue;
  
     boost::tokenizer<elsc> tokens(*effCmd, commonEscapes);
  
     vector<string> args;
     for (boost::tokenizer<elsc>::const_iterator iToken = tokens.begin(); iToken != tokens.end(); ++iToken) {
       if (iToken->empty())
         continue;
       args.push_back(*iToken);
     }
  
     if (args.size() < 4) {
       LogInfo("DQMGenericClient") << "Wrong input to effCmds\n";
       continue;
     }
  
     EfficOption opt;
     opt.name = args[0];
     opt.title = args[1];
     opt.numerator = args[2];
     opt.denominator = args[3];
     opt.isProfile = false;
  
     const string typeName = args.size() == 4 ? "eff" : args[4];
     if (typeName == "eff")
       opt.type = EfficType::efficiency;
     else if (typeName == "fake")
       opt.type = EfficType::fakerate;
     else if (typeName == "simpleratio")
       opt.type = EfficType::simpleratio;
     else
       opt.type = EfficType::none;
  
     efficOptions_.push_back(opt);
   }
  
   VPSet efficSets = pset.getUntrackedParameter<VPSet>("efficiencySets", VPSet());
   for (VPSet::const_iterator efficSet = efficSets.begin(); efficSet != efficSets.end(); ++efficSet) {
     EfficOption opt;
     opt.name = efficSet->getUntrackedParameter<string>("name");
     opt.title = efficSet->getUntrackedParameter<string>("title");
     opt.numerator = efficSet->getUntrackedParameter<string>("numerator");
     opt.denominator = efficSet->getUntrackedParameter<string>("denominator");
     opt.isProfile = false;
  
     const string typeName = efficSet->getUntrackedParameter<string>("typeName", "eff");
     if (typeName == "eff")
       opt.type = EfficType::efficiency;
     else if (typeName == "fake")
       opt.type = EfficType::fakerate;
     else if (typeName == "simpleratio")
       opt.type = EfficType::simpleratio;
     else
       opt.type = EfficType::none;
  
     efficOptions_.push_back(opt);
   }
  
   // Parse efficiency profiles
   vstring effProfileCmds = pset.getUntrackedParameter<vstring>("efficiencyProfile", vstring());
   for (vstring::const_iterator effProfileCmd = effProfileCmds.begin(); effProfileCmd != effProfileCmds.end();
        ++effProfileCmd) {
     if (effProfileCmd->empty())
       continue;
  
     boost::tokenizer<elsc> tokens(*effProfileCmd, commonEscapes);
  
     vector<string> args;
     for (boost::tokenizer<elsc>::const_iterator iToken = tokens.begin(); iToken != tokens.end(); ++iToken) {
       if (iToken->empty())
         continue;
       args.push_back(*iToken);
     }
  
     if (args.size() < 4) {
       LogInfo("DQMGenericClient") << "Wrong input to effProfileCmds\n";
       continue;
     }
  
     EfficOption opt;
     opt.name = args[0];
     opt.title = args[1];
     opt.numerator = args[2];
     opt.denominator = args[3];
     opt.isProfile = true;
  
     const string typeName = args.size() == 4 ? "eff" : args[4];
     if (typeName == "eff")
       opt.type = EfficType::efficiency;
     else if (typeName == "fake")
       opt.type = EfficType::fakerate;
     else if (typeName == "simpleratio")
       opt.type = EfficType::simpleratio;
     else
       opt.type = EfficType::none;
  
     efficOptions_.push_back(opt);
   }
  
   VPSet effProfileSets = pset.getUntrackedParameter<VPSet>("efficiencyProfileSets", VPSet());
   for (VPSet::const_iterator effProfileSet = effProfileSets.begin(); effProfileSet != effProfileSets.end();
        ++effProfileSet) {
     EfficOption opt;
     opt.name = effProfileSet->getUntrackedParameter<string>("name");
     opt.title = effProfileSet->getUntrackedParameter<string>("title");
     opt.numerator = effProfileSet->getUntrackedParameter<string>("numerator");
     opt.denominator = effProfileSet->getUntrackedParameter<string>("denominator");
     opt.isProfile = true;
  
     const string typeName = effProfileSet->getUntrackedParameter<string>("typeName", "eff");
     if (typeName == "eff")
       opt.type = EfficType::efficiency;
     else if (typeName == "fake")
       opt.type = EfficType::fakerate;
     else if (typeName == "simpleratio")
       opt.type = EfficType::simpleratio;
     else
       opt.type = EfficType::none;
  
     efficOptions_.push_back(opt);
   }
  
   // Parse resolution commands
   vstring resCmds = pset.getParameter<vstring>("resolution");
   for (vstring::const_iterator resCmd = resCmds.begin(); resCmd != resCmds.end(); ++resCmd) {
     if (resCmd->empty())
       continue;
     boost::tokenizer<elsc> tokens(*resCmd, commonEscapes);
  
     vector<string> args;
     for (boost::tokenizer<elsc>::const_iterator iToken = tokens.begin(); iToken != tokens.end(); ++iToken) {
       if (iToken->empty())
         continue;
       args.push_back(*iToken);
     }
  
     if (args.size() != 3) {
       LogInfo("DQMGenericClient") << "Wrong input to resCmds\n";
       continue;
     }
  
     ResolOption opt;
     opt.namePrefix = args[0];
     opt.titlePrefix = args[1];
     opt.srcName = args[2];
  
     resolOptions_.push_back(opt);
   }
  
   VPSet resolSets = pset.getUntrackedParameter<VPSet>("resolutionSets", VPSet());
   for (VPSet::const_iterator resolSet = resolSets.begin(); resolSet != resolSets.end(); ++resolSet) {
     ResolOption opt;
     opt.namePrefix = resolSet->getUntrackedParameter<string>("namePrefix");
     opt.titlePrefix = resolSet->getUntrackedParameter<string>("titlePrefix");
     opt.srcName = resolSet->getUntrackedParameter<string>("srcName");
  
     resolOptions_.push_back(opt);
   }
  
   // Parse profiles
   vstring profileCmds = pset.getUntrackedParameter<vstring>("profile", vstring());
   for (const auto& profileCmd : profileCmds) {
     boost::tokenizer<elsc> tokens(profileCmd, commonEscapes);
  
     vector<string> args;
     for (boost::tokenizer<elsc>::const_iterator iToken = tokens.begin(); iToken != tokens.end(); ++iToken) {
       if (iToken->empty())
         continue;
       args.push_back(*iToken);
     }
  
     if (args.size() != 3) {
       LogInfo("DQMGenericClient") << "Wrong input to profileCmds\n";
       continue;
     }
  
     ProfileOption opt;
     opt.name = args[0];
     opt.title = args[1];
     opt.srcName = args[2];
  
     profileOptions_.push_back(opt);
   }
  
   VPSet profileSets = pset.getUntrackedParameter<VPSet>("profileSets", VPSet());
   for (const auto& profileSet : profileSets) {
     ProfileOption opt;
     opt.name = profileSet.getUntrackedParameter<string>("name");
     opt.title = profileSet.getUntrackedParameter<string>("title");
     opt.srcName = profileSet.getUntrackedParameter<string>("srcName");
  
     profileOptions_.push_back(opt);
   }
  
   // Parse Normalization commands
   vstring normCmds = pset.getUntrackedParameter<vstring>("normalization", vstring());
   for (vstring::const_iterator normCmd = normCmds.begin(); normCmd != normCmds.end(); ++normCmd) {
     if (normCmd->empty())
       continue;
     boost::tokenizer<elsc> tokens(*normCmd, commonEscapes);
  
     vector<string> args;
     for (boost::tokenizer<elsc>::const_iterator iToken = tokens.begin(); iToken != tokens.end(); ++iToken) {
       if (iToken->empty())
         continue;
       args.push_back(*iToken);
     }
  
     if (args.empty() or args.size() > 2) {
       LogInfo("DQMGenericClient") << "Wrong input to normCmds\n";
       continue;
     }
  
     NormOption opt;
     opt.name = args[0];
     opt.normHistName = args.size() == 2 ? args[1] : args[0];
  
     normOptions_.push_back(opt);
   }
  
   VPSet normSets = pset.getUntrackedParameter<VPSet>("normalizationSets", VPSet());
   for (VPSet::const_iterator normSet = normSets.begin(); normSet != normSets.end(); ++normSet) {
     NormOption opt;
     opt.name = normSet->getUntrackedParameter<string>("name");
     opt.normHistName = normSet->getUntrackedParameter<string>("normalizedTo", opt.name);
  
     normOptions_.push_back(opt);
   }
  
   // Cumulative distributions
   vstring cdCmds = pset.getUntrackedParameter<vstring>("cumulativeDists", vstring());
   for (vstring::const_iterator cdCmd = cdCmds.begin(); cdCmd != cdCmds.end(); ++cdCmd) {
     if (cdCmd->empty())
       continue;
     boost::tokenizer<elsc> tokens(*cdCmd, commonEscapes);
  
     vector<string> args;
     for (boost::tokenizer<elsc>::const_iterator iToken = tokens.begin(); iToken != tokens.end(); ++iToken) {
       if (iToken->empty())
         continue;
       args.push_back(*iToken);
     }
  
     if (args.empty() || args.size() > 2) {
       LogInfo("DQMGenericClient") << "Wrong input to cdCmds\n";
       continue;
     }
  
     CDOption opt;
     opt.name = args[0];
     opt.ascending = args.size() == 2 ? (args[1] != "descending") : true;
  
     cdOptions_.push_back(opt);
   }
  
   VPSet cdSets = pset.getUntrackedParameter<VPSet>("cumulativeDistSets", VPSet());
   for (VPSet::const_iterator cdSet = cdSets.begin(); cdSet != cdSets.end(); ++cdSet) {
     CDOption opt;
     opt.name = cdSet->getUntrackedParameter<string>("name");
     opt.ascending = cdSet->getUntrackedParameter<bool>("ascending", true);
  
     cdOptions_.push_back(opt);
   }
  
   // move under/overflows to first/last bins
   vstring noFlowCmds = pset.getUntrackedParameter<vstring>("noFlowDists", vstring());
   for (vstring::const_iterator noFlowCmd = noFlowCmds.begin(); noFlowCmd != noFlowCmds.end(); ++noFlowCmd) {
     if (noFlowCmd->empty())
       continue;
     boost::tokenizer<elsc> tokens(*noFlowCmd, commonEscapes);
  
     vector<string> args;
     for (boost::tokenizer<elsc>::const_iterator iToken = tokens.begin(); iToken != tokens.end(); ++iToken) {
       if (iToken->empty())
         continue;
       args.push_back(*iToken);
     }
  
     if (args.empty() || args.size() > 2) {
       LogInfo("DQMGenericClient") << "Wrong input to noFlowCmds\n";
       continue;
     }
  
     NoFlowOption opt;
     opt.name = args[0];
  
     noFlowOptions_.push_back(opt);
   }
  
   VPSet noFlowSets = pset.getUntrackedParameter<VPSet>("noFlowDistSets", VPSet());
   for (VPSet::const_iterator noFlowSet = noFlowSets.begin(); noFlowSet != noFlowSets.end(); ++noFlowSet) {
     NoFlowOption opt;
     opt.name = noFlowSet->getUntrackedParameter<string>("name");
  
     noFlowOptions_.push_back(opt);
   }
  
   outputFileName_ = pset.getUntrackedParameter<string>("outputFileName", "");
   subDirs_ = pset.getUntrackedParameter<vstring>("subDirs");
  
   resLimitedFit_ = pset.getUntrackedParameter<bool>("resolutionLimitedFit", false);
   isWildcardUsed_ = false;
 }

References writedatasetfile::args, cdOptions_, efficiency, efficOptions_, postValidation_cfi::efficSet(), fakerate, isWildcardUsed_, makeGlobalEffPlot_, noFlowOptions_, none, normOptions_, runTheMatrix::opt, or, outputFileName_, profileOptions_, muonDTDigis_cfi::pset, resLimitedFit_, resolOptions_, runOnEndJob_, runOnEndLumi_, simpleratio, subDirs_, dqmiodumpindices::typeName, verbose_, and HistogramManager_cfi::VPSet().

◆ ~DQMGenericClient()

DQMGenericClient::~DQMGenericClient ( )

inlineoverride

Definition at line 38 of file DQMGenericClient.cc.

38 {};

Member Function Documentation

◆ computeEfficiency()

void DQMGenericClient::computeEfficiency	(	DQMStore::IBooker &	ibooker,
		DQMStore::IGetter &	igetter,
		const std::string &	startDir,
		const std::string &	efficMEName,
		const std::string &	efficMETitle,
		const std::string &	recoMEName,
		const std::string &	simMEName,
		const EfficType	type = `EfficType::efficiency`,
		const bool	makeProfile = `false`
	)

Definition at line 671 of file DQMGenericClient.cc.

                                                                  {
   if (!igetter.dirExists(startDir)) {
     if (verbose_ >= 2 || (verbose_ == 1 && !isWildcardUsed_)) {
       LogInfo("DQMGenericClient") << "computeEfficiency() : "
                                   << "Cannot find sub-directory " << startDir << endl;
     }
     return;
   }
  
   ibooker.cd();
  
   ME* simME = igetter.get(startDir + "/" + simMEName);
   ME* recoME = igetter.get(startDir + "/" + recoMEName);
  
   if (!simME) {
     if (verbose_ >= 2 || (verbose_ == 1 && !isWildcardUsed_)) {
       LogInfo("DQMGenericClient") << "computeEfficiency() : "
                                   << "No sim-ME '" << simMEName << "' found\n";
     }
     return;
   }
  
   if (!recoME) {
     if (verbose_ >= 2 || (verbose_ == 1 && !isWildcardUsed_)) {
       LogInfo("DQMGenericClient") << "computeEfficiency() : "
                                   << "No reco-ME '" << recoMEName << "' found\n";
     }
     return;
   }
  
   // Treat everything as the base class, TH1
  
   TH1* hSim = simME->getTH1();
   TH1* hReco = recoME->getTH1();
  
   if (!hSim || !hReco) {
     if (verbose_ >= 2 || (verbose_ == 1 && !isWildcardUsed_)) {
       LogInfo("DQMGenericClient") << "computeEfficiency() : "
                                   << "Cannot create TH1 from ME\n";
     }
     return;
   }
  
   string efficDir = startDir;
   string newEfficMEName = efficMEName;
   string::size_type shiftPos;
   if (string::npos != (shiftPos = efficMEName.rfind('/'))) {
     efficDir += "/" + efficMEName.substr(0, shiftPos);
     newEfficMEName.erase(0, shiftPos + 1);
   }
   ibooker.setCurrentFolder(efficDir);
  
   if (makeProfile) {
     TProfile* efficHist = (hReco->GetXaxis()->GetXbins()->GetSize() == 0)
                               ? new TProfile(newEfficMEName.c_str(),
                                              efficMETitle.c_str(),
                                              hReco->GetXaxis()->GetNbins(),
                                              hReco->GetXaxis()->GetXmin(),
                                              hReco->GetXaxis()->GetXmax())
                               : new TProfile(newEfficMEName.c_str(),
                                              efficMETitle.c_str(),
                                              hReco->GetXaxis()->GetNbins(),
                                              hReco->GetXaxis()->GetXbins()->GetArray());
  
     efficHist->GetXaxis()->SetTitle(hSim->GetXaxis()->GetTitle());
     efficHist->GetYaxis()->SetTitle(hSim->GetYaxis()->GetTitle());
  
     for (int i = 1; i <= hReco->GetNbinsX(); i++) {
       const double nReco = hReco->GetBinContent(i);
       const double nSim = hSim->GetBinContent(i);
  
       if (!std::string(hSim->GetXaxis()->GetBinLabel(i)).empty())
         efficHist->GetXaxis()->SetBinLabel(i, hSim->GetXaxis()->GetBinLabel(i));
  
       if (nSim == 0 or nReco < 0 or nReco > nSim)
         continue;
       const double effVal = nReco / nSim;
       const double errLo = TEfficiency::ClopperPearson(nSim, nReco, 0.683, false);
       const double errUp = TEfficiency::ClopperPearson(nSim, nReco, 0.683, true);
       const double errVal = (effVal - errLo > errUp - effVal) ? effVal - errLo : errUp - effVal;
       efficHist->SetBinContent(i, effVal);
       efficHist->SetBinEntries(i, 1);
       efficHist->SetBinError(i, std::hypot(effVal, errVal));
     }
     ibooker.bookProfile(newEfficMEName, efficHist);
     delete efficHist;
   }
  
   else {
     TH1* efficHist = (TH1*)hSim->Clone(newEfficMEName.c_str());
     efficHist->SetTitle(efficMETitle.c_str());
  
     // Here is where you have trouble --- you need
     // to understand what type of hist you have.
  
     ME* efficME = nullptr;
  
     // Parse the class name
     // This works, but there might be a better way
     TClass* myHistClass = efficHist->IsA();
     TString histClassName = myHistClass->GetName();
  
     if (histClassName == "TH1F") {
       efficME = ibooker.book1D(newEfficMEName, (TH1F*)efficHist);
     } else if (histClassName == "TH2F") {
       efficME = ibooker.book2D(newEfficMEName, (TH2F*)efficHist);
     } else if (histClassName == "TH3F") {
       efficME = ibooker.book3D(newEfficMEName, (TH3F*)efficHist);
     }
  
     delete efficHist;
  
     if (!efficME) {
       LogInfo("DQMGenericClient") << "computeEfficiency() : "
                                   << "Cannot book effic-ME from the DQM\n";
       return;
     }
  
     // Update: 2009-9-16 slaunwhj
     // call the most generic efficiency function
     // works up to 3-d histograms
  
     generic_eff(hSim, hReco, efficME, type);
  
     //   const int nBin = efficME->getNbinsX();
     //   for(int bin = 0; bin <= nBin; ++bin) {
     //     const float nSim  = simME ->getBinContent(bin);
     //     const float nReco = recoME->getBinContent(bin);
     //     float eff =0;
     //     if (type=="fake")eff = nSim ? 1-nReco/nSim : 0.;
     //     else eff= nSim ? nReco/nSim : 0.;
     //     const float err = nSim && eff <= 1 ? sqrt(eff*(1-eff)/nSim) : 0.;
     //     efficME->setBinContent(bin, eff);
     //     efficME->setBinError(bin, err);
     //   }
     efficME->setEntries(simME->getEntries());
   }
  
   // Global efficiency
   if (makeGlobalEffPlot_) {
     ME* globalEfficME = igetter.get(efficDir + "/globalEfficiencies");
     if (!globalEfficME)
       globalEfficME = ibooker.book1D("globalEfficiencies", "Global efficiencies", 1, 0, 1);
     if (!globalEfficME) {
       LogInfo("DQMGenericClient") << "computeEfficiency() : "
                                   << "Cannot book globalEffic-ME from the DQM\n";
       return;
     }
     globalEfficME->setEfficiencyFlag();
     TH1F* hGlobalEffic = globalEfficME->getTH1F();
     if (!hGlobalEffic) {
       LogInfo("DQMGenericClient") << "computeEfficiency() : "
                                   << "Cannot create TH1F from ME, globalEfficME\n";
       return;
     }
  
     const float nSimAll = hSim->GetEntries();
     const float nRecoAll = hReco->GetEntries();
     float efficAll = 0;
     if (type == EfficType::efficiency || type == EfficType::simpleratio)
       efficAll = nSimAll ? nRecoAll / nSimAll : 0;
     else if (type == EfficType::fakerate)
       efficAll = nSimAll ? 1 - nRecoAll / nSimAll : 0;
     float errorAll = 0;
     if (type == EfficType::simpleratio) {
       if (nSimAll) {
         const float x = nRecoAll / nSimAll;
         errorAll = std::sqrt(1.f / nSimAll * x * (1 + x));
       }
     } else
       errorAll = nSimAll && efficAll < 1 ? sqrt(efficAll * (1 - efficAll) / nSimAll) : 0;
  
     const int iBin = hGlobalEffic->Fill(newEfficMEName.c_str(), 0);
     hGlobalEffic->SetBinContent(iBin, efficAll);
     hGlobalEffic->SetBinError(iBin, errorAll);
   }
 }

References efficiency, relativeConstraints::empty, f, fakerate, generic_eff(), mps_fire::i, isWildcardUsed_, makeGlobalEffPlot_, or, simpleratio, mathSSE::sqrt(), AlCaHLTBitMon_QueryRunRegistry::string, verbose_, and x.

Referenced by makeAllPlots().

◆ computeProfile()

void DQMGenericClient::computeProfile	(	DQMStore::IBooker &	ibooker,
		DQMStore::IGetter &	igetter,
		const std::string &	startDir,
		const std::string &	profileMEName,
		const std::string &	profileMETitle,
		const std::string &	srcMEName
	)

Definition at line 934 of file DQMGenericClient.cc.

                                                                   {
   if (!igetter.dirExists(startDir)) {
     if (verbose_ >= 2 || (verbose_ == 1 && !isWildcardUsed_)) {
       LogInfo("DQMGenericClient") << "computeProfile() : "
                                   << "Cannot find sub-directory " << startDir << endl;
     }
     return;
   }
  
   ibooker.cd();
  
   ME* srcME = igetter.get(startDir + "/" + srcMEName);
   if (!srcME) {
     if (verbose_ >= 2 || (verbose_ == 1 && !isWildcardUsed_)) {
       LogInfo("DQMGenericClient") << "computeProfile() : "
                                   << "No source ME '" << srcMEName << "' found\n";
     }
     return;
   }
  
   TH2F* hSrc = srcME->getTH2F();
   if (!hSrc) {
     if (verbose_ >= 2 || (verbose_ == 1 && !isWildcardUsed_)) {
       LogInfo("DQMGenericClient") << "computeProfile() : "
                                   << "Cannot create TH2F from source-ME\n";
     }
     return;
   }
  
   string profileDir = startDir;
   string newProfileMEName = profileMEName;
   string::size_type shiftPos;
   if (string::npos != (shiftPos = profileMEName.rfind('/'))) {
     profileDir += "/" + profileMEName.substr(0, shiftPos);
     newProfileMEName.erase(0, shiftPos + 1);
   }
   ibooker.setCurrentFolder(profileDir);
  
   std::unique_ptr<TProfile> profile(hSrc->ProfileX());  // We own the pointer
   profile->SetTitle(profileMETitle.c_str());
   ibooker.bookProfile(profileMEName, profile.get());  // ibooker makes a copy
 }

References isWildcardUsed_, PostProcessor_cff::profile, and verbose_.

Referenced by makeAllPlots().

◆ computeResolution()

void DQMGenericClient::computeResolution	(	DQMStore::IBooker &	ibooker,
		DQMStore::IGetter &	igetter,
		const std::string &	startDir,
		const std::string &	fitMEPrefix,
		const std::string &	fitMETitlePrefix,
		const std::string &	srcMEName
	)

Definition at line 857 of file DQMGenericClient.cc.

                                                                    {
   if (!igetter.dirExists(startDir)) {
     if (verbose_ >= 2 || (verbose_ == 1 && !isWildcardUsed_)) {
       LogInfo("DQMGenericClient") << "computeResolution() : "
                                   << "Cannot find sub-directory " << startDir << endl;
     }
     return;
   }
  
   ibooker.cd();
  
   ME* srcME = igetter.get(startDir + "/" + srcName);
   if (!srcME) {
     if (verbose_ >= 2 || (verbose_ == 1 && !isWildcardUsed_)) {
       LogInfo("DQMGenericClient") << "computeResolution() : "
                                   << "No source ME '" << srcName << "' found\n";
     }
     return;
   }
  
   TH2F* hSrc = srcME->getTH2F();
   if (!hSrc) {
     if (verbose_ >= 2 || (verbose_ == 1 && !isWildcardUsed_)) {
       LogInfo("DQMGenericClient") << "computeResolution() : "
                                   << "Cannot create TH2F from source-ME\n";
     }
     return;
   }
  
   const int nBin = hSrc->GetNbinsX();
  
   string newDir = startDir;
   string newPrefix = namePrefix;
   string::size_type shiftPos;
   if (string::npos != (shiftPos = namePrefix.rfind('/'))) {
     newDir += "/" + namePrefix.substr(0, shiftPos);
     newPrefix.erase(0, shiftPos + 1);
   }
  
   ibooker.setCurrentFolder(newDir);
  
   float* lowedgesfloats = new float[nBin + 1];
   ME* meanME;
   ME* sigmaME;
   if (hSrc->GetXaxis()->GetXbins()->GetSize()) {
     for (int j = 0; j < nBin + 1; ++j)
       lowedgesfloats[j] = (float)hSrc->GetXaxis()->GetXbins()->GetAt(j);
     meanME = ibooker.book1D(newPrefix + "_Mean", titlePrefix + " Mean", nBin, lowedgesfloats);
     sigmaME = ibooker.book1D(newPrefix + "_Sigma", titlePrefix + " Sigma", nBin, lowedgesfloats);
   } else {
     meanME = ibooker.book1D(
         newPrefix + "_Mean", titlePrefix + " Mean", nBin, hSrc->GetXaxis()->GetXmin(), hSrc->GetXaxis()->GetXmax());
     sigmaME = ibooker.book1D(
         newPrefix + "_Sigma", titlePrefix + " Sigma", nBin, hSrc->GetXaxis()->GetXmin(), hSrc->GetXaxis()->GetXmax());
   }
  
   if (meanME && sigmaME) {
     meanME->setEfficiencyFlag();
     sigmaME->setEfficiencyFlag();
  
     if (!resLimitedFit_) {
       FitSlicesYTool fitTool(srcME);
       fitTool.getFittedMeanWithError(meanME);
       fitTool.getFittedSigmaWithError(sigmaME);
     } else {
       limitedFit(srcME, meanME, sigmaME);
     }
   }
   delete[] lowedgesfloats;
 }

References FitSlicesYTool::getFittedMeanWithError(), FitSlicesYTool::getFittedSigmaWithError(), isWildcardUsed_, dqmiolumiharvest::j, limitedFit(), postValidation_cfi::namePrefix, PFElectronDQMAnalyzer_cfi::nBin, resLimitedFit_, postValidation_cfi::srcName, L1TdeStage2uGMT_cff::titlePrefix, and verbose_.

Referenced by makeAllPlots().

◆ dqmEndJob()

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

inlineoverride

Definition at line 45 of file DQMGenericClient.cc.

45 {};

◆ dqmEndLuminosityBlock()

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

override

Definition at line 561 of file DQMGenericClient.cc.

                                                                      {
   if (runOnEndLumi_) {
     makeAllPlots(ibooker, igetter);
   }
 }

References makeAllPlots(), and runOnEndLumi_.

◆ dqmEndRun()

void DQMGenericClient::dqmEndRun	(	DQMStore::IBooker &	ibooker,
		DQMStore::IGetter &	igetter,
		edm::Run const &	,
		edm::EventSetup const &
	)

override

Definition at line 570 of file DQMGenericClient.cc.

                                                        {
   // Create new MEs in endRun, even though we are requested to do it in endJob.
   // This gives the QTests a chance to run, before summaries are created in
   // endJob. The negative side effect is that we cannot run the GenericClient
   // for plots produced in Harvesting, but that seems rather rare.
   //
   // It is important that this is still save in the presence of multiple runs,
   // first because in multi-run harvesting, we accumulate statistics over all
   // runs and have full statistics at the endRun of the last run, and second,
   // because we set the efficiencyFlag so any further aggregation should produce
   // correct results. Also, all operations should be idempotent; running them
   // more than once does no harm.
  
   // needed to access the DQMStore::save method
   theDQM = nullptr;
   theDQM = Service<DQMStore>().operator->();
  
   if (runOnEndJob_) {
     makeAllPlots(ibooker, igetter);
   }
  
   if (!outputFileName_.empty())
     theDQM->save(outputFileName_);
 }

References makeAllPlots(), outputFileName_, runOnEndJob_, and theDQM.

◆ findAllSubdirectories()

void DQMGenericClient::findAllSubdirectories	(	DQMStore::IBooker &	ibooker,
		DQMStore::IGetter &	igetter,
		std::string	dir,
		std::set< std::string > *	myList,
		const TString &	pattern = `TString("")`
	)

private

Definition at line 1190 of file DQMGenericClient.cc.

                                                                                     {
   TString pattern = _pattern;
   if (!igetter.dirExists(dir)) {
     LogError("DQMGenericClient") << " DQMGenericClient::findAllSubdirectories ==> Missing folder " << dir << " !!!";
     return;
   }
   if (pattern != "") {
     if (pattern.Contains(nonPerlWildcard_))
       pattern.ReplaceAll("*", ".*");
     TPRegexp regexp(pattern);
     ibooker.cd(dir);
     vector<string> foundDirs = igetter.getSubdirs();
     for (vector<string>::const_iterator iDir = foundDirs.begin(); iDir != foundDirs.end(); ++iDir) {
       TString dirName = iDir->substr(iDir->rfind('/') + 1, iDir->length());
       if (dirName.Contains(regexp))
         findAllSubdirectories(ibooker, igetter, *iDir, myList);
     }
   }
   //std::cout << "Looking for directory " << dir ;
   else if (igetter.dirExists(dir)) {
     //std::cout << "... it exists! Inserting it into the list ";
     myList->insert(dir);
     //std::cout << "... now list has size " << myList->size() << std::endl;
     ibooker.cd(dir);
     findAllSubdirectories(ibooker, igetter, dir, myList, "*");
   } else {
     //std::cout << "... DOES NOT EXIST!!! Skip bogus dir" << std::endl;
  
     LogInfo("DQMGenericClient") << "Trying to find sub-directories of " << dir << " failed because " << dir
                                 << " does not exist";
   }
   return;
 }

References DeadROC_duringRun::dir, TrackerOfflineValidation_Dqm_cff::dirName, PatBasicFWLiteJetAnalyzer_Selector_cfg::myList, nonPerlWildcard_, topSingleLeptonDQM_PU_cfi::pattern, and fetchall_from_DQM_v2::regexp.

Referenced by makeAllPlots().

◆ generic_eff()

void DQMGenericClient::generic_eff	(	TH1 *	denom,
		TH1 *	numer,
		MonitorElement *	efficiencyHist,
		const EfficType	type = `EfficType::efficiency`
	)

private

Definition at line 1228 of file DQMGenericClient.cc.

                                                                                                                {
   for (int iBinX = 1; iBinX < denom->GetNbinsX() + 1; iBinX++) {
     for (int iBinY = 1; iBinY < denom->GetNbinsY() + 1; iBinY++) {
       for (int iBinZ = 1; iBinZ < denom->GetNbinsZ() + 1; iBinZ++) {
         int globalBinNum = denom->GetBin(iBinX, iBinY, iBinZ);
  
         float numerVal = numer->GetBinContent(globalBinNum);
         float denomVal = denom->GetBinContent(globalBinNum);
  
         float effVal = 0;
  
         // fake eff is in use
         if (type == EfficType::fakerate) {
           effVal = denomVal ? (1 - numerVal / denomVal) : 0;
         } else {
           effVal = denomVal ? numerVal / denomVal : 0;
         }
  
         float errVal = 0;
         if (type == EfficType::simpleratio) {
           //          errVal = denomVal ? 1.f/denomVal*effVal*(1+effVal) : 0;
           float numerErr = numer->GetBinError(globalBinNum);
           float denomErr = denom->GetBinError(globalBinNum);
           float denomsq = denomVal * denomVal;
           errVal = denomVal ? sqrt(pow(1.f / denomVal * numerErr, 2.0) + pow(numerVal / denomsq * denomErr, 2)) : 0;
         } else {
           errVal = (denomVal && (effVal <= 1)) ? sqrt(effVal * (1 - effVal) / denomVal) : 0;
         }
  
         LogDebug("DQMGenericClient") << "(iBinX, iBinY, iBinZ)  = " << iBinX << ", " << iBinY << ", " << iBinZ
                                      << "), global bin =  " << globalBinNum << "eff = " << numerVal << "  /  "
                                      << denomVal << " =  " << effVal << " ... setting the error for that bin ... "
                                      << endl
                                      << endl;
  
         efficiencyHist->setBinContent(globalBinNum, effVal);
         efficiencyHist->setBinError(globalBinNum, errVal);
         efficiencyHist->setEfficiencyFlag();
       }
     }
   }
  
   //efficiencyHist->setMinimum(0.0);
   //efficiencyHist->setMaximum(1.0);
 }

References makePileupJSON::denom, f, fakerate, LogDebug, funct::pow(), dqm::impl::MonitorElement::setBinContent(), dqm::impl::MonitorElement::setBinError(), dqm::impl::MonitorElement::setEfficiencyFlag(), simpleratio, and mathSSE::sqrt().

Referenced by computeEfficiency().

◆ limitedFit()

void DQMGenericClient::limitedFit	(	MonitorElement *	srcME,
		MonitorElement *	meanME,
		MonitorElement *	sigmaME
	)

Definition at line 1137 of file DQMGenericClient.cc.

                                                                                                         {
   TH2F* histo = srcME->getTH2F();
  
   static int i = 0;
   i++;
  
   // Fit slices projected along Y from bins in X
   double cont_min = 100;  //Minimum number of entries
   Int_t binx = histo->GetXaxis()->GetNbins();
  
   for (int i = 1; i <= binx; i++) {
     TString iString(i);
     TH1* histoY = histo->ProjectionY(" ", i, i);
     double cont = histoY->GetEntries();
  
     if (cont >= cont_min) {
       float minfit = histoY->GetMean() - histoY->GetRMS();
       float maxfit = histoY->GetMean() + histoY->GetRMS();
  
       TF1* fitFcn = new TF1(TString("g") + histo->GetName() + iString, "gaus", minfit, maxfit);
       double x1, x2;
       fitFcn->GetRange(x1, x2);
  
       histoY->Fit(fitFcn, "QR0 SERIAL", "", x1, x2);
  
       //      histoY->Fit(fitFcn->GetName(),"RME");
       double* par = fitFcn->GetParameters();
       const double* err = fitFcn->GetParErrors();
  
       meanME->setBinContent(i, par[1]);
       meanME->setBinError(i, err[1]);
       //       meanME->setBinEntries(i, 1.);
       //       meanME->setBinError(i,sqrt(err[1]*err[1]+par[1]*par[1]));
  
       sigmaME->setBinContent(i, par[2]);
       sigmaME->setBinError(i, err[2]);
       //       sigmaME->setBinEntries(i, 1.);
       //       sigmaME->setBinError(i,sqrt(err[2]*err[2]+par[2]*par[2]));
  
       if (fitFcn)
         delete fitFcn;
       if (histoY)
         delete histoY;
     } else {
       if (histoY)
         delete histoY;
       continue;
     }
   }
 }

References generateEDF::cont, runTheMatrix::err, dqm::legacy::MonitorElement::getTH2F(), timingPdfMaker::histo, mps_fire::i, dqm::impl::MonitorElement::setBinContent(), dqm::impl::MonitorElement::setBinError(), tools::TF1, testProducerWithPsetDescEmpty_cfi::x1, and testProducerWithPsetDescEmpty_cfi::x2.

Referenced by computeResolution().

◆ makeAllPlots()

void DQMGenericClient::makeAllPlots	(	DQMStore::IBooker &	ibooker,
		DQMStore::IGetter &	igetter
	)

private

Definition at line 598 of file DQMGenericClient.cc.

                                                                                       {
   typedef vector<string> vstring;
  
   // Process wildcard in the sub-directory
   set<string> subDirSet;
  
   for (vstring::const_iterator iSubDir = subDirs_.begin(); iSubDir != subDirs_.end(); ++iSubDir) {
     string subDir = *iSubDir;
  
     if (subDir[subDir.size() - 1] == '/')
       subDir.erase(subDir.size() - 1);
  
     if (TString(subDir).Contains(metacharacters_)) {
       isWildcardUsed_ = true;
  
       const string::size_type shiftPos = subDir.rfind('/');
       const string searchPath = subDir.substr(0, shiftPos);
       const string pattern = subDir.substr(shiftPos + 1, subDir.length());
       //std::cout << "\n\n\n\nLooking for all subdirs of " << subDir << std::endl;
  
       findAllSubdirectories(ibooker, igetter, searchPath, &subDirSet, pattern);
  
     } else {
       subDirSet.insert(subDir);
     }
   }
  
   for (set<string>::const_iterator iSubDir = subDirSet.begin(); iSubDir != subDirSet.end(); ++iSubDir) {
     const string& dirName = *iSubDir;
  
     // First normalize, then move under/overflows, then make
     // cumulative, and only then efficiency This allows to use the
     // cumulative distributions for efficiency calculation
     for (vector<NormOption>::const_iterator normOption = normOptions_.begin(); normOption != normOptions_.end();
          ++normOption) {
       normalizeToEntries(ibooker, igetter, dirName, normOption->name, normOption->normHistName);
     }
  
     for (vector<NoFlowOption>::const_iterator noFlowOption = noFlowOptions_.begin();
          noFlowOption != noFlowOptions_.end();
          ++noFlowOption) {
       makeNoFlowDist(ibooker, igetter, dirName, noFlowOption->name);
     }
  
     for (vector<CDOption>::const_iterator cdOption = cdOptions_.begin(); cdOption != cdOptions_.end(); ++cdOption) {
       makeCumulativeDist(ibooker, igetter, dirName, cdOption->name, cdOption->ascending);
     }
  
     for (vector<EfficOption>::const_iterator efficOption = efficOptions_.begin(); efficOption != efficOptions_.end();
          ++efficOption) {
       computeEfficiency(ibooker,
                         igetter,
                         dirName,
                         efficOption->name,
                         efficOption->title,
                         efficOption->numerator,
                         efficOption->denominator,
                         efficOption->type,
                         efficOption->isProfile);
     }
  
     for (vector<ResolOption>::const_iterator resolOption = resolOptions_.begin(); resolOption != resolOptions_.end();
          ++resolOption) {
       computeResolution(
           ibooker, igetter, dirName, resolOption->namePrefix, resolOption->titlePrefix, resolOption->srcName);
     }
  
     for (const auto& profileOption : profileOptions_) {
       computeProfile(ibooker, igetter, dirName, profileOption.name, profileOption.title, profileOption.srcName);
     }
   }
 }

References cdOptions_, computeEfficiency(), computeProfile(), computeResolution(), TrackerOfflineValidation_Dqm_cff::dirName, efficOptions_, findAllSubdirectories(), isWildcardUsed_, makeCumulativeDist(), makeNoFlowDist(), metacharacters_, noFlowOptions_, normalizeToEntries(), normOptions_, topSingleLeptonDQM_PU_cfi::pattern, profileOptions_, resolOptions_, PostProcessorHcalIsoTrack_cfi::subDir, and subDirs_.

Referenced by dqmEndLuminosityBlock(), and dqmEndRun().

◆ makeCumulativeDist()

void DQMGenericClient::makeCumulativeDist	(	DQMStore::IBooker &	ibooker,
		DQMStore::IGetter &	igetter,
		const std::string &	startDir,
		const std::string &	cdName,
		bool	ascending = `true`
	)

Definition at line 1045 of file DQMGenericClient.cc.

                                                           {
   if (!igetter.dirExists(startDir)) {
     if (verbose_ >= 2 || (verbose_ == 1 && !isWildcardUsed_)) {
       LogInfo("DQMGenericClient") << "makeCumulativeDist() : "
                                   << "Cannot find sub-directory " << startDir << endl;
     }
     return;
   }
  
   ibooker.cd();
  
   ME* element_cd = igetter.get(startDir + "/" + cdName);
  
   if (!element_cd) {
     if (verbose_ >= 2 || (verbose_ == 1 && !isWildcardUsed_)) {
       LogInfo("DQMGenericClient") << "makeCumulativeDist() : "
                                   << "No such element '" << cdName << "' found\n";
     }
     return;
   }
  
   TH1F* cd = element_cd->getTH1F();
  
   if (!cd) {
     if (verbose_ >= 2 || (verbose_ == 1 && !isWildcardUsed_)) {
       LogInfo("DQMGenericClient") << "makeCumulativeDist() : "
                                   << "Cannot create TH1F from ME\n";
     }
     return;
   }
  
   int n_bins = cd->GetNbinsX() + 1;
  
   if (ascending) {
     for (int i = 1; i <= n_bins; i++) {
       cd->SetBinContent(i, cd->GetBinContent(i) + cd->GetBinContent(i - 1));
     }
   } else {
     for (int i = n_bins - 1; i >= 0; i--) {  // n_bins points to the overflow bin
       cd->SetBinContent(i, cd->GetBinContent(i) + cd->GetBinContent(i + 1));
     }
   }
  
   return;
 }

References hippyaddtobaddatafiles::cd(), mps_fire::i, isWildcardUsed_, and verbose_.

Referenced by makeAllPlots().

◆ makeNoFlowDist()

void DQMGenericClient::makeNoFlowDist	(	DQMStore::IBooker &	ibooker,
		DQMStore::IGetter &	igetter,
		const std::string &	startDir,
		const std::string &	cdName
	)

Definition at line 1095 of file DQMGenericClient.cc.

                                                                    {
   if (!igetter.dirExists(startDir)) {
     if (verbose_ >= 2 || (verbose_ == 1 && !isWildcardUsed_)) {
       LogInfo("DQMGenericClient") << "makeNoFlowDist() : "
                                   << "Cannot find sub-directory " << startDir << endl;
     }
     return;
   }
  
   ibooker.cd();
  
   ME* element_noFlow = igetter.get(startDir + "/" + noFlowName);
  
   if (!element_noFlow) {
     if (verbose_ >= 2 || (verbose_ == 1 && !isWildcardUsed_)) {
       LogInfo("DQMGenericClient") << "makeNoFlowDist() : "
                                   << "No such element '" << noFlowName << "' found\n";
     }
     return;
   }
  
   TH1F* noFlow = element_noFlow->getTH1F();
  
   if (!noFlow) {
     if (verbose_ >= 2 || (verbose_ == 1 && !isWildcardUsed_)) {
       LogInfo("DQMGenericClient") << "makeNoFlowDist() : "
                                   << "Cannot create TH1F from ME\n";
     }
     return;
   }
  
   noFlow->AddBinContent(1, noFlow->GetBinContent(0));
   noFlow->SetBinContent(0, 0.);
  
   const auto lastBin = noFlow->GetNbinsX();
   noFlow->AddBinContent(lastBin, noFlow->GetBinContent(lastBin + 1));
   noFlow->SetBinContent(lastBin + 1, 0.);
 }

References isWildcardUsed_, and verbose_.

Referenced by makeAllPlots().

◆ normalizeToEntries()

void DQMGenericClient::normalizeToEntries	(	DQMStore::IBooker &	ibooker,
		DQMStore::IGetter &	igetter,
		const std::string &	startDir,
		const std::string &	histName,
		const std::string &	normHistName
	)

Definition at line 982 of file DQMGenericClient.cc.

                                                                          {
   if (!igetter.dirExists(startDir)) {
     if (verbose_ >= 2 || (verbose_ == 1 && !isWildcardUsed_)) {
       LogInfo("DQMGenericClient") << "normalizeToEntries() : "
                                   << "Cannot find sub-directory " << startDir << endl;
     }
     return;
   }
  
   ibooker.cd();
  
   ME* element = igetter.get(startDir + "/" + histName);
   ME* normME = igetter.get(startDir + "/" + normHistName);
  
   if (!element) {
     if (verbose_ >= 2 || (verbose_ == 1 && !isWildcardUsed_)) {
       LogInfo("DQMGenericClient") << "normalizeToEntries() : "
                                   << "No such element '" << histName << "' found\n";
     }
     return;
   }
  
   if (!normME) {
     if (verbose_ >= 2 || (verbose_ == 1 && !isWildcardUsed_)) {
       LogInfo("DQMGenericClient") << "normalizeToEntries() : "
                                   << "No such element '" << normHistName << "' found\n";
     }
     return;
   }
  
   TH1F* hist = element->getTH1F();
   if (!hist) {
     if (verbose_ >= 2 || (verbose_ == 1 && !isWildcardUsed_)) {
       LogInfo("DQMGenericClient") << "normalizeToEntries() : "
                                   << "Cannot create TH1F from ME\n";
     }
     return;
   }
  
   TH1F* normHist = normME->getTH1F();
   if (!normHist) {
     if (verbose_ >= 2 || (verbose_ == 1 && !isWildcardUsed_)) {
       LogInfo("DQMGenericClient") << "normalizeToEntries() : "
                                   << "Cannot create TH1F from ME\n";
     }
     return;
   }
  
   const double entries = normHist->GetEntries();
   if (entries != 0) {
     hist->Scale(1. / entries);
   } else {
     LogInfo("DQMGenericClient") << "normalizeToEntries() : "
                                 << "Zero entries in histogram\n";
   }
  
   return;
 }

References compare::hist, isWildcardUsed_, and verbose_.

Referenced by makeAllPlots().

◆ removeMEIfBooked()

void DQMGenericClient::removeMEIfBooked	(	const std::string &	meName,
		DQMStore::IGetter &	igetter
	)

private

Member Data Documentation

◆ cdOptions_

std::vector<CDOption> DQMGenericClient::cdOptions_

private

Definition at line 136 of file DQMGenericClient.cc.

Referenced by DQMGenericClient(), and makeAllPlots().

◆ efficOptions_

std::vector<EfficOption> DQMGenericClient::efficOptions_

private

Definition at line 132 of file DQMGenericClient.cc.

Referenced by DQMGenericClient(), and makeAllPlots().

◆ isWildcardUsed_

bool DQMGenericClient::isWildcardUsed_

private

Definition at line 125 of file DQMGenericClient.cc.

Referenced by computeEfficiency(), computeProfile(), computeResolution(), DQMGenericClient(), makeAllPlots(), makeCumulativeDist(), makeNoFlowDist(), and normalizeToEntries().

◆ makeGlobalEffPlot_

bool DQMGenericClient::makeGlobalEffPlot_

private

Definition at line 124 of file DQMGenericClient.cc.

Referenced by computeEfficiency(), and DQMGenericClient().

◆ metacharacters_

TPRegexp DQMGenericClient::metacharacters_

private

Definition at line 119 of file DQMGenericClient.cc.

Referenced by makeAllPlots().

◆ noFlowOptions_

std::vector<NoFlowOption> DQMGenericClient::noFlowOptions_

private

Definition at line 137 of file DQMGenericClient.cc.

Referenced by DQMGenericClient(), and makeAllPlots().

◆ nonPerlWildcard_

TPRegexp DQMGenericClient::nonPerlWildcard_

private

Definition at line 120 of file DQMGenericClient.cc.

Referenced by findAllSubdirectories().

◆ normOptions_

std::vector<NormOption> DQMGenericClient::normOptions_

private

Definition at line 135 of file DQMGenericClient.cc.

Referenced by DQMGenericClient(), and makeAllPlots().

◆ outputFileName_

std::string DQMGenericClient::outputFileName_

private

Definition at line 130 of file DQMGenericClient.cc.

Referenced by dqmEndRun(), and DQMGenericClient().

◆ profileOptions_

std::vector<ProfileOption> DQMGenericClient::profileOptions_

private

Definition at line 134 of file DQMGenericClient.cc.

Referenced by DQMGenericClient(), and makeAllPlots().

◆ resLimitedFit_

bool DQMGenericClient::resLimitedFit_

private

Definition at line 126 of file DQMGenericClient.cc.

Referenced by computeResolution(), and DQMGenericClient().

◆ resolOptions_

std::vector<ResolOption> DQMGenericClient::resolOptions_

private

Definition at line 133 of file DQMGenericClient.cc.

Referenced by DQMGenericClient(), and makeAllPlots().

◆ runOnEndJob_

bool DQMGenericClient::runOnEndJob_

private

Definition at line 123 of file DQMGenericClient.cc.

Referenced by dqmEndRun(), and DQMGenericClient().

◆ runOnEndLumi_

bool DQMGenericClient::runOnEndLumi_

private

Definition at line 122 of file DQMGenericClient.cc.

Referenced by dqmEndLuminosityBlock(), and DQMGenericClient().

◆ subDirs_

std::vector<std::string> DQMGenericClient::subDirs_

private

Definition at line 129 of file DQMGenericClient.cc.

Referenced by DQMGenericClient(), and makeAllPlots().

◆ theDQM

DQMStore* DQMGenericClient::theDQM

private

Definition at line 128 of file DQMGenericClient.cc.

Referenced by dqmEndRun().

◆ verbose_

unsigned int DQMGenericClient::verbose_

private

Definition at line 121 of file DQMGenericClient.cc.

Referenced by computeEfficiency(), computeProfile(), computeResolution(), DQMGenericClient(), makeCumulativeDist(), makeNoFlowDist(), and normalizeToEntries().

Classes

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ EfficType

Constructor & Destructor Documentation

◆ DQMGenericClient()

◆ ~DQMGenericClient()

Member Function Documentation

◆ computeEfficiency()

◆ computeProfile()

◆ computeResolution()

◆ dqmEndJob()

◆ dqmEndLuminosityBlock()

◆ dqmEndRun()

◆ findAllSubdirectories()

◆ generic_eff()

◆ limitedFit()

◆ makeAllPlots()

◆ makeCumulativeDist()

◆ makeNoFlowDist()

◆ normalizeToEntries()

◆ removeMEIfBooked()

Member Data Documentation

◆ cdOptions_

◆ efficOptions_

◆ isWildcardUsed_

◆ makeGlobalEffPlot_

◆ metacharacters_

◆ noFlowOptions_

◆ nonPerlWildcard_

◆ normOptions_

◆ outputFileName_

◆ profileOptions_

◆ resLimitedFit_

◆ resolOptions_

◆ runOnEndJob_

◆ runOnEndLumi_

◆ subDirs_

◆ theDQM

◆ verbose_