CMS 3D CMS Logo

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