PFAnalyzer Class Reference

#include <PFAnalyzer.h>

Inheritance diagram for PFAnalyzer:

Classes
struct	binInfo

Public Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override
	Get the analysis. More...
void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
	Inizialize parameters for histo binning. More...
void	dqmBeginRun (const edm::Run &, const edm::EventSetup &) override
	Initialize run-based parameters. More...
	PFAnalyzer (const edm::ParameterSet &)
	Constructor. More...
	~PFAnalyzer () override
	Destructor. More...
Public Member Functions inherited from DQMEDAnalyzer
void	accumulate (edm::Event const &event, edm::EventSetup const &setup) final
void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final
void	beginRun (edm::Run const &run, edm::EventSetup const &setup) final
void	beginStream (edm::StreamID id) final
	DQMEDAnalyzer ()
void	endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final
void	endRun (edm::Run const &run, edm::EventSetup const &setup) final
virtual bool	getCanSaveByLumi ()
Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
	EDProducer ()=default
	EDProducer (const EDProducer &)=delete
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final
const EDProducer &	operator= (const EDProducer &)=delete

Private Types
typedef std::vector< double >	vDouble
typedef std::vector< std::string >	vstring

Private Member Functions
void	bookMESetSelection (std::string, DQMStore::IBooker &)
std::vector< std::string >	getAllSuffixes (std::vector< std::string > observables, std::vector< std::vector< double >> binnings)
binInfo	getBinInfo (std::string)
std::vector< double >	getBinList (std::string binString)
int	getBinNumber (double binVal, std::vector< double > bins)
int	getBinNumbers (std::vector< double > binVal, std::vector< std::vector< double >> bins)
int	getJetBin (const reco::PFJet jetCand, int i)
int	getPFBin (const reco::PFCandidate pfCand, int i)
std::string	getSuffix (std::vector< int > binList, std::vector< std::string > observables, std::vector< std::vector< double >> binnings)
bool	passesEventSelection (const edm::Event &iEvent)
std::string	stringWithDecimals (int bin, std::vector< double > bins)

Static Private Member Functions
static double	getAbsEta (const reco::PFCandidate pfCand)
static double	getDNNEBkgNonIsolated (const reco::PFCandidate pfCand)
static double	getDNNEBkgPhotonIsolated (const reco::PFCandidate pfCand)
static double	getDNNEBkgTauIsolated (const reco::PFCandidate pfCand)
static double	getDNNESigIsolated (const reco::PFCandidate pfCand)
static double	getDNNESigNonIsolated (const reco::PFCandidate pfCand)
static double	getECalEFrac (const reco::PFCandidate pfCand)
static double	getEcalEnergy (const reco::PFCandidate pfCand)
static double	getECalEnergy (const reco::PFCandidate pfCand)
static double	getEnergy (const reco::PFCandidate pfCand)
static double	getEnergySpectrum (const reco::PFCandidate pfCand, const reco::PFJet jet)
static double	getEoverP (const reco::PFCandidate pfCand)
static double	getEta (const reco::PFCandidate pfCand)
static double	getHadCalibration (const reco::PFCandidate pfCand)
static double	getHCalEFrac (const reco::PFCandidate pfCand)
static double	getHcalEnergy (const reco::PFCandidate pfCand)
static double	getHCalEnergy (const reco::PFCandidate pfCand)
static double	getHcalEnergy_depth1 (const reco::PFCandidate pfCand)
static double	getHcalEnergy_depth2 (const reco::PFCandidate pfCand)
static double	getHcalEnergy_depth3 (const reco::PFCandidate pfCand)
static double	getHcalEnergy_depth4 (const reco::PFCandidate pfCand)
static double	getHcalEnergy_depth5 (const reco::PFCandidate pfCand)
static double	getHcalEnergy_depth6 (const reco::PFCandidate pfCand)
static double	getHcalEnergy_depth7 (const reco::PFCandidate pfCand)
static double	getHOEnergy (const reco::PFCandidate pfCand)
static double	getJetPt (const reco::PFJet jet)
static double	getMVAEMu (const reco::PFCandidate pfCand)
static double	getMVAEPi (const reco::PFCandidate pfCand)
static double	getMVAGammaNH (const reco::PFCandidate pfCand)
static double	getMVAIsolated (const reco::PFCandidate pfCand)
static double	getMVANothingGamma (const reco::PFCandidate pfCand)
static double	getMVANothingNH (const reco::PFCandidate pfCand)
static double	getMVAPiMu (const reco::PFCandidate pfCand)
static double	getNPFC (const reco::PFCandidateCollection pfCands, reco::PFCandidate::ParticleType pfType)
static double	getNPFCinJet (const std::vector< reco::PFCandidatePtr > pfCands, reco::PFCandidate::ParticleType pfType)
static double	getNTracksInBlock (const reco::PFCandidate pfCand)
static double	getPhi (const reco::PFCandidate pfCand)
static double	getPt (const reco::PFCandidate pfCand)
static double	getRawEcalEnergy (const reco::PFCandidate pfCand)
static double	getRawHcalEnergy (const reco::PFCandidate pfCand)
static double	getRawHOEnergy (const reco::PFCandidate pfCand)
static double	getTime (const reco::PFCandidate pfCand)
static double	getTrackPt (const reco::PFCandidate pfCand)

Private Attributes
edm::InputTag	highPtJetExpr_
std::vector< std::vector< std::string > >	m_allJetSuffixes
std::vector< std::vector< std::string > >	m_allSuffixes
std::vector< std::vector< std::vector< double > > >	m_binList
vstring	m_cutList
std::string	m_directory
std::map< std::string, std::function< double(const reco::PFCandidateCollection, reco::PFCandidate::ParticleType pfType)> >	m_eventFuncMap
vstring	m_eventObservableNames
vstring	m_eventObservables
std::vector< std::vector< std::string > >	m_fullCutList
std::vector< std::vector< std::string > >	m_fullJetCutList
std::map< std::string, std::function< double(const reco::PFCandidate)> >	m_funcMap
std::vector< std::vector< std::vector< double > > >	m_jetBinList
vstring	m_jetCutList
std::map< std::string, std::function< double(const reco::PFJet)> >	m_jetFuncMap
std::map< std::string, std::function< double(const std::vector< reco::PFCandidatePtr > pfCands, reco::PFCandidate::ParticleType pfType)> >	m_jetWideFuncMap
double	m_matchingRadius
vDouble	m_npvBins
vstring	m_observableNames
vstring	m_observables
std::map< std::string, std::function< double(const reco::PFCandidate, const reco::PFJet)> >	m_pfInJetFuncMap
vstring	m_pfInJetObservableNames
vstring	m_pfInJetObservables
std::vector< std::string >	m_pfNames
std::map< std::string, MonitorElement * >	map_of_MEs
edm::ParameterSet	parameters_
edm::EDGetTokenT< reco::PFJetCollection >	pfJetsToken_
edm::InputTag	srcWeights
edm::EDGetTokenT< reco::PFCandidateCollection >	thePfCandidateCollection_
edm::InputTag	theTriggerResultsLabel_
edm::EDGetTokenT< GenEventInfoProduct >	tok_ew_
edm::EDGetTokenT< edm::TriggerResults >	triggerResultsToken_
edm::InputTag	vertexTag_
edm::EDGetTokenT< std::vector< reco::Vertex > >	vertexToken_
edm::ValueMap< float > const *	weights_
edm::EDGetTokenT< edm::ValueMap< float > >	weightsToken_

Additional Inherited Members
Public Types inherited from DQMEDAnalyzer
typedef dqm::reco::DQMStore	DQMStore
typedef dqm::reco::MonitorElement	MonitorElement
Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
using	CacheTypes = CacheContexts< T... >
using	GlobalCache = typename CacheTypes::GlobalCache
using	HasAbility = AbilityChecker< T... >
using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
using	RunCache = typename CacheTypes::RunCache
using	RunContext = RunContextT< RunCache, GlobalCache >
using	RunSummaryCache = typename CacheTypes::RunSummaryCache
Static Public Member Functions inherited from DQMEDAnalyzer
static void	globalEndJob (DQMEDAnalyzerGlobalCache const *)
static void	globalEndLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup, LuminosityBlockContext const *context)
static void	globalEndRunProduce (edm::Run &run, edm::EventSetup const &setup, RunContext const *context)
static std::unique_ptr< DQMEDAnalyzerGlobalCache >	initializeGlobalCache (edm::ParameterSet const &)
Protected Member Functions inherited from DQMEDAnalyzer
uint64_t	meId () const
Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_
edm::EDPutTokenT< DQMToken >	runToken_
unsigned int	streamId_

Detailed Description

DQM ParticleFlow analysis monitoring

Author

J. Roloff - Brown University

Definition at line 51 of file PFAnalyzer.h.

Member Typedef Documentation

vDouble

typedef std::vector<double> PFAnalyzer::vDouble

private

Definition at line 299 of file PFAnalyzer.h.

vstring

typedef std::vector<std::string> PFAnalyzer::vstring

private

Definition at line 298 of file PFAnalyzer.h.

Constructor & Destructor Documentation

PFAnalyzer()

PFAnalyzer::PFAnalyzer

(

const edm::ParameterSet &

pSet

)

Constructor.

Definition at line 12 of file PFAnalyzer.cc.

References spr::find(), getBinList(), getDNNEBkgNonIsolated(), getDNNEBkgPhotonIsolated(), getDNNEBkgTauIsolated(), getDNNESigIsolated(), getDNNESigNonIsolated(), getEcalEnergy(), getEnergy(), getEnergySpectrum(), getEoverP(), getEta(), getHadCalibration(), getHcalEnergy(), getHCalEnergy(), getHcalEnergy_depth1(), getHcalEnergy_depth2(), getHcalEnergy_depth3(), getHcalEnergy_depth4(), getHcalEnergy_depth5(), getHcalEnergy_depth6(), getHcalEnergy_depth7(), getHOEnergy(), getJetPt(), getMVAEMu(), getMVAEPi(), getMVAGammaNH(), getMVAIsolated(), getMVANothingGamma(), getMVANothingNH(), getMVAPiMu(), getNPFC(), getNPFCinJet(), getNTracksInBlock(), edm::ParameterSet::getParameter(), getPhi(), getPt(), getRawEcalEnergy(), getRawHcalEnergy(), getRawHOEnergy(), highPtJetExpr_, mps_fire::i, ProducerED_cfi::InputTag, dqmiolumiharvest::j, m_binList, m_cutList, m_directory, m_eventFuncMap, m_eventObservables, m_fullCutList, m_fullJetCutList, m_funcMap, m_jetBinList, m_jetCutList, m_jetFuncMap, m_jetWideFuncMap, m_npvBins, m_observables, m_pfInJetFuncMap, m_pfInJetObservables, m_pfNames, parameters_, pfJetsToken_, srcWeights, AlCaHLTBitMon_QueryRunRegistry::string, thePfCandidateCollection_, theTriggerResultsLabel_, tok_ew_, triggerResultsToken_, trackerHitRTTI::vector, vertexTag_, vertexToken_, and weightsToken_.

                                                  {
  m_directory = "ParticleFlow";
  parameters_ = pSet.getParameter<edm::ParameterSet>("pfAnalysis");

  thePfCandidateCollection_ = consumes<reco::PFCandidateCollection>(pSet.getParameter<edm::InputTag>("pfCandidates"));
  pfJetsToken_ = consumes<reco::PFJetCollection>(pSet.getParameter<edm::InputTag>("pfJetCollection"));

  theTriggerResultsLabel_ = pSet.getParameter<edm::InputTag>("TriggerResultsLabel");
  triggerResultsToken_ = consumes<edm::TriggerResults>(edm::InputTag(theTriggerResultsLabel_));
  highPtJetExpr_ = pSet.getParameter<edm::InputTag>("TriggerName");

  srcWeights = pSet.getParameter<edm::InputTag>("srcWeights");
  weightsToken_ = consumes<edm::ValueMap<float>>(srcWeights);

  m_pfNames = {"allPFC", "neutralHadPFC", "chargedHadPFC", "electronPFC", "muonPFC", "gammaPFC", "hadHFPFC", "emHFPFC"};
  vertexTag_ = pSet.getParameter<edm::InputTag>("PVCollection");
  vertexToken_ = consumes<std::vector<reco::Vertex>>(edm::InputTag(vertexTag_));

  tok_ew_ = consumes<GenEventInfoProduct>(edm::InputTag("generator"));

  m_observables = parameters_.getParameter<vstring>("observables");
  m_eventObservables = parameters_.getParameter<vstring>("eventObservables");
  m_pfInJetObservables = parameters_.getParameter<vstring>("pfInJetObservables");
  m_npvBins = parameters_.getParameter<vDouble>("NPVBins");

  // List of cuts applied to PFCs that we want to plot
  m_cutList = parameters_.getParameter<vstring>("cutList");
  // List of jet cuts that we apply for the case of plotting PFCs in jets
  m_jetCutList = parameters_.getParameter<vstring>("jetCutList");

  // Link observable strings to the static functions defined in the header file
  // Many of these are quite trivial, but this enables a simple way to include a
  // variety of observables on-the-fly.
  m_funcMap["pt"] = &getPt;
  m_funcMap["energy"] = getEnergy;
  m_funcMap["eta"] = getEta;
  m_funcMap["phi"] = getPhi;

  m_funcMap["HCalE_depth1"] = getHcalEnergy_depth1;
  m_funcMap["HCalE_depth2"] = getHcalEnergy_depth2;
  m_funcMap["HCalE_depth3"] = getHcalEnergy_depth3;
  m_funcMap["HCalE_depth4"] = getHcalEnergy_depth4;
  m_funcMap["HCalE_depth5"] = getHcalEnergy_depth5;
  m_funcMap["HCalE_depth6"] = getHcalEnergy_depth6;
  m_funcMap["HCalE_depth7"] = getHcalEnergy_depth7;

  m_funcMap["ECal_E"] = getEcalEnergy;
  m_funcMap["RawECal_E"] = getRawEcalEnergy;
  m_funcMap["HCal_E"] = getHcalEnergy;
  m_funcMap["RawHCal_E"] = getRawHcalEnergy;
  m_funcMap["HO_E"] = getHOEnergy;
  m_funcMap["RawHO_E"] = getRawHOEnergy;
  m_funcMap["PFHad_calibration"] = getHadCalibration;

  m_funcMap["MVAIsolated"] = getMVAIsolated;
  m_funcMap["MVAEPi"] = getMVAEPi;
  m_funcMap["MVAEMu"] = getMVAEMu;
  m_funcMap["MVAPiMu"] = getMVAPiMu;
  m_funcMap["MVANothingGamma"] = getMVANothingGamma;
  m_funcMap["MVANothingNH"] = getMVANothingNH;
  m_funcMap["MVAGammaNH"] = getMVAGammaNH;

  m_funcMap["DNNESigIsolated"] = getDNNESigIsolated;
  m_funcMap["DNNESigNonIsolated"] = getDNNESigNonIsolated;
  m_funcMap["DNNEBkgNonIsolated"] = getDNNEBkgNonIsolated;
  m_funcMap["DNNEBkgTauIsolated"] = getDNNEBkgTauIsolated;
  m_funcMap["DNNEBkgPhotonIsolated"] = getDNNEBkgPhotonIsolated;

  m_funcMap["hcalE"] = getHCalEnergy;
  m_funcMap["eOverP"] = getEoverP;
  m_funcMap["nTrkInBlock"] = getNTracksInBlock;

  m_eventFuncMap["NPFC"] = getNPFC;
  m_jetWideFuncMap["NPFC"] = getNPFCinJet;

  m_pfInJetFuncMap["PFSpectrum"] = getEnergySpectrum;

  // Link jet observables to static functions in the header file.
  // This is very similar to m_funcMap, but for jets instead.
  m_jetFuncMap["pt"] = getJetPt;

  // Convert the cutList strings into real cuts that can be applied
  // The format should be three comma separated values
  // with the first number being the name of the observable
  // (corresponding to a key in m_funcMap),
  // the second being the minimum value, and the last being the max.
  //
  for (unsigned int i = 0; i < m_cutList.size(); i++) {
    m_fullCutList.push_back(std::vector<std::string>());
    while (m_cutList[i].find("]") != std::string::npos) {
      size_t pos = m_cutList[i].find("]");
      m_fullCutList[i].push_back(m_cutList[i].substr(1, pos));
      m_cutList[i].erase(0, pos + 1);
    }
  }

  for (unsigned int i = 0; i < m_fullCutList.size(); i++) {
    m_binList.push_back(std::vector<std::vector<double>>());
    for (unsigned int j = 0; j < m_fullCutList[i].size(); j++) {
      size_t pos = m_fullCutList[i][j].find(";");
      std::string observableName = m_fullCutList[i][j].substr(0, pos);
      m_fullCutList[i][j].erase(0, pos + 1);

      m_binList[i].push_back(getBinList(m_fullCutList[i][j]));
      m_fullCutList[i][j] = observableName;
    }
  }

  // Convert the jetCutList strings into real cuts that can be applied
  // The format should be three comma separated values,
  // with the first number being the name of the observable
  // (corresponding to a key in m_jetFuncMap),
  // the second being the minimum value, and the last being the max value.
  //
  for (unsigned int i = 0; i < m_jetCutList.size(); i++) {
    m_fullJetCutList.push_back(std::vector<std::string>());
    while (m_jetCutList[i].find("]") != std::string::npos) {
      size_t pos = m_jetCutList[i].find("]");
      m_fullJetCutList[i].push_back(m_jetCutList[i].substr(1, pos));
      m_jetCutList[i].erase(0, pos + 1);
    }
  }

  for (unsigned int i = 0; i < m_fullJetCutList.size(); i++) {
    m_jetBinList.push_back(std::vector<std::vector<double>>());
    for (unsigned int j = 0; j < m_fullJetCutList[i].size(); j++) {
      size_t pos = m_fullJetCutList[i][j].find(";");
      std::string observableName = m_fullJetCutList[i][j].substr(0, pos);
      m_fullJetCutList[i][j].erase(0, pos + 1);

      m_jetBinList[i].push_back(getBinList(m_fullJetCutList[i][j]));
      m_fullJetCutList[i][j] = observableName;
    }
  }
}

~PFAnalyzer()

PFAnalyzer::~PFAnalyzer ( )

override

Destructor.

Definition at line 149 of file PFAnalyzer.cc.

References LogTrace.

{ LogTrace("PFAnalyzer") << "[PFAnalyzer] Saving the histos"; }

Member Function Documentation

analyze()

void PFAnalyzer::analyze ( const edm::Event &  iEvent, const edm::EventSetup &  iSetup  )

overridevirtual

Get the analysis.

Reimplemented from DQMEDAnalyzer.

Definition at line 528 of file PFAnalyzer.cc.

References plotT0FromHistos::binNumber(), MillePedeFileConverter_cfg::e, HcalObjRepresent::Fill(), CustomPhysics_cfi::gamma, genParticles2HepMC_cfi::genEventInfo, getBinNumber(), getJetBin(), getPFBin(), h, highPtJetExpr_, mps_fire::i, iEvent, edm::HandleBase::isValid(), dqmiolumiharvest::j, isotrackApplyRegressor::k, edm::InputTag::label(), LogDebug, m_allJetSuffixes, m_allSuffixes, m_directory, m_eventFuncMap, m_eventObservableNames, m_fullCutList, m_fullJetCutList, m_funcMap, m_jetWideFuncMap, m_npvBins, m_observableNames, m_observables, m_pfInJetFuncMap, m_pfInJetObservableNames, map_of_MEs, amptDefaultParameters_cff::mu, passesEventSelection(), pfJets_cff::pfJets, pfJetsToken_, edm::Handle< T >::product(), findQualityFiles::size, AlCaHLTBitMon_QueryRunRegistry::string, thePfCandidateCollection_, tok_ew_, L1TEGammaOffline_cfi::triggerNames, triggerResults, triggerResultsToken_, findQualityFiles::v, bphysicsOniaDQM_cfi::vertex, vertexToken_, weights_, weightsToken_, and X.

                                                                            {
  const edm::Handle<GenEventInfoProduct> genEventInfo = iEvent.getHandle(tok_ew_);
  double eventWeight = 1;
  if (genEventInfo.isValid()) {
    eventWeight = genEventInfo->weight();
  }

  weights_ = &iEvent.get(weightsToken_);

  // **** Get the TriggerResults container
  edm::Handle<edm::TriggerResults> triggerResults;
  iEvent.getByToken(triggerResultsToken_, triggerResults);

  // Hack to make it pass the lowest unprescaled HLT?
  Int_t JetHiPass = 0;

  if (triggerResults.isValid()) {
    const edm::TriggerNames& triggerNames = iEvent.triggerNames(*triggerResults);

    const unsigned int nTrig(triggerNames.size());
    for (unsigned int i = 0; i < nTrig; ++i) {
      if (triggerNames.triggerName(i).find(highPtJetExpr_.label()) != std::string::npos && triggerResults->accept(i)) {
        JetHiPass = 1;
      }
    }
  }

  //Vertex information
  edm::Handle<reco::VertexCollection> vertexHandle;
  iEvent.getByToken(vertexToken_, vertexHandle);

  if (!vertexHandle.isValid()) {
    LogDebug("") << "PFAnalyzer: Could not find vertex collection" << std::endl;
  }
  int numPV = 0;

  if (vertexHandle.isValid()) {
    reco::VertexCollection vertex = *(vertexHandle.product());
    for (reco::VertexCollection::const_iterator v = vertex.begin(); v != vertex.end(); ++v) {
      if (v->isFake())
        continue;
      if (v->ndof() < 4)
        continue;
      if (fabs(v->z()) > 24.0)
        continue;
      ++numPV;
    }
  }

  int npvBin = getBinNumber(numPV, m_npvBins);
  if (npvBin < 0)
    return;
  std::string npvString = Form("npv_%.0f_%.0f", m_npvBins[npvBin], m_npvBins[npvBin + 1]);

  if (!JetHiPass)
    return;

  // Retrieve the PFCs
  edm::Handle<reco::PFCandidateCollection> pfCollection;
  iEvent.getByToken(thePfCandidateCollection_, pfCollection);
  if (!pfCollection.isValid()) {
    edm::LogError("PFAnalyzer") << "invalid collection: PF candidate \n";
    return;
  }

  edm::Handle<reco::PFJetCollection> pfJets;
  iEvent.getByToken(pfJetsToken_, pfJets);
  if (!pfJets.isValid()) {
    edm::LogError("PFAnalyzer") << "invalid collection: PF jets \n";
    return;
  }

  // Probably we want to define a few different options for how the selection will work
  // Currently it is just a dummy function, and we hardcode the other cuts.
  if (pfJets->size() < 2)
    return;
  if (pfJets->at(0).pt() < 450)
    return;
  if (pfJets->at(0).pt() / pfJets->at(1).pt() > 2)
    return;

  if (!passesEventSelection(iEvent))
    return;

  for (reco::PFCandidateCollection::const_iterator recoPF = pfCollection->begin(); recoPF != pfCollection->end();
       ++recoPF) {
    for (unsigned int j = 0; j < m_fullCutList.size(); j++) {
      int binNumber = getPFBin(*recoPF, j);
      if (binNumber < 0)
        continue;
      if (binNumber >= int(m_allSuffixes[j].size())) {
        continue;
      }
      std::string binString = m_allSuffixes[j][binNumber];

      // Eventually, we might want the hist name to include the cuts that we are applying,
      // so I am keepking it as a separate string for now, even though it is redundant.
      // Make plots of all observables
      for (unsigned int i = 0; i < m_observables.size(); i++) {
        std::string histName = Form("%s%s_%s", m_observableNames[i].c_str(), binString.c_str(), npvString.c_str());
        map_of_MEs[m_directory + "/allPFC_" + histName]->Fill(m_funcMap[m_observableNames[i]](*recoPF), eventWeight);

        switch (recoPF->particleId()) {
          case reco::PFCandidate::ParticleType::h:
            map_of_MEs[m_directory + "/chargedHadPFC_" + histName]->Fill(m_funcMap[m_observableNames[i]](*recoPF),
                                                                         eventWeight);
            break;
          case reco::PFCandidate::ParticleType::h0:
            map_of_MEs[m_directory + "/neutralHadPFC_" + histName]->Fill(m_funcMap[m_observableNames[i]](*recoPF),
                                                                         eventWeight);
            break;
          case reco::PFCandidate::ParticleType::e:
            map_of_MEs[m_directory + "/electronPFC_" + histName]->Fill(m_funcMap[m_observableNames[i]](*recoPF),
                                                                       eventWeight);
            break;
          case reco::PFCandidate::ParticleType::mu:
            map_of_MEs[m_directory + "/muonPFC_" + histName]->Fill(m_funcMap[m_observableNames[i]](*recoPF),
                                                                   eventWeight);
            break;
          case reco::PFCandidate::ParticleType::gamma:
            map_of_MEs[m_directory + "/gammaPFC_" + histName]->Fill(m_funcMap[m_observableNames[i]](*recoPF),
                                                                    eventWeight);
            break;
          case reco::PFCandidate::ParticleType::h_HF:
            map_of_MEs[m_directory + "/hadHFPFC_" + histName]->Fill(m_funcMap[m_observableNames[i]](*recoPF),
                                                                    eventWeight);
            break;
          case reco::PFCandidate::ParticleType::egamma_HF:
            map_of_MEs[m_directory + "/emHFPFC_" + histName]->Fill(m_funcMap[m_observableNames[i]](*recoPF),
                                                                   eventWeight);
            break;
          default:
            break;
        }
      }
    }
  }

  for (unsigned int i = 0; i < m_eventObservableNames.size(); i++) {
    std::string histName = Form("%s_%s", m_eventObservableNames[i].c_str(), npvString.c_str());
    map_of_MEs[m_directory + "/allPFC_" + histName]->Fill(
        m_eventFuncMap[m_eventObservableNames[i]](*pfCollection, reco::PFCandidate::ParticleType::X), eventWeight);
    map_of_MEs[m_directory + "/chargedHadPFC_" + histName]->Fill(
        m_eventFuncMap[m_eventObservableNames[i]](*pfCollection, reco::PFCandidate::ParticleType::h), eventWeight);
    map_of_MEs[m_directory + "/neutralHadPFC_" + histName]->Fill(
        m_eventFuncMap[m_eventObservableNames[i]](*pfCollection, reco::PFCandidate::ParticleType::h0), eventWeight);
    map_of_MEs[m_directory + "/electronPFC_" + histName]->Fill(
        m_eventFuncMap[m_eventObservableNames[i]](*pfCollection, reco::PFCandidate::ParticleType::e), eventWeight);
    map_of_MEs[m_directory + "/muonPFC_" + histName]->Fill(
        m_eventFuncMap[m_eventObservableNames[i]](*pfCollection, reco::PFCandidate::ParticleType::mu), eventWeight);
    map_of_MEs[m_directory + "/gammaPFC_" + histName]->Fill(
        m_eventFuncMap[m_eventObservableNames[i]](*pfCollection, reco::PFCandidate::ParticleType::gamma), eventWeight);
    map_of_MEs[m_directory + "/hadHFPFC_" + histName]->Fill(
        m_eventFuncMap[m_eventObservableNames[i]](*pfCollection, reco::PFCandidate::ParticleType::h_HF), eventWeight);
    map_of_MEs[m_directory + "/emHFPFC_" + histName]->Fill(
        m_eventFuncMap[m_eventObservableNames[i]](*pfCollection, reco::PFCandidate::ParticleType::egamma_HF),
        eventWeight);
  }

  // Plots for generic debugging
  map_of_MEs[m_directory + "/NPV"]->Fill(numPV, eventWeight);
  map_of_MEs[m_directory + Form("/jetPtLead_%s", npvString.c_str())]->Fill(pfJets->begin()->pt(), eventWeight);
  map_of_MEs[m_directory + Form("/jetEtaLead_%s", npvString.c_str())]->Fill(pfJets->begin()->eta(), eventWeight);

  // Make plots of all observables, this time for PF candidates within jets
  for (reco::PFJetCollection::const_iterator cjet = pfJets->begin(); cjet != pfJets->end(); ++cjet) {
    map_of_MEs[m_directory + Form("/jetPt_%s", npvString.c_str())]->Fill(cjet->pt(), eventWeight);
    map_of_MEs[m_directory + Form("/jetEta_%s", npvString.c_str())]->Fill(cjet->eta(), eventWeight);

    for (unsigned int k = 0; k < m_fullJetCutList.size(); k++) {
      int jetBinNumber = getJetBin(*cjet, k);
      if (jetBinNumber < 0)
        continue;
      std::string jetBinString = m_allJetSuffixes[k][jetBinNumber];

      std::vector<reco::PFCandidatePtr> pfConstits = cjet->getPFConstituents();

      for (auto recoPF : pfConstits) {
        for (unsigned int j = 0; j < m_fullCutList.size(); j++) {
          int binNumber = getPFBin(*recoPF, j);
          if (binNumber < 0)
            continue;
          if (binNumber >= int(m_allSuffixes[j].size())) {
            continue;
          }
          std::string binString = m_allSuffixes[j][binNumber];

          for (unsigned int i = 0; i < m_observableNames.size(); i++) {
            std::string histName = Form("%s%s_jetCuts%s_%s",
                                        m_observableNames[i].c_str(),
                                        binString.c_str(),
                                        jetBinString.c_str(),
                                        npvString.c_str());
            map_of_MEs[m_directory + "/allPFC_jetMatched_" + histName]->Fill(m_funcMap[m_observableNames[i]](*recoPF),
                                                                             eventWeight);

            switch (recoPF->particleId()) {
              case reco::PFCandidate::ParticleType::h:
                map_of_MEs[m_directory + "/chargedHadPFC_jetMatched_" + histName]->Fill(
                    m_funcMap[m_observableNames[i]](*recoPF), eventWeight);
                break;
              case reco::PFCandidate::ParticleType::h0:
                map_of_MEs[m_directory + "/neutralHadPFC_jetMatched_" + histName]->Fill(
                    m_funcMap[m_observableNames[i]](*recoPF), eventWeight);
                break;
              case reco::PFCandidate::ParticleType::e:
                map_of_MEs[m_directory + "/electronPFC_jetMatched_" + histName]->Fill(
                    m_funcMap[m_observableNames[i]](*recoPF), eventWeight);
                break;
              case reco::PFCandidate::ParticleType::mu:
                map_of_MEs[m_directory + "/muonPFC_jetMatched_" + histName]->Fill(
                    m_funcMap[m_observableNames[i]](*recoPF), eventWeight);
                break;
              case reco::PFCandidate::ParticleType::gamma:
                map_of_MEs[m_directory + "/gammaPFC_jetMatched_" + histName]->Fill(
                    m_funcMap[m_observableNames[i]](*recoPF), eventWeight);
                break;
              case reco::PFCandidate::ParticleType::h_HF:
                map_of_MEs[m_directory + "/hadHFPFC_jetMatched_" + histName]->Fill(
                    m_funcMap[m_observableNames[i]](*recoPF), eventWeight);
                break;
              case reco::PFCandidate::ParticleType::egamma_HF:
                map_of_MEs[m_directory + "/emHFPFC_jetMatched_" + histName]->Fill(
                    m_funcMap[m_observableNames[i]](*recoPF), eventWeight);
                break;
              default:
                break;
            }
          }

          for (unsigned int i = 0; i < m_pfInJetObservableNames.size(); i++) {
            std::string histName = Form("%s%s_jetCuts%s_%s",
                                        m_pfInJetObservableNames[i].c_str(),
                                        binString.c_str(),
                                        jetBinString.c_str(),
                                        npvString.c_str());
            map_of_MEs[m_directory + "/allPFC_jetMatched_" + histName]->Fill(
                m_pfInJetFuncMap[m_pfInJetObservableNames[i]](*recoPF, *cjet), eventWeight);

            switch (recoPF->particleId()) {
              case reco::PFCandidate::ParticleType::h:
                map_of_MEs[m_directory + "/chargedHadPFC_jetMatched_" + histName]->Fill(
                    m_pfInJetFuncMap[m_pfInJetObservableNames[i]](*recoPF, *cjet), eventWeight);
                break;
              case reco::PFCandidate::ParticleType::h0:
                map_of_MEs[m_directory + "/neutralHadPFC_jetMatched_" + histName]->Fill(
                    m_pfInJetFuncMap[m_pfInJetObservableNames[i]](*recoPF, *cjet), eventWeight);
                break;
              case reco::PFCandidate::ParticleType::e:
                map_of_MEs[m_directory + "/electronPFC_jetMatched_" + histName]->Fill(
                    m_pfInJetFuncMap[m_pfInJetObservableNames[i]](*recoPF, *cjet), eventWeight);
                break;
              case reco::PFCandidate::ParticleType::mu:
                map_of_MEs[m_directory + "/muonPFC_jetMatched_" + histName]->Fill(
                    m_pfInJetFuncMap[m_pfInJetObservableNames[i]](*recoPF, *cjet), eventWeight);
                break;
              case reco::PFCandidate::ParticleType::gamma:
                map_of_MEs[m_directory + "/gammaPFC_jetMatched_" + histName]->Fill(
                    m_pfInJetFuncMap[m_pfInJetObservableNames[i]](*recoPF, *cjet), eventWeight);
                break;
              case reco::PFCandidate::ParticleType::h_HF:
                map_of_MEs[m_directory + "/hadHFPFC_jetMatched_" + histName]->Fill(
                    m_pfInJetFuncMap[m_pfInJetObservableNames[i]](*recoPF, *cjet), eventWeight);
                break;
              case reco::PFCandidate::ParticleType::egamma_HF:
                map_of_MEs[m_directory + "/emHFPFC_jetMatched_" + histName]->Fill(
                    m_pfInJetFuncMap[m_pfInJetObservableNames[i]](*recoPF, *cjet), eventWeight);
                break;
              default:
                break;
            }
          }
        }

        for (unsigned int i = 0; i < m_eventObservableNames.size(); i++) {
          std::string histName =
              Form("%s_jetCuts%s_%s", m_eventObservableNames[i].c_str(), jetBinString.c_str(), npvString.c_str());
          map_of_MEs[m_directory + "/allPFC_jetMatched_" + histName]->Fill(
              m_jetWideFuncMap[m_eventObservableNames[i]](pfConstits, reco::PFCandidate::ParticleType::X), eventWeight);
          map_of_MEs[m_directory + "/chargedHadPFC_jetMatched_" + histName]->Fill(
              m_jetWideFuncMap[m_eventObservableNames[i]](pfConstits, reco::PFCandidate::ParticleType::h), eventWeight);
          map_of_MEs[m_directory + "/neutralHadPFC_jetMatched_" + histName]->Fill(
              m_jetWideFuncMap[m_eventObservableNames[i]](pfConstits, reco::PFCandidate::ParticleType::h0),
              eventWeight);
          map_of_MEs[m_directory + "/electronPFC_jetMatched_" + histName]->Fill(
              m_jetWideFuncMap[m_eventObservableNames[i]](pfConstits, reco::PFCandidate::ParticleType::e), eventWeight);
          map_of_MEs[m_directory + "/muonPFC_jetMatched_" + histName]->Fill(
              m_jetWideFuncMap[m_eventObservableNames[i]](pfConstits, reco::PFCandidate::ParticleType::mu),
              eventWeight);
          map_of_MEs[m_directory + "/gammaPFC_jetMatched_" + histName]->Fill(
              m_jetWideFuncMap[m_eventObservableNames[i]](pfConstits, reco::PFCandidate::ParticleType::gamma),
              eventWeight);
          map_of_MEs[m_directory + "/hadHFPFC_jetMatched_" + histName]->Fill(
              m_jetWideFuncMap[m_eventObservableNames[i]](pfConstits, reco::PFCandidate::ParticleType::h_HF),
              eventWeight);
          map_of_MEs[m_directory + "/emHFPFC_jetMatched_" + histName]->Fill(
              m_jetWideFuncMap[m_eventObservableNames[i]](pfConstits, reco::PFCandidate::ParticleType::egamma_HF),
              eventWeight);
        }
      }
    }
  }
}

bookHistograms()

void PFAnalyzer::bookHistograms ( DQMStore::IBooker &  ibooker, edm::Run const &  iRun, edm::EventSetup const &    )

overridevirtual

Inizialize parameters for histo binning.

Implements DQMEDAnalyzer.

Definition at line 152 of file PFAnalyzer.cc.

References PFAnalyzer::binInfo::axisName, spclusmultinvestigator_cfi::binMax, PFAnalyzer::binInfo::binMax, binMin, PFAnalyzer::binInfo::binMin, dqm::implementation::IBooker::book1D(), getAllSuffixes(), getBinInfo(), mps_fire::i, dqmiolumiharvest::j, isotrackApplyRegressor::k, visualization-live-secondInstance_cfg::m, m_allJetSuffixes, m_allSuffixes, m_binList, m_directory, m_eventObservableNames, m_eventObservables, m_fullCutList, m_fullJetCutList, m_jetBinList, m_npvBins, m_observableNames, m_observables, m_pfInJetObservableNames, m_pfInJetObservables, m_pfNames, map_of_MEs, create_idmaps::n, ecalPedestalPCLworker_cfi::nBins, PFAnalyzer::binInfo::nBins, PFAnalyzer::binInfo::observable, AlCaHLTBitMon_ParallelJobs::p, dqm::implementation::NavigatorBase::setCurrentFolder(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                  {
  ibooker.setCurrentFolder(m_directory);

  for (unsigned int i = 0; i < m_fullCutList.size(); i++) {
    m_allSuffixes.push_back(getAllSuffixes(m_fullCutList[i], m_binList[i]));
  }

  for (unsigned int i = 0; i < m_fullJetCutList.size(); i++) {
    m_allJetSuffixes.push_back(getAllSuffixes(m_fullJetCutList[i], m_jetBinList[i]));
  }

  for (unsigned int npv = 0; npv < m_npvBins.size() - 1; npv++) {
    std::string npvString = Form("npv_%.0f_%.0f", m_npvBins[npv], m_npvBins[npv + 1]);
    // TODO: Make it possible to use an arbitrary list of bins instead of evenly space bins?
    // It is not clear if this is straightforward to do with these classes and CMSSW.
    // If it is, it should be an easy change to the code.
    //
    //
    // Books a histogram for each histogram in the config file.
    // The format for the observables should be four comma separated values,
    // with the first being the observable name (corresponding to one of
    // the keys in m_funcMap), the second being the number of bins,
    // and the last two being the min and max value for the histogram respectively.
    for (unsigned int i = 0; i < m_observables.size(); i++) {
      std::string cObservable = m_observables[i];
      PFAnalyzer::binInfo obsInfo = getBinInfo(cObservable);

      if (npv == 0)
        m_observableNames.push_back(obsInfo.observable);

      for (unsigned int j = 0; j < m_allSuffixes.size(); j++) {
        for (unsigned int n = 0; n < m_allSuffixes[j].size(); n++) {
          // Loop over all of the different types of PF candidates
          for (unsigned int m = 0; m < m_pfNames.size(); m++) {
            // For each observable, we make a couple histograms based on a few generic categorizations.
            // In all cases, the PFCs that go into these histograms must pass the PFC selection from m_cutList.
            std::string histName = Form("%s_%s%s_%s",
                                        m_pfNames[m].c_str(),
                                        obsInfo.observable.c_str(),
                                        m_allSuffixes[j][n].c_str(),
                                        npvString.c_str());
            MonitorElement* mHist = ibooker.book1D(
                histName, Form(";%s;", obsInfo.axisName.c_str()), obsInfo.nBins, obsInfo.binMin, obsInfo.binMax);
            map_of_MEs.insert(std::pair<std::string, MonitorElement*>(m_directory + "/" + histName, mHist));
          }

          for (unsigned int k = 0; k < m_allJetSuffixes.size(); k++) {
            for (unsigned int p = 0; p < m_allJetSuffixes[k].size(); p++) {
              for (unsigned int m = 0; m < m_pfNames.size(); m++) {
                // These histograms are for PFCs passing the basic selection, and which are matched to jets
                // that pass the jet selection
                std::string histName = Form("%s_jetMatched_%s%s_jetCuts%s_%s",
                                            m_pfNames[m].c_str(),
                                            obsInfo.observable.c_str(),
                                            m_allSuffixes[j][n].c_str(),
                                            m_allJetSuffixes[k][p].c_str(),
                                            npvString.c_str());
                MonitorElement* mHistInJet = ibooker.book1D(
                    histName, Form(";%s;", obsInfo.axisName.c_str()), obsInfo.nBins, obsInfo.binMin, obsInfo.binMax);
                map_of_MEs.insert(std::pair<std::string, MonitorElement*>(m_directory + "/" + histName, mHistInJet));
              }
            }
          }
        }
      }
    }

    // Do the same for global observables (things like the number of PFCs in an event, or in a jet, etc)
    for (unsigned int i = 0; i < m_eventObservables.size(); i++) {
      std::string cEventObservable = m_eventObservables[i];
      size_t pos = cEventObservable.find(";");
      std::string observableName = cEventObservable.substr(0, pos);
      cEventObservable.erase(0, pos + 1);

      pos = cEventObservable.find(";");
      std::string axisString = cEventObservable.substr(0, pos);
      cEventObservable.erase(0, pos + 1);

      pos = cEventObservable.find(";");
      int nBins = atoi(cEventObservable.substr(0, pos).c_str());
      cEventObservable.erase(0, pos + 1);

      pos = cEventObservable.find(";");
      float binMin = atof(cEventObservable.substr(0, pos).c_str());
      cEventObservable.erase(0, pos + 1);

      pos = cEventObservable.find(";");
      float binMax = atof(cEventObservable.substr(0, pos).c_str());
      cEventObservable.erase(0, pos + 1);

      pos = cEventObservable.find(";");
      int nBinsJet = atoi(cEventObservable.substr(0, pos).c_str());
      cEventObservable.erase(0, pos + 1);

      pos = cEventObservable.find(";");
      float binMinJet = atof(cEventObservable.substr(0, pos).c_str());
      cEventObservable.erase(0, pos + 1);

      float binMaxJet = atof(cEventObservable.c_str());
      if (npv == 0)
        m_eventObservableNames.push_back(observableName);

      for (unsigned int m = 0; m < m_pfNames.size(); m++) {
        std::string histName = Form("%s_%s_%s", m_pfNames[m].c_str(), observableName.c_str(), npvString.c_str());
        MonitorElement* mHist = ibooker.book1D(histName, Form(";%s;", axisString.c_str()), nBins, binMin, binMax);
        map_of_MEs.insert(std::pair<std::string, MonitorElement*>(m_directory + "/" + histName, mHist));
      }

      for (unsigned int k = 0; k < m_allJetSuffixes.size(); k++) {
        for (unsigned int p = 0; p < m_allJetSuffixes[k].size(); p++) {
          for (unsigned int m = 0; m < m_pfNames.size(); m++) {
            // These histograms are for PFCs passing the basic selection, and which are matched to jets
            // that pass the jet selection
            std::string histName = Form("%s_jetMatched_%s_jetCuts%s_%s",
                                        m_pfNames[m].c_str(),
                                        observableName.c_str(),
                                        m_allJetSuffixes[k][p].c_str(),
                                        npvString.c_str());
            MonitorElement* mHistInJet =
                ibooker.book1D(histName, Form(";%s;", axisString.c_str()), nBinsJet, binMinJet, binMaxJet);
            map_of_MEs.insert(std::pair<std::string, MonitorElement*>(m_directory + "/" + histName, mHistInJet));
          }
        }
      }
    }

    for (unsigned int i = 0; i < m_pfInJetObservables.size(); i++) {
      std::string cPfInJetObservable = m_pfInJetObservables[i];
      PFAnalyzer::binInfo pfInJetInfo = getBinInfo(cPfInJetObservable);
      if (npv == 0)
        m_pfInJetObservableNames.push_back(pfInJetInfo.observable);

      for (unsigned int j = 0; j < m_allSuffixes.size(); j++) {
        for (unsigned int n = 0; n < m_allSuffixes[j].size(); n++) {
          for (unsigned int k = 0; k < m_allJetSuffixes.size(); k++) {
            for (unsigned int p = 0; p < m_allJetSuffixes[k].size(); p++) {
              for (unsigned int m = 0; m < m_pfNames.size(); m++) {
                // These histograms are for PFCs passing the basic selection, and which are matched to jets
                // that pass the jet selection
                std::string histName = Form("%s_jetMatched_%s%s_jetCuts%s_%s",
                                            m_pfNames[m].c_str(),
                                            pfInJetInfo.observable.c_str(),
                                            m_allSuffixes[j][n].c_str(),
                                            m_allJetSuffixes[k][p].c_str(),
                                            npvString.c_str());
                MonitorElement* mHistInJet = ibooker.book1D(histName,
                                                            Form(";%s;", pfInJetInfo.axisName.c_str()),
                                                            pfInJetInfo.nBins,
                                                            pfInJetInfo.binMin,
                                                            pfInJetInfo.binMax);
                map_of_MEs.insert(std::pair<std::string, MonitorElement*>(m_directory + "/" + histName, mHistInJet));
              }
            }
          }
        }
      }
    }

    // Extra histograms for basic validation of the selection etc.
    std::string histName = Form("jetPt_%s", npvString.c_str());
    MonitorElement* mHist = ibooker.book1D(histName, Form(";%s;", "p_{T,jet}"), 2000, 0, 2000);
    map_of_MEs.insert(std::pair<std::string, MonitorElement*>(m_directory + "/" + histName, mHist));

    histName = Form("jetPtLead_%s", npvString.c_str());
    mHist = ibooker.book1D(histName, Form(";%s;", "p_{T, leading jet}"), 2000, 0, 2000);
    map_of_MEs.insert(std::pair<std::string, MonitorElement*>(m_directory + "/" + histName, mHist));

    histName = Form("jetEta_%s", npvString.c_str());
    mHist = ibooker.book1D(histName, Form(";%s;", "#eta_{jet}"), 200, -5, 5);
    map_of_MEs.insert(std::pair<std::string, MonitorElement*>(m_directory + "/" + histName, mHist));

    histName = Form("jetEtaLead_%s", npvString.c_str());
    mHist = ibooker.book1D(histName, Form(";%s;", "#eta_{leading jet}"), 200, -5, 5);
    map_of_MEs.insert(std::pair<std::string, MonitorElement*>(m_directory + "/" + histName, mHist));
  }

  std::string histName = Form("NPV");
  MonitorElement* mHist = ibooker.book1D(histName, Form(";%s;", "N_PV"), 100, 0, 100);
  map_of_MEs.insert(std::pair<std::string, MonitorElement*>(m_directory + "/" + histName, mHist));
}

bookMESetSelection()

void PFAnalyzer::bookMESetSelection ( std::string  DirName, DQMStore::IBooker &  ibooker  )

private

Definition at line 358 of file PFAnalyzer.cc.

References fed_dqm_sourceclient-live_cfg::DirName, and dqm::implementation::NavigatorBase::setCurrentFolder().

                                                                               {
  ibooker.setCurrentFolder(DirName);
}

dqmBeginRun()

void PFAnalyzer::dqmBeginRun ( const edm::Run &  iRun, const edm::EventSetup &  iSetup  )

overridevirtual

Initialize run-based parameters.

Reimplemented from DQMEDAnalyzer.

Definition at line 363 of file PFAnalyzer.cc.

{}

getAbsEta()

static double PFAnalyzer::getAbsEta ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 137 of file PFAnalyzer.h.

References funct::abs(), and reco::LeafCandidate::eta().

{ return std::abs(pfCand.eta()); }

getAllSuffixes()

std::vector< std::string > PFAnalyzer::getAllSuffixes ( std::vector< std::string >  observables, std::vector< std::vector< double >>  binnings  )

private

Definition at line 423 of file PFAnalyzer.cc.

References getSuffix(), mps_fire::i, dqmiolumiharvest::j, isotrackApplyRegressor::k, visualization-live-secondInstance_cfg::m, ecalPedestalPCLworker_cfi::nBins, runBasic_cfi::observables, and findQualityFiles::size.

Referenced by bookHistograms().

                                                                                           {
  int nTotalBins = 1;
  std::vector<int> nBins;
  for (unsigned int i = 0; i < binnings.size(); i++) {
    nTotalBins = (binnings[i].size() - 1) * nTotalBins;
    nBins.push_back(binnings[i].size() - 1);
  }

  std::vector<std::vector<int>> binList;

  for (int i = 0; i < nTotalBins; i++) {
    binList.push_back(std::vector<int>());
  }

  int factor = nTotalBins;
  int otherFactor = 1;
  for (unsigned int i = 0; i < binnings.size(); i++) {
    factor = factor / nBins[i];

    for (int j = 0; j < nBins[i]; j++) {
      for (int k = 0; k < factor; k++) {
        for (int m = 0; m < otherFactor; m++) {
          binList[m * otherFactor + j * factor + k].push_back(j);
        }
      }
    }
    otherFactor = otherFactor * nBins[i];
  }

  std::vector<std::string> allSuffixes;
  for (int i = 0; i < nTotalBins; i++) {
    allSuffixes.push_back(getSuffix(binList[i], observables, binnings));
  }

  return allSuffixes;
}

getBinInfo()

PFAnalyzer::binInfo PFAnalyzer::getBinInfo ( std::string  observableString )

private

Definition at line 333 of file PFAnalyzer.cc.

References PFAnalyzer::binInfo::axisName, PFAnalyzer::binInfo::binMax, PFAnalyzer::binInfo::binMin, getBinList(), PFAnalyzer::binInfo::nBins, and PFAnalyzer::binInfo::observable.

Referenced by bookHistograms().

                                                                   {
  PFAnalyzer::binInfo binningDetails;

  size_t pos = observableString.find(";");
  binningDetails.observable = observableString.substr(0, pos);
  observableString.erase(0, pos + 1);

  std::vector<double> binList = getBinList(observableString);
  pos = observableString.find(";");
  binningDetails.axisName = observableString.substr(0, pos);
  observableString.erase(0, pos + 1);

  pos = observableString.find(";");
  binningDetails.nBins = atoi(observableString.substr(0, pos).c_str());
  observableString.erase(0, pos + 1);

  pos = observableString.find(";");
  binningDetails.binMin = atof(observableString.substr(0, pos).c_str());
  observableString.erase(0, pos + 1);

  binningDetails.binMax = atof(observableString.c_str());

  return binningDetails;
}

getBinList()

std::vector< double > PFAnalyzer::getBinList ( std::string  binString )

private

Definition at line 399 of file PFAnalyzer.cc.

References mps_fire::i, createfilelist::int, and ecalPedestalPCLworker_cfi::nBins.

Referenced by getBinInfo(), and PFAnalyzer().

                                                            {
  std::vector<double> binList;

  while (binString.find(";") != std::string::npos) {
    size_t pos = binString.find(";");
    binList.push_back(atof(binString.substr(0, pos).c_str()));
    binString.erase(0, pos + 1);
  }
  binList.push_back(atof(binString.c_str()));

  if (binList.size() == 3) {
    int nBins = int(binList[0]);
    double minVal = binList[1];
    double maxVal = binList[2];
    binList.clear();

    for (int i = 0; i <= nBins; i++) {
      binList.push_back(minVal + i * (maxVal - minVal) / nBins);
    }
  }

  return binList;
}

getBinNumber()

int PFAnalyzer::getBinNumber ( double  binVal, std::vector< double >  bins  )

private

Definition at line 477 of file PFAnalyzer.cc.

References isotrackApplyRegressor::bins, and mps_fire::i.

Referenced by analyze(), and getBinNumbers().

                                                                  {
  if (binVal < bins[0])
    return -1;
  for (unsigned int i = 0; i < bins.size(); i++) {
    if (binVal < bins[i])
      return i - 1;
  }

  return -1;
}

getBinNumbers()

int PFAnalyzer::getBinNumbers ( std::vector< double >  binVal, std::vector< std::vector< double >>  bins  )

private

Definition at line 488 of file PFAnalyzer.cc.

References newFWLiteAna::bin, isotrackApplyRegressor::bins, getBinNumber(), mps_fire::i, ecalPedestalPCLworker_cfi::nBins, and findQualityFiles::size.

Referenced by getJetBin(), and getPFBin().

                                                                                         {
  std::vector<int> cbins;
  std::vector<int> nBins;
  for (unsigned int i = 0; i < binVal.size(); i++) {
    int cbin = getBinNumber(binVal[i], bins[i]);
    if (cbin < 0)
      return -1;
    nBins.push_back(bins[i].size() - 1);
    cbins.push_back(cbin);
  }

  int bin = 0;
  int factor = 1;
  for (unsigned int i = 0; i < binVal.size(); i++) {
    bin += cbins[i] * factor;
    factor = factor * nBins[i];
  }

  return bin;
}

getDNNEBkgNonIsolated()

static double PFAnalyzer::getDNNEBkgNonIsolated ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 173 of file PFAnalyzer.h.

References reco::PFCandidate::dnn_e_bkgNonIsolated().

Referenced by PFAnalyzer().

{ return pfCand.dnn_e_bkgNonIsolated(); }

getDNNEBkgPhotonIsolated()

static double PFAnalyzer::getDNNEBkgPhotonIsolated ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 175 of file PFAnalyzer.h.

References reco::PFCandidate::dnn_e_bkgPhoton().

Referenced by PFAnalyzer().

{ return pfCand.dnn_e_bkgPhoton(); }

getDNNEBkgTauIsolated()

static double PFAnalyzer::getDNNEBkgTauIsolated ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 174 of file PFAnalyzer.h.

References reco::PFCandidate::dnn_e_bkgTau().

Referenced by PFAnalyzer().

{ return pfCand.dnn_e_bkgTau(); }

getDNNESigIsolated()

static double PFAnalyzer::getDNNESigIsolated ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 171 of file PFAnalyzer.h.

References reco::PFCandidate::dnn_e_sigIsolated().

Referenced by PFAnalyzer().

{ return pfCand.dnn_e_sigIsolated(); }

getDNNESigNonIsolated()

static double PFAnalyzer::getDNNESigNonIsolated ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 172 of file PFAnalyzer.h.

References reco::PFCandidate::dnn_e_sigNonIsolated().

Referenced by PFAnalyzer().

{ return pfCand.dnn_e_sigNonIsolated(); }

getECalEFrac()

static double PFAnalyzer::getECalEFrac ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 177 of file PFAnalyzer.h.

References reco::PFCandidate::ecalEnergy(), and reco::LeafCandidate::energy().

{ return pfCand.ecalEnergy() / pfCand.energy(); }

getEcalEnergy()

static double PFAnalyzer::getEcalEnergy ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 156 of file PFAnalyzer.h.

References reco::PFCandidate::ecalEnergy().

Referenced by PFAnalyzer().

{ return pfCand.ecalEnergy(); }

getECalEnergy()

static double PFAnalyzer::getECalEnergy ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 228 of file PFAnalyzer.h.

References MillePedeFileConverter_cfg::e, reco::PFBlockElement::ECAL, bookConverter::elements, reco::PFCandidate::elementsInBlocks(), HBHEDarkening_cff::energy, reco::PFCluster::energy(), and isoTrack_cff::maxElement.

                                                            {
    double energy = 0;
    int maxElement = pfCand.elementsInBlocks().size();
    for (int e = 0; e < maxElement; ++e) {
      // Get elements from block
      reco::PFBlockRef blockRef = pfCand.elementsInBlocks()[e].first;
      const edm::OwnVector<reco::PFBlockElement>& elements = blockRef->elements();
      for (unsigned iEle = 0; iEle < elements.size(); iEle++) {
        if (elements[iEle].index() == pfCand.elementsInBlocks()[e].second) {
          if (elements[iEle].type() == reco::PFBlockElement::ECAL) {  // Element is HB or HE
            // Get cluster and hits
            reco::PFClusterRef clusterref = elements[iEle].clusterRef();
            // When we don't have isolated tracks, this will be a bit useless, since the energy is shared across multiple tracks
            reco::PFCluster cluster = *clusterref;
            energy += cluster.energy();
          }
        }
      }
    }
    return energy;
  }

getEnergy()

static double PFAnalyzer::getEnergy ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 135 of file PFAnalyzer.h.

References reco::LeafCandidate::energy().

Referenced by PFAnalyzer().

{ return pfCand.energy(); }

getEnergySpectrum()

static double PFAnalyzer::getEnergySpectrum ( const reco::PFCandidate  pfCand, const reco::PFJet  jet  )

inlinestaticprivate

Definition at line 104 of file PFAnalyzer.h.

References metsig::jet, and reco::LeafCandidate::pt().

Referenced by PFAnalyzer().

                                                                                     {
    if (!jet.pt())
      return -1;
    return pfCand.pt() / jet.pt();
  }

getEoverP()

static double PFAnalyzer::getEoverP ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 185 of file PFAnalyzer.h.

References MillePedeFileConverter_cfg::e, reco::PFBlockElement::ECAL, bookConverter::elements, reco::PFCandidate::elementsInBlocks(), HBHEDarkening_cff::energy, reco::PFCluster::energy(), reco::PFBlockElement::HCAL, isoTrack_cff::maxElement, and reco::LeafCandidate::p().

Referenced by PFAnalyzer().

                                                        {
    double energy = 0;
    int maxElement = pfCand.elementsInBlocks().size();
    for (int e = 0; e < maxElement; ++e) {
      // Get elements from block
      reco::PFBlockRef blockRef = pfCand.elementsInBlocks()[e].first;
      const edm::OwnVector<reco::PFBlockElement>& elements = blockRef->elements();
      for (unsigned iEle = 0; iEle < elements.size(); iEle++) {
        if (elements[iEle].index() == pfCand.elementsInBlocks()[e].second) {
          if (elements[iEle].type() == reco::PFBlockElement::HCAL ||
              elements[iEle].type() == reco::PFBlockElement::ECAL) {  // Element is HB or HE
            reco::PFClusterRef clusterref = elements[iEle].clusterRef();
            reco::PFCluster cluster = *clusterref;
            energy += cluster.energy();
          }
        }
      }
    }
    return energy / pfCand.p();
  }

getEta()

static double PFAnalyzer::getEta ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 136 of file PFAnalyzer.h.

References reco::LeafCandidate::eta().

Referenced by PFAnalyzer().

{ return pfCand.eta(); }

getHadCalibration()

static double PFAnalyzer::getHadCalibration ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 140 of file PFAnalyzer.h.

References reco::PFCandidate::hcalEnergy(), and reco::PFCandidate::rawHcalEnergy().

Referenced by PFAnalyzer().

                                                                {
    if (pfCand.rawHcalEnergy() == 0)
      return -1;
    return pfCand.hcalEnergy() / pfCand.rawHcalEnergy();
  }

getHCalEFrac()

static double PFAnalyzer::getHCalEFrac ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 178 of file PFAnalyzer.h.

References reco::LeafCandidate::energy(), and reco::PFCandidate::hcalEnergy().

{ return pfCand.hcalEnergy() / pfCand.energy(); }

getHcalEnergy()

static double PFAnalyzer::getHcalEnergy ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 158 of file PFAnalyzer.h.

References reco::PFCandidate::hcalEnergy().

Referenced by PFAnalyzer().

{ return pfCand.hcalEnergy(); }

getHCalEnergy()

static double PFAnalyzer::getHCalEnergy ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 206 of file PFAnalyzer.h.

References MillePedeFileConverter_cfg::e, bookConverter::elements, reco::PFCandidate::elementsInBlocks(), HBHEDarkening_cff::energy, reco::PFCluster::energy(), reco::PFBlockElement::HCAL, and isoTrack_cff::maxElement.

Referenced by PFAnalyzer().

                                                            {
    double energy = 0;
    int maxElement = pfCand.elementsInBlocks().size();
    for (int e = 0; e < maxElement; ++e) {
      // Get elements from block
      reco::PFBlockRef blockRef = pfCand.elementsInBlocks()[e].first;
      const edm::OwnVector<reco::PFBlockElement>& elements = blockRef->elements();
      for (unsigned iEle = 0; iEle < elements.size(); iEle++) {
        if (elements[iEle].index() == pfCand.elementsInBlocks()[e].second) {
          if (elements[iEle].type() == reco::PFBlockElement::HCAL) {  // Element is HB or HE
            // Get cluster and hits
            reco::PFClusterRef clusterref = elements[iEle].clusterRef();
            reco::PFCluster cluster = *clusterref;
            //std::vector<std::pair<DetId, float>> hitsAndFracs = cluster.hitsAndFractions();
            energy += cluster.energy();
          }
        }
      }
    }
    return energy;
  }

getHcalEnergy_depth1()

static double PFAnalyzer::getHcalEnergy_depth1 ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 148 of file PFAnalyzer.h.

References reco::PFCandidate::hcalDepthEnergyFraction().

Referenced by PFAnalyzer().

{ return pfCand.hcalDepthEnergyFraction(1); }

getHcalEnergy_depth2()

static double PFAnalyzer::getHcalEnergy_depth2 ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 149 of file PFAnalyzer.h.

References reco::PFCandidate::hcalDepthEnergyFraction().

Referenced by PFAnalyzer().

{ return pfCand.hcalDepthEnergyFraction(2); }

getHcalEnergy_depth3()

static double PFAnalyzer::getHcalEnergy_depth3 ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 150 of file PFAnalyzer.h.

References reco::PFCandidate::hcalDepthEnergyFraction().

Referenced by PFAnalyzer().

{ return pfCand.hcalDepthEnergyFraction(3); }

getHcalEnergy_depth4()

static double PFAnalyzer::getHcalEnergy_depth4 ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 151 of file PFAnalyzer.h.

References reco::PFCandidate::hcalDepthEnergyFraction().

Referenced by PFAnalyzer().

{ return pfCand.hcalDepthEnergyFraction(4); }

getHcalEnergy_depth5()

static double PFAnalyzer::getHcalEnergy_depth5 ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 152 of file PFAnalyzer.h.

References reco::PFCandidate::hcalDepthEnergyFraction().

Referenced by PFAnalyzer().

{ return pfCand.hcalDepthEnergyFraction(5); }

getHcalEnergy_depth6()

static double PFAnalyzer::getHcalEnergy_depth6 ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 153 of file PFAnalyzer.h.

References reco::PFCandidate::hcalDepthEnergyFraction().

Referenced by PFAnalyzer().

{ return pfCand.hcalDepthEnergyFraction(6); }

getHcalEnergy_depth7()

static double PFAnalyzer::getHcalEnergy_depth7 ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 154 of file PFAnalyzer.h.

References reco::PFCandidate::hcalDepthEnergyFraction().

Referenced by PFAnalyzer().

{ return pfCand.hcalDepthEnergyFraction(7); }

getHOEnergy()

static double PFAnalyzer::getHOEnergy ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 160 of file PFAnalyzer.h.

References reco::PFCandidate::hoEnergy().

Referenced by PFAnalyzer().

{ return pfCand.hoEnergy(); }

getJetBin()

int PFAnalyzer::getJetBin ( const reco::PFJet  jetCand, int  i  )

private

Definition at line 518 of file PFAnalyzer.cc.

References getBinNumbers(), mps_fire::i, dqmiolumiharvest::j, m_fullJetCutList, m_jetBinList, and m_jetFuncMap.

Referenced by analyze().

                                                        {
  std::vector<double> binVals;
  for (unsigned int j = 0; j < m_fullJetCutList[i].size(); j++) {
    binVals.push_back(m_jetFuncMap[m_fullJetCutList[i][j]](jetCand));
  }

  return getBinNumbers(binVals, m_jetBinList[i]);
}

getJetPt()

static double PFAnalyzer::getJetPt ( const reco::PFJet  jet )

inlinestaticprivate

Definition at line 269 of file PFAnalyzer.h.

References metsig::jet.

Referenced by PFAnalyzer().

{ return jet.pt(); }

getMVAEMu()

static double PFAnalyzer::getMVAEMu ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 165 of file PFAnalyzer.h.

References reco::PFCandidate::mva_e_mu().

Referenced by PFAnalyzer().

{ return pfCand.mva_e_mu(); }

getMVAEPi()

static double PFAnalyzer::getMVAEPi ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 164 of file PFAnalyzer.h.

References reco::PFCandidate::mva_e_pi().

Referenced by PFAnalyzer().

{ return pfCand.mva_e_pi(); }

getMVAGammaNH()

static double PFAnalyzer::getMVAGammaNH ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 169 of file PFAnalyzer.h.

References reco::PFCandidate::mva_gamma_nh().

Referenced by PFAnalyzer().

{ return pfCand.mva_gamma_nh(); }

getMVAIsolated()

static double PFAnalyzer::getMVAIsolated ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 163 of file PFAnalyzer.h.

References reco::PFCandidate::mva_Isolated().

Referenced by PFAnalyzer().

{ return pfCand.mva_Isolated(); }

getMVANothingGamma()

static double PFAnalyzer::getMVANothingGamma ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 167 of file PFAnalyzer.h.

References reco::PFCandidate::mva_nothing_gamma().

Referenced by PFAnalyzer().

{ return pfCand.mva_nothing_gamma(); }

getMVANothingNH()

static double PFAnalyzer::getMVANothingNH ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 168 of file PFAnalyzer.h.

References reco::PFCandidate::mva_nothing_nh().

Referenced by PFAnalyzer().

{ return pfCand.mva_nothing_nh(); }

getMVAPiMu()

static double PFAnalyzer::getMVAPiMu ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 166 of file PFAnalyzer.h.

References reco::PFCandidate::mva_pi_mu().

Referenced by PFAnalyzer().

{ return pfCand.mva_pi_mu(); }

getNPFC()

static double PFAnalyzer::getNPFC ( const reco::PFCandidateCollection  pfCands, reco::PFCandidate::ParticleType  pfType  )

inlinestaticprivate

Definition at line 110 of file PFAnalyzer.h.

References X.

Referenced by PFAnalyzer().

                                                                                                     {
    int nPF = 0;
    for (auto pfCand : pfCands) {
      // We use X to indicate all
      if (pfCand.particleId() == pfType || pfType == reco::PFCandidate::ParticleType::X) {
        nPF++;
      }
    }
    return nPF;
  }

getNPFCinJet()

static double PFAnalyzer::getNPFCinJet ( const std::vector< reco::PFCandidatePtr >  pfCands, reco::PFCandidate::ParticleType  pfType  )

inlinestaticprivate

Definition at line 121 of file PFAnalyzer.h.

References X.

Referenced by PFAnalyzer().

                                                                                                              {
    int nPF = 0;
    for (auto pfCand : pfCands) {
      if (!pfCand)
        continue;
      // We use X to indicate all
      if (pfCand->particleId() == pfType || pfType == reco::PFCandidate::ParticleType::X)
        nPF++;
    }
    return nPF;
  }

getNTracksInBlock()

static double PFAnalyzer::getNTracksInBlock ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 250 of file PFAnalyzer.h.

References MillePedeFileConverter_cfg::e, bookConverter::elements, reco::PFCandidate::elementsInBlocks(), isoTrack_cff::maxElement, l1ctLayer1_cff::nTrack, and reco::PFBlockElement::TRACK.

Referenced by PFAnalyzer().

                                                                {
    // We need this function to return a double, even though this is an integer value
    double nTrack = 0;
    int maxElement = pfCand.elementsInBlocks().size();
    for (int e = 0; e < maxElement; ++e) {
      // Get elements from block
      reco::PFBlockRef blockRef = pfCand.elementsInBlocks()[e].first;
      const edm::OwnVector<reco::PFBlockElement>& elements = blockRef->elements();
      for (unsigned iEle = 0; iEle < elements.size(); iEle++) {
        if (elements[iEle].index() == pfCand.elementsInBlocks()[e].second) {
          if (elements[iEle].type() == reco::PFBlockElement::TRACK) {  // Element is HB or HE
            nTrack += 1;
          }
        }
      }
    }
    return nTrack;
  }

getPFBin()

int PFAnalyzer::getPFBin ( const reco::PFCandidate  pfCand, int  i  )

private

Definition at line 509 of file PFAnalyzer.cc.

References getBinNumbers(), mps_fire::i, dqmiolumiharvest::j, m_binList, m_fullCutList, and m_funcMap.

Referenced by analyze().

                                                            {
  std::vector<double> binVals;
  for (unsigned int j = 0; j < m_fullCutList[i].size(); j++) {
    binVals.push_back(m_funcMap[m_fullCutList[i][j]](pfCand));
  }

  return getBinNumbers(binVals, m_binList[i]);
}

getPhi()

static double PFAnalyzer::getPhi ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 138 of file PFAnalyzer.h.

References reco::LeafCandidate::phi().

Referenced by PFAnalyzer().

{ return pfCand.phi(); }

getPt()

static double PFAnalyzer::getPt ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 134 of file PFAnalyzer.h.

References reco::LeafCandidate::pt().

Referenced by PFAnalyzer().

{ return pfCand.pt(); }

getRawEcalEnergy()

static double PFAnalyzer::getRawEcalEnergy ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 157 of file PFAnalyzer.h.

References reco::PFCandidate::rawEcalEnergy().

Referenced by PFAnalyzer().

{ return pfCand.rawEcalEnergy(); }

getRawHcalEnergy()

static double PFAnalyzer::getRawHcalEnergy ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 159 of file PFAnalyzer.h.

References reco::PFCandidate::rawHcalEnergy().

Referenced by PFAnalyzer().

{ return pfCand.rawHcalEnergy(); }

getRawHOEnergy()

static double PFAnalyzer::getRawHOEnergy ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 161 of file PFAnalyzer.h.

References reco::PFCandidate::rawHoEnergy().

Referenced by PFAnalyzer().

{ return pfCand.rawHoEnergy(); }

getSuffix()

std::string PFAnalyzer::getSuffix ( std::vector< int >  binList, std::vector< std::string >  observables, std::vector< std::vector< double >>  binnings  )

private

Definition at line 462 of file PFAnalyzer.cc.

References mps_fire::i, runBasic_cfi::observables, AlCaHLTBitMon_QueryRunRegistry::string, stringWithDecimals(), and Ecal_PulseShapes_cfg::suffix.

Referenced by getAllSuffixes().

                                                                         {
  std::string suffix = "";
  for (unsigned int i = 0; i < binList.size(); i++) {
    if (binList[i] < 0)
      return "";
    std::string digitString = stringWithDecimals(binList[i], binnings[i]);

    suffix = Form("%s_%s_%s", suffix.c_str(), observables[i].c_str(), digitString.c_str());
  }

  return suffix;
}

getTime()

static double PFAnalyzer::getTime ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 146 of file PFAnalyzer.h.

References reco::PFCandidate::time().

{ return pfCand.time(); }

getTrackPt()

static double PFAnalyzer::getTrackPt ( const reco::PFCandidate  pfCand )

inlinestaticprivate

Definition at line 179 of file PFAnalyzer.h.

References edm::Ref< C, T, F >::isNonnull(), DiDispStaMuonMonitor_cfi::pt, and reco::PFCandidate::trackRef().

                                                         {
    if (pfCand.trackRef().isNonnull())
      return (pfCand.trackRef())->pt();
    return 0;
  }

passesEventSelection()

bool PFAnalyzer::passesEventSelection ( const edm::Event &  iEvent )

private

Definition at line 365 of file PFAnalyzer.cc.

Referenced by analyze().

{ return true; }

stringWithDecimals()

std::string PFAnalyzer::stringWithDecimals ( int  bin, std::vector< double >  bins  )

private

Definition at line 368 of file PFAnalyzer.cc.

References funct::abs(), newFWLiteAna::bin, isotrackApplyRegressor::bins, change_name::diff, createfilelist::int, funct::pow(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by getSuffix().

                                                                        {
  double diff = bins[bin + 1] - bins[bin];
  double sigFigs = log10(diff);

  // We only want to save as many significant digits as we need to.
  // Currently, we might lose some information, so we should think about
  // if we want to specify more digits
  if (sigFigs >= 1) {
    return Form("%.0f_%.0f", bins[bin], bins[bin + 1]);
  }

  int nDecimals = int(-1 * sigFigs) + 1;
  // We do not want to use decimals since these can mess up histogram retrieval in some cases.
  // Instead, we use a 'p' to indicate the decimal.
  double newDigit = abs((bins[bin] - int(bins[bin])) * pow(10, nDecimals));
  double newDigit2 = (bins[bin + 1] - int(bins[bin + 1])) * pow(10, nDecimals);
  std::string signStringLow = "";
  std::string signStringHigh = "";
  if (bins[bin] < 0)
    signStringLow = "m";
  if (bins[bin + 1] < 0)
    signStringHigh = "m";
  return Form("%s%.0fp%.0f_%s%.0fp%.0f",
              signStringLow.c_str(),
              abs(bins[bin]),
              newDigit,
              signStringHigh.c_str(),
              abs(bins[bin + 1]),
              newDigit2);
}

Member Data Documentation

highPtJetExpr_

edm::InputTag PFAnalyzer::highPtJetExpr_

private

Definition at line 283 of file PFAnalyzer.h.

Referenced by analyze(), and PFAnalyzer().

m_allJetSuffixes

std::vector<std::vector<std::string> > PFAnalyzer::m_allJetSuffixes

private

Definition at line 287 of file PFAnalyzer.h.

Referenced by analyze(), and bookHistograms().

m_allSuffixes

std::vector<std::vector<std::string> > PFAnalyzer::m_allSuffixes

private

Definition at line 286 of file PFAnalyzer.h.

Referenced by analyze(), and bookHistograms().

m_binList

std::vector<std::vector<std::vector<double> > > PFAnalyzer::m_binList

private

Definition at line 321 of file PFAnalyzer.h.

Referenced by bookHistograms(), getPFBin(), and PFAnalyzer().

m_cutList

vstring PFAnalyzer::m_cutList

private

Definition at line 319 of file PFAnalyzer.h.

Referenced by PFAnalyzer().

m_directory

std::string PFAnalyzer::m_directory

private

Definition at line 290 of file PFAnalyzer.h.

Referenced by analyze(), bookHistograms(), and PFAnalyzer().

m_eventFuncMap

std::map<std::string, std::function<double(const reco::PFCandidateCollection, reco::PFCandidate::ParticleType pfType)> > PFAnalyzer::m_eventFuncMap

private

Definition at line 75 of file PFAnalyzer.h.

Referenced by analyze(), and PFAnalyzer().

m_eventObservableNames

vstring PFAnalyzer::m_eventObservableNames

private

Definition at line 311 of file PFAnalyzer.h.

Referenced by analyze(), and bookHistograms().

m_eventObservables

vstring PFAnalyzer::m_eventObservables

private

Definition at line 307 of file PFAnalyzer.h.

Referenced by bookHistograms(), and PFAnalyzer().

m_fullCutList

std::vector<std::vector<std::string> > PFAnalyzer::m_fullCutList

private

Definition at line 320 of file PFAnalyzer.h.

Referenced by analyze(), bookHistograms(), getPFBin(), and PFAnalyzer().

m_fullJetCutList

std::vector<std::vector<std::string> > PFAnalyzer::m_fullJetCutList

private

Definition at line 329 of file PFAnalyzer.h.

Referenced by analyze(), bookHistograms(), getJetBin(), and PFAnalyzer().

m_funcMap

std::map<std::string, std::function<double(const reco::PFCandidate)> > PFAnalyzer::m_funcMap

private

Definition at line 69 of file PFAnalyzer.h.

Referenced by analyze(), getPFBin(), and PFAnalyzer().

m_jetBinList

std::vector<std::vector<std::vector<double> > > PFAnalyzer::m_jetBinList

private

Definition at line 330 of file PFAnalyzer.h.

Referenced by bookHistograms(), getJetBin(), and PFAnalyzer().

m_jetCutList

vstring PFAnalyzer::m_jetCutList

private

Definition at line 328 of file PFAnalyzer.h.

Referenced by PFAnalyzer().

m_jetFuncMap

std::map<std::string, std::function<double(const reco::PFJet)> > PFAnalyzer::m_jetFuncMap

private

Definition at line 80 of file PFAnalyzer.h.

Referenced by getJetBin(), and PFAnalyzer().

m_jetWideFuncMap

std::map<std::string, std::function<double(const std::vector<reco::PFCandidatePtr> pfCands, reco::PFCandidate::ParticleType pfType)> > PFAnalyzer::m_jetWideFuncMap

private

Definition at line 78 of file PFAnalyzer.h.

Referenced by analyze(), and PFAnalyzer().

m_matchingRadius

double PFAnalyzer::m_matchingRadius

private

Definition at line 336 of file PFAnalyzer.h.

m_npvBins

vDouble PFAnalyzer::m_npvBins

private

Definition at line 332 of file PFAnalyzer.h.

Referenced by analyze(), bookHistograms(), and PFAnalyzer().

m_observableNames

vstring PFAnalyzer::m_observableNames

private

Definition at line 310 of file PFAnalyzer.h.

Referenced by analyze(), and bookHistograms().

m_observables

vstring PFAnalyzer::m_observables

private

Definition at line 306 of file PFAnalyzer.h.

Referenced by analyze(), bookHistograms(), and PFAnalyzer().

m_pfInJetFuncMap

std::map<std::string, std::function<double(const reco::PFCandidate, const reco::PFJet)> > PFAnalyzer::m_pfInJetFuncMap

private

Definition at line 79 of file PFAnalyzer.h.

Referenced by analyze(), and PFAnalyzer().

m_pfInJetObservableNames

vstring PFAnalyzer::m_pfInJetObservableNames

private

Definition at line 312 of file PFAnalyzer.h.

Referenced by analyze(), and bookHistograms().

m_pfInJetObservables

vstring PFAnalyzer::m_pfInJetObservables

private

Definition at line 308 of file PFAnalyzer.h.

Referenced by bookHistograms(), and PFAnalyzer().

m_pfNames

std::vector<std::string> PFAnalyzer::m_pfNames

private

Definition at line 338 of file PFAnalyzer.h.

Referenced by bookHistograms(), and PFAnalyzer().

map_of_MEs

std::map<std::string, MonitorElement*> PFAnalyzer::map_of_MEs

private

Definition at line 293 of file PFAnalyzer.h.

Referenced by analyze(), and bookHistograms().

parameters_

edm::ParameterSet PFAnalyzer::parameters_

private

Definition at line 296 of file PFAnalyzer.h.

Referenced by Mixins._TypedParameterizable::clone(), Types.PSet::clone(), Types.EDAlias::clone(), Mixins._TypedParameterizable::copy(), and PFAnalyzer().

pfJetsToken_

edm::EDGetTokenT<reco::PFJetCollection> PFAnalyzer::pfJetsToken_

private

Definition at line 273 of file PFAnalyzer.h.

Referenced by analyze(), and PFAnalyzer().

srcWeights

edm::InputTag PFAnalyzer::srcWeights

private

Definition at line 274 of file PFAnalyzer.h.

Referenced by PFAnalyzer().

thePfCandidateCollection_

edm::EDGetTokenT<reco::PFCandidateCollection> PFAnalyzer::thePfCandidateCollection_

private

Definition at line 271 of file PFAnalyzer.h.

Referenced by analyze(), and PFAnalyzer().

theTriggerResultsLabel_

edm::InputTag PFAnalyzer::theTriggerResultsLabel_

private

Definition at line 281 of file PFAnalyzer.h.

Referenced by PFAnalyzer().

tok_ew_

edm::EDGetTokenT<GenEventInfoProduct> PFAnalyzer::tok_ew_

private

Definition at line 279 of file PFAnalyzer.h.

Referenced by analyze(), and PFAnalyzer().

triggerResultsToken_

edm::EDGetTokenT<edm::TriggerResults> PFAnalyzer::triggerResultsToken_

private

Definition at line 284 of file PFAnalyzer.h.

Referenced by analyze(), and PFAnalyzer().

vertexTag_

edm::InputTag PFAnalyzer::vertexTag_

private

Definition at line 282 of file PFAnalyzer.h.

Referenced by PFAnalyzer().

vertexToken_

edm::EDGetTokenT<std::vector<reco::Vertex> > PFAnalyzer::vertexToken_

private

Definition at line 272 of file PFAnalyzer.h.

Referenced by analyze(), and PFAnalyzer().

weights_

edm::ValueMap<float> const* PFAnalyzer::weights_

private

Definition at line 277 of file PFAnalyzer.h.

Referenced by analyze().

weightsToken_

edm::EDGetTokenT<edm::ValueMap<float> > PFAnalyzer::weightsToken_

private

Definition at line 276 of file PFAnalyzer.h.

Referenced by analyze(), and PFAnalyzer().