DQMGenericClient Class Reference

#include <DQMGenericClient.h>

Inheritance diagram for DQMGenericClient:

Classes
struct	CDOption
struct	EfficOption
struct	NormOption
struct	ProfileOption
struct	ResolOption

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 int type=1, 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
	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	normalizeToEntries (DQMStore::IBooker &ibooker, DQMStore::IGetter &igetter, const std::string &startDir, const std::string &histName, const std::string &normHistName)
	~DQMGenericClient ()
Public Member Functions inherited from DQMEDHarvester
virtual void	analyze (edm::Event const &, edm::EventSetup const &) final
virtual void	beginLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) final
virtual void	beginRun (edm::Run const &, edm::EventSetup const &)
	DQMEDHarvester (void)
virtual void	dqmEndLuminosityBlock (DQMStore::IBooker &, DQMStore::IGetter &, edm::LuminosityBlock const &, edm::EventSetup const &)
virtual void	endJob () final
virtual void	endLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) final
virtual void	endRun (edm::Run const &, edm::EventSetup const &)
Public Member Functions inherited from edm::one::EDAnalyzer< edm::one::WatchRuns, edm::one::WatchLuminosityBlocks, edm::one::SharedResources >
	EDAnalyzer ()=default
Public Member Functions inherited from edm::one::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
	EDAnalyzerBase ()
ModuleDescription const &	moduleDescription () const
virtual	~EDAnalyzerBase ()
Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const
	EDConsumerBase ()
	EDConsumerBase (EDConsumerBase const &)=delete
	EDConsumerBase (EDConsumerBase &&)=default
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 &	itemsToGetFromEvent () const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, 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	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
virtual	~EDConsumerBase () noexcept(false)

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 int type=1)

Private Attributes
std::vector< CDOption >	cdOptions_
std::vector< EfficOption >	efficOptions_
bool	isWildcardUsed_
std::vector< NormOption >	normOptions_
std::string	outputFileName_
std::vector< ProfileOption >	profileOptions_
bool	resLimitedFit_
std::vector< ResolOption >	resolOptions_
std::vector< std::string >	subDirs_
DQMStore *	theDQM
unsigned int	verbose_

Additional Inherited Members
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels
Static Public Member Functions inherited from edm::one::EDAnalyzerBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)
Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
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 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)

Detailed Description

Definition at line 28 of file DQMGenericClient.h.

Constructor & Destructor Documentation

DQMGenericClient::DQMGenericClient

(

const edm::ParameterSet &

pset

)

Definition at line 34 of file DQMGenericClient.cc.

References createfilelist::args, DQMGenericClient::CDOption::ascending, DQMGenericClient::EfficOption::denominator, genericClientPSetHelper_cff::efficSet(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), DQMGenericClient::EfficOption::isProfile, DQMGenericClient::EfficOption::name, DQMGenericClient::ProfileOption::name, DQMGenericClient::NormOption::name, DQMGenericClient::CDOption::name, DQMGenericClient::ResolOption::namePrefix, DQMGenericClient::NormOption::normHistName, DQMGenericClient::EfficOption::numerator, or, DQMGenericClient::ResolOption::srcName, DQMGenericClient::ProfileOption::srcName, DQMGenericClient::EfficOption::title, DQMGenericClient::ProfileOption::title, DQMGenericClient::ResolOption::titlePrefix, DQMGenericClient::EfficOption::type, and HistogramManager_cfi::VPSet().

{
  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);

  // 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 = 1;
    else if ( typeName == "fake" ) opt.type = 2;
    else opt.type = 0;
 
    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 = 1;
    else if ( typeName == "fake" ) opt.type = 2;
    else opt.type = 0;

    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 = 1;
    else if ( typeName == "fake" ) opt.type = 2;
    else opt.type = 0;
 
    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 = 1;
    else if ( typeName == "fake" ) opt.type = 2;
    else opt.type = 0;

    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.size() == 0 || 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);
  }

  outputFileName_ = pset.getUntrackedParameter<string>("outputFileName", "");
  subDirs_ = pset.getUntrackedParameter<vstring>("subDirs");

  resLimitedFit_ = pset.getUntrackedParameter<bool>("resolutionLimitedFit",false);
  isWildcardUsed_ = false;
}

DQMGenericClient::~DQMGenericClient ( )

inline

Definition at line 32 of file DQMGenericClient.h.

References dqmEndJob().

{};

Member Function Documentation

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 int	type = 1,
		const bool	makeProfile = false
	)

Definition at line 401 of file DQMGenericClient.cc.

References DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), DQMStore::IBooker::book3D(), DQMStore::IBooker::bookProfile(), DQMStore::IBooker::cd(), DQMStore::IGetter::dirExists(), DQMStore::IGetter::get(), i, DQMStore::IBooker::setCurrentFolder(), mathSSE::sqrt(), and AlCaHLTBitMon_QueryRunRegistry::string.

{
  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());

#if ROOT_VERSION_CODE >= ROOT_VERSION(5,27,0)
    for (int i=1; i <= hReco->GetNbinsX(); i++) {

      const double nReco = hReco->GetBinContent(i);
      const double nSim = hSim->GetBinContent(i);
      if(nSim > INT_MAX || nSim < INT_MIN || nReco > INT_MAX || nReco < INT_MIN)
    {
      LogError("DQMGenericClient")  << "computeEfficiency() : "
                    << "Overflow: bin content either too large or too small to be casted to int";
      return;
    }

      if(std::string(hSim->GetXaxis()->GetBinLabel(i)) != "")
    efficHist->GetXaxis()->SetBinLabel(i, hSim->GetXaxis()->GetBinLabel(i));
      
      if ( nSim == 0 || nReco > nSim ) continue;
      const double effVal = nReco/nSim;

      const double errLo = TEfficiency::ClopperPearson((int)nSim, 
                               (int)nReco,
                               0.683,false);
      const double errUp = TEfficiency::ClopperPearson((int)nSim, 
                               (int)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, sqrt(effVal * effVal + errVal * errVal));
    }
#else
    for (int i=1; i <= hReco->GetNbinsX(); i++) {

      const double nReco = hReco->GetBinContent(i);
      const double nSim = hSim->GetBinContent(i);
      if(nSim > INT_MAX || nSim < INT_MIN || nReco > INT_MAX || nReco < INT_MIN)
        {
          LogError("DQMGenericClient")  << "computeEfficiency() : "
                                        << "Overflow: bin content either too large or too small to be casted to int";
          return;
        }

      TGraphAsymmErrorsWrapper asymm;
      std::pair<double, double> efficiencyWithError;
      efficiencyWithError = asymm.efficiency((int)nReco,
                                             (int)nSim);
      double effVal = efficiencyWithError.first;
      double errVal = efficiencyWithError.second;
      if ((int)nSim > 0) {
        efficHist->SetBinContent(i, effVal);
        efficHist->SetBinEntries(i, 1);
        efficHist->SetBinError(i, sqrt(effVal * effVal + errVal * errVal));
      }
      if(std::string(hSim->GetXaxis()->GetBinLabel(i)) != "")
    efficHist->GetXaxis()->SetBinLabel(i, hSim->GetXaxis()->GetBinLabel(i));
    }
#endif
    ibooker.bookProfile(newEfficMEName.c_str(),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 = 0;

    // 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);    
    } 
  

    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
  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 == 1 ) efficAll = nSimAll ? nRecoAll/nSimAll : 0;
  else if ( type == 2 ) efficAll = nSimAll ? 1-nRecoAll/nSimAll : 0;
  const float 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);
}

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 687 of file DQMGenericClient.cc.

References DQMStore::IBooker::bookProfile(), DQMStore::IBooker::cd(), DQMStore::IGetter::dirExists(), DQMStore::IGetter::get(), and DQMStore::IBooker::setCurrentFolder().

                                                                                                                                                                                                                {
  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
}

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 607 of file DQMGenericClient.cc.

References DQMStore::IBooker::book1D(), DQMStore::IBooker::cd(), DQMStore::IGetter::dirExists(), DQMStore::IGetter::get(), FitSlicesYTool::getFittedMeanWithError(), FitSlicesYTool::getFittedSigmaWithError(), j, postValidation_cfi::namePrefix, and DQMStore::IBooker::setCurrentFolder().

{
  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;
}

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

overridevirtual

Implements DQMEDHarvester.

Definition at line 312 of file DQMGenericClient.cc.

References TrackerOfflineValidation_Dqm_cff::dirName, metacharacters(), cppFunctionSkipper::operator, listBenchmarks::pattern, and muonValidation_cff::subDir.

Referenced by ~DQMGenericClient().

                                                                                     {

  typedef vector<string> vstring;

  // Update 2014-04-02
  // Migrated back to the endJob. the DQMFileSaver logic has
  // to be reviewed to guarantee that the endJob is properly
  // considered. The splitting per run is done centrally when
  // running the harvesting in production

  // Update 2009-09-23
  // Migrated all code from endJob to this function
  // endJob is not necessarily called in the proper sequence
  // and does not necessarily book histograms produced in
  // that step.
  // It more robust to do the histogram manipulation in
  // this endRun function

  // needed to access the DQMStore::save method
  theDQM = 0;
  theDQM = Service<DQMStore>().operator->();

  // 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 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<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);
    }

  }

  if ( ! outputFileName_.empty() ) theDQM->save(outputFileName_);
  
}

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 893 of file DQMGenericClient.cc.

References DQMStore::IBooker::cd(), DQMStore::IGetter::dirExists(), TrackerOfflineValidation_Dqm_cff::dirName, DQMStore::IGetter::getSubdirs(), nonPerlWildcard(), listBenchmarks::pattern, and fetchall_from_DQM_v2::regexp.

                                                                 {
  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;
}

void DQMGenericClient::generic_eff ( TH1 *  denom, TH1 *  numer, MonitorElement *  efficiencyHist, const int  type = 1  )

private

Definition at line 930 of file DQMGenericClient.cc.

References LogDebug, MonitorElement::setBinContent(), MonitorElement::setBinError(), MonitorElement::setEfficiencyFlag(), and mathSSE::sqrt().

                                                                                                          {
  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 == 2 ) {          
          effVal = denomVal ? (1 - numerVal / denomVal) : 0;
        } else {
          effVal = denomVal ? numerVal / denomVal : 0;
        }

        float 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);
}

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

Definition at line 841 of file DQMGenericClient.cc.

References MonitorElement::getTH2F(), trackerHits::histo, i, MonitorElement::setBinContent(), and MonitorElement::setBinError().

{
  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","",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;
    }
  }
}

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

Definition at line 793 of file DQMGenericClient.cc.

References DQMStore::IBooker::cd(), DQMStore::IGetter::dirExists(), DQMStore::IGetter::get(), and i.

{
  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;
}

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

Definition at line 731 of file DQMGenericClient.cc.

References DQMStore::IBooker::cd(), DQMStore::IGetter::dirExists(), DQMStore::IGetter::get(), and create_public_lumi_plots::hist.

{
  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;
}

Member Data Documentation

std::vector<CDOption> DQMGenericClient::cdOptions_

private

Definition at line 113 of file DQMGenericClient.h.

std::vector<EfficOption> DQMGenericClient::efficOptions_

private

Definition at line 109 of file DQMGenericClient.h.

bool DQMGenericClient::isWildcardUsed_

private

Definition at line 102 of file DQMGenericClient.h.

std::vector<NormOption> DQMGenericClient::normOptions_

private

Definition at line 112 of file DQMGenericClient.h.

std::string DQMGenericClient::outputFileName_

private

Definition at line 107 of file DQMGenericClient.h.

std::vector<ProfileOption> DQMGenericClient::profileOptions_

private

Definition at line 111 of file DQMGenericClient.h.

bool DQMGenericClient::resLimitedFit_

private

Definition at line 103 of file DQMGenericClient.h.

std::vector<ResolOption> DQMGenericClient::resolOptions_

private

Definition at line 110 of file DQMGenericClient.h.

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

private

Definition at line 106 of file DQMGenericClient.h.

DQMStore* DQMGenericClient::theDQM

private

Definition at line 105 of file DQMGenericClient.h.

unsigned int DQMGenericClient::verbose_

private

Definition at line 101 of file DQMGenericClient.h.