TrackingMonitorSource/plugins/ZtoMMEventSelector.cc

0001 // user includes
0002 #include "DataFormats/BeamSpot/interface/BeamSpot.h"
0003 #include "DataFormats/Common/interface/Handle.h"
0004 #include "DataFormats/MuonReco/interface/Muon.h"
0005 #include "DataFormats/MuonReco/interface/MuonFwd.h"
0006 #include "DataFormats/MuonReco/interface/MuonSelectors.h"
0007 #include "DataFormats/TrackReco/interface/HitPattern.h"
0008 #include "DataFormats/TrackReco/interface/TrackFwd.h"
0009 #include "FWCore/Framework/interface/Event.h"
0010 #include "FWCore/Framework/interface/Frameworkfwd.h"
0011 #include "FWCore/Framework/interface/stream/EDFilter.h"
0012 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0013 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
0014 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0015 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
0016
0017 // ROOT includes
0018 #include "TLorentzVector.h"
0019
0020 class ZtoMMEventSelector : public edm::stream::EDFilter<> {
0021 public:
0022   explicit ZtoMMEventSelector(const edm::ParameterSet&);
0023   static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
0024   bool filter(edm::Event&, edm::EventSetup const&) override;
0025
0026 private:
0027   bool verbose_;
0028   const edm::InputTag muonTag_;
0029   const edm::InputTag bsTag_;
0030   const edm::EDGetTokenT<reco::MuonCollection> muonToken_;
0031   const edm::EDGetTokenT<reco::BeamSpot> bsToken_;
0032
0033   const double maxEta_;
0034   const double minPt_;
0035   const double maxNormChi2_;
0036   const double maxD0_;
0037   const double maxDz_;
0038   const int minPixelHits_;
0039   const int minStripHits_;
0040   const int minChambers_;
0041   const int minMatches_;
0042   const int minMatchedStations_;
0043   const double maxIso_;
0044   const double minPtHighest_;
0045   const double minInvMass_;
0046   const double maxInvMass_;
0047 };
0048
0049 using namespace std;
0050 using namespace edm;
0051
0052 void ZtoMMEventSelector::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0053   edm::ParameterSetDescription desc;
0054   desc.addUntracked<bool>("verbose", false);
0055   desc.addUntracked<edm::InputTag>("muonInputTag", edm::InputTag("muons"));
0056   desc.addUntracked<edm::InputTag>("offlineBeamSpot", edm::InputTag("offlineBeamSpot"));
0057   desc.addUntracked<double>("maxEta", 2.4);
0058   desc.addUntracked<double>("minPt", 5);
0059   desc.addUntracked<double>("maxNormChi2", 1000);
0060   desc.addUntracked<double>("maxD0", 0.02);
0061   desc.addUntracked<double>("maxDz", 20.);
0062   desc.addUntracked<uint32_t>("minPixelHits", 1);
0063   desc.addUntracked<uint32_t>("minStripHits", 8);
0064   desc.addUntracked<uint32_t>("minChambers", 2);
0065   desc.addUntracked<uint32_t>("minMatches", 2);
0066   desc.addUntracked<double>("minMatchedStations", 2);
0067   desc.addUntracked<double>("maxIso", 0.3);
0068   desc.addUntracked<double>("minPtHighest", 24);
0069   desc.addUntracked<double>("minInvMass", 75);
0070   desc.addUntracked<double>("maxInvMass", 105);
0071   descriptions.addWithDefaultLabel(desc);
0072 }
0073
0074 ZtoMMEventSelector::ZtoMMEventSelector(const edm::ParameterSet& ps)
0075     : verbose_(ps.getUntrackedParameter<bool>("verbose", false)),
0076       muonTag_(ps.getUntrackedParameter<edm::InputTag>("muonInputTag", edm::InputTag("muons"))),
0077       bsTag_(ps.getUntrackedParameter<edm::InputTag>("offlineBeamSpot", edm::InputTag("offlineBeamSpot"))),
0078       muonToken_(consumes<reco::MuonCollection>(muonTag_)),
0079       bsToken_(consumes<reco::BeamSpot>(bsTag_)),
0080       maxEta_(ps.getUntrackedParameter<double>("maxEta", 2.4)),
0081       minPt_(ps.getUntrackedParameter<double>("minPt", 5)),
0082       maxNormChi2_(ps.getUntrackedParameter<double>("maxNormChi2", 1000)),
0083       maxD0_(ps.getUntrackedParameter<double>("maxD0", 0.02)),
0084       maxDz_(ps.getUntrackedParameter<double>("maxDz", 20.)),
0085       minPixelHits_(ps.getUntrackedParameter<uint32_t>("minPixelHits", 1)),
0086       minStripHits_(ps.getUntrackedParameter<uint32_t>("minStripHits", 8)),
0087       minChambers_(ps.getUntrackedParameter<uint32_t>("minChambers", 2)),
0088       minMatches_(ps.getUntrackedParameter<uint32_t>("minMatches", 2)),
0089       minMatchedStations_(ps.getUntrackedParameter<double>("minMatchedStations", 2)),
0090       maxIso_(ps.getUntrackedParameter<double>("maxIso", 0.3)),
0091       minPtHighest_(ps.getUntrackedParameter<double>("minPtHighest", 24)),
0092       minInvMass_(ps.getUntrackedParameter<double>("minInvMass", 75)),
0093       maxInvMass_(ps.getUntrackedParameter<double>("maxInvMass", 105)) {}
0094
0095 bool ZtoMMEventSelector::filter(edm::Event& iEvent, edm::EventSetup const& iSetup) {
0096   // Read Muon Collection
0097   edm::Handle<reco::MuonCollection> muonColl;
0098   iEvent.getByToken(muonToken_, muonColl);
0099
0100   // and the beamspot
0101   edm::Handle<reco::BeamSpot> beamSpot;
0102   iEvent.getByToken(bsToken_, beamSpot);
0103
0104   std::vector<TLorentzVector> list;
0105   if (muonColl.isValid()) {
0106     for (auto const& mu : *muonColl) {
0107       if (!mu.isGlobalMuon())
0108         continue;
0109       if (!mu.isPFMuon())
0110         continue;
0111       if (std::fabs(mu.eta()) >= maxEta_)
0112         continue;
0113       if (mu.pt() < minPt_)
0114         continue;
0115
0116       reco::TrackRef gtk = mu.globalTrack();
0117       double chi2 = gtk->chi2();
0118       double ndof = gtk->ndof();
0119       double chbyndof = (ndof > 0) ? chi2 / ndof : 0;
0120       if (chbyndof >= maxNormChi2_)
0121         continue;
0122
0123       if (beamSpot.isValid()) {
0124         reco::TrackRef tk = mu.innerTrack();
0125         double abstrkd0 = std::abs(tk->dxy(beamSpot->position()));
0126         if (abstrkd0 >= maxD0_)
0127           continue;
0128         double abstrkdz = std::abs(tk->dz(beamSpot->position()));
0129         if (abstrkdz >= maxDz_)
0130           continue;
0131       } else {
0132         edm::LogError("ZtoMMEventSelector") << "Error >> Failed to get BeamSpot for label: " << bsTag_;
0133       }
0134
0135       const reco::HitPattern& hitp = gtk->hitPattern();
0136       if (hitp.numberOfValidPixelHits() < minPixelHits_)
0137         continue;
0138       if (hitp.numberOfValidStripHits() < minStripHits_)
0139         continue;
0140
0141       // Hits/section in the muon chamber
0142       if (mu.numberOfChambers() < minChambers_)
0143         continue;
0144       if (mu.numberOfMatches() < minMatches_)
0145         continue;
0146       if (mu.numberOfMatchedStations() < minMatchedStations_)
0147         continue;
0148       if (!muon::isGoodMuon(mu, muon::GlobalMuonPromptTight))
0149         continue;
0150
0151       // PF Isolation
0152       const reco::MuonPFIsolation& pfIso04 = mu.pfIsolationR04();
0153       double absiso = pfIso04.sumChargedParticlePt +
0154                       std::max(0.0, pfIso04.sumNeutralHadronEt + pfIso04.sumPhotonEt - 0.5 * pfIso04.sumPUPt);
0155       if (absiso / mu.pt() > maxIso_)
0156         continue;
0157
0158       TLorentzVector lv;
0159       lv.SetPtEtaPhiE(mu.pt(), mu.eta(), mu.phi(), mu.energy());
0160       list.push_back(lv);
0161     }
0162   } else {
0163     edm::LogError("ZtoMMEventSelector") << "Error >> Failed to get MuonCollection for label: " << muonTag_;
0164     return false;
0165   }
0166
0167   if (list.size() < 2)
0168     return false;
0169   if (list[0].Pt() < minPtHighest_)
0170     return false;
0171   TLorentzVector zv = list[0] + list[1];
0172   double mass = zv.M();
0173   if (mass < minInvMass_ || mass > maxInvMass_)
0174     return false;
0175
0176   return true;
0177 }
0178
0179 // Define this as a plug-in
0180 #include "FWCore/Framework/interface/MakerMacros.h"
0181 DEFINE_FWK_MODULE(ZtoMMEventSelector);