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 Member Functions
	L1TMuonDQMOffline (const edm::ParameterSet &ps)
	~L1TMuonDQMOffline () override
Public Member Functions inherited from one::DQMEDAnalyzer< T >
	DQMEDAnalyzer ()=default
	DQMEDAnalyzer (DQMEDAnalyzer< T... > const &)=delete
	DQMEDAnalyzer (DQMEDAnalyzer< T... > &&)=delete
	~DQMEDAnalyzer () override=default

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

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)
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
PropagateToMuon	m_propagator
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

Detailed Description

Definition at line 63 of file L1TMuonDQMOffline.h.

Member Typedef Documentation

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

private

Definition at line 104 of file L1TMuonDQMOffline.h.

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

private

Definition at line 103 of file L1TMuonDQMOffline.h.

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

private

Definition at line 102 of file L1TMuonDQMOffline.h.

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

private

Definition at line 101 of file L1TMuonDQMOffline.h.

Member Enumeration Documentation

enum L1TMuonDQMOffline::Control

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

Definition at line 65 of file L1TMuonDQMOffline.h.

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

enum L1TMuonDQMOffline::EffType

Enumerator
kEffPt
kEffPhi
kEffEta
kEffVtx

Definition at line 66 of file L1TMuonDQMOffline.h.

{kEffPt, kEffPhi, kEffEta, kEffVtx};

enum L1TMuonDQMOffline::EtaRegion

Enumerator
kEtaRegionAll
kEtaRegionBmtf
kEtaRegionOmtf
kEtaRegionEmtf
kEtaRegionOut

Definition at line 68 of file L1TMuonDQMOffline.h.

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

enum L1TMuonDQMOffline::QualLevel

Enumerator
kQualAll
kQualOpen
kQualDouble
kQualSingle

Definition at line 69 of file L1TMuonDQMOffline.h.

{kQualAll, kQualOpen, kQualDouble, kQualSingle};

enum L1TMuonDQMOffline::ResType

Enumerator
kResPt
kRes1OverPt
kResQOverPt
kResPhi
kResEta
kResCh

Definition at line 67 of file L1TMuonDQMOffline.h.

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

Constructor & Destructor Documentation

L1TMuonDQMOffline::L1TMuonDQMOffline

(

const edm::ParameterSet &

ps

)

Definition at line 92 of file L1TMuonDQMOffline.cc.

References gather_cfg::cout, kEffEta, kEffPhi, kEffPt, kEffVtx, kEtaRegionAll, kEtaRegionBmtf, kEtaRegionEmtf, kEtaRegionOmtf, kQualAll, kQualDouble, kQualOpen, kQualSingle, kRes1OverPt, kResCh, kResEta, kResPhi, kResPt, kResQOverPt, m_BsInputTag, m_cuts, m_cutsVPSet, m_effLabelStrings, m_effStrings, m_effVsEtaBins, m_effVsPhiBins, m_effVsPtBins, m_effVsVtxBins, m_etaRegions, m_etaStrings, m_GmtInputTag, m_HistFolder, m_maxGmtMuonDR, m_maxHltMuonDR, m_minTagProbeDR, m_MuonInputTag, m_qualLevelsRes, m_qualStrings, m_recoToL1PtCutFactor, m_resLabelStrings, m_resStrings, m_resTypes, m_TagPtCut, m_trigInputTag, m_trigNames, m_trigProcess, m_trigProcess_token, m_useAtVtxCoord, m_verbose, and m_VtxInputTag.

                                                            :
    m_propagator(ps.getParameter<edm::ParameterSet>("muProp")),
    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 ( )

override

Definition at line 143 of file L1TMuonDQMOffline.cc.

{ }

Member Function Documentation

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

overrideprotected

Definition at line 179 of file L1TMuonDQMOffline.cc.

References ecalDrivenElectronSeedsParameters_cff::beamSpot, gather_cfg::cout, TkAlMuonSelectors_cfi::cut, edm::Event::getByToken(), getMuonGmtPairs(), getNVertices(), getPrimaryVertex(), getProbeMuons(), getTightMuons(), 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_qualLevelsRes, m_recoToL1PtCutFactor, m_ResolutionHistos, m_resTypes, m_trigInputTag, m_trigProcess_token, m_verbose, m_VtxInputTag, extraflags_cff::muons, impactParameterTagInfos_cfi::primaryVertex, and JetChargeProducer_cfi::var.

                                                                                  {

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

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

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

protectedvirtual

Definition at line 301 of file L1TMuonDQMOffline.cc.

References DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), gather_cfg::cout, kCtrlMuonGmtDeltaR, kCtrlNProbesVsTight, kCtrlNTightVsAll, kCtrlProbeEta, kCtrlProbePhi, kCtrlProbePt, kCtrlTagEta, kCtrlTagHltDr, kCtrlTagPhi, kCtrlTagProbeDr, kCtrlTagPt, m_ControlHistos, m_HistFolder, m_verbose, and DQMStore::IBooker::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);
}

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

protectedvirtual

Definition at line 323 of file L1TMuonDQMOffline.cc.

References DQMStore::IBooker::book1D(), TkAlMuonSelectors_cfi::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, dataset::name, DQMStore::IBooker::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, and JetChargeProducer_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]);
                }
            }
        }
    }
}

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

overrideprotected

Definition at line 153 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;
    }
}

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

protectedvirtual

Definition at line 365 of file L1TMuonDQMOffline.cc.

References DQMStore::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, dataset::name, pileupCalc::nbins, DQMStore::IBooker::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, JetChargeProducer_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);
            }
        }
    }
}

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

overrideprotected

Definition at line 145 of file L1TMuonDQMOffline.cc.

References gather_cfg::cout, PropagateToMuon::init(), HLTConfigProvider::init(), m_hltConfig, m_propagator, m_trigProcess, and m_verbose.

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

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

private

Definition at line 565 of file L1TMuonDQMOffline.cc.

References 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.};
}

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

private

Definition at line 585 of file L1TMuonDQMOffline.cc.

References DEFINE_FWK_MODULE, 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};
}

void L1TMuonDQMOffline::getMuonGmtPairs ( edm::Handle< l1t::MuonBxCollection > &  gmtCands )

private

Definition at line 502 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_propagator, m_useAtVtxCoord, and m_verbose.

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, m_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), m_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());
    }
}

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

private

Definition at line 384 of file L1TMuonDQMOffline.cc.

References edm::HandleBase::isValid().

Referenced by analyze().

                                                                                    {
    unsigned int nVtx = 0;

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

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

private

Definition at line 398 of file L1TMuonDQMOffline.cc.

References reco::BeamSpot::BeamWidthX(), reco::BeamSpot::BeamWidthY(), edm::HandleBase::isValid(), reco::BeamSpot::position(), impactParameterTagInfos_cfi::primaryVertex, and reco::BeamSpot::sigmaZ().

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

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

private

Definition at line 446 of file L1TMuonDQMOffline.cc.

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

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

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

private

Definition at line 430 of file L1TMuonDQMOffline.cc.

References gather_cfg::cout, muon::isTightMuon(), kCtrlNTightVsAll, m_ControlHistos, m_TightMuons, and m_verbose.

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

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

private

Definition at line 537 of file L1TMuonDQMOffline.cc.

References deltaR(), trigger::TriggerEvent::filterIds(), trigger::TriggerEvent::filterIndex(), trigger::TriggerEvent::filterKeys(), trigger::TriggerEvent::getObjects(), m_hltConfig, m_trigIndices, m_trigProcess, HLTConfigProvider::moduleLabels(), HLTConfigProvider::size(), 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

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

private

Definition at line 150 of file L1TMuonDQMOffline.h.

Referenced by analyze(), and L1TMuonDQMOffline().

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

private

Definition at line 113 of file L1TMuonDQMOffline.h.

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

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

private

Definition at line 125 of file L1TMuonDQMOffline.h.

Referenced by analyze(), bookEfficiencyHistos(), and L1TMuonDQMOffline().

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

private

Definition at line 146 of file L1TMuonDQMOffline.h.

Referenced by L1TMuonDQMOffline().

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

private

Definition at line 111 of file L1TMuonDQMOffline.h.

Referenced by analyze(), and bookEfficiencyHistos().

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

private

Definition at line 110 of file L1TMuonDQMOffline.h.

Referenced by analyze(), and bookEfficiencyHistos().

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

private

Definition at line 109 of file L1TMuonDQMOffline.h.

Referenced by analyze(), and bookEfficiencyHistos().

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

private

Definition at line 108 of file L1TMuonDQMOffline.h.

Referenced by analyze(), and bookEfficiencyHistos().

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

private

Definition at line 107 of file L1TMuonDQMOffline.h.

Referenced by analyze(), and bookEfficiencyHistos().

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

private

Definition at line 135 of file L1TMuonDQMOffline.h.

Referenced by bookEfficiencyHistos(), and L1TMuonDQMOffline().

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

private

Definition at line 134 of file L1TMuonDQMOffline.h.

Referenced by bookEfficiencyHistos(), and L1TMuonDQMOffline().

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

private

Definition at line 128 of file L1TMuonDQMOffline.h.

Referenced by analyze(), and bookEfficiencyHistos().

std::vector<double> L1TMuonDQMOffline::m_effVsEtaBins

private

Definition at line 158 of file L1TMuonDQMOffline.h.

Referenced by getHistBinsEff(), and L1TMuonDQMOffline().

std::vector<double> L1TMuonDQMOffline::m_effVsPhiBins

private

Definition at line 157 of file L1TMuonDQMOffline.h.

Referenced by getHistBinsEff(), and L1TMuonDQMOffline().

std::vector<double> L1TMuonDQMOffline::m_effVsPtBins

private

Definition at line 156 of file L1TMuonDQMOffline.h.

Referenced by getHistBinsEff(), and L1TMuonDQMOffline().

std::vector<double> L1TMuonDQMOffline::m_effVsVtxBins

private

Definition at line 159 of file L1TMuonDQMOffline.h.

Referenced by getHistBinsEff(), and L1TMuonDQMOffline().

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

private

Definition at line 130 of file L1TMuonDQMOffline.h.

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

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

private

Definition at line 138 of file L1TMuonDQMOffline.h.

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

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

private

Definition at line 148 of file L1TMuonDQMOffline.h.

Referenced by analyze(), and L1TMuonDQMOffline().

std::string L1TMuonDQMOffline::m_HistFolder

private

Definition at line 143 of file L1TMuonDQMOffline.h.

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

HLTConfigProvider L1TMuonDQMOffline::m_hltConfig

private

Definition at line 93 of file L1TMuonDQMOffline.h.

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

BXVector<l1t::Muon> L1TMuonDQMOffline::m_L1tL1tMuons

private

Definition at line 123 of file L1TMuonDQMOffline.h.

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

private

Definition at line 121 of file L1TMuonDQMOffline.h.

float L1TMuonDQMOffline::m_maxGmtMuonDR

private

Definition at line 164 of file L1TMuonDQMOffline.h.

Referenced by getMuonGmtPairs(), and L1TMuonDQMOffline().

float L1TMuonDQMOffline::m_maxHltMuonDR

private

Definition at line 166 of file L1TMuonDQMOffline.h.

Referenced by L1TMuonDQMOffline().

float L1TMuonDQMOffline::m_minTagProbeDR

private

Definition at line 165 of file L1TMuonDQMOffline.h.

Referenced by getProbeMuons(), and L1TMuonDQMOffline().

std::vector<MuonGmtPair> L1TMuonDQMOffline::m_MuonGmtPairs

private

Definition at line 118 of file L1TMuonDQMOffline.h.

Referenced by analyze(), and getMuonGmtPairs().

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

private

Definition at line 147 of file L1TMuonDQMOffline.h.

Referenced by analyze(), and L1TMuonDQMOffline().

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

private

Definition at line 117 of file L1TMuonDQMOffline.h.

Referenced by getMuonGmtPairs(), and getProbeMuons().

PropagateToMuon L1TMuonDQMOffline::m_propagator

private

Definition at line 95 of file L1TMuonDQMOffline.h.

Referenced by dqmBeginRun(), and getMuonGmtPairs().

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

private

Definition at line 131 of file L1TMuonDQMOffline.h.

Referenced by analyze(), bookResolutionHistos(), and L1TMuonDQMOffline().

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

private

Definition at line 139 of file L1TMuonDQMOffline.h.

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

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

private

Definition at line 120 of file L1TMuonDQMOffline.h.

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

private

Definition at line 122 of file L1TMuonDQMOffline.h.

double L1TMuonDQMOffline::m_recoToL1PtCutFactor

private

Definition at line 145 of file L1TMuonDQMOffline.h.

Referenced by analyze(), and L1TMuonDQMOffline().

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

private

Definition at line 137 of file L1TMuonDQMOffline.h.

Referenced by bookResolutionHistos(), and L1TMuonDQMOffline().

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

private

Definition at line 112 of file L1TMuonDQMOffline.h.

Referenced by analyze(), and bookResolutionHistos().

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

private

Definition at line 136 of file L1TMuonDQMOffline.h.

Referenced by bookResolutionHistos(), and L1TMuonDQMOffline().

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

private

Definition at line 129 of file L1TMuonDQMOffline.h.

Referenced by analyze(), bookResolutionHistos(), and L1TMuonDQMOffline().

double L1TMuonDQMOffline::m_TagPtCut

private

Definition at line 144 of file L1TMuonDQMOffline.h.

Referenced by getProbeMuons(), and L1TMuonDQMOffline().

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

private

Definition at line 116 of file L1TMuonDQMOffline.h.

Referenced by getProbeMuons(), and getTightMuons().

std::vector<int> L1TMuonDQMOffline::m_trigIndices

private

Definition at line 161 of file L1TMuonDQMOffline.h.

Referenced by bookHistograms(), and matchHlt().

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

private

Definition at line 151 of file L1TMuonDQMOffline.h.

Referenced by analyze(), and L1TMuonDQMOffline().

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

private

Definition at line 155 of file L1TMuonDQMOffline.h.

Referenced by bookHistograms(), and L1TMuonDQMOffline().

std::string L1TMuonDQMOffline::m_trigProcess

private

Definition at line 152 of file L1TMuonDQMOffline.h.

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

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

private

Definition at line 153 of file L1TMuonDQMOffline.h.

Referenced by analyze(), and L1TMuonDQMOffline().

bool L1TMuonDQMOffline::m_useAtVtxCoord

private

Definition at line 163 of file L1TMuonDQMOffline.h.

Referenced by getMuonGmtPairs(), and L1TMuonDQMOffline().

bool L1TMuonDQMOffline::m_verbose

private

Definition at line 142 of file L1TMuonDQMOffline.h.

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

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

private

Definition at line 149 of file L1TMuonDQMOffline.h.

Referenced by analyze(), and L1TMuonDQMOffline().