CMS 3D CMS Logo
PATMuonProducer.cc
Go to the documentation of this file.
1 
12 #include "DataFormats/BeamSpot/interface/BeamSpot.h"
13 #include "DataFormats/Common/interface/Association.h"
14 #include "DataFormats/Common/interface/TriggerResults.h"
15 #include "DataFormats/HepMCCandidate/interface/GenParticle.h"
16 #include "DataFormats/HepMCCandidate/interface/GenParticleFwd.h"
17 #include "DataFormats/Math/interface/deltaPhi.h"
18 #include "DataFormats/Math/interface/deltaR.h"
19 #include "DataFormats/MuonReco/interface/Muon.h"
20 #include "DataFormats/MuonReco/interface/MuonSimInfo.h"
21 #include "DataFormats/MuonReco/interface/MuonTimeExtra.h"
22 #include "DataFormats/ParticleFlowCandidate/interface/IsolatedPFCandidate.h"
23 #include "DataFormats/PatCandidates/interface/Muon.h"
24 #include "DataFormats/PatCandidates/interface/PFIsolation.h"
25 #include "DataFormats/PatCandidates/interface/PackedCandidate.h"
26 #include "DataFormats/PatCandidates/interface/TriggerObjectStandAlone.h"
27 #include "DataFormats/PatCandidates/interface/UserData.h"
28 #include "DataFormats/VertexReco/interface/Vertex.h"
29 #include "FWCore/Framework/interface/Event.h"
30 #include "FWCore/Framework/interface/stream/EDProducer.h"
31 #include "FWCore/MessageLogger/interface/MessageLogger.h"
32 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
33 #include "FWCore/ParameterSet/interface/EmptyGroupDescription.h"
34 #include "FWCore/ParameterSet/interface/FileInPath.h"
35 #include "FWCore/ParameterSet/interface/ParameterSet.h"
36 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
37 #include "FWCore/Utilities/interface/Exception.h"
38 #include "FWCore/Utilities/interface/transform.h"
39 #include "Geometry/CommonDetUnit/interface/GeomDet.h"
40 #include "Geometry/Records/interface/GlobalTrackingGeometryRecord.h"
41 #include "JetMETCorrections/JetCorrector/interface/JetCorrector.h"
42 #include "PhysicsTools/PatAlgos/interface/EfficiencyLoader.h"
43 #include "PhysicsTools/PatAlgos/interface/KinResolutionsLoader.h"
44 #include "PhysicsTools/PatAlgos/interface/MultiIsolator.h"
45 #include "PhysicsTools/PatAlgos/interface/CalculatePtRatioRel.h"
46 #include "PhysicsTools/PatAlgos/interface/MuonMvaIDEstimator.h"
47 #include "PhysicsTools/PatAlgos/interface/PATUserDataHelper.h"
48 #include "PhysicsTools/PatAlgos/interface/SoftMuonMvaEstimator.h"
49 #include "PhysicsTools/PatUtils/interface/MiniIsolation.h"
50 #include "TrackingTools/IPTools/interface/IPTools.h"
51 #include "TrackingTools/Records/interface/TransientTrackRecord.h"
52 #include "TrackingTools/TransientTrack/interface/TransientTrack.h"
53 #include "TrackingTools/TransientTrack/interface/TransientTrackBuilder.h"
54 
55 namespace pat {
56 
57  class PATMuonHeavyObjectCache {
58  public:
59  PATMuonHeavyObjectCache(const edm::ParameterSet&);
60 
61  pat::CalculatePtRatioRel const& calculatePtRatioRel() const { return *calculatePtRatioRel_; }
62  pat::MuonMvaIDEstimator const& muonMvaIDEstimator() const { return *muonMvaIDEstimator_; }
63  pat::SoftMuonMvaEstimator const& softMuonMvaEstimator() const { return *softMuonMvaEstimator_; }
64 
65  private:
66  std::unique_ptr<const pat::CalculatePtRatioRel> calculatePtRatioRel_;
67  std::unique_ptr<const pat::MuonMvaIDEstimator> muonMvaIDEstimator_;
68  std::unique_ptr<const pat::SoftMuonMvaEstimator> softMuonMvaEstimator_;
69  };
70 
72  class TrackerIsolationPt;
73  class CaloIsolationEnergy;
74 
76  class PATMuonProducer : public edm::stream::EDProducer<edm::GlobalCache<PATMuonHeavyObjectCache>> {
77  public:
79  explicit PATMuonProducer(const edm::ParameterSet& iConfig, PATMuonHeavyObjectCache const*);
81  ~PATMuonProducer() override;
82 
83  static std::unique_ptr<PATMuonHeavyObjectCache> initializeGlobalCache(const edm::ParameterSet& iConfig) {
84  return std::make_unique<PATMuonHeavyObjectCache>(iConfig);
85  }
86 
87  static void globalEndJob(PATMuonHeavyObjectCache*) {}
88 
90  void produce(edm::Event& iEvent, const edm::EventSetup& iSetup) override;
92  static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
93 
94  private:
96  typedef edm::RefToBase<reco::Muon> MuonBaseRef;
97  typedef std::vector<edm::Handle<edm::Association<reco::GenParticleCollection>>> GenAssociations;
98  typedef std::vector<edm::Handle<edm::ValueMap<IsoDeposit>>> IsoDepositMaps;
99  typedef std::vector<edm::Handle<edm::ValueMap<double>>> IsolationValueMaps;
100  typedef std::pair<pat::IsolationKeys, edm::InputTag> IsolationLabel;
101  typedef std::vector<IsolationLabel> IsolationLabels;
102 
104  void fillMuon(Muon& aMuon,
105  const MuonBaseRef& muonRef,
106  const reco::CandidateBaseRef& baseRef,
107  const GenAssociations& genMatches,
108  const IsoDepositMaps& deposits,
109  const IsolationValueMaps& isolationValues) const;
112  template <typename T>
113  void readIsolationLabels(const edm::ParameterSet& iConfig,
114  const char* psetName,
115  IsolationLabels& labels,
116  std::vector<edm::EDGetTokenT<edm::ValueMap<T>>>& tokens);
117 
118  void setMuonMiniIso(pat::Muon& aMuon, const pat::PackedCandidateCollection* pc);
119  double getRelMiniIsoPUCorrected(const pat::Muon& muon, double rho, const std::vector<double>& area);
120 
121  double puppiCombinedIsolation(const pat::Muon& muon, const pat::PackedCandidateCollection* pc);
122  bool isNeutralHadron(long pdgid);
123  bool isChargedHadron(long pdgid);
124  bool isPhoton(long pdgid);
125 
126  // embed various impact parameters with errors
127  // embed high level selection
128  void embedHighLevel(pat::Muon& aMuon,
129  reco::TrackRef track,
130  reco::TransientTrack& tt,
131  reco::Vertex& primaryVertex,
132  bool primaryVertexIsValid,
133  reco::BeamSpot& beamspot,
134  bool beamspotIsValid);
135  double relMiniIsoPUCorrected(const pat::Muon& aMuon, double rho);
136  std::optional<GlobalPoint> getMuonDirection(const reco::MuonChamberMatch& chamberMatch,
137  const edm::ESHandle<GlobalTrackingGeometry>& geometry,
138  const DetId& chamberId);
139  void fillL1TriggerInfo(pat::Muon& muon,
140  edm::Handle<std::vector<pat::TriggerObjectStandAlone>>& triggerObjects,
141  const edm::TriggerNames& names,
142  const edm::ESHandle<GlobalTrackingGeometry>& geometry);
143  void fillHltTriggerInfo(pat::Muon& muon,
144  edm::Handle<std::vector<pat::TriggerObjectStandAlone>>& triggerObjects,
145  const edm::TriggerNames& names,
146  const std::vector<std::string>& collection_names);
147 
148  private:
150  edm::EDGetTokenT<edm::View<reco::Muon>> muonToken_;
151 
152  // for mini-iso calculation
153  edm::EDGetTokenT<pat::PackedCandidateCollection> pcToken_;
154  bool computeMiniIso_;
155  bool computePuppiCombinedIso_;
156  std::vector<double> effectiveAreaVec_;
157  std::vector<double> miniIsoParams_;
158  double relMiniIsoPUCorrected_;
160  double mvaIDtightCut_;
161  double mvaIDmediumCut_;
163  bool embedBestTrack_;
165  bool embedTunePBestTrack_;
167  bool forceEmbedBestTrack_;
169  bool embedTrack_;
171  bool embedStandAloneMuon_;
173  bool embedCombinedMuon_;
175  bool embedCaloMETMuonCorrs_;
177  edm::EDGetTokenT<edm::ValueMap<reco::MuonMETCorrectionData>> caloMETMuonCorrsToken_;
179  bool embedTcMETMuonCorrs_;
181  edm::EDGetTokenT<edm::ValueMap<reco::MuonMETCorrectionData>> tcMETMuonCorrsToken_;
183  bool embedPickyMuon_;
185  bool embedTpfmsMuon_;
187  bool embedDytMuon_;
189  bool addInverseBeta_;
191  edm::EDGetTokenT<edm::ValueMap<reco::MuonTimeExtra>> muonTimeExtraToken_;
193  bool addGenMatch_;
195  std::vector<edm::EDGetTokenT<edm::Association<reco::GenParticleCollection>>> genMatchTokens_;
197  bool embedGenMatch_;
199  bool addResolutions_;
201  pat::helper::KinResolutionsLoader resolutionLoader_;
203  bool useParticleFlow_;
205  edm::EDGetTokenT<reco::PFCandidateCollection> pfMuonToken_;
207  bool embedPFCandidate_;
209  bool embedHighLevelSelection_;
211  edm::EDGetTokenT<reco::BeamSpot> beamLineToken_;
213  edm::EDGetTokenT<std::vector<reco::Vertex>> pvToken_;
215  IsolationLabels isoDepositLabels_;
216  std::vector<edm::EDGetTokenT<edm::ValueMap<IsoDeposit>>> isoDepositTokens_;
218  IsolationLabels isolationValueLabels_;
219  std::vector<edm::EDGetTokenT<edm::ValueMap<double>>> isolationValueTokens_;
221  bool addEfficiencies_;
223  bool useUserData_;
225  bool embedPfEcalEnergy_;
227  bool addPuppiIsolation_;
228  //PUPPI isolation tokens
229  edm::EDGetTokenT<edm::ValueMap<float>> PUPPIIsolation_charged_hadrons_;
230  edm::EDGetTokenT<edm::ValueMap<float>> PUPPIIsolation_neutral_hadrons_;
231  edm::EDGetTokenT<edm::ValueMap<float>> PUPPIIsolation_photons_;
232  //PUPPINoLeptons isolation tokens
233  edm::EDGetTokenT<edm::ValueMap<float>> PUPPINoLeptonsIsolation_charged_hadrons_;
234  edm::EDGetTokenT<edm::ValueMap<float>> PUPPINoLeptonsIsolation_neutral_hadrons_;
235  edm::EDGetTokenT<edm::ValueMap<float>> PUPPINoLeptonsIsolation_photons_;
237  bool computeMuonIDMVA_;
238  bool computeSoftMuonMVA_;
239  bool recomputeBasicSelectors_;
240  bool useJec_;
241  edm::EDGetTokenT<reco::JetTagCollection> mvaBTagCollectionTag_;
242  edm::EDGetTokenT<reco::JetCorrector> mvaL1Corrector_;
243  edm::EDGetTokenT<reco::JetCorrector> mvaL1L2L3ResCorrector_;
244  edm::EDGetTokenT<double> rho_;
245 
248  pat::helper::MultiIsolator isolator_;
250  pat::helper::MultiIsolator::IsolationValuePairs isolatorTmpStorage_;
252  pat::helper::EfficiencyLoader efficiencyLoader_;
254  pat::PATUserDataHelper<pat::Muon> userDataHelper_;
255 
257  edm::EDGetTokenT<edm::ValueMap<reco::MuonSimInfo>> simInfo_;
258 
260  bool addTriggerMatching_;
261  edm::EDGetTokenT<std::vector<pat::TriggerObjectStandAlone>> triggerObjects_;
262  edm::EDGetTokenT<edm::TriggerResults> triggerResults_;
263  std::vector<std::string> hltCollectionFilters_;
264 
265  const edm::ESGetToken<GlobalTrackingGeometry, GlobalTrackingGeometryRecord> geometryToken_;
266  const edm::ESGetToken<TransientTrackBuilder, TransientTrackRecord> transientTrackBuilderToken_;
267 
268  const edm::EDPutTokenT<std::vector<Muon>> patMuonPutToken_;
269  };
270 
271 } // namespace pat
272 
273 template <typename T>
274 void pat::PATMuonProducer::readIsolationLabels(const edm::ParameterSet& iConfig,
275  const char* psetName,
276  pat::PATMuonProducer::IsolationLabels& labels,
277  std::vector<edm::EDGetTokenT<edm::ValueMap<T>>>& tokens) {
278  labels.clear();
279 
280  if (iConfig.exists(psetName)) {
281  edm::ParameterSet depconf = iConfig.getParameter<edm::ParameterSet>(psetName);
282 
283  if (depconf.exists("tracker"))
284  labels.emplace_back(pat::TrackIso, depconf.getParameter<edm::InputTag>("tracker"));
285  if (depconf.exists("ecal"))
286  labels.emplace_back(pat::EcalIso, depconf.getParameter<edm::InputTag>("ecal"));
287  if (depconf.exists("hcal"))
288  labels.emplace_back(pat::HcalIso, depconf.getParameter<edm::InputTag>("hcal"));
289  if (depconf.exists("pfAllParticles")) {
290  labels.emplace_back(pat::PfAllParticleIso, depconf.getParameter<edm::InputTag>("pfAllParticles"));
291  }
292  if (depconf.exists("pfChargedHadrons")) {
293  labels.emplace_back(pat::PfChargedHadronIso, depconf.getParameter<edm::InputTag>("pfChargedHadrons"));
294  }
295  if (depconf.exists("pfChargedAll")) {
296  labels.emplace_back(pat::PfChargedAllIso, depconf.getParameter<edm::InputTag>("pfChargedAll"));
297  }
298  if (depconf.exists("pfPUChargedHadrons")) {
299  labels.emplace_back(pat::PfPUChargedHadronIso, depconf.getParameter<edm::InputTag>("pfPUChargedHadrons"));
300  }
301  if (depconf.exists("pfNeutralHadrons")) {
302  labels.emplace_back(pat::PfNeutralHadronIso, depconf.getParameter<edm::InputTag>("pfNeutralHadrons"));
303  }
304  if (depconf.exists("pfPhotons")) {
305  labels.emplace_back(pat::PfGammaIso, depconf.getParameter<edm::InputTag>("pfPhotons"));
306  }
307  if (depconf.exists("user")) {
308  std::vector<edm::InputTag> userdeps = depconf.getParameter<std::vector<edm::InputTag>>("user");
309  std::vector<edm::InputTag>::const_iterator it = userdeps.begin(), ed = userdeps.end();
310  int key = pat::IsolationKeys::UserBaseIso;
311  for (; it != ed; ++it, ++key) {
312  labels.push_back(std::make_pair(pat::IsolationKeys(key), *it));
313  }
314  }
315  }
316  tokens = edm::vector_transform(labels, [this](pat::PATMuonProducer::IsolationLabel const& label) {
317  return consumes<edm::ValueMap<T>>(label.second);
318  });
319 }
320 
321 using namespace pat;
322 using namespace std;
323 
324 PATMuonHeavyObjectCache::PATMuonHeavyObjectCache(const edm::ParameterSet& iConfig) {
325  if (iConfig.getParameter<bool>("computeMiniIso")) {
326  float mvaDrMax = iConfig.getParameter<double>("mvaDrMax");
327  calculatePtRatioRel_ = std::make_unique<CalculatePtRatioRel>(mvaDrMax * mvaDrMax);
328  }
329 
330  if (iConfig.getParameter<bool>("computeMuonIDMVA")) {
331  edm::FileInPath mvaIDTrainingFile = iConfig.getParameter<edm::FileInPath>("mvaIDTrainingFile");
332  muonMvaIDEstimator_ = std::make_unique<MuonMvaIDEstimator>(mvaIDTrainingFile);
333  }
334 
335  if (iConfig.getParameter<bool>("computeSoftMuonMVA")) {
336  edm::FileInPath softMvaTrainingFile = iConfig.getParameter<edm::FileInPath>("softMvaTrainingFile");
337  softMuonMvaEstimator_ = std::make_unique<SoftMuonMvaEstimator>(softMvaTrainingFile);
338  }
339 }
340 
341 PATMuonProducer::PATMuonProducer(const edm::ParameterSet& iConfig, PATMuonHeavyObjectCache const*)
342  : relMiniIsoPUCorrected_(0),
343  useUserData_(iConfig.exists("userData")),
344  computeMuonIDMVA_(false),
345  computeSoftMuonMVA_(false),
346  recomputeBasicSelectors_(false),
347  useJec_(false),
348  isolator_(iConfig.getParameter<edm::ParameterSet>("userIsolation"), consumesCollector(), false),
349  geometryToken_{esConsumes()},
350  transientTrackBuilderToken_{esConsumes(edm::ESInputTag("", "TransientTrackBuilder"))},
351  patMuonPutToken_{produces<std::vector<Muon>>()} {
352  // Muon MVA ID wps
353  mvaIDmediumCut_ = iConfig.getParameter<double>("mvaIDwpMedium");
354  mvaIDtightCut_ = iConfig.getParameter<double>("mvaIDwpTight");
355 
356  // input source
357  muonToken_ = consumes<edm::View<reco::Muon>>(iConfig.getParameter<edm::InputTag>("muonSource"));
358  // embedding of tracks
359  embedBestTrack_ = iConfig.getParameter<bool>("embedMuonBestTrack");
360  embedTunePBestTrack_ = iConfig.getParameter<bool>("embedTunePMuonBestTrack");
361  forceEmbedBestTrack_ = iConfig.getParameter<bool>("forceBestTrackEmbedding");
362  embedTrack_ = iConfig.getParameter<bool>("embedTrack");
363  embedCombinedMuon_ = iConfig.getParameter<bool>("embedCombinedMuon");
364  embedStandAloneMuon_ = iConfig.getParameter<bool>("embedStandAloneMuon");
365  // embedding of muon MET correction information
366  embedCaloMETMuonCorrs_ = iConfig.getParameter<bool>("embedCaloMETMuonCorrs");
367  embedTcMETMuonCorrs_ = iConfig.getParameter<bool>("embedTcMETMuonCorrs");
368  caloMETMuonCorrsToken_ =
369  mayConsume<edm::ValueMap<reco::MuonMETCorrectionData>>(iConfig.getParameter<edm::InputTag>("caloMETMuonCorrs"));
370  tcMETMuonCorrsToken_ =
371  mayConsume<edm::ValueMap<reco::MuonMETCorrectionData>>(iConfig.getParameter<edm::InputTag>("tcMETMuonCorrs"));
372  // pflow specific configurables
373  useParticleFlow_ = iConfig.getParameter<bool>("useParticleFlow");
374  embedPFCandidate_ = iConfig.getParameter<bool>("embedPFCandidate");
375  pfMuonToken_ = mayConsume<reco::PFCandidateCollection>(iConfig.getParameter<edm::InputTag>("pfMuonSource"));
376  embedPfEcalEnergy_ = iConfig.getParameter<bool>("embedPfEcalEnergy");
377  // embedding of tracks from TeV refit
378  embedPickyMuon_ = iConfig.getParameter<bool>("embedPickyMuon");
379  embedTpfmsMuon_ = iConfig.getParameter<bool>("embedTpfmsMuon");
380  embedDytMuon_ = iConfig.getParameter<bool>("embedDytMuon");
381  // embedding of inverse beta variable information
382  addInverseBeta_ = iConfig.getParameter<bool>("addInverseBeta");
383  if (addInverseBeta_) {
384  muonTimeExtraToken_ =
385  consumes<edm::ValueMap<reco::MuonTimeExtra>>(iConfig.getParameter<edm::InputTag>("sourceMuonTimeExtra"));
386  }
387  // Monte Carlo matching
388  addGenMatch_ = iConfig.getParameter<bool>("addGenMatch");
389  if (addGenMatch_) {
390  embedGenMatch_ = iConfig.getParameter<bool>("embedGenMatch");
391  if (iConfig.existsAs<edm::InputTag>("genParticleMatch")) {
392  genMatchTokens_.push_back(consumes<edm::Association<reco::GenParticleCollection>>(
393  iConfig.getParameter<edm::InputTag>("genParticleMatch")));
394  } else {
395  genMatchTokens_ = edm::vector_transform(
396  iConfig.getParameter<std::vector<edm::InputTag>>("genParticleMatch"),
397  [this](edm::InputTag const& tag) { return consumes<edm::Association<reco::GenParticleCollection>>(tag); });
398  }
399  }
400  // efficiencies
401  addEfficiencies_ = iConfig.getParameter<bool>("addEfficiencies");
402  if (addEfficiencies_) {
403  efficiencyLoader_ =
404  pat::helper::EfficiencyLoader(iConfig.getParameter<edm::ParameterSet>("efficiencies"), consumesCollector());
405  }
406  // resolutions
407  addResolutions_ = iConfig.getParameter<bool>("addResolutions");
408  if (addResolutions_) {
409  resolutionLoader_ =
410  pat::helper::KinResolutionsLoader(iConfig.getParameter<edm::ParameterSet>("resolutions"), consumesCollector());
411  }
412  // puppi
413  addPuppiIsolation_ = iConfig.getParameter<bool>("addPuppiIsolation");
414  if (addPuppiIsolation_) {
415  PUPPIIsolation_charged_hadrons_ =
416  consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiIsolationChargedHadrons"));
417  PUPPIIsolation_neutral_hadrons_ =
418  consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiIsolationNeutralHadrons"));
419  PUPPIIsolation_photons_ =
420  consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiIsolationPhotons"));
421  //puppiNoLeptons
422  PUPPINoLeptonsIsolation_charged_hadrons_ =
423  consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiNoLeptonsIsolationChargedHadrons"));
424  PUPPINoLeptonsIsolation_neutral_hadrons_ =
425  consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiNoLeptonsIsolationNeutralHadrons"));
426  PUPPINoLeptonsIsolation_photons_ =
427  consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiNoLeptonsIsolationPhotons"));
428  }
429  // read isoDeposit labels, for direct embedding
430  readIsolationLabels(iConfig, "isoDeposits", isoDepositLabels_, isoDepositTokens_);
431  // read isolation value labels, for direct embedding
432  readIsolationLabels(iConfig, "isolationValues", isolationValueLabels_, isolationValueTokens_);
433  // check to see if the user wants to add user data
434  if (useUserData_) {
435  userDataHelper_ = PATUserDataHelper<Muon>(iConfig.getParameter<edm::ParameterSet>("userData"), consumesCollector());
436  }
437  // embed high level selection variables
438  embedHighLevelSelection_ = iConfig.getParameter<bool>("embedHighLevelSelection");
439  if (embedHighLevelSelection_) {
440  beamLineToken_ = consumes<reco::BeamSpot>(iConfig.getParameter<edm::InputTag>("beamLineSrc"));
441  pvToken_ = consumes<std::vector<reco::Vertex>>(iConfig.getParameter<edm::InputTag>("pvSrc"));
442  }
443 
444  //for mini-isolation calculation
445  computeMiniIso_ = iConfig.getParameter<bool>("computeMiniIso");
446 
447  computePuppiCombinedIso_ = iConfig.getParameter<bool>("computePuppiCombinedIso");
448 
449  effectiveAreaVec_ = iConfig.getParameter<std::vector<double>>("effectiveAreaVec");
450 
451  miniIsoParams_ = iConfig.getParameter<std::vector<double>>("miniIsoParams");
452  if (computeMiniIso_ && miniIsoParams_.size() != 9) {
453  throw cms::Exception("ParameterError") << "miniIsoParams must have exactly 9 elements.\n";
454  }
455  if (computeMiniIso_ || computePuppiCombinedIso_)
456  pcToken_ = consumes<pat::PackedCandidateCollection>(iConfig.getParameter<edm::InputTag>("pfCandsForMiniIso"));
457 
458  // standard selectors
459  recomputeBasicSelectors_ = iConfig.getParameter<bool>("recomputeBasicSelectors");
460  computeMuonIDMVA_ = iConfig.getParameter<bool>("computeMuonIDMVA");
461 
462  if (computeMiniIso_) {
463  // pfCombinedInclusiveSecondaryVertexV2BJetTags
464  mvaBTagCollectionTag_ = consumes<reco::JetTagCollection>(iConfig.getParameter<edm::InputTag>("mvaJetTag"));
465  mvaL1Corrector_ = consumes<reco::JetCorrector>(iConfig.getParameter<edm::InputTag>("mvaL1Corrector"));
466  mvaL1L2L3ResCorrector_ = consumes<reco::JetCorrector>(iConfig.getParameter<edm::InputTag>("mvaL1L2L3ResCorrector"));
467  rho_ = consumes<double>(iConfig.getParameter<edm::InputTag>("rho"));
468  useJec_ = iConfig.getParameter<bool>("useJec");
469  }
470 
471  computeSoftMuonMVA_ = iConfig.getParameter<bool>("computeSoftMuonMVA");
472 
473  // MC info
474  simInfo_ = consumes<edm::ValueMap<reco::MuonSimInfo>>(iConfig.getParameter<edm::InputTag>("muonSimInfo"));
475 
476  addTriggerMatching_ = iConfig.getParameter<bool>("addTriggerMatching");
477  if (addTriggerMatching_) {
478  triggerObjects_ =
479  consumes<std::vector<pat::TriggerObjectStandAlone>>(iConfig.getParameter<edm::InputTag>("triggerObjects"));
480  triggerResults_ = consumes<edm::TriggerResults>(iConfig.getParameter<edm::InputTag>("triggerResults"));
481  }
482  hltCollectionFilters_ = iConfig.getParameter<std::vector<std::string>>("hltCollectionFilters");
483 }
484 
485 PATMuonProducer::~PATMuonProducer() {}
486 
487 std::optional<GlobalPoint> PATMuonProducer::getMuonDirection(const reco::MuonChamberMatch& chamberMatch,
488  const edm::ESHandle<GlobalTrackingGeometry>& geometry,
489  const DetId& chamberId) {
490  const GeomDet* chamberGeometry = geometry->idToDet(chamberId);
491  if (chamberGeometry) {
492  LocalPoint localPosition(chamberMatch.x, chamberMatch.y, 0);
493  return std::optional<GlobalPoint>(std::in_place, chamberGeometry->toGlobal(localPosition));
494  }
495  return std::optional<GlobalPoint>();
496 }
497 
498 void PATMuonProducer::fillL1TriggerInfo(pat::Muon& aMuon,
499  edm::Handle<std::vector<pat::TriggerObjectStandAlone>>& triggerObjects,
500  const edm::TriggerNames& names,
501  const edm::ESHandle<GlobalTrackingGeometry>& geometry) {
502  // L1 trigger object parameters are defined at MB2/ME2. Use the muon
503  // chamber matching information to get the local direction of the
504  // muon trajectory and convert it to a global direction to match the
505  // trigger objects
506 
507  std::optional<GlobalPoint> muonPosition;
508  // Loop over chambers
509  // initialize muonPosition with any available match, just in case
510  // the second station is missing - it's better folling back to
511  // dR matching at IP
512  for (const auto& chamberMatch : aMuon.matches()) {
513  if (chamberMatch.id.subdetId() == MuonSubdetId::DT) {
514  DTChamberId detId(chamberMatch.id.rawId());
515  if (abs(detId.station()) > 3)
516  continue;
517  muonPosition = getMuonDirection(chamberMatch, geometry, detId);
518  if (abs(detId.station()) == 2)
519  break;
520  }
521  if (chamberMatch.id.subdetId() == MuonSubdetId::CSC) {
522  CSCDetId detId(chamberMatch.id.rawId());
523  if (abs(detId.station()) > 3)
524  continue;
525  muonPosition = getMuonDirection(chamberMatch, geometry, detId);
526  if (abs(detId.station()) == 2)
527  break;
528  }
529  }
530  if (not muonPosition)
531  return;
532  for (const auto& triggerObject : *triggerObjects) {
533  if (triggerObject.hasTriggerObjectType(trigger::TriggerL1Mu)) {
534  if (std::abs(triggerObject.eta()) < 0.001) {
535  // L1 is defined in X-Y plain
536  if (deltaPhi(triggerObject.phi(), muonPosition->phi()) > 0.1)
537  continue;
538  } else {
539  // 3D L1
540  if (deltaR(triggerObject.p4(), *muonPosition) > 0.15)
541  continue;
542  }
543  pat::TriggerObjectStandAlone obj(triggerObject);
544  obj.unpackPathNames(names);
545  aMuon.addTriggerObjectMatch(obj);
546  }
547  }
548 }
549 
550 void PATMuonProducer::fillHltTriggerInfo(pat::Muon& muon,
551  edm::Handle<std::vector<pat::TriggerObjectStandAlone>>& triggerObjects,
552  const edm::TriggerNames& names,
553  const std::vector<std::string>& collection_filter_names) {
554  // WARNING: in a case of close-by muons the dR matching may select both muons.
555  // It's better to select the best match for a given collection.
556  for (const auto& triggerObject : *triggerObjects) {
557  if (triggerObject.hasTriggerObjectType(trigger::TriggerMuon)) {
558  bool keepIt = false;
559  for (const auto& name : collection_filter_names) {
560  if (triggerObject.hasCollection(name)) {
561  keepIt = true;
562  break;
563  }
564  }
565  if (not keepIt)
566  continue;
567  if (deltaR(triggerObject.p4(), muon) > 0.1)
568  continue;
569  pat::TriggerObjectStandAlone obj(triggerObject);
570  obj.unpackPathNames(names);
571  muon.addTriggerObjectMatch(obj);
572  }
573  }
574 }
575 
576 void PATMuonProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
577  // get the tracking Geometry
578  auto geometry = iSetup.getHandle(geometryToken_);
579  if (!geometry.isValid())
580  throw cms::Exception("FatalError") << "Unable to find GlobalTrackingGeometryRecord in event!\n";
581 
582  // switch off embedding (in unschedules mode)
583  if (iEvent.isRealData()) {
584  addGenMatch_ = false;
585  embedGenMatch_ = false;
586  }
587 
588  edm::Handle<edm::View<reco::Muon>> muons;
589  iEvent.getByToken(muonToken_, muons);
590 
591  edm::Handle<pat::PackedCandidateCollection> pc;
592  if (computeMiniIso_ || computePuppiCombinedIso_)
593  iEvent.getByToken(pcToken_, pc);
594 
595  // get the ESHandle for the transient track builder,
596  // if needed for high level selection embedding
597  TransientTrackBuilder const* trackBuilder = nullptr;
598 
599  if (isolator_.enabled())
600  isolator_.beginEvent(iEvent, iSetup);
601  if (efficiencyLoader_.enabled())
602  efficiencyLoader_.newEvent(iEvent);
603  if (resolutionLoader_.enabled())
604  resolutionLoader_.newEvent(iEvent, iSetup);
605 
606  IsoDepositMaps deposits(isoDepositTokens_.size());
607  for (size_t j = 0; j < isoDepositTokens_.size(); ++j) {
608  iEvent.getByToken(isoDepositTokens_[j], deposits[j]);
609  }
610 
611  IsolationValueMaps isolationValues(isolationValueTokens_.size());
612  for (size_t j = 0; j < isolationValueTokens_.size(); ++j) {
613  iEvent.getByToken(isolationValueTokens_[j], isolationValues[j]);
614  }
615 
616  //value maps for puppi isolation
617  edm::Handle<edm::ValueMap<float>> PUPPIIsolation_charged_hadrons;
618  edm::Handle<edm::ValueMap<float>> PUPPIIsolation_neutral_hadrons;
619  edm::Handle<edm::ValueMap<float>> PUPPIIsolation_photons;
620  //value maps for puppiNoLeptons isolation
621  edm::Handle<edm::ValueMap<float>> PUPPINoLeptonsIsolation_charged_hadrons;
622  edm::Handle<edm::ValueMap<float>> PUPPINoLeptonsIsolation_neutral_hadrons;
623  edm::Handle<edm::ValueMap<float>> PUPPINoLeptonsIsolation_photons;
624  if (addPuppiIsolation_) {
625  //puppi
626  iEvent.getByToken(PUPPIIsolation_charged_hadrons_, PUPPIIsolation_charged_hadrons);
627  iEvent.getByToken(PUPPIIsolation_neutral_hadrons_, PUPPIIsolation_neutral_hadrons);
628  iEvent.getByToken(PUPPIIsolation_photons_, PUPPIIsolation_photons);
629  //puppiNoLeptons
630  iEvent.getByToken(PUPPINoLeptonsIsolation_charged_hadrons_, PUPPINoLeptonsIsolation_charged_hadrons);
631  iEvent.getByToken(PUPPINoLeptonsIsolation_neutral_hadrons_, PUPPINoLeptonsIsolation_neutral_hadrons);
632  iEvent.getByToken(PUPPINoLeptonsIsolation_photons_, PUPPINoLeptonsIsolation_photons);
633  }
634 
635  // inputs for muon mva
636  edm::Handle<reco::JetTagCollection> mvaBTagCollectionTag;
637  edm::Handle<reco::JetCorrector> mvaL1Corrector;
638  edm::Handle<reco::JetCorrector> mvaL1L2L3ResCorrector;
639  if (computeMiniIso_) {
640  iEvent.getByToken(mvaBTagCollectionTag_, mvaBTagCollectionTag);
641  iEvent.getByToken(mvaL1Corrector_, mvaL1Corrector);
642  iEvent.getByToken(mvaL1L2L3ResCorrector_, mvaL1L2L3ResCorrector);
643  }
644 
645  // prepare the MC genMatchTokens_
646  GenAssociations genMatches(genMatchTokens_.size());
647  if (addGenMatch_) {
648  for (size_t j = 0, nd = genMatchTokens_.size(); j < nd; ++j) {
649  iEvent.getByToken(genMatchTokens_[j], genMatches[j]);
650  }
651  }
652 
653  // prepare the high level selection: needs beamline
654  // OR primary vertex, depending on user selection
655  reco::Vertex primaryVertex;
656  reco::BeamSpot beamSpot;
657  bool beamSpotIsValid = false;
658  bool primaryVertexIsValid = false;
659  if (embedHighLevelSelection_) {
660  // get the beamspot
661  edm::Handle<reco::BeamSpot> beamSpotHandle;
662  iEvent.getByToken(beamLineToken_, beamSpotHandle);
663 
664  // get the primary vertex
665  edm::Handle<std::vector<reco::Vertex>> pvHandle;
666  iEvent.getByToken(pvToken_, pvHandle);
667 
668  if (beamSpotHandle.isValid()) {
669  beamSpot = *beamSpotHandle;
670  beamSpotIsValid = true;
671  } else {
672  edm::LogError("DataNotAvailable") << "No beam spot available from EventSetup, not adding high level selection \n";
673  }
674  if (pvHandle.isValid() && !pvHandle->empty()) {
675  primaryVertex = pvHandle->at(0);
676  primaryVertexIsValid = true;
677  } else {
678  edm::LogError("DataNotAvailable")
679  << "No primary vertex available from EventSetup, not adding high level selection \n";
680  }
681  // this is needed by the IPTools methods from the tracking group
682  trackBuilder = &iSetup.getData(transientTrackBuilderToken_);
683  }
684 
685  // MC info
686  edm::Handle<edm::ValueMap<reco::MuonSimInfo>> simInfo;
687  bool simInfoIsAvailalbe = iEvent.getByToken(simInfo_, simInfo);
688 
689  // this will be the new object collection
690  std::vector<Muon> patMuons;
691 
692  edm::Handle<reco::PFCandidateCollection> pfMuons;
693  if (useParticleFlow_) {
694  // get the PFCandidates of type muons
695  iEvent.getByToken(pfMuonToken_, pfMuons);
696 
697  unsigned index = 0;
698  for (reco::PFCandidateConstIterator i = pfMuons->begin(); i != pfMuons->end(); ++i, ++index) {
699  const reco::PFCandidate& pfmu = *i;
700  //const reco::IsolaPFCandidate& pfmu = *i;
701  const reco::MuonRef& muonRef = pfmu.muonRef();
702  assert(muonRef.isNonnull());
703 
704  MuonBaseRef muonBaseRef(muonRef);
705  Muon aMuon(muonBaseRef);
706 
707  if (useUserData_) {
708  userDataHelper_.add(aMuon, iEvent, iSetup);
709  }
710 
711  // embed high level selection
712  if (embedHighLevelSelection_) {
713  // get the tracks
714  reco::TrackRef innerTrack = muonBaseRef->innerTrack();
715  reco::TrackRef globalTrack = muonBaseRef->globalTrack();
716  reco::TrackRef bestTrack = muonBaseRef->muonBestTrack();
717  reco::TrackRef chosenTrack = innerTrack;
718  // Make sure the collection it points to is there
719  if (bestTrack.isNonnull() && bestTrack.isAvailable())
720  chosenTrack = bestTrack;
721 
722  if (chosenTrack.isNonnull() && chosenTrack.isAvailable()) {
723  unsigned int nhits = chosenTrack->numberOfValidHits(); // ????
724  aMuon.setNumberOfValidHits(nhits);
725 
726  reco::TransientTrack tt = trackBuilder->build(chosenTrack);
727  embedHighLevel(aMuon, chosenTrack, tt, primaryVertex, primaryVertexIsValid, beamSpot, beamSpotIsValid);
728  }
729 
730  if (globalTrack.isNonnull() && globalTrack.isAvailable() && !embedCombinedMuon_) {
731  double norm_chi2 = globalTrack->chi2() / globalTrack->ndof();
732  aMuon.setNormChi2(norm_chi2);
733  }
734  }
735  reco::PFCandidateRef pfRef(pfMuons, index);
736  //reco::PFCandidatePtr ptrToMother(pfMuons,index);
737  reco::CandidateBaseRef pfBaseRef(pfRef);
738 
739  aMuon.setPFCandidateRef(pfRef);
740  if (embedPFCandidate_)
741  aMuon.embedPFCandidate();
742  fillMuon(aMuon, muonBaseRef, pfBaseRef, genMatches, deposits, isolationValues);
743 
744  if (computeMiniIso_)
745  setMuonMiniIso(aMuon, pc.product());
746 
747  if (addPuppiIsolation_) {
748  aMuon.setIsolationPUPPI((*PUPPIIsolation_charged_hadrons)[muonBaseRef],
749  (*PUPPIIsolation_neutral_hadrons)[muonBaseRef],
750  (*PUPPIIsolation_photons)[muonBaseRef]);
751 
752  aMuon.setIsolationPUPPINoLeptons((*PUPPINoLeptonsIsolation_charged_hadrons)[muonBaseRef],
753  (*PUPPINoLeptonsIsolation_neutral_hadrons)[muonBaseRef],
754  (*PUPPINoLeptonsIsolation_photons)[muonBaseRef]);
755  } else {
756  aMuon.setIsolationPUPPI(-999., -999., -999.);
757  aMuon.setIsolationPUPPINoLeptons(-999., -999., -999.);
758  }
759 
760  if (embedPfEcalEnergy_) {
761  aMuon.setPfEcalEnergy(pfmu.ecalEnergy());
762  }
763 
764  patMuons.push_back(aMuon);
765  }
766  } else {
767  edm::Handle<edm::View<reco::Muon>> muons;
768  iEvent.getByToken(muonToken_, muons);
769 
770  // embedding of muon MET corrections
771  edm::Handle<edm::ValueMap<reco::MuonMETCorrectionData>> caloMETMuonCorrs;
772  //edm::ValueMap<reco::MuonMETCorrectionData> caloMETmuCorValueMap;
773  if (embedCaloMETMuonCorrs_) {
774  iEvent.getByToken(caloMETMuonCorrsToken_, caloMETMuonCorrs);
775  //caloMETmuCorValueMap = *caloMETmuCorValueMap_h;
776  }
777  edm::Handle<edm::ValueMap<reco::MuonMETCorrectionData>> tcMETMuonCorrs;
778  //edm::ValueMap<reco::MuonMETCorrectionData> tcMETmuCorValueMap;
779  if (embedTcMETMuonCorrs_) {
780  iEvent.getByToken(tcMETMuonCorrsToken_, tcMETMuonCorrs);
781  //tcMETmuCorValueMap = *tcMETmuCorValueMap_h;
782  }
783 
784  if (embedPfEcalEnergy_ || embedPFCandidate_) {
785  // get the PFCandidates of type muons
786  iEvent.getByToken(pfMuonToken_, pfMuons);
787  }
788 
789  edm::Handle<edm::ValueMap<reco::MuonTimeExtra>> muonsTimeExtra;
790  if (addInverseBeta_) {
791  // get MuonTimerExtra value map
792  iEvent.getByToken(muonTimeExtraToken_, muonsTimeExtra);
793  }
794 
795  for (edm::View<reco::Muon>::const_iterator itMuon = muons->begin(); itMuon != muons->end(); ++itMuon) {
796  // construct the Muon from the ref -> save ref to original object
797  unsigned int idx = itMuon - muons->begin();
798  MuonBaseRef muonRef = muons->refAt(idx);
799  reco::CandidateBaseRef muonBaseRef(muonRef);
800 
801  Muon aMuon(muonRef);
802  fillMuon(aMuon, muonRef, muonBaseRef, genMatches, deposits, isolationValues);
803  if (computeMiniIso_)
804  setMuonMiniIso(aMuon, pc.product());
805  if (addPuppiIsolation_) {
806  aMuon.setIsolationPUPPI((*PUPPIIsolation_charged_hadrons)[muonRef],
807  (*PUPPIIsolation_neutral_hadrons)[muonRef],
808  (*PUPPIIsolation_photons)[muonRef]);
809  aMuon.setIsolationPUPPINoLeptons((*PUPPINoLeptonsIsolation_charged_hadrons)[muonRef],
810  (*PUPPINoLeptonsIsolation_neutral_hadrons)[muonRef],
811  (*PUPPINoLeptonsIsolation_photons)[muonRef]);
812  } else {
813  aMuon.setIsolationPUPPI(-999., -999., -999.);
814  aMuon.setIsolationPUPPINoLeptons(-999., -999., -999.);
815  }
816 
817  // Isolation
818  if (isolator_.enabled()) {
819  //reco::CandidatePtr mother = ptrToMother->sourceCandidatePtr(0);
820  isolator_.fill(*muons, idx, isolatorTmpStorage_);
821  typedef pat::helper::MultiIsolator::IsolationValuePairs IsolationValuePairs;
822  // better to loop backwards, so the vector is resized less times
823  for (IsolationValuePairs::const_reverse_iterator it = isolatorTmpStorage_.rbegin(),
824  ed = isolatorTmpStorage_.rend();
825  it != ed;
826  ++it) {
827  aMuon.setIsolation(it->first, it->second);
828  }
829  }
830 
831  // for (size_t j = 0, nd = deposits.size(); j < nd; ++j) {
832  // aMuon.setIsoDeposit(isoDepositLabels_[j].first,
833  // (*deposits[j])[muonRef]);
834  // }
835 
836  // add sel to selected
837  edm::Ptr<reco::Muon> muonsPtr = muons->ptrAt(idx);
838  if (useUserData_) {
839  userDataHelper_.add(aMuon, iEvent, iSetup);
840  }
841 
842  // embed high level selection
843  if (embedHighLevelSelection_) {
844  // get the tracks
845  reco::TrackRef innerTrack = itMuon->innerTrack();
846  reco::TrackRef globalTrack = itMuon->globalTrack();
847  reco::TrackRef bestTrack = itMuon->muonBestTrack();
848  reco::TrackRef chosenTrack = innerTrack;
849  // Make sure the collection it points to is there
850  if (bestTrack.isNonnull() && bestTrack.isAvailable())
851  chosenTrack = bestTrack;
852  if (chosenTrack.isNonnull() && chosenTrack.isAvailable()) {
853  unsigned int nhits = chosenTrack->numberOfValidHits(); // ????
854  aMuon.setNumberOfValidHits(nhits);
855 
856  reco::TransientTrack tt = trackBuilder->build(chosenTrack);
857  embedHighLevel(aMuon, chosenTrack, tt, primaryVertex, primaryVertexIsValid, beamSpot, beamSpotIsValid);
858  }
859 
860  if (globalTrack.isNonnull() && globalTrack.isAvailable()) {
861  double norm_chi2 = globalTrack->chi2() / globalTrack->ndof();
862  aMuon.setNormChi2(norm_chi2);
863  }
864  }
865 
866  // embed MET muon corrections
867  if (embedCaloMETMuonCorrs_)
868  aMuon.embedCaloMETMuonCorrs((*caloMETMuonCorrs)[muonRef]);
869  if (embedTcMETMuonCorrs_)
870  aMuon.embedTcMETMuonCorrs((*tcMETMuonCorrs)[muonRef]);
871 
872  if (embedPfEcalEnergy_ || embedPFCandidate_) {
873  if (embedPfEcalEnergy_)
874  aMuon.setPfEcalEnergy(-99.0);
875  unsigned index = 0;
876  for (const reco::PFCandidate& pfmu : *pfMuons) {
877  if (pfmu.muonRef().isNonnull()) {
878  if (pfmu.muonRef().id() != muonRef.id())
879  throw cms::Exception("Configuration")
880  << "Muon reference within PF candidates does not point to the muon collection." << std::endl;
881  if (pfmu.muonRef().key() == muonRef.key()) {
882  reco::PFCandidateRef pfRef(pfMuons, index);
883  aMuon.setPFCandidateRef(pfRef);
884  if (embedPfEcalEnergy_)
885  aMuon.setPfEcalEnergy(pfmu.ecalEnergy());
886  if (embedPFCandidate_)
887  aMuon.embedPFCandidate();
888  break;
889  }
890  }
891  index++;
892  }
893  }
894 
895  if (addInverseBeta_) {
896  aMuon.readTimeExtra((*muonsTimeExtra)[muonRef]);
897  }
898  // MC info
899  aMuon.initSimInfo();
900  if (simInfoIsAvailalbe) {
901  const auto& msi = (*simInfo)[muonBaseRef];
902  aMuon.setSimType(msi.primaryClass);
903  aMuon.setExtSimType(msi.extendedClass);
904  aMuon.setSimFlavour(msi.flavour);
905  aMuon.setSimHeaviestMotherFlavour(msi.heaviestMotherFlavour);
906  aMuon.setSimPdgId(msi.pdgId);
907  aMuon.setSimMotherPdgId(msi.motherPdgId);
908  aMuon.setSimBX(msi.tpBX);
909  aMuon.setSimTpEvent(msi.tpEvent);
910  aMuon.setSimProdRho(msi.vertex.Rho());
911  aMuon.setSimProdZ(msi.vertex.Z());
912  aMuon.setSimPt(msi.p4.pt());
913  aMuon.setSimEta(msi.p4.eta());
914  aMuon.setSimPhi(msi.p4.phi());
915  aMuon.setSimMatchQuality(msi.tpAssoQuality);
916  }
917  patMuons.push_back(aMuon);
918  }
919  }
920 
921  // sort muons in pt
922  std::sort(patMuons.begin(), patMuons.end(), [](auto const& t1, auto const& t2) { return t1.pt() > t2.pt(); });
923 
924  // Store standard muon selection decisions and jet related
925  // quantaties.
926  // Need a separate loop over muons to have all inputs properly
927  // computed and stored in the object.
928  edm::Handle<double> rho;
929  if (computeMiniIso_)
930  iEvent.getByToken(rho_, rho);
931  const reco::Vertex* pv(nullptr);
932  if (primaryVertexIsValid)
933  pv = &primaryVertex;
934 
935  edm::Handle<std::vector<pat::TriggerObjectStandAlone>> triggerObjects;
936  edm::Handle<edm::TriggerResults> triggerResults;
937  bool triggerObjectsAvailable = false;
938  bool triggerResultsAvailable = false;
939  if (addTriggerMatching_) {
940  triggerObjectsAvailable = iEvent.getByToken(triggerObjects_, triggerObjects);
941  triggerResultsAvailable = iEvent.getByToken(triggerResults_, triggerResults);
942  }
943 
944  for (auto& muon : patMuons) {
945  // trigger info
946  if (addTriggerMatching_ and triggerObjectsAvailable and triggerResultsAvailable) {
947  const edm::TriggerNames& triggerNames(iEvent.triggerNames(*triggerResults));
948  fillL1TriggerInfo(muon, triggerObjects, triggerNames, geometry);
949  fillHltTriggerInfo(muon, triggerObjects, triggerNames, hltCollectionFilters_);
950  }
951 
952  if (recomputeBasicSelectors_) {
953  muon.setSelectors(0);
954  bool isRun2016BCDEF = (272728 <= iEvent.run() && iEvent.run() <= 278808);
955  muon.setSelectors(muon::makeSelectorBitset(muon, pv, isRun2016BCDEF));
956  }
957  float miniIsoValue = -1;
958  if (computeMiniIso_) {
959  // MiniIsolation working points
960 
961  miniIsoValue = getRelMiniIsoPUCorrected(muon, *rho, effectiveAreaVec_);
962 
963  muon.setSelector(reco::Muon::MiniIsoLoose, miniIsoValue < 0.40);
964  muon.setSelector(reco::Muon::MiniIsoMedium, miniIsoValue < 0.20);
965  muon.setSelector(reco::Muon::MiniIsoTight, miniIsoValue < 0.10);
966  muon.setSelector(reco::Muon::MiniIsoVeryTight, miniIsoValue < 0.05);
967  }
968 
969  double puppiCombinedIsolationPAT = -1;
970  if (computePuppiCombinedIso_) {
971  puppiCombinedIsolationPAT = puppiCombinedIsolation(muon, pc.product());
972  muon.setSelector(reco::Muon::PuppiIsoLoose, puppiCombinedIsolationPAT < 0.27);
973  muon.setSelector(reco::Muon::PuppiIsoMedium, puppiCombinedIsolationPAT < 0.22);
974  muon.setSelector(reco::Muon::PuppiIsoTight, puppiCombinedIsolationPAT < 0.12);
975  }
976 
977  std::array<float, 2> jetPtRatioRel = {{0.0, 0.0}};
978  if (primaryVertexIsValid && computeMiniIso_) {
979  if (useJec_) {
980  jetPtRatioRel = globalCache()->calculatePtRatioRel().computePtRatioRel(
981  muon, *(mvaBTagCollectionTag.product()), mvaL1Corrector.product(), mvaL1L2L3ResCorrector.product());
982  } else {
983  jetPtRatioRel = globalCache()->calculatePtRatioRel().computePtRatioRel(muon, *mvaBTagCollectionTag);
984  }
985 
986  muon.setJetPtRatio(jetPtRatioRel[0]);
987  muon.setJetPtRel(jetPtRatioRel[1]);
988 
989  // multi-isolation
990  if (computeMiniIso_) {
991  muon.setSelector(reco::Muon::MultiIsoMedium,
992  miniIsoValue < 0.11 && (muon.jetPtRatio() > 0.74 || muon.jetPtRel() > 6.8));
993  }
994  }
995 
996  // MVA ID
997  float mvaID = 0.0;
998  constexpr int MVAsentinelValue = -99;
999  if (computeMuonIDMVA_) {
1000  if (muon.isLooseMuon()) {
1001  mvaID = globalCache()->muonMvaIDEstimator().computeMVAID(muon)[1];
1002  } else {
1003  mvaID = MVAsentinelValue;
1004  }
1005  muon.setMvaIDValue(mvaID);
1006  muon.setSelector(reco::Muon::MvaIDwpMedium, muon.mvaIDValue() > mvaIDmediumCut_);
1007  muon.setSelector(reco::Muon::MvaIDwpTight, muon.mvaIDValue() > mvaIDtightCut_);
1008  }
1009 
1010  //SOFT MVA
1011  if (computeSoftMuonMVA_) {
1012  float mva = globalCache()->softMuonMvaEstimator().computeMva(muon);
1013  muon.setSoftMvaValue(mva);
1014  //preselection in SoftMuonMvaEstimator.cc
1015  muon.setSelector(reco::Muon::SoftMvaId, muon.softMvaValue() > 0.58); //WP choose for bmm4
1016  }
1017  }
1018 
1019  // put products in Event
1020  iEvent.emplace(patMuonPutToken_, std::move(patMuons));
1021 
1022  if (isolator_.enabled())
1023  isolator_.endEvent();
1024 }
1025 
1026 void PATMuonProducer::fillMuon(Muon& aMuon,
1027  const MuonBaseRef& muonRef,
1028  const reco::CandidateBaseRef& baseRef,
1029  const GenAssociations& genMatches,
1030  const IsoDepositMaps& deposits,
1031  const IsolationValueMaps& isolationValues) const {
1032  // in the particle flow algorithm,
1033  // the muon momentum is recomputed.
1034  // the new value is stored as the momentum of the
1035  // resulting PFCandidate of type Muon, and choosen
1036  // as the pat::Muon momentum
1037  if (useParticleFlow_)
1038  aMuon.setP4(aMuon.pfCandidateRef()->p4());
1039  if (embedTrack_)
1040  aMuon.embedTrack();
1041  if (embedStandAloneMuon_)
1042  aMuon.embedStandAloneMuon();
1043  if (embedCombinedMuon_)
1044  aMuon.embedCombinedMuon();
1045 
1046  // embed the TeV refit track refs (only available for globalMuons)
1047  if (aMuon.isGlobalMuon()) {
1048  if (embedPickyMuon_ && aMuon.isAValidMuonTrack(reco::Muon::Picky))
1049  aMuon.embedPickyMuon();
1050  if (embedTpfmsMuon_ && aMuon.isAValidMuonTrack(reco::Muon::TPFMS))
1051  aMuon.embedTpfmsMuon();
1052  if (embedDytMuon_ && aMuon.isAValidMuonTrack(reco::Muon::DYT))
1053  aMuon.embedDytMuon();
1054  }
1055 
1056  // embed best tracks (at the end, so unless forceEmbedBestTrack_ is true we can save some space not embedding them twice)
1057  if (embedBestTrack_)
1058  aMuon.embedMuonBestTrack(forceEmbedBestTrack_);
1059  if (embedTunePBestTrack_)
1060  aMuon.embedTunePMuonBestTrack(forceEmbedBestTrack_);
1061 
1062  // store the match to the generated final state muons
1063  if (addGenMatch_) {
1064  for (auto const& genMatch : genMatches) {
1065  reco::GenParticleRef genMuon = (*genMatch)[baseRef];
1066  aMuon.addGenParticleRef(genMuon);
1067  }
1068  if (embedGenMatch_)
1069  aMuon.embedGenParticle();
1070  }
1071  if (efficiencyLoader_.enabled()) {
1072  efficiencyLoader_.setEfficiencies(aMuon, muonRef);
1073  }
1074 
1075  for (size_t j = 0, nd = deposits.size(); j < nd; ++j) {
1076  if (useParticleFlow_) {
1077  if (deposits[j]->contains(baseRef.id())) {
1078  aMuon.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[baseRef]);
1079  } else if (deposits[j]->contains(muonRef.id())) {
1080  aMuon.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[muonRef]);
1081  } else {
1082  reco::CandidatePtr source = aMuon.pfCandidateRef()->sourceCandidatePtr(0);
1083  aMuon.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[source]);
1084  }
1085  } else {
1086  aMuon.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[muonRef]);
1087  }
1088  }
1089 
1090  for (size_t j = 0; j < isolationValues.size(); ++j) {
1091  if (useParticleFlow_) {
1092  if (isolationValues[j]->contains(baseRef.id())) {
1093  aMuon.setIsolation(isolationValueLabels_[j].first, (*isolationValues[j])[baseRef]);
1094  } else if (isolationValues[j]->contains(muonRef.id())) {
1095  aMuon.setIsolation(isolationValueLabels_[j].first, (*isolationValues[j])[muonRef]);
1096  } else {
1097  reco::CandidatePtr source = aMuon.pfCandidateRef()->sourceCandidatePtr(0);
1098  aMuon.setIsolation(isolationValueLabels_[j].first, (*isolationValues[j])[source]);
1099  }
1100  } else {
1101  aMuon.setIsolation(isolationValueLabels_[j].first, (*isolationValues[j])[muonRef]);
1102  }
1103  }
1104 
1105  if (resolutionLoader_.enabled()) {
1106  resolutionLoader_.setResolutions(aMuon);
1107  }
1108 }
1109 
1110 void PATMuonProducer::setMuonMiniIso(Muon& aMuon, const PackedCandidateCollection* pc) {
1111  pat::PFIsolation miniiso = pat::getMiniPFIsolation(pc,
1112  aMuon.polarP4(),
1113  miniIsoParams_[0],
1114  miniIsoParams_[1],
1115  miniIsoParams_[2],
1116  miniIsoParams_[3],
1117  miniIsoParams_[4],
1118  miniIsoParams_[5],
1119  miniIsoParams_[6],
1120  miniIsoParams_[7],
1121  miniIsoParams_[8]);
1122  aMuon.setMiniPFIsolation(miniiso);
1123 }
1124 
1125 double PATMuonProducer::getRelMiniIsoPUCorrected(const pat::Muon& muon, double rho, const std::vector<double>& area) {
1126  double mindr(miniIsoParams_[0]);
1127  double maxdr(miniIsoParams_[1]);
1128  double kt_scale(miniIsoParams_[2]);
1129  double drcut = pat::miniIsoDr(muon.polarP4(), mindr, maxdr, kt_scale);
1130  return pat::muonRelMiniIsoPUCorrected(muon.miniPFIsolation(), muon.polarP4(), drcut, rho, area);
1131 }
1132 
1133 double PATMuonProducer::puppiCombinedIsolation(const pat::Muon& muon, const pat::PackedCandidateCollection* pc) {
1134  constexpr double dR_threshold = 0.4;
1135  constexpr double dR2_threshold = dR_threshold * dR_threshold;
1136  constexpr double mix_fraction = 0.5;
1137  enum particleType { CH = 0, NH = 1, PH = 2, OTHER = 100000 };
1138  double val_PuppiWithLep = 0.0;
1139  double val_PuppiWithoutLep = 0.0;
1140 
1141  for (const auto& cand : *pc) { //pat::pat::PackedCandidate loop start
1142 
1143  const particleType pType = isChargedHadron(cand.pdgId()) ? CH
1144  : isNeutralHadron(cand.pdgId()) ? NH
1145  : isPhoton(cand.pdgId()) ? PH
1146  : OTHER;
1147  if (pType == OTHER) {
1148  if (cand.pdgId() != 1 && cand.pdgId() != 2 && abs(cand.pdgId()) != 11 && abs(cand.pdgId()) != 13) {
1149  LogTrace("PATMuonProducer") << "candidate with PDGID = " << cand.pdgId()
1150  << " is not CH/NH/PH/e/mu or 1/2 (and this is removed from isolation calculation)"
1151  << std::endl;
1152  }
1153  continue;
1154  }
1155  double d_eta = std::abs(cand.eta() - muon.eta());
1156  if (d_eta > dR_threshold)
1157  continue;
1158 
1159  double d_phi = std::abs(reco::deltaPhi(cand.phi(), muon.phi()));
1160  if (d_phi > dR_threshold)
1161  continue;
1162 
1163  double dR2 = reco::deltaR2(cand, muon);
1164  if (dR2 > dR2_threshold)
1165  continue;
1166  if (pType == CH && dR2 < 0.0001 * 0.0001)
1167  continue;
1168  if (pType == NH && dR2 < 0.01 * 0.01)
1169  continue;
1170  if (pType == PH && dR2 < 0.01 * 0.01)
1171  continue;
1172  val_PuppiWithLep += cand.pt() * cand.puppiWeight();
1173  val_PuppiWithoutLep += cand.pt() * cand.puppiWeightNoLep();
1174 
1175  } //pat::pat::PackedCandidate loop end
1176 
1177  double reliso_Puppi_withLep = val_PuppiWithLep / muon.pt();
1178  double reliso_Puppi_withoutlep = val_PuppiWithoutLep / muon.pt();
1179  double reliso_Puppi_combined = mix_fraction * reliso_Puppi_withLep + (1.0 - mix_fraction) * reliso_Puppi_withoutlep;
1180  return reliso_Puppi_combined;
1181 }
1182 
1183 bool PATMuonProducer::isNeutralHadron(long pdgid) { return std::abs(pdgid) == 130; }
1184 
1185 bool PATMuonProducer::isChargedHadron(long pdgid) { return std::abs(pdgid) == 211; }
1186 
1187 bool PATMuonProducer::isPhoton(long pdgid) { return pdgid == 22; }
1188 
1189 // ParameterSet description for module
1190 void PATMuonProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
1191  edm::ParameterSetDescription iDesc;
1192  iDesc.setComment("PAT muon producer module");
1193 
1194  // input source
1195  iDesc.add<edm::InputTag>("muonSource", edm::InputTag("no default"))->setComment("input collection");
1196 
1197  // embedding
1198  iDesc.add<bool>("embedMuonBestTrack", true)->setComment("embed muon best track (global pflow)");
1199  iDesc.add<bool>("embedTunePMuonBestTrack", true)->setComment("embed muon best track (muon only)");
1200  iDesc.add<bool>("forceBestTrackEmbedding", true)
1201  ->setComment(
1202  "force embedding separately the best tracks even if they're already embedded e.g. as tracker or global "
1203  "tracks");
1204  iDesc.add<bool>("embedTrack", true)->setComment("embed external track");
1205  iDesc.add<bool>("embedStandAloneMuon", true)->setComment("embed external stand-alone muon");
1206  iDesc.add<bool>("embedCombinedMuon", false)->setComment("embed external combined muon");
1207  iDesc.add<bool>("embedPickyMuon", false)->setComment("embed external picky track");
1208  iDesc.add<bool>("embedTpfmsMuon", false)->setComment("embed external tpfms track");
1209  iDesc.add<bool>("embedDytMuon", false)->setComment("embed external dyt track ");
1210 
1211  // embedding of MET muon corrections
1212  iDesc.add<bool>("embedCaloMETMuonCorrs", true)->setComment("whether to add MET muon correction for caloMET or not");
1213  iDesc.add<edm::InputTag>("caloMETMuonCorrs", edm::InputTag("muonMETValueMapProducer", "muCorrData"))
1214  ->setComment("source of MET muon corrections for caloMET");
1215  iDesc.add<bool>("embedTcMETMuonCorrs", true)->setComment("whether to add MET muon correction for tcMET or not");
1216  iDesc.add<edm::InputTag>("tcMETMuonCorrs", edm::InputTag("muonTCMETValueMapProducer", "muCorrData"))
1217  ->setComment("source of MET muon corrections for tcMET");
1218 
1219  // pf specific parameters
1220  iDesc.add<edm::InputTag>("pfMuonSource", edm::InputTag("pfMuons"))->setComment("particle flow input collection");
1221  iDesc.add<bool>("useParticleFlow", false)->setComment("whether to use particle flow or not");
1222  iDesc.add<bool>("embedPFCandidate", false)->setComment("embed external particle flow object");
1223  iDesc.add<bool>("embedPfEcalEnergy", true)->setComment("add ecal energy as reconstructed by PF");
1224 
1225  // inverse beta computation
1226  iDesc.add<bool>("addInverseBeta", true)->setComment("add combined inverse beta");
1227  iDesc.add<edm::InputTag>("sourceInverseBeta", edm::InputTag("muons", "combined"))
1228  ->setComment("source of inverse beta values");
1229 
1230  // MC matching configurables
1231  iDesc.add<bool>("addGenMatch", true)->setComment("add MC matching");
1232  iDesc.add<bool>("embedGenMatch", false)->setComment("embed MC matched MC information");
1233  std::vector<edm::InputTag> emptySourceVector;
1234  iDesc
1235  .addNode(edm::ParameterDescription<edm::InputTag>("genParticleMatch", edm::InputTag(), true) xor
1236  edm::ParameterDescription<std::vector<edm::InputTag>>("genParticleMatch", emptySourceVector, true))
1237  ->setComment("input with MC match information");
1238 
1239  // mini-iso
1240  iDesc.add<bool>("computeMiniIso", false)->setComment("whether or not to compute and store electron mini-isolation");
1241  iDesc.add<bool>("computePuppiCombinedIso", false)
1242  ->setComment("whether or not to compute and store puppi combined isolation");
1243 
1244  iDesc.add<edm::InputTag>("pfCandsForMiniIso", edm::InputTag("packedPFCandidates"))
1245  ->setComment("collection to use to compute mini-iso");
1246  iDesc.add<std::vector<double>>("miniIsoParams", std::vector<double>())
1247  ->setComment("mini-iso parameters to use for muons");
1248 
1249  iDesc.add<bool>("addTriggerMatching", false)->setComment("add L1 and HLT matching to offline muon");
1250 
1251  pat::helper::KinResolutionsLoader::fillDescription(iDesc);
1252 
1253  // IsoDeposit configurables
1254  edm::ParameterSetDescription isoDepositsPSet;
1255  isoDepositsPSet.addOptional<edm::InputTag>("tracker");
1256  isoDepositsPSet.addOptional<edm::InputTag>("ecal");
1257  isoDepositsPSet.addOptional<edm::InputTag>("hcal");
1258  isoDepositsPSet.addOptional<edm::InputTag>("particle");
1259  isoDepositsPSet.addOptional<edm::InputTag>("pfChargedHadrons");
1260  isoDepositsPSet.addOptional<edm::InputTag>("pfChargedAll");
1261  isoDepositsPSet.addOptional<edm::InputTag>("pfPUChargedHadrons");
1262  isoDepositsPSet.addOptional<edm::InputTag>("pfNeutralHadrons");
1263  isoDepositsPSet.addOptional<edm::InputTag>("pfPhotons");
1264  isoDepositsPSet.addOptional<std::vector<edm::InputTag>>("user");
1265  iDesc.addOptional("isoDeposits", isoDepositsPSet);
1266 
1267  // isolation values configurables
1268  edm::ParameterSetDescription isolationValuesPSet;
1269  isolationValuesPSet.addOptional<edm::InputTag>("tracker");
1270  isolationValuesPSet.addOptional<edm::InputTag>("ecal");
1271  isolationValuesPSet.addOptional<edm::InputTag>("hcal");
1272  isolationValuesPSet.addOptional<edm::InputTag>("particle");
1273  isolationValuesPSet.addOptional<edm::InputTag>("pfChargedHadrons");
1274  isolationValuesPSet.addOptional<edm::InputTag>("pfChargedAll");
1275  isolationValuesPSet.addOptional<edm::InputTag>("pfPUChargedHadrons");
1276  isolationValuesPSet.addOptional<edm::InputTag>("pfNeutralHadrons");
1277  isolationValuesPSet.addOptional<edm::InputTag>("pfPhotons");
1278  iDesc.addOptional("isolationValues", isolationValuesPSet);
1279 
1280  iDesc.ifValue(edm::ParameterDescription<bool>("addPuppiIsolation", false, true),
1281  true >> (edm::ParameterDescription<edm::InputTag>(
1282  "puppiIsolationChargedHadrons",
1283  edm::InputTag("muonPUPPIIsolation", "h+-DR030-ThresholdVeto000-ConeVeto000"),
1284  true) and
1285  edm::ParameterDescription<edm::InputTag>(
1286  "puppiIsolationNeutralHadrons",
1287  edm::InputTag("muonPUPPIIsolation", "h0-DR030-ThresholdVeto000-ConeVeto001"),
1288  true) and
1289  edm::ParameterDescription<edm::InputTag>(
1290  "puppiIsolationPhotons",
1291  edm::InputTag("muonPUPPIIsolation", "gamma-DR030-ThresholdVeto000-ConeVeto001"),
1292  true) and
1293  edm::ParameterDescription<edm::InputTag>(
1294  "puppiNoLeptonsIsolationChargedHadrons",
1295  edm::InputTag("muonPUPPINoLeptonsIsolation", "h+-DR030-ThresholdVeto000-ConeVeto000"),
1296  true) and
1297  edm::ParameterDescription<edm::InputTag>(
1298  "puppiNoLeptonsIsolationNeutralHadrons",
1299  edm::InputTag("muonPUPPINoLeptonsIsolation", "h0-DR030-ThresholdVeto000-ConeVeto001"),
1300  true) and
1301  edm::ParameterDescription<edm::InputTag>(
1302  "puppiNoLeptonsIsolationPhotons",
1303  edm::InputTag("muonPUPPINoLeptonsIsolation", "gamma-DR030-ThresholdVeto000-ConeVeto001"),
1304  true)) or
1305  false >> edm::EmptyGroupDescription());
1306 
1307  // Efficiency configurables
1308  edm::ParameterSetDescription efficienciesPSet;
1309  efficienciesPSet.setAllowAnything(); // TODO: the pat helper needs to implement a description.
1310  iDesc.add("efficiencies", efficienciesPSet);
1311  iDesc.add<bool>("addEfficiencies", false);
1312 
1313  // Check to see if the user wants to add user data
1314  edm::ParameterSetDescription userDataPSet;
1315  PATUserDataHelper<Muon>::fillDescription(userDataPSet);
1316  iDesc.addOptional("userData", userDataPSet);
1317 
1318  edm::ParameterSetDescription isolationPSet;
1319  isolationPSet.setAllowAnything(); // TODO: the pat helper needs to implement a description.
1320  iDesc.add("userIsolation", isolationPSet);
1321 
1322  iDesc.add<bool>("embedHighLevelSelection", true)->setComment("embed high level selection");
1323  edm::ParameterSetDescription highLevelPSet;
1324  highLevelPSet.setAllowAnything();
1325  iDesc.addNode(edm::ParameterDescription<edm::InputTag>("beamLineSrc", edm::InputTag(), true))
1326  ->setComment("input with high level selection");
1327  iDesc.addNode(edm::ParameterDescription<edm::InputTag>("pvSrc", edm::InputTag(), true))
1328  ->setComment("input with high level selection");
1329 
1330  //descriptions.add("PATMuonProducer", iDesc);
1331 }
1332 
1333 // embed various impact parameters with errors
1334 // embed high level selection
1335 void PATMuonProducer::embedHighLevel(pat::Muon& aMuon,
1336  reco::TrackRef track,
1337  reco::TransientTrack& tt,
1338  reco::Vertex& primaryVertex,
1339  bool primaryVertexIsValid,
1340  reco::BeamSpot& beamspot,
1341  bool beamspotIsValid) {
1342  // Correct to PV
1343 
1344  // PV2D
1345  aMuon.setDB(track->dxy(primaryVertex.position()),
1346  track->dxyError(primaryVertex.position(), primaryVertex.covariance()),
1347  pat::Muon::PV2D);
1348 
1349  // PV3D
1350  std::pair<bool, Measurement1D> result =
1351  IPTools::signedImpactParameter3D(tt, GlobalVector(track->px(), track->py(), track->pz()), primaryVertex);
1352  double d0_corr = result.second.value();
1353  double d0_err = primaryVertexIsValid ? result.second.error() : -1.0;
1354  aMuon.setDB(d0_corr, d0_err, pat::Muon::PV3D);
1355 
1356  // Correct to beam spot
1357 
1358  // BS2D
1359  aMuon.setDB(track->dxy(beamspot), track->dxyError(beamspot), pat::Muon::BS2D);
1360 
1361  // make a fake vertex out of beam spot
1362  reco::Vertex vBeamspot(beamspot.position(), beamspot.rotatedCovariance3D());
1363 
1364  // BS3D
1365  result = IPTools::signedImpactParameter3D(tt, GlobalVector(track->px(), track->py(), track->pz()), vBeamspot);
1366  d0_corr = result.second.value();
1367  d0_err = beamspotIsValid ? result.second.error() : -1.0;
1368  aMuon.setDB(d0_corr, d0_err, pat::Muon::BS3D);
1369 
1370  // PVDZ
1371  aMuon.setDB(
1372  track->dz(primaryVertex.position()), std::hypot(track->dzError(), primaryVertex.zError()), pat::Muon::PVDZ);
1373 }
1374 
1375 #include "FWCore/Framework/interface/MakerMacros.h"
1376 
1377 DEFINE_FWK_MODULE(PATMuonProducer);
pat::PATMuonProducer::embedTpfmsMuon_
bool embedTpfmsMuon_
embed track from tpfms muon fit into the muon
Definition: PATMuonProducer.cc:185
pat::PATMuonProducer::PUPPIIsolation_charged_hadrons_
edm::EDGetTokenT< edm::ValueMap< float > > PUPPIIsolation_charged_hadrons_
Definition: PATMuonProducer.cc:229
pat::PATMuonProducer::useUserData_
bool useUserData_
add user data to the muon (this will be data members of th muon even w/o embedding) ...
Definition: PATMuonProducer.cc:223
pat::PATMuonProducer::readIsolationLabels
void readIsolationLabels(const edm::ParameterSet &iConfig, const char *psetName, IsolationLabels &labels, std::vector< edm::EDGetTokenT< edm::ValueMap< T >>> &tokens)
Definition: PATMuonProducer.cc:274
reco::deltaPhi
constexpr double deltaPhi(double phi1, double phi2)
Definition: deltaPhi.h:26
pat::PATMuonProducer::PUPPIIsolation_photons_
edm::EDGetTokenT< edm::ValueMap< float > > PUPPIIsolation_photons_
Definition: PATMuonProducer.cc:231
pat::helper::EfficiencyLoader::enabled
bool enabled() const
&#39;true&#39; if this there is at least one efficiency configured
Definition: EfficiencyLoader.h:25
edm::ParameterDescriptionNode::setComment
void setComment(std::string const &value)
Definition: ParameterDescriptionNode.cc:109
edm::ParameterSetDescription::ifValue
ParameterDescriptionNode * ifValue(ParameterDescription< T > const &switchParameter, std::unique_ptr< ParameterDescriptionCases< T >> cases)
Definition: ParameterSetDescription.h:220
pat::helper::EfficiencyLoader::newEvent
void newEvent(const edm::Event &event)
To be called for each new event, reads in the ValueMaps for efficiencies.
Definition: EfficiencyLoader.cc:21
muonProducer_cfi.caloMETMuonCorrs
caloMETMuonCorrs
Definition: muonProducer_cfi.py:48
pat::PATMuonProducer::addPuppiIsolation_
bool addPuppiIsolation_
add puppi isolation
Definition: PATMuonProducer.cc:227
jetUpdater_cfi.sort
sort
Definition: jetUpdater_cfi.py:30
ProducerED_cfi.InputTag
InputTag
Definition: ProducerED_cfi.py:5
deDxTools::esConsumes
ESGetTokenH3DDVariant esConsumes(std::string const &Record, edm::ConsumesCollector &)
Definition: DeDxTools.cc:283
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:307
pat::Muon::embedDytMuon
void embedDytMuon()
embed reference to the above dyt Track
Matriplex::hypot
MPlex< T, D1, D2, N > hypot(const MPlex< T, D1, D2, N > &a, const MPlex< T, D1, D2, N > &b)
Definition: Matriplex.h:417
edm::ParameterSetDescription::addOptional
ParameterDescriptionBase * addOptional(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:105
pat::Muon::embedTpfmsMuon
void embedTpfmsMuon()
embed reference to the above tpfms Track
mps_fire.i
i
Definition: mps_fire.py:429
pat::PATMuonProducer::tcMETMuonCorrsToken_
edm::EDGetTokenT< edm::ValueMap< reco::MuonMETCorrectionData > > tcMETMuonCorrsToken_
source of tcMET muon corrections
Definition: PATMuonProducer.cc:181
pat::Lepton::setIsolation
void setIsolation(IsolationKeys key, float value)
Definition: Lepton.h:115
pat::PATMuonProducer::embedTcMETMuonCorrs_
bool embedTcMETMuonCorrs_
embed muon MET correction info for tcMET into the muon
Definition: PATMuonProducer.cc:179
pat::PATMuonProducer
class definition
Definition: PATMuonProducer.cc:76
pat::Muon::embedTcMETMuonCorrs
void embedTcMETMuonCorrs(const reco::MuonMETCorrectionData &t)
pat::PATMuonProducer::pvToken_
edm::EDGetTokenT< std::vector< reco::Vertex > > pvToken_
input source of the primary vertex
Definition: PATMuonProducer.cc:213
edm::contains
bool contains(EventRange const &lh, EventID const &rh)
Definition: EventRange.cc:37
edm::EventSetup::getData
T const & getData(const ESGetToken< T, R > &iToken) const noexcept(false)
Definition: EventSetup.h:119
pat::helper::MultiIsolator::enabled
bool enabled() const
True if it has a non null configuration.
Definition: MultiIsolator.h:55
dqm::qstatus::OTHER
static const int OTHER
Definition: MonitorElement.h:50
L1TEGammaOffline_cfi.triggerNames
triggerNames
Definition: L1TEGammaOffline_cfi.py:40
MTVHistoProducerAlgoForTrackerBlock_cfi.mindr
mindr
Definition: MTVHistoProducerAlgoForTrackerBlock_cfi.py:79
pat::PATMuonProducer::muonTimeExtraToken_
edm::EDGetTokenT< edm::ValueMap< reco::MuonTimeExtra > > muonTimeExtraToken_
input tag for reading inverse beta
Definition: PATMuonProducer.cc:191
mps_fire.result
result
Definition: mps_fire.py:311
pat::PATMuonProducer::PUPPINoLeptonsIsolation_photons_
edm::EDGetTokenT< edm::ValueMap< float > > PUPPINoLeptonsIsolation_photons_
Definition: PATMuonProducer.cc:235
pat::Muon::embedCombinedMuon
void embedCombinedMuon()
set reference to Track reconstructed in both tracked and muon detector (reimplemented from reco::Muon...
pat::PATMuonProducer::rho_
edm::EDGetTokenT< double > rho_
Definition: PATMuonProducer.cc:244
pat::PATMuonProducer::muonToken_
edm::EDGetTokenT< edm::View< reco::Muon > > muonToken_
input source
Definition: PATMuonProducer.cc:150
pat::Muon::embedTunePMuonBestTrack
void embedTunePMuonBestTrack(bool force=false)
pat::PATMuonProducer::addEfficiencies_
bool addEfficiencies_
add efficiencies to the muon (this will be data members of th muon even w/o embedding) ...
Definition: PATMuonProducer.cc:221
pat::PATMuonProducer::caloMETMuonCorrsToken_
edm::EDGetTokenT< edm::ValueMap< reco::MuonMETCorrectionData > > caloMETMuonCorrsToken_
source of caloMET muon corrections
Definition: PATMuonProducer.cc:177
heavyIonCSV_trainingSettings.idx
idx
Definition: heavyIonCSV_trainingSettings.py:5
pat::helper::EfficiencyLoader::setEfficiencies
void setEfficiencies(pat::PATObject< T > &obj, const R &originalRef) const
Sets the efficiencies for this object, using the reference to the original objects.
Definition: EfficiencyLoader.h:41
trigger::TriggerL1Mu
enum start value shifted to 81 so as to avoid clashes with PDG codes
Definition: TriggerTypeDefs.h:30
edm::ParameterSetDescription::setAllowAnything
void setAllowAnything()
allow any parameter label/value pairs
Definition: ParameterSetDescription.cc:37
hemisphereProducer_cfi.patMuons
patMuons
Definition: hemisphereProducer_cfi.py:6
pat::Muon::setSimFlavour
void setSimFlavour(int f)
Definition: Muon.h:321
reco::Muon::isAValidMuonTrack
bool isAValidMuonTrack(const MuonTrackType &type) const
pat::PATMuonProducer::embedCaloMETMuonCorrs_
bool embedCaloMETMuonCorrs_
embed muon MET correction info for caloMET into the muon
Definition: PATMuonProducer.cc:175
pat::PATMuonProducer::isChargedHadron
bool isChargedHadron(long pdgid)
Definition: PATMuonProducer.cc:1185
edm::ParameterSet::exists
bool exists(std::string const &parameterName) const
checks if a parameter exists
Definition: ParameterSet.cc:730
pat::PATMuonProducer::~PATMuonProducer
~PATMuonProducer() override
default destructur
Definition: PATMuonProducer.cc:485
pat::PATMuonProducer::simInfo_
edm::EDGetTokenT< edm::ValueMap< reco::MuonSimInfo > > simInfo_
MC info.
Definition: PATMuonProducer.cc:257
edm::Handle::product
T const * product() const
Definition: Handle.h:70
pat::Muon::embedMuonBestTrack
void embedMuonBestTrack(bool force=false)
pat::PackedCandidateCollection
std::vector< pat::PackedCandidate > PackedCandidateCollection
Definition: PackedCandidate.h:1166
pat::Muon::setIsolationPUPPINoLeptons
void setIsolationPUPPINoLeptons(float chargedhadrons, float neutralhadrons, float photons)
sets PUPPINoLeptons isolations
Definition: Muon.h:207
pat::PATMuonProducer::setMuonMiniIso
void setMuonMiniIso(pat::Muon &aMuon, const pat::PackedCandidateCollection *pc)
Definition: PATMuonProducer.cc:1110
pat::PATMuonProducer::PATMuonProducer
PATMuonProducer(const edm::ParameterSet &iConfig, PATMuonHeavyObjectCache const *)
default constructir
Definition: PATMuonProducer.cc:341
SiPixelRawToDigiRegional_cfi.deltaPhi
deltaPhi
Definition: SiPixelRawToDigiRegional_cfi.py:9
pat::PATMuonProducer::addTriggerMatching_
bool addTriggerMatching_
Trigger.
Definition: PATMuonProducer.cc:260
pat::Muon::setSimBX
void setSimBX(int bx)
Definition: Muon.h:325
PbPb_ZMuSkimMuonDPG_cff.deltaR
deltaR
Definition: PbPb_ZMuSkimMuonDPG_cff.py:63
pwdgSkimBPark_cfi.beamSpot
beamSpot
Definition: pwdgSkimBPark_cfi.py:5
edm::ParameterSetDescription::addNode
ParameterDescriptionNode * addNode(ParameterDescriptionNode const &node)
Definition: ParameterSetDescription.cc:41
pat::PATMuonProducer::embedBestTrack_
bool embedBestTrack_
embed the track from best muon measurement (global pflow)
Definition: PATMuonProducer.cc:163
L1DTConfigBti_cff.CH
CH
LTS and SET for low trigger suppression.
Definition: L1DTConfigBti_cff.py:38
pat::PATMuonProducer::mvaL1Corrector_
edm::EDGetTokenT< reco::JetCorrector > mvaL1Corrector_
Definition: PATMuonProducer.cc:242
IPTools::signedImpactParameter3D
std::pair< bool, Measurement1D > signedImpactParameter3D(const reco::TransientTrack &track, const GlobalVector &direction, const reco::Vertex &vertex)
Definition: IPTools.cc:81
edm::Ref::isNonnull
bool isNonnull() const
Checks for non-null.
Definition: Ref.h:238
pat::PATMuonProducer::transientTrackBuilderToken_
const edm::ESGetToken< TransientTrackBuilder, TransientTrackRecord > transientTrackBuilderToken_
Definition: PATMuonProducer.cc:266
beam_dqm_sourceclient-live_cfg.mva
mva
Definition: beam_dqm_sourceclient-live_cfg.py:143
pat::PATMuonProducer::addResolutions_
bool addResolutions_
add resolutions to the muon (this will be data members of th muon even w/o embedding) ...
Definition: PATMuonProducer.cc:199
EgammaValidation_cff.pdgid
pdgid
Definition: EgammaValidation_cff.py:29
triggerMatchMonitor_cfi.triggerObjects
triggerObjects
Definition: triggerMatchMonitor_cfi.py:15
pat::helper::KinResolutionsLoader::setResolutions
void setResolutions(pat::PATObject< T > &obj) const
Sets the efficiencies for this object, using the reference to the original objects.
Definition: KinResolutionsLoader.h:52
pat::IsolationKeys
IsolationKeys
Enum defining isolation keys.
Definition: Isolation.h:9
pat::PATMuonProducer::PUPPINoLeptonsIsolation_charged_hadrons_
edm::EDGetTokenT< edm::ValueMap< float > > PUPPINoLeptonsIsolation_charged_hadrons_
Definition: PATMuonProducer.cc:233
pat::PATMuonProducer::miniIsoParams_
std::vector< double > miniIsoParams_
Definition: PATMuonProducer.cc:157
pat::Muon::setSimPhi
void setSimPhi(float phi)
Definition: Muon.h:331
edm::LogError
Log< level::Error, false > LogError
Definition: MessageLogger.h:129
edm::vector_transform
auto vector_transform(std::vector< InputType > const &input, Function predicate) -> std::vector< typename std::remove_cv< typename std::remove_reference< decltype(predicate(input.front()))>::type >::type >
Definition: transform.h:11
reco::PFCandidateConstIterator
PFCandidateCollection::const_iterator PFCandidateConstIterator
iterator
Definition: PFCandidateFwd.h:18
displacedMuonProducer_cff.mvaL1Corrector
mvaL1Corrector
Definition: displacedMuonProducer_cff.py:67
pat::Muon::setSimProdRho
void setSimProdRho(float rho)
Definition: Muon.h:327
pat::Muon::setSimHeaviestMotherFlavour
void setSimHeaviestMotherFlavour(int id)
Definition: Muon.h:322
muon::makeSelectorBitset
reco::Muon::Selector makeSelectorBitset(reco::Muon const &muon, reco::Vertex const *vertex=nullptr, bool run2016_hip_mitigation=false)
Definition: MuonSelectors.cc:1030
cms::cuda::assert
assert(be >=bs)
pat::Muon::setPFCandidateRef
void setPFCandidateRef(const reco::PFCandidateRef &ref)
add a reference to the source IsolatedPFCandidate
Definition: Muon.h:141
pat::PATMuonProducer::embedHighLevel
void embedHighLevel(pat::Muon &aMuon, reco::TrackRef track, reco::TransientTrack &tt, reco::Vertex &primaryVertex, bool primaryVertexIsValid, reco::BeamSpot &beamspot, bool beamspotIsValid)
Definition: PATMuonProducer.cc:1335
cutBasedMuonId_MuonPOG_V0_cff.globalTrack
globalTrack
Definition: cutBasedMuonId_MuonPOG_V0_cff.py:135
pat::PATMuonProducer::effectiveAreaVec_
std::vector< double > effectiveAreaVec_
Definition: PATMuonProducer.cc:156
names
const std::string names[nVars_]
Definition: PhotonIDValueMapProducer.cc:124
pat::PATMuonProducer::PUPPINoLeptonsIsolation_neutral_hadrons_
edm::EDGetTokenT< edm::ValueMap< float > > PUPPINoLeptonsIsolation_neutral_hadrons_
Definition: PATMuonProducer.cc:234
pat::Muon::setSimType
void setSimType(reco::MuonSimType type)
Definition: Muon.h:319
pat::Muon::embedStandAloneMuon
void embedStandAloneMuon()
set reference to Track reconstructed in the muon detector only (reimplemented from reco::Muon) ...
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:242
pat::PATMuonProducer::mvaBTagCollectionTag_
edm::EDGetTokenT< reco::JetTagCollection > mvaBTagCollectionTag_
Definition: PATMuonProducer.cc:241
pat::PATMuonProducer::pfMuonToken_
edm::EDGetTokenT< reco::PFCandidateCollection > pfMuonToken_
input source pfCandidates that will be to be transformed into pat::Muons, when using PF2PAT ...
Definition: PATMuonProducer.cc:205
pat::Muon::setIsolationPUPPI
void setIsolationPUPPI(float chargedhadrons, float neutralhadrons, float photons)
sets PUPPI isolations
Definition: Muon.h:201
edm::RefToBase::id
ProductID id() const
Definition: RefToBase.h:216
pat::PATMuonProducer::isolator_
pat::helper::MultiIsolator isolator_
Definition: PATMuonProducer.cc:248
pat::PATMuonProducer::isoDepositTokens_
std::vector< edm::EDGetTokenT< edm::ValueMap< IsoDeposit > > > isoDepositTokens_
Definition: PATMuonProducer.cc:216
pat::helper::MultiIsolator::fill
void fill(const edm::View< T > &coll, int idx, IsolationValuePairs &isolations) const
Definition: MultiIsolator.h:84
pat::Lepton::setIsoDeposit
void setIsoDeposit(IsolationKeys key, const IsoDeposit &dep)
Sets the IsoDeposit associated with some key; if it is already existent, it is overwritten.
Definition: Lepton.h:191
pat
Definition: HeavyIon.h:7
pat::Muon::embedTrack
void embedTrack()
set reference to Track reconstructed in the tracker only (reimplemented from reco::Muon) ...
pat::PATUserDataHelper::fillDescription
static void fillDescription(edm::ParameterSetDescription &iDesc)
Definition: PATUserDataHelper.h:134
pat::PATMuonHeavyObjectCache::muonMvaIDEstimator
pat::MuonMvaIDEstimator const & muonMvaIDEstimator() const
Definition: PATMuonProducer.cc:62
TransientTrackBuilder::build
reco::TransientTrack build(const reco::Track *p) const
Definition: TransientTrackBuilder.cc:20
pat::PATMuonProducer::IsolationLabels
std::vector< IsolationLabel > IsolationLabels
Definition: PATMuonProducer.cc:101
pat::PATMuonProducer::beamLineToken_
edm::EDGetTokenT< reco::BeamSpot > beamLineToken_
input source of the primary vertex/beamspot
Definition: PATMuonProducer.cc:211
pat::PATMuonProducer::addInverseBeta_
bool addInverseBeta_
add combined inverse beta measurement into the muon
Definition: PATMuonProducer.cc:189
pat::PATMuonProducer::useParticleFlow_
bool useParticleFlow_
switch to use particle flow (PF2PAT) or not
Definition: PATMuonProducer.cc:203
pat::PATMuonProducer::userDataHelper_
pat::PATUserDataHelper< pat::Muon > userDataHelper_
helper class to add userData to the muon
Definition: PATMuonProducer.cc:254
pat::PATMuonProducer::IsoDepositMaps
std::vector< edm::Handle< edm::ValueMap< IsoDeposit > > > IsoDepositMaps
Definition: PATMuonProducer.cc:98
label
char const * label
Definition: PFTauDecayModeTools.cc:11
pat::PATMuonProducer::embedStandAloneMuon_
bool embedStandAloneMuon_
embed track from muon system into the muon
Definition: PATMuonProducer.cc:171
edm::ParameterSetDescription::setComment
void setComment(std::string const &value)
Definition: ParameterSetDescription.cc:33
pat::PATMuonProducer::triggerResults_
edm::EDGetTokenT< edm::TriggerResults > triggerResults_
Definition: PATMuonProducer.cc:262
iEvent
int iEvent
Definition: GenABIO.cc:224
tt
Definition: TTTypes.h:54
pat::helper::MultiIsolator::beginEvent
void beginEvent(const edm::Event &event, const edm::EventSetup &eventSetup)
Definition: MultiIsolator.cc:79
pat::PATMuonProducer::embedTrack_
bool embedTrack_
embed the track from inner tracker into the muon
Definition: PATMuonProducer.cc:169
pat::Muon::setDB
void setDB(double dB, double edB, IPTYPE type=PV2D)
Definition: Muon.h:247
pat::PATMuonProducer::addGenMatch_
bool addGenMatch_
add generator match information
Definition: PATMuonProducer.cc:193
pat::PATMuonHeavyObjectCache::PATMuonHeavyObjectCache
PATMuonHeavyObjectCache(const edm::ParameterSet &)
Definition: PATMuonProducer.cc:324
pat::PATMuonProducer::fillDescriptions
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
description of config file parameters
Definition: PATMuonProducer.cc:1190
Muon
Definition: Muon.py:1
pat::PATMuonProducer::fillL1TriggerInfo
void fillL1TriggerInfo(pat::Muon &muon, edm::Handle< std::vector< pat::TriggerObjectStandAlone >> &triggerObjects, const edm::TriggerNames &names, const edm::ESHandle< GlobalTrackingGeometry > &geometry)
Definition: PATMuonProducer.cc:498
pat::muonRelMiniIsoPUCorrected
double muonRelMiniIsoPUCorrected(const PFIsolation &iso, const reco::Candidate::PolarLorentzVector &p4, double dr, double rho, const std::vector< double > &area)
Definition: MiniIsolation.cc:59
pat::PATMuonProducer::geometryToken_
const edm::ESGetToken< GlobalTrackingGeometry, GlobalTrackingGeometryRecord > geometryToken_
Definition: PATMuonProducer.cc:265
pat::PATMuonProducer::embedPfEcalEnergy_
bool embedPfEcalEnergy_
add ecal PF energy
Definition: PATMuonProducer.cc:225
makeGlobalPositionRcd_cfg.tag
tag
Definition: makeGlobalPositionRcd_cfg.py:6
pat::PATObject::embedGenParticle
void embedGenParticle()
Definition: PATObject.h:768
pat::helper::KinResolutionsLoader::newEvent
void newEvent(const edm::Event &event, const edm::EventSetup &setup)
To be called for each new event, reads in the EventSetup object.
Definition: KinResolutionsLoader.cc:27
pat::Muon::embedPFCandidate
void embedPFCandidate()
embed the IsolatedPFCandidate pointed to by pfCandidateRef_
or
The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e< void, edm::EventID const &, edm::Timestamp const & > We also list in braces which AR_WATCH_USING_METHOD_ is used for those or
Definition: Activities.doc:12
edm::Ref::isAvailable
bool isAvailable() const
Definition: Ref.h:541
pat::helper::KinResolutionsLoader::enabled
bool enabled() const
&#39;true&#39; if this there is at least one efficiency configured
Definition: KinResolutionsLoader.h:30
reco::LeafCandidate::polarP4
const PolarLorentzVector & polarP4() const final
four-momentum Lorentz vector
Definition: LeafCandidate.h:116
pat::PATMuonProducer::produce
void produce(edm::Event &iEvent, const edm::EventSetup &iSetup) override
everything that needs to be done during the event loop
Definition: PATMuonProducer.cc:576
CandIsolatorFromDeposits_cfi.deposits
deposits
Definition: CandIsolatorFromDeposits_cfi.py:4
pat::PATMuonProducer::computeMuonIDMVA_
bool computeMuonIDMVA_
standard muon selectors
Definition: PATMuonProducer.cc:237
MetAnalyzer.pv
def pv(vc)
Definition: MetAnalyzer.py:7
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
pat::PATMuonProducer::relMiniIsoPUCorrected
double relMiniIsoPUCorrected(const pat::Muon &aMuon, double rho)
pat::PATMuonProducer::pcToken_
edm::EDGetTokenT< pat::PackedCandidateCollection > pcToken_
Definition: PATMuonProducer.cc:153
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
HLT_2023v12_cff.muon
muon
Definition: HLT_2023v12_cff.py:9625
pat::PATMuonProducer::IsolationLabel
std::pair< pat::IsolationKeys, edm::InputTag > IsolationLabel
Definition: PATMuonProducer.cc:100
pat::PATMuonProducer::globalEndJob
static void globalEndJob(PATMuonHeavyObjectCache *)
Definition: PATMuonProducer.cc:87
triggerResults
static std::string const triggerResults
Definition: EdmProvDump.cc:47
MTVHistoProducerAlgoForTrackerBlock_cfi.maxdr
maxdr
Definition: MTVHistoProducerAlgoForTrackerBlock_cfi.py:80
custom_jme_cff.area
area
Definition: custom_jme_cff.py:135
edm::ParameterSetDescription::add
ParameterDescriptionBase * add(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:95
pat::PATMuonProducer::fillMuon
void fillMuon(Muon &aMuon, const MuonBaseRef &muonRef, const reco::CandidateBaseRef &baseRef, const GenAssociations &genMatches, const IsoDepositMaps &deposits, const IsolationValueMaps &isolationValues) const
common muon filling, for both the standard and PF2PAT case
Definition: PATMuonProducer.cc:1026
pat::PATMuonProducer::puppiCombinedIsolation
double puppiCombinedIsolation(const pat::Muon &muon, const pat::PackedCandidateCollection *pc)
Definition: PATMuonProducer.cc:1133
reco::PFCandidate::ecalEnergy
double ecalEnergy() const
return corrected Ecal energy
Definition: PFCandidate.h:221
edm::EventSetup::getHandle
ESHandle< T > getHandle(const ESGetToken< T, R > &iToken) const
Definition: EventSetup.h:130
reco::PFCandidate::muonRef
reco::MuonRef muonRef() const
Definition: PFCandidate.cc:450
hcalRecHitTable_cff.detId
detId
Definition: hcalRecHitTable_cff.py:12
pat::Muon::readTimeExtra
void readTimeExtra(const reco::MuonTimeExtra &t)
pat::PATMuonProducer::hltCollectionFilters_
std::vector< std::string > hltCollectionFilters_
Definition: PATMuonProducer.cc:263
pat::PATUserDataHelper::add
void add(ObjectType &patObject, edm::Event const &iEvent, edm::EventSetup const &iSetup)
Definition: PATUserDataHelper.h:113
pat::miniIsoDr
float miniIsoDr(const reco::Candidate::PolarLorentzVector &p4, float mindr, float maxdr, float kt_scale)
Definition: MiniIsolation.cc:15
GeomDet::toGlobal
GlobalPoint toGlobal(const Local2DPoint &lp) const
Conversion to the global R.F. from the R.F. of the GeomDet.
Definition: GeomDet.h:49
pat::PATMuonProducer::fillHltTriggerInfo
void fillHltTriggerInfo(pat::Muon &muon, edm::Handle< std::vector< pat::TriggerObjectStandAlone >> &triggerObjects, const edm::TriggerNames &names, const std::vector< std::string > &collection_names)
Definition: PATMuonProducer.cc:550
pat::PATMuonProducer::initializeGlobalCache
static std::unique_ptr< PATMuonHeavyObjectCache > initializeGlobalCache(const edm::ParameterSet &iConfig)
Definition: PATMuonProducer.cc:83
PbPb_ZMuSkimMuonDPG_cff.particleType
particleType
Definition: PbPb_ZMuSkimMuonDPG_cff.py:27
photons_cff.mvaID
mvaID
Definition: photons_cff.py:127
DetId
Definition: DetId.h:17
pat::helper::MultiIsolator::IsolationValuePairs
std::vector< std::pair< pat::IsolationKeys, float > > IsolationValuePairs
Definition: MultiIsolator.h:17
pat::Muon::initSimInfo
void initSimInfo(void)
reco::deltaR2
constexpr auto deltaR2(const T1 &t1, const T2 &t2) -> decltype(t1.eta())
Definition: deltaR.h:16
pat::PATObject::addGenParticleRef
void addGenParticleRef(const reco::GenParticleRef &ref)
Definition: PATObject.h:751
pat::Muon::setPfEcalEnergy
void setPfEcalEnergy(float pfEcalEnergy)
Definition: Muon.h:277
pat::PATMuonProducer::embedTunePBestTrack_
bool embedTunePBestTrack_
embed the track from best muon measurement (muon only)
Definition: PATMuonProducer.cc:165
pat::helper::KinResolutionsLoader::fillDescription
static void fillDescription(edm::ParameterSetDescription &iDesc)
Method for documentation and validation of PSet.
Definition: KinResolutionsLoader.cc:33
pat::PATMuonProducer::getRelMiniIsoPUCorrected
double getRelMiniIsoPUCorrected(const pat::Muon &muon, double rho, const std::vector< double > &area)
Definition: PATMuonProducer.cc:1125
pat::Muon::setSimMotherPdgId
void setSimMotherPdgId(int id)
Definition: Muon.h:324
pat::PATObject::addTriggerObjectMatch
void addTriggerObjectMatch(const TriggerObjectStandAlone &trigObj)
add a trigger match
Definition: PATObject.h:238
pat::Muon::setExtSimType
void setExtSimType(reco::ExtendedMuonSimType type)
Definition: Muon.h:320
reco::Muon::matches
std::vector< MuonChamberMatch > & matches()
get muon matching information
Definition: Muon.h:145
pat::PATMuonHeavyObjectCache::muonMvaIDEstimator_
std::unique_ptr< const pat::MuonMvaIDEstimator > muonMvaIDEstimator_
Definition: PATMuonProducer.cc:67
pat::Lepton::setMiniPFIsolation
void setMiniPFIsolation(PFIsolation const &iso)
Definition: Lepton.h:217
pat::PATMuonHeavyObjectCache::softMuonMvaEstimator_
std::unique_ptr< const pat::SoftMuonMvaEstimator > softMuonMvaEstimator_
Definition: PATMuonProducer.cc:68
displacedMuonProducer_cff.mvaDrMax
mvaDrMax
Definition: displacedMuonProducer_cff.py:65
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:70
pat::PATMuonProducer::GenAssociations
std::vector< edm::Handle< edm::Association< reco::GenParticleCollection > > > GenAssociations
Definition: PATMuonProducer.cc:97
pat::PATMuonProducer::mvaIDtightCut_
double mvaIDtightCut_
working points of the muon MVA ID
Definition: PATMuonProducer.cc:160
pat::PATMuonProducer::mvaL1L2L3ResCorrector_
edm::EDGetTokenT< reco::JetCorrector > mvaL1L2L3ResCorrector_
Definition: PATMuonProducer.cc:243
pat::Muon::setSimProdZ
void setSimProdZ(float z)
Definition: Muon.h:328
reco::PFCandidate
Particle reconstructed by the particle flow algorithm.
Definition: PFCandidate.h:41
pat::PATMuonProducer::IsolationValueMaps
std::vector< edm::Handle< edm::ValueMap< double > > > IsolationValueMaps
Definition: PATMuonProducer.cc:99
pat::PATMuonProducer::efficiencyLoader_
pat::helper::EfficiencyLoader efficiencyLoader_
helper class to add efficiencies to the muon
Definition: PATMuonProducer.cc:252
edm
HLT enums.
Definition: AlignableModifier.h:19
pat::PATMuonProducer::embedPickyMuon_
bool embedPickyMuon_
embed track from picky muon fit into the muon
Definition: PATMuonProducer.cc:183
pat::Muon::setNormChi2
void setNormChi2(double normChi2)
Definition: Muon.h:262
edm::View::const_iterator
boost::indirect_iterator< typename seq_t::const_iterator > const_iterator
Definition: View.h:86
pat::PATMuonProducer::embedDytMuon_
bool embedDytMuon_
embed track from DYT muon fit into the muon
Definition: PATMuonProducer.cc:187
pat::Muon::embedCaloMETMuonCorrs
void embedCaloMETMuonCorrs(const reco::MuonMETCorrectionData &t)
pat::PATMuonHeavyObjectCache::calculatePtRatioRel
pat::CalculatePtRatioRel const & calculatePtRatioRel() const
Definition: PATMuonProducer.cc:61
pat::Muon::setSimPdgId
void setSimPdgId(int id)
Definition: Muon.h:323
pat::PATMuonProducer::patMuonPutToken_
const edm::EDPutTokenT< std::vector< Muon > > patMuonPutToken_
Definition: PATMuonProducer.cc:268
pat::Muon::setSimPt
void setSimPt(float pt)
Definition: Muon.h:329
pat::Muon::pfCandidateRef
reco::PFCandidateRef pfCandidateRef() const
pat::CaloIsolationEnergy
Calculates a lepton&#39;s calorimetric isolation energy.
Definition: CaloIsolationEnergy.h:32
muonProducer_cfi.mvaIDTrainingFile
mvaIDTrainingFile
Definition: muonProducer_cfi.py:113
pat::PATMuonProducer::isPhoton
bool isPhoton(long pdgid)
Definition: PATMuonProducer.cc:1187
SummaryClient_cfi.labels
labels
Definition: SummaryClient_cfi.py:61
pat::PATMuonProducer::isolatorTmpStorage_
pat::helper::MultiIsolator::IsolationValuePairs isolatorTmpStorage_
isolation value pair for temporary storage before being folded into the muon
Definition: PATMuonProducer.cc:250
pat::PATMuonProducer::triggerObjects_
edm::EDGetTokenT< std::vector< pat::TriggerObjectStandAlone > > triggerObjects_
Definition: PATMuonProducer.cc:261
pat::PATMuonProducer::embedGenMatch_
bool embedGenMatch_
embed the gen match information into the muon
Definition: PATMuonProducer.cc:197
PDWG_BPHSkim_cff.muons
muons
Definition: PDWG_BPHSkim_cff.py:47
pat::PATMuonProducer::isoDepositLabels_
IsolationLabels isoDepositLabels_
input source for isoDeposits
Definition: PATMuonProducer.cc:215
pat::PATMuonProducer::genMatchTokens_
std::vector< edm::EDGetTokenT< edm::Association< reco::GenParticleCollection > > > genMatchTokens_
input tags for generator match information
Definition: PATMuonProducer.cc:195
pat::getMiniPFIsolation
PFIsolation getMiniPFIsolation(const pat::PackedCandidateCollection *pfcands, const reco::Candidate::PolarLorentzVector &p4, float mindr=0.05, float maxdr=0.2, float kt_scale=10.0, float ptthresh=0.5, float deadcone_ch=0.0001, float deadcone_pu=0.01, float deadcone_ph=0.01, float deadcone_nh=0.01, float dZ_cut=0.0)
Definition: MiniIsolation.cc:19
displacedMuonProducer_cff.mvaL1L2L3ResCorrector
mvaL1L2L3ResCorrector
Definition: displacedMuonProducer_cff.py:68
pat::PATMuonHeavyObjectCache::calculatePtRatioRel_
std::unique_ptr< const pat::CalculatePtRatioRel > calculatePtRatioRel_
Definition: PATMuonProducer.cc:66
MuonSubdetId::DT
static constexpr int DT
Definition: MuonSubdetId.h:11
pat::PATMuonProducer::isolationValueLabels_
IsolationLabels isolationValueLabels_
input source isolation value maps
Definition: PATMuonProducer.cc:218
pat::Muon::embedPickyMuon
void embedPickyMuon()
embed reference to the above picky Track
displacedMuonProducer_cff.softMvaTrainingFile
softMvaTrainingFile
Definition: displacedMuonProducer_cff.py:72
MuonSubdetId::CSC
static constexpr int CSC
Definition: MuonSubdetId.h:12
BeamMonitor_cff.primaryVertex
primaryVertex
hltOfflineBeamSpot for HLTMON
Definition: BeamMonitor_cff.py:7
pat::PATMuonProducer::forceEmbedBestTrack_
bool forceEmbedBestTrack_
force separate embed of the best track even if already embedded
Definition: PATMuonProducer.cc:167
pat::PATMuonProducer::MuonBaseRef
edm::RefToBase< reco::Muon > MuonBaseRef
typedefs for convenience
Definition: PATMuonProducer.cc:96
pat::PATMuonProducer::embedPFCandidate_
bool embedPFCandidate_
embed pfCandidates into the muon
Definition: PATMuonProducer.cc:207
pat::PATMuonProducer::isolationValueTokens_
std::vector< edm::EDGetTokenT< edm::ValueMap< double > > > isolationValueTokens_
Definition: PATMuonProducer.cc:219
pat::Muon::setNumberOfValidHits
void setNumberOfValidHits(unsigned int numberOfValidHits)
Definition: Muon.h:255
pat::Muon::setSimEta
void setSimEta(float eta)
Definition: Muon.h:330
pat::PATMuonProducer::embedCombinedMuon_
bool embedCombinedMuon_
embed track of the combined fit into the muon
Definition: PATMuonProducer.cc:173
muonProducer_cfi.tcMETMuonCorrs
tcMETMuonCorrs
Definition: muonProducer_cfi.py:51
pat::Muon
Analysis-level muon class.
Definition: Muon.h:51
pat::PATMuonProducer::resolutionLoader_
pat::helper::KinResolutionsLoader resolutionLoader_
helper class to add resolutions to the muon
Definition: PATMuonProducer.cc:201
source
static std::string const source
Definition: EdmProvDump.cc:49
reco::Muon::isGlobalMuon
bool isGlobalMuon() const override
Definition: Muon.h:303
reco::LeafCandidate::setP4
void setP4(const LorentzVector &p4) final
set 4-momentum
Definition: LeafCandidate.h:158
pat::PATMuonHeavyObjectCache::softMuonMvaEstimator
pat::SoftMuonMvaEstimator const & softMuonMvaEstimator() const
Definition: PATMuonProducer.cc:63
pat::PATMuonProducer::PUPPIIsolation_neutral_hadrons_
edm::EDGetTokenT< edm::ValueMap< float > > PUPPIIsolation_neutral_hadrons_
Definition: PATMuonProducer.cc:230
eostools.move
def move(src, dest)
Definition: eostools.py:511
pat::PATMuonProducer::getMuonDirection
std::optional< GlobalPoint > getMuonDirection(const reco::MuonChamberMatch &chamberMatch, const edm::ESHandle< GlobalTrackingGeometry > &geometry, const DetId &chamberId)
Definition: PATMuonProducer.cc:487
pat::PATMuonProducer::isNeutralHadron
bool isNeutralHadron(long pdgid)
Definition: PATMuonProducer.cc:1183
TtFullHadEvtBuilder_cfi.genMatch
genMatch
add extra information on genMatch
Definition: TtFullHadEvtBuilder_cfi.py:37
GlobalVector
Global3DVector GlobalVector
Definition: GlobalVector.h:10
pat::TrackerIsolationPt
Calculates a lepton&#39;s tracker isolation pt.
Definition: TrackerIsolationPt.h:31
HLT_2023v12_cff.track
track
Definition: HLT_2023v12_cff.py:9624
pat::TriggerObjectStandAlone
Analysis-level trigger object class (stand-alone)
Definition: TriggerObjectStandAlone.h:32
commonCuts_cff.triggerResults_
triggerResults_
Definition: commonCuts_cff.py:17
Skims_PA_cff.name
name
Definition: Skims_PA_cff.py:17
pat::Muon::setSimMatchQuality
void setSimMatchQuality(float quality)
Definition: Muon.h:332
displacedMuonProducer_cff.isolationValues
isolationValues
Definition: displacedMuonProducer_cff.py:86
pat::Muon::setSimTpEvent
void setSimTpEvent(int tpEvent)
Definition: Muon.h:326
pat::PATMuonProducer::embedHighLevelSelection_
bool embedHighLevelSelection_
embed high level selection variables
Definition: PATMuonProducer.cc:209
Generated for CMSSW Reference Manual by doxygen 1.8.14