L1TMuonDQMOffline Class Reference

#include <L1TMuonDQMOffline.h>

Inheritance diagram for L1TMuonDQMOffline:

Public Types
enum	Control {   kCtrlTagPt, kCtrlTagEta, kCtrlTagPhi, kCtrlProbePt,   kCtrlProbeEta, kCtrlProbePhi, kCtrlTagProbeDr, kCtrlTagHltDr,   kCtrlMuonGmtDeltaR, kCtrlNTightVsAll, kCtrlNProbesVsTight }
enum	EffType { kEffPt, kEffPhi, kEffEta, kEffVtx }
enum	EtaRegion {   kEtaRegionAll, kEtaRegionBmtf, kEtaRegionOmtf, kEtaRegionEmtf,   kEtaRegionOut }
enum	QualLevel { kQualAll, kQualOpen, kQualDouble, kQualSingle }
enum	ResType {   kResPt, kRes1OverPt, kResQOverPt, kResPhi,   kResEta, kResCh }
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

Public Member Functions
	L1TMuonDQMOffline (const edm::ParameterSet &ps)
	~L1TMuonDQMOffline () override
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

Protected Member Functions
void	analyze (const edm::Event &e, const edm::EventSetup &c) override
virtual void	bookControlHistos (DQMStore::IBooker &)
virtual void	bookEfficiencyHistos (DQMStore::IBooker &ibooker)
void	bookHistograms (DQMStore::IBooker &ibooker, const edm::Run &run, const edm::EventSetup &iSetup) override
virtual void	bookResolutionHistos (DQMStore::IBooker &ibooker)
void	dqmBeginRun (const edm::Run &run, const edm::EventSetup &iSetup) override
Protected Member Functions inherited from DQMEDAnalyzer
uint64_t	meId () const

Private Types
typedef std::tuple< EffType, int, EtaRegion >	m_histoKeyEffDenVarType
typedef std::pair< int, QualLevel >	m_histoKeyEffNumEtaType
typedef std::tuple< EffType, int, EtaRegion, QualLevel >	m_histoKeyEffNumVarType
typedef std::tuple< ResType, EtaRegion, QualLevel >	m_histoKeyResType

Private Member Functions
std::vector< float >	getHistBinsEff (EffType eff)
std::tuple< int, double, double >	getHistBinsRes (ResType res)
void	getMuonGmtPairs (edm::Handle< l1t::MuonBxCollection > &gmtCands, PropagateToMuon const &propagator)
const unsigned int	getNVertices (edm::Handle< reco::VertexCollection > &vertex)
const reco::Vertex	getPrimaryVertex (edm::Handle< reco::VertexCollection > &vertex, edm::Handle< reco::BeamSpot > &beamSpot)
void	getProbeMuons (edm::Handle< edm::TriggerResults > &trigResults, edm::Handle< trigger::TriggerEvent > &trigEvent)
void	getTightMuons (edm::Handle< reco::MuonCollection > &muons, const reco::Vertex &vertex)
double	matchHlt (edm::Handle< trigger::TriggerEvent > &triggerEvent, const reco::Muon *mu)

Private Attributes
edm::EDGetTokenT< reco::BeamSpot >	m_BsInputTag
std::map< Control, MonitorElement * >	m_ControlHistos
std::vector< std::pair< int, QualLevel > >	m_cuts
std::vector< edm::ParameterSet >	m_cutsVPSet
std::map< int, MonitorElement * >	m_EfficiencyDenEtaHistos
std::map< EtaRegion, MonitorElement * >	m_EfficiencyDenPtHistos
std::map< std::tuple< EffType, int, EtaRegion >, MonitorElement * >	m_EfficiencyDenVarHistos
std::map< std::pair< int, QualLevel >, MonitorElement * >	m_EfficiencyNumEtaHistos
std::map< std::tuple< EffType, int, EtaRegion, QualLevel >, MonitorElement * >	m_EfficiencyNumVarHistos
std::map< EffType, std::string >	m_effLabelStrings
std::map< EffType, std::string >	m_effStrings
const std::vector< EffType >	m_effTypes
std::vector< double >	m_effVsEtaBins
std::vector< double >	m_effVsPhiBins
std::vector< double >	m_effVsPtBins
std::vector< double >	m_effVsVtxBins
const std::vector< EtaRegion >	m_etaRegions
std::map< EtaRegion, std::string >	m_etaStrings
edm::EDGetTokenT< l1t::MuonBxCollection >	m_GmtInputTag
std::string	m_HistFolder
HLTConfigProvider	m_hltConfig
BXVector< l1t::Muon >	m_L1tL1tMuons
std::vector< l1t::MuonBxCollection >	m_L1tMuons
float	m_maxGmtMuonDR
float	m_maxHltMuonDR
float	m_minTagProbeDR
std::vector< MuonGmtPair >	m_MuonGmtPairs
edm::EDGetTokenT< reco::MuonCollection >	m_MuonInputTag
std::vector< const reco::Muon * >	m_ProbeMuons
PropagateToMuonSetup const	m_propagatorSetup
const std::vector< QualLevel >	m_qualLevelsRes
std::map< QualLevel, std::string >	m_qualStrings
std::vector< reco::MuonCollection >	m_RecoMuons
std::vector< reco::Muon >	m_RecoRecoMuons
double	m_recoToL1PtCutFactor
std::map< ResType, std::string >	m_resLabelStrings
std::map< std::tuple< ResType, EtaRegion, QualLevel >, MonitorElement * >	m_ResolutionHistos
std::map< ResType, std::string >	m_resStrings
const std::vector< ResType >	m_resTypes
double	m_TagPtCut
std::vector< const reco::Muon * >	m_TightMuons
std::vector< int >	m_trigIndices
edm::EDGetTokenT< trigger::TriggerEvent >	m_trigInputTag
std::vector< std::string >	m_trigNames
std::string	m_trigProcess
edm::EDGetTokenT< edm::TriggerResults >	m_trigProcess_token
bool	m_useAtVtxCoord
bool	m_verbose
edm::EDGetTokenT< reco::VertexCollection >	m_VtxInputTag

Additional Inherited Members
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 Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_
edm::EDPutTokenT< DQMToken >	runToken_
unsigned int	streamId_

Detailed Description

Definition at line 62 of file L1TMuonDQMOffline.h.

Member Typedef Documentation

m_histoKeyEffDenVarType

typedef std::tuple<EffType, int, EtaRegion> L1TMuonDQMOffline::m_histoKeyEffDenVarType

private

Definition at line 118 of file L1TMuonDQMOffline.h.

m_histoKeyEffNumEtaType

typedef std::pair<int, QualLevel> L1TMuonDQMOffline::m_histoKeyEffNumEtaType

private

Definition at line 116 of file L1TMuonDQMOffline.h.

m_histoKeyEffNumVarType

typedef std::tuple<EffType, int, EtaRegion, QualLevel> L1TMuonDQMOffline::m_histoKeyEffNumVarType

private

Definition at line 115 of file L1TMuonDQMOffline.h.

m_histoKeyResType

typedef std::tuple<ResType, EtaRegion, QualLevel> L1TMuonDQMOffline::m_histoKeyResType

private

Definition at line 113 of file L1TMuonDQMOffline.h.

Member Enumeration Documentation

Control

enum L1TMuonDQMOffline::Control

Enumerator
kCtrlTagPt
kCtrlTagEta
kCtrlTagPhi
kCtrlProbePt
kCtrlProbeEta
kCtrlProbePhi
kCtrlTagProbeDr
kCtrlTagHltDr
kCtrlMuonGmtDeltaR
kCtrlNTightVsAll
kCtrlNProbesVsTight

Definition at line 64 of file L1TMuonDQMOffline.h.

               {
    kCtrlTagPt,
    kCtrlTagEta,
    kCtrlTagPhi,
    kCtrlProbePt,
    kCtrlProbeEta,
    kCtrlProbePhi,
    kCtrlTagProbeDr,
    kCtrlTagHltDr,
    kCtrlMuonGmtDeltaR,
    kCtrlNTightVsAll,
    kCtrlNProbesVsTight
  };

EffType

enum L1TMuonDQMOffline::EffType

Enumerator
kEffPt
kEffPhi
kEffEta
kEffVtx

Definition at line 77 of file L1TMuonDQMOffline.h.

{ kEffPt, kEffPhi, kEffEta, kEffVtx };

EtaRegion

enum L1TMuonDQMOffline::EtaRegion

Enumerator
kEtaRegionAll
kEtaRegionBmtf
kEtaRegionOmtf
kEtaRegionEmtf
kEtaRegionOut

Definition at line 79 of file L1TMuonDQMOffline.h.

{ kEtaRegionAll, kEtaRegionBmtf, kEtaRegionOmtf, kEtaRegionEmtf, kEtaRegionOut };

QualLevel

enum L1TMuonDQMOffline::QualLevel

Enumerator
kQualAll
kQualOpen
kQualDouble
kQualSingle

Definition at line 80 of file L1TMuonDQMOffline.h.

{ kQualAll, kQualOpen, kQualDouble, kQualSingle };

ResType

enum L1TMuonDQMOffline::ResType

Enumerator
kResPt
kRes1OverPt
kResQOverPt
kResPhi
kResEta
kResCh

Definition at line 78 of file L1TMuonDQMOffline.h.

{ kResPt, kRes1OverPt, kResQOverPt, kResPhi, kResEta, kResCh };

Constructor & Destructor Documentation

L1TMuonDQMOffline()

L1TMuonDQMOffline::L1TMuonDQMOffline

(

const edm::ParameterSet &

ps

)

Definition at line 110 of file L1TMuonDQMOffline.cc.

References kEffEta, kEffPhi, kEffPt, and kEffVtx.

    : m_propagatorSetup(ps.getParameter<edm::ParameterSet>("muProp"), consumesCollector()),
      m_effTypes({kEffPt, kEffPhi, kEffEta, kEffVtx}),
      m_resTypes({kResPt, kResQOverPt, kResPhi, kResEta}),
      m_etaRegions({kEtaRegionAll, kEtaRegionBmtf, kEtaRegionOmtf, kEtaRegionEmtf}),
      m_qualLevelsRes({kQualAll}),
      m_effStrings({{kEffPt, "pt"}, {kEffPhi, "phi"}, {kEffEta, "eta"}, {kEffVtx, "vtx"}}),
      m_effLabelStrings({{kEffPt, "p_{T} (GeV)"}, {kEffPhi, "#phi"}, {kEffEta, "#eta"}, {kEffVtx, "# vertices"}}),
      m_resStrings({{kResPt, "pt"},
                    {kRes1OverPt, "1overpt"},
                    {kResQOverPt, "qoverpt"},
                    {kResPhi, "phi"},
                    {kResEta, "eta"},
                    {kResCh, "charge"}}),
      m_resLabelStrings({{kResPt, "(p_{T}^{L1} - p_{T}^{reco})/p_{T}^{reco}"},
                         {kRes1OverPt, "(p_{T}^{reco} - p_{T}^{L1})/p_{T}^{L1}"},
                         {kResQOverPt, "(q^{L1}*q^{reco}*p_{T}^{reco} - p_{T}^{L1})/p_{T}^{L1}"},
                         {kResPhi, "#phi_{L1} - #phi_{reco}"},
                         {kResEta, "#eta_{L1} - #eta_{reco}"},
                         {kResCh, "charge^{L1} - charge^{reco}"}}),
      m_etaStrings({{kEtaRegionAll, "etaMin0_etaMax2p4"},
                    {kEtaRegionBmtf, "etaMin0_etaMax0p83"},
                    {kEtaRegionOmtf, "etaMin0p83_etaMax1p24"},
                    {kEtaRegionEmtf, "etaMin1p24_etaMax2p4"}}),
      m_qualStrings(
          {{kQualAll, "qualAll"}, {kQualOpen, "qualOpen"}, {kQualDouble, "qualDouble"}, {kQualSingle, "qualSingle"}}),
      m_verbose(ps.getUntrackedParameter<bool>("verbose")),
      m_HistFolder(ps.getUntrackedParameter<string>("histFolder")),
      m_TagPtCut(ps.getUntrackedParameter<double>("tagPtCut")),
      m_recoToL1PtCutFactor(ps.getUntrackedParameter<double>("recoToL1PtCutFactor")),
      m_cutsVPSet(ps.getUntrackedParameter<std::vector<edm::ParameterSet>>("cuts")),
      m_MuonInputTag(consumes<reco::MuonCollection>(ps.getUntrackedParameter<InputTag>("muonInputTag"))),
      m_GmtInputTag(consumes<l1t::MuonBxCollection>(ps.getUntrackedParameter<InputTag>("gmtInputTag"))),
      m_VtxInputTag(consumes<VertexCollection>(ps.getUntrackedParameter<InputTag>("vtxInputTag"))),
      m_BsInputTag(consumes<BeamSpot>(ps.getUntrackedParameter<InputTag>("bsInputTag"))),
      m_trigInputTag(consumes<trigger::TriggerEvent>(ps.getUntrackedParameter<InputTag>("trigInputTag"))),
      m_trigProcess(ps.getUntrackedParameter<string>("trigProcess")),
      m_trigProcess_token(consumes<edm::TriggerResults>(ps.getUntrackedParameter<InputTag>("trigProcess_token"))),
      m_trigNames(ps.getUntrackedParameter<vector<string>>("triggerNames")),
      m_effVsPtBins(ps.getUntrackedParameter<std::vector<double>>("efficiencyVsPtBins")),
      m_effVsPhiBins(ps.getUntrackedParameter<std::vector<double>>("efficiencyVsPhiBins")),
      m_effVsEtaBins(ps.getUntrackedParameter<std::vector<double>>("efficiencyVsEtaBins")),
      m_effVsVtxBins(ps.getUntrackedParameter<std::vector<double>>("efficiencyVsVtxBins")),
      m_useAtVtxCoord(ps.getUntrackedParameter<bool>("useL1AtVtxCoord")),
      m_maxGmtMuonDR(0.3),
      m_minTagProbeDR(0.5),
      m_maxHltMuonDR(0.1) {
  if (m_verbose)
    cout << "[L1TMuonDQMOffline:] ____________ Storage initialization ____________ " << endl;

  for (const auto& cutsPSet : m_cutsVPSet) {
    const auto qCut = cutsPSet.getUntrackedParameter<int>("qualCut");
    QualLevel qLevel = kQualAll;
    if (qCut > 11) {
      qLevel = kQualSingle;
    } else if (qCut > 7) {
      qLevel = kQualDouble;
    } else if (qCut > 3) {
      qLevel = kQualOpen;
    }
    m_cuts.emplace_back(std::make_pair(cutsPSet.getUntrackedParameter<int>("ptCut"), qLevel));
  }
}

~L1TMuonDQMOffline()

L1TMuonDQMOffline::~L1TMuonDQMOffline ( )

override

Definition at line 175 of file L1TMuonDQMOffline.cc.

{}

Member Function Documentation

analyze()

void L1TMuonDQMOffline::analyze ( const edm::Event &  e, const edm::EventSetup &  c  )

overrideprotectedvirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 212 of file L1TMuonDQMOffline.cc.

References pwdgSkimBPark_cfi::beamSpot, gather_cfg::cout, PA_MinBiasSkim_cff::cut, options_cfi::eventSetup, getMuonGmtPairs(), getNVertices(), getPrimaryVertex(), getProbeMuons(), getTightMuons(), iEvent, kEffEta, kEffPt, kEffVtx, kEtaRegionAll, kEtaRegionOut, kQualAll, kResPt, m_BsInputTag, m_cuts, m_EfficiencyDenEtaHistos, m_EfficiencyDenPtHistos, m_EfficiencyDenVarHistos, m_EfficiencyNumEtaHistos, m_EfficiencyNumVarHistos, m_effTypes, m_GmtInputTag, m_MuonGmtPairs, m_MuonInputTag, m_propagatorSetup, m_qualLevelsRes, m_recoToL1PtCutFactor, m_ResolutionHistos, m_resTypes, m_trigInputTag, m_trigProcess_token, m_verbose, m_VtxInputTag, PDWG_BPHSkim_cff::muons, L1TkPrimaryVertex_cfi::nVtx, BeamMonitor_cff::primaryVertex, TrackCandidateProducer_cfi::propagator, L1TMuonDQMOffline_cfi::qualCut, B2GTnPMonitor_cfi::trigEvent, trigObjTnPSource_cfi::var, and bphysicsOniaDQM_cfi::vertex.

                                                                                 {
  auto const propagator = m_propagatorSetup.init(eventSetup);

  Handle<reco::MuonCollection> muons;
  iEvent.getByToken(m_MuonInputTag, muons);
  Handle<BeamSpot> beamSpot;
  iEvent.getByToken(m_BsInputTag, beamSpot);
  Handle<VertexCollection> vertex;
  iEvent.getByToken(m_VtxInputTag, vertex);
  Handle<l1t::MuonBxCollection> gmtCands;
  iEvent.getByToken(m_GmtInputTag, gmtCands);
  Handle<edm::TriggerResults> trigResults;
  iEvent.getByToken(m_trigProcess_token, trigResults);
  edm::Handle<trigger::TriggerEvent> trigEvent;
  iEvent.getByToken(m_trigInputTag, trigEvent);

  const auto nVtx = getNVertices(vertex);
  const Vertex primaryVertex = getPrimaryVertex(vertex, beamSpot);

  getTightMuons(muons, primaryVertex);
  getProbeMuons(trigResults, trigEvent);  // CB add flag to run on orthogonal datasets (no T&P)

  getMuonGmtPairs(gmtCands, propagator);

  if (m_verbose)
    cout << "[L1TMuonDQMOffline:] Computing efficiencies" << endl;

  vector<MuonGmtPair>::const_iterator muonGmtPairsIt = m_MuonGmtPairs.begin();
  vector<MuonGmtPair>::const_iterator muonGmtPairsEnd = m_MuonGmtPairs.end();

  // To fill once for global eta and once for TF eta region of the L1T muon.
  // The second entry is a placeholder and will be replaced by the TF eta region of the L1T muon.
  std::array<EtaRegion, 2> regsToFill{{kEtaRegionAll, kEtaRegionAll}};

  for (; muonGmtPairsIt != muonGmtPairsEnd; ++muonGmtPairsIt) {
    // Fill the resolution histograms
    if ((muonGmtPairsIt->etaRegion() != kEtaRegionOut) && (muonGmtPairsIt->gmtPt() > 0)) {
      regsToFill[1] = muonGmtPairsIt->etaRegion();
      m_histoKeyResType histoKeyRes = {kResPt, kEtaRegionAll, kQualAll};
      for (const auto var : m_resTypes) {
        const auto varToFill = muonGmtPairsIt->getDeltaVar(var);
        std::get<0>(histoKeyRes) = var;
        // Fill for the global eta and for TF eta region that the probe muon is in
        for (const auto regToFill : regsToFill) {
          std::get<1>(histoKeyRes) = regToFill;
          for (const auto qualLevel : m_qualLevelsRes) {
            // This assumes that the qualLevel enum has increasing qualities
            // HW quality levels can be 0, 4, 8, or 12
            int qualCut = qualLevel * 4;
            if (muonGmtPairsIt->gmtQual() >= qualCut) {
              std::get<2>(histoKeyRes) = qualLevel;
              m_ResolutionHistos[histoKeyRes]->Fill(varToFill);
            }
          }
        }
      }
    }

    // Fill the efficiency numerator and denominator histograms
    if (muonGmtPairsIt->etaRegion() != kEtaRegionOut) {
      unsigned int cutsCounter = 0;
      for (const auto& cut : m_cuts) {
        const auto gmtPtCut = cut.first;
        const auto qualLevel = cut.second;
        const bool gmtAboveCut = (muonGmtPairsIt->gmtPt() > gmtPtCut);

        // default keys
        m_histoKeyEffDenVarType histoKeyEffDenVar = {kEffPt, gmtPtCut, kEtaRegionAll};
        m_histoKeyEffNumVarType histoKeyEffNumVar = {kEffPt, gmtPtCut, kEtaRegionAll, qualLevel};

        regsToFill[1] = muonGmtPairsIt->etaRegion();
        for (const auto var : m_effTypes) {
          if (var != kEffPt) {
            if (muonGmtPairsIt->pt() < m_recoToL1PtCutFactor * gmtPtCut)
              break;  // efficiency at plateau
          }
          double varToFill;
          if (var == kEffVtx) {
            varToFill = static_cast<double>(nVtx);
          } else {
            varToFill = muonGmtPairsIt->getVar(var);
          }
          // Fill denominators
          if (var == kEffEta) {
            m_EfficiencyDenEtaHistos[gmtPtCut]->Fill(varToFill);
          } else {
            std::get<0>(histoKeyEffDenVar) = var;
            // Fill for the global eta and for TF eta region that the probe muon is in
            for (const auto regToFill : regsToFill) {
              if (var == kEffPt) {
                if (cutsCounter == 0) {
                  m_EfficiencyDenPtHistos[regToFill]->Fill(varToFill);
                }
              } else {
                std::get<2>(histoKeyEffDenVar) = regToFill;
                m_EfficiencyDenVarHistos[histoKeyEffDenVar]->Fill(varToFill);
              }
            }
          }
          // Fill numerators
          std::get<0>(histoKeyEffNumVar) = var;
          // This assumes that the qualLevel enum has increasing qualities
          if (gmtAboveCut && muonGmtPairsIt->gmtQual() >= qualLevel * 4) {
            if (var == kEffEta) {
              m_histoKeyEffNumEtaType histoKeyEffNumEta = {gmtPtCut, qualLevel};
              m_EfficiencyNumEtaHistos[histoKeyEffNumEta]->Fill(varToFill);
            } else {
              std::get<3>(histoKeyEffNumVar) = qualLevel;
              // Fill for the global eta and for TF eta region that the probe muon is in
              for (const auto regToFill : regsToFill) {
                std::get<2>(histoKeyEffNumVar) = regToFill;
                m_EfficiencyNumVarHistos[histoKeyEffNumVar]->Fill(varToFill);
              }
            }
          }
        }
        ++cutsCounter;
      }
    }
  }

  if (m_verbose)
    cout << "[L1TMuonDQMOffline:] Computation finished" << endl;
}

bookControlHistos()

void L1TMuonDQMOffline::bookControlHistos ( DQMStore::IBooker &  ibooker )

protectedvirtual

Definition at line 338 of file L1TMuonDQMOffline.cc.

References dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), gather_cfg::cout, kCtrlMuonGmtDeltaR, kCtrlNProbesVsTight, kCtrlNTightVsAll, kCtrlProbeEta, kCtrlProbePhi, kCtrlProbePt, kCtrlTagEta, kCtrlTagHltDr, kCtrlTagPhi, kCtrlTagProbeDr, kCtrlTagPt, m_ControlHistos, m_HistFolder, m_verbose, and dqm::implementation::NavigatorBase::setCurrentFolder().

Referenced by bookHistograms().

                                                                  {
  if (m_verbose)
    cout << "[L1TMuonDQMOffline:] Booking Control Plot Histos" << endl;

  ibooker.setCurrentFolder(m_HistFolder + "/control_variables");

  m_ControlHistos[kCtrlMuonGmtDeltaR] = ibooker.book1D("MuonGmtDeltaR", "MuonGmtDeltaR; #DeltaR", 50, 0., 0.5);
  m_ControlHistos[kCtrlNTightVsAll] =
      ibooker.book2D("NTightVsAll", "NTightVsAll; # muons; # tight muons", 20, -0.5, 19.5, 16, -0.5, 15.5);
  m_ControlHistos[kCtrlNProbesVsTight] =
      ibooker.book2D("NProbesVsTight", "NProbesVsTight; # tight muons; # probe muons", 8, -0.5, 7.5, 8, -0.5, 7.5);

  m_ControlHistos[kCtrlTagPt] = ibooker.book1D("TagMuonPt", "TagMuonPt; p_{T}", 50, 0., 100.);
  m_ControlHistos[kCtrlTagPhi] = ibooker.book1D("TagMuonPhi", "TagMuonPhi; #phi", 66, -3.3, 3.3);
  m_ControlHistos[kCtrlTagEta] = ibooker.book1D("TagMuonEta", "TagMuonEta; #eta", 50, -2.5, 2.5);

  m_ControlHistos[kCtrlProbePt] = ibooker.book1D("ProbeMuonPt", "ProbeMuonPt; p_{T}", 50, 0., 100.);
  m_ControlHistos[kCtrlProbePhi] = ibooker.book1D("ProbeMuonPhi", "ProbeMuonPhi; #phi", 66, -3.3, 3.3);
  m_ControlHistos[kCtrlProbeEta] = ibooker.book1D("ProbeMuonEta", "ProbeMuonEta; #eta", 50, -2.5, 2.5);

  m_ControlHistos[kCtrlTagProbeDr] =
      ibooker.book1D("TagMuonProbeMuonDeltaR", "TagMuonProbeMuonDeltaR; #DeltaR", 50, 0., 5.0);
  m_ControlHistos[kCtrlTagHltDr] = ibooker.book1D("TagMuonHltDeltaR", "TagMuonHltDeltaR;#DeltaR", 55, 0., 0.11);
}

bookEfficiencyHistos()

void L1TMuonDQMOffline::bookEfficiencyHistos ( DQMStore::IBooker &  ibooker )

protectedvirtual

Definition at line 364 of file L1TMuonDQMOffline.cc.

References dqm::implementation::IBooker::book1D(), PA_MinBiasSkim_cff::cut, getHistBinsEff(), kEffEta, kEffPt, m_cuts, m_EfficiencyDenEtaHistos, m_EfficiencyDenPtHistos, m_EfficiencyDenVarHistos, m_EfficiencyNumEtaHistos, m_EfficiencyNumVarHistos, m_effLabelStrings, m_effStrings, m_effTypes, m_etaRegions, m_etaStrings, m_HistFolder, m_qualStrings, Skims_PA_cff::name, dqm::implementation::NavigatorBase::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, cond::impl::to_string(), and trigObjTnPSource_cfi::var.

Referenced by bookHistograms().

                                                                     {
  ibooker.setCurrentFolder(m_HistFolder + "/numerators_and_denominators");

  for (const auto var : m_effTypes) {
    auto histBins = getHistBinsEff(var);
    // histograms for eta variable get a special treatment
    if (var == kEffEta) {
      for (const auto& cut : m_cuts) {
        const auto gmtPtCut = cut.first;
        const auto qualLevel = cut.second;
        std::string name = "effDen_" + m_effStrings[var] + "_" + std::to_string(gmtPtCut);
        m_EfficiencyDenEtaHistos[gmtPtCut] =
            ibooker.book1D(name, name + ";" + m_effLabelStrings[var], histBins.size() - 1, &histBins[0]);
        name = "effNum_" + m_effStrings[var] + "_" + std::to_string(gmtPtCut) + "_" + m_qualStrings[qualLevel];
        m_histoKeyEffNumEtaType histoKeyEffNumEta = {gmtPtCut, qualLevel};
        m_EfficiencyNumEtaHistos[histoKeyEffNumEta] =
            ibooker.book1D(name, name + ";" + m_effLabelStrings[var], histBins.size() - 1, &histBins[0]);
      }
    } else {
      for (const auto etaReg : m_etaRegions) {
        // denominator histograms for pt variable get a special treatment
        if (var == kEffPt) {
          std::string name = "effDen_" + m_effStrings[var] + "_" + m_etaStrings[etaReg];
          m_EfficiencyDenPtHistos[etaReg] =
              ibooker.book1D(name, name + ";" + m_effLabelStrings[var], histBins.size() - 1, &histBins[0]);
        } else {
          for (const auto& cut : m_cuts) {
            const int gmtPtCut = cut.first;
            std::string name =
                "effDen_" + m_effStrings[var] + "_" + std::to_string(gmtPtCut) + "_" + m_etaStrings[etaReg];
            m_histoKeyEffDenVarType histoKeyEffDenVar = {var, gmtPtCut, etaReg};
            m_EfficiencyDenVarHistos[histoKeyEffDenVar] =
                ibooker.book1D(name, name + ";" + m_effLabelStrings[var], histBins.size() - 1, &histBins[0]);
          }
        }
        for (const auto& cut : m_cuts) {
          const auto gmtPtCut = cut.first;
          const auto qualLevel = cut.second;
          std::string name = "effNum_" + m_effStrings[var] + "_" + std::to_string(gmtPtCut) + "_" +
                             m_etaStrings[etaReg] + "_" + m_qualStrings[qualLevel];
          m_histoKeyEffNumVarType histoKeyEffNum = {var, gmtPtCut, etaReg, qualLevel};
          m_EfficiencyNumVarHistos[histoKeyEffNum] =
              ibooker.book1D(name, name + ";" + m_effLabelStrings[var], histBins.size() - 1, &histBins[0]);
        }
      }
    }
  }
}

bookHistograms()

void L1TMuonDQMOffline::bookHistograms ( DQMStore::IBooker &  ibooker, const edm::Run &  run, const edm::EventSetup &  iSetup  )

overrideprotectedvirtual

Implements DQMEDAnalyzer.

Definition at line 185 of file L1TMuonDQMOffline.cc.

References bookControlHistos(), bookEfficiencyHistos(), bookResolutionHistos(), gather_cfg::cout, createfilelist::int, m_hltConfig, m_trigIndices, m_trigNames, m_verbose, HLTConfigProvider::size(), and HLTConfigProvider::triggerName().

                                                                                                               {
  //book histos
  bookControlHistos(ibooker);
  bookEfficiencyHistos(ibooker);
  bookResolutionHistos(ibooker);

  vector<string>::const_iterator trigNamesIt = m_trigNames.begin();
  vector<string>::const_iterator trigNamesEnd = m_trigNames.end();

  for (; trigNamesIt != trigNamesEnd; ++trigNamesIt) {
    TString tNameTmp = TString(*trigNamesIt);  // use TString as it handles regex
    TRegexp tNamePattern = TRegexp(tNameTmp, true);
    int tIndex = -1;

    for (unsigned ipath = 0; ipath < m_hltConfig.size(); ++ipath) {
      TString tmpName = TString(m_hltConfig.triggerName(ipath));
      if (tmpName.Contains(tNamePattern)) {
        tIndex = int(ipath);
        m_trigIndices.push_back(tIndex);
      }
    }
    if (tIndex < 0 && m_verbose)
      cout << "[L1TMuonDQMOffline:] Warning: Could not find trigger " << (*trigNamesIt) << endl;
  }
}

bookResolutionHistos()

void L1TMuonDQMOffline::bookResolutionHistos ( DQMStore::IBooker &  ibooker )

protectedvirtual

Definition at line 413 of file L1TMuonDQMOffline.cc.

References dqm::implementation::IBooker::book1D(), gather_cfg::cout, getHistBinsRes(), m_etaRegions, m_etaStrings, m_HistFolder, m_qualLevelsRes, m_qualStrings, m_resLabelStrings, m_ResolutionHistos, m_resStrings, m_resTypes, m_verbose, Skims_PA_cff::name, LaserClient_cfi::nbins, dqm::implementation::NavigatorBase::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, trigObjTnPSource_cfi::var, TrackerOfflineValidation_Dqm_cff::xmax, and TrackerOfflineValidation_Dqm_cff::xmin.

Referenced by bookHistograms().

                                                                     {
  if (m_verbose)
    cout << "[L1TMuonOffline:] Booking Resolution Plot Histos" << endl;
  ibooker.setCurrentFolder(m_HistFolder + "/resolution");

  for (const auto var : m_resTypes) {
    auto nbins = std::get<0>(getHistBinsRes(var));
    auto xmin = std::get<1>(getHistBinsRes(var));
    auto xmax = std::get<2>(getHistBinsRes(var));
    for (const auto etaReg : m_etaRegions) {
      for (const auto qualLevel : m_qualLevelsRes) {
        m_histoKeyResType histoKeyRes = {var, etaReg, qualLevel};
        std::string name =
            "resolution_" + m_resStrings[var] + "_" + m_etaStrings[etaReg] + "_" + m_qualStrings[qualLevel];
        m_ResolutionHistos[histoKeyRes] = ibooker.book1D(name, name + ";" + m_resLabelStrings[var], nbins, xmin, xmax);
      }
    }
  }
}

dqmBeginRun()

void L1TMuonDQMOffline::dqmBeginRun ( const edm::Run &  run, const edm::EventSetup &  iSetup  )

overrideprotectedvirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 177 of file L1TMuonDQMOffline.cc.

References gather_cfg::cout, HLTConfigProvider::init(), m_hltConfig, m_trigProcess, m_verbose, and writedatasetfile::run.

                                                                                  {
  if (m_verbose)
    cout << "[L1TMuonDQMOffline:] Called beginRun." << endl;
  bool changed = true;
  m_hltConfig.init(run, iSetup, m_trigProcess, changed);
}

getHistBinsEff()

std::vector< float > L1TMuonDQMOffline::getHistBinsEff ( EffType  eff )

private

Definition at line 619 of file L1TMuonDQMOffline.cc.

References L1TMuonDQMOffline_cfi::effVsEtaBins, L1TMuonDQMOffline_cfi::effVsPhiBins, L1TMuonDQMOffline_cfi::effVsPtBins, L1TMuonDQMOffline_cfi::effVsVtxBins, kEffEta, kEffPhi, kEffPt, kEffVtx, m_effVsEtaBins, m_effVsPhiBins, m_effVsPtBins, and m_effVsVtxBins.

Referenced by bookEfficiencyHistos().

                                                              {
  if (eff == kEffPt) {
    std::vector<float> effVsPtBins(m_effVsPtBins.begin(), m_effVsPtBins.end());
    return effVsPtBins;
  }
  if (eff == kEffPhi) {
    std::vector<float> effVsPhiBins(m_effVsPhiBins.begin(), m_effVsPhiBins.end());
    return effVsPhiBins;
  }
  if (eff == kEffEta) {
    std::vector<float> effVsEtaBins(m_effVsEtaBins.begin(), m_effVsEtaBins.end());
    return effVsEtaBins;
  }
  if (eff == kEffVtx) {
    std::vector<float> effVsVtxBins(m_effVsVtxBins.begin(), m_effVsVtxBins.end());
    return effVsVtxBins;
  }
  return {0., 1.};
}

getHistBinsRes()

std::tuple< int, double, double > L1TMuonDQMOffline::getHistBinsRes ( ResType  res )

private

Definition at line 639 of file L1TMuonDQMOffline.cc.

References kRes1OverPt, kResCh, kResEta, kResPhi, kResPt, and kResQOverPt.

Referenced by bookResolutionHistos().

                                                                           {
  if (res == kResPt)
    return {50, -2., 2.};
  if (res == kRes1OverPt)
    return {50, -2., 2.};
  if (res == kResQOverPt)
    return {50, -2., 2.};
  if (res == kResPhi)
    return {96, -0.2, 0.2};
  if (res == kResEta)
    return {100, -0.1, 0.1};
  if (res == kResCh)
    return {5, -2, 3};
  return {1, 0, 1};
}

getMuonGmtPairs()

void L1TMuonDQMOffline::getMuonGmtPairs ( edm::Handle< l1t::MuonBxCollection > &  gmtCands, PropagateToMuon const &  propagator  )

private

Definition at line 556 of file L1TMuonDQMOffline.cc.

References BXVector< T >::begin(), gather_cfg::cout, MuonGmtPair::dR(), BXVector< T >::end(), MuonGmtPair::getVar(), kCtrlMuonGmtDeltaR, kCtrlProbeEta, kCtrlProbePhi, kCtrlProbePt, kEffEta, kEffPhi, kEffPt, m_ControlHistos, m_maxGmtMuonDR, m_MuonGmtPairs, m_ProbeMuons, m_useAtVtxCoord, m_verbose, and TrackCandidateProducer_cfi::propagator.

Referenced by analyze().

                                                                           {
  m_MuonGmtPairs.clear();
  if (m_verbose)
    cout << "[L1TMuonDQMOffline:] Getting muon GMT pairs" << endl;

  vector<const reco::Muon*>::const_iterator probeMuIt = m_ProbeMuons.begin();
  vector<const reco::Muon*>::const_iterator probeMuEnd = m_ProbeMuons.end();

  l1t::MuonBxCollection::const_iterator gmtIt;
  l1t::MuonBxCollection::const_iterator gmtEnd = gmtCands->end(0);

  for (; probeMuIt != probeMuEnd; ++probeMuIt) {
    MuonGmtPair pairBestCand((*probeMuIt), nullptr, propagator, m_useAtVtxCoord);

    // Fill the control histograms with the probe muon kinematic variables used
    m_ControlHistos[kCtrlProbeEta]->Fill(pairBestCand.getVar(L1TMuonDQMOffline::kEffEta));
    m_ControlHistos[kCtrlProbePhi]->Fill(pairBestCand.getVar(L1TMuonDQMOffline::kEffPhi));
    m_ControlHistos[kCtrlProbePt]->Fill(pairBestCand.getVar(L1TMuonDQMOffline::kEffPt));

    gmtIt = gmtCands->begin(0);  // use only on L1T muons from BX 0

    for (; gmtIt != gmtEnd; ++gmtIt) {
      MuonGmtPair pairTmpCand((*probeMuIt), &(*gmtIt), propagator, m_useAtVtxCoord);

      if ((pairTmpCand.dR() < m_maxGmtMuonDR) && (pairTmpCand.dR() < pairBestCand.dR())) {
        pairBestCand = pairTmpCand;
      }
    }
    m_MuonGmtPairs.push_back(pairBestCand);
    m_ControlHistos[kCtrlMuonGmtDeltaR]->Fill(pairBestCand.dR());
  }
}

getNVertices()

const unsigned int L1TMuonDQMOffline::getNVertices ( edm::Handle< reco::VertexCollection > &  vertex )

private

Definition at line 434 of file L1TMuonDQMOffline.cc.

References L1TkPrimaryVertex_cfi::nVtx, and bphysicsOniaDQM_cfi::vertex.

Referenced by analyze().

                                                                                   {
  unsigned int nVtx = 0;

  if (vertex.isValid()) {
    for (const auto& vertexIt : *vertex) {
      if (vertexIt.isValid() && !vertexIt.isFake()) {
        ++nVtx;
      }
    }
  }
  return nVtx;
}

getPrimaryVertex()

const reco::Vertex L1TMuonDQMOffline::getPrimaryVertex ( edm::Handle< reco::VertexCollection > &  vertex, edm::Handle< reco::BeamSpot > &  beamSpot  )

private

Definition at line 448 of file L1TMuonDQMOffline.cc.

References pwdgSkimBPark_cfi::beamSpot, BeamMonitor_cff::primaryVertex, and bphysicsOniaDQM_cfi::vertex.

Referenced by analyze().

                                                                                                                 {
  Vertex::Point posVtx;
  Vertex::Error errVtx;

  bool hasPrimaryVertex = false;

  if (vertex.isValid()) {
    vector<Vertex>::const_iterator vertexIt = vertex->begin();
    vector<Vertex>::const_iterator vertexEnd = vertex->end();

    for (; vertexIt != vertexEnd; ++vertexIt) {
      if (vertexIt->isValid() && !vertexIt->isFake()) {
        posVtx = vertexIt->position();
        errVtx = vertexIt->error();
        hasPrimaryVertex = true;
        break;
      }
    }
  }

  if (!hasPrimaryVertex) {
    posVtx = beamSpot->position();
    errVtx(0, 0) = beamSpot->BeamWidthX();
    errVtx(1, 1) = beamSpot->BeamWidthY();
    errVtx(2, 2) = beamSpot->sigmaZ();
  }
  const Vertex primaryVertex(posVtx, errVtx);
  return primaryVertex;
}

getProbeMuons()

void L1TMuonDQMOffline::getProbeMuons ( edm::Handle< edm::TriggerResults > &  trigResults, edm::Handle< trigger::TriggerEvent > &  trigEvent  )

private

Definition at line 495 of file L1TMuonDQMOffline.cc.

References gather_cfg::cout, HLT_2022v12_cff::dEta, HLT_2022v12_cff::distance, HLT_2022v12_cff::dPhi, PVValHelper::eta, kCtrlNProbesVsTight, kCtrlTagEta, kCtrlTagHltDr, kCtrlTagPhi, kCtrlTagProbeDr, kCtrlTagPt, m_ControlHistos, m_minTagProbeDR, m_ProbeMuons, m_TagPtCut, m_TightMuons, m_verbose, matchHlt(), phi, DiDispStaMuonMonitor_cfi::pt, mathSSE::sqrt(), and B2GTnPMonitor_cfi::trigEvent.

Referenced by analyze().

                                                                                 {
  if (m_verbose)
    cout << "[L1TMuonDQMOffline:] getting probe muons" << endl;
  m_ProbeMuons.clear();
  std::vector<const reco::Muon*> tagMuonsInHist;

  tagMuonsInHist.clear();

  vector<const reco::Muon*>::const_iterator probeCandIt = m_TightMuons.begin();
  vector<const reco::Muon*>::const_iterator tightMuonsEnd = m_TightMuons.end();

  for (; probeCandIt != tightMuonsEnd; ++probeCandIt) {
    bool isProbe = false;
    vector<const reco::Muon*>::const_iterator tagCandIt = m_TightMuons.begin();
    float deltar = 0.;

    for (; tagCandIt != tightMuonsEnd; ++tagCandIt) {
      bool tagMuonAlreadyInHist = false;
      bool tagHasTrig = false;
      float eta = (*tagCandIt)->eta();
      float phi = (*tagCandIt)->phi();
      float pt = (*tagCandIt)->pt();
      float dEta = eta - (*probeCandIt)->eta();
      float dPhi = phi - (*probeCandIt)->phi();
      deltar = sqrt(dEta * dEta + dPhi * dPhi);

      if ((*tagCandIt) == (*probeCandIt) || deltar < m_minTagProbeDR)
        continue;  // CB has a little bias for closed-by muons
      auto matchHltDeltaR = matchHlt(trigEvent, (*tagCandIt));
      tagHasTrig = (matchHltDeltaR < m_maxHltMuonDR) && (pt > m_TagPtCut);
      isProbe |= tagHasTrig;
      if (tagHasTrig) {
        if (std::distance(m_TightMuons.begin(), m_TightMuons.end()) > 2) {
          for (vector<const reco::Muon*>::const_iterator tagMuonsInHistIt = tagMuonsInHist.begin();
               tagMuonsInHistIt != tagMuonsInHist.end();
               ++tagMuonsInHistIt) {
            if ((*tagCandIt) == (*tagMuonsInHistIt)) {
              tagMuonAlreadyInHist = true;
              break;
            }
          }
          if (tagMuonAlreadyInHist == false)
            tagMuonsInHist.push_back((*tagCandIt));
        }
        if (tagMuonAlreadyInHist == false) {
          m_ControlHistos[kCtrlTagEta]->Fill(eta);
          m_ControlHistos[kCtrlTagPhi]->Fill(phi);
          m_ControlHistos[kCtrlTagPt]->Fill(pt);
          m_ControlHistos[kCtrlTagProbeDr]->Fill(deltar);
          m_ControlHistos[kCtrlTagHltDr]->Fill(matchHltDeltaR);
        }
      }
    }
    if (isProbe)
      m_ProbeMuons.push_back((*probeCandIt));
  }
  m_ControlHistos[kCtrlNProbesVsTight]->Fill(m_TightMuons.size(), m_ProbeMuons.size());
}

getTightMuons()

void L1TMuonDQMOffline::getTightMuons ( edm::Handle< reco::MuonCollection > &  muons, const reco::Vertex &  vertex  )

private

Definition at line 479 of file L1TMuonDQMOffline.cc.

References gather_cfg::cout, muon::isTightMuon(), kCtrlNTightVsAll, m_ControlHistos, m_TightMuons, m_verbose, PDWG_BPHSkim_cff::muons, and bphysicsOniaDQM_cfi::vertex.

Referenced by analyze().

                                                                                                {
  if (m_verbose)
    cout << "[L1TMuonDQMOffline:] Getting tight muons" << endl;
  m_TightMuons.clear();
  MuonCollection::const_iterator muonIt = muons->begin();
  MuonCollection::const_iterator muonEnd = muons->end();

  for (; muonIt != muonEnd; ++muonIt) {
    if (muon::isTightMuon((*muonIt), vertex)) {
      m_TightMuons.push_back(&(*muonIt));
    }
  }
  m_ControlHistos[kCtrlNTightVsAll]->Fill(muons->size(), m_TightMuons.size());
}

matchHlt()

double L1TMuonDQMOffline::matchHlt ( edm::Handle< trigger::TriggerEvent > &  triggerEvent, const reco::Muon *  mu  )

private

Definition at line 591 of file L1TMuonDQMOffline.cc.

References PbPb_ZMuSkimMuonDPG_cff::deltaR, HLT_2022v12_cff::InputTag, m_hltConfig, m_trigIndices, m_trigProcess, HLTConfigProvider::moduleLabels(), amptDefaultParameters_cff::mu, HLTConfigProvider::size(), PDWG_DiPhoton_SD_cff::triggerEvent, and TriggerAnalyzer::trigObjs.

Referenced by getProbeMuons().

                                                                                            {
  double matchDeltaR = 9999;

  TriggerObjectCollection trigObjs = triggerEvent->getObjects();

  vector<int>::const_iterator trigIndexIt = m_trigIndices.begin();
  vector<int>::const_iterator trigIndexEnd = m_trigIndices.end();

  for (; trigIndexIt != trigIndexEnd; ++trigIndexIt) {
    const vector<string> moduleLabels(m_hltConfig.moduleLabels(*trigIndexIt));
    const unsigned moduleIndex = m_hltConfig.size((*trigIndexIt)) - 2;
    const unsigned hltFilterIndex = triggerEvent->filterIndex(InputTag(moduleLabels[moduleIndex], "", m_trigProcess));

    if (hltFilterIndex < triggerEvent->sizeFilters()) {
      const Keys triggerKeys(triggerEvent->filterKeys(hltFilterIndex));
      const Vids triggerVids(triggerEvent->filterIds(hltFilterIndex));
      const unsigned nTriggers = triggerVids.size();
      for (size_t iTrig = 0; iTrig < nTriggers; ++iTrig) {
        const TriggerObject trigObject = trigObjs[triggerKeys[iTrig]];
        double dRtmp = deltaR((*mu), trigObject);
        if (dRtmp < matchDeltaR)
          matchDeltaR = dRtmp;
      }
    }
  }
  return matchDeltaR;
}

Member Data Documentation

m_BsInputTag

edm::EDGetTokenT<reco::BeamSpot> L1TMuonDQMOffline::m_BsInputTag

private

Definition at line 164 of file L1TMuonDQMOffline.h.

Referenced by analyze().

m_ControlHistos

std::map<Control, MonitorElement*> L1TMuonDQMOffline::m_ControlHistos

private

Definition at line 127 of file L1TMuonDQMOffline.h.

Referenced by bookControlHistos(), getMuonGmtPairs(), getProbeMuons(), and getTightMuons().

m_cuts

std::vector<std::pair<int, QualLevel> > L1TMuonDQMOffline::m_cuts

private

Definition at line 139 of file L1TMuonDQMOffline.h.

Referenced by analyze(), and bookEfficiencyHistos().

m_cutsVPSet

std::vector<edm::ParameterSet> L1TMuonDQMOffline::m_cutsVPSet

private

Definition at line 160 of file L1TMuonDQMOffline.h.

m_EfficiencyDenEtaHistos

std::map<int, MonitorElement*> L1TMuonDQMOffline::m_EfficiencyDenEtaHistos

private

Definition at line 125 of file L1TMuonDQMOffline.h.

Referenced by analyze(), and bookEfficiencyHistos().

m_EfficiencyDenPtHistos

std::map<EtaRegion, MonitorElement*> L1TMuonDQMOffline::m_EfficiencyDenPtHistos

private

Definition at line 124 of file L1TMuonDQMOffline.h.

Referenced by analyze(), and bookEfficiencyHistos().

m_EfficiencyDenVarHistos

std::map<std::tuple<EffType, int, EtaRegion>, MonitorElement*> L1TMuonDQMOffline::m_EfficiencyDenVarHistos

private

Definition at line 123 of file L1TMuonDQMOffline.h.

Referenced by analyze(), and bookEfficiencyHistos().

m_EfficiencyNumEtaHistos

std::map<std::pair<int, QualLevel>, MonitorElement*> L1TMuonDQMOffline::m_EfficiencyNumEtaHistos

private

Definition at line 122 of file L1TMuonDQMOffline.h.

Referenced by analyze(), and bookEfficiencyHistos().

m_EfficiencyNumVarHistos

std::map<std::tuple<EffType, int, EtaRegion, QualLevel>, MonitorElement*> L1TMuonDQMOffline::m_EfficiencyNumVarHistos

private

Definition at line 121 of file L1TMuonDQMOffline.h.

Referenced by analyze(), and bookEfficiencyHistos().

m_effLabelStrings

std::map<EffType, std::string> L1TMuonDQMOffline::m_effLabelStrings

private

Definition at line 149 of file L1TMuonDQMOffline.h.

Referenced by bookEfficiencyHistos().

m_effStrings

std::map<EffType, std::string> L1TMuonDQMOffline::m_effStrings

private

Definition at line 148 of file L1TMuonDQMOffline.h.

Referenced by bookEfficiencyHistos().

m_effTypes

const std::vector<EffType> L1TMuonDQMOffline::m_effTypes

private

Definition at line 142 of file L1TMuonDQMOffline.h.

Referenced by analyze(), and bookEfficiencyHistos().

m_effVsEtaBins

std::vector<double> L1TMuonDQMOffline::m_effVsEtaBins

private

Definition at line 172 of file L1TMuonDQMOffline.h.

Referenced by getHistBinsEff().

m_effVsPhiBins

std::vector<double> L1TMuonDQMOffline::m_effVsPhiBins

private

Definition at line 171 of file L1TMuonDQMOffline.h.

Referenced by getHistBinsEff().

m_effVsPtBins

std::vector<double> L1TMuonDQMOffline::m_effVsPtBins

private

Definition at line 170 of file L1TMuonDQMOffline.h.

Referenced by getHistBinsEff().

m_effVsVtxBins

std::vector<double> L1TMuonDQMOffline::m_effVsVtxBins

private

Definition at line 173 of file L1TMuonDQMOffline.h.

Referenced by getHistBinsEff().

m_etaRegions

const std::vector<EtaRegion> L1TMuonDQMOffline::m_etaRegions

private

Definition at line 144 of file L1TMuonDQMOffline.h.

Referenced by bookEfficiencyHistos(), and bookResolutionHistos().

m_etaStrings

std::map<EtaRegion, std::string> L1TMuonDQMOffline::m_etaStrings

private

Definition at line 152 of file L1TMuonDQMOffline.h.

Referenced by bookEfficiencyHistos(), and bookResolutionHistos().

m_GmtInputTag

edm::EDGetTokenT<l1t::MuonBxCollection> L1TMuonDQMOffline::m_GmtInputTag

private

Definition at line 162 of file L1TMuonDQMOffline.h.

Referenced by analyze().

m_HistFolder

std::string L1TMuonDQMOffline::m_HistFolder

private

Definition at line 157 of file L1TMuonDQMOffline.h.

Referenced by bookControlHistos(), bookEfficiencyHistos(), and bookResolutionHistos().

m_hltConfig

HLTConfigProvider L1TMuonDQMOffline::m_hltConfig

private

Definition at line 105 of file L1TMuonDQMOffline.h.

Referenced by bookHistograms(), dqmBeginRun(), and matchHlt().

m_L1tL1tMuons

BXVector<l1t::Muon> L1TMuonDQMOffline::m_L1tL1tMuons

private

Definition at line 137 of file L1TMuonDQMOffline.h.

m_L1tMuons

std::vector<l1t::MuonBxCollection> L1TMuonDQMOffline::m_L1tMuons

private

Definition at line 135 of file L1TMuonDQMOffline.h.

m_maxGmtMuonDR

float L1TMuonDQMOffline::m_maxGmtMuonDR

private

Definition at line 178 of file L1TMuonDQMOffline.h.

Referenced by getMuonGmtPairs().

m_maxHltMuonDR

float L1TMuonDQMOffline::m_maxHltMuonDR

private

Definition at line 180 of file L1TMuonDQMOffline.h.

m_minTagProbeDR

float L1TMuonDQMOffline::m_minTagProbeDR

private

Definition at line 179 of file L1TMuonDQMOffline.h.

Referenced by getProbeMuons().

m_MuonGmtPairs

std::vector<MuonGmtPair> L1TMuonDQMOffline::m_MuonGmtPairs

private

Definition at line 132 of file L1TMuonDQMOffline.h.

Referenced by analyze(), and getMuonGmtPairs().

m_MuonInputTag

edm::EDGetTokenT<reco::MuonCollection> L1TMuonDQMOffline::m_MuonInputTag

private

Definition at line 161 of file L1TMuonDQMOffline.h.

Referenced by analyze().

m_ProbeMuons

std::vector<const reco::Muon*> L1TMuonDQMOffline::m_ProbeMuons

private

Definition at line 131 of file L1TMuonDQMOffline.h.

Referenced by getMuonGmtPairs(), and getProbeMuons().

m_propagatorSetup

PropagateToMuonSetup const L1TMuonDQMOffline::m_propagatorSetup

private

Definition at line 107 of file L1TMuonDQMOffline.h.

Referenced by analyze().

m_qualLevelsRes

const std::vector<QualLevel> L1TMuonDQMOffline::m_qualLevelsRes

private

Definition at line 145 of file L1TMuonDQMOffline.h.

Referenced by analyze(), and bookResolutionHistos().

m_qualStrings

std::map<QualLevel, std::string> L1TMuonDQMOffline::m_qualStrings

private

Definition at line 153 of file L1TMuonDQMOffline.h.

Referenced by bookEfficiencyHistos(), and bookResolutionHistos().

m_RecoMuons

std::vector<reco::MuonCollection> L1TMuonDQMOffline::m_RecoMuons

private

Definition at line 134 of file L1TMuonDQMOffline.h.

m_RecoRecoMuons

std::vector<reco::Muon> L1TMuonDQMOffline::m_RecoRecoMuons

private

Definition at line 136 of file L1TMuonDQMOffline.h.

m_recoToL1PtCutFactor

double L1TMuonDQMOffline::m_recoToL1PtCutFactor

private

Definition at line 159 of file L1TMuonDQMOffline.h.

Referenced by analyze().

m_resLabelStrings

std::map<ResType, std::string> L1TMuonDQMOffline::m_resLabelStrings

private

Definition at line 151 of file L1TMuonDQMOffline.h.

Referenced by bookResolutionHistos().

m_ResolutionHistos

std::map<std::tuple<ResType, EtaRegion, QualLevel>, MonitorElement*> L1TMuonDQMOffline::m_ResolutionHistos

private

Definition at line 126 of file L1TMuonDQMOffline.h.

Referenced by analyze(), and bookResolutionHistos().

m_resStrings

std::map<ResType, std::string> L1TMuonDQMOffline::m_resStrings

private

Definition at line 150 of file L1TMuonDQMOffline.h.

Referenced by bookResolutionHistos().

m_resTypes

const std::vector<ResType> L1TMuonDQMOffline::m_resTypes

private

Definition at line 143 of file L1TMuonDQMOffline.h.

Referenced by analyze(), and bookResolutionHistos().

m_TagPtCut

double L1TMuonDQMOffline::m_TagPtCut

private

Definition at line 158 of file L1TMuonDQMOffline.h.

Referenced by getProbeMuons().

m_TightMuons

std::vector<const reco::Muon*> L1TMuonDQMOffline::m_TightMuons

private

Definition at line 130 of file L1TMuonDQMOffline.h.

Referenced by getProbeMuons(), and getTightMuons().

m_trigIndices

std::vector<int> L1TMuonDQMOffline::m_trigIndices

private

Definition at line 175 of file L1TMuonDQMOffline.h.

Referenced by bookHistograms(), and matchHlt().

m_trigInputTag

edm::EDGetTokenT<trigger::TriggerEvent> L1TMuonDQMOffline::m_trigInputTag

private

Definition at line 165 of file L1TMuonDQMOffline.h.

Referenced by analyze().

m_trigNames

std::vector<std::string> L1TMuonDQMOffline::m_trigNames

private

Definition at line 169 of file L1TMuonDQMOffline.h.

Referenced by bookHistograms().

m_trigProcess

std::string L1TMuonDQMOffline::m_trigProcess

private

Definition at line 166 of file L1TMuonDQMOffline.h.

Referenced by dqmBeginRun(), and matchHlt().

m_trigProcess_token

edm::EDGetTokenT<edm::TriggerResults> L1TMuonDQMOffline::m_trigProcess_token

private

Definition at line 167 of file L1TMuonDQMOffline.h.

Referenced by analyze().

m_useAtVtxCoord

bool L1TMuonDQMOffline::m_useAtVtxCoord

private

Definition at line 177 of file L1TMuonDQMOffline.h.

Referenced by getMuonGmtPairs().

m_verbose

bool L1TMuonDQMOffline::m_verbose

private

Definition at line 156 of file L1TMuonDQMOffline.h.

Referenced by analyze(), bookControlHistos(), bookHistograms(), bookResolutionHistos(), dqmBeginRun(), getMuonGmtPairs(), getProbeMuons(), and getTightMuons().

m_VtxInputTag

edm::EDGetTokenT<reco::VertexCollection> L1TMuonDQMOffline::m_VtxInputTag

private

Definition at line 163 of file L1TMuonDQMOffline.h.

Referenced by analyze().