diff --git a/DQMOffline/Trigger/plugins/BTVHLTOfflineSource.cc b/DQMOffline/Trigger/plugins/BTVHLTOfflineSource.cc index c1f435eae2004..464127097b77f 100644 --- a/DQMOffline/Trigger/plugins/BTVHLTOfflineSource.cc +++ b/DQMOffline/Trigger/plugins/BTVHLTOfflineSource.cc @@ -172,6 +172,37 @@ class BTVHLTOfflineSource : public DQMEDAnalyzer { MonitorElement* h_3d_ip_distance = nullptr; MonitorElement* h_3d_ip_error = nullptr; MonitorElement* h_3d_ip_sig = nullptr; + + //NEW + MonitorElement* h_jetNSecondaryVertices = nullptr; + MonitorElement* h_jet_pt = nullptr; + MonitorElement* h_jet_eta = nullptr; + MonitorElement* h_trackSumJetEtRatio = nullptr; + MonitorElement* h_trackSip2dValAboveCharm = nullptr; + MonitorElement* h_trackSip2dSigAboveCharm = nullptr; + MonitorElement* h_trackSip3dValAboveCharm = nullptr; + MonitorElement* h_trackSip3dSigAboveCharm = nullptr; + MonitorElement* h_jetNSelectedTracks = nullptr; + MonitorElement* h_jetNTracksEtaRel = nullptr; + MonitorElement* h_vertexCategory = nullptr; + MonitorElement* h_trackSumJetDeltaR = nullptr; + + MonitorElement* h_trackJetDistVal = nullptr; + MonitorElement* h_trackPtRel = nullptr; + MonitorElement* h_trackDeltaR = nullptr; + MonitorElement* h_trackPtRatio = nullptr; + MonitorElement* h_trackSip3dSig = nullptr; + MonitorElement* h_trackSip2dSig = nullptr; + MonitorElement* h_trackDecayLenVal = nullptr; + MonitorElement* h_trackEtaRel = nullptr; + + MonitorElement* h_vertexEnergyRatio = nullptr; + MonitorElement* h_vertexJetDeltaR = nullptr; + MonitorElement* h_flightDistance2dVal = nullptr; + MonitorElement* h_flightDistance2dSig = nullptr; + MonitorElement* h_flightDistance3dVal = nullptr; + MonitorElement* h_flightDistance3dSig = nullptr; + ObjME OnlineTrkEff_Pt; ObjME OnlineTrkEff_Eta; ObjME OnlineTrkEff_3d_ip_distance; @@ -484,7 +515,7 @@ void BTVHLTOfflineSource::analyze(const edm::Event& iEvent, const edm::EventSetu v.PVz_HLTMinusRECO->Fill(VertexHandler->begin()->z() - offlineVertexHandler->begin()->z()); } } - } // caloTagsValid + } // caloTagsValid or PFTagsValid // specific to Calo b-tagging if (caloTags.isValid() && v.getTriggerType() == "Calo" && !caloTags->empty()) { @@ -521,21 +552,99 @@ void BTVHLTOfflineSource::analyze(const edm::Event& iEvent, const edm::EventSetu // n secondary vertices and n selected tracks for (const auto& tagVar : tagVars.getList(reco::btau::jetNSecondaryVertices, false)) { + v.h_jetNSecondaryVertices->Fill(tagVar); v.n_vtx->Fill(tagVar); } + for (const auto& tagVar : tagVars.getList(reco::btau::jetNSelectedTracks, false)) { v.n_sel_tracks->Fill(tagVar); + v.h_jetNSelectedTracks->Fill(tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::jetPt, false)) { + v.h_jet_pt->Fill(tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::jetEta, false)) { + v.h_jet_eta->Fill(tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::trackSumJetEtRatio, false)) { + v.h_trackSumJetEtRatio->Fill(tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::trackSumJetDeltaR, false)) { + v.h_trackSumJetDeltaR->Fill(tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::vertexCategory, false)) { + v.h_vertexCategory->Fill(tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::trackSip2dValAboveCharm, false)) { + v.h_trackSip2dValAboveCharm->Fill(tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::trackSip2dSigAboveCharm, false)) { + v.h_trackSip2dSigAboveCharm->Fill(tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::trackSip3dValAboveCharm, false)) { + v.h_trackSip3dValAboveCharm->Fill(tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::trackSip3dSigAboveCharm, false)) { + v.h_trackSip3dSigAboveCharm->Fill(tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::jetNTracksEtaRel, false)) { + v.h_jetNTracksEtaRel->Fill(tagVar); } // impact parameter + // and new info const auto& trackSip3dVal = tagVars.getList(reco::btau::trackSip3dVal, false); const auto& trackSip3dSig = tagVars.getList(reco::btau::trackSip3dSig, false); + const auto& trackJetDistVal = tagVars.getList(reco::btau::trackJetDistVal, false); + const auto& trackPtRel = tagVars.getList(reco::btau::trackPtRel, false); + const auto& trackSip2dSig = tagVars.getList(reco::btau::trackSip2dSig, false); + const auto& trackDeltaR = tagVars.getList(reco::btau::trackDeltaR, false); + const auto& trackPtRatio = tagVars.getList(reco::btau::trackPtRatio, false); + const auto& trackDecayLenVal = tagVars.getList(reco::btau::trackDecayLenVal, false); + const auto& trackEtaRel = tagVars.getList(reco::btau::trackEtaRel, false); + + for (unsigned i_trk = 0; i_trk < trackEtaRel.size(); i_trk++) { + v.h_trackEtaRel->Fill(trackEtaRel[i_trk]); + } + + for (unsigned i_trk = 0; i_trk < trackJetDistVal.size(); i_trk++) { + v.h_trackJetDistVal->Fill(trackJetDistVal[i_trk]); + } + + for (unsigned i_trk = 0; i_trk < trackPtRel.size(); i_trk++) { + v.h_trackPtRel->Fill(trackPtRel[i_trk]); + } + + for (unsigned i_trk = 0; i_trk < trackDeltaR.size(); i_trk++) { + v.h_trackDeltaR->Fill(trackDeltaR[i_trk]); + } + + for (unsigned i_trk = 0; i_trk < trackPtRatio.size(); i_trk++) { + v.h_trackPtRatio->Fill(trackPtRatio[i_trk]); + } + + for (unsigned i_trk = 0; i_trk < trackDecayLenVal.size(); i_trk++) { + v.h_trackDecayLenVal->Fill(trackDecayLenVal[i_trk]); + } + for (unsigned i_trk = 0; i_trk < trackSip3dVal.size(); i_trk++) { float val = trackSip3dVal[i_trk]; float sig = trackSip3dSig[i_trk]; v.h_3d_ip_distance->Fill(val); v.h_3d_ip_error->Fill(val / sig); v.h_3d_ip_sig->Fill(sig); + + v.h_trackSip2dSig->Fill(trackSip2dSig[i_trk]); } // vertex mass and tracks per vertex @@ -546,6 +655,30 @@ void BTVHLTOfflineSource::analyze(const edm::Event& iEvent, const edm::EventSetu v.n_vtx_trks->Fill(tagVar); } + for (const auto& tagVar : tagVars.getList(reco::btau::vertexEnergyRatio, false)) { + v.h_vertexEnergyRatio->Fill(tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::vertexJetDeltaR, false)) { + v.h_vertexJetDeltaR->Fill(tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::flightDistance2dVal, false)) { + v.h_flightDistance2dVal->Fill(tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::flightDistance2dSig, false)) { + v.h_flightDistance2dSig->Fill(tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::flightDistance3dVal, false)) { + v.h_flightDistance3dVal->Fill(tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::flightDistance3dSig, false)) { + v.h_flightDistance3dSig->Fill(tagVar); + } + // // track N total/pixel hits // for (const auto & tagVar : tagVars.getList(reco::btau::trackNPixelHits, false)) { // v.n_pixel_hits->Fill(tagVar);} @@ -589,7 +722,7 @@ void BTVHLTOfflineSource::analyze(const edm::Event& iEvent, const edm::EventSetu // } // } // } - } + } //end paths loop } std::vector BTVHLTOfflineSource::getOfflineBTagTracks(float hltJetEta, @@ -759,6 +892,111 @@ void BTVHLTOfflineSource::bookHistograms(DQMStore::IBooker& iBooker, edm::Run co title = "3D IP significance of tracks (cm)" + trigPath; v.h_3d_ip_sig = iBooker.book1D(histoname.c_str(), title.c_str(), 40, -40, 40); + //new + histoname = "jetNSecondaryVertices"; + title = "jet N Secondary Vertices" + trigPath; + v.h_jetNSecondaryVertices = iBooker.book1D(histoname.c_str(), title.c_str(), 10, -0.5, 9.5); + + histoname = "jet_pt"; + title = "jet pt" + trigPath; + v.h_jet_pt = iBooker.book1D(histoname.c_str(), title.c_str(), 100, -0.1, 100); + + histoname = "jet_eta"; + title = "jet eta" + trigPath; + v.h_jet_eta = iBooker.book1D(histoname.c_str(), title.c_str(), 100, -2.5, 2.5); + + histoname = "trackSumJetEtRatio"; + title = "trackSumJetEtRatio" + trigPath; + v.h_trackSumJetEtRatio = iBooker.book1D(histoname.c_str(), title.c_str(), 100, -0.1, 1.5); + + histoname = "trackSip2dValAboveCharm"; + title = "trackSip2dSigAboveCharm" + trigPath; + v.h_trackSip2dSigAboveCharm = iBooker.book1D(histoname.c_str(), title.c_str(), 100, -0.2, 0.2); + + histoname = "trackSip2dSigAboveCharm"; + title = "trackSip2dSigAboveCharm" + trigPath; + v.h_trackSip2dValAboveCharm = iBooker.book1D(histoname.c_str(), title.c_str(), 100, -50, 50); + + histoname = "trackSip3dValAboveCharm"; + title = "trackSip3dValAboveCharm" + trigPath; + v.h_trackSip3dValAboveCharm = iBooker.book1D(histoname.c_str(), title.c_str(), 100, -0.2, 0.2); + + histoname = "trackSip3dSigAboveCharm"; + title = "trackSip3dSigAboveCharm" + trigPath; + v.h_trackSip3dSigAboveCharm = iBooker.book1D(histoname.c_str(), title.c_str(), 100, -50, 50); + + histoname = "jetNSelectedTracks"; + title = "jet N Selected Tracks" + trigPath; + v.h_jetNSelectedTracks = iBooker.book1D(histoname.c_str(), title.c_str(), 42, -1.5, 40.5); + + histoname = "jetNTracksEtaRel"; + title = "jetNTracksEtaRel" + trigPath; + v.h_jetNTracksEtaRel = iBooker.book1D(histoname.c_str(), title.c_str(), 42, -1.5, 40.5); + + histoname = "vertexCategory"; + title = "vertex category" + trigPath; + v.h_vertexCategory = iBooker.book1D(histoname.c_str(), title.c_str(), 4, -1.5, 2.5); + + histoname = "trackSumJetDeltaR"; + title = "trackSumJetDeltaR" + trigPath; + v.h_trackSumJetDeltaR = iBooker.book1D(histoname.c_str(), title.c_str(), 100, -0.1, 0.35); + + //new 2 below + histoname = "trackJetDistVal"; + title = "trackJetDistVal" + trigPath; + v.h_trackJetDistVal = iBooker.book1D(histoname.c_str(), title.c_str(), 100, -1, 0.01); + + histoname = "trackPtRel"; + title = "track pt rel" + trigPath; + v.h_trackPtRel = iBooker.book1D(histoname.c_str(), title.c_str(), 100, -0.1, 7); + + histoname = "trackDeltaR"; + title = "trackDeltaR" + trigPath; + v.h_trackDeltaR = iBooker.book1D(histoname.c_str(), title.c_str(), 160, -0.05, .47); + + histoname = "trackPtRatio"; + title = "trackPtRatio" + trigPath; + v.h_trackPtRatio = iBooker.book1D(histoname.c_str(), title.c_str(), 100, -0.01, 0.3); + + histoname = "trackSip2dSig"; + title = "trackSip2dSig" + trigPath; + v.h_trackSip2dSig = iBooker.book1D(histoname.c_str(), title.c_str(), 100, -55, 55); + + histoname = "trackDecayLenVal"; + title = "trackDecayLenVal" + trigPath; + v.h_trackDecayLenVal = iBooker.book1D(histoname.c_str(), title.c_str(), 100, -0.1, 22); + + histoname = "trackEtaRel"; + title = "trackEtaRel" + trigPath; + v.h_trackEtaRel = iBooker.book1D(histoname.c_str(), title.c_str(), 31, 0, 30); + + //new 3 below + histoname = "vertexEnergyRatio"; + title = "vertexEnergyRatio" + trigPath; + v.h_vertexEnergyRatio = iBooker.book1D(histoname.c_str(), title.c_str(), 100, -0.1, 3); + + histoname = "vertexJetDeltaR"; + title = "vertexJetDeltaR" + trigPath; + v.h_vertexJetDeltaR = iBooker.book1D(histoname.c_str(), title.c_str(), 100, -0.01, 0.4); + + histoname = "flightDistance2dVal"; + title = "flightDistance2dVal" + trigPath; + v.h_flightDistance2dVal = iBooker.book1D(histoname.c_str(), title.c_str(), 100, -0.1, 5); + + histoname = "flightDistance2dSig"; + title = "flightDistance2dSig" + trigPath; + v.h_flightDistance2dSig = iBooker.book1D(histoname.c_str(), title.c_str(), 100, -10, 150); + + histoname = "flightDistance3dVal"; + title = "flightDistance3dVal" + trigPath; + v.h_flightDistance3dVal = iBooker.book1D(histoname.c_str(), title.c_str(), 100, -0.1, 5); + + histoname = "flightDistance3dSig"; + title = "flightDistance3dSig" + trigPath; + v.h_flightDistance3dSig = iBooker.book1D(histoname.c_str(), title.c_str(), 100, -10, 150); + + //end new + histoname = "OnlineTrkEff_Pt"; title = "Relative Online Trk Efficiency vs Pt " + trigPath; v.bookME(iBooker, v.OnlineTrkEff_Pt, histoname, title, 50, -0.5, 20.); diff --git a/DQMOffline/Trigger/plugins/BTagAndProbe.cc b/DQMOffline/Trigger/plugins/BTagAndProbe.cc new file mode 100644 index 0000000000000..fe6b322e85fdd --- /dev/null +++ b/DQMOffline/Trigger/plugins/BTagAndProbe.cc @@ -0,0 +1,1135 @@ +#include "DQMServices/Core/interface/DQMStore.h" +#include "DQMServices/Core/interface/DQMEDAnalyzer.h" +#include "FWCore/Utilities/interface/EDGetToken.h" +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/Registry.h" +#include "FWCore/Utilities/interface/transform.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "CommonTools/Utils/interface/StringCutObjectSelector.h" +#include "CommonTools/TriggerUtils/interface/GenericTriggerEventFlag.h" +#include "DataFormats/Math/interface/deltaR.h" +#include "DataFormats/Common/interface/ValueMap.h" +#include "DataFormats/VertexReco/interface/VertexFwd.h" +#include "DataFormats/MuonReco/interface/Muon.h" +#include "DataFormats/MuonReco/interface/MuonFwd.h" +#include "DataFormats/GsfTrackReco/interface/GsfTrack.h" +#include "DataFormats/EgammaCandidates/interface/GsfElectronFwd.h" +#include "DataFormats/EgammaCandidates/interface/Photon.h" +#include "DataFormats/EgammaCandidates/interface/PhotonFwd.h" +#include "DataFormats/JetReco/interface/PFJet.h" +#include "DataFormats/JetReco/interface/PFJetCollection.h" +#include "DataFormats/BTauReco/interface/JetTag.h" +#include "DataFormats/METReco/interface/PFMET.h" +#include "DataFormats/METReco/interface/PFMETCollection.h" +#include "DQMOffline/Trigger/plugins/TriggerDQMBase.h" + +//Tagging variables +#include "DataFormats/BTauReco/interface/ShallowTagInfo.h" + +#include +#include +#include +#include + +class BTagAndProbe : public DQMEDAnalyzer, public TriggerDQMBase { +public: + typedef dqm::reco::MonitorElement MonitorElement; + typedef dqm::reco::DQMStore DQMStore; + + BTagAndProbe(const edm::ParameterSet&); + ~BTagAndProbe() throw() override; + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + +protected: + void bookHistograms(DQMStore::IBooker&, edm::Run const&, edm::EventSetup const&) override; + void analyze(edm::Event const& iEvent, edm::EventSetup const& iSetup) override; + + struct JetRefCompare { + inline bool operator()(const edm::RefToBase& j1, const edm::RefToBase& j2) const { + return (j1.id() < j2.id()) || ((j1.id() == j2.id()) && (j1.key() < j2.key())); + } + }; + typedef std::map, float, JetRefCompare> JetTagMap; + +private: + const std::string folderName_; + + const bool requireValidHLTPaths_; + bool hltPathsAreValid_; + + const edm::EDGetTokenT vtxToken_; + const edm::EDGetTokenT muoToken_; + const edm::EDGetTokenT > eleToken_; + const edm::EDGetTokenT > elecIDToken_; + const std::vector > jetTagTokens_; + + //Tag info + const edm::EDGetTokenT > shallowTagInfosToken_; + struct PVcut { + double dxy; + double dz; + + PVcut(double dxy_, double dz_) { + dxy = dxy_; + dz = dz_; + } + }; + + // for the tag and probe + MonitorElement* h_nElectrons1 = nullptr; + MonitorElement* h_nElectrons2 = nullptr; + MonitorElement* h_nElectrons3 = nullptr; + MonitorElement* h_nElectrons4 = nullptr; + MonitorElement* h_nElectrons5 = nullptr; + MonitorElement* h_nElectrons6 = nullptr; + MonitorElement* h_nElectrons7 = nullptr; + MonitorElement* h_nElectrons8 = nullptr; + + MonitorElement* h_nMuons1 = nullptr; + MonitorElement* h_nMuons2 = nullptr; + MonitorElement* h_nMuons3 = nullptr; + MonitorElement* h_nMuons4 = nullptr; + MonitorElement* h_nMuons5 = nullptr; + MonitorElement* h_nMuons6 = nullptr; + MonitorElement* h_nMuons7 = nullptr; + + MonitorElement* h_nJets = nullptr; + MonitorElement* h_btagVal = nullptr; + MonitorElement* h_btagVal2 = nullptr; + MonitorElement* h_btagVal_pp = nullptr; + MonitorElement* h_btagVal_pf = nullptr; + MonitorElement* h_btagVal_pa = nullptr; + + MonitorElement* h_nJets1 = nullptr; + MonitorElement* h_nJets2 = nullptr; + MonitorElement* h_nJets3 = nullptr; + MonitorElement* h_nJets4 = nullptr; + MonitorElement* h_nJets5 = nullptr; + MonitorElement* h_nJets6 = nullptr; + MonitorElement* h_nJets7 = nullptr; + MonitorElement* h_nJets8 = nullptr; + MonitorElement* h_nJets9 = nullptr; + MonitorElement* h_nJets10 = nullptr; + MonitorElement* h_nJets11 = nullptr; + MonitorElement* h_nJets12 = nullptr; + + //muon pt + MonitorElement* h_Muons1_pt = nullptr; + MonitorElement* h_Muons2_pt = nullptr; + MonitorElement* h_Muons3_pt = nullptr; + MonitorElement* h_Muons4_pt = nullptr; + MonitorElement* h_Muons5_pt = nullptr; + + //muon eta + MonitorElement* h_Muons1_eta = nullptr; + MonitorElement* h_Muons2_eta = nullptr; + MonitorElement* h_Muons3_eta = nullptr; + MonitorElement* h_Muons4_eta = nullptr; + MonitorElement* h_Muons5_eta = nullptr; + + //electron pt + MonitorElement* h_Electrons1_pt = nullptr; + MonitorElement* h_Electrons2_pt = nullptr; + MonitorElement* h_Electrons3_pt = nullptr; + MonitorElement* h_Electrons4_pt = nullptr; + + //electron eta + MonitorElement* h_Electrons1_eta = nullptr; + MonitorElement* h_Electrons2_eta = nullptr; + MonitorElement* h_Electrons3_eta = nullptr; + MonitorElement* h_Electrons4_eta = nullptr; + + MonitorElement* cutFlow = nullptr; + + // new for tnp + ObjME jetNSecondaryVertices_; + ObjME jet_tagVal_; + ObjME jet_pt_; + ObjME jet_eta_; + ObjME trackSumJetEtRatio_; + ObjME trackSip2dValAboveCharm_; + ObjME trackSip2dSigAboveCharm_; + ObjME trackSip3dValAboveCharm_; + ObjME trackSip3dSigAboveCharm_; + ObjME jetNTracksEtaRel_; + ObjME jetNSelectedTracks_; + ObjME vertexCategory_; + ObjME trackSumJetDeltaR_; + + ObjME trackJetDistVal_; + ObjME trackPtRel_; + ObjME trackDeltaR_; + ObjME trackPtRatio_; + ObjME trackSip3dSig_; + ObjME trackSip2dSig_; + ObjME trackDecayLenVal_; + ObjME trackEtaRel_; + + ObjME vertexMass_; + ObjME vertexNTracks_; + ObjME vertexEnergyRatio_; + ObjME vertexJetDeltaR_; + ObjME flightDistance2dVal_; + ObjME flightDistance3dVal_; + ObjME flightDistance2dSig_; + ObjME flightDistance3dSig_; + + std::unique_ptr genTriggerEventFlag_; + + StringCutObjectSelector jetSelection_; + StringCutObjectSelector eleSelection_; + StringCutObjectSelector muoSelection_; + + StringCutObjectSelector vtxSelection_; + + StringCutObjectSelector bjetSelection_; + + const unsigned int nelectrons_; + const unsigned int nmuons_; + const double leptJetDeltaRmin_; + const double bJetDeltaEtaMax_; + const unsigned int nbjets_; + const double workingpoint_; + const std::string btagalgoName_; + const PVcut lepPVcuts_; + const bool applyLeptonPVcuts_; + const bool debug_; + + const bool applyMETcut_ = false; +}; + +BTagAndProbe::BTagAndProbe(const edm::ParameterSet& iConfig) + : folderName_(iConfig.getParameter("FolderName")), + requireValidHLTPaths_(iConfig.getParameter("requireValidHLTPaths")), + hltPathsAreValid_(false), + vtxToken_(mayConsume(iConfig.getParameter("vertices"))), + muoToken_(mayConsume(iConfig.getParameter("muons"))), + eleToken_(mayConsume >(iConfig.getParameter("electrons"))), + elecIDToken_(consumes >(iConfig.getParameter("elecID"))), + jetTagTokens_( + edm::vector_transform(iConfig.getParameter >("btagAlgos"), + [this](edm::InputTag const& tag) { return mayConsume(tag); })), + shallowTagInfosToken_( + consumes >(edm::InputTag("hltDeepCombinedSecondaryVertexBJetTagsInfos"))), + genTriggerEventFlag_(new GenericTriggerEventFlag( + iConfig.getParameter("genericTriggerEventPSet"), consumesCollector(), *this)), + jetSelection_(iConfig.getParameter("jetSelection")), + eleSelection_(iConfig.getParameter("eleSelection")), + muoSelection_(iConfig.getParameter("muoSelection")), + vtxSelection_(iConfig.getParameter("vertexSelection")), + bjetSelection_(iConfig.getParameter("bjetSelection")), + nelectrons_(iConfig.getParameter("nelectrons")), + nmuons_(iConfig.getParameter("nmuons")), + leptJetDeltaRmin_(iConfig.getParameter("leptJetDeltaRmin")), + bJetDeltaEtaMax_(iConfig.getParameter("bJetDeltaEtaMax")), + nbjets_(iConfig.getParameter("nbjets")), + workingpoint_(iConfig.getParameter("workingpoint")), + lepPVcuts_(((iConfig.getParameter("leptonPVcuts")).getParameter("dxy")), ((iConfig.getParameter("leptonPVcuts")).getParameter("dz"))), + applyLeptonPVcuts_(iConfig.getParameter("applyLeptonPVcuts")), + debug_(iConfig.getParameter("debug")) + { + ObjME empty; +} + +BTagAndProbe::~BTagAndProbe() throw() { + if (genTriggerEventFlag_) + genTriggerEventFlag_.reset(); +} + +void BTagAndProbe::bookHistograms(DQMStore::IBooker& ibooker, edm::Run const& iRun, edm::EventSetup const& iSetup) { + std::string histname, histtitle; + std::string title; + std::string currentFolder = folderName_; + ibooker.setCurrentFolder(currentFolder); + + histname = "cutFlow"; + title = "cutFlow"; + cutFlow = ibooker.book1D(histname.c_str(), title.c_str(), 20, 1, 21); + cutFlow->setBinLabel(1, "all"); + + // Initialize the GenericTriggerEventFlag + if (genTriggerEventFlag_ && genTriggerEventFlag_->on()) + genTriggerEventFlag_->initRun(iRun, iSetup); + + // check if every HLT path specified in numerator and denominator has a valid match in the HLT Menu + hltPathsAreValid_ = (genTriggerEventFlag_ && genTriggerEventFlag_->on() && + genTriggerEventFlag_->allHLTPathsAreValid()); + + // if valid HLT paths are required, + // create DQM outputs only if all paths are valid + if (requireValidHLTPaths_ && (!hltPathsAreValid_)) { + return; + } + + if (debug_) { + histname = "nElectrons1"; + title = "number of electrons1"; + h_nElectrons1 = ibooker.book1D(histname.c_str(), title.c_str(), 10, 0, 10); + + histname = "nElectrons2"; + title = "number of electrons2"; + h_nElectrons2 = ibooker.book1D(histname.c_str(), title.c_str(), 10, 0, 10); + + histname = "nElectrons3"; + title = "number of electrons3"; + h_nElectrons3 = ibooker.book1D(histname.c_str(), title.c_str(), 10, 0, 10); + + histname = "nElectrons4"; + title = "number of electrons4"; + h_nElectrons4 = ibooker.book1D(histname.c_str(), title.c_str(), 10, 0, 10); + + histname = "nElectrons5"; + title = "number of electrons5"; + h_nElectrons5 = ibooker.book1D(histname.c_str(), title.c_str(), 10, 0, 10); + + histname = "nElectrons6"; + title = "number of electrons6"; + h_nElectrons6 = ibooker.book1D(histname.c_str(), title.c_str(), 10, 0, 10); + + histname = "nElectrons7"; + title = "number of electrons7"; + h_nElectrons7 = ibooker.book1D(histname.c_str(), title.c_str(), 10, 0, 10); + + histname = "nElectrons8"; + title = "number of electrons8"; + h_nElectrons8 = ibooker.book1D(histname.c_str(), title.c_str(), 10, 0, 10); + + histname = "nMuons1"; + title = "number of muons1"; + h_nMuons1 = ibooker.book1D(histname.c_str(), title.c_str(), 10, 0, 10); + + histname = "nMuons2"; + title = "number of muons2"; + h_nMuons2 = ibooker.book1D(histname.c_str(), title.c_str(), 10, 0, 10); + + histname = "nMuons3"; + title = "number of muons3"; + h_nMuons3 = ibooker.book1D(histname.c_str(), title.c_str(), 10, 0, 10); + + histname = "nMuons4"; + title = "number of muons4"; + h_nMuons4 = ibooker.book1D(histname.c_str(), title.c_str(), 10, 0, 10); + + histname = "nMuons5"; + title = "number of muons5"; + h_nMuons5 = ibooker.book1D(histname.c_str(), title.c_str(), 10, 0, 10); + + histname = "nMuons6"; + title = "number of muons6"; + h_nMuons6 = ibooker.book1D(histname.c_str(), title.c_str(), 10, 0, 10); + + histname = "nMuons7"; + title = "number of muons7"; + h_nMuons7 = ibooker.book1D(histname.c_str(), title.c_str(), 10, 0, 10); + + //muon pt + histname = "Muons1_pt"; + title = "muons1 pt"; + h_Muons1_pt = ibooker.book1D(histname.c_str(), title.c_str(), 50, 0, 100); + + histname = "Muons2_pt"; + title = "muons2 pt"; + h_Muons2_pt = ibooker.book1D(histname.c_str(), title.c_str(), 50, 0, 100); + + histname = "Muons3_pt"; + title = "muons3 pt"; + h_Muons3_pt = ibooker.book1D(histname.c_str(), title.c_str(), 50, 0, 100); + + histname = "Muons4_pt"; + title = "muons4 pt"; + h_Muons4_pt = ibooker.book1D(histname.c_str(), title.c_str(), 50, 0, 50); + + histname = "Muons5_pt"; + title = "muons5 pt"; + h_Muons5_pt = ibooker.book1D(histname.c_str(), title.c_str(), 50, 0, 50); + + //muon eta + histname = "Muons1_eta"; + title = "muons1 eta"; + h_Muons1_eta = ibooker.book1D(histname.c_str(), title.c_str(), 10, -5, 5); + + histname = "Muons2_eta"; + title = "muons2 eta"; + h_Muons2_eta = ibooker.book1D(histname.c_str(), title.c_str(), 10, -5, 5); + + histname = "Muons3_eta"; + title = "muons3 eta"; + h_Muons3_eta = ibooker.book1D(histname.c_str(), title.c_str(), 10, -5, 5); + + histname = "Muons4_eta"; + title = "muons4 eta"; + h_Muons4_eta = ibooker.book1D(histname.c_str(), title.c_str(), 10, -2.50, 2.50); + + histname = "Muons5_eta"; + title = "muons5 eta"; + h_Muons5_eta = ibooker.book1D(histname.c_str(), title.c_str(), 10, -2.50, 2.50); + + //electron pt + histname = "Electrons1_pt"; + title = "electrons1 pt"; + h_Electrons1_pt = ibooker.book1D(histname.c_str(), title.c_str(), 50, 0, 100); + + histname = "Electrons2_pt"; + title = "Electrons2 pt"; + h_Electrons2_pt = ibooker.book1D(histname.c_str(), title.c_str(), 50, 0, 100); + + histname = "Electrons3_pt"; + title = "Electrons3 pt"; + h_Electrons3_pt = ibooker.book1D(histname.c_str(), title.c_str(), 50, 0, 100); + + histname = "Electrons4_pt"; + title = "Electrons4 pt"; + h_Electrons4_pt = ibooker.book1D(histname.c_str(), title.c_str(), 50, 0, 100); + + //electron eta + histname = "Electrons1_eta"; + title = "Electrons1 eta"; + h_Electrons1_eta = ibooker.book1D(histname.c_str(), title.c_str(), 10, -2.50, 2.50); + + histname = "Electrons2_eta"; + title = "Electrons2 eta"; + h_Electrons2_eta = ibooker.book1D(histname.c_str(), title.c_str(), 10, -2.50, 2.50); + + histname = "Electrons3_eta"; + title = "Electrons3 eta"; + h_Electrons3_eta = ibooker.book1D(histname.c_str(), title.c_str(), 10, -2.50, 2.50); + + histname = "Electrons4_eta"; + title = "Electrons4 eta"; + h_Electrons4_eta = ibooker.book1D(histname.c_str(), title.c_str(), 10, -2.50, 2.50); + + //nJets + histname = "nJets1"; + title = "number of jets1"; + h_nJets1 = ibooker.book1D(histname.c_str(), title.c_str(), 20, 0, 20); + + histname = "nJets2"; + title = "number of jets2"; + h_nJets2 = ibooker.book1D(histname.c_str(), title.c_str(), 20, 0, 20); + + histname = "nJets3"; + title = "number of jets3"; + h_nJets3 = ibooker.book1D(histname.c_str(), title.c_str(), 20, 0, 20); + + histname = "nJets4"; + title = "number of jets4"; + h_nJets4 = ibooker.book1D(histname.c_str(), title.c_str(), 20, 0, 20); + + histname = "nJets5"; + title = "number of jets5"; + h_nJets5 = ibooker.book1D(histname.c_str(), title.c_str(), 20, 0, 20); + + histname = "nJets6"; + title = "number of jets6"; + h_nJets6 = ibooker.book1D(histname.c_str(), title.c_str(), 20, 0, 20); + + histname = "nJets7"; + title = "number of jets7"; + h_nJets7 = ibooker.book1D(histname.c_str(), title.c_str(), 20, 0, 20); + + histname = "nJets8"; + title = "number of jets8"; + h_nJets8 = ibooker.book1D(histname.c_str(), title.c_str(), 20, 0, 20); + + histname = "nJets9"; + title = "number of jets9"; + h_nJets9 = ibooker.book1D(histname.c_str(), title.c_str(), 20, 0, 20); + + histname = "nJets10"; + title = "number of jets10"; + h_nJets10 = ibooker.book1D(histname.c_str(), title.c_str(), 20, 0, 20); + + histname = "nJets11"; + title = "number of jets11"; + h_nJets11 = ibooker.book1D(histname.c_str(), title.c_str(), 20, 0, 20); + + histname = "nJets12"; + title = "number of jets12"; + h_nJets12 = ibooker.book1D(histname.c_str(), title.c_str(), 20, 0, 20); + } + + histname = "btagVal"; + title = "btagVal"; + h_btagVal = ibooker.book1D(histname.c_str(), title.c_str(), 10, 0, 1); + + histname = "btagVal2"; + title = "btagVal"; + h_btagVal2 = ibooker.book1D(histname.c_str(), title.c_str(), 10, 0, 1); + + histname = "btagVal_probe_pass"; + title = "btagVal"; + h_btagVal_pp = ibooker.book1D(histname.c_str(), title.c_str(), 10, 0, 1); + + histname = "btagVal_probe_fail"; + title = "btagVal"; + h_btagVal_pf = ibooker.book1D(histname.c_str(), title.c_str(), 10, 0, 1); + + histname = "btagVal_probe_all"; + title = "btagVal"; + h_btagVal_pa = ibooker.book1D(histname.c_str(), title.c_str(), 10, 0, 1); + + histname = "jetNSecondaryVertices"; + title = "jetNSecondaryVertices"; + bookME(ibooker, jetNSecondaryVertices_, histname, title, 10, -0.5, 9.5); + setMETitle(jetNSecondaryVertices_, "jetNSecondaryVertices", "Entries"); + + histname = "jet_bTagVal"; + title = "jet bTag Val"; + bookME(ibooker, jet_tagVal_, histname, title, 10, 0., 1.); + setMETitle(jet_tagVal_, "jet bTag Val", "Entries"); + + histname = "jet_pt"; + title = "jet p_{T}"; + bookME(ibooker, jet_pt_, histname, title, 100, -0.1, 400.); + setMETitle(jet_pt_, "jet pt", "Entries"); + + histname = "jet_eta"; + title = "jet #eta"; + bookME(ibooker, jet_eta_, histname, title, 20, -2.5, 2.5); + setMETitle(jet_eta_, "#eta", "Entries"); + + histname = "jetNSecondaryVertices"; + title = "jet NSecondary Vertices"; + bookME(ibooker, jetNSecondaryVertices_, histname, title, 10, -0.5, 9.5); + setMETitle(jetNSecondaryVertices_, "N Secondary Vertices", "Entries"); + + histname = "trackSumJetEtRatio"; + title = "trackSumJetEtRatio"; + bookME(ibooker, trackSumJetEtRatio_, histname, title, 100, -.1, 1.5); + setMETitle(trackSumJetEtRatio_, "trackSumJetEtRatio", "Entries"); + + histname = "trackSumJetDeltaR"; + title = "trackSumJetDeltaR"; + bookME(ibooker, trackSumJetDeltaR_, histname, title, 100, -0.1, 0.35); + setMETitle(trackSumJetDeltaR_, "trackSumJetDeltaR", "Entries"); + + histname = "vertexCategory"; + title = "vertexCategory"; + bookME(ibooker, vertexCategory_, histname, title, 4, -1.5, 2.5); + setMETitle(vertexCategory_, "vertexCategory", "Entries"); + + histname = "trackSip2dValAboveCharm"; + title = "trackSip2dValAboveCharm"; + bookME(ibooker, trackSip2dValAboveCharm_, histname, title, 100, -0.2, 0.2); + setMETitle(trackSip2dValAboveCharm_, "trackSip2dValAboveCharm", "Entries"); + + histname = "trackSip2dSigAboveCharm"; + title = "trackSip2dSigAboveCharm"; + bookME(ibooker, trackSip2dSigAboveCharm_, histname, title, 100, -50, 50); + setMETitle(trackSip2dSigAboveCharm_, "trackSip2dSigAboveCharm", "Entries"); + + histname = "trackSip3dValAboveCharm"; + title = "trackSip3dValAboveCharm"; + bookME(ibooker, trackSip3dValAboveCharm_, histname, title, 100, -0.2, 0.2); + setMETitle(trackSip3dValAboveCharm_, "trackSip3dValAboveCharm", "Entries"); + + histname = "trackSip3dSigAboveCharm"; + title = "trackSip3dSigAboveCharm"; + bookME(ibooker, trackSip3dSigAboveCharm_, histname, title, 100, -50, 50); + setMETitle(trackSip3dSigAboveCharm_, "trackSip3dSigAboveCharm", "Entries"); + + histname = "jetNSelectedTracks"; + title = "jetNSelectedTracks"; + bookME(ibooker, jetNSelectedTracks_, histname, title, 42, -1.5, 40.5); + setMETitle(jetNSelectedTracks_, "jetNSelectedTracks", "Entries"); + + histname = "jetNTracksEtaRel"; + title = "jetNTracksEtaRel"; + bookME(ibooker, jetNTracksEtaRel_, histname, title, 42, -1.5, 40.5); + setMETitle(jetNTracksEtaRel_, "jetNTracksEtaRel", "Entries"); + + histname = "trackJetDistVal"; + title = "trackJetDistVal"; + bookME(ibooker, trackJetDistVal_, histname, title, 100, -1, 0.01); + setMETitle(trackJetDistVal_, "trackJetDistVal", "Entries"); + + histname = "trackPtRel"; + title = "trackPtRel"; + bookME(ibooker, trackPtRel_, histname, title, 100, -0.1, 7); + setMETitle(trackPtRel_, "trackPtRel", "Entries"); + + histname = "trackDeltaR"; + title = "trackDeltaR"; + bookME(ibooker, trackDeltaR_, histname, title, 160, -0.05, 0.47); + setMETitle(trackDeltaR_, "trackDeltaR", "Entries"); + + histname = "trackPtRatio"; + title = "trackPtRatio"; + bookME(ibooker, trackPtRatio_, histname, title, 100, -0.01, 0.3); + setMETitle(trackPtRatio_, "trackPtRatio", "Entries"); + + histname = "trackSip3dSig"; + title = "trackSip3dSig"; + bookME(ibooker, trackSip3dSig_, histname, title, 40, -40, 40); + setMETitle(trackSip3dSig_, "trackSip3dSig", "Entries"); + + histname = "trackSip2dSig"; + title = "trackSip2dSig"; + bookME(ibooker, trackSip2dSig_, histname, title, 100, -50, 50.); + setMETitle(trackSip2dSig_, "trackSip2dSig", "Entries"); + + histname = "trackDecayLenVal"; + title = "trackDecayLenVal"; + bookME(ibooker, trackDecayLenVal_, histname, title, 100, -0.1, 22); + setMETitle(trackDecayLenVal_, "trackDecayLenVal", "Entries"); + + histname = "trackEtaRel"; + title = "trackEtaRel"; + bookME(ibooker, trackEtaRel_, histname, title, 31, -0.1, 30); + setMETitle(trackEtaRel_, "trackEtaRel", "Entries"); + + histname = "vertexMass"; + title = "vertexMass"; + bookME(ibooker, vertexMass_, histname, title, 20, 0, 10); + setMETitle(vertexMass_, "vertexMass", "Entries"); + + histname = "vertexNTracks"; + title = "vertexNTracks"; + bookME(ibooker, vertexNTracks_, histname, title, 20, -0.5, 19.5); + setMETitle(vertexNTracks_, "vertexNTracks", "Entries"); + + histname = "vertexEnergyRatio"; + title = "vertexEnergyRatio"; + bookME(ibooker, vertexEnergyRatio_, histname, title, 100, -0.1, 3); + setMETitle(vertexEnergyRatio_, "vertexEnergyRatio", "Entries"); + + histname = "vertexJetDeltaR"; + title = "vertexJetDeltaR"; + bookME(ibooker, vertexJetDeltaR_, histname, title, 100, -0.01, .4); + setMETitle(vertexJetDeltaR_, "vertexJetDeltaR", "Entries"); + + histname = "flightDistance2dVal"; + title = "flightDistance2dVal"; + bookME(ibooker, flightDistance2dVal_, histname, title, 100, -0.1, 5); + setMETitle(flightDistance2dVal_, "flightDistance2dVal", "Entries"); + + histname = "flightDistance2dSig"; + title = "flightDistance2dSig"; + bookME(ibooker, flightDistance2dSig_, histname, title, 100, -10, 150.); + setMETitle(flightDistance2dSig_, "flightDistance2dSig", "Entries"); + + histname = "flightDistance3dVal"; + title = "flightDistance3dVal"; + bookME(ibooker, flightDistance3dVal_, histname, title, 100, -0.1, 5); + setMETitle(flightDistance3dVal_, "flightDistance3dVal", "Entries"); + + histname = "flightDistance3dSig"; + title = "flightDistance3dSig"; + bookME(ibooker, flightDistance3dSig_, histname, title, 100, -10, 150.); + setMETitle(flightDistance3dSig_, "flightDistance3dSig", "Entries"); +} + +void BTagAndProbe::analyze(edm::Event const& iEvent, edm::EventSetup const& iSetup) { + //vector definitions + std::vector electrons; + std::vector muons; + + //clear vectors + electrons.clear(); + muons.clear(); + + //jets map definition + // map of Jet,btagValues (for all jets passing bJetSelection_) + // - btagValue of each jet is calculated as sum of values from InputTags in jetTagTokens_ + JetTagMap allJetBTagVals; + + JetTagMap bjets; + + allJetBTagVals.clear(); + bjets.clear(); + + int cutFlowStatus = 1; + cutFlow->Fill(cutFlowStatus); + + cutFlowStatus++; + cutFlow->setBinLabel(cutFlowStatus, "allValid"); + // if valid HLT paths are required, + // analyze event only if all paths are valid + if (requireValidHLTPaths_ && (!hltPathsAreValid_)) + return; + + // electron Handle valid + edm::Handle > eleHandle; + iEvent.getByToken(eleToken_, eleHandle); + if (!eleHandle.isValid() && nelectrons_ > 0) { + edm::LogWarning("BTagAndProbe") << "Electron handle not valid \n"; + return; + } + + //electron ID Handle valid + edm::Handle > eleIDHandle; + iEvent.getByToken(elecIDToken_, eleIDHandle); + if (!eleIDHandle.isValid() && nelectrons_ > 0) { + edm::LogWarning("BTagAndProbe") << "Electron ID handle not valid \n"; + return; + } + + //muon handle valid + edm::Handle muoHandle; + iEvent.getByToken(muoToken_, muoHandle); + if (!muoHandle.isValid() && nmuons_ > 0) { + edm::LogWarning("BTagAndProbe") << "Muon handle not valid \n"; + return; + } + + for (const auto& jetTagToken : jetTagTokens_) { + edm::Handle bjetHandle; + iEvent.getByToken(jetTagToken, bjetHandle); + if (!bjetHandle.isValid() && nbjets_ > 0) { + edm::LogWarning("BTagAndProbe") << "B-Jet handle not valid, will skip event \n"; + return; + } + } + + //tag info + edm::Handle > shallowTagInfos; + iEvent.getByToken(shallowTagInfosToken_, shallowTagInfos); + if (!shallowTagInfos.isValid()) { + edm::LogWarning("BTagAndProbe") << "shallow tag handle not valid, will skip event \n"; + return; + } + + cutFlow->Fill(cutFlowStatus); + + // Filter out events if Trigger Filtering is requested + if (genTriggerEventFlag_->on() && !genTriggerEventFlag_->accept(iEvent, iSetup)) + return; + cutFlowStatus++; + cutFlow->setBinLabel(cutFlowStatus, "passTrigger"); + cutFlow->Fill(cutFlowStatus); + + edm::Handle primaryVertices; + iEvent.getByToken(vtxToken_, primaryVertices); + //Primary Vertex selection + const reco::Vertex* pv = nullptr; + for (auto const& v : *primaryVertices) { + if (!vtxSelection_(v)) + continue; + pv = &v; + break; + } + + cutFlowStatus++; + cutFlow->setBinLabel(cutFlowStatus, "LeptonPVcuts"); + if (applyLeptonPVcuts_ && (pv == nullptr)) { + edm::LogWarning("BTagAndProbe") << "Invalid handle to reco::VertexCollection, event will be skipped"; + return; + } + cutFlow->Fill(cutFlowStatus); + + unsigned int nElectrons = 0; + if (nelectrons_ > 0) { + if (debug_) { + h_nElectrons1->Fill(eleHandle->size()); + h_nElectrons2->Fill(eleIDHandle->size()); + } + + for (size_t index = 0; index < eleHandle->size(); index++) { + const auto e = eleHandle->at(index); + const auto el = eleHandle->ptrAt(index); + + bool pass_id = (*eleIDHandle)[el]; + + if (debug_) { + h_Electrons1_pt->Fill(e.pt()); + h_Electrons1_eta->Fill(e.eta()); + } + + if (eleSelection_(e) && pass_id) { + if (debug_) { + h_Electrons2_pt->Fill(e.pt()); + h_Electrons2_eta->Fill(e.eta()); + } + + if (applyLeptonPVcuts_ && ((std::fabs(e.gsfTrack()->dxy(pv->position())) >= lepPVcuts_.dxy) || + (std::fabs(e.gsfTrack()->dz(pv->position())) >= lepPVcuts_.dz))) { + continue; + } + electrons.push_back(e); + + if (debug_) { + h_Electrons3_pt->Fill(e.pt()); + h_Electrons3_eta->Fill(e.eta()); + } + } + } + nElectrons = electrons.size(); + if (debug_) + h_nElectrons3->Fill(nElectrons); + } + + if (debug_) + h_nMuons1->Fill(muoHandle->size()); + + unsigned int nMuons = 0; + if (nmuons_ > 0) { // need nmuons_ at least be '1' + for (auto const& m : *muoHandle) { + if (debug_) { + h_Muons1_pt->Fill(m.pt()); + h_Muons1_eta->Fill(m.eta()); + } + if (muoSelection_(m)) { + if (debug_) { + h_Muons2_pt->Fill(m.pt()); + h_Muons2_eta->Fill(m.eta()); + } + + if (applyLeptonPVcuts_ && ((std::fabs(m.muonBestTrack()->dxy(pv->position())) >= lepPVcuts_.dxy) || + (std::fabs(m.muonBestTrack()->dz(pv->position())) >= lepPVcuts_.dz))) { + continue; + } + muons.push_back(m); + + if (debug_) { + h_Muons3_pt->Fill(m.pt()); + h_Muons3_eta->Fill(m.eta()); + } + } + } + if (debug_) + h_nMuons2->Fill(muons.size()); + + nMuons = muons.size(); + if (nMuons < nmuons_) + return; + if (debug_) + h_nMuons3->Fill(nMuons); + } + + int nbjets1 = 0; + int nbjets2 = 0; + int nbjets3 = 0; + + for (const auto& jetTagToken : jetTagTokens_) { + edm::Handle bjetHandle; + iEvent.getByToken(jetTagToken, bjetHandle); + + const reco::JetTagCollection& bTags = *(bjetHandle.product()); + + for (const auto& i_jetTag : bTags) { + const auto& jetRef = i_jetTag.first; // where jet that is tagged exists + nbjets1++; + if (not bjetSelection_(*dynamic_cast(jetRef.get()))) + continue; + nbjets2++; + const auto btagVal = i_jetTag.second; // bTagVal exists + h_btagVal->Fill(btagVal); + + if (not std::isfinite(btagVal)) + continue; // checks bTagVal exists + nbjets3++; + if (allJetBTagVals.find(jetRef) != allJetBTagVals.end()) { + allJetBTagVals.at(jetRef) += btagVal; // add bjet tagVal to map + } else { + allJetBTagVals.insert(JetTagMap::value_type(jetRef, btagVal)); + } + } + } + + if (debug_) { + h_nJets1->Fill(nbjets1); + h_nJets2->Fill(nbjets2); + h_nJets3->Fill(nbjets3); + } + + int nbjets4 = 0; + int nbjets5 = 0; + int nbjets6 = 0; + for (const auto& jetBTagVal : allJetBTagVals) { + bool isJetOverlappedWithLepton = false; + nbjets4++; + if (nmuons_ > 0) { + for (auto const& m : muons) { + if (deltaR2(*jetBTagVal.first, m) < leptJetDeltaRmin_ * leptJetDeltaRmin_) { + isJetOverlappedWithLepton = true; + break; + } + if (debug_) { + h_Muons4_pt->Fill(m.pt()); + h_Muons4_eta->Fill(m.eta()); + } + } + } + if (isJetOverlappedWithLepton) + continue; + nbjets5++; + + isJetOverlappedWithLepton = false; + if (nelectrons_ > 0) { + for (auto const& e : electrons) { + if (deltaR2(*jetBTagVal.first, e) < leptJetDeltaRmin_ * leptJetDeltaRmin_) { + isJetOverlappedWithLepton = true; + break; + } + } + } + if (isJetOverlappedWithLepton) + continue; + nbjets6++; + + bjets.insert(JetTagMap::value_type(jetBTagVal.first, jetBTagVal.second)); + } + if (debug_) { + h_nJets4->Fill(nbjets4); + h_nJets5->Fill(nbjets5); + h_nJets6->Fill(nbjets6); + + h_nJets7->Fill(bjets.size()); + h_nElectrons4->Fill(nElectrons); + h_nMuons4->Fill(nMuons); + + h_nJets8->Fill(bjets.size()); + } + + unsigned int nbJets = bjets.size(); + + cutFlowStatus++; + cutFlow->setBinLabel(cutFlowStatus, "PassJetDeltaEta"); + if (bjets.size() > 1) { + double deltaEta = std::abs(bjets.begin()->first->eta() - (++bjets.begin())->first->eta()); + if (deltaEta > bJetDeltaEtaMax_) + return; + } + cutFlow->Fill(cutFlowStatus); + if (debug_) + h_nJets9->Fill(bjets.size()); + + // Event selection // + if (debug_) + h_nElectrons5->Fill(nElectrons); + cutFlowStatus++; + cutFlow->setBinLabel(cutFlowStatus, "reqNumElectrons " + std::to_string(nelectrons_)); + if (nElectrons < nelectrons_) + return; + cutFlow->Fill(cutFlowStatus); + if (debug_) { + h_nJets10->Fill(bjets.size()); + h_nElectrons6->Fill(nElectrons); + h_nMuons5->Fill(nMuons); + } + cutFlowStatus++; + cutFlow->setBinLabel(cutFlowStatus, "reqNumMuons " + std::to_string(nmuons_)); + if (nMuons < nmuons_) + return; + cutFlow->Fill(cutFlowStatus); + if (debug_) { + h_nJets11->Fill(bjets.size()); + h_nElectrons7->Fill(nElectrons); + h_nMuons6->Fill(nMuons); + } + cutFlowStatus++; + cutFlow->setBinLabel(cutFlowStatus, "twoOrMoreJets"); + + if (nbJets < 2) + return; + + cutFlow->Fill(cutFlowStatus); + if (debug_) + h_nJets12->Fill(nbJets); + + //loop electron, muon distributions + if (debug_) { + for (auto const& m : muons) { + h_Muons5_pt->Fill(m.pt()); + h_Muons5_eta->Fill(m.eta()); + } + + for (auto const& e : electrons) { + h_Electrons4_pt->Fill(e.pt()); + h_Electrons4_eta->Fill(e.eta()); + } + h_nElectrons8->Fill(nElectrons); //Fill electron counter + h_nMuons7->Fill(nMuons); //Fill muon counter + } + + bool isProbe; + bool passProbe; + for (auto& jet1 : bjets) { + isProbe = false; + for (auto& jet2 : bjets) { + if (deltaR2(*jet1.first, *jet2.first) < 0.3 * 0.3) + continue; // check if same jet + if (jet2.second >= workingpoint_) { // check if passing btag + isProbe = true; + break; + } + } + + if (isProbe) { + h_btagVal_pa->Fill(jet1.second); + passProbe = false; + + if (jet1.second >= workingpoint_) { + h_btagVal_pp->Fill(jet1.second); + passProbe = true; + } else + h_btagVal_pf->Fill(jet1.second); + + for (const auto& shallowTagInfo : *shallowTagInfos) { + const auto tagJet = shallowTagInfo.jet(); + const auto& tagVars = shallowTagInfo.taggingVariables(); + + if (deltaR2(jet1.first->eta(), jet1.first->phi(), tagJet->eta(), tagJet->phi()) > 0.3 * 0.3) + continue; + + jet_pt_.fill(passProbe, tagJet->pt()); + jet_eta_.fill(passProbe, tagJet->eta()); + + for (const auto& tagVar : tagVars.getList(reco::btau::jetNSecondaryVertices, false)) { + jetNSecondaryVertices_.fill(passProbe, tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::trackSumJetEtRatio, false)) { + trackSumJetEtRatio_.fill(passProbe, tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::trackSumJetDeltaR, false)) { + trackSumJetDeltaR_.fill(passProbe, tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::vertexCategory, false)) { + vertexCategory_.fill(passProbe, tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::trackSip2dValAboveCharm, false)) { + trackSip2dValAboveCharm_.fill(passProbe, tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::trackSip2dSigAboveCharm, false)) { + trackSip2dSigAboveCharm_.fill(passProbe, tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::trackSip3dValAboveCharm, false)) { + trackSip3dValAboveCharm_.fill(passProbe, tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::trackSip3dSigAboveCharm, false)) { + trackSip3dSigAboveCharm_.fill(passProbe, tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::jetNSelectedTracks, false)) { + jetNSelectedTracks_.fill(passProbe, tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::jetNTracksEtaRel, false)) { + jetNTracksEtaRel_.fill(passProbe, tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::trackJetDistVal, false)) { + trackJetDistVal_.fill(passProbe, tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::trackPtRel, false)) { + trackPtRel_.fill(passProbe, tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::trackDeltaR, false)) { + trackDeltaR_.fill(passProbe, tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::trackPtRatio, false)) { + trackPtRatio_.fill(passProbe, tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::trackSip3dSig, false)) { + trackSip3dSig_.fill(passProbe, tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::trackSip2dSig, false)) { + trackSip2dSig_.fill(passProbe, tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::trackDecayLenVal, false)) { + trackDecayLenVal_.fill(passProbe, tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::trackEtaRel, false)) { + trackEtaRel_.fill(passProbe, tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::vertexMass, false)) { + vertexMass_.fill(passProbe, tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::vertexNTracks, false)) { + vertexNTracks_.fill(passProbe, tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::vertexEnergyRatio, false)) { + vertexEnergyRatio_.fill(passProbe, tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::vertexJetDeltaR, false)) { + vertexJetDeltaR_.fill(passProbe, tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::flightDistance2dVal, false)) { + flightDistance2dVal_.fill(passProbe, tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::flightDistance2dSig, false)) { + flightDistance2dSig_.fill(passProbe, tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::flightDistance3dVal, false)) { + flightDistance3dVal_.fill(passProbe, tagVar); + } + + for (const auto& tagVar : tagVars.getList(reco::btau::flightDistance3dSig, false)) { + flightDistance3dSig_.fill(passProbe, tagVar); + } + } + } + } +} + +void BTagAndProbe::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add("FolderName", "HLT/BTV"); + + desc.add("requireValidHLTPaths", true); + + desc.add("vertices", edm::InputTag("offlinePrimaryVertices")); + desc.add("muons", edm::InputTag("muons")); + desc.add("electrons", edm::InputTag("gedGsfElectrons")); + desc.add("elecID", edm::InputTag("egmGsfElectronIDsForDQM:cutBasedElectronID-Fall17-94X-V1-tight")); + desc.add >( + "btagAlgos", {edm::InputTag("pfDeepCSVJetTags:probb"), edm::InputTag("pfDeepCSVJetTags:probbb")}); + + desc.add("jetSelection", "pt > 30"); + desc.add("eleSelection", "pt > 0 && abs(eta) < 2.5"); + desc.add("muoSelection", "pt > 6 && abs(eta) < 2.4"); + desc.add("vertexSelection", "!isFake"); + desc.add("bjetSelection", "pt > 30"); + desc.add("nelectrons", 0); + desc.add("nmuons", 0); + desc.add("leptJetDeltaRmin", 0); + desc.add("bJetMuDeltaRmax", 9999.); + desc.add("bJetDeltaEtaMax", 9999.); + + desc.add("nbjets", 0); + desc.add("workingpoint", 0.4941); // DeepCSV Medium wp + desc.add("applyLeptonPVcuts", false); + desc.add("debug", false); + + edm::ParameterSetDescription genericTriggerEventPSet; + GenericTriggerEventFlag::fillPSetDescription(genericTriggerEventPSet); + + desc.add("genericTriggerEventPSet", genericTriggerEventPSet); + + edm::ParameterSetDescription lPVcutPSet; + lPVcutPSet.add("dxy", 9999.); + lPVcutPSet.add("dz", 9999.); + desc.add("leptonPVcuts", lPVcutPSet); + + descriptions.add("BTagAndProbeMonitoring", desc); +} + +// Define this as a plug-in +DEFINE_FWK_MODULE(BTagAndProbe); diff --git a/DQMOffline/Trigger/python/BTVHLTOfflineSource_cfi.py b/DQMOffline/Trigger/python/BTVHLTOfflineSource_cfi.py index f28c2af313d6a..468e3faf2a14d 100644 --- a/DQMOffline/Trigger/python/BTVHLTOfflineSource_cfi.py +++ b/DQMOffline/Trigger/python/BTVHLTOfflineSource_cfi.py @@ -28,26 +28,17 @@ maxJetDistance = cms.double(0.07), dRTrackMatch = cms.double(0.01), - pathPairs = cms.VPSet( cms.PSet( - pathname = cms.string("HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFDiJet30_PFBtagDeepCSV_1p5_v"), - pathtype = cms.string("PF"), - ), - cms.PSet( - pathname = cms.string("HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_CaloDiJet30_CaloBtagDeepCSV_1p5_v"), - pathtype = cms.string("Calo"), - ), - cms.PSet( - pathname = cms.string("HLT_PFHT400_SixPFJet32_DoublePFBTagDeepCSV_2p94_v"), - pathtype = cms.string("PF"), + pathname = cms.string("HLT_Mu12_DoublePFJets40_PFBTagDeepCSV_p71_v"), + pathtype = cms.string("PF") ), cms.PSet( - pathname = cms.string("HLT_PFHT400_SixPFJet32_DoublePFBTagDeepCSV_2p94_v"), - pathtype = cms.string("Calo"), + pathname = cms.string("HLT_Mu12_DoublePFJets40MaxDeta1p6_DoublePFBTagDeepCSV_p71_v"), + pathtype = cms.string("Calo") ), - ), + ), ) # @@ -60,44 +51,26 @@ cut = cms.string("quality('highPurity')") ) -bTagHLTTrackMonitoring_EmuCalo = trackToTrackComparisonHists.clone( +bTagHLTTrackMonitoring_muPF1 = trackToTrackComparisonHists.clone( dzWRTPvCut = 0.1, - monitoredTrack = "hltMergedTracksForBTag", + monitoredTrack = "hltMergedTracks", referenceTrack = "referenceTracksForHLTBTag", monitoredBeamSpot = "hltOnlineBeamSpot", referenceBeamSpot = "offlineBeamSpot", - topDirName = "HLT/BTV/HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_CaloDiJet30_CaloBtagDeepCSV_1p5Calo", + topDirName = "HLT/BTV/HLT_Mu12_DoublePFJets40_PFBTagDeepCSV_p71PF", referencePrimaryVertices = "offlinePrimaryVertices", - monitoredPrimaryVertices = "hltVerticesL3", - genericTriggerEventPSet = dict(hltPaths = ["HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_CaloDiJet30_CaloBtagDeepCSV_1p5*"]) -) - -bTagHLTTrackMonitoring_SixJetCalo = bTagHLTTrackMonitoring_EmuCalo.clone( - topDirName = "HLT/BTV/HLT_PFHT400_SixPFJet32_DoublePFBTagDeepCSV_2p94PF", - genericTriggerEventPSet = dict(hltPaths = ["HLT_PFHT400_SixPFJet32_DoublePFBTagDeepCSV_2p94_v*"]) -) - -bTagHLTTrackMonitoring_EmuPF = bTagHLTTrackMonitoring_EmuCalo.clone( - monitoredTrack = "hltMergedTracks", monitoredPrimaryVertices = "hltVerticesPFSelector", - topDirName = "HLT/BTV/HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFDiJet30_PFBtagDeepCSV_1p5PF", - genericTriggerEventPSet = dict(hltPaths = ["HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFDiJet30_PFBtagDeepCSV_1p5*"]) + genericTriggerEventPSet = dict(hltPaths = ["HLT_Mu12_DoublePFJets40_PFBTagDeepCSV_p71*"]) ) -bTagHLTTrackMonitoring_SixJetPF = bTagHLTTrackMonitoring_EmuPF.clone( - monitoredTrack = "hltMergedTracks", - monitoredPrimaryVertices = "hltVerticesPFSelector", - topDirName = "HLT/BTV/HLT_PFHT400_SixPFJet32_DoublePFBTagDeepCSV_2p94PF", - genericTriggerEventPSet = dict(hltPaths = ["HLT_PFHT400_SixPFJet32_DoublePFBTagDeepCSV_2p94_v*"]) +bTagHLTTrackMonitoring_muPF2 = bTagHLTTrackMonitoring_muPF1.clone( + topDirName = "HLT/BTV/HLT_Mu12_DoublePFJets40MaxDeta1p6_DoublePFBTagDeepCSV_p71PF", + genericTriggerEventPSet = dict(hltPaths = ["HLT_Mu12_DoublePFJets40MaxDeta1p6_DoublePFBTagDeepCSV_p71*"]) ) bTagHLTTrackMonitoringSequence = cms.Sequence( cms.ignore(referenceTracksForHLTBTag) - + bTagHLTTrackMonitoring_EmuCalo - + bTagHLTTrackMonitoring_SixJetCalo - + bTagHLTTrackMonitoring_EmuPF - + bTagHLTTrackMonitoring_SixJetPF + + bTagHLTTrackMonitoring_muPF1 + + bTagHLTTrackMonitoring_muPF2 ) - - diff --git a/DQMOffline/Trigger/python/BTagAndProbeMonitor_cfi.py b/DQMOffline/Trigger/python/BTagAndProbeMonitor_cfi.py new file mode 100644 index 0000000000000..7c0df3e897270 --- /dev/null +++ b/DQMOffline/Trigger/python/BTagAndProbeMonitor_cfi.py @@ -0,0 +1,39 @@ +import FWCore.ParameterSet.Config as cms + +from DQMOffline.Trigger.BTagAndProbeMonitoring_cfi import BTagAndProbeMonitoring + +BTagAndProbeMonitoring = BTagAndProbeMonitoring.clone( + FolderName = 'HLT/BTV/default/', + requireValidHLTPaths = True, + applyLeptonPVcuts = False, + leptonPVcuts = dict(dxy = 9999., + dz = 9999.), + + electrons = "gedGsfElectrons", # while pfIsolatedElectronsEI are reco::PFCandidate ! + elecID = "egmGsfElectronIDsForDQM:cutBasedElectronID-Fall17-94X-V1-tight", #Electron ID + muons = "muons", # while pfIsolatedMuonsEI are reco::PFCandidate ! + vertices = "offlinePrimaryVertices", + + btagAlgos = ['pfDeepCSVJetTags:probb', 'pfDeepCSVJetTags:probbb'], + workingpoint = 0.8484, # Medium wp + leptJetDeltaRmin = 0.4, + bJetDeltaEtaMax = 9999., + + #genericTriggerEventPSet = dict(andOr = False, + # andOrHlt = True, + # hltInputTag = "TriggerResults::HLT", + # errorReplyHlt = False, + # verbosityLevel = 0, + # ), + + genericTriggerEventPSet = dict( andOr = False, + andOrHlt = True, # True:=OR; False:=AND + hltInputTag = "TriggerResults::HLT", + errorReplyHlt = False, + dcsInputTag = "scalersRawToDigi", + dcsPartitions = [24, 25, 26, 27, 28, 29], # 24-27: strip, 28-29: pixel, we should add all other detectors ! + andOrDcs = False, + errorReplyDcs = True, + verbosityLevel = 0,), +) + diff --git a/DQMOffline/Trigger/python/BTagAndProbeMonitoring_Client_cff.py b/DQMOffline/Trigger/python/BTagAndProbeMonitoring_Client_cff.py new file mode 100644 index 0000000000000..43b9da6269c19 --- /dev/null +++ b/DQMOffline/Trigger/python/BTagAndProbeMonitoring_Client_cff.py @@ -0,0 +1,43 @@ +import FWCore.ParameterSet.Config as cms + +from DQMServices.Core.DQMEDHarvester import DQMEDHarvester + +BTagAndProbe_TnP = DQMEDHarvester("DQMGenericClient", + subDirs = cms.untracked.vstring("HLT/BTV/TnP/*"), + verbose = cms.untracked.uint32(0), # Set to 2 for all messages + resolution = cms.vstring(), + efficiency = cms.vstring( + "jet_eta 'BTag and Probe jet eta efficiency; jet #eta; efficiency' jet_eta_numerator jet_eta_denominator", + "jet_pt 'BTag and Probe jet pt efficiency; jet pt; efficiency' jet_pt_numerator jet_pt_denominator", + "vertexMass 'BTag and Probe vertexMass efficiency; vertexMass; efficiency' vertexMass_numerator vertexMass_denominator", + "jetNSecondaryVertices 'BTag and Probe jetNSecondaryVertices efficiency; jetNSecondaryVertices; efficiency' jetNSecondaryVertices_numerator jetNSecondaryVertices_denominator", + "trackSumJetEtRatio 'BTag and Probe trackSumJetEtRatio efficiency; jet trackSumJetEtRatio; efficiency' trackSumJetEtRatio_numerator trackSumJetEtRatio_denominator", + "trackSip2dValAboveCharm 'BTag and Probe trackSip2dValAboveCharm efficiency; trackSip2dValAboveCharm; efficiency' trackSip2dValAboveCharm_numerator trackSip2dValAboveCharm_denominator", + "trackSip2dSigAboveCharm 'BTag and Probe trackSip2dSigAboveCharm efficiency; trackSip2dValAboveCharm; efficiency' trackSip2dValAboveCharm_numerator trackSip2dValAboveCharm_denominator", + "trackSip3dValAboveCharm 'BTag and Probe trackSip3dValAboveCharm efficiency; trackSip3dValAboveCharm; efficiency' trackSip3dValAboveCharm_numerator trackSip3dValAboveCharm_denominator", + "trackSip3dSigAboveCharm 'BTag and Probe trackSip3dSigAboveCharm efficiency; trackSip3dSigAboveCharm; efficiency' trackSip3dSigAboveCharm_numerator trackSip3dSigAboveCharm_denominator", + "jetNSelectedTracks 'BTag and Probe jetNSelectedTracks efficiency; jetNSelectedTracks; efficiency' jetNSelectedTracks_numerator jetNSelectedTracks_denominator", + "jetNTracksEtaRel 'BTag and Probe jetNTracksEtaRel efficiency; jetNTracksEtaRel; efficiency' jetNTracksEtaRel_numerator jetNTracksEtaRel_denominator", + "vertexCategory 'BTag and Probe vertexCategory efficiency; vertexCategory; efficiency' vertexCategory_numerator vertexCategory_denominator", + "trackSumJetDeltaR 'BTag and Probe trackSumJetDeltaR efficiency; trackSumJetDeltaR; efficiency' trackSumJetDeltaR_numerator trackSumJetDeltaR_denominator", + "trackJetDistVal 'BTag and Probe trackJetDistVal efficiency; trackJetDistVal; efficiency' trackJetDistVal_numerator trackJetDistVal_denominator", + "trackPtRel 'BTag and Probe trackPtRel efficiency; trackPtRel; efficiency' trackPtRel_numerator trackPtRel_denominator", + "trackDeltaR 'BTag and Probe trackDeltaR efficiency; trackDeltaR; efficiency' trackDeltaR_numerator trackDeltaR_denominator", + "trackPtRatio 'BTag and Probe trackPtRatio efficiency; jet trackPtRatio; efficiency' trackPtRatio_numerator trackPtRatio_denominator", + "trackSip2dSig 'BTag and Probe trackSip2dSig efficiency; trackSip2dSig; efficiency' trackSip2dSig_numerator trackSip2dSig_denominator", + "trackSip3dSig 'BTag and Probe trackSip3dSig efficiency; trackSip3dSig; efficiency' trackSip3dSig_numerator trackSip3dSig_denominator", + "trackDecayLenVal 'BTag and Probe trackDecayLenVal efficiency; trackDecayLenVal; efficiency' trackDecayLenVal_numerator trackDecayLenVal_denominator", + "trackEtaRel 'BTag and Probe trackEtaRel efficiency; trackEtaRel; efficiency' trackEtaRel_numerator trackEtaRel_denominator", + "vertexEnergyRatio 'BTag and Probe vertexEnergyRatio efficiency; vertexEnergyRatio; efficiency' vertexEnergyRatio_numerator vertexEnergyRatio_denominator", + "vertexJetDeltaR 'BTag and Probe vertexJetDeltaR efficiency; jetNTracksEtaRel; efficiency' vertexJetDeltaR_numerator vertexJetDeltaR_denominator", + "vertexNTracks 'BTag and Probe vertexNTracks efficiency; vertexNTracks; efficiency' vertexNTracks_numerator vertexNTracks_denominator", + "flightDistance2dVal 'BTag and Probe flightDistance2dVal efficiency; flightDistance2dVal; efficiency' flightDistance2dVal_numerator flightDistance2dVal_denominator", + "flightDistance2dSig 'BTag and Probe flightDistance2dSig efficiency; flightDistance2dSig; efficiency' flightDistance2dSig_numerator flightDistance2dSig_denominator", + "flightDistance3dVal 'BTag and Probe flightDistance3dVal efficiency; flightDistance3dVal; efficiency' flightDistance3dVal_numerator flightDistance3dVal_denominator", + "flightDistance3dSig 'BTag and Probe flightDistance3dSig efficiency; flightDistance3dSig; efficiency' flightDistance3dSig_numerator flightDistance3dSig_denominator", + ), +) + +BTagAndProbeClient = cms.Sequence( + BTagAndProbe_TnP +) diff --git a/DQMOffline/Trigger/python/BTagAndProbeMonitoring_cff.py b/DQMOffline/Trigger/python/BTagAndProbeMonitoring_cff.py new file mode 100644 index 0000000000000..39f09d45333ed --- /dev/null +++ b/DQMOffline/Trigger/python/BTagAndProbeMonitoring_cff.py @@ -0,0 +1,55 @@ +import FWCore.ParameterSet.Config as cms + +from DQMOffline.Trigger.BTagAndProbeMonitor_cfi import BTagAndProbeMonitoring + +from Configuration.Eras.Modifier_run2_HLTconditions_2018_cff import run2_HLTconditions_2018 +from Configuration.Eras.Modifier_run2_HLTconditions_2017_cff import run2_HLTconditions_2017 +from Configuration.Eras.Modifier_run2_HLTconditions_2016_cff import run2_HLTconditions_2016 + +### +### Ele+Jet +### + +BTagAndProbe_1e1m = BTagAndProbeMonitoring.clone( + FolderName = cms.string('HLT/BTV/TnP/oneEle_oneMu'), + nmuons = 1, + nelectrons = 1, + nbjets = 2, + eleSelection = 'pt>10 & abs(eta)<2.5', + muoSelection = 'pt>10 & abs(eta)<2.4', + bjetSelection = 'pt>20 & abs(eta)<2.4', + genericTriggerEventPSet = dict(hltPaths = ['HLT_Mu12_DoublePFJets40_PFBTagDeepCSV_p71_v*', + 'HLT_Mu12_DoublePFJets40MaxDeta1p6_DoublePFBTagDeepCSV_p71_v*']), + #denGenericTriggerEventPSet = dict(hltPaths = ['HLT_Mu12_DoublePFJets40_PFBTagDeepCSV_p71_v*', + # 'HLT_Mu12_DoublePFJets40MaxDeta1p6_DoublePFBTagDeepCSV_p71_v*']), + debug = cms.bool(True), +) + +### --- + +BTagAndProbe_1e0m = BTagAndProbe_1e1m.clone( + FolderName = cms.string('HLT/BTV/TnP/OneEle_NoMu'), + nmuons = 0, + nelectrons = 1, + debug = False, +) + +### --- +BTagAndProbe_0e1m = BTagAndProbe_1e1m.clone( + FolderName = cms.string('HLT/BTV/TnP/NoEle_OneMu'), + nmuons = 1, + nelectrons = 0, + debug = False, +) + + +from DQMOffline.Trigger.HLTEGTnPMonitor_cfi import egmGsfElectronIDsForDQM + +BTagAndProbeHLT = cms.Sequence( + + BTagAndProbe_1e1m + + BTagAndProbe_1e0m + + BTagAndProbe_0e1m + + , cms.Task(egmGsfElectronIDsForDQM) # Use of electron VID requires this module being executed first +) diff --git a/DQMOffline/Trigger/python/BTagAndProbeMonitoring_cfi.py b/DQMOffline/Trigger/python/BTagAndProbeMonitoring_cfi.py new file mode 100644 index 0000000000000..b7f99c47d8684 --- /dev/null +++ b/DQMOffline/Trigger/python/BTagAndProbeMonitoring_cfi.py @@ -0,0 +1,64 @@ +import FWCore.ParameterSet.Config as cms + +BTagAndProbeMonitoring = cms.EDProducer('BTagAndProbe', + FolderName = cms.string('HLT/BTV'), + requireValidHLTPaths = cms.bool(True), + vertices = cms.InputTag('offlinePrimaryVertices'), + muons = cms.InputTag('muons'), + electrons = cms.InputTag('gedGsfElectrons'), + elecID = cms.InputTag('egmGsfElectronIDsForDQM', 'cutBasedElectronID-Fall17-94X-V1-tight'), + #jets = cms.InputTag('ak4PFJetsCHS'), + btagAlgos = cms.VInputTag( + 'pfDeepCSVJetTags:probb', + 'pfDeepCSVJetTags:probbb' + ), + jetSelection = cms.string('pt > 0'), + eleSelection = cms.string('pt > 0 && abs(eta) < 2.5'), + muoSelection = cms.string('pt > 6 && abs(eta) < 2.4'), + vertexSelection = cms.string('!isFake'), + bjetSelection = cms.string('pt > 0'), + nelectrons = cms.uint32(0), + nmuons = cms.uint32(0), + leptJetDeltaRmin = cms.double(0), + bJetDeltaEtaMax = cms.double(9999), + nbjets = cms.uint32(0), + workingpoint = cms.double(0.4941), + applyLeptonPVcuts = cms.bool(False), + debug = cms.bool(False), + #numGenericTriggerEventPSet = cms.PSet( + # andOr = cms.required.bool, + # dcsInputTag = cms.InputTag('scalersRawToDigi'), + # dcsPartitions = cms.vint32(), + # andOrDcs = cms.bool(False), + # errorReplyDcs = cms.bool(True), + # dbLabel = cms.string(''), + # andOrHlt = cms.bool(True), + # dcsRecordInputTag = cms.InputTag('onlineMetaDataDigis'), + # hltInputTag = cms.InputTag('TriggerResults', '', 'HLT'), + # hltPaths = cms.vstring(), + # hltDBKey = cms.string(''), + # errorReplyHlt = cms.bool(False), + # verbosityLevel = cms.uint32(1) + #), + genericTriggerEventPSet = cms.PSet( + andOr = cms.required.bool, + dcsInputTag = cms.InputTag('scalersRawToDigi'), + dcsPartitions = cms.vint32(), + andOrDcs = cms.bool(False), + errorReplyDcs = cms.bool(True), + dbLabel = cms.string(''), + andOrHlt = cms.bool(True), + dcsRecordInputTag = cms.InputTag('onlineMetaDataDigis'), + hltInputTag = cms.InputTag('TriggerResults', '', 'HLT'), + hltPaths = cms.vstring(), + hltDBKey = cms.string(''), + errorReplyHlt = cms.bool(False), + verbosityLevel = cms.uint32(1) + ), + + leptonPVcuts = cms.PSet( + dxy = cms.double(9999), + dz = cms.double(9999) + ), + mightGet = cms.optional.untracked.vstring +) diff --git a/DQMOffline/Trigger/python/BTaggingMonitor_cfi.py b/DQMOffline/Trigger/python/BTaggingMonitor_cfi.py index eba91ff4741f7..7e8461e5fcc5d 100644 --- a/DQMOffline/Trigger/python/BTaggingMonitor_cfi.py +++ b/DQMOffline/Trigger/python/BTaggingMonitor_cfi.py @@ -13,7 +13,7 @@ metPSet = dict( nbins = 30, xmin = 0, - xmax = 300), + xmax = 300), ptPSet = dict( nbins = 100, xmin = 0, @@ -48,60 +48,60 @@ xmin = 60, xmax = 300), - #MET and HT binning + #MET and HT binning metBinning = [0,20,40,60,80,100,125,150,175,200], HTBinning = [0,20,40,60,80,100,125,150,175,200,300,400,500,700], - #Eta binning + #Eta binning eleEtaBinning = [-2.4,-2.1,-1.5,-0.9,-0.3,0.,0.3,0.9,1.5,2.1,2.4], jetEtaBinning = [-2.4,-2.1,-1.5,-0.9,-0.3,0.,0.3,0.9,1.5,2.1,2.4], muEtaBinning = [-2.4,-2.1,-1.5,-0.9,-0.3,0.,0.3,0.9,1.5,2.1,2.4], - #pt binning + #pt binning elePtBinning = [0,3,5,8,15,20,25,30,40,50,60,80,120,200,400,700], jetPtBinning = [0,3,5,8,15,20,25,30,40,50,70,100,150,200,400,700,1000,1500,3000], muPtBinning = [0,3,5,7,10,15,20,30,40,50,70,100,150,200,400,700], - #Eta binning 2D + #Eta binning 2D eleEtaBinning2D = [-2.5,-1.5,-0.6,0.,0.6,1.5,2.5], jetEtaBinning2D = [-2.5,-1.5,-0.6,0.,0.6,1.5,2.5], muEtaBinning2D = [-2.5,-1.5,-0.6,0.,0.6,1.5,2.5], - #pt binning 2D + #pt binning 2D elePtBinning2D = [0,15,20,30,40,60,80,100,200,400], jetPtBinning2D = [0,15,20,30,40,60,80,100,200,400], muPtBinning2D = [0,15,20,30,40,60,80,100,200,400], - #HT and phi binning 2D + #HT and phi binning 2D HTBinning2D =[0,20,40,70,100,150,200,400,700], phiBinning2D = [-3.1416,-1.8849,-0.6283,0.6283,1.8849,3.1416], ), - met = "pfMet", # pfMet - jets = "ak4PFJetsCHS", # ak4PFJets, ak4PFJetsCHS, ak4PFJets - electrons = "gedGsfElectrons", # while pfIsolatedElectronsEI are reco::PFCandidate ! - muons = "muons", # while pfIsolatedMuonsEI are reco::PFCandidate ! - + met = "pfMet", # pfMet + jets = "ak4PFJetsCHS", # ak4PFJets, ak4PFJetsCHS, ak4PFJets + electrons = "gedGsfElectrons", # while pfIsolatedElectronsEI are reco::PFCandidate ! + muons = "muons", # while pfIsolatedMuonsEI are reco::PFCandidate ! + btagAlgos = ["pfCombinedSecondaryVertexV2BJetTags"], - workingpoint = -1., #no cut applied - + workingpoint = -1., #no cut applied + HTdefinition = 'pt>30 & abs(eta)<2.5', leptJetDeltaRmin = 0.0, bJetMuDeltaRmax = 9999., bJetDeltaEtaMax = 9999., - #always monitor CSV score for one jet + #always monitor CSV score for one jet nbjets = 1, bjetSelection = 'pt>30 & abs(eta)<2.4', numGenericTriggerEventPSet = dict( andOr = False, - andOrHlt = True,# True:=OR; False:=AND + andOrHlt = True,# True:=OR; False:=AND hltInputTag = "TriggerResults::HLT", errorReplyHlt = False, verbosityLevel = 0), denGenericTriggerEventPSet = dict( andOr= False, - andOrHlt = True,# True:=OR; False:=AND + andOrHlt = True,# True:=OR; False:=AND hltInputTag = "TriggerResults::HLT", errorReplyHlt = False, dcsInputTag = "scalersRawToDigi", dcsRecordInputTag = "onlineMetaDataDigis", - dcsPartitions = [24, 25, 26, 27, 28, 29], # 24-27: strip, 28-29: pixel, we should add all other detectors ! + dcsPartitions = [24, 25, 26, 27, 28, 29], # 24-27: strip, 28-29: pixel, we should add all other detectors ! andOrDcs = False, errorReplyDcs = True, verbosityLevel = 0) diff --git a/DQMOffline/Trigger/python/BTaggingMonitoring_Client_cff.py b/DQMOffline/Trigger/python/BTaggingMonitoring_Client_cff.py index ece9eda6cb005..27804065a5bf2 100644 --- a/DQMOffline/Trigger/python/BTaggingMonitoring_Client_cff.py +++ b/DQMOffline/Trigger/python/BTaggingMonitoring_Client_cff.py @@ -178,8 +178,8 @@ BTVEfficiency_TurnOnCurves = DQMEDHarvester("DQMGenericClient", subDirs = cms.untracked.vstring( "HLT/BTV/HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFDiJet30_PFBtagDeepCSV_1p5*", - "HLT/BTV/HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_CaloDiJet30_CaloBtagDeepCSV_1p5*", - "HLT/BTV/HLT_PFHT400_SixPFJet32_DoublePFBTagDeepCSV_2p94*", + "HLT/BTV/HLT_DoublePFJets40_CaloBTagDeepCSV_p71*", + "HLT/BTV/HLT_Mu12_DoublePFJets40_CaloBTagDeepCSV_p71*", ), verbose = cms.untracked.uint32(0), resolution = cms.vstring(), @@ -193,8 +193,8 @@ BTVEfficiency_OnlineTrackEff = DQMEDHarvester("DQMGenericClient", subDirs = cms.untracked.vstring( "HLT/BTV/HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFDiJet30_PFBtagDeepCSV_1p5*", - "HLT/BTV/HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_CaloDiJet30_CaloBtagDeepCSV_1p5*", - "HLT/BTV/HLT_PFHT400_SixPFJet32_DoublePFBTagDeepCSV_2p94*", + "HLT/BTV/HLT_DoublePFJets40_CaloBTagDeepCSV_p71*", + "HLT/BTV/HLT_Mu12_DoublePFJets40_CaloBTagDeepCSV_p71*", ), verbose = cms.untracked.uint32(0), resolution = cms.vstring(), @@ -209,8 +209,8 @@ BTVEfficiency_OnlineTrackFake = DQMEDHarvester("DQMGenericClient", subDirs = cms.untracked.vstring( "HLT/BTV/HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFDiJet30_PFBtagDeepCSV_1p5*", - "HLT/BTV/HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_CaloDiJet30_CaloBtagDeepCSV_1p5*", - "HLT/BTV/HLT_PFHT400_SixPFJet32_DoublePFBTagDeepCSV_2p94*", + "HLT/BTV/HLT_DoublePFJets40_CaloBTagDeepCSV_p71*", + "HLT/BTV/HLT_Mu12_DoublePFJets40_CaloBTagDeepCSV_p71*", ), verbose = cms.untracked.uint32(0), resolution = cms.vstring(), @@ -225,12 +225,13 @@ from DQMOffline.Trigger.TrackingMonitoring_Client_cff import TrackToTrackEfficiencies BJetTrackToTrackEfficiencies = TrackToTrackEfficiencies.clone( - subDirs = ["HLT/BTV/HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFDiJet30_PFBtagDeepCSV_1p5*", - "HLT/BTV/HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_CaloDiJet30_CaloBtagDeepCSV_1p5*", - "HLT/BTV/HLT_PFHT400_SixPFJet32_DoublePFBTagDeepCSV_2p94*"] + subDirs = ["HLT/BTV/HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFDiJet30_PFBtagDeepCSV_1p5*", + "HLT/BTV/HLT_DoublePFJets40_CaloBTagDeepCSV_p71*", + "HLT/BTV/HLT_Mu12_DoublePFJets40_CaloBTagDeepCSV_p71*", + ] ) -btaggingClient = cms.Sequence( +btaggingClient = cms.Sequence( BTVEfficiency_TurnOnCurves + BTVEfficiency_OnlineTrackEff + BTVEfficiency_OnlineTrackFake diff --git a/DQMOffline/Trigger/python/BTaggingMonitoring_cff.py b/DQMOffline/Trigger/python/BTaggingMonitoring_cff.py index da05230ad68e0..5cf11b2426308 100644 --- a/DQMOffline/Trigger/python/BTaggingMonitoring_cff.py +++ b/DQMOffline/Trigger/python/BTaggingMonitoring_cff.py @@ -125,116 +125,6 @@ numGenericTriggerEventPSet = dict(hltPaths = ['HLT_PFJet40_v*']) ) - -PFJet60 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/PFJet60', - nmuons = 0, - nelectrons = 0, - njets = 1, - jetSelection = 'pt>50 & abs(eta)<2.4', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_PFJet60_v*']), - histoPSet = dict(jetPtBinning = [0,50,55,60,65,70,80,90,100,120,150,200,400,700,1000,1500,3000]) -) - - -PFJet80 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/PFJet80', - nmuons = 0, - nelectrons = 0, - njets = 1, - jetSelection = 'pt>70 & abs(eta)<2.4', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_PFJet80_v*']), - histoPSet = dict(jetPtBinning = [0,70,75,80,85,90,100,120,150,200,400,700,1000,1500,3000]) -) - - -PFJet140 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/PFJet140', - nmuons = 0, - nelectrons = 0, - njets = 1, - jetSelection = 'pt>120 & abs(eta)<2.4', - histoPSet = dict(jetPtBinning = [0,120,130,140,150,160,170,200,400,700,1000,1500,3000]), - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_PFJet140_v*']) -) - - -PFJet200 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/PFJet200', - nmuons = 0, - nelectrons = 0, - njets = 1, - jetSelection = 'pt>170 & abs(eta)<2.4', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_PFJet200_v*']), - histoPSet = dict(jetPtBinning = [0,170,180,190,200,210,220,250,300,400,700,1000,1500,3000]) -) - - -PFJet260 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/PFJet260', - nmuons = 0, - nelectrons = 0, - njets = 1, - jetSelection = 'pt>220 & abs(eta)<2.4', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_PFJet260_v*']), - histoPSet = dict(jetPtBinning = [0,220,240,260,280,300,350,400,700,1000,1500,3000]) -) - - -PFJet320 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/PFJet320', - nmuons = 0, - nelectrons = 0, - njets = 1, - jetSelection = 'pt>280 & abs(eta)<2.4', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_PFJet320_v*']), - histoPSet = dict(jetPtBinning = [0,280,300,320,340,360,400,500,700,1000,1500,3000]) -) - - -PFJet400 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/PFJet400', - nmuons = 0, - nelectrons = 0, - njets = 1, - jetSelection = 'pt>350 & abs(eta)<2.4', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_PFJet400_v*']), - histoPSet = dict(jetPtBinning = [0,350,380,400,420,450,500,700,1000,1500,3000]) -) - - -PFJet450 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/PFJet450', - nmuons = 0, - nelectrons = 0, - njets = 1, - jetSelection = 'pt>400 & abs(eta)<2.4', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_PFJet450_v*']), - histoPSet = dict(jetPtBinning = [0,400,430,450,470,500,700,1000,1500,3000]) -) - - -PFJet500 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/PFJet500', - nmuons = 0, - nelectrons = 0, - njets = 1, - jetSelection = 'pt>450 & abs(eta)<2.4', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_PFJet500_v*']), - histoPSet = dict(jetPtBinning = [0,450,480,500,520,550,600,700,1000,1500,3000]) -) - - -PFJet550 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/PFJet550', - nmuons = 0, - nelectrons = 0, - njets = 1, - jetSelection = 'pt>500 & abs(eta)<2.4', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_PFJet550_v*']), - histoPSet = dict(jetPtBinning = [0,500,520,550,600,700,1000,1500,3000]) -) - # PFJet AK8 AK8PFJet40 = hltBTVmonitoring.clone( FolderName = 'HLT/BTV/PFJet/AK8PFJet40', @@ -248,126 +138,6 @@ histoPSet = dict(jetPtBinning = [0,30,35,40,45,50,60,70,100,150,200,400,700,1000,1500,3000]) ) - -AK8PFJet60 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/AK8PFJet60', - nmuons = 0, - nelectrons = 0, - njets = 1, - jets = "ak8PFJetsPuppi", - jetSelection = 'pt>50 & abs(eta)<2.4', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_AK8PFJet60_v*']), - histoPSet = dict(jetPtBinning = [0,50,55,60,65,70,80,90,100,120,150,200,400,700,1000,1500,3000]) -) - -AK8PFJet80 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/AK8PFJet80', - nmuons = 0, - nelectrons = 0, - njets = 1, - jets = "ak8PFJetsPuppi", - jetSelection = 'pt>70 & abs(eta)<2.4', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_AK8PFJet80_v*']), - histoPSet = dict(jetPtBinning = [0,70,75,80,85,90,100,120,150,200,400,700,1000,1500,3000]) -) - - -AK8PFJet140 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/AK8PFJet140', - nmuons = 0, - nelectrons = 0, - njets = 1, - jets = "ak8PFJetsPuppi", - jetSelection = 'pt>120 & abs(eta)<2.4', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_AK8PFJet140_v*']), - histoPSet = dict(jetPtBinning = [0,120,130,140,150,160,170,200,400,700,1000,1500,3000]) -) - - -AK8PFJet200 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/AK8PFJet200', - nmuons = 0, - nelectrons = 0, - njets = 1, - jets = "ak8PFJetsPuppi", - jetSelection = 'pt>170 & abs(eta)<2.4', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_AK8PFJet200_v*']), - histoPSet = dict(jetPtBinning = [0,170,180,190,200,210,220,250,300,400,700,1000,1500,3000]) -) - - -AK8PFJet260 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/AK8PFJet260', - nmuons = 0, - nelectrons = 0, - njets = 1, - jets = "ak8PFJetsPuppi", - jetSelection = 'pt>220 & abs(eta)<2.4', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_AK8PFJet260_v*']), - histoPSet = dict(jetPtBinning = [0,220,240,260,280,300,350,400,700,1000,1500,3000]) -) - - -AK8PFJet320 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/AK8PFJet320', - nmuons = 0, - nelectrons = 0, - njets = 1, - jets = "ak8PFJetsPuppi", - jetSelection = 'pt>280 & abs(eta)<2.4', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_AK8PFJet320_v*']), - histoPSet = dict(jetPtBinning = [0,280,300,320,340,360,400,500,700,1000,1500,3000]) -) - - -AK8PFJet400 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/AK8PFJet400', - nmuons = 0, - nelectrons = 0, - njets = 1, - jets = "ak8PFJetsPuppi", - jetSelection = 'pt>350 & abs(eta)<2.4', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_AK8PFJet400_v*']), - histoPSet = dict(jetPtBinning = [0,350,380,400,420,450,500,700,1000,1500,3000]) -) - - -AK8PFJet450 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/AK8PFJet450', - nmuons = 0, - nelectrons = 0, - njets = 1, - jets = "ak8PFJetsPuppi", - jetSelection = 'pt>400 & abs(eta)<2.4', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_AK8PFJet450_v*']), - histoPSet = dict(jetPtBinning = [0,400,430,450,470,500,700,1000,1500,3000]) -) - - -AK8PFJet500 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/AK8PFJet500', - nmuons = 0, - nelectrons = 0, - njets = 1, - jets = "ak8PFJetsPuppi", - jetSelection = 'pt>450 & abs(eta)<2.4', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_AK8PFJet500_v*']), - histoPSet = dict(jetPtBinning = [0,450,480,500,520,550,600,700,1000,1500,3000]) -) - - -AK8PFJet550 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/AK8PFJet550', - nmuons = 0, - nelectrons = 0, - njets = 1, - jets = "ak8PFJetsPuppi", - jetSelection = 'pt>500 & abs(eta)<2.4', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_AK8PFJet550_v*']), - histoPSet = dict(jetPtBinning = [0,500,520,550,600,700,1000,1500,3000]) -) - - # PFJetFwd AK4 PFJetFwd40 = hltBTVmonitoring.clone( FolderName = 'HLT/BTV/PFJet/PFJetFwd40', @@ -385,150 +155,6 @@ ) ) - -PFJetFwd60 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/PFJetFwd60', - nmuons = 0, - nelectrons = 0, - njets = 1, - jetSelection = 'pt>50 & abs(eta)>2.7 & abs(eta)<5.0', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_PFJetFwd60_v*']), - histoPSet = dict( - jetPtBinning = [0,50,55,60,65,70,80,90,100,120,150,200,400,700,1000,1500,3000], - jetEtaBinning = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - jetEtaBinning2D = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - etaPSet = dict(nbins=50, xmin=-5.0, xmax=5.0) - ) -) - - -PFJetFwd80 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/PFJetFwd80', - nmuons = 0, - nelectrons = 0, - njets = 1, - jetSelection = 'pt>70 & abs(eta)>2.7 & abs(eta)<5.0', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_PFJetFwd80_v*']), - histoPSet = dict( - jetPtBinning = [0,70,75,80,85,90,100,120,150,200,400,700,1000,1500,3000], - jetEtaBinning = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - jetEtaBinning2D = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - etaPSet = dict(nbins=50, xmin=-5.0, xmax=5.0) - ) -) - - -PFJetFwd140 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/PFJetFwd140', - nmuons = 0, - nelectrons = 0, - njets = 1, - jetSelection = 'pt>120 & abs(eta)>2.7 & abs(eta)<5.0', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_PFJetFwd140_v*']), - histoPSet = dict( - jetPtBinning = [0,120,130,140,150,160,170,200,400,700,1000,1500,3000], - jetEtaBinning = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - jetEtaBinning2D = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - etaPSet = dict(nbins=50, xmin=-5.0, xmax=5.0) - ) -) - - -PFJetFwd200 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/PFJetFwd200', - nmuons = 0, - nelectrons = 0, - njets = 1, - jetSelection = 'pt>170 & abs(eta)>2.7 & abs(eta)<5.0', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_PFJetFwd200_v*']), - histoPSet = dict( - jetPtBinning = [0,170,180,190,200,210,220,250,300,400,700,1000,1500,3000], - jetEtaBinning = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - jetEtaBinning2D = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - etaPSet = dict(nbins=50, xmin=-5.0, xmax=5.0) - ) -) - - -PFJetFwd260 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/PFJetFwd260', - nmuons = 0, - nelectrons = 0, - njets = 1, - jetSelection = 'pt>220 & abs(eta)>2.7 & abs(eta)<5.0', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_PFJetFwd260_v*']), - histoPSet = dict( - jetPtBinning = [0,220,240,260,280,300,350,400,700,1000,1500,3000], - jetEtaBinning = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - jetEtaBinning2D = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - etaPSet = dict(nbins=50, xmin=-5.0, xmax=5.0) - ) -) - - -PFJetFwd320 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/PFJetFwd320', - nmuons = 0, - nelectrons = 0, - njets = 1, - jetSelection = 'pt>280 & abs(eta)>2.7 & abs(eta)<5.0', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_PFJetFwd320_v*']), - histoPSet = dict( - jetPtBinning = [0,280,300,320,340,360,400,500,700,1000,1500,3000], - jetEtaBinning = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - jetEtaBinning2D = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - etaPSet = dict(nbins=50, xmin=-5.0, xmax=5.0) - ) -) - - -PFJetFwd400 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/PFJetFwd400', - nmuons = 0, - nelectrons = 0, - njets = 1, - jetSelection = 'pt>350 & abs(eta)>2.7 & abs(eta)<5.0', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_PFJetFwd400_v*']), - histoPSet = dict( - jetPtBinning = [0,350,380,400,420,450,500,700,1000,1500,3000], - jetEtaBinning = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - jetEtaBinning2D = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - etaPSet = dict(nbins=50, xmin=-5.0, xmax=5.0) - ) -) - - -PFJetFwd450 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/PFJetFwd450', - nmuons = 0, - nelectrons = 0, - njets = 1, - jetSelection = 'pt>400 & abs(eta)>2.7 & abs(eta)<5.0', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_PFJetFwd450_v*']), - histoPSet = dict( - jetPtBinning = [0,400,430,450,470,500,700,1000,1500,3000], - jetEtaBinning = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - jetEtaBinning2D = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - etaPSet = dict(nbins=50, xmin=-5.0, xmax=5.0) - ) -) - - -PFJetFwd500 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/PFJetFwd500', - nmuons = 0, - nelectrons = 0, - njets = 1, - jetSelection = 'pt>450 & abs(eta)>2.7 & abs(eta)<5.0', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_PFJetFwd500_v*']), - histoPSet = dict( - jetPtBinning = [0,450,480,500,520,550,600,700,1000,1500,3000], - jetEtaBinning = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - jetEtaBinning2D = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - etaPSet = dict(nbins=50, xmin=-5.0, xmax=5.0) - ) -) - # PFJetFwd AK8 AK8PFJetFwd40 = hltBTVmonitoring.clone( FolderName = 'HLT/BTV/PFJet/AK8PFJetFwd40', @@ -547,160 +173,6 @@ ) ) - -AK8PFJetFwd60 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/AK8PFJetFwd60', - nmuons = 0, - nelectrons = 0, - njets = 1, - jets = "ak8PFJetsPuppi", - jetSelection = 'pt>50 & abs(eta)>2.7 & abs(eta)<5.0', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_AK8PFJetFwd60_v*']), - histoPSet = dict( - jetPtBinning = [0,50,55,60,65,70,80,90,100,120,150,200,400,700,1000,1500,3000], - jetEtaBinning = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - jetEtaBinning2D = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - etaPSet = dict(nbins=50, xmin=-5.0, xmax=5.0) - ) -) - - -AK8PFJetFwd80 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/AK8PFJetFwd80', - nmuons = 0, - nelectrons = 0, - njets = 1, - jets = "ak8PFJetsPuppi", - jetSelection = 'pt>70 & abs(eta)>2.7 & abs(eta)<5.0', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_AK8PFJetFwd80_v*']), - histoPSet = dict( - jetPtBinning = [0,70,75,80,85,90,100,120,150,200,400,700,1000,1500,3000], - jetEtaBinning = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - jetEtaBinning2D = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - etaPSet = dict(nbins=50, xmin=-5.0, xmax=5.0) - ) -) - - -AK8PFJetFwd140 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/AK8PFJetFwd140', - nmuons = 0, - nelectrons = 0, - njets = 1, - jets = "ak8PFJetsPuppi", - jetSelection = 'pt>120 & abs(eta)>2.7 & abs(eta)<5.0', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_AK8PFJetFwd140_v*']), - histoPSet = dict( - jetPtBinning = [0,120,130,140,150,160,170,200,400,700,1000,1500,3000], - jetEtaBinning = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - jetEtaBinning2D = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - etaPSet = dict(nbins=50, xmin=-5.0, xmax=5.0) - ) -) - - -AK8PFJetFwd200 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/AK8PFJetFwd200', - nmuons = 0, - nelectrons = 0, - njets = 1, - jets = "ak8PFJetsPuppi", - jetSelection = 'pt>170 & abs(eta)>2.7 & abs(eta)<5.0', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_AK8PFJetFwd200_v*']), - histoPSet = dict( - jetPtBinning = [0,170,180,190,200,210,220,250,300,400,700,1000,1500,3000], - jetEtaBinning = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - jetEtaBinning2D = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - etaPSet = dict(nbins=50, xmin=-5.0, xmax=5.0) - ) -) - - -AK8PFJetFwd260 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/AK8PFJetFwd260', - nmuons = 0, - nelectrons = 0, - njets = 1, - jets = "ak8PFJetsPuppi", - jetSelection = 'pt>220 & abs(eta)>2.7 & abs(eta)<5.0', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_AK8PFJetFwd260_v*']), - histoPSet = dict( - jetPtBinning = [0,220,240,260,280,300,350,400,700,1000,1500,3000], - jetEtaBinning = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - jetEtaBinning2D = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - etaPSet = dict(nbins=50, xmin=-5.0, xmax=5.0) - ) -) - - -AK8PFJetFwd320 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/AK8PFJetFwd320', - nmuons = 0, - nelectrons = 0, - njets = 1, - jets = "ak8PFJetsPuppi", - jetSelection = 'pt>280 & abs(eta)>2.7 & abs(eta)<5.0', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_AK8PFJetFwd320_v*']), - histoPSet = dict( - jetPtBinning = [0,280,300,320,340,360,400,500,700,1000,1500,3000], - jetEtaBinning = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - jetEtaBinning2D = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - etaPSet = dict(nbins = 50, xmin = -5.0, xmax = 5.0) - ) -) - - -AK8PFJetFwd400 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/AK8PFJetFwd400', - nmuons = 0, - nelectrons = 0, - njets = 1, - jets = "ak8PFJetsPuppi", - jetSelection = 'pt>350 & abs(eta)>2.7 & abs(eta)<5.0', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_AK8PFJetFwd400_v*']), - histoPSet = dict( - jetPtBinning = [0,350,380,400,420,450,500,700,1000,1500,3000], - jetEtaBinning = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - jetEtaBinning2D = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - etaPSet = dict(nbins=50, xmin=-5.0, xmax=5.0) - ) -) - - -AK8PFJetFwd450 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/AK8PFJetFwd450', - nmuons = 0, - nelectrons = 0, - njets = 1, - jets = "ak8PFJetsPuppi", - jetSelection = 'pt>400 & abs(eta)>2.7 & abs(eta)<5.0', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_AK8PFJetFwd450_v*']), - histoPSet = dict( - jetPtBinning = [0,400,430,450,470,500,700,1000,1500,3000], - jetEtaBinning = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - jetEtaBinning2D = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - etaPSet = dict(nbins=50, xmin=-5.0, xmax=5.0) - ) -) - - -AK8PFJetFwd500 = hltBTVmonitoring.clone( - FolderName = 'HLT/BTV/PFJet/AK8PFJetFwd500', - nmuons = 0, - nelectrons = 0, - njets = 1, - jets = "ak8PFJetsPuppi", - jetSelection = 'pt>450 & abs(eta)>2.7 & abs(eta)<5.0', - numGenericTriggerEventPSet = dict(hltPaths = ['HLT_AK8PFJetFwd500_v*']), - histoPSet = dict( - jetPtBinning = [0,450,480,500,520,550,600,700,1000,1500,3000], - jetEtaBinning = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - jetEtaBinning2D = [-5.0,-4.7,-4.4,-4.1,-3.8,-3.5,-3.2,-2.9,-2.7,-2.4,-2.1,0.0,2.1,2.4,2.7,2.9,3.2,3.5,3.8,4.1,4.4,4.7,5.0], - etaPSet = dict(nbins=50, xmin=-5.0, xmax=5.0) - ) -) - - ### Sequences btagMonitorHLT = cms.Sequence( @@ -717,45 +189,7 @@ btvHLTDQMSourceExtra = cms.Sequence( PFJet40 - + PFJet60 - + PFJet80 - + PFJet140 - + PFJet200 - + PFJet260 - + PFJet320 - + PFJet400 - + PFJet450 - + PFJet500 - + PFJet550 + AK8PFJet40 - + AK8PFJet60 - + AK8PFJet80 - + AK8PFJet140 - + AK8PFJet200 - + AK8PFJet260 - + AK8PFJet320 - + AK8PFJet400 - + AK8PFJet450 - + AK8PFJet500 - + AK8PFJet550 + PFJetFwd40 - + PFJetFwd60 - + PFJetFwd80 - + PFJetFwd140 - + PFJetFwd200 - + PFJetFwd260 - + PFJetFwd320 - + PFJetFwd400 - + PFJetFwd450 - + PFJetFwd500 + AK8PFJetFwd40 - + AK8PFJetFwd60 - + AK8PFJetFwd80 - + AK8PFJetFwd140 - + AK8PFJetFwd200 - + AK8PFJetFwd260 - + AK8PFJetFwd320 - + AK8PFJetFwd400 - + AK8PFJetFwd450 - + AK8PFJetFwd500 ) diff --git a/DQMOffline/Trigger/python/DQMOffline_HLT_Client_cff.py b/DQMOffline/Trigger/python/DQMOffline_HLT_Client_cff.py index 017ab681044ce..da2753f186c16 100644 --- a/DQMOffline/Trigger/python/DQMOffline_HLT_Client_cff.py +++ b/DQMOffline/Trigger/python/DQMOffline_HLT_Client_cff.py @@ -28,6 +28,7 @@ from DQMOffline.Trigger.BPHMonitoring_Client_cff import * from DQMOffline.Trigger.JetMETPromptMonitoring_Client_cff import * from DQMOffline.Trigger.DiJetMonitor_Client_cff import * +from DQMOffline.Trigger.BTagAndProbeMonitoring_Client_cff import * hltOfflineDQMClient = cms.Sequence( # hltGeneralSeqClient @@ -55,6 +56,7 @@ * bphClient * JetMetPromClient * dijetClient + * BTagAndProbeClient ) hltOfflineDQMClientExtra = cms.Sequence( diff --git a/DQMOffline/Trigger/python/DQMOffline_Trigger_cff.py b/DQMOffline/Trigger/python/DQMOffline_Trigger_cff.py index 7bf0e54efa33d..3cc2b42a5da59 100644 --- a/DQMOffline/Trigger/python/DQMOffline_Trigger_cff.py +++ b/DQMOffline/Trigger/python/DQMOffline_Trigger_cff.py @@ -34,6 +34,11 @@ from DQMOffline.Trigger.BTVHLTOfflineSource_cfi import * from DQMOffline.Trigger.BTaggingMonitoring_cff import * +#BTag and Probe monitoring +from DQMOffline.Trigger.BTagAndProbeMonitor_cfi import * +from DQMOffline.Trigger.BTagAndProbeMonitoring_cff import * + + # vertexing from DQMOffline.Trigger.PrimaryVertexMonitoring_cff import * @@ -187,8 +192,9 @@ sistripMonitorHLTsequence * # strip sipixelMonitorHLTsequence * # pixel BTVHLTOfflineSource * # BTV - bTagHLTTrackMonitoringSequence * # BTV relative track efficeicies + bTagHLTTrackMonitoringSequence * # BTV relative track efficiencies trackingMonitorHLT * # tracking + BTagAndProbeHLT * #BTag and Probe trackingMonitorHLTDisplacedJet* # EXO : DisplacedJet Tracking egmTrackingMonitorHLT * # EGM tracking hltToOfflineTrackValidatorSequence * # Relative Online to Offline performace diff --git a/HLTriggerOffline/Btag/python/HltBtagValidation_cff.py b/HLTriggerOffline/Btag/python/HltBtagValidation_cff.py index 2a30fcaf4838c..f2d78a29711f3 100644 --- a/HLTriggerOffline/Btag/python/HltBtagValidation_cff.py +++ b/HLTriggerOffline/Btag/python/HltBtagValidation_cff.py @@ -26,7 +26,7 @@ 'HLT_PFHT400_SixPFJet32_DoublePFBTagDeepCSV_', 'HLT_IsoMu24_eta2p1_v', 'HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFDiJet30_PFBtagDeepCSV_1p5', - 'HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_CaloDiJet30_CaloBtagDeepCSV_1p5' + 'HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_CaloDiJet30_CaloBtagDeepCSV_1p5', 'HLT_BTagMu_AK4DiJet20_Mu5_v', ), Vertex = cms.VInputTag( diff --git a/HLTriggerOffline/Common/python/HLTValidationHarvest_cff.py b/HLTriggerOffline/Common/python/HLTValidationHarvest_cff.py index 0d54bb6edf854..479588f4167c3 100644 --- a/HLTriggerOffline/Common/python/HLTValidationHarvest_cff.py +++ b/HLTriggerOffline/Common/python/HLTValidationHarvest_cff.py @@ -35,7 +35,7 @@ +hltExoticaPostProcessors +b2gHLTriggerValidationHarvest +HLTSMPPostVal - +HltBTagPostVal + #+HltBTagPostVal ) from Configuration.Eras.Modifier_phase1Pixel_cff import phase1Pixel diff --git a/HLTriggerOffline/Common/python/HLTValidation_cff.py b/HLTriggerOffline/Common/python/HLTValidation_cff.py index 7ac76ddbf0c8f..b2d82801b5d65 100644 --- a/HLTriggerOffline/Common/python/HLTValidation_cff.py +++ b/HLTriggerOffline/Common/python/HLTValidation_cff.py @@ -57,7 +57,7 @@ +ExoticaValidationSequence +b2gHLTriggerValidation +SMPValidationSequence - +hltbtagValidationSequence #too noisy for now + #+hltbtagValidationSequence #too noisy for now +hltHCALdigisAnalyzer+hltHCALRecoAnalyzer+hltHCALNoiseRates # HCAL )