File indexing completed on 2024-04-06 12:24:09
0001 #ifndef PhysicsTools_PatUtils_interface_PFMuonSelector_h
0002 #define PhysicsTools_PatUtils_interface_PFMuonSelector_h
0003
0004 #ifndef __GCCXML__
0005 #include "FWCore/Framework/interface/ConsumesCollector.h"
0006 #endif
0007 #include "DataFormats/PatCandidates/interface/Muon.h"
0008 #include "DataFormats/BeamSpot/interface/BeamSpot.h"
0009 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0010
0011 #include "PhysicsTools/SelectorUtils/interface/Selector.h"
0012 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0013
0014 #include <iostream>
0015
0016 class PFMuonSelector : public Selector<pat::Muon> {
0017 public:
0018 bool verbose_;
0019
0020 enum Version_t { TOPPAG12_LJETS, N_VERSIONS };
0021
0022 PFMuonSelector() {}
0023
0024 #ifndef __GCCXML__
0025 PFMuonSelector(edm::ParameterSet const& parameters, edm::ConsumesCollector&& iC) : PFMuonSelector(parameters) {}
0026 #endif
0027
0028 PFMuonSelector(edm::ParameterSet const& parameters) {
0029 verbose_ = false;
0030
0031 std::string versionStr = parameters.getParameter<std::string>("version");
0032
0033 Version_t version = N_VERSIONS;
0034
0035 if (versionStr == "TOPPAG12_LJETS") {
0036 version = TOPPAG12_LJETS;
0037 } else {
0038 throw cms::Exception("InvalidInput") << "Expect version to be one of SPRING11" << std::endl;
0039 }
0040
0041 initialize(version,
0042 parameters.getParameter<double>("Chi2"),
0043 parameters.getParameter<int>("minTrackerLayers"),
0044 parameters.getParameter<int>("minValidMuHits"),
0045 parameters.getParameter<double>("maxIp"),
0046 parameters.getParameter<int>("minPixelHits"),
0047 parameters.getParameter<int>("minMatchedStations"),
0048 parameters.getParameter<double>("maxPfRelIso"));
0049 if (parameters.exists("cutsToIgnore"))
0050 setIgnoredCuts(parameters.getParameter<std::vector<std::string> >("cutsToIgnore"));
0051
0052 retInternal_ = getBitTemplate();
0053 }
0054
0055 void initialize(Version_t version,
0056 double chi2 = 10.0,
0057 int minTrackerLayers = 6,
0058 int minValidMuonHits = 1,
0059 double maxIp = 0.2,
0060 int minPixelHits = 1,
0061 int minNMatches = 2,
0062 double pfiso = 0.12) {
0063 version_ = version;
0064
0065 push_back("GlobalMuon", true);
0066 push_back("TrackerMuon", true);
0067 push_back("Chi2", chi2);
0068 push_back("minTrackerLayers", minTrackerLayers);
0069 push_back("minValidMuHits", minValidMuonHits);
0070 push_back("maxIp", maxIp);
0071 push_back("minPixelHits", minPixelHits);
0072 push_back("minMatchedStations", minNMatches);
0073 push_back("maxPfRelIso", pfiso);
0074
0075 set("GlobalMuon");
0076 set("TrackerMuon");
0077 set("Chi2");
0078 set("minTrackerLayers");
0079 set("minValidMuHits");
0080 set("maxIp");
0081 set("minPixelHits");
0082 set("minMatchedStations");
0083 set("maxPfRelIso");
0084
0085 indexChi2_ = index_type(&bits_, "Chi2");
0086 indexMinTrackerLayers_ = index_type(&bits_, "minTrackerLayers");
0087 indexminValidMuHits_ = index_type(&bits_, "minValidMuHits");
0088 indexMaxIp_ = index_type(&bits_, "maxIp");
0089 indexPixHits_ = index_type(&bits_, "minPixelHits");
0090 indexStations_ = index_type(&bits_, "minMatchedStations");
0091 indexmaxPfRelIso_ = index_type(&bits_, "maxPfRelIso");
0092
0093 if (version_ == TOPPAG12_LJETS) {
0094 set("TrackerMuon", false);
0095 }
0096 }
0097
0098
0099 bool operator()(const pat::Muon& muon, pat::strbitset& ret) override {
0100 if (version_ == TOPPAG12_LJETS)
0101 return TopPag12LjetsCuts(muon, ret);
0102 else {
0103 return false;
0104 }
0105 }
0106
0107 using Selector<pat::Muon>::operator();
0108
0109 bool TopPag12LjetsCuts(const pat::Muon& muon, pat::strbitset& ret) {
0110 ret.set(false);
0111
0112 bool isGlobal = muon.isGlobalMuon();
0113 bool isTracker = muon.isTrackerMuon();
0114
0115 double norm_chi2 = 9999999.0;
0116 int minTrackerLayers = 0;
0117 int minValidMuonHits = 0;
0118 int _ip = 0.0;
0119 int minPixelHits = 0;
0120 if (muon.globalTrack().isNonnull() && muon.globalTrack().isAvailable()) {
0121 norm_chi2 = muon.normChi2();
0122 minTrackerLayers = static_cast<int>(muon.track()->hitPattern().trackerLayersWithMeasurement());
0123 minValidMuonHits = static_cast<int>(muon.globalTrack()->hitPattern().numberOfValidMuonHits());
0124 _ip = muon.dB();
0125 minPixelHits = muon.innerTrack()->hitPattern().numberOfValidPixelHits();
0126 }
0127
0128 int minMatchedStations = muon.numberOfMatches();
0129
0130 double chIso = muon.userIsolation(pat::PfChargedHadronIso);
0131 double nhIso = muon.userIsolation(pat::PfNeutralHadronIso);
0132 double gIso = muon.userIsolation(pat::PfGammaIso);
0133 double pt = muon.pt();
0134
0135 double pfIso = (chIso + nhIso + gIso) / pt;
0136
0137 if (isGlobal || ignoreCut("GlobalMuon"))
0138 passCut(ret, "GlobalMuon");
0139 if (isTracker || ignoreCut("TrackerMuon"))
0140 passCut(ret, "TrackerMuon");
0141 if (norm_chi2 < cut(indexChi2_, double()) || ignoreCut(indexChi2_))
0142 passCut(ret, indexChi2_);
0143 if (minTrackerLayers >= cut(indexMinTrackerLayers_, int()) || ignoreCut(indexMinTrackerLayers_))
0144 passCut(ret, indexMinTrackerLayers_);
0145 if (minValidMuonHits >= cut(indexminValidMuHits_, int()) || ignoreCut(indexminValidMuHits_))
0146 passCut(ret, indexminValidMuHits_);
0147 if (_ip < cut(indexMaxIp_, double()) || ignoreCut(indexMaxIp_))
0148 passCut(ret, indexMaxIp_);
0149 if (minPixelHits >= cut(indexPixHits_, int()) || ignoreCut(indexPixHits_))
0150 passCut(ret, indexPixHits_);
0151 if (minMatchedStations >= cut(indexStations_, int()) || ignoreCut(indexStations_))
0152 passCut(ret, indexStations_);
0153 if (pfIso < cut(indexmaxPfRelIso_, double()) || ignoreCut(indexmaxPfRelIso_))
0154 passCut(ret, indexmaxPfRelIso_);
0155
0156 setIgnored(ret);
0157
0158 return (bool)ret;
0159 }
0160
0161 private:
0162 Version_t version_;
0163
0164 index_type indexChi2_;
0165 index_type indexMinTrackerLayers_;
0166 index_type indexminValidMuHits_;
0167 index_type indexMaxIp_;
0168 index_type indexPixHits_;
0169 index_type indexStations_;
0170 index_type indexmaxPfRelIso_;
0171 };
0172
0173 #endif
