86 return std::make_unique<PATMuonHeavyObjectCache>(iConfig);
99 typedef std::vector<edm::Handle<edm::Association<reco::GenParticleCollection>>>
GenAssociations;
114 template <
typename T>
134 bool primaryVertexIsValid,
136 bool beamspotIsValid);
140 const DetId& chamberId);
148 const std::vector<std::string>& collection_names);
195 std::vector<edm::EDGetTokenT<edm::Association<reco::GenParticleCollection>>>
genMatchTokens_;
274 template <
typename T>
284 if (depconf.
exists(
"tracker"))
286 if (depconf.
exists(
"ecal"))
288 if (depconf.
exists(
"hcal"))
290 if (depconf.
exists(
"pfAllParticles")) {
293 if (depconf.
exists(
"pfChargedHadrons")) {
296 if (depconf.
exists(
"pfChargedAll")) {
299 if (depconf.
exists(
"pfPUChargedHadrons")) {
302 if (depconf.
exists(
"pfNeutralHadrons")) {
305 if (depconf.
exists(
"pfPhotons")) {
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) {
320 return consumes<edm::ValueMap<T>>(
label.second);
333 muonLowPtMvaEstimator_ = std::make_unique<MuonMvaEstimator>(mvaLowPtTrainingFile,
mvaDrMax);
348 : relMiniIsoPUCorrected_(0),
349 useUserData_(iConfig.exists(
"userData")),
350 computeMuonMVA_(
false),
351 computeMuonIDMVA_(
false),
352 computeSoftMuonMVA_(
false),
353 recomputeBasicSelectors_(
false),
355 isolator_(iConfig.getParameter<
edm::
ParameterSet>(
"userIsolation"), consumesCollector(),
false),
358 patMuonPutToken_{produces<std::vector<Muon>>()} {
360 muonToken_ = consumes<edm::View<reco::Muon>>(iConfig.getParameter<
edm::InputTag>(
"muonSource"));
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");
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"));
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");
381 embedPickyMuon_ = iConfig.getParameter<
bool>(
"embedPickyMuon");
382 embedTpfmsMuon_ = iConfig.getParameter<
bool>(
"embedTpfmsMuon");
383 embedDytMuon_ = iConfig.getParameter<
bool>(
"embedDytMuon");
385 addInverseBeta_ = iConfig.getParameter<
bool>(
"addInverseBeta");
386 if (addInverseBeta_) {
387 muonTimeExtraToken_ =
388 consumes<edm::ValueMap<reco::MuonTimeExtra>>(iConfig.getParameter<
edm::InputTag>(
"sourceMuonTimeExtra"));
391 addGenMatch_ = iConfig.getParameter<
bool>(
"addGenMatch");
393 embedGenMatch_ = iConfig.getParameter<
bool>(
"embedGenMatch");
399 iConfig.getParameter<std::vector<edm::InputTag>>(
"genParticleMatch"),
400 [
this](
edm::InputTag const&
tag) { return consumes<edm::Association<reco::GenParticleCollection>>(tag); });
404 addEfficiencies_ = iConfig.getParameter<
bool>(
"addEfficiencies");
405 if (addEfficiencies_) {
410 addResolutions_ = iConfig.getParameter<
bool>(
"addResolutions");
411 if (addResolutions_) {
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"));
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"));
433 readIsolationLabels(iConfig,
"isoDeposits", isoDepositLabels_, isoDepositTokens_);
435 readIsolationLabels(iConfig,
"isolationValues", isolationValueLabels_, isolationValueTokens_);
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"));
448 computeMiniIso_ = iConfig.getParameter<
bool>(
"computeMiniIso");
450 computePuppiCombinedIso_ = iConfig.getParameter<
bool>(
"computePuppiCombinedIso");
452 effectiveAreaVec_ = iConfig.getParameter<std::vector<double>>(
"effectiveAreaVec");
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";
458 if (computeMiniIso_ || computePuppiCombinedIso_)
459 pcToken_ = consumes<pat::PackedCandidateCollection>(iConfig.getParameter<
edm::InputTag>(
"pfCandsForMiniIso"));
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";
468 if (computeMuonMVA_) {
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");
477 computeSoftMuonMVA_ = iConfig.getParameter<
bool>(
"computeSoftMuonMVA");
480 simInfo_ = consumes<edm::ValueMap<reco::MuonSimInfo>>(iConfig.getParameter<
edm::InputTag>(
"muonSimInfo"));
482 addTriggerMatching_ = iConfig.getParameter<
bool>(
"addTriggerMatching");
483 if (addTriggerMatching_) {
485 consumes<std::vector<pat::TriggerObjectStandAlone>>(iConfig.getParameter<
edm::InputTag>(
"triggerObjects"));
488 hltCollectionFilters_ = iConfig.getParameter<std::vector<std::string>>(
"hltCollectionFilters");
495 const DetId& chamberId) {
497 if (chamberGeometry) {
498 LocalPoint localPosition(chamberMatch.
x, chamberMatch.
y, 0);
499 return std::optional<GlobalPoint>(std::in_place, chamberGeometry->
toGlobal(localPosition));
501 return std::optional<GlobalPoint>();
513 std::optional<GlobalPoint> muonPosition;
518 for (
const auto& chamberMatch : aMuon.
matches()) {
521 if (
abs(detId.station()) > 3)
524 if (
abs(detId.station()) == 2)
528 CSCDetId detId(chamberMatch.id.rawId());
529 if (
abs(detId.station()) > 3)
532 if (
abs(detId.station()) == 2)
536 if (not muonPosition)
540 if (
std::abs(triggerObject.eta()) < 0.001) {
542 if (
deltaPhi(triggerObject.phi(), muonPosition->phi()) > 0.1)
546 if (
deltaR(triggerObject.p4(), *muonPosition) > 0.15)
559 const std::vector<std::string>& collection_filter_names) {
565 for (
const auto&
name : collection_filter_names) {
566 if (triggerObject.hasCollection(
name)) {
577 muon.addTriggerObjectMatch(
obj);
586 throw cms::Exception(
"FatalError") <<
"Unable to find GlobalTrackingGeometryRecord in event!\n";
589 if (
iEvent.isRealData()) {
663 bool beamSpotIsValid =
false;
664 bool primaryVertexIsValid =
false;
674 if (beamSpotHandle.
isValid()) {
676 beamSpotIsValid =
true;
678 edm::LogError(
"DataNotAvailable") <<
"No beam spot available from EventSetup, not adding high level selection \n";
680 if (pvHandle.
isValid() && !pvHandle->empty()) {
682 primaryVertexIsValid =
true;
685 <<
"No primary vertex available from EventSetup, not adding high level selection \n";
711 Muon aMuon(muonBaseRef);
726 chosenTrack = bestTrack;
729 unsigned int nhits = chosenTrack->numberOfValidHits();
755 (*PUPPIIsolation_neutral_hadrons)[muonBaseRef],
756 (*PUPPIIsolation_photons)[muonBaseRef]);
759 (*PUPPINoLeptonsIsolation_neutral_hadrons)[muonBaseRef],
760 (*PUPPINoLeptonsIsolation_photons)[muonBaseRef]);
803 unsigned int idx = itMuon -
muons->begin();
813 (*PUPPIIsolation_neutral_hadrons)[muonRef],
814 (*PUPPIIsolation_photons)[muonRef]);
816 (*PUPPINoLeptonsIsolation_neutral_hadrons)[muonRef],
817 (*PUPPINoLeptonsIsolation_photons)[muonRef]);
857 chosenTrack = bestTrack;
859 unsigned int nhits = chosenTrack->numberOfValidHits();
883 if (pfmu.muonRef().isNonnull()) {
884 if (pfmu.muonRef().id() != muonRef.id())
886 <<
"Muon reference within PF candidates does not point to the muon collection." << std::endl;
887 if (pfmu.muonRef().key() == muonRef.key()) {
906 if (simInfoIsAvailalbe) {
907 const auto& msi = (*simInfo)[muonBaseRef];
938 if (primaryVertexIsValid)
943 bool triggerObjectsAvailable =
false;
944 bool triggerResultsAvailable =
false;
959 muon.setSelectors(0);
960 bool isRun2016BCDEF = (272728 <=
iEvent.run() &&
iEvent.run() <= 278808);
963 float miniIsoValue = -1;
975 double puppiCombinedIsolationPAT = -1;
983 float jetPtRatio = 0.0;
984 float jetPtRel = 0.0;
986 float mva_lowpt = 0.0;
989 mva = globalCache()->muonMvaEstimator().computeMva(
muon,
991 *(mvaBTagCollectionTag.
product()),
997 mva_lowpt = globalCache()->muonLowPtMvaEstimator().computeMva(
muon,
999 *(mvaBTagCollectionTag.
product()),
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);
1014 muon.setLowPtMvaValue(mva_lowpt);
1015 muon.setJetPtRatio(jetPtRatio);
1016 muon.setJetPtRel(jetPtRel);
1021 miniIsoValue < 0.11 && (
muon.jetPtRatio() > 0.74 ||
muon.jetPtRel() > 6.8));
1029 const double sip3D = edB3D > 0 ? dB3D / edB3D : 0.0;
1034 dB2D < 0.05 and
dz < 0.1) {
1041 if (
muon.pt() > 5 and
muon.isLooseMuon() and sip3D < 4 and dB2D < 0.5 and
dz < 1) {
1049 constexpr
int MVAsentinelValue = -99;
1050 constexpr
float mvaIDmediumCut = 0.08;
1051 constexpr
float mvaIDtightCut = 0.12;
1055 if (
muon.isLooseMuon()) {
1056 mvaID = globalCache()->muonMvaIDEstimator().computeMVAID(
muon)[1];
1058 mvaID = MVAsentinelValue;
1067 float mva = globalCache()->softMuonMvaEstimator().computeMva(
muon);
1119 for (
auto const&
genMatch : genMatches) {
1130 for (
size_t j = 0, nd =
deposits.size();
j < nd; ++
j) {
1189 constexpr
double dR_threshold = 0.4;
1190 constexpr
double dR2_threshold = dR_threshold * dR_threshold;
1191 constexpr
double mix_fraction = 0.5;
1193 double val_PuppiWithLep = 0.0;
1194 double val_PuppiWithoutLep = 0.0;
1196 for (
const auto&
cand : *pc) {
1202 if (pType ==
OTHER) {
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)" 1211 if (d_eta > dR_threshold)
1215 if (d_phi > dR_threshold)
1219 if (dR2 > dR2_threshold)
1221 if (pType ==
CH && dR2 < 0.0001 * 0.0001)
1223 if (pType ==
NH && dR2 < 0.01 * 0.01)
1225 if (pType == PH && dR2 < 0.01 * 0.01)
1227 val_PuppiWithLep +=
cand.pt() *
cand.puppiWeight();
1228 val_PuppiWithoutLep +=
cand.pt() *
cand.puppiWeightNoLep();
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;
1247 iDesc.
setComment(
"PAT muon producer module");
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)
1257 "force embedding separately the best tracks even if they're already embedded e.g. as tracker or global " 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 ");
1267 iDesc.
add<
bool>(
"embedCaloMETMuonCorrs",
true)->setComment(
"whether to add MET muon correction for caloMET or not");
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");
1272 ->setComment(
"source of MET muon corrections for tcMET");
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");
1281 iDesc.
add<
bool>(
"addInverseBeta",
true)->setComment(
"add combined inverse beta");
1283 ->setComment(
"source of inverse beta values");
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;
1292 ->
setComment(
"input with MC match information");
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");
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");
1304 iDesc.
add<
bool>(
"addTriggerMatching",
false)->setComment(
"add L1 and HLT matching to offline muon");
1319 isoDepositsPSet.
addOptional<std::vector<edm::InputTag>>(
"user");
1320 iDesc.
addOptional(
"isoDeposits", isoDepositsPSet);
1333 iDesc.
addOptional(
"isolationValues", isolationValuesPSet);
1337 "puppiIsolationChargedHadrons",
1338 edm::InputTag(
"muonPUPPIIsolation",
"h+-DR030-ThresholdVeto000-ConeVeto000"),
1341 "puppiIsolationNeutralHadrons",
1342 edm::InputTag(
"muonPUPPIIsolation",
"h0-DR030-ThresholdVeto000-ConeVeto001"),
1345 "puppiIsolationPhotons",
1346 edm::InputTag(
"muonPUPPIIsolation",
"gamma-DR030-ThresholdVeto000-ConeVeto001"),
1349 "puppiNoLeptonsIsolationChargedHadrons",
1350 edm::InputTag(
"muonPUPPINoLeptonsIsolation",
"h+-DR030-ThresholdVeto000-ConeVeto000"),
1353 "puppiNoLeptonsIsolationNeutralHadrons",
1354 edm::InputTag(
"muonPUPPINoLeptonsIsolation",
"h0-DR030-ThresholdVeto000-ConeVeto001"),
1357 "puppiNoLeptonsIsolationPhotons",
1358 edm::InputTag(
"muonPUPPINoLeptonsIsolation",
"gamma-DR030-ThresholdVeto000-ConeVeto001"),
1365 iDesc.
add(
"efficiencies", efficienciesPSet);
1366 iDesc.
add<
bool>(
"addEfficiencies",
false);
1375 iDesc.
add(
"userIsolation", isolationPSet);
1377 iDesc.
add<
bool>(
"embedHighLevelSelection",
true)->setComment(
"embed high level selection");
1381 ->
setComment(
"input with high level selection");
1383 ->
setComment(
"input with high level selection");
1394 bool primaryVertexIsValid,
1396 bool beamspotIsValid) {
1405 std::pair<bool, Measurement1D>
result =
1407 double d0_corr =
result.second.value();
1408 double d0_err = primaryVertexIsValid ?
result.second.error() : -1.0;
1421 d0_corr =
result.second.value();
1422 d0_err = beamspotIsValid ?
result.second.error() : -1.0;
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)
edm::EDGetTokenT< edm::ValueMap< float > > PUPPIIsolation_photons_
bool enabled() const
'true' 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
T getParameter(std::string const &) const
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)
bool embedTcMETMuonCorrs_
embed muon MET correction info for tcMET into the muon
pat::MuonMvaEstimator const & muonLowPtMvaEstimator() const
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)
bool enabled() const
True if it has a non null configuration.
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)
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 ¶meterName) const
checks if a parameter exists
~PATMuonProducer() override
default destructur
edm::EDGetTokenT< edm::ValueMap< reco::MuonSimInfo > > simInfo_
MC info.
T const * product() const
void embedMuonBestTrack(bool force=false)
std::vector< pat::PackedCandidate > PackedCandidateCollection
void setIsolationPUPPINoLeptons(float chargedhadrons, float neutralhadrons, float photons)
sets PUPPINoLeptons isolations
void setMuonMiniIso(pat::Muon &aMuon, const pat::PackedCandidateCollection *pc)
PATMuonProducer(const edm::ParameterSet &iConfig, PATMuonHeavyObjectCache const *)
default constructir
bool addTriggerMatching_
Trigger.
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_
bool isNonnull() const
Checks for non-null.
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.
edm::EDGetTokenT< edm::ValueMap< float > > PUPPINoLeptonsIsolation_charged_hadrons_
std::vector< double > miniIsoParams_
void setSimPhi(float phi)
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 >
PFCandidateCollection::const_iterator PFCandidateConstIterator
iterator
bool computePuppiCombinedIso_
void setSimProdRho(float rho)
void setSimHeaviestMotherFlavour(int id)
reco::Muon::Selector makeSelectorBitset(reco::Muon const &muon, reco::Vertex const *vertex=nullptr, bool run2016_hip_mitigation=false)
void setPFCandidateRef(const reco::PFCandidateRef &ref)
add a reference to the source IsolatedPFCandidate
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)
void embedStandAloneMuon()
set reference to Track reconstructed in the muon detector only (reimplemented from reco::Muon) ...
double relMiniIsoPUCorrected_
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
pat::helper::MultiIsolator isolator_
std::vector< edm::EDGetTokenT< edm::ValueMap< IsoDeposit > > > isoDepositTokens_
void fill(const edm::View< T > &coll, int idx, IsolationValuePairs &isolations) const
void setIsoDeposit(IsolationKeys key, const IsoDeposit &dep)
Sets the IsoDeposit associated with some key; if it is already existent, it is overwritten.
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
bool embedStandAloneMuon_
embed track from muon system into the muon
void setComment(std::string const &value)
edm::EDGetTokenT< edm::TriggerResults > triggerResults_
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)
bool addGenMatch_
add generator match information
PATMuonHeavyObjectCache(const edm::ParameterSet &)
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
description of config file parameters
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 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
bool enabled() const
'true' 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_
Abs< T >::type abs(const T &t)
double relMiniIsoPUCorrected(const pat::Muon &aMuon, double rho)
edm::EDGetTokenT< pat::PackedCandidateCollection > pcToken_
#define DEFINE_FWK_MODULE(type)
std::pair< pat::IsolationKeys, edm::InputTag > IsolationLabel
bool getData(T &iHolder) const
static void globalEndJob(PATMuonHeavyObjectCache *)
static std::string const triggerResults
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
ESHandle< T > getHandle(const ESGetToken< T, R > &iToken) const
reco::MuonRef muonRef() const
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.
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)
std::vector< std::pair< pat::IsolationKeys, float > > IsolationValuePairs
constexpr auto deltaR2(const T1 &t1, const T2 &t2) -> decltype(t1.eta())
void addGenParticleRef(const reco::GenParticleRef &ref)
void setPfEcalEnergy(float pfEcalEnergy)
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)
void addTriggerObjectMatch(const TriggerObjectStandAlone &trigObj)
add a trigger match
void setExtSimType(reco::ExtendedMuonSimType type)
std::vector< MuonChamberMatch > & matches()
get muon matching information
std::unique_ptr< const pat::MuonMvaIDEstimator > muonMvaIDEstimator_
void setMiniPFIsolation(PFIsolation const &iso)
std::unique_ptr< const pat::SoftMuonMvaEstimator > softMuonMvaEstimator_
std::vector< edm::Handle< edm::Association< reco::GenParticleCollection > > > GenAssociations
edm::EDGetTokenT< reco::JetCorrector > mvaL1L2L3ResCorrector_
void setSimProdZ(float z)
Particle reconstructed by the particle flow algorithm.
std::vector< edm::Handle< edm::ValueMap< double > > > IsolationValueMaps
pat::helper::EfficiencyLoader efficiencyLoader_
helper class to add efficiencies to the muon
bool embedPickyMuon_
embed track from picky muon fit into the muon
void setNormChi2(double normChi2)
boost::indirect_iterator< typename seq_t::const_iterator > const_iterator
bool embedDytMuon_
embed track from DYT muon fit into the muon
void embedCaloMETMuonCorrs(const reco::MuonMETCorrectionData &t)
const edm::EDPutTokenT< std::vector< Muon > > patMuonPutToken_
reco::PFCandidateRef pfCandidateRef() const
Calculates a lepton'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)
IsolationLabels isolationValueLabels_
input source isolation value maps
bool recomputeBasicSelectors_
void embedPickyMuon()
embed reference to the above picky Track
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)
bool computeMuonMVA_
standard muon selectors
void setSimEta(float eta)
bool embedCombinedMuon_
embed track of the combined fit into the muon
Analysis-level muon class.
pat::helper::KinResolutionsLoader resolutionLoader_
helper class to add resolutions to the muon
static std::string const source
bool isGlobalMuon() const override
void setP4(const LorentzVector &p4) final
set 4-momentum
pat::SoftMuonMvaEstimator const & softMuonMvaEstimator() const
edm::EDGetTokenT< edm::ValueMap< float > > PUPPIIsolation_neutral_hadrons_
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
Calculates a lepton's tracker isolation pt.
Analysis-level trigger object class (stand-alone)
void setSimMatchQuality(float quality)
void setSimTpEvent(int tpEvent)
bool embedHighLevelSelection_
embed high level selection variables