From ed98eef0a754c1b3fdcabd60008bd92808b6b1eb Mon Sep 17 00:00:00 2001 From: Davide Bruschini Date: Thu, 12 Oct 2023 15:06:50 +0200 Subject: [PATCH 1/2] Latest updates in DQM/TrackingMonitorSource for data/MC comparisons for the Tracking POG Added switch to run on RECO (StandaloneTrackMonitor loops over recHits, not available in AOD) --- .../plugins/BuildFile.xml | 1 + .../plugins/StandaloneTrackMonitor.cc | 204 ++++++++++++++---- .../python/StandaloneTrackMonitor_cfi.py | 1 + 3 files changed, 166 insertions(+), 40 deletions(-) diff --git a/DQM/TrackingMonitorSource/plugins/BuildFile.xml b/DQM/TrackingMonitorSource/plugins/BuildFile.xml index fc7cdaf9c4fc1..4f22a7d2e249b 100644 --- a/DQM/TrackingMonitorSource/plugins/BuildFile.xml +++ b/DQM/TrackingMonitorSource/plugins/BuildFile.xml @@ -10,6 +10,7 @@ + diff --git a/DQM/TrackingMonitorSource/plugins/StandaloneTrackMonitor.cc b/DQM/TrackingMonitorSource/plugins/StandaloneTrackMonitor.cc index 9c905c664626a..c390913a7471b 100644 --- a/DQM/TrackingMonitorSource/plugins/StandaloneTrackMonitor.cc +++ b/DQM/TrackingMonitorSource/plugins/StandaloneTrackMonitor.cc @@ -20,6 +20,7 @@ #include "DataFormats/TrackerRecHit2D/interface/SiStripMatchedRecHit2D.h" #include "DataFormats/VertexReco/interface/Vertex.h" #include "DataFormats/VertexReco/interface/VertexFwd.h" +#include "DataFormats/Math/interface/deltaR.h" #include "FWCore/Framework/interface/ESHandle.h" #include "FWCore/Framework/interface/Event.h" #include "FWCore/Framework/interface/Frameworkfwd.h" @@ -36,6 +37,9 @@ #include "TrackingTools/Records/interface/TransientTrackRecord.h" #include "TrackingTools/TransientTrack/interface/TransientTrack.h" #include "TrackingTools/TransientTrack/interface/TransientTrackBuilder.h" +#include "RecoVertex/VertexPrimitives/interface/TransientVertex.h" +#include "RecoVertex/KalmanVertexFit/interface/KalmanVertexFitter.h" +#include "RecoVertex/VertexTools/interface/VertexDistance3D.h" // ROOT includes #include "TFile.h" @@ -67,9 +71,13 @@ class StandaloneTrackMonitor : public DQMEDAnalyzer { double wfac = 1); private: + const reco::Vertex* findClosestVertex(const TransientVertex aTransVtx, const reco::VertexCollection* vertices) + const; //same as in /DQMOffline/Alignment/src/DiMuonVertexSelector.cc const std::string moduleName_; const std::string folderName_; + const bool isRECO_; + SiStripClusterInfo siStripClusterInfo_; const edm::InputTag trackTag_; @@ -163,6 +171,13 @@ class StandaloneTrackMonitor : public DQMEDAnalyzer { MonitorElement* sipDxyToPVH_; MonitorElement* sipDzToPVH_; + MonitorElement* ip3dToPV2validpixelhitsH_; + MonitorElement* ip3dToBS2validpixelhitsH_; + MonitorElement* iperr3dToPV2validpixelhitsH_; + MonitorElement* iperr3dToBS2validpixelhitsH_; + MonitorElement* sip3dToPV2validpixelhitsH_; + MonitorElement* sip3dToBS2validpixelhitsH_; + MonitorElement* nallHitsH_; MonitorElement* ntrackerHitsH_; @@ -344,6 +359,8 @@ class StandaloneTrackMonitor : public DQMEDAnalyzer { MonitorElement* Zpt_; MonitorElement* ZInvMass_; + MonitorElement* cosPhi3DdileptonH_; + std::vector lumivec1; std::vector lumivec2; std::vector vpu_; @@ -355,6 +372,7 @@ void StandaloneTrackMonitor::fillDescriptions(edm::ConfigurationDescriptions& de edm::ParameterSetDescription desc; desc.addUntracked("moduleName", "StandaloneTrackMonitor"); desc.addUntracked("folderName", "highPurityTracks"); + desc.addUntracked("isRECO", false); desc.addUntracked("trackInputTag", edm::InputTag("generalTracks")); desc.addUntracked("offlineBeamSpot", edm::InputTag("offlineBeamSpot")); desc.addUntracked("vertexTag", edm::InputTag("offlinePrimaryVertices")); @@ -409,6 +427,7 @@ void StandaloneTrackMonitor::fillDescriptions(edm::ConfigurationDescriptions& de StandaloneTrackMonitor::StandaloneTrackMonitor(const edm::ParameterSet& ps) : moduleName_(ps.getUntrackedParameter("moduleName", "StandaloneTrackMonitor")), folderName_(ps.getUntrackedParameter("folderName", "highPurityTracks")), + isRECO_(ps.getUntrackedParameter("isRECO", false)), siStripClusterInfo_(consumesCollector()), trackTag_(ps.getUntrackedParameter("trackInputTag", edm::InputTag("generalTracks"))), bsTag_(ps.getUntrackedParameter("offlineBeamSpot", edm::InputTag("offlineBeamSpot"))), @@ -572,6 +591,14 @@ StandaloneTrackMonitor::StandaloneTrackMonitor(const edm::ParameterSet& ps) hOffTrkClusChargeThickH_ = nullptr; hOffTrkClusWidthThickH_ = nullptr; + cosPhi3DdileptonH_ = nullptr; + ip3dToPV2validpixelhitsH_ = nullptr; + ip3dToBS2validpixelhitsH_ = nullptr; + iperr3dToPV2validpixelhitsH_ = nullptr; + iperr3dToBS2validpixelhitsH_ = nullptr; + sip3dToPV2validpixelhitsH_ = nullptr; + sip3dToBS2validpixelhitsH_ = nullptr; + // Read pileup weight factors if (isMC_ && doPUCorrection_ && doTrackCorrection_) { @@ -668,21 +695,41 @@ void StandaloneTrackMonitor::bookHistograms(DQMStore::IBooker& ibook, ibook.book1D("trackDeltaRwrtClosestTrack", "min#DeltaR(considered track,other tracks)", 500, 0, 10); ip2dToPVH_ = ibook.book1D("ip2dToPV", "IP in 2d To PV", 1000, -1.0, 1.0); - iperr2dToPVH_ = ibook.book1D("iperr2dToPV", "IP error in 2d To PV", 50, 0, 4); - iperr2dToPVWtH_ = ibook.book1D("iperr2dToPVWt", "IP error in 2d To PV", 50, 0, 4); + unsigned int niperrbins = 100; + float iperrbinning[niperrbins + 1]; + float miniperr = 0.0001, maxiperr = 5; + iperrbinning[0] = miniperr; + for (unsigned int i = 1; i != niperrbins + 1; i++) { + iperrbinning[i] = iperrbinning[i - 1] * pow(maxiperr / miniperr, 1. / niperrbins); + } + iperr2dToPVH_ = ibook.book1D("iperr2dToPV", "IP error in 2d To PV", niperrbins, iperrbinning); + iperr2dToPVWtH_ = ibook.book1D("iperr2dToPVWt", "IP error in 2d To PV", niperrbins, iperrbinning); ip3dToPVH_ = ibook.book1D("ip3dToPV", "IP in 3d To PV", 200, -20, 20); ip3dToBSH_ = ibook.book1D("ip3dToBS", "IP in 3d To BS", 200, -20, 20); - iperr3dToPVH_ = ibook.book1D("iperr3dToPV", "IP error in 3d To PV", 100, 0, 5); - iperr3dToBSH_ = ibook.book1D("iperr3dToBS", "IP error in 3d To BS", 100, 0, 5); + iperr3dToPVH_ = ibook.book1D("iperr3dToPV", "IP error in 3d To PV", niperrbins, iperrbinning); + iperr3dToBSH_ = ibook.book1D("iperr3dToBS", "IP error in 3d To BS", niperrbins, iperrbinning); sip3dToPVH_ = ibook.book1D("sip3dToPV", "IP significance in 3d To PV", 200, -10, 10); sip3dToBSH_ = ibook.book1D("sip3dToBS", "IP significance in 3d To BS", 200, -10, 10); + ip3dToPV2validpixelhitsH_ = + ibook.book1D("ip3dToPV2validpixelhits", "IP in 3d To PV (nValidPixelHits>2)", 200, -0.20, 0.20); + ip3dToBS2validpixelhitsH_ = + ibook.book1D("ip3dToBS2validpixelhits", "IP in 3d To BS (nValidPixelHits>2)", 200, -0.20, 0.20); + iperr3dToPV2validpixelhitsH_ = ibook.book1D( + "iperr3dToPV2validpixelhits", "IP error in 3d To PV (nValidPixelHits>2)", niperrbins, iperrbinning); + iperr3dToBS2validpixelhitsH_ = ibook.book1D( + "iperr3dToBS2validpixelhits", "IP error in 3d To BS (nValidPixelHits>2)", niperrbins, iperrbinning); + sip3dToPV2validpixelhitsH_ = + ibook.book1D("sip3dToPV2validpixelhits", "IP significance in 3d To PV (nValidPixelHits>2)", 200, -10, 10); + sip3dToBS2validpixelhitsH_ = + ibook.book1D("sip3dToBS2validpixelhits", "IP significance in 3d To BS (nValidPixelHits>2)", 200, -10, 10); + ip2dToBSH_ = ibook.book1D("ip2dToBS", "IP in 2d To BS", 1000, -1., 1.); //Beamspot - iperr2dToBSH_ = ibook.book1D("iperr2dToBS", "IP error in 2d To BS", 50, 0, 4); + iperr2dToBSH_ = ibook.book1D("iperr2dToBS", "IP error in 2d To BS", niperrbins, iperrbinning); sip2dToBSH_ = ibook.book1D("sip2dToBS", "IP significance in 2d To BS", 200, -10, 10); - iperr3dToPVWtH_ = ibook.book1D("iperr3dToPVWt", "IP error in 3d To PV", 100, 0, 5); + iperr3dToPVWtH_ = ibook.book1D("iperr3dToPVWt", "IP error in 3d To PV", niperrbins, iperrbinning); sip2dToPVH_ = ibook.book1D("sip2dToPV", "IP significance in 2d To PV", 200, -10, 10); sip2dToPVWtH_ = ibook.book1D("sip2dToPVWt", "IP significance in 2d To PV", 200, -10, 10); @@ -768,6 +815,7 @@ void StandaloneTrackMonitor::bookHistograms(DQMStore::IBooker& ibook, ibook.book1D("Jet_chargedMultiplicity", "Jet charged Hadron Multiplicity", 201, -0.5, 200.5); Zpt_ = ibook.book1D("Zpt", "Z-boson transverse momentum", 100, 0, 100); ZInvMass_ = ibook.book1D("ZInvMass", "m_{ll}", 120, 75, 105); + cosPhi3DdileptonH_ = ibook.book1D("cosPhi3Ddilepton", "cos#Phi_{3D,ll}", 202, -1.01, 1.01); } if (isMC_) { bunchCrossingH_ = ibook.book1D("bunchCrossing", "Bunch Crossing", 60, 0, 60.0); @@ -1341,19 +1389,25 @@ void StandaloneTrackMonitor::analyze(edm::Event const& iEvent, edm::EventSetup c // Get MVA and quality mask collections int ntracks = 0; + std::vector list; + + const TransientTrackBuilder* theB = &iSetup.getData(transTrackToken_); + TransientVertex mumuTransientVtx; + std::vector tks; if (tracks.isValid()) { if (verbose_) edm::LogInfo("StandaloneTrackMonitor") << "Total # of Tracks: " << tracks->size(); reco::Track::TrackQuality quality = reco::Track::qualityByName(trackQuality_); - std::vector list; - for (auto const& track : *tracks) { if (!track.quality(quality)) continue; ++ntracks; + reco::TransientTrack trajectory = theB->build(track); + tks.push_back(trajectory); + double eta = track.eta(); double theta = track.theta(); double phi = track.phi(); @@ -1364,18 +1418,18 @@ void StandaloneTrackMonitor::analyze(edm::Event const& iEvent, edm::EventSetup c double nAllTrackerHits = hitp.numberOfAllTrackerHits(reco::HitPattern::TRACK_HITS); double trackdeltaR = std::numeric_limits::max(); - TLorentzVector track1; - track1.SetPtEtaPhiM(track.pt(), track.eta(), track.phi(), 0.); + double muonmass = 0.1056583745; + TLorentzVector trackpmu; + trackpmu.SetPtEtaPhiM(track.pt(), track.eta(), track.phi(), muonmass); for (auto const& TRACK : *tracks) { if (&track == &TRACK) continue; - TLorentzVector track2; - track2.SetPtEtaPhiM(TRACK.pt(), TRACK.eta(), TRACK.phi(), 0.); - if (track1.DeltaR(track2) < trackdeltaR) - trackdeltaR = track1.DeltaR(track2); + double tmpdr = reco::deltaR(track.eta(), track.phi(), TRACK.eta(), TRACK.phi()); + if (tmpdr < trackdeltaR) + trackdeltaR = tmpdr; } - list.push_back(track1); + list.push_back(trackpmu); double nValidTrackerHits = hitp.numberOfValidTrackerHits(); double nValidPixelHits = hitp.numberOfValidPixelHits(); @@ -1624,26 +1678,28 @@ void StandaloneTrackMonitor::analyze(edm::Event const& iEvent, edm::EventSetup c vertexZposH_->Fill(vz, wfac); int nPixBarrel = 0, nPixEndcap = 0, nStripTIB = 0, nStripTOB = 0, nStripTEC = 0, nStripTID = 0; - for (auto it = track.recHitsBegin(); it != track.recHitsEnd(); ++it) { - const TrackingRecHit& hit = (**it); - if (hit.isValid()) { - if (hit.geographicalId().det() == DetId::Tracker) { - int subdetId = hit.geographicalId().subdetId(); - if (subdetId == PixelSubdetector::PixelBarrel) - ++nPixBarrel; - else if (subdetId == PixelSubdetector::PixelEndcap) - ++nPixEndcap; - else if (subdetId == StripSubdetector::TIB) - ++nStripTIB; - else if (subdetId == StripSubdetector::TOB) - ++nStripTOB; - else if (subdetId == StripSubdetector::TEC) - ++nStripTEC; - else if (subdetId == StripSubdetector::TID) - ++nStripTID; - - // Find on-track clusters - processHit(hit, iSetup, tkGeom, wfac); + if (isRECO_) { + for (auto it = track.recHitsBegin(); it != track.recHitsEnd(); ++it) { + const TrackingRecHit& hit = (**it); + if (hit.isValid()) { + if (hit.geographicalId().det() == DetId::Tracker) { + int subdetId = hit.geographicalId().subdetId(); + if (subdetId == PixelSubdetector::PixelBarrel) + ++nPixBarrel; + else if (subdetId == PixelSubdetector::PixelEndcap) + ++nPixEndcap; + else if (subdetId == StripSubdetector::TIB) + ++nStripTIB; + else if (subdetId == StripSubdetector::TOB) + ++nStripTOB; + else if (subdetId == StripSubdetector::TEC) + ++nStripTEC; + else if (subdetId == StripSubdetector::TID) + ++nStripTID; + + // Find on-track clusters + processHit(hit, iSetup, tkGeom, wfac); + } } } } @@ -1685,6 +1741,15 @@ void StandaloneTrackMonitor::analyze(edm::Event const& iEvent, edm::EventSetup c sipDxyToPVH_->Fill(sipDxyToPV, wfac); sipDzToPVH_->Fill(sipDzToPV, wfac); + if (nValidPixelHits >= 2) { + ip3dToPV2validpixelhitsH_->Fill(ip3dToPV, wfac); + iperr3dToPV2validpixelhitsH_->Fill(iperr3dToPV, wfac); + ip3dToBS2validpixelhitsH_->Fill(ip3dToBS, wfac); + iperr3dToBS2validpixelhitsH_->Fill(iperr3dToBS, wfac); + sip3dToPV2validpixelhitsH_->Fill(sip3dToPV, wfac); + sip3dToBS2validpixelhitsH_->Fill(sip3dToBS, wfac); + } + trackIperr3dVsEta2DH_->Fill(eta, iperr3dToPV, wfac); trackSip2dVsEta2DH_->Fill(eta, sip2dToPV, wfac); trackIperr3dVsChi2prob2DH_->Fill(chi2prob, iperr3dToPV, wfac); @@ -1735,11 +1800,6 @@ void StandaloneTrackMonitor::analyze(edm::Event const& iEvent, edm::EventSetup c nlostTIDHitsH_->Fill(nLostStripTIDHits, wfac); nlostTECHitsH_->Fill(nLostStripTECHits, wfac); } - - if (list.size() >= 2) { - Zpt_->Fill((list[0] + list[1]).Pt(), wfac); - ZInvMass_->Fill((list[0] + list[1]).Mag(), wfac); - } } } else { edm::LogError("StandaloneTrackMonitor") << "Error! Failed to get reco::Track collection, " << trackTag_; @@ -1757,6 +1817,40 @@ void StandaloneTrackMonitor::analyze(edm::Event const& iEvent, edm::EventSetup c Jet_energy_->Fill(jet.energy(), wfac); Jet_chargedMultiplicity_->Fill(jet.chargedHadronMultiplicity(), wfac); } + if (list.size() >= 2) { + TLorentzVector Zp = list[0] + list[1]; + Zpt_->Fill(Zp.Pt(), wfac); + ZInvMass_->Fill(Zp.Mag(), wfac); + KalmanVertexFitter kalman(true); + mumuTransientVtx = kalman.vertex(tks); + if (mumuTransientVtx.isValid()) { + const reco::Vertex* theClosestVertex; + edm::Handle vertexHandle = iEvent.getHandle(vertexToken_); + if (vertexHandle.isValid()) { + const reco::VertexCollection* vertices = vertexHandle.product(); + theClosestVertex = this->findClosestVertex(mumuTransientVtx, vertices); + reco::Vertex theMainVtx; + if (theClosestVertex == nullptr) { + theMainVtx = vertexHandle.product()->front(); + } else { + theMainVtx = *theClosestVertex; + } + if (theMainVtx.isValid()) { + const math::XYZPoint theMainVtxPos( + theMainVtx.position().x(), theMainVtx.position().y(), theMainVtx.position().z()); + const math::XYZPoint myVertex( + mumuTransientVtx.position().x(), mumuTransientVtx.position().y(), mumuTransientVtx.position().z()); + const math::XYZPoint deltaVtx( + theMainVtxPos.x() - myVertex.x(), theMainVtxPos.y() - myVertex.y(), theMainVtxPos.z() - myVertex.z()); + double cosphi3D = + (Zp.Px() * deltaVtx.x() + Zp.Py() * deltaVtx.y() + Zp.Pz() * deltaVtx.z()) / + (sqrt(Zp.Px() * Zp.Px() + Zp.Py() * Zp.Py() + Zp.Pz() * Zp.Pz()) * + sqrt(deltaVtx.x() * deltaVtx.x() + deltaVtx.y() * deltaVtx.y() + deltaVtx.z() * deltaVtx.z())); + cosPhi3DdileptonH_->Fill(cosphi3D, wfac); + } + } + } + } } // off track cluster properties @@ -1878,6 +1972,36 @@ void StandaloneTrackMonitor::addClusterToMap(uint32_t detid, const SiStripCluste s.insert(cluster); } } + +const reco::Vertex* StandaloneTrackMonitor::findClosestVertex( + const TransientVertex aTransVtx, + const reco::VertexCollection* vertices) const { //same as in /DQMOffline/Alignment/src/DiMuonVertexSelector.cc + reco::Vertex* defaultVtx = nullptr; + + if (!aTransVtx.isValid()) + return defaultVtx; + + // find the closest vertex to the secondary vertex in 3D + VertexDistance3D vertTool3D; + float minD = 9999.; + int closestVtxIndex = 0; + int counter = 0; + for (const auto& vtx : *vertices) { + double dist3D = vertTool3D.distance(aTransVtx, vtx).value(); + if (dist3D < minD) { + minD = dist3D; + closestVtxIndex = counter; + } + counter++; + } + + if ((*vertices).at(closestVtxIndex).isValid()) { + return &(vertices->at(closestVtxIndex)); + } else { + return defaultVtx; + } +} + // Define this as a plug-in #include "FWCore/Framework/interface/MakerMacros.h" DEFINE_FWK_MODULE(StandaloneTrackMonitor); diff --git a/DQM/TrackingMonitorSource/python/StandaloneTrackMonitor_cfi.py b/DQM/TrackingMonitorSource/python/StandaloneTrackMonitor_cfi.py index 35d1d95079af1..296368efa3b77 100644 --- a/DQM/TrackingMonitorSource/python/StandaloneTrackMonitor_cfi.py +++ b/DQM/TrackingMonitorSource/python/StandaloneTrackMonitor_cfi.py @@ -5,6 +5,7 @@ standaloneTrackMonitor = standaloneTrackMonitorDefault.clone( moduleName = "StandaloneTrackMonitor", folderName = "highPurityTracks", + isRECO = False, vertexTag = "selectedPrimaryVertices", # "offlinePrimaryVertices", puTag = "addPileupInfo", clusterTag = "siStripClusters", From c04633e8407f21b32f017a662412053bd9408859 Mon Sep 17 00:00:00 2001 From: Davide Bruschini Date: Mon, 16 Oct 2023 11:36:26 +0200 Subject: [PATCH 2/2] Changed invariant mass range for dilepton event selection --- DQM/TrackingMonitorSource/plugins/ZEEDetails.cc | 8 ++++---- .../plugins/ZtoEEElectronTrackProducer.cc | 8 ++++---- DQM/TrackingMonitorSource/plugins/ZtoEEEventSelector.cc | 8 ++++---- DQM/TrackingMonitorSource/plugins/ZtoMMEventSelector.cc | 8 ++++---- .../plugins/ZtoMMMuonTrackProducer.cc | 8 ++++---- 5 files changed, 20 insertions(+), 20 deletions(-) diff --git a/DQM/TrackingMonitorSource/plugins/ZEEDetails.cc b/DQM/TrackingMonitorSource/plugins/ZEEDetails.cc index 7ad937fbd42df..8719d7d25bcd8 100644 --- a/DQM/TrackingMonitorSource/plugins/ZEEDetails.cc +++ b/DQM/TrackingMonitorSource/plugins/ZEEDetails.cc @@ -115,8 +115,8 @@ void ZEEDetails::fillDescriptions(edm::ConfigurationDescriptions& descriptions) desc.addUntracked("minStripHits", 8); desc.addUntracked("maxIso", 0.3); desc.addUntracked("minPtHighest", 24); - desc.addUntracked("minInvMass", 60); - desc.addUntracked("maxInvMass", 120); + desc.addUntracked("minInvMass", 75); + desc.addUntracked("maxInvMass", 105); desc.addUntracked("trackQuality", "highPurity"); desc.addUntracked("isMC", false); desc.addUntracked("doPUCorrection", false); @@ -152,8 +152,8 @@ ZEEDetails::ZEEDetails(const edm::ParameterSet& ps) minStripHits_(ps.getUntrackedParameter("minStripHits", 8)), maxIso_(ps.getUntrackedParameter("maxIso", 0.3)), minPtHighest_(ps.getUntrackedParameter("minPtHighest", 24)), - minInvMass_(ps.getUntrackedParameter("minInvMass", 60)), - maxInvMass_(ps.getUntrackedParameter("maxInvMass", 120)), + minInvMass_(ps.getUntrackedParameter("minInvMass", 75)), + maxInvMass_(ps.getUntrackedParameter("maxInvMass", 105)), trackQuality_(ps.getUntrackedParameter("trackQuality", "highPurity")), isMC_(ps.getUntrackedParameter("isMC", false)), doPUCorrection_(ps.getUntrackedParameter("doPUCorrection", false)), diff --git a/DQM/TrackingMonitorSource/plugins/ZtoEEElectronTrackProducer.cc b/DQM/TrackingMonitorSource/plugins/ZtoEEElectronTrackProducer.cc index 28c3df9d79cf2..a5ed35fa252c2 100644 --- a/DQM/TrackingMonitorSource/plugins/ZtoEEElectronTrackProducer.cc +++ b/DQM/TrackingMonitorSource/plugins/ZtoEEElectronTrackProducer.cc @@ -84,8 +84,8 @@ void ZtoEEElectronTrackProducer::fillDescriptions(edm::ConfigurationDescriptions desc.addUntracked("minStripHits", 8); desc.addUntracked("maxIso", 0.3); desc.addUntracked("minPtHighest", 24); - desc.addUntracked("minInvMass", 60); - desc.addUntracked("maxInvMass", 120); + desc.addUntracked("minInvMass", 75); + desc.addUntracked("maxInvMass", 105); descriptions.addWithDefaultLabel(desc); } @@ -111,8 +111,8 @@ ZtoEEElectronTrackProducer::ZtoEEElectronTrackProducer(const edm::ParameterSet& minStripHits_(ps.getUntrackedParameter("minStripHits", 8)), maxIso_(ps.getUntrackedParameter("maxIso", 0.3)), minPtHighest_(ps.getUntrackedParameter("minPtHighest", 24)), - minInvMass_(ps.getUntrackedParameter("minInvMass", 60)), - maxInvMass_(ps.getUntrackedParameter("maxInvMass", 120)) { + minInvMass_(ps.getUntrackedParameter("minInvMass", 75)), + maxInvMass_(ps.getUntrackedParameter("maxInvMass", 105)) { produces(""); } diff --git a/DQM/TrackingMonitorSource/plugins/ZtoEEEventSelector.cc b/DQM/TrackingMonitorSource/plugins/ZtoEEEventSelector.cc index c64e700691ce7..0dabe82694989 100644 --- a/DQM/TrackingMonitorSource/plugins/ZtoEEEventSelector.cc +++ b/DQM/TrackingMonitorSource/plugins/ZtoEEEventSelector.cc @@ -79,8 +79,8 @@ void ZtoEEEventSelector::fillDescriptions(edm::ConfigurationDescriptions& descri desc.addUntracked("minStripHits", 8); desc.addUntracked("maxIso", 0.3); desc.addUntracked("minPtHighest", 24); - desc.addUntracked("minInvMass", 60); - desc.addUntracked("maxInvMass", 120); + desc.addUntracked("minInvMass", 75); + desc.addUntracked("maxInvMass", 105); descriptions.addWithDefaultLabel(desc); } @@ -106,8 +106,8 @@ ZtoEEEventSelector::ZtoEEEventSelector(const edm::ParameterSet& ps) minStripHits_(ps.getUntrackedParameter("minStripHits", 8)), maxIso_(ps.getUntrackedParameter("maxIso", 0.3)), minPtHighest_(ps.getUntrackedParameter("minPtHighest", 24)), - minInvMass_(ps.getUntrackedParameter("minInvMass", 60)), - maxInvMass_(ps.getUntrackedParameter("maxInvMass", 120)) {} + minInvMass_(ps.getUntrackedParameter("minInvMass", 75)), + maxInvMass_(ps.getUntrackedParameter("maxInvMass", 105)) {} bool ZtoEEEventSelector::filter(edm::Event& iEvent, edm::EventSetup const& iSetup) { // Read Electron Collection diff --git a/DQM/TrackingMonitorSource/plugins/ZtoMMEventSelector.cc b/DQM/TrackingMonitorSource/plugins/ZtoMMEventSelector.cc index d51657763823e..5d011d4307b50 100644 --- a/DQM/TrackingMonitorSource/plugins/ZtoMMEventSelector.cc +++ b/DQM/TrackingMonitorSource/plugins/ZtoMMEventSelector.cc @@ -66,8 +66,8 @@ void ZtoMMEventSelector::fillDescriptions(edm::ConfigurationDescriptions& descri desc.addUntracked("minMatchedStations", 2); desc.addUntracked("maxIso", 0.3); desc.addUntracked("minPtHighest", 24); - desc.addUntracked("minInvMass", 60); - desc.addUntracked("maxInvMass", 120); + desc.addUntracked("minInvMass", 75); + desc.addUntracked("maxInvMass", 105); descriptions.addWithDefaultLabel(desc); } @@ -89,8 +89,8 @@ ZtoMMEventSelector::ZtoMMEventSelector(const edm::ParameterSet& ps) minMatchedStations_(ps.getUntrackedParameter("minMatchedStations", 2)), maxIso_(ps.getUntrackedParameter("maxIso", 0.3)), minPtHighest_(ps.getUntrackedParameter("minPtHighest", 24)), - minInvMass_(ps.getUntrackedParameter("minInvMass", 60)), - maxInvMass_(ps.getUntrackedParameter("maxInvMass", 120)) {} + minInvMass_(ps.getUntrackedParameter("minInvMass", 75)), + maxInvMass_(ps.getUntrackedParameter("maxInvMass", 105)) {} bool ZtoMMEventSelector::filter(edm::Event& iEvent, edm::EventSetup const& iSetup) { // Read Muon Collection diff --git a/DQM/TrackingMonitorSource/plugins/ZtoMMMuonTrackProducer.cc b/DQM/TrackingMonitorSource/plugins/ZtoMMMuonTrackProducer.cc index 447bcf1163a18..830ad1e044748 100644 --- a/DQM/TrackingMonitorSource/plugins/ZtoMMMuonTrackProducer.cc +++ b/DQM/TrackingMonitorSource/plugins/ZtoMMMuonTrackProducer.cc @@ -74,8 +74,8 @@ void ZtoMMMuonTrackProducer::fillDescriptions(edm::ConfigurationDescriptions& de desc.addUntracked("minMatchedStations", 2); desc.addUntracked("maxIso", 0.3); desc.addUntracked("minPtHighest", 24); - desc.addUntracked("minInvMass", 60); - desc.addUntracked("maxInvMass", 120); + desc.addUntracked("minInvMass", 75); + desc.addUntracked("maxInvMass", 105); descriptions.addWithDefaultLabel(desc); } @@ -96,8 +96,8 @@ ZtoMMMuonTrackProducer::ZtoMMMuonTrackProducer(const edm::ParameterSet& ps) minMatchedStations_(ps.getUntrackedParameter("minMatchedStations", 2)), maxIso_(ps.getUntrackedParameter("maxIso", 0.3)), minPtHighest_(ps.getUntrackedParameter("minPtHighest", 24)), - minInvMass_(ps.getUntrackedParameter("minInvMass", 60)), - maxInvMass_(ps.getUntrackedParameter("maxInvMass", 120)) { + minInvMass_(ps.getUntrackedParameter("minInvMass", 75)), + maxInvMass_(ps.getUntrackedParameter("maxInvMass", 105)) { produces(""); }