From 5bd545f8c9e7dbc05bbf0c8e7d2b004bb15f6f6d Mon Sep 17 00:00:00 2001 From: Xinmei Date: Thu, 11 May 2017 18:16:14 +0200 Subject: [PATCH] get rid of the intermediate TTree --- DQMOffline/LumiZCounting/BuildFile.xml | 10 + DQMOffline/LumiZCounting/data/HLTFile_phys14 | 98 ++++ DQMOffline/LumiZCounting/data/HLT_50nsGRun | 58 +++ .../LumiZCounting/data/HLT_50nsGRun_80X | 55 ++ .../LumiZCounting/interface/MiniBaconDefs.h | 11 + .../LumiZCounting/interface/RunLumiRangeMap.h | 26 + DQMOffline/LumiZCounting/interface/TTrigger.h | 26 + .../LumiZCounting/interface/TriggerRecord.h | 31 ++ .../LumiZCounting/interface/TriggerTools.h | 20 + .../LumiZCounting/plugins/BuildFile.xml | 12 + DQMOffline/LumiZCounting/plugins/ZCounting.cc | 472 ++++++++++++++++++ DQMOffline/LumiZCounting/plugins/ZCounting.h | 137 +++++ .../LumiZCounting/python/ZCounting_cfg.py | 117 +++++ .../LumiZCounting/src/RunLumiRangeMap.cc | 50 ++ DQMOffline/LumiZCounting/src/TTrigger.cc | 145 ++++++ DQMOffline/LumiZCounting/src/TriggerTools.cc | 39 ++ 16 files changed, 1307 insertions(+) create mode 100644 DQMOffline/LumiZCounting/BuildFile.xml create mode 100644 DQMOffline/LumiZCounting/data/HLTFile_phys14 create mode 100644 DQMOffline/LumiZCounting/data/HLT_50nsGRun create mode 100644 DQMOffline/LumiZCounting/data/HLT_50nsGRun_80X create mode 100644 DQMOffline/LumiZCounting/interface/MiniBaconDefs.h create mode 100644 DQMOffline/LumiZCounting/interface/RunLumiRangeMap.h create mode 100644 DQMOffline/LumiZCounting/interface/TTrigger.h create mode 100644 DQMOffline/LumiZCounting/interface/TriggerRecord.h create mode 100644 DQMOffline/LumiZCounting/interface/TriggerTools.h create mode 100644 DQMOffline/LumiZCounting/plugins/BuildFile.xml create mode 100644 DQMOffline/LumiZCounting/plugins/ZCounting.cc create mode 100644 DQMOffline/LumiZCounting/plugins/ZCounting.h create mode 100644 DQMOffline/LumiZCounting/python/ZCounting_cfg.py create mode 100644 DQMOffline/LumiZCounting/src/RunLumiRangeMap.cc create mode 100644 DQMOffline/LumiZCounting/src/TTrigger.cc create mode 100644 DQMOffline/LumiZCounting/src/TriggerTools.cc diff --git a/DQMOffline/LumiZCounting/BuildFile.xml b/DQMOffline/LumiZCounting/BuildFile.xml new file mode 100644 index 0000000000000..4f9ebbf5ff0c5 --- /dev/null +++ b/DQMOffline/LumiZCounting/BuildFile.xml @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/DQMOffline/LumiZCounting/data/HLTFile_phys14 b/DQMOffline/LumiZCounting/data/HLTFile_phys14 new file mode 100644 index 0000000000000..5c906697b91ab --- /dev/null +++ b/DQMOffline/LumiZCounting/data/HLTFile_phys14 @@ -0,0 +1,98 @@ +// SingleMu +HLT_Mu40_v* hltL3fL1sMu16L1f0L2f16QL3Filtered40Q 1 +HLT_IsoMu20_eta2p1_IterTrk02_v* hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f20QL3crIsoRhoFiltered0p15IterTrk02 1 +HLT_IsoTkMu20_eta2p1_IterTrk02_v* hltL3fL1sMu16L1Eta2p1f0TkFiltered20QL3crIsoRhoFiltered0p15IterTrk02 1 +HLT_IsoMu24_eta2p1_IterTrk02_v* hltL3crIsoL1sMu20Eta2p1L1f0L2f20QL3f24QL3crIsoRhoFiltered0p15IterTrk02 1 +HLT_IsoTkMu24_eta2p1_IterTrk02_v* hltL3fL1sMu20L1Eta2p1f0TkFiltered24QL3crIsoRhoFiltered0p15IterTrk02 1 +HLT_IsoMu24_IterTrk02_v* hltL3crIsoL1sMu16L1f0L2f16QL3f24QL3crIsoRhoFiltered0p15IterTrk02 1 +HLT_IsoTkMu24_IterTrk02_v* hltL3fL1sMu16L1f0TkFiltered24QL3crIsoRhoFiltered0p15IterTrk02 1 +// DoubleMu +HLT_Mu17_Mu8_v* hltL3fL1sDoubleMu103p5L1f0L2f10OneMuL3Filtered17 1 +HLT_Mu17_Mu8_v* hltL3pfL1sDoubleMu103p5L1f0L2pf0L3PreFiltered8 2 +HLT_Mu17_TkMu8_v* hltL3fL1sDoubleMu103p5L1f0L2f10L3Filtered17 1 +HLT_Mu17_TkMu8_v* hltDiMuonGlbFiltered17TrkFiltered8 2 +HLT_Mu30_TkMu11_v* hltL3fL1sMu16L1f0L2f25L3Filtered30 1 +HLT_Mu30_TkMu11_v* hltDiMuonGlbFiltered30TrkFiltered11 2 +HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_v* hltL3fL1sDoubleMu103p5L1f0L2f10OneMuL3Filtered17 1 +HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_v* hltL3pfL1sDoubleMu103p5L1f0L2pf0L3PreFiltered8 2 +HLT_Mu17_TrkIsoVVL_TkMu8_TrkIsoVVL_v* hltL3fL1sDoubleMu103p5L1f0L2f10L3Filtered17 1 +HLT_Mu17_TrkIsoVVL_TkMu8_TrkIsoVVL_v* hltDiMuonGlbFiltered17TrkFiltered8 2 +// SingleElectron +HLT_Ele27_eta2p1_WP85_Gsf_v* hltEle27WP85GsfTrackIsoFilter 1 +HLT_Ele32_eta2p1_WP85_Gsf_v* hltEle32WP85GsfTrackIsoFilter 1 +HLT_Ele95_CaloIdVT_GsfTrkIdT_v* hltEle95CaloIdVTGsfTrkIdTGsfDphiFilter 1 // not saved? +// Jet +HLT_PFJet260_v* hltSinglePFJet260 1 +HLT_AK8PFJet360TrimMod_Mass30_v* hltAK8SinglePFJet360TrimModMass30 1 +// Tau +HLT_IsoMu17_eta2p1_LooseIsoPFTau20_v* hltL3crIsoL1sMu16erTauJet20erL1f0L2f16QL3f17QL3crIsoRhoFiltered0p15IterTrk02 1 +HLT_IsoMu17_eta2p1_LooseIsoPFTau20_v* hltOverlapFilterIsoMu17LooseIsoPFTau20 2 +HLT_Ele22_eta2p1_WP85_Gsf_LooseIsoPFTau20_v* hltEle22WP85GsfTrackIsoFilter 1 +HLT_Ele22_eta2p1_WP85_Gsf_LooseIsoPFTau20_v* hltOverlapFilterIsoEle22WP85GsfLooseIsoPFTau20 2 +HLT_DoubleMediumIsoPFTau40_Trk1_eta2p1_Reg_v* hltDoublePFTau40TrackPt1MediumIsolationL1HLTMatchedReg 1 +HLT_LooseIsoPFTau50_Trk30_eta2p1_MET120_v* hltPFTau50TrackPt30LooseAbsOrRelIso 1 +// Lepton+Jets +HLT_IsoMu20_eta2p1_IterTrk02_TriCentralPFJet60_50_35_v* hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f20QL3crIsoRhoFiltered0p15IterTrk02 1 +HLT_IsoMu20_eta2p1_IterTrk02_TriCentralPFJet60_50_35_v* hltIsoMu20Eta2p1Trk02CentralPFJet60MuCleaned 2 +HLT_IsoMu20_eta2p1_IterTrk02_TriCentralPFJet60_50_35_v* hltIsoMu20Eta2p1Trk02DiCentralPFJet50MuCleaned 3 +HLT_IsoMu20_eta2p1_IterTrk02_TriCentralPFJet60_50_35_v* hltIsoMu20Eta2p1Trk02TriCentralPFJet35MuCleaned 4 +HLT_IsoMu20_eta2p1_IterTrk02_TriCentralPFJet40_v* hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f20QL3crIsoRhoFiltered0p15IterTrk02 1 +HLT_IsoMu20_eta2p1_IterTrk02_TriCentralPFJet40_v* hltIsoMu20Eta2p1Trk02TriCentralPFJet40MuCleaned 2 +HLT_IsoMu20_eta2p1_IterTrk02_CentralPFJet30_BTagCSV_v* hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f20QL3crIsoRhoFiltered0p15IterTrk02 1 +HLT_IsoMu20_eta2p1_IterTrk02_CentralPFJet30_BTagCSV_v* hltCSVFilterSingleTopIsoMu20Eta2p1 2 +HLT_IsoMu24_eta2p1_IterTrk02_TriCentralPFJet60_50_35_v* hltL3crIsoL1sMu20Eta2p1L1f0L2f20QL3f24QL3crIsoRhoFiltered0p15IterTrk02 1 +HLT_IsoMu24_eta2p1_IterTrk02_TriCentralPFJet60_50_35_v* hltIsoMu24Eta2p1Trk02CentralPFJet60MuCleaned 2 +HLT_IsoMu24_eta2p1_IterTrk02_TriCentralPFJet60_50_35_v* hltIsoMu24Eta2p1Trk02DiCentralPFJet50MuCleaned 3 +HLT_IsoMu24_eta2p1_IterTrk02_TriCentralPFJet60_50_35_v* hltIsoMu24Eta2p1Trk02TriCentralPFJet35MuCleaned 4 +HLT_IsoMu24_eta2p1_IterTrk02_TriCentralPFJet40_v* hltL3crIsoL1sMu20Eta2p1L1f0L2f20QL3f24QL3crIsoRhoFiltered0p15IterTrk02 1 +HLT_IsoMu24_eta2p1_IterTrk02_TriCentralPFJet40_v* hltIsoMu24Eta2p1Trk02TriCentralPFJet40MuCleaned 2 +HLT_IsoMu24_eta2p1_IterTrk02_CentralPFJet30_BTagCSV_v* hltL3crIsoL1sMu20Eta2p1L1f0L2f20QL3f24QL3crIsoRhoFiltered0p15IterTrk02 1 +HLT_IsoMu24_eta2p1_IterTrk02_CentralPFJet30_BTagCSV_v* hltCSVFilterSingleTopIsoMu24Eta2p1 2 +HLT_Ele27_eta2p1_WP85_Gsf_TriCentralPFJet40_v* hltEle27WP85GsfTrackIsoFilter 1 +HLT_Ele27_eta2p1_WP85_Gsf_TriCentralPFJet40_v* hltEle27TriCentralPFJet40EleCleaned 2 +HLT_Ele27_eta2p1_WP85_Gsf_TriCentralPFJet60_50_35_v* hltEle27WP85GsfTrackIsoFilter 1 +HLT_Ele27_eta2p1_WP85_Gsf_TriCentralPFJet60_50_35_v* hltEle27CentralPFJet60EleCleaned 2 +HLT_Ele27_eta2p1_WP85_Gsf_TriCentralPFJet60_50_35_v* hltEle27DiCentralPFJet50EleCleaned 3 +HLT_Ele27_eta2p1_WP85_Gsf_TriCentralPFJet60_50_35_v* hltEle27TriCentralPFJet35EleCleaned 4 +HLT_Ele27_eta2p1_WP85_Gsf_CentralPFJet30_BTagCSV_v* hltEle27WP85GsfTrackIsoFilter 1 +HLT_Ele27_eta2p1_WP85_Gsf_CentralPFJet30_BTagCSV_v* hltCSVFilterSingleTopEle27 2 +HLT_Ele32_eta2p1_WP85_Gsf_TriCentralPFJet40_v* hltEle32WP85GsfTrackIsoFilter 1 +HLT_Ele32_eta2p1_WP85_Gsf_TriCentralPFJet40_v* hltEle32TriCentralPFJet40EleCleaned 2 +HLT_Ele32_eta2p1_WP85_Gsf_TriCentralPFJet60_50_35_v* hltEle32WP85GsfTrackIsoFilter 1 +HLT_Ele32_eta2p1_WP85_Gsf_TriCentralPFJet60_50_35_v* hltEle32CentralPFJet60EleCleaned 2 +HLT_Ele32_eta2p1_WP85_Gsf_TriCentralPFJet60_50_35_v* hltEle32DiCentralPFJet50EleCleaned 3 +HLT_Ele32_eta2p1_WP85_Gsf_TriCentralPFJet60_50_35_v* hltEle32TriCentralPFJet35EleCleaned 4 +HLT_Ele32_eta2p1_WP85_Gsf_CentralPFJet30_BTagCSV_v* hltEle32WP85GsfTrackIsoFilter 1 +HLT_Ele32_eta2p1_WP85_Gsf_CentralPFJet30_BTagCSV_v* hltCSVFilterSingleTopEle32 2 +HLT_Mu40_eta2p1_PFJet200_PFJet50_v* hltL3fL1sMu16Eta2p1L1f0L2f16QL3Filtered40Q 1 +HLT_Mu40_eta2p1_PFJet200_PFJet50_v* hltMu40eta2p1CentralPFJet200MuCleaned 2 +HLT_Mu40_eta2p1_PFJet200_PFJet50_v* hltMu40eta2p1DiCentralPFJet50MuCleaned 3 +HLT_Ele45_CaloIdVT_GsfTrkIdT_PFJet200_PFJet50_v* hltEle45CaloIdVTGsfTrkIdTGsfDphiFilter 1 // not saved? +HLT_Ele45_CaloIdVT_GsfTrkIdT_PFJet200_PFJet50_v* hltEle45CaloIdVTGsfTrkIdTCentralPFJet200EleCleaned 2 +HLT_Ele45_CaloIdVT_GsfTrkIdT_PFJet200_PFJet50_v* hltEle45CaloIdVTGsfTrkIdTDiCentralPFJet50EleCleaned 3 +// DoubleElectron +HLT_Ele23_Ele12_CaloId_TrackId_Iso_v* hltEle23Ele12CaloIdTrackIdIsoTrackIsoLeg1Filter 1 +HLT_Ele23_Ele12_CaloId_TrackId_Iso_v* hltEle23Ele12CaloIdTrackIdIsoTrackIsoLeg2Filter 2 +HLT_Ele17_Ele12_Ele10_CaloId_TrackId_v* hltEle17Ele12Ele10CaloIdTrackIdDphiLeg1Filter 1 +HLT_Ele17_Ele12_Ele10_CaloId_TrackId_v* hltEle17Ele12Ele10CaloIdTrackIdDphiLeg2Filter 2 +HLT_Ele17_Ele12_Ele10_CaloId_TrackId_v* hltEle17Ele12Ele10CaloIdTrackIdDphiLeg3Filter 3 +HLT_DoubleEle33_CaloIdL_GsfTrkIdVL_v* hltDiEle33CaloIdLGsfTrkIdVLDPhiUnseededFilter 1 +HLT_DoubleEle33_CaloIdL_GsfTrkIdVL_MW_v* hltDiEle33CaloIdLNewPixelMatchUnseededFilter 1 +// MuEG +HLT_Mu23_TrkIsoVVL_Ele12_Gsf_CaloId_TrackId_Iso_MediumWP_v* hltL1Mu12EG7L3IsoMuFiltered23 1 +HLT_Mu23_TrkIsoVVL_Ele12_Gsf_CaloId_TrackId_Iso_MediumWP_v* hltMu23Ele12GsfTrackIsoLegEle12GsfCaloIdTrackIdIsoMediumWPFilter 2 +HLT_Mu8_TrkIsoVVL_Ele23_Gsf_CaloId_TrackId_Iso_MediumWP_v* hltL1sL1Mu5EG20ORL1Mu5IsoEG18L3IsoFiltered8 1 +HLT_Mu8_TrkIsoVVL_Ele23_Gsf_CaloId_TrackId_Iso_MediumWP_v* hltMu8Ele23GsfTrackIsoLegEle23GsfCaloIdTrackIdIsoMediumWPFilter 2 +// SinglePhoton +HLT_Photon155_v* hltPhoton155HEFilter 1 +// DoubleElectron Tag-and-Probe +HLT_Ele20WP60_Ele8_Mass55_v* hltEle20WP60Ele8TrackIsoFilter 1 +HLT_Ele20WP60_Ele8_Mass55_v* hltEle20WP60Ele8PixelMatchUnseededFilter 2 +HLT_Ele25WP60_SC4_Mass55_v* hltEle25WP60SC4TrackIsoFilter 1 +HLT_Ele25WP60_SC4_Mass55_v* hltEle25WP60SC4EtUnseededFilter 2 +// MET +HLT_PFMET170_NoiseCleaned_v* hltPFMET170Filter 1 +HLT_PFMET120_NoiseCleaned_BTagCSV07_v* hltPFMET120Filter 1 +HLT_PFMET120_NoiseCleaned_BTagCSV07_v* hltBLifetimeL3FilterCSVsusy 2 +HLT_PFHT350_PFMET120_NoiseCleaned_v* hltPFHT350 1 +HLT_PFHT350_PFMET120_NoiseCleaned_v* hltPFMET120Filter 2 diff --git a/DQMOffline/LumiZCounting/data/HLT_50nsGRun b/DQMOffline/LumiZCounting/data/HLT_50nsGRun new file mode 100644 index 0000000000000..c278ac49b6ba3 --- /dev/null +++ b/DQMOffline/LumiZCounting/data/HLT_50nsGRun @@ -0,0 +1,58 @@ +// single electron +HLT_Ele23_WPLoose_Gsf_v* hltEGL1SingleEG20ORL1SingleEG15Filter 1 +HLT_Ele23_WPLoose_Gsf_v* hltEle23WPLooseGsfTrackIsoFilter 2 +HLT_Ele22_WP75_Gsf_v* hltL1sL1SingleEG20 1 +HLT_Ele22_WP75_Gsf_v* hltEle22WP75GsfTrackIsoFilter 2 +HLT_Ele23_WP75_Gsf_v* hltL1sL1SingleEG20 1 +HLT_Ele23_WP75_Gsf_v* hltEle23WP75GsfTrackIsoFilter 2 +// single muon +HLT_IsoMu20_v* hltL1sL1SingleMu18 1 +HLT_IsoMu20_v* hltL3crIsoL1sMu18L1f0L2f10QL3f20QL3trkIsoFiltered0p09 2 +HLT_IsoMu20_v* hltL3crIsoL1sMu16L1f0L2f10QL3f20QL3trkIsoFiltered0p09 3 +HLT_IsoTkMu20_eta2p1_v* hltL3crIsoL1sMu18Eta2p1L1f0L2f10QL3f20QL3trkIsoFiltered0p09 1 + +// single muon pre-scaled +HLT_Mu17_TrkIsoVVL_v* hltL3fL1sMu12L1f0L2f12L3Filtered17TkIsoFiltered0p4 1 +HLT_Mu8_TrkIsoVVL_v* hltL3fL1sMu5L1f0L2f5L3Filtered8TkIsoFiltered0p4 1 +HLT_IsoMu22_v* hltL3crIsoL1sMu20L1f0L2f10QL3f22QL3trkIsoFiltered0p09 1 +HLT_IsoTkMu18_v* hltL3fL1sMu16L1f0Tkf18QL3trkIsoFiltered0p09 1 +HLT_Ele27_WPLoose_Gsf_v* hltEle27noerWPLooseGsfTrackIsoFilter 1 +HLT_Ele22_eta2p1_WP75_Gsf_v* hltEle22WP75GsfTrackIsoFilter 1 +HLT_Ele27_eta2p1_WP75_Gsf_v* hltEle27WP75GsfTrackIsoFilter 1 +HLT_Ele22_eta2p1_WPLoose_Gsf_v* hltEle22WPLooseGsfTrackIsoFilter 1 + +HLT_Mu20_v* hltL3fL1sMu18L1f0L2f10QL3Filtered20Q 1 +HLT_Mu27_v* hltL3fL1sMu22Or25L1f0L2f10QL3Filtered27Q 1 +HLT_Mu50_v* hltL3fL1sMu22Or25L1f0L2f10QL3Filtered50Q 1 +HLT_TkMu50_v* hltL3fL1sMu25f0TkFiltered50Q 1 + +// double muon pre-scaled +HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_v* hltL3fL1sDoubleMu103p5L1f0L2f10OneMuL3Filtered17 1 +HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_v* hltDiMuonGlb17Glb8RelTrkIsoFiltered0p4 2 +HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_v* hltL3fL1sDoubleMu103p5L1f0L2f10OneMuL3Filtered17 1 +HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_v* hltDiMuonGlb17Glb8RelTrkIsoFiltered0p4 2 +HLT_Mu17_TrkIsoVVL_TkMu8_TrkIsoVVL_v* hltL3fL1sDoubleMu103p5L1f0L2f10L3Filtered17 1 +HLT_Mu17_TrkIsoVVL_TkMu8_TrkIsoVVL_v* hltDiMuonGlb17Trk8RelTrkIsoFiltered0p4 2 +HLT_Mu17_TrkIsoVVL_TkMu8_TrkIsoVVL_DZ_v* hltL3fL1sDoubleMu103p5L1f0L2f10L3Filtered17 1 +HLT_Mu17_TrkIsoVVL_TkMu8_TrkIsoVVL_DZ_v* hltDiMuonGlb17Trk8RelTrkIsoFiltered0p4 2 + +// double electron +HLT_Ele17_Ele12_CaloIdL_TrackIdL_IsoVL_v* hltEle17Ele12CaloIdLTrackIdLIsoVLTrackIsoLeg1Filter 1 +HLT_Ele17_Ele12_CaloIdL_TrackIdL_IsoVL_v* hltEle17Ele12CaloIdLTrackIdLIsoVLTrackIsoLeg2Filter 2 +HLT_Ele17_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v* hltEle17Ele12CaloIdLTrackIdLIsoVLTrackIsoLeg1Filter 1 +HLT_Ele17_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v* hltEle17Ele12CaloIdLTrackIdLIsoVLTrackIsoLeg2Filter 2 +HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_v* hltEle23Ele12CaloIdLTrackIdLIsoVLTrackIsoLeg1Filter 1 +HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_v* hltEle23Ele12CaloIdLTrackIdLIsoVLTrackIsoLeg2Filter 2 +HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v* hltEle23Ele12CaloIdLTrackIdLIsoVLTrackIsoLeg1Filter 1 +HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v* hltEle23Ele12CaloIdLTrackIdLIsoVLTrackIsoLeg2Filter 2 + +//Double Photon +HLT_DoublePhoton60_v* hltDiEG60HEUnseededFilter 1 + +HLT_IsoMu24_v* hltL3crIsoL1sMu22L1f0L2f10QL3f24QL3trkIsoFiltered0p09 1 +HLT_IsoMu27_v* hltL3crIsoL1sMu22Or25L1f0L2f10QL3f27QL3trkIsoFiltered0p09 1 +HLT_Ele25_eta2p1_WPTight_Gsf_v* hltEle25erWPTightGsfTrackIsoFilter 1 +HLT_Ele27_WPTight_Gsf_v* hltEle27WPTightGsfTrackIsoFilter 1 +HLT_Ele27_eta2p1_WPLoose_Gsf_v* hltEle27erWPLooseGsfTrackIsoFilter 1 + +//MC triggers diff --git a/DQMOffline/LumiZCounting/data/HLT_50nsGRun_80X b/DQMOffline/LumiZCounting/data/HLT_50nsGRun_80X new file mode 100644 index 0000000000000..1108c7df3fffe --- /dev/null +++ b/DQMOffline/LumiZCounting/data/HLT_50nsGRun_80X @@ -0,0 +1,55 @@ +// single electron +HLT_Ele23_WPLoose_Gsf_v* hltEGL1SingleEG20ORL1SingleEG15Filter 1 +HLT_Ele23_WPLoose_Gsf_v* hltEle23WPLooseGsfTrackIsoFilter 2 +HLT_Ele22_WP75_Gsf_v* hltL1sL1SingleEG20 1 +HLT_Ele22_WP75_Gsf_v* hltEle22WP75GsfTrackIsoFilter 2 +HLT_Ele23_WP75_Gsf_v* hltL1sL1SingleEG20 1 +HLT_Ele23_WP75_Gsf_v* hltEle23WP75GsfTrackIsoFilter 2 +// single muon +HLT_IsoMu20_v* hltL1sL1SingleMu18 1 +HLT_IsoMu20_v* hltL3crIsoL1sMu18L1f0L2f10QL3f20QL3trkIsoFiltered0p09 2 +HLT_IsoTkMu20_eta2p1_v* hltL3crIsoL1sMu18Eta2p1L1f0L2f10QL3f20QL3trkIsoFiltered0p09 1 + +// single muon pre-scaled +HLT_Mu17_TrkIsoVVL_v* hltL3fL1sMu12L1f0L2f12L3Filtered17TkIsoFiltered0p4 1 +HLT_Mu8_TrkIsoVVL_v* hltL3fL1sMu5L1f0L2f5L3Filtered8TkIsoFiltered0p4 1 +HLT_IsoMu22_v* hltL3crIsoL1sMu20L1f0L2f10QL3f22QL3trkIsoFiltered0p09 1 +HLT_IsoTkMu18_v* hltL3fL1sMu16L1f0Tkf18QL3trkIsoFiltered0p09 1 +HLT_Ele27_WPLoose_Gsf_v* hltEle27noerWPLooseGsfTrackIsoFilter 1 +HLT_Ele22_eta2p1_WP75_Gsf_v* hltEle22WP75GsfTrackIsoFilter 1 +HLT_Ele27_eta2p1_WP75_Gsf_v* hltEle27WP75GsfTrackIsoFilter 1 +HLT_Ele22_eta2p1_WPLoose_Gsf_v* hltEle22WPLooseGsfTrackIsoFilter 1 + +HLT_Mu20_v* hltL3fL1sMu18L1f0L2f10QL3Filtered20Q 1 +HLT_Mu27_v* hltL3fL1sMu22Or25L1f0L2f10QL3Filtered27Q 1 +HLT_Mu50_v* hltL3fL1sMu22Or25L1f0L2f10QL3Filtered50Q 1 +HLT_TkMu50_v* hltL3fL1sMu25f0TkFiltered50Q 1 + +// double muon pre-scaled +HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_v* hltL3fL1sDoubleMu103p5L1f0L2f10OneMuL3Filtered17 1 +HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_v* hltDiMuonGlb17Glb8RelTrkIsoFiltered0p4 2 +HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_v* hltL3fL1sDoubleMu103p5L1f0L2f10OneMuL3Filtered17 1 +HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_v* hltDiMuonGlb17Glb8RelTrkIsoFiltered0p4 2 +HLT_Mu17_TrkIsoVVL_TkMu8_TrkIsoVVL_v* hltL3fL1sDoubleMu103p5L1f0L2f10L3Filtered17 1 +HLT_Mu17_TrkIsoVVL_TkMu8_TrkIsoVVL_v* hltDiMuonGlb17Trk8RelTrkIsoFiltered0p4 2 +HLT_Mu17_TrkIsoVVL_TkMu8_TrkIsoVVL_DZ_v* hltL3fL1sDoubleMu103p5L1f0L2f10L3Filtered17 1 +HLT_Mu17_TrkIsoVVL_TkMu8_TrkIsoVVL_DZ_v* hltDiMuonGlb17Trk8RelTrkIsoFiltered0p4 2 + +// double electron +HLT_Ele17_Ele12_CaloIdL_TrackIdL_IsoVL_v* hltEle17Ele12CaloIdLTrackIdLIsoVLTrackIsoLeg1Filter 1 +HLT_Ele17_Ele12_CaloIdL_TrackIdL_IsoVL_v* hltEle17Ele12CaloIdLTrackIdLIsoVLTrackIsoLeg2Filter 2 +HLT_Ele17_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v* hltEle17Ele12CaloIdLTrackIdLIsoVLTrackIsoLeg1Filter 1 +HLT_Ele17_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v* hltEle17Ele12CaloIdLTrackIdLIsoVLTrackIsoLeg2Filter 2 +HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_v* hltEle23Ele12CaloIdLTrackIdLIsoVLTrackIsoLeg1Filter 1 +HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_v* hltEle23Ele12CaloIdLTrackIdLIsoVLTrackIsoLeg2Filter 2 +HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v* hltEle23Ele12CaloIdLTrackIdLIsoVLTrackIsoLeg1Filter 1 +HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v* hltEle23Ele12CaloIdLTrackIdLIsoVLTrackIsoLeg2Filter 2 + +//Double Photon +HLT_DoublePhoton60_v* hltDiEG60HEUnseededFilter 1 + +HLT_IsoMu24_v* hltL3crIsoL1sMu22L1f0L2f10QL3f24QL3trkIsoFiltered0p09 1 +HLT_IsoMu27_v* hltL3crIsoL1sMu22Or25L1f0L2f10QL3f27QL3trkIsoFiltered0p09 1 +HLT_Ele25_eta2p1_WPTight_Gsf_v* hltEle25erWPTightGsfTrackIsoFilter 1 +HLT_Ele27_WPTight_Gsf_v* hltEle27WPTightGsfTrackIsoFilter 1 +HLT_Ele27_eta2p1_WPLoose_Gsf_* hltEle27erWPLooseGsfTrackIsoFilter 1 \ No newline at end of file diff --git a/DQMOffline/LumiZCounting/interface/MiniBaconDefs.h b/DQMOffline/LumiZCounting/interface/MiniBaconDefs.h new file mode 100644 index 0000000000000..95f62ff052287 --- /dev/null +++ b/DQMOffline/LumiZCounting/interface/MiniBaconDefs.h @@ -0,0 +1,11 @@ +#ifndef DQMOFFLINE_LUMIZCOUNTING_MINIBACONDEFS_H +#define DQMOFFLINE_LUMIZCOUNTING_MINIBACONDEFS_H + +#include + +const unsigned int kNTrigBit = 128; +typedef std::bitset TriggerBits; +const unsigned int kNTrigObjectBit = 256; +typedef std::bitset TriggerObjects; + +#endif diff --git a/DQMOffline/LumiZCounting/interface/RunLumiRangeMap.h b/DQMOffline/LumiZCounting/interface/RunLumiRangeMap.h new file mode 100644 index 0000000000000..a5b5374abda50 --- /dev/null +++ b/DQMOffline/LumiZCounting/interface/RunLumiRangeMap.h @@ -0,0 +1,26 @@ +#ifndef DQMOFFLINE_LUMIZCOUNTING_RUNLUMIRANGEMAP_H +#define DQMOFFLINE_LUMIZCOUNTING_RUNLUMIRANGEMAP_H + +#include +#include +#include + +namespace baconhep +{ + class RunLumiRangeMap + { + public: + typedef std::pair RunLumiPairType; + typedef std::map> MapType; + + RunLumiRangeMap(){} + ~RunLumiRangeMap(){} + + void addJSONFile(const std::string &filepath); + bool hasRunLumi(const RunLumiPairType &runLumi) const; + + protected: + MapType fMap; // mapped run-lumi ranges to accept + }; +} +#endif diff --git a/DQMOffline/LumiZCounting/interface/TTrigger.h b/DQMOffline/LumiZCounting/interface/TTrigger.h new file mode 100644 index 0000000000000..f298254421dd0 --- /dev/null +++ b/DQMOffline/LumiZCounting/interface/TTrigger.h @@ -0,0 +1,26 @@ +#ifndef DQMOFFLINE_LUMIZCOUNTING_TTRIGGER_H +#define DQMOFFLINE_LUMIZCOUNTING_TTRIGGER_H + +#include "DQMOffline/LumiZCounting/interface/TriggerRecord.h" // class to handle user specified trigger info +#include "DQMOffline/LumiZCounting/interface/MiniBaconDefs.h" + +namespace baconhep +{ + class TTrigger + { + public: + TTrigger(const std::string iFileName); + ~TTrigger(){} + + // Methods + int getTriggerBit(const std::string iName) const; + int getTriggerObjectBit(const std::string iName, const int iLeg) const; + int getTriggerObjectBit(const std::string iName, const std::string iObjName) const; + bool pass(const std::string iName, const TriggerBits &iTrig) const; + bool passObj(const std::string iName, const int iLeg, const TriggerObjects &iTrigObj) const; + bool passObj(const std::string iName, const std::string iObjName, const TriggerObjects &iTrigObj) const; + + std::vector fRecords; + }; +} +#endif diff --git a/DQMOffline/LumiZCounting/interface/TriggerRecord.h b/DQMOffline/LumiZCounting/interface/TriggerRecord.h new file mode 100644 index 0000000000000..eeb9ab89901c4 --- /dev/null +++ b/DQMOffline/LumiZCounting/interface/TriggerRecord.h @@ -0,0 +1,31 @@ +#ifndef DQMOFFLINE_LUMIZCOUNTING_TRIGGERRECORD_H +#define DQMOFFLINE_LUMIZCOUNTING_TRIGGERRECORD_H + +#include +#include +#include + +namespace baconhep { + +class TriggerRecord +{ +public: + TriggerRecord(const std::string name="", const unsigned int value=0) { + hltPattern = name; + baconTrigBit = value; + hltPathName = ""; + hltPathIndex = (unsigned int)-1; + } + ~TriggerRecord(){} + + std::string hltPattern; // HLT path name/pattern (wildcards allowed: *,?) + unsigned int baconTrigBit; // bacon trigger bit + std::string hltPathName; // HLT path name in trigger menu + unsigned int hltPathIndex; // HLT path index in trigger menu + + // map between trigger object name and bacon trigger object bit + std::vector< std::pair > objectMap; +}; + +} +#endif diff --git a/DQMOffline/LumiZCounting/interface/TriggerTools.h b/DQMOffline/LumiZCounting/interface/TriggerTools.h new file mode 100644 index 0000000000000..490e7312ec0f9 --- /dev/null +++ b/DQMOffline/LumiZCounting/interface/TriggerTools.h @@ -0,0 +1,20 @@ +#ifndef DQMOFFLINE_LUMIZCOUNTING_TRIGGERTOOLS_H +#define DQMOFFLINE_LUMIZCOUNTING_TRIGGERTOOLS_H + +#include "DQMOffline/LumiZCounting/interface/MiniBaconDefs.h" +#include "DQMOffline/LumiZCounting/interface/TriggerRecord.h" +#include "DataFormats/HLTReco/interface/TriggerEvent.h" +#include + +namespace baconhep { + +class TriggerTools +{ +public: + static TriggerObjects matchHLT(const double eta, const double phi, + const std::vector &triggerRecords, + const trigger::TriggerEvent &triggerEvent); +}; + +} +#endif diff --git a/DQMOffline/LumiZCounting/plugins/BuildFile.xml b/DQMOffline/LumiZCounting/plugins/BuildFile.xml new file mode 100644 index 0000000000000..e0370ba48d819 --- /dev/null +++ b/DQMOffline/LumiZCounting/plugins/BuildFile.xml @@ -0,0 +1,12 @@ + + + + + + + + + + + + diff --git a/DQMOffline/LumiZCounting/plugins/ZCounting.cc b/DQMOffline/LumiZCounting/plugins/ZCounting.cc new file mode 100644 index 0000000000000..e59de25703a47 --- /dev/null +++ b/DQMOffline/LumiZCounting/plugins/ZCounting.cc @@ -0,0 +1,472 @@ +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Common/interface/TriggerNames.h" +#include "FWCore/Utilities/interface/RegexMatch.h" +#include "DataFormats/Common/interface/Handle.h" +#include "DataFormats/Common/interface/TriggerResults.h" +#include "DataFormats/HLTReco/interface/TriggerEvent.h" +#include "DataFormats/VertexReco/interface/Vertex.h" +#include "DataFormats/MuonReco/interface/Muon.h" +#include "DataFormats/MuonReco/interface/MuonSelectors.h" + +#include "DQMOffline/LumiZCounting/interface/MiniBaconDefs.h" +#include "DQMOffline/LumiZCounting/interface/TTrigger.h" +#include "DQMOffline/LumiZCounting/interface/TriggerTools.h" + +#include +#include +#include + +#include "DQMOffline/LumiZCounting/plugins/ZCounting.h" + +using namespace baconhep; + +// +// -------------------------------------- Constructor -------------------------------------------- +// +ZCounting::ZCounting(const edm::ParameterSet& iConfig): + fHLTFile (iConfig.getUntrackedParameter("TriggerFile","HLT")), + fHLTObjTag (iConfig.getParameter("TriggerEvent")), + fHLTTag (iConfig.getParameter("TriggerResults")), + fPVName (iConfig.getUntrackedParameter("edmPVName","offlinePrimaryVertices")), + fMuonName (iConfig.getUntrackedParameter("edmName","muons")), + fTrackName (iConfig.getUntrackedParameter("edmTrackName","generalTracks")), + fTrigger (0) +{ + edm::LogInfo("ZCounting") << "Constructor ZCounting::ZCounting " << std::endl; + + //Get parameters from configuration file + fHLTTag_token = consumes(fHLTTag); + fHLTObjTag_token = consumes(fHLTObjTag); + fPVName_token = consumes(fPVName); + fMuonName_token = consumes(fMuonName); + fTrackName_token = consumes(fTrackName); + + //Cuts + IDType_ = iConfig.getUntrackedParameter("IDType"); + IsoType_ = iConfig.getUntrackedParameter("IsoType"); + IsoCut_ = iConfig.getUntrackedParameter("IsoCut"); + + PtCutL1_ = iConfig.getUntrackedParameter("PtCutL1"); + PtCutL2_ = iConfig.getUntrackedParameter("PtCutL2"); + EtaCutL1_ = iConfig.getUntrackedParameter("EtaCutL1"); + EtaCutL2_ = iConfig.getUntrackedParameter("EtaCutL2"); + + MassBin_ = iConfig.getUntrackedParameter("MassBin"); + MassMin_ = iConfig.getUntrackedParameter("MassMin"); + MassMax_ = iConfig.getUntrackedParameter("MassMax"); + + LumiBin_ = iConfig.getUntrackedParameter("LumiBin"); + LumiMin_ = iConfig.getUntrackedParameter("LumiMin"); + LumiMax_ = iConfig.getUntrackedParameter("LumiMax"); + + PVBin_ = iConfig.getUntrackedParameter("PVBin"); + PVMin_ = iConfig.getUntrackedParameter("PVMin"); + PVMax_ = iConfig.getUntrackedParameter("PVMax"); + + VtxNTracksFitCut_ = iConfig.getUntrackedParameter("VtxNTracksFitMin"); + VtxNdofCut_ = iConfig.getUntrackedParameter("VtxNdofMin"); + VtxAbsZCut_ = iConfig.getUntrackedParameter("VtxAbsZMax"); + VtxRhoCut_ = iConfig.getUntrackedParameter("VtxRhoMax"); +} + +// +// -------------------------------------- Destructor -------------------------------------------- +// +ZCounting::~ZCounting() +{ + edm::LogInfo("ZCounting") << "Destructor ZCounting::~ZCounting " << std::endl; + + delete fTrigger; +} + +// +// -------------------------------------- beginRun -------------------------------------------- +// +void ZCounting::dqmBeginRun(edm::Run const &, edm::EventSetup const &) +{ + edm::LogInfo("ZCounting") << "ZCounting::beginRun" << std::endl; + + // Triggers + setTriggers(); +} +// +// -------------------------------------- bookHistos -------------------------------------------- +// +void ZCounting::bookHistograms(DQMStore::IBooker & ibooker_, edm::Run const &, edm::EventSetup const &) +{ + edm::LogInfo("ZCounting") << "ZCounting::bookHistograms" << std::endl; + + ibooker_.cd(); + ibooker_.setCurrentFolder("ZCounting/Histograms"); +/* + h_mass_HLT_pass_central = ibooker_.book1D("h_mass_HLT_pass_central", "h_mass_HLT_pass_central", MassBin_, MassMin_, MassMax_); + h_mass_HLT_pass_forward = ibooker_.book1D("h_mass_HLT_pass_forward", "h_mass_HLT_pass_forward", MassBin_, MassMin_, MassMax_); + h_mass_HLT_fail_central = ibooker_.book1D("h_mass_HLT_fail_central", "h_mass_HLT_fail_central", MassBin_, MassMin_, MassMax_); + h_mass_HLT_fail_forward = ibooker_.book1D("h_mass_HLT_fail_forward", "h_mass_HLT_fail_forward", MassBin_, MassMin_, MassMax_); + + h_mass_SIT_pass_central = ibooker_.book1D("h_mass_SIT_pass_central", "h_mass_SIT_pass_central", MassBin_, MassMin_, MassMax_); + h_mass_SIT_pass_forward = ibooker_.book1D("h_mass_SIT_pass_forward", "h_mass_SIT_pass_forward", MassBin_, MassMin_, MassMax_); + h_mass_SIT_fail_central = ibooker_.book1D("h_mass_SIT_fail_central", "h_mass_SIT_fail_central", MassBin_, MassMin_, MassMax_); + h_mass_SIT_fail_forward = ibooker_.book1D("h_mass_SIT_fail_forward", "h_mass_SIT_fail_forward", MassBin_, MassMin_, MassMax_); + + h_mass_Sta_pass_central = ibooker_.book1D("h_mass_Sta_pass_central", "h_mass_Sta_pass_central", MassBin_, MassMin_, MassMax_); + h_mass_Sta_pass_forward = ibooker_.book1D("h_mass_Sta_pass_forward", "h_mass_Sta_pass_forward", MassBin_, MassMin_, MassMax_); + h_mass_Sta_fail_central = ibooker_.book1D("h_mass_Sta_fail_central", "h_mass_Sta_fail_central", MassBin_, MassMin_, MassMax_); + h_mass_Sta_fail_forward = ibooker_.book1D("h_mass_Sta_fail_forward", "h_mass_Sta_fail_forward", MassBin_, MassMin_, MassMax_); +*/ + h_mass_HLT_pass_central = ibooker_.book2D("h_mass_HLT_pass_central", "h_mass_HLT_pass_central", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_); + h_mass_HLT_pass_forward = ibooker_.book2D("h_mass_HLT_pass_forward", "h_mass_HLT_pass_forward", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_); + h_mass_HLT_fail_central = ibooker_.book2D("h_mass_HLT_fail_central", "h_mass_HLT_fail_central", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_); + h_mass_HLT_fail_forward = ibooker_.book2D("h_mass_HLT_fail_forward", "h_mass_HLT_fail_forward", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_); + + h_mass_SIT_pass_central = ibooker_.book2D("h_mass_SIT_pass_central", "h_mass_SIT_pass_central", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_); + h_mass_SIT_pass_forward = ibooker_.book2D("h_mass_SIT_pass_forward", "h_mass_SIT_pass_forward", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_); + h_mass_SIT_fail_central = ibooker_.book2D("h_mass_SIT_fail_central", "h_mass_SIT_fail_central", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_); + h_mass_SIT_fail_forward = ibooker_.book2D("h_mass_SIT_fail_forward", "h_mass_SIT_fail_forward", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_); + + h_mass_Sta_pass_central = ibooker_.book2D("h_mass_Sta_pass_central", "h_mass_Sta_pass_central", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_); + h_mass_Sta_pass_forward = ibooker_.book2D("h_mass_Sta_pass_forward", "h_mass_Sta_pass_forward", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_); + h_mass_Sta_fail_central = ibooker_.book2D("h_mass_Sta_fail_central", "h_mass_Sta_fail_central", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_); + h_mass_Sta_fail_forward = ibooker_.book2D("h_mass_Sta_fail_forward", "h_mass_Sta_fail_forward", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_); + + h_npv = ibooker_.book2D("h_npv", "h_npv", LumiBin_, LumiMin_, LumiMax_, PVBin_, PVMin_, PVMax_); + h_yield_Z = ibooker_.book1D("h_yield_Z", "h_yield_Z", LumiBin_, LumiMin_, LumiMax_); + +} +// +// -------------------------------------- beginLuminosityBlock -------------------------------------------- +// +void ZCounting::beginLuminosityBlock(edm::LuminosityBlock const& lumiSeg, edm::EventSetup const& context) +{ + edm::LogInfo("ZCounting") << "ZCounting::beginLuminosityBlock" << std::endl; +} + + +// +// -------------------------------------- Analyze -------------------------------------------- +// +//-------------------------------------------------------------------------------------------------- +void ZCounting::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) +{// Fill event tree on the fly + edm::LogInfo("ZCounting") << "ZCounting::analyze" << std::endl; + + //------------------------------- + //--- Vertex + //------------------------------- + edm::Handle hVertexProduct; + iEvent.getByToken(fPVName_token,hVertexProduct); + if(!hVertexProduct.isValid()) return; + + const reco::VertexCollection *pvCol = hVertexProduct.product(); + const reco::Vertex* pv = &(*pvCol->begin()); + int nvtx = 0; + + for(reco::VertexCollection::const_iterator itVtx = pvCol->begin(); itVtx!=pvCol->end(); ++itVtx) { + if(itVtx->isFake()) continue; + if(itVtx->tracksSize() < VtxNTracksFitCut_) continue; + if(itVtx->ndof() < VtxNdofCut_) continue; + if(fabs(itVtx->z()) > VtxAbsZCut_) continue; + if(itVtx->position().Rho() > VtxRhoCut_) continue; + + if(nvtx==0) { + pv = &(*itVtx); + } + nvtx++; + } + + h_npv->Fill(iEvent.luminosityBlock(), nvtx); + + // Good vertex requirement + if(nvtx==0) return; + + //------------------------------- + //--- Trigger + //------------------------------- + edm::Handle hTrgRes; + iEvent.getByToken(fHLTTag_token,hTrgRes); + if(!hTrgRes.isValid()) return; + + edm::Handle hTrgEvt; + iEvent.getByToken(fHLTObjTag_token,hTrgEvt); + + const edm::TriggerNames &triggerNames = iEvent.triggerNames(*hTrgRes); + Bool_t config_changed = false; + if(fTriggerNamesID != triggerNames.parameterSetID()) { + fTriggerNamesID = triggerNames.parameterSetID(); + config_changed = true; + } + if(config_changed) { + initHLT(*hTrgRes, triggerNames); + } + + TriggerBits triggerBits; + for(unsigned int irec=0; irecfRecords.size(); irec++) { + if(fTrigger->fRecords[irec].hltPathIndex == (unsigned int)-1) continue; + if(hTrgRes->accept(fTrigger->fRecords[irec].hltPathIndex)) { + triggerBits [fTrigger->fRecords[irec].baconTrigBit] = 1; + } + } + //if(fSkipOnHLTFail && triggerBits == 0) return; + + // Trigger requirement + if(!isMuonTrigger(*fTrigger, triggerBits)) return; + + //------------------------------- + //--- Muons and Tracks + //------------------------------- + edm::Handle hMuonProduct; + iEvent.getByToken(fMuonName_token,hMuonProduct); + if(!hMuonProduct.isValid()) return; + const reco::MuonCollection *muonCol = hMuonProduct.product(); + + edm::Handle hTrackProduct; + iEvent.getByToken(fTrackName_token,hTrackProduct); + if(!hTrackProduct.isValid()) return; + const reco::TrackCollection *trackCol = hTrackProduct.product(); + + TLorentzVector vTag(0.,0.,0.,0.); + TLorentzVector vProbe(0.,0.,0.,0.); + TLorentzVector vTrack(0.,0.,0.,0.); + + // Tag loop + for(reco::MuonCollection::const_iterator itMu1 = muonCol->begin(); itMu1!=muonCol->end(); ++itMu1) { + float pt1 = itMu1->muonBestTrack()->pt(); + float eta1 = itMu1->muonBestTrack()->eta(); + float phi1 = itMu1->muonBestTrack()->phi(); + float q1 = itMu1->muonBestTrack()->charge(); + + // Tag selection: kinematic cuts, lepton selection and trigger matching + if(pt1 < PtCutL1_) continue; + if(fabs(eta1) > EtaCutL1_) continue; + if(!(passMuonID(*itMu1, *pv, IDType_) && passMuonIso(*itMu1, IsoType_, IsoCut_))) continue; + if(!isMuonTriggerObj(*fTrigger, TriggerTools::matchHLT(eta1, phi1, fTrigger->fRecords, *hTrgEvt))) continue; + + vTag.SetPtEtaPhiM(pt1, eta1, phi1, MUON_MASS); + + // Probe loop over muons + for(reco::MuonCollection::const_iterator itMu2 = muonCol->begin(); itMu2!=muonCol->end(); ++itMu2) { + if(itMu2 == itMu1) continue; + + float pt2 = itMu2->muonBestTrack()->pt(); + float eta2 = itMu2->muonBestTrack()->eta(); + float phi2 = itMu2->muonBestTrack()->phi(); + float q2 = itMu2->muonBestTrack()->charge(); + + // Probe selection: kinematic cuts and opposite charge requirement + if(pt2 < PtCutL2_) continue; + if(fabs(eta2) > EtaCutL2_) continue; + if(q1 == q2) continue; + + vProbe.SetPtEtaPhiM(pt2, eta2, phi2, MUON_MASS); + + // Mass window + TLorentzVector vDilep = vTag + vProbe; + if((vDilep.M() < MassMin_) || (vDilep.M() > MassMax_)) continue; + + bool isTagCentral = false; + bool isProbeCentral = false; + if(fabs(eta1) < MUON_BOUND) isTagCentral = true; + if(fabs(eta2) < MUON_BOUND) isProbeCentral = true; + + // Determine event category for efficiency calculation + if(passMuonID(*itMu2, *pv, IDType_) && passMuonIso(*itMu2, IsoType_, IsoCut_)){ + if(isMuonTriggerObj(*fTrigger, TriggerTools::matchHLT(eta2, phi2, fTrigger->fRecords, *hTrgEvt))){ + // category 2HLT: both muons passing trigger requirements + if(itMu1>itMu2) continue; // make sure we don't double count MuMu2HLT category + + // Fill twice for each event, since both muons pass trigger + if(isTagCentral){ + h_mass_HLT_pass_central->Fill(iEvent.luminosityBlock(), vDilep.M()); + h_mass_SIT_pass_central->Fill(iEvent.luminosityBlock(), vDilep.M()); + h_mass_Sta_pass_central->Fill(iEvent.luminosityBlock(), vDilep.M()); + } + else + { + h_mass_HLT_pass_forward->Fill(iEvent.luminosityBlock(), vDilep.M()); + h_mass_SIT_pass_forward->Fill(iEvent.luminosityBlock(), vDilep.M()); + h_mass_Sta_pass_forward->Fill(iEvent.luminosityBlock(), vDilep.M()); + } + + if(isProbeCentral){ + h_mass_HLT_pass_central->Fill(iEvent.luminosityBlock(), vDilep.M()); + h_mass_SIT_pass_central->Fill(iEvent.luminosityBlock(), vDilep.M()); + h_mass_Sta_pass_central->Fill(iEvent.luminosityBlock(), vDilep.M()); + } + else + { + h_mass_HLT_pass_forward->Fill(iEvent.luminosityBlock(), vDilep.M()); + h_mass_SIT_pass_forward->Fill(iEvent.luminosityBlock(), vDilep.M()); + h_mass_Sta_pass_forward->Fill(iEvent.luminosityBlock(), vDilep.M()); + } + + } + else{ + // category 1HLT: probe passing selection but not trigger + if(isProbeCentral){ + h_mass_HLT_fail_central->Fill(iEvent.luminosityBlock(), vDilep.M()); + h_mass_SIT_pass_central->Fill(iEvent.luminosityBlock(), vDilep.M()); + h_mass_Sta_pass_central->Fill(iEvent.luminosityBlock(), vDilep.M()); + } + else + { + h_mass_HLT_fail_forward->Fill(iEvent.luminosityBlock(), vDilep.M()); + h_mass_SIT_pass_forward->Fill(iEvent.luminosityBlock(), vDilep.M()); + h_mass_Sta_pass_forward->Fill(iEvent.luminosityBlock(), vDilep.M()); + } + + } + // category 2HLT + 1HLT: Fill once for Z yield + h_yield_Z->Fill(iEvent.luminosityBlock()); + } + else if(itMu2->isGlobalMuon()){ + // category NoSel: probe is a GLB muon but failing selection + if(isProbeCentral){ + h_mass_SIT_fail_central->Fill(iEvent.luminosityBlock(), vDilep.M()); + h_mass_Sta_pass_central->Fill(iEvent.luminosityBlock(), vDilep.M()); + } + else + { + h_mass_SIT_fail_forward->Fill(iEvent.luminosityBlock(), vDilep.M()); + h_mass_Sta_pass_forward->Fill(iEvent.luminosityBlock(), vDilep.M()); + } + } + else if(itMu2->isStandAloneMuon()){ + // category STA: probe is a STA muon + if(isProbeCentral){ + h_mass_Sta_fail_central->Fill(iEvent.luminosityBlock(), vDilep.M()); + } + else + { + h_mass_Sta_fail_forward->Fill(iEvent.luminosityBlock(), vDilep.M()); + } + } + else if(itMu2->innerTrack()->hitPattern().trackerLayersWithMeasurement() >= 6 && itMu2->innerTrack()->hitPattern().numberOfValidPixelHits() >= 1){ + // cateogry Trk: probe is a tracker track + if(isProbeCentral){ + h_mass_Sta_fail_central->Fill(iEvent.luminosityBlock(), vDilep.M()); + } + else + { + h_mass_Sta_fail_forward->Fill(iEvent.luminosityBlock(), vDilep.M()); + } + } + + }// End of probe loop over muons + + // Probe loop over tracks, only for standalone efficiency calculation + for(reco::TrackCollection::const_iterator itTrk = trackCol->begin(); itTrk!=trackCol->end(); ++itTrk) { + + // Check track is not a muon + bool isMuon = false; + for(reco::MuonCollection::const_iterator itMu = muonCol->begin(); itMu!=muonCol->end(); ++itMu) { + if(itMu->innerTrack().isNonnull() && itMu->innerTrack().get() == &(*itTrk)) { + isMuon = true; + break; + } + } + if(isMuon) continue; + + float pt2 = itTrk->pt(); + float eta2 = itTrk->eta(); + float phi2 = itTrk->phi(); + float q2 = itTrk->charge(); + + // Probe selection: kinematic cuts and opposite charge requirement + if(pt2 < PtCutL2_) continue; + if(fabs(eta2) > EtaCutL2_) continue; + if(q1 == q2) continue; + + vTrack.SetPtEtaPhiM(pt2, eta2, phi2, MUON_MASS); + + TLorentzVector vDilep = vTag + vTrack; + if((vDilep.M() < MassMin_) || (vDilep.M() > MassMax_)) continue; + + bool isTrackCentral = false; + if(fabs(eta2) > MUON_BOUND) isTrackCentral = true; + + if(itTrk->hitPattern().trackerLayersWithMeasurement() >= 6 && itTrk->hitPattern().numberOfValidPixelHits() >= 1){ + if(isTrackCentral) h_mass_Sta_fail_central->Fill(iEvent.luminosityBlock(), vDilep.M()); + else h_mass_Sta_fail_forward->Fill(iEvent.luminosityBlock(), vDilep.M()); + } + + }//End of probe loop over tracks + + }//End of tag loop + +} + +// +// -------------------------------------- endLuminosityBlock -------------------------------------------- +// +void ZCounting::endLuminosityBlock(edm::LuminosityBlock const& lumiSeg, edm::EventSetup const& eSetup) +{ + edm::LogInfo("ZCounting") << "ZCounting::endLuminosityBlock" << std::endl; +} + +// +// -------------------------------------- functions -------------------------------------------- +// +void ZCounting::setTriggers() +{ + std::string cmssw_base_src = getenv("CMSSW_BASE"); cmssw_base_src+="/src/"; + fTrigger = new baconhep::TTrigger(cmssw_base_src + fHLTFile); +} + +//-------------------------------------------------------------------------------------------------- +void ZCounting::initHLT(const edm::TriggerResults& result, const edm::TriggerNames& triggerNames) +{ + for(unsigned int irec=0; irecfRecords.size(); irec++) { + fTrigger->fRecords[irec].hltPathName = ""; + fTrigger->fRecords[irec].hltPathIndex = (unsigned int)-1; + const std::string pattern = fTrigger->fRecords[irec].hltPattern; + if(edm::is_glob(pattern)) { // handle pattern with wildcards (*,?) + std::vector::const_iterator> matches = edm::regexMatch(triggerNames.triggerNames(), pattern); + if(matches.empty()) { + edm::LogWarning("ZCounting") << "requested pattern [" << pattern << "] does not match any HLT paths" << std::endl; + } else { + BOOST_FOREACH(std::vector::const_iterator match, matches) { + fTrigger->fRecords[irec].hltPathName = *match; + } + } + } else { // take full HLT path name given + fTrigger->fRecords[irec].hltPathName = pattern; + } + // Retrieve index in trigger menu corresponding to HLT path + unsigned int index = triggerNames.triggerIndex(fTrigger->fRecords[irec].hltPathName); + if(index < result.size()) { // check for valid index + fTrigger->fRecords[irec].hltPathIndex = index; + } + } +} + +//-------------------------------------------------------------------------------------------------- +bool ZCounting::isMuonTrigger(baconhep::TTrigger triggerMenu, TriggerBits hltBits) +{ + return triggerMenu.pass("HLT_IsoMu24_v*",hltBits); +} + +//-------------------------------------------------------------------------------------------------- +bool ZCounting::isMuonTriggerObj(baconhep::TTrigger triggerMenu, TriggerObjects hltMatchBits) +{ + return triggerMenu.passObj("HLT_IsoMu24_v*","hltL3crIsoL1sMu22L1f0L2f10QL3f24QL3trkIsoFiltered0p09",hltMatchBits); +} +//-------------------------------------------------------------------------------------------------- +bool ZCounting::passMuonID(const reco::Muon& muon, const reco::Vertex& vtx, const std::string idType) +{//Muon ID selection, using internal function "DataFormats/MuonReco/src/MuonSelectors.cc + + if(idType == "Loose" && muon::isLooseMuon(muon)) return true; + else if(idType == "Medium" && muon::isMediumMuon(muon)) return true; + else if(idType == "Tight" && muon::isTightMuon(muon, vtx)) return true; + else return false; +} +//-------------------------------------------------------------------------------------------------- +bool ZCounting::passMuonIso(const reco::Muon& muon, const std::string isoType, const float isoCut) +{//Muon isolation selection, up-to-date with MUO POG recommendation + + if(isoType == "Tracker-based" && muon.isolationR03().sumPt < isoCut) return true; + else if(isoType == "PF-based" && muon.pfIsolationR04().sumChargedHadronPt + TMath::Max(0.,muon.pfIsolationR04().sumNeutralHadronEt + muon.pfIsolationR04().sumPhotonEt - 0.5*muon.pfIsolationR04().sumPUPt) < isoCut) return true; + else if(isoType == "NULL") return true; + else return false; +} + +DEFINE_FWK_MODULE(ZCounting); diff --git a/DQMOffline/LumiZCounting/plugins/ZCounting.h b/DQMOffline/LumiZCounting/plugins/ZCounting.h new file mode 100644 index 0000000000000..b0265f9493ace --- /dev/null +++ b/DQMOffline/LumiZCounting/plugins/ZCounting.h @@ -0,0 +1,137 @@ +#ifndef ZCounting_H +#define ZCounting_H + +#include "FWCore/Framework/interface/MakerMacros.h" // definitions for declaring plug-in modules +#include "FWCore/Framework/interface/Frameworkfwd.h" // declaration of EDM types +#include "FWCore/Framework/interface/EDAnalyzer.h" // EDAnalyzer class +#include "FWCore/Framework/interface/ConsumesCollector.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" // Parameters +#include "FWCore/Utilities/interface/InputTag.h" + +#include // string class +#include +#include + +#include "DataFormats/HLTReco/interface/TriggerEvent.h" +#include "DataFormats/VertexReco/interface/Vertex.h" +#include "DataFormats/VertexReco/interface/VertexFwd.h" +#include "DataFormats/MuonReco/interface/Muon.h" +#include "DataFormats/MuonReco/interface/MuonFwd.h" +#include "DataFormats/MuonReco/interface/MuonSelectors.h" + +#include "DQMServices/Core/interface/DQMEDAnalyzer.h" +#include "DQMServices/Core/interface/DQMStore.h" +#include "DQMServices/Core/interface/MonitorElement.h" + +#include "DQMOffline/LumiZCounting/interface/MiniBaconDefs.h" +#include "DQMOffline/LumiZCounting/interface/TTrigger.h" +#include "DQMOffline/LumiZCounting/interface/TriggerTools.h" + +class TFile; +class TH1D; +class TTree; +class TClonesArray; +namespace edm { + class TriggerResults; + class TriggerNames; +} +namespace baconhep { + class TTrigger; +} + +class ZCounting: public DQMEDAnalyzer{ + +public: + + ZCounting(const edm::ParameterSet& ps); + virtual ~ZCounting(); + +protected: + + void dqmBeginRun(edm::Run const &, edm::EventSetup const &) override; + void bookHistograms(DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override; + void analyze(edm::Event const& e, edm::EventSetup const& eSetup) override; + void beginLuminosityBlock(edm::LuminosityBlock const& lumi, edm::EventSetup const& eSetup) override ; + void endLuminosityBlock(edm::LuminosityBlock const& lumi, edm::EventSetup const& eSetup) override; + +private: + //other functions + bool isMuonTrigger(baconhep::TTrigger triggerMenu, TriggerBits hltBits); + bool isMuonTriggerObj(baconhep::TTrigger triggerMenu, TriggerObjects hltMatchBits); + bool passMuonID(const reco::Muon& muon, const reco::Vertex& vtx, const std::string idType); + bool passMuonIso(const reco::Muon& muon, const std::string isoType, const float isoCut); + + // specify trigger paths of interest + void setTriggers(); + + // initialization from HLT menu; needs to be called on every change in HLT menu + void initHLT(const edm::TriggerResults&, const edm::TriggerNames&); + + // EDM object collection names + edm::ParameterSetID fTriggerNamesID; + std::string fHLTFile; + edm::InputTag fHLTObjTag; + edm::InputTag fHLTTag; + edm::EDGetTokenT fHLTObjTag_token; + edm::EDGetTokenT fHLTTag_token; + std::string fPVName; + edm::EDGetTokenT fPVName_token; + std::string fMuonName; + edm::EDGetTokenT fMuonName_token; + std::string fTrackName; + edm::EDGetTokenT fTrackName_token; + + // bacon fillers + baconhep::TTrigger *fTrigger; + + std::string IDType_; + std::string IsoType_; + double IsoCut_; + + double PtCutL1_; + double PtCutL2_; + double EtaCutL1_; + double EtaCutL2_; + + int MassBin_; + double MassMin_; + double MassMax_; + + int LumiBin_; + double LumiMin_; + double LumiMax_; + + int PVBin_; + double PVMin_; + double PVMax_; + + double VtxNTracksFitCut_; + double VtxNdofCut_; + double VtxAbsZCut_; + double VtxRhoCut_; + + const Double_t MUON_MASS = 0.105658369; + const Double_t MUON_BOUND = 0.9; + + // Histograms + MonitorElement* h_mass_HLT_pass_central; + MonitorElement* h_mass_HLT_pass_forward; + MonitorElement* h_mass_HLT_fail_central; + MonitorElement* h_mass_HLT_fail_forward; + + MonitorElement* h_mass_SIT_pass_central; + MonitorElement* h_mass_SIT_pass_forward; + MonitorElement* h_mass_SIT_fail_central; + MonitorElement* h_mass_SIT_fail_forward; + + MonitorElement* h_mass_Sta_pass_central; + MonitorElement* h_mass_Sta_pass_forward; + MonitorElement* h_mass_Sta_fail_central; + MonitorElement* h_mass_Sta_fail_forward; + + MonitorElement* h_npv; + MonitorElement* h_yield_Z; +}; + + +#endif diff --git a/DQMOffline/LumiZCounting/python/ZCounting_cfg.py b/DQMOffline/LumiZCounting/python/ZCounting_cfg.py new file mode 100644 index 0000000000000..2702011a56abc --- /dev/null +++ b/DQMOffline/LumiZCounting/python/ZCounting_cfg.py @@ -0,0 +1,117 @@ +import FWCore.ParameterSet.Config as cms + +process = cms.Process('RECODQM') + +# import of standard configurations +process.load('Configuration/StandardSequences/Services_cff') +process.load('FWCore/MessageService/MessageLogger_cfi') +process.load('Configuration/StandardSequences/GeometryDB_cff') +process.load('Configuration/StandardSequences/MagneticField_38T_cff') +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') +#process.load('Configuration/StandardSequences/FrontierConditions_GlobalTag_condDBv2_cff') +process.load('Configuration/EventContent/EventContent_cff') +process.load('TrackingTools/TransientTrack/TransientTrackBuilder_cfi') +process.load('Configuration.StandardSequences.EDMtoMEAtRunEnd_cff') + +# load DQM +process.load("DQMServices.Core.DQM_cfg") +process.load("DQMServices.Components.DQMEnvironment_cfi") + +process.MessageLogger.cerr.FwkReport.reportEvery = 1000 +process.GlobalTag.globaltag = '80X_dataRun2_2016SeptRepro_v3' + +# trigger filter +import os +cmssw_base = os.environ['CMSSW_BASE'] +hlt_filename = "DQMOffline/LumiZCounting/data/HLT_50nsGRun" +process.load('HLTrigger/HLTfilters/hltHighLevel_cfi') +process.hltHighLevel.throw = cms.bool(False) +process.hltHighLevel.HLTPaths = cms.vstring() + + +from CondCore.CondDB.CondDB_cfi import * + +hlt_file = open(cmssw_base + "/src/" + hlt_filename, "r") +for line in hlt_file.readlines(): + line = line.strip() # strip preceding and trailing whitespaces + if (line[0:3] == 'HLT'): # assumes typical lines begin with HLT path name (e.g. HLT_Mu15_v1) + hlt_path = line.split()[0] + process.hltHighLevel.HLTPaths.extend(cms.untracked.vstring(hlt_path)) + +process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(-1) ) +process.source = cms.Source("PoolSource", + fileNames = cms.untracked.vstring( +#'/store/data/Run2016H/SingleMuon/RECO/PromptReco-v2/000/281/693/00000/000146F7-1686-E611-BD78-FA163E90B8E2.root', +#'/store/data/Run2016H/SingleMuon/RECO/PromptReco-v2/000/281/693/00000/0005E4FF-1686-E611-8EA1-FA163E4D9EA1.root', +#'/store/data/Run2016H/SingleMuon/RECO/PromptReco-v2/000/281/693/00000/0015960B-1786-E611-9959-02163E011FA5.root', +#'/store/data/Run2016H/SingleMuon/RECO/PromptReco-v2/000/281/693/00000/003BBD87-2086-E611-91F2-02163E0133E6.root', +#'/store/data/Run2016H/SingleMuon/RECO/PromptReco-v2/000/281/693/00000/0050E751-1786-E611-8CE8-02163E0142A0.root', +#'/store/data/Run2016H/SingleMuon/RECO/PromptReco-v2/000/281/693/00000/005C022F-1886-E611-9710-02163E0120DF.root', +#'/store/data/Run2016H/SingleMuon/RECO/PromptReco-v2/000/281/693/00000/00C7E60D-1786-E611-AF8B-02163E011A02.root', +#'/store/data/Run2016H/SingleMuon/RECO/PromptReco-v2/000/281/693/00000/00DFE8EE-1686-E611-8794-FA163E725C0F.root', +#'/store/data/Run2016H/SingleMuon/RECO/PromptReco-v2/000/281/693/00000/022DEC66-1986-E611-AD21-02163E012464.root', +#'/store/data/Run2016H/SingleMuon/RECO/PromptReco-v2/000/281/693/00000/02532811-1786-E611-AFEB-02163E011AA8.root', +'/store/data/Run2016H/SingleMuon/RECO/PromptReco-v2/000/281/727/00000/000744C8-D286-E611-BBEE-02163E012677.root' + ) + ) +process.source.inputCommands = cms.untracked.vstring("keep *", + "drop *_MEtoEDMConverter_*_*") + +process.options = cms.untracked.PSet( + wantSummary = cms.untracked.bool(False), + Rethrow = cms.untracked.vstring('ProductNotFound'), + fileMode = cms.untracked.string('NOMERGE') + ) + +process.zcounting = cms.EDAnalyzer('ZCounting', + TriggerFile = cms.untracked.string(hlt_filename), + TriggerEvent = cms.InputTag('hltTriggerSummaryAOD','','HLT'), + TriggerResults = cms.InputTag('TriggerResults','','HLT'), + edmPVName = cms.untracked.string('offlinePrimaryVertices'), + edmName = cms.untracked.string('muons'), + edmTrackName = cms.untracked.string('generalTracks'), + + IDType = cms.untracked.string("Medium"),# Tight, Medium, Loose + IsoType = cms.untracked.string("NULL"), # Tracker-based, PF-based + IsoCut = cms.untracked.double(0.), # {0.05, 0.10} for Tracker-based, {0.15, 0.25} for PF-based + + PtCutL1 = cms.untracked.double(27.0), + PtCutL2 = cms.untracked.double(27.0), + EtaCutL1 = cms.untracked.double(2.4), + EtaCutL2 = cms.untracked.double(2.4), + + MassBin = cms.untracked.int32(50), + MassMin = cms.untracked.double(66.0), + MassMax = cms.untracked.double(116.0), + + LumiBin = cms.untracked.int32(400), + LumiMin = cms.untracked.double(0.0), + LumiMax = cms.untracked.double(2000.0), + + PVBin = cms.untracked.int32(60), + PVMin = cms.untracked.double(0.0), + PVMax = cms.untracked.double(60.0), + + VtxNTracksFitMin = cms.untracked.double(0.), + VtxNdofMin = cms.untracked.double(4.), + VtxAbsZMax = cms.untracked.double(24.), + VtxRhoMax = cms.untracked.double(2.) + ) + +process.DQMoutput = cms.OutputModule("DQMRootOutputModule", + fileName = cms.untracked.string("OUT_step1.root")) + +# Path and EndPath definitions +process.dqmoffline_step = cms.Path(process.zcounting) +process.dqmsave_step = cms.Path(process.DQMSaver) +#process.DQMoutput_step = cms.EndPath(process.DQMoutput) + + +# Schedule definition +process.schedule = cms.Schedule( + process.dqmoffline_step, +# process.DQMoutput_step + process.dqmsave_step + ) + +process.dqmSaver.workflow = '/SingleMuon/Run2016H-PromptReco-v2/RECO' diff --git a/DQMOffline/LumiZCounting/src/RunLumiRangeMap.cc b/DQMOffline/LumiZCounting/src/RunLumiRangeMap.cc new file mode 100644 index 0000000000000..0f287a0ebc89b --- /dev/null +++ b/DQMOffline/LumiZCounting/src/RunLumiRangeMap.cc @@ -0,0 +1,50 @@ +#include "DQMOffline/LumiZCounting/interface/RunLumiRangeMap.h" +#include +#include +#include + +using namespace baconhep; + +//-------------------------------------------------------------------------------------------------- +void RunLumiRangeMap::addJSONFile(const std::string &filepath) +{ + // read json file into boost property tree + boost::property_tree::ptree jsonTree; + boost::property_tree::read_json(filepath,jsonTree); + + // loop through boost property tree and fill the MapType structure with the list of good lumi ranges for each run + for(boost::property_tree::ptree::const_iterator it = jsonTree.begin(); it!=jsonTree.end(); ++it) { + unsigned int runNum = boost::lexical_cast(it->first); + MapType::mapped_type &lumiPairList = fMap[runNum]; + boost::property_tree::ptree lumiPairListTree = it->second; + for(boost::property_tree::ptree::const_iterator jt = lumiPairListTree.begin(); jt!=lumiPairListTree.end(); ++jt) { + boost::property_tree::ptree lumiPairTree = jt->second; + if(lumiPairTree.size()==2) { + unsigned int firstLumi = boost::lexical_cast(lumiPairTree.begin()->second.data()); + unsigned int lastLumi = boost::lexical_cast((++lumiPairTree.begin())->second.data()); + lumiPairList.push_back(std::pair(firstLumi,lastLumi)); + } + } + } +} + +//-------------------------------------------------------------------------------------------------- +bool RunLumiRangeMap::hasRunLumi(const RunLumiPairType &runLumi) const +{ + // Check if a given run,lumi pair is included in the mapped lumi ranges + + // check if run is included in the map + MapType::const_iterator it = fMap.find(runLumi.first); + if(it!=fMap.end()) { + //check lumis + const MapType::mapped_type &lumiPairList = it->second; + for(MapType::mapped_type::const_iterator jt = lumiPairList.begin(); jt= jt->first && runLumi.second <= jt->second) { + //found lumi in accepted range + return true; + } + } + } + + return false; +} diff --git a/DQMOffline/LumiZCounting/src/TTrigger.cc b/DQMOffline/LumiZCounting/src/TTrigger.cc new file mode 100644 index 0000000000000..dfc4b78a606b9 --- /dev/null +++ b/DQMOffline/LumiZCounting/src/TTrigger.cc @@ -0,0 +1,145 @@ +#include "DQMOffline/LumiZCounting/interface/TTrigger.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" + +#include +#include +#include +#include +#include + +using namespace baconhep; + +//-------------------------------------------------------------------------------------------------- +// +// Reads in an input file specifying the triggers we're interested in. +// The input file has the format: +// +// +// A trigger with multiple objects will have multiple entries with the same but +// one entry for each . +// +// The trigger object leg numbering is to account for the possibility that a particular object of +// the trigger can evolve and obtain a different trigger object name, but we still want this to +// be associated with the same leg (e.g. the trailing electron in a dielectron trigger) +// +TTrigger::TTrigger(const std::string iFileName) { + std::ifstream lFile(iFileName.c_str()); + assert(lFile.is_open()); + + int lTrigIndex = -1; // bacon trigger bits index + int lTrigObjIndex = -1; // bacon trigger object bits index + std::string lLastTrigName = ""; // keep track of when new trigger name is encountered + int lLastLeg = -1; // keep track of when new trigger object leg is encountered + + while(lFile.good()) { + std::string pTrigName; + std::string pFilterName; + int pLeg; + + lFile >> pTrigName; + + // allow C++ style comments in HLT file + if(pTrigName.find("//") != std::string::npos) { + lFile.ignore(std::numeric_limits::max(), '\n'); + continue; + } + + // ignore empty lines + if(pTrigName == "") continue; + + lFile >> pFilterName >> pLeg; + + if(lLastTrigName != pTrigName) { + lTrigIndex++; + fRecords.push_back(baconhep::TriggerRecord(pTrigName,lTrigIndex)); + lTrigObjIndex++; + + } else if(lLastLeg != pLeg) { + lTrigObjIndex++; + } + + fRecords.back().objectMap.push_back(std::pair(pFilterName,lTrigObjIndex)); + lLastTrigName = pTrigName; + lLastLeg = pLeg; + + // ignore all trailing stuff + lFile.ignore(std::numeric_limits::max(), '\n'); + } +} + +//-------------------------------------------------------------------------------------------------- +int TTrigger::getTriggerBit(const std::string iName) const { + int lId = -1; + for(unsigned int i0 = 0; i0 < fRecords.size(); i0++) { + if(iName == fRecords[i0].hltPattern) lId = i0; + } + if(lId == -1) edm::LogWarning("ZCounting") << "=== Missing Trigger ==" << iName << std::endl; + return lId; +} + +//-------------------------------------------------------------------------------------------------- +int TTrigger::getTriggerObjectBit(const std::string iName, const int iLeg) const { + int lId = getTriggerBit(iName); + if(lId == -1) return -1; + + // + // Assumes trigger object legs are numbered 1,2,3, etc. + // The logic below looks for index changes in the objectMap. + // For example, if looking for the trigger object bit for leg 3, looping through the objectMap + // list one needs to find the 3rd unique object bit associated with the trigger record. + // + if(iLeg==1) { + return fRecords[lId].objectMap[0].second; + } + int tmp = 1; + unsigned int lastObjIndex = fRecords[lId].objectMap[0].second; + for(unsigned int i0 = 1; i0 < fRecords[lId].objectMap.size(); i0++) { + unsigned int newId = fRecords[lId].objectMap[i0].second; + if(lastObjIndex != newId) { + lastObjIndex = newId; + tmp++; + if(tmp==iLeg) { + return fRecords[lId].objectMap[i0].second; + } + } + } + + return -1; +} + +//-------------------------------------------------------------------------------------------------- +int TTrigger::getTriggerObjectBit(const std::string iName, const std::string iObjName) const { + int lId = getTriggerBit(iName); + if(lId == -1) return -1; + + for(unsigned int i0 = 0; i0 < fRecords[lId].objectMap.size(); i0++) { + if(iObjName != fRecords[lId].objectMap[i0].first) continue; + return fRecords[lId].objectMap[i0].second; + } + + return -1; +} + +//-------------------------------------------------------------------------------------------------- +bool TTrigger::pass(const std::string iName, const TriggerBits &iTrig) const { + int lId = getTriggerBit(iName); + if(lId == -1) return false; + + return iTrig[lId]; +} + +//-------------------------------------------------------------------------------------------------- +bool TTrigger::passObj(const std::string iName, const int iLeg, const TriggerObjects &iTrigObj) const { + int lId = getTriggerObjectBit(iName,iLeg); + if(lId == -1) return false; + + return iTrigObj[lId]; +} + +//-------------------------------------------------------------------------------------------------- +bool TTrigger::passObj(const std::string iName, const std::string iObjName, const TriggerObjects &iTrigObj) const { + int lId = getTriggerObjectBit(iName,iObjName); + if(lId == -1) return false; + + return iTrigObj[lId]; +} diff --git a/DQMOffline/LumiZCounting/src/TriggerTools.cc b/DQMOffline/LumiZCounting/src/TriggerTools.cc new file mode 100644 index 0000000000000..ff0794b3b973f --- /dev/null +++ b/DQMOffline/LumiZCounting/src/TriggerTools.cc @@ -0,0 +1,39 @@ +#include "DQMOffline/LumiZCounting/interface/TriggerTools.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "DataFormats/Math/interface/deltaR.h" +#include + +using namespace baconhep; + +//-------------------------------------------------------------------------------------------------- +TriggerObjects TriggerTools::matchHLT(const double eta, const double phi, + const std::vector& triggerRecords, + const trigger::TriggerEvent& triggerEvent) +{ + const double dRMax = 0.2; + + TriggerObjects matchBits; + for(unsigned int irec=0; irec