diff --git a/DQM/Physics/python/DQMPhysics_cff.py b/DQM/Physics/python/DQMPhysics_cff.py index c371cd00dae76..2fc4e2aee7089 100644 --- a/DQM/Physics/python/DQMPhysics_cff.py +++ b/DQM/Physics/python/DQMPhysics_cff.py @@ -18,6 +18,7 @@ from DQM.Physics.CentralitypADQM_cfi import * from DQM.Physics.topJetCorrectionHelper_cfi import * from DQM.Physics.FSQDQM_cfi import * +from DQM.Physics.SMPDQM_cfi import * dqmPhysics = cms.Sequence( bphysicsOniaDQM # Empty Histograms from EWK and Error log messages @@ -36,6 +37,7 @@ *ExoticaDQM *B2GDQM *FSQDQM + *SMPDQM ) from Configuration.Eras.Modifier_phase1Pixel_cff import phase1Pixel diff --git a/DQM/Physics/python/SMPDQM_cfi.py b/DQM/Physics/python/SMPDQM_cfi.py new file mode 100644 index 0000000000000..265618a5d30c4 --- /dev/null +++ b/DQM/Physics/python/SMPDQM_cfi.py @@ -0,0 +1,11 @@ +import FWCore.ParameterSet.Config as cms + +from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer +SMPDQM= DQMEDAnalyzer('SMPDQM', + pvs = cms.InputTag('offlinePrimaryVertices'), + jets = cms.InputTag("ak4PFJetsCHS"), + mets = cms.VInputTag("pfMet"), + elecCollection = cms.InputTag('gedGsfElectrons'), + muonCollection = cms.InputTag('muons'), + pfMETCollection = cms.InputTag("pfMet"), + ) diff --git a/DQM/Physics/src/SMPDQM.cc b/DQM/Physics/src/SMPDQM.cc new file mode 100644 index 0000000000000..2126dc370fe86 --- /dev/null +++ b/DQM/Physics/src/SMPDQM.cc @@ -0,0 +1,273 @@ +#include "DQM/Physics/src/SMPDQM.h" + +using namespace std; +using namespace reco; + +struct SortByPt + +{ + bool operator()(const TLorentzVector& a, const TLorentzVector& b) const { return a.Pt() > b.Pt(); } +}; +SMPDQM::SMPDQM(const edm::ParameterSet& iConfig) { + //now do what ever initialization is needed + muons_ = consumes(iConfig.getParameter("muonCollection")); + pvs_ = consumes>(iConfig.getParameter("pvs")); + + elecs_ = consumes(iConfig.getParameter("elecCollection")); + jets_ = consumes>(iConfig.getParameter("jets")); + + for (edm::InputTag const& tag : iConfig.getParameter>("mets")) + mets_.push_back(consumes>(tag)); +} + +SMPDQM::~SMPDQM() { + // do anything here that needs to be done at desctruction time + // (e.g. close files, deallocate resources etc.) +} +// ------------ method called for each event ------------ +void SMPDQM::bookHistograms(DQMStore::IBooker& bei, edm::Run const&, edm::EventSetup const&) { + bei.setCurrentFolder("Physics/SMP"); + + NPV = bei.book1D("NPV", "Number of primary vertices", 40, 0., 80.); + MET = bei.book1D("MET", "MET", 100, 0.0, 200); + METphi = bei.book1D("METphi", "#phi(MET)", 50, -3.14, 3.14); + + pt_muons = bei.book1D("pt_muons", "p_{T}(muons)", 40, 0., 200.); + eta_muons = bei.book1D("eta_muons", "#eta(muons)", 50, -5., 5.); + phi_muons = bei.book1D("phi_muons", "#phi(muons)", 32, -3.2, 3.2); + muIso_CombRelIso03 = bei.book1D("muIso_CombRelIso03", "Iso_{rel}^{#mu}", 20, 0., 1.); + Nmuons = bei.book1D("Nmuons", "Number of muons", 20, 0., 10.); + isGlobalmuon = bei.book1D("isGlobalmuon", "isGlobalmuon", 2, 0, 1); + isTrackermuon = bei.book1D("isTrackermuon", "isTrackermuon", 2, 0, 1); + isStandalonemuon = bei.book1D("isStandalonemuon", "isStandalonemuon", 2, 0, 1); + isPFmuon = bei.book1D("isPFmuon", "isPFmuon", 2, 0, 1); + muIso_TrackerBased03 = bei.book1D("muIso_TrackerBased03", "Iso_{trk03}^{#mu}", 20, 0, 10); + + Nelecs = bei.book1D("Nelecs", "Number of electrons", 20, 0., 10.); + HoverE_elecs = bei.book1D("HoverE_elecs", "HoverE", 50, 0., 1.); + pt_elecs = bei.book1D("pt_elecs", "p_{T}(elecs)", 40, 0., 200.); + eta_elecs = bei.book1D("eta_elecs", "#eta(elecs)", 50, -5., 5.); + phi_elecs = bei.book1D("phi_elecs", "#phielecs)", 32, -3.2, 3.2); + elIso_cal = bei.book1D("elIso_cal", "Iso_{cal}^{el}", 21, -1., 20.); + elIso_trk = bei.book1D("elIso_trk", "Iso_{trk}^{el}", 21, -2., 40.); + elIso_CombRelIso = bei.book1D("elIso_CombRelIso", "Iso_{rel}^{el}", 20, 0., 1.); + + PFJetpt = bei.book1D("PFJetpt", "p_{T}(jets)", 100, 0.0, 100); + PFJeteta = bei.book1D("PFJeteta", "#eta(jets)", 50, -2.5, 2.5); + PFJetphi = bei.book1D("PFJetphi", "#phi(jets)", 50, -3.14, 3.14); + PFJetMulti = bei.book1D("PFJetMulti", "jet multiplicity", 5, -0.5, 4.5); + PFJetRapidity = bei.book1D("PFJetRapidity", "y(jets)", 50, -6.0, 6.0); + mjj = bei.book1D("mjj", "m_{jj}", 100, 0, 1000); + detajj = bei.book1D("detajj", "#Delta#etajj", 20, 0, 5); + + dphi_lepMET = bei.book1D("dphi_lepMET", "#Delta#phi(lep,MET)", 60, -3.2, 3.2); + mass_lepMET = bei.book1D("mass_lepMET", "m(lep,MET)", 200, 0, 200); + pt_lepMET = bei.book1D("pt_lepMET", "p_{T}(lep,MET)", 200, 0, 200); + detall = bei.book1D("detall", "#Delta#etall", 20, -5, 5); + dphill = bei.book1D("dphill", "#Delta#phill", 20, -6.4, 6.4); + mll = bei.book1D("mll", "mll", 200, 0, 200); + etall = bei.book1D("etall", "#Delta#etall", 60, -6, 6); + ptll = bei.book1D("ptll", "p_{T}ll", 200, 0, 200); + mjj = bei.book1D("mjj", "mjj", 100, 0, 1000); + detajj = bei.book1D("detajj", "#Delta#etajj", 20, 0, 5); + + dphi_lepjet1 = bei.book1D("dphi_lepjet1", "#Delta#phi(lep,jet1)", 60, -3.2, 3.2); + + dphi_lep1jet1 = bei.book1D("dphi_lep1jet1", "#Delta#phi(lep1,jet1)", 60, -3.2, 3.2); + dphi_lep2jet1 = bei.book1D("dphi_lep2jet1", "#Delta#phi(lep2,jet1)", 60, -3.2, 3.2); +} +void SMPDQM::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { + std::vector recoPFJets; + recoPFJets.clear(); + TLorentzVector imet; + imet.Clear(); + std::vector selected_recoPFJets; + selected_recoPFJets.clear(); + std::vector selected_lep; + selected_lep.clear(); + + for (std::vector>>::const_iterator met_ = mets_.begin(); met_ != mets_.end(); + ++met_) { + edm::Handle> met; + if (!iEvent.getByToken(*met_, met)) + continue; + if (met->begin() != met->end()) { + MET->Fill(met->begin()->et()); + METphi->Fill(met->begin()->phi()); + imet.SetPtEtaPhiM(met->begin()->et(), 0., met->begin()->phi(), 0.0); + } + } + + // Muons + + edm::Handle> pvs; + if (!iEvent.getByToken(pvs_, pvs)) { + return; + } + + unsigned int pvMult = 0; + + for (edm::View::const_iterator pv = pvs->begin(); pv != pvs->end(); ++pv) { + if (pv->position().Rho() < 2 && abs(pv->position().z()) <= 24. && pv->ndof() > 4 && !pv->isFake()) { + pvMult++; + } + } + NPV->Fill(pvMult); + + edm::Handle muons; + iEvent.getByToken(muons_, muons); + reco::MuonCollection::const_iterator mu; + if (!muons.failedToGet()) { + Nmuons->Fill(muons->size()); + + for (mu = muons->begin(); mu != muons->end(); ++mu) { + if (mu->pt() < 3.0) + continue; + TLorentzVector Mu; + Mu.SetPtEtaPhiM(mu->pt(), mu->eta(), mu->phi(), 0.0); + selected_lep.push_back(Mu); + pt_muons->Fill(mu->pt()); + eta_muons->Fill(mu->eta()); + phi_muons->Fill(mu->phi()); + isGlobalmuon->Fill(mu->isGlobalMuon()); + isTrackermuon->Fill(mu->isTrackerMuon()); + isStandalonemuon->Fill(mu->isStandAloneMuon()); + isPFmuon->Fill(mu->isPFMuon()); + + reco::MuonIsolation muIso03 = mu->isolationR03(); + double muonCombRelIso = 1.; + + muonCombRelIso = (muIso03.emEt + muIso03.hadEt + muIso03.hoEt + muIso03.sumPt) / mu->pt(); + + muIso_TrackerBased03->Fill(muIso03.sumPt / mu->pt()); + muIso_CombRelIso03->Fill(muonCombRelIso); + + } //size of muons + + } // muons + + // electrons + + edm::Handle elecs; + iEvent.getByToken(elecs_, elecs); + reco::GsfElectronCollection::const_iterator elec; + + if (!elecs.failedToGet()) { + Nelecs->Fill(elecs->size()); + + for (elec = elecs->begin(); elec != elecs->end(); ++elec) { + if (elec->pt() < 5.0) + continue; + TLorentzVector El; + El.SetPtEtaPhiM(elec->pt(), elec->eta(), elec->phi(), 0.0); + selected_lep.push_back(El); + + HoverE_elecs->Fill(elec->hcalOverEcal()); + pt_elecs->Fill(elec->pt()); + eta_elecs->Fill(elec->eta()); + phi_elecs->Fill(elec->phi()); + + reco::GsfTrackRef track = elec->gsfTrack(); + reco::GsfElectron::IsolationVariables elecIso = elec->dr03IsolationVariables(); + + double elecCombRelIso = 1.; + + elecCombRelIso = (elecIso.ecalRecHitSumEt + elecIso.hcalDepth1TowerSumEt + elecIso.tkSumPt) / elec->pt(); + elIso_CombRelIso->Fill(elecCombRelIso); + elIso_cal->Fill(elecIso.ecalRecHitSumEt); + elIso_trk->Fill(elecIso.tkSumPt); + } + + } // electrons + // jets + + edm::Handle> jets; + if (!iEvent.getByToken(jets_, jets)) { + return; + } + + for (edm::View::const_iterator jet = jets->begin(); jet != jets->end(); ++jet) { + if (jet->pt() < 15.0) + continue; + TLorentzVector ijet; + ijet.SetPtEtaPhiM(jet->pt(), jet->eta(), jet->phi(), jet->mass()); + recoPFJets.push_back(ijet); + } + + std::sort(recoPFJets.begin(), recoPFJets.end(), SortByPt()); + std::sort(selected_lep.begin(), selected_lep.end(), SortByPt()); + + for (unsigned int i = 0; i < recoPFJets.size(); i++) { + bool goodjet = false; + for (unsigned int j = 0; j < selected_lep.size(); j++) { + if (recoPFJets[i].DeltaR(selected_lep[j]) > 0.4) { + goodjet = true; + continue; + } else { + goodjet = false; + break; + } + } + if (goodjet) { + TLorentzVector temp; + temp.Clear(); + temp.SetPtEtaPhiM(recoPFJets[i].Pt(), recoPFJets[i].Eta(), recoPFJets[i].Phi(), recoPFJets[i].M()); + selected_recoPFJets.push_back(temp); + } + } + + std::sort(selected_recoPFJets.begin(), selected_recoPFJets.end(), SortByPt()); // for safety + int njet = 0; + for (unsigned int k = 0; k < selected_recoPFJets.size(); k++) { + if (k > 4) + break; + else { + njet++; + PFJetpt->Fill(selected_recoPFJets.at(k).Pt()); + PFJeteta->Fill(selected_recoPFJets.at(k).Eta()); + PFJetphi->Fill(selected_recoPFJets.at(k).Phi()); + PFJetRapidity->Fill(selected_recoPFJets.at(k).Rapidity()); + } + } + PFJetMulti->Fill(njet); + + // now we have selected jet and lepton collections + + if (selected_lep.size() > 1) { + detall->Fill(selected_lep[0].Eta() - selected_lep[1].Eta()); + dphill->Fill(selected_lep[0].DeltaPhi(selected_lep[1])); + mll->Fill((selected_lep[0] + selected_lep[1]).M()); + ptll->Fill((selected_lep[0] + selected_lep[1]).Pt()); + etall->Fill((selected_lep[0] + selected_lep[1]).Eta()); + if (!selected_recoPFJets.empty()) { + dphi_lep1jet1->Fill(selected_recoPFJets[0].DeltaPhi(selected_lep[0])); + dphi_lep2jet1->Fill(selected_recoPFJets[0].DeltaPhi(selected_lep[1])); + } + } + + else if (selected_lep.size() == 1) { + dphi_lepMET->Fill(selected_lep[0].DeltaPhi(imet)); + mass_lepMET->Fill((selected_lep[0] + imet).M()); + pt_lepMET->Fill((selected_lep[0] + imet).Pt()); + if (!selected_recoPFJets.empty()) { + dphi_lepjet1->Fill(selected_recoPFJets[0].DeltaPhi(selected_lep[0])); + } + } // W case + + else { + // std::cout << "zero lepton case" << endl; + } + if (selected_recoPFJets.size() > 1) { + detajj->Fill(abs(selected_recoPFJets[0].Eta() - selected_recoPFJets[1].Eta())); + mjj->Fill((selected_recoPFJets[0] + selected_recoPFJets[1]).M()); + } + +} // analyze + +//define this as a plug-in +//DEFINE_FWK_MODULE(SMPDQM); + +//dilepton eta,pt and phi using lorentz vectors +//first five jets +// dphi(lepton jet) +//vbf detajj, mjj diff --git a/DQM/Physics/src/SMPDQM.h b/DQM/Physics/src/SMPDQM.h new file mode 100644 index 0000000000000..927952c714556 --- /dev/null +++ b/DQM/Physics/src/SMPDQM.h @@ -0,0 +1,161 @@ +#ifndef SMPDQM_H +#define SMPDQM_H +#include + +#include "DQMServices/Core/interface/DQMEDAnalyzer.h" +#include "DQMServices/Core/interface/MonitorElement.h" + +// user include files +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/one/EDAnalyzer.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" + +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "DataFormats/TrackReco/interface/Track.h" +#include "DataFormats/TrackReco/interface/TrackFwd.h" +#include +#include +#include +#include +#include +#include "TFile.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "FWCore/Utilities/interface/EDMException.h" +#include "CommonTools/UtilAlgos/interface/TFileService.h" + +#include "DataFormats/Common/interface/Ref.h" +#include "DataFormats/Common/interface/Handle.h" +#include "DataFormats/Common/interface/TriggerResults.h" +#include "DataFormats/MuonReco/interface/Muon.h" +#include "DataFormats/MuonReco/interface/MuonFwd.h" +#include "DataFormats/MuonReco/interface/MuonEnergy.h" +#include "DataFormats/MuonReco/interface/MuonIsolation.h" +#include "DataFormats/EgammaCandidates/interface/Electron.h" +#include "DataFormats/EgammaCandidates/interface/ElectronFwd.h" +#include "DataFormats/EgammaCandidates/interface/GsfElectron.h" +#include "DataFormats/EgammaCandidates/interface/GsfElectronFwd.h" +#include "DataFormats/GsfTrackReco/interface/GsfTrack.h" +#include "DataFormats/VertexReco/interface/Vertex.h" +#include "DataFormats/VertexReco/interface/VertexFwd.h" +#include "DataFormats/JetReco/interface/PFJet.h" +#include "JetMETCorrections/JetCorrector/interface/JetCorrector.h" +#include "JetMETCorrections/Objects/interface/JetCorrector.h" +#include "DataFormats/METReco/interface/CaloMET.h" +#include "DataFormats/Common/interface/ValueMap.h" +#include "TLorentzVector.h" +#include "DataFormats/Math/interface/deltaR.h" +#include "TrackingTools/TransientTrack/interface/TransientTrack.h" +#include "TrackingTools/TransientTrack/interface/TransientTrackBuilder.h" +#include "TrackingTools/Records/interface/TransientTrackRecord.h" +#include "RecoTracker/Record/interface/TrackerRecoGeometryRecord.h" +#include "Geometry/Records/interface/TrackerDigiGeometryRecord.h" +#include "Geometry/Records/interface/MuonGeometryRecord.h" +#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h" + +#include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h" +#include + +// +// class declaration +// + +// If the analyzer does not use TFileService, please remove +// the template argument to the base class so the class inherits +// from edm::one::EDAnalyzer<> +// This will improve performance in multithreaded jobs. + +//using reco::TrackCollection; +class DQMStore; +class SMPDQM : public DQMEDAnalyzer { +public: + SMPDQM(const edm::ParameterSet &); + ~SMPDQM() override; + +protected: + void analyze(const edm::Event &, const edm::EventSetup &) override; + +private: + void bookHistograms(DQMStore::IBooker &bei, edm::Run const &, edm::EventSetup const &) override; + void bookHistos(DQMStore *bei); + + edm::EDGetTokenT muons_; + edm::EDGetTokenT elecs_; + edm::EDGetTokenT > pvs_; + edm::EDGetTokenT > jets_; + std::vector > > mets_; + //edm::EDGetTokenT thePfMETCollectionToken_; + // ----------member data --------------------------- + + //NPV + MonitorElement *NPV; + //MET + MonitorElement *MET; + MonitorElement *METphi; + //muons + MonitorElement *pt_muons; + MonitorElement *eta_muons; + MonitorElement *phi_muons; + MonitorElement *muIso_CombRelIso03; + MonitorElement *Nmuons; + MonitorElement *isGlobalmuon; + MonitorElement *isTrackermuon; + MonitorElement *isStandalonemuon; + MonitorElement *isPFmuon; + MonitorElement *muIso_TrackerBased03; + //electrons + MonitorElement *Nelecs; + MonitorElement *HoverE_elecs; + MonitorElement *pt_elecs; + MonitorElement *eta_elecs; + MonitorElement *phi_elecs; + MonitorElement *elIso_cal; + MonitorElement *elIso_trk; + MonitorElement *elIso_CombRelIso; + //jets + MonitorElement *PFJetpt; + MonitorElement *PFJeteta; + MonitorElement *PFJetphi; + MonitorElement *PFJetMulti; + MonitorElement *PFJetRapidity; + MonitorElement *mjj; + MonitorElement *detajj; + //lepMET + + MonitorElement *dphi_lepMET; + MonitorElement *mass_lepMET; + MonitorElement *pt_lepMET; + MonitorElement *detall; + MonitorElement *dphill; + MonitorElement *mll; + MonitorElement *etall; + MonitorElement *ptll; + //lepjet1 + MonitorElement *dphi_lepjet1; + MonitorElement *dphi_lep1jet1; + MonitorElement *dphi_lep2jet1; +}; + +// +// constants, enums and typedefs +// + +// +// static data member definitions +// + +// +// constructors and destructor +// + +#endif +// +// member functions +// diff --git a/DQM/Physics/src/plugins.cc b/DQM/Physics/src/plugins.cc index 78cf112ecc6c1..638d42f0b74f4 100644 --- a/DQM/Physics/src/plugins.cc +++ b/DQM/Physics/src/plugins.cc @@ -22,7 +22,7 @@ #include "DQM/Physics/src/CentralityDQM.h" #include "DQM/Physics/src/CentralitypADQM.h" #include "DQM/Physics/src/FSQDQM.h" - +#include "DQM/Physics/src/SMPDQM.h" DEFINE_FWK_MODULE(BPhysicsOniaDQM); DEFINE_FWK_MODULE(EwkDQM); DEFINE_FWK_MODULE(EwkMuDQM); @@ -45,6 +45,7 @@ DEFINE_FWK_MODULE(B2GDQM); DEFINE_FWK_MODULE(CentralityDQM); DEFINE_FWK_MODULE(CentralitypADQM); DEFINE_FWK_MODULE(FSQDQM); +DEFINE_FWK_MODULE(SMPDQM); // Local Variables: // show-trailing-whitespace: t // truncate-lines: t diff --git a/DQM/Physics/test/SMPDQM_cfg.py b/DQM/Physics/test/SMPDQM_cfg.py new file mode 100644 index 0000000000000..8f3324582a9c0 --- /dev/null +++ b/DQM/Physics/test/SMPDQM_cfg.py @@ -0,0 +1,41 @@ +import FWCore.ParameterSet.Config as cms + +process = cms.Process("SMPDQM") +process.load("DQM.Physics.dqmfsq_cfi") +process.load("DQMServices.Core.DQM_cfg") +process.load("DQMServices.Components.DQMEnvironment_cfi") +#process.DQM.collectorHost = '' +process.load("FWCore.MessageService.MessageLogger_cfi") +process.load("Configuration.StandardSequences.GeometryRecoDB_cff") +process.load("Configuration.StandardSequences.MagneticField_cff") +process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") +#from Configuration.AlCa.GlobalTag import GlobalTag +#process.GlobalTag.globaltag='92X_dataRun2_Prompt_v6' + +#process.dqmSaver.workflow = cms.untracked.string('/Physics/SMP/TESTSMP') +process.dqmSaver.workflow = cms.untracked.string('workflow/for/mytest') +process.source = cms.Source("PoolSource", + fileNames = cms.untracked.vstring('/store/relval/CMSSW_11_0_0_pre6/RelValSingleMuPt100_UP18/GEN-SIM-DIGI-RECO/110X_upgrade2018_realistic_v3_FastSim-v1/20000/EC423F2E-1E67-794B-8A88-AACBE3193AF3.root', + '/store/relval/CMSSW_11_0_0_pre6/RelValSingleMuPt100_UP18/GEN-SIM-DIGI-RECO/110X_upgrade2018_realistic_v3_FastSim-v1/20000/6C0A2520-1016-E74A-B1F3-CE94AF3C97ED.root' + ) + ) +process.maxEvents = cms.untracked.PSet( + input = cms.untracked.int32(-1) + ) + +process.MessageLogger = cms.Service("MessageLogger", + destinations = cms.untracked.vstring('detailedInfo'), + detailedInfo = cms.untracked.PSet( + default = cms.untracked.PSet( limit = cms.untracked.int32(10) ), + threshold = cms.untracked.string('INFO') + ) + ) + +#process.demo = cms.EDAnalyzer('SMPDQM') +process.p = cms.Path(process.SMPDQM)#+process.dqmSaver) + + +process.TFileService = cms.Service("TFileService", + fileName = cms.string("Validation.root") + ) +#process.p = cms.Path(process.demo)