class definition More...

Inheritance diagram for pat::PATMuonProducer:

Public Member Functions
	PATMuonProducer (const edm::ParameterSet &iConfig, PATMuonHeavyObjectCache const *)
	default constructir More...

void	produce (edm::Event &iEvent, const edm::EventSetup &iSetup) override
	everything that needs to be done during the event loop More...

	~PATMuonProducer () override
	default destructur More...

Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< PATMuonHeavyObjectCache > >
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)
	description of config file parameters More...

static void	globalEndJob (PATMuonHeavyObjectCache *)

static std::unique_ptr< PATMuonHeavyObjectCache >	initializeGlobalCache (const edm::ParameterSet &iConfig)

Private Types
typedef std::vector< edm::Handle< edm::Association< reco::GenParticleCollection > > >	GenAssociations

typedef std::vector< edm::Handle< edm::ValueMap< IsoDeposit > > >	IsoDepositMaps

typedef std::pair< pat::IsolationKeys, edm::InputTag >	IsolationLabel

typedef std::vector< IsolationLabel >	IsolationLabels

typedef std::vector< edm::Handle< edm::ValueMap< double > > >	IsolationValueMaps

typedef edm::RefToBase< reco::Muon >	MuonBaseRef
	typedefs for convenience More...

Private Member Functions
void	embedHighLevel (pat::Muon &aMuon, reco::TrackRef track, reco::TransientTrack &tt, reco::Vertex &primaryVertex, bool primaryVertexIsValid, reco::BeamSpot &beamspot, bool beamspotIsValid)

void	fillHltTriggerInfo (pat::Muon &muon, edm::Handle< std::vector< pat::TriggerObjectStandAlone >> &triggerObjects, const edm::TriggerNames &names, const std::vector< std::string > &collection_names)

void	fillL1TriggerInfo (pat::Muon &muon, edm::Handle< std::vector< pat::TriggerObjectStandAlone >> &triggerObjects, const edm::TriggerNames &names, const edm::ESHandle< GlobalTrackingGeometry > &geometry)

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 More...

std::optional< GlobalPoint >	getMuonDirection (const reco::MuonChamberMatch &chamberMatch, const edm::ESHandle< GlobalTrackingGeometry > &geometry, const DetId &chamberId)

double	getRelMiniIsoPUCorrected (const pat::Muon &muon, double rho, const std::vector< double > &area)

bool	isChargedHadron (long pdgid)

bool	isNeutralHadron (long pdgid)

bool	isPhoton (long pdgid)

double	puppiCombinedIsolation (const pat::Muon &muon, const pat::PackedCandidateCollection *pc)

template<typename T >
void	readIsolationLabels (const edm::ParameterSet &iConfig, const char *psetName, IsolationLabels &labels, std::vector< edm::EDGetTokenT< edm::ValueMap< T >>> &tokens)

double	relMiniIsoPUCorrected (const pat::Muon &aMuon, double rho)

void	setMuonMiniIso (pat::Muon &aMuon, const pat::PackedCandidateCollection *pc)

Private Attributes
bool	addEfficiencies_
	add efficiencies to the muon (this will be data members of th muon even w/o embedding) More...

bool	addGenMatch_
	add generator match information More...

bool	addInverseBeta_
	add combined inverse beta measurement into the muon More...

bool	addPuppiIsolation_
	add puppi isolation More...

bool	addResolutions_
	add resolutions to the muon (this will be data members of th muon even w/o embedding) More...

bool	addTriggerMatching_
	Trigger. More...

edm::EDGetTokenT< reco::BeamSpot >	beamLineToken_
	input source of the primary vertex/beamspot More...

edm::EDGetTokenT< edm::ValueMap< reco::MuonMETCorrectionData > >	caloMETMuonCorrsToken_
	source of caloMET muon corrections More...

bool	computeMiniIso_

bool	computeMuonIDMVA_
	standard muon selectors More...

bool	computePuppiCombinedIso_

bool	computeSoftMuonMVA_

std::vector< double >	effectiveAreaVec_

pat::helper::EfficiencyLoader	efficiencyLoader_
	helper class to add efficiencies to the muon More...

bool	embedBestTrack_
	embed the track from best muon measurement (global pflow) More...

bool	embedCaloMETMuonCorrs_
	embed muon MET correction info for caloMET into the muon More...

bool	embedCombinedMuon_
	embed track of the combined fit into the muon More...

bool	embedDytMuon_
	embed track from DYT muon fit into the muon More...

bool	embedGenMatch_
	embed the gen match information into the muon More...

bool	embedHighLevelSelection_
	embed high level selection variables More...

bool	embedPFCandidate_
	embed pfCandidates into the muon More...

bool	embedPfEcalEnergy_
	add ecal PF energy More...

bool	embedPickyMuon_
	embed track from picky muon fit into the muon More...

bool	embedStandAloneMuon_
	embed track from muon system into the muon More...

bool	embedTcMETMuonCorrs_
	embed muon MET correction info for tcMET into the muon More...

bool	embedTpfmsMuon_
	embed track from tpfms muon fit into the muon More...

bool	embedTrack_
	embed the track from inner tracker into the muon More...

bool	embedTunePBestTrack_
	embed the track from best muon measurement (muon only) More...

bool	forceEmbedBestTrack_
	force separate embed of the best track even if already embedded More...

std::vector< edm::EDGetTokenT< edm::Association< reco::GenParticleCollection > > >	genMatchTokens_
	input tags for generator match information More...

const edm::ESGetToken< GlobalTrackingGeometry, GlobalTrackingGeometryRecord >	geometryToken_

std::vector< std::string >	hltCollectionFilters_

IsolationLabels	isoDepositLabels_
	input source for isoDeposits More...

std::vector< edm::EDGetTokenT< edm::ValueMap< IsoDeposit > > >	isoDepositTokens_

IsolationLabels	isolationValueLabels_
	input source isolation value maps More...

std::vector< edm::EDGetTokenT< edm::ValueMap< double > > >	isolationValueTokens_

pat::helper::MultiIsolator	isolator_

pat::helper::MultiIsolator::IsolationValuePairs	isolatorTmpStorage_
	isolation value pair for temporary storage before being folded into the muon More...

std::vector< double >	miniIsoParams_

edm::EDGetTokenT< edm::ValueMap< reco::MuonTimeExtra > >	muonTimeExtraToken_
	input tag for reading inverse beta More...

edm::EDGetTokenT< edm::View< reco::Muon > >	muonToken_
	input source More...

edm::EDGetTokenT< reco::JetTagCollection >	mvaBTagCollectionTag_

double	mvaIDmediumCut_

double	mvaIDtightCut_
	working points of the muon MVA ID More...

edm::EDGetTokenT< reco::JetCorrector >	mvaL1Corrector_

edm::EDGetTokenT< reco::JetCorrector >	mvaL1L2L3ResCorrector_

const edm::EDPutTokenT< std::vector< Muon > >	patMuonPutToken_

edm::EDGetTokenT< pat::PackedCandidateCollection >	pcToken_

edm::EDGetTokenT< reco::PFCandidateCollection >	pfMuonToken_
	input source pfCandidates that will be to be transformed into pat::Muons, when using PF2PAT More...

edm::EDGetTokenT< edm::ValueMap< float > >	PUPPIIsolation_charged_hadrons_

edm::EDGetTokenT< edm::ValueMap< float > >	PUPPIIsolation_neutral_hadrons_

edm::EDGetTokenT< edm::ValueMap< float > >	PUPPIIsolation_photons_

edm::EDGetTokenT< edm::ValueMap< float > >	PUPPINoLeptonsIsolation_charged_hadrons_

edm::EDGetTokenT< edm::ValueMap< float > >	PUPPINoLeptonsIsolation_neutral_hadrons_

edm::EDGetTokenT< edm::ValueMap< float > >	PUPPINoLeptonsIsolation_photons_

edm::EDGetTokenT< std::vector< reco::Vertex > >	pvToken_
	input source of the primary vertex More...

bool	recomputeBasicSelectors_

double	relMiniIsoPUCorrected_

pat::helper::KinResolutionsLoader	resolutionLoader_
	helper class to add resolutions to the muon More...

edm::EDGetTokenT< double >	rho_

edm::EDGetTokenT< edm::ValueMap< reco::MuonSimInfo > >	simInfo_
	MC info. More...

std::unique_ptr< pat::XGBooster >	softMuonMvaRun3Booster_

edm::EDGetTokenT< edm::ValueMap< reco::MuonMETCorrectionData > >	tcMETMuonCorrsToken_
	source of tcMET muon corrections More...

const edm::ESGetToken< TransientTrackBuilder, TransientTrackRecord >	transientTrackBuilderToken_

edm::EDGetTokenT< std::vector< pat::TriggerObjectStandAlone > >	triggerObjects_

edm::EDGetTokenT< edm::TriggerResults >	triggerResults_

bool	useJec_

bool	useParticleFlow_
	switch to use particle flow (PF2PAT) or not More...

pat::PATUserDataHelper< pat::Muon >	userDataHelper_
	helper class to add userData to the muon More...

bool	useUserData_
	add user data to the muon (this will be data members of th muon even w/o embedding) More...

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< PATMuonHeavyObjectCache > >
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

class definition

Produces pat::Muon's.

The PATMuonProducer produces analysis-level pat::Muon's starting from a collection of objects of reco::Muon.

Author: Steven Lowette, Roger Wolf

Version

Id: PATMuonProducer.h,v 1.29 2012/08/22 15:02:52 bellan Exp

Definition at line 78 of file PATMuonProducer.cc.

Member Typedef Documentation

◆ GenAssociations

typedef std::vector<edm::Handle<edm::Association<reco::GenParticleCollection> > > pat::PATMuonProducer::GenAssociations

private

Definition at line 99 of file PATMuonProducer.cc.

◆ IsoDepositMaps

typedef std::vector<edm::Handle<edm::ValueMap<IsoDeposit> > > pat::PATMuonProducer::IsoDepositMaps

private

Definition at line 100 of file PATMuonProducer.cc.

◆ IsolationLabel

typedef std::pair<pat::IsolationKeys, edm::InputTag> pat::PATMuonProducer::IsolationLabel

private

Definition at line 102 of file PATMuonProducer.cc.

◆ IsolationLabels

typedef std::vector<IsolationLabel> pat::PATMuonProducer::IsolationLabels

private

Definition at line 103 of file PATMuonProducer.cc.

◆ IsolationValueMaps

typedef std::vector<edm::Handle<edm::ValueMap<double> > > pat::PATMuonProducer::IsolationValueMaps

private

Definition at line 101 of file PATMuonProducer.cc.

◆ MuonBaseRef

typedef edm::RefToBase<reco::Muon> pat::PATMuonProducer::MuonBaseRef

private

typedefs for convenience

Definition at line 98 of file PATMuonProducer.cc.

Constructor & Destructor Documentation

◆ PATMuonProducer()

PATMuonProducer::PATMuonProducer	(	const edm::ParameterSet &	iConfig,
		PATMuonHeavyObjectCache const *
	)

explicit

default constructir

Definition at line 344 of file PATMuonProducer.cc.

References deDxTools::esConsumes().

     : relMiniIsoPUCorrected_(0),
       useUserData_(iConfig.exists("userData")),
       computeMuonIDMVA_(false),
       computeSoftMuonMVA_(false),
       recomputeBasicSelectors_(false),
       useJec_(false),
       isolator_(iConfig.getParameter<edm::ParameterSet>("userIsolation"), consumesCollector(), false),
       geometryToken_{esConsumes()},
       transientTrackBuilderToken_{esConsumes(edm::ESInputTag("", "TransientTrackBuilder"))},
       patMuonPutToken_{produces<std::vector<Muon>>()} {
   // Muon MVA ID wps
   mvaIDmediumCut_ = iConfig.getParameter<double>("mvaIDwpMedium");
   mvaIDtightCut_ = iConfig.getParameter<double>("mvaIDwpTight");
 
   // input source
   muonToken_ = consumes<edm::View<reco::Muon>>(iConfig.getParameter<edm::InputTag>("muonSource"));
   // embedding of tracks
   embedBestTrack_ = iConfig.getParameter<bool>("embedMuonBestTrack");
   embedTunePBestTrack_ = iConfig.getParameter<bool>("embedTunePMuonBestTrack");
   forceEmbedBestTrack_ = iConfig.getParameter<bool>("forceBestTrackEmbedding");
   embedTrack_ = iConfig.getParameter<bool>("embedTrack");
   embedCombinedMuon_ = iConfig.getParameter<bool>("embedCombinedMuon");
   embedStandAloneMuon_ = iConfig.getParameter<bool>("embedStandAloneMuon");
   // embedding of muon MET correction information
   embedCaloMETMuonCorrs_ = iConfig.getParameter<bool>("embedCaloMETMuonCorrs");
   embedTcMETMuonCorrs_ = iConfig.getParameter<bool>("embedTcMETMuonCorrs");
   caloMETMuonCorrsToken_ =
       mayConsume<edm::ValueMap<reco::MuonMETCorrectionData>>(iConfig.getParameter<edm::InputTag>("caloMETMuonCorrs"));
   tcMETMuonCorrsToken_ =
       mayConsume<edm::ValueMap<reco::MuonMETCorrectionData>>(iConfig.getParameter<edm::InputTag>("tcMETMuonCorrs"));
   // pflow specific configurables
   useParticleFlow_ = iConfig.getParameter<bool>("useParticleFlow");
   embedPFCandidate_ = iConfig.getParameter<bool>("embedPFCandidate");
   pfMuonToken_ = mayConsume<reco::PFCandidateCollection>(iConfig.getParameter<edm::InputTag>("pfMuonSource"));
   embedPfEcalEnergy_ = iConfig.getParameter<bool>("embedPfEcalEnergy");
   // embedding of tracks from TeV refit
   embedPickyMuon_ = iConfig.getParameter<bool>("embedPickyMuon");
   embedTpfmsMuon_ = iConfig.getParameter<bool>("embedTpfmsMuon");
   embedDytMuon_ = iConfig.getParameter<bool>("embedDytMuon");
   // embedding of inverse beta variable information
   addInverseBeta_ = iConfig.getParameter<bool>("addInverseBeta");
   if (addInverseBeta_) {
     muonTimeExtraToken_ =
         consumes<edm::ValueMap<reco::MuonTimeExtra>>(iConfig.getParameter<edm::InputTag>("sourceMuonTimeExtra"));
   }
   // Monte Carlo matching
   addGenMatch_ = iConfig.getParameter<bool>("addGenMatch");
   if (addGenMatch_) {
     embedGenMatch_ = iConfig.getParameter<bool>("embedGenMatch");
     if (iConfig.existsAs<edm::InputTag>("genParticleMatch")) {
       genMatchTokens_.push_back(consumes<edm::Association<reco::GenParticleCollection>>(
           iConfig.getParameter<edm::InputTag>("genParticleMatch")));
     } else {
       genMatchTokens_ = edm::vector_transform(
           iConfig.getParameter<std::vector<edm::InputTag>>("genParticleMatch"),
           [this](edm::InputTag const& tag) { return consumes<edm::Association<reco::GenParticleCollection>>(tag); });
     }
   }
   // efficiencies
   addEfficiencies_ = iConfig.getParameter<bool>("addEfficiencies");
   if (addEfficiencies_) {
     efficiencyLoader_ =
         pat::helper::EfficiencyLoader(iConfig.getParameter<edm::ParameterSet>("efficiencies"), consumesCollector());
   }
   // resolutions
   addResolutions_ = iConfig.getParameter<bool>("addResolutions");
   if (addResolutions_) {
     resolutionLoader_ =
         pat::helper::KinResolutionsLoader(iConfig.getParameter<edm::ParameterSet>("resolutions"), consumesCollector());
   }
   // puppi
   addPuppiIsolation_ = iConfig.getParameter<bool>("addPuppiIsolation");
   if (addPuppiIsolation_) {
     PUPPIIsolation_charged_hadrons_ =
         consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiIsolationChargedHadrons"));
     PUPPIIsolation_neutral_hadrons_ =
         consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiIsolationNeutralHadrons"));
     PUPPIIsolation_photons_ =
         consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiIsolationPhotons"));
     //puppiNoLeptons
     PUPPINoLeptonsIsolation_charged_hadrons_ =
         consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiNoLeptonsIsolationChargedHadrons"));
     PUPPINoLeptonsIsolation_neutral_hadrons_ =
         consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiNoLeptonsIsolationNeutralHadrons"));
     PUPPINoLeptonsIsolation_photons_ =
         consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("puppiNoLeptonsIsolationPhotons"));
   }
   // read isoDeposit labels, for direct embedding
   readIsolationLabels(iConfig, "isoDeposits", isoDepositLabels_, isoDepositTokens_);
   // read isolation value labels, for direct embedding
   readIsolationLabels(iConfig, "isolationValues", isolationValueLabels_, isolationValueTokens_);
   // check to see if the user wants to add user data
   if (useUserData_) {
     userDataHelper_ = PATUserDataHelper<Muon>(iConfig.getParameter<edm::ParameterSet>("userData"), consumesCollector());
   }
   // embed high level selection variables
   embedHighLevelSelection_ = iConfig.getParameter<bool>("embedHighLevelSelection");
   if (embedHighLevelSelection_) {
     beamLineToken_ = consumes<reco::BeamSpot>(iConfig.getParameter<edm::InputTag>("beamLineSrc"));
     pvToken_ = consumes<std::vector<reco::Vertex>>(iConfig.getParameter<edm::InputTag>("pvSrc"));
   }
 
   //for mini-isolation calculation
   computeMiniIso_ = iConfig.getParameter<bool>("computeMiniIso");
 
   computePuppiCombinedIso_ = iConfig.getParameter<bool>("computePuppiCombinedIso");
 
   effectiveAreaVec_ = iConfig.getParameter<std::vector<double>>("effectiveAreaVec");
 
   miniIsoParams_ = iConfig.getParameter<std::vector<double>>("miniIsoParams");
   if (computeMiniIso_ && miniIsoParams_.size() != 9) {
     throw cms::Exception("ParameterError") << "miniIsoParams must have exactly 9 elements.\n";
   }
   if (computeMiniIso_ || computePuppiCombinedIso_)
     pcToken_ = consumes<pat::PackedCandidateCollection>(iConfig.getParameter<edm::InputTag>("pfCandsForMiniIso"));
 
   // standard selectors
   recomputeBasicSelectors_ = iConfig.getParameter<bool>("recomputeBasicSelectors");
   computeMuonIDMVA_ = iConfig.getParameter<bool>("computeMuonIDMVA");
 
   if (computeMiniIso_) {
     // pfCombinedInclusiveSecondaryVertexV2BJetTags
     mvaBTagCollectionTag_ = consumes<reco::JetTagCollection>(iConfig.getParameter<edm::InputTag>("mvaJetTag"));
     mvaL1Corrector_ = consumes<reco::JetCorrector>(iConfig.getParameter<edm::InputTag>("mvaL1Corrector"));
     mvaL1L2L3ResCorrector_ = consumes<reco::JetCorrector>(iConfig.getParameter<edm::InputTag>("mvaL1L2L3ResCorrector"));
     rho_ = consumes<double>(iConfig.getParameter<edm::InputTag>("rho"));
     useJec_ = iConfig.getParameter<bool>("useJec");
   }
 
   computeSoftMuonMVA_ = iConfig.getParameter<bool>("computeSoftMuonMVA");
 
   // MC info
   simInfo_ = consumes<edm::ValueMap<reco::MuonSimInfo>>(iConfig.getParameter<edm::InputTag>("muonSimInfo"));
 
   if (computeSoftMuonMVA_) {
     std::string softMvaRun3Model = iConfig.getParameter<string>("softMvaRun3Model");
     softMuonMvaRun3Booster_ =
         std::make_unique<pat::XGBooster>(edm::FileInPath(softMvaRun3Model + ".model").fullPath(),
                                          edm::FileInPath(softMvaRun3Model + ".features").fullPath());
   }
 
   addTriggerMatching_ = iConfig.getParameter<bool>("addTriggerMatching");
   if (addTriggerMatching_) {
     triggerObjects_ =
         consumes<std::vector<pat::TriggerObjectStandAlone>>(iConfig.getParameter<edm::InputTag>("triggerObjects"));
     triggerResults_ = consumes<edm::TriggerResults>(iConfig.getParameter<edm::InputTag>("triggerResults"));
   }
   hltCollectionFilters_ = iConfig.getParameter<std::vector<std::string>>("hltCollectionFilters");
 }

◆ ~PATMuonProducer()

PATMuonProducer::~PATMuonProducer ( )

override

default destructur

Definition at line 495 of file PATMuonProducer.cc.

495 {}

Member Function Documentation

◆ embedHighLevel()

void PATMuonProducer::embedHighLevel	(	pat::Muon &	aMuon,
		reco::TrackRef	track,
		reco::TransientTrack &	tt,
		reco::Vertex &	primaryVertex,
		bool	primaryVertexIsValid,
		reco::BeamSpot &	beamspot,
		bool	beamspotIsValid
	)

private

Definition at line 1348 of file PATMuonProducer.cc.

References pat::Muon::BS2D, pat::Muon::BS3D, Matriplex::hypot(), BeamMonitor_cff::primaryVertex, pat::Muon::PV2D, pat::Muon::PV3D, pat::Muon::PVDZ, mps_fire::result, pat::Muon::setDB(), IPTools::signedImpactParameter3D(), and HLT_2023v12_cff::track.

Referenced by produce().

                                                            {
   // Correct to PV
 
   // PV2D
   aMuon.setDB(track->dxy(primaryVertex.position()),
               track->dxyError(primaryVertex.position(), primaryVertex.covariance()),
               pat::Muon::PV2D);
 
   // PV3D
   std::pair<bool, Measurement1D> result =
       IPTools::signedImpactParameter3D(tt, GlobalVector(track->px(), track->py(), track->pz()), primaryVertex);
   double d0_corr = result.second.value();
   double d0_err = primaryVertexIsValid ? result.second.error() : -1.0;
   aMuon.setDB(d0_corr, d0_err, pat::Muon::PV3D);
 
   // Correct to beam spot
 
   // BS2D
   aMuon.setDB(track->dxy(beamspot), track->dxyError(beamspot), pat::Muon::BS2D);
 
   // make a fake vertex out of beam spot
   reco::Vertex vBeamspot(beamspot.position(), beamspot.rotatedCovariance3D());
 
   // BS3D
   result = IPTools::signedImpactParameter3D(tt, GlobalVector(track->px(), track->py(), track->pz()), vBeamspot);
   d0_corr = result.second.value();
   d0_err = beamspotIsValid ? result.second.error() : -1.0;
   aMuon.setDB(d0_corr, d0_err, pat::Muon::BS3D);
 
   // PVDZ
   aMuon.setDB(
       track->dz(primaryVertex.position()), std::hypot(track->dzError(), primaryVertex.zError()), pat::Muon::PVDZ);
 }

◆ fillDescriptions()

void PATMuonProducer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

description of config file parameters

Definition at line 1203 of file PATMuonProducer.cc.

References edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addNode(), edm::ParameterSetDescription::addOptional(), pat::helper::KinResolutionsLoader::fillDescription(), pat::PATUserDataHelper< ObjectType >::fillDescription(), edm::ParameterSetDescription::ifValue(), ProducerED_cfi::InputTag, or, edm::ParameterSetDescription::setAllowAnything(), edm::ParameterSetDescription::setComment(), and edm::ParameterDescriptionNode::setComment().

                                                                                  {
   edm::ParameterSetDescription iDesc;
   iDesc.setComment("PAT muon producer module");
 
   // input source
   iDesc.add<edm::InputTag>("muonSource", edm::InputTag("no default"))->setComment("input collection");
 
   // embedding
   iDesc.add<bool>("embedMuonBestTrack", true)->setComment("embed muon best track (global pflow)");
   iDesc.add<bool>("embedTunePMuonBestTrack", true)->setComment("embed muon best track (muon only)");
   iDesc.add<bool>("forceBestTrackEmbedding", true)
       ->setComment(
           "force embedding separately the best tracks even if they're already embedded e.g. as tracker or global "
           "tracks");
   iDesc.add<bool>("embedTrack", true)->setComment("embed external track");
   iDesc.add<bool>("embedStandAloneMuon", true)->setComment("embed external stand-alone muon");
   iDesc.add<bool>("embedCombinedMuon", false)->setComment("embed external combined muon");
   iDesc.add<bool>("embedPickyMuon", false)->setComment("embed external picky track");
   iDesc.add<bool>("embedTpfmsMuon", false)->setComment("embed external tpfms track");
   iDesc.add<bool>("embedDytMuon", false)->setComment("embed external dyt track ");
 
   // embedding of MET muon corrections
   iDesc.add<bool>("embedCaloMETMuonCorrs", true)->setComment("whether to add MET muon correction for caloMET or not");
   iDesc.add<edm::InputTag>("caloMETMuonCorrs", edm::InputTag("muonMETValueMapProducer", "muCorrData"))
       ->setComment("source of MET muon corrections for caloMET");
   iDesc.add<bool>("embedTcMETMuonCorrs", true)->setComment("whether to add MET muon correction for tcMET or not");
   iDesc.add<edm::InputTag>("tcMETMuonCorrs", edm::InputTag("muonTCMETValueMapProducer", "muCorrData"))
       ->setComment("source of MET muon corrections for tcMET");
 
   // pf specific parameters
   iDesc.add<edm::InputTag>("pfMuonSource", edm::InputTag("pfMuons"))->setComment("particle flow input collection");
   iDesc.add<bool>("useParticleFlow", false)->setComment("whether to use particle flow or not");
   iDesc.add<bool>("embedPFCandidate", false)->setComment("embed external particle flow object");
   iDesc.add<bool>("embedPfEcalEnergy", true)->setComment("add ecal energy as reconstructed by PF");
 
   // inverse beta computation
   iDesc.add<bool>("addInverseBeta", true)->setComment("add combined inverse beta");
   iDesc.add<edm::InputTag>("sourceInverseBeta", edm::InputTag("muons", "combined"))
       ->setComment("source of inverse beta values");
 
   // MC matching configurables
   iDesc.add<bool>("addGenMatch", true)->setComment("add MC matching");
   iDesc.add<bool>("embedGenMatch", false)->setComment("embed MC matched MC information");
   std::vector<edm::InputTag> emptySourceVector;
   iDesc
       .addNode(edm::ParameterDescription<edm::InputTag>("genParticleMatch", edm::InputTag(), true) xor
                edm::ParameterDescription<std::vector<edm::InputTag>>("genParticleMatch", emptySourceVector, true))
       ->setComment("input with MC match information");
 
   // mini-iso
   iDesc.add<bool>("computeMiniIso", false)->setComment("whether or not to compute and store electron mini-isolation");
   iDesc.add<bool>("computePuppiCombinedIso", false)
       ->setComment("whether or not to compute and store puppi combined isolation");
 
   iDesc.add<edm::InputTag>("pfCandsForMiniIso", edm::InputTag("packedPFCandidates"))
       ->setComment("collection to use to compute mini-iso");
   iDesc.add<std::vector<double>>("miniIsoParams", std::vector<double>())
       ->setComment("mini-iso parameters to use for muons");
 
   iDesc.add<bool>("addTriggerMatching", false)->setComment("add L1 and HLT matching to offline muon");
 
   pat::helper::KinResolutionsLoader::fillDescription(iDesc);
 
   // IsoDeposit configurables
   edm::ParameterSetDescription isoDepositsPSet;
   isoDepositsPSet.addOptional<edm::InputTag>("tracker");
   isoDepositsPSet.addOptional<edm::InputTag>("ecal");
   isoDepositsPSet.addOptional<edm::InputTag>("hcal");
   isoDepositsPSet.addOptional<edm::InputTag>("particle");
   isoDepositsPSet.addOptional<edm::InputTag>("pfChargedHadrons");
   isoDepositsPSet.addOptional<edm::InputTag>("pfChargedAll");
   isoDepositsPSet.addOptional<edm::InputTag>("pfPUChargedHadrons");
   isoDepositsPSet.addOptional<edm::InputTag>("pfNeutralHadrons");
   isoDepositsPSet.addOptional<edm::InputTag>("pfPhotons");
   isoDepositsPSet.addOptional<std::vector<edm::InputTag>>("user");
   iDesc.addOptional("isoDeposits", isoDepositsPSet);
 
   // isolation values configurables
   edm::ParameterSetDescription isolationValuesPSet;
   isolationValuesPSet.addOptional<edm::InputTag>("tracker");
   isolationValuesPSet.addOptional<edm::InputTag>("ecal");
   isolationValuesPSet.addOptional<edm::InputTag>("hcal");
   isolationValuesPSet.addOptional<edm::InputTag>("particle");
   isolationValuesPSet.addOptional<edm::InputTag>("pfChargedHadrons");
   isolationValuesPSet.addOptional<edm::InputTag>("pfChargedAll");
   isolationValuesPSet.addOptional<edm::InputTag>("pfPUChargedHadrons");
   isolationValuesPSet.addOptional<edm::InputTag>("pfNeutralHadrons");
   isolationValuesPSet.addOptional<edm::InputTag>("pfPhotons");
   iDesc.addOptional("isolationValues", isolationValuesPSet);
 
   iDesc.ifValue(edm::ParameterDescription<bool>("addPuppiIsolation", false, true),
                 true >> (edm::ParameterDescription<edm::InputTag>(
                              "puppiIsolationChargedHadrons",
                              edm::InputTag("muonPUPPIIsolation", "h+-DR030-ThresholdVeto000-ConeVeto000"),
                              true) and
                          edm::ParameterDescription<edm::InputTag>(
                              "puppiIsolationNeutralHadrons",
                              edm::InputTag("muonPUPPIIsolation", "h0-DR030-ThresholdVeto000-ConeVeto001"),
                              true) and
                          edm::ParameterDescription<edm::InputTag>(
                              "puppiIsolationPhotons",
                              edm::InputTag("muonPUPPIIsolation", "gamma-DR030-ThresholdVeto000-ConeVeto001"),
                              true) and
                          edm::ParameterDescription<edm::InputTag>(
                              "puppiNoLeptonsIsolationChargedHadrons",
                              edm::InputTag("muonPUPPINoLeptonsIsolation", "h+-DR030-ThresholdVeto000-ConeVeto000"),
                              true) and
                          edm::ParameterDescription<edm::InputTag>(
                              "puppiNoLeptonsIsolationNeutralHadrons",
                              edm::InputTag("muonPUPPINoLeptonsIsolation", "h0-DR030-ThresholdVeto000-ConeVeto001"),
                              true) and
                          edm::ParameterDescription<edm::InputTag>(
                              "puppiNoLeptonsIsolationPhotons",
                              edm::InputTag("muonPUPPINoLeptonsIsolation", "gamma-DR030-ThresholdVeto000-ConeVeto001"),
                              true)) or
                     false >> edm::EmptyGroupDescription());
 
   // Efficiency configurables
   edm::ParameterSetDescription efficienciesPSet;
   efficienciesPSet.setAllowAnything();  // TODO: the pat helper needs to implement a description.
   iDesc.add("efficiencies", efficienciesPSet);
   iDesc.add<bool>("addEfficiencies", false);
 
   // Check to see if the user wants to add user data
   edm::ParameterSetDescription userDataPSet;
   PATUserDataHelper<Muon>::fillDescription(userDataPSet);
   iDesc.addOptional("userData", userDataPSet);
 
   edm::ParameterSetDescription isolationPSet;
   isolationPSet.setAllowAnything();  // TODO: the pat helper needs to implement a description.
   iDesc.add("userIsolation", isolationPSet);
 
   iDesc.add<bool>("embedHighLevelSelection", true)->setComment("embed high level selection");
   edm::ParameterSetDescription highLevelPSet;
   highLevelPSet.setAllowAnything();
   iDesc.addNode(edm::ParameterDescription<edm::InputTag>("beamLineSrc", edm::InputTag(), true))
       ->setComment("input with high level selection");
   iDesc.addNode(edm::ParameterDescription<edm::InputTag>("pvSrc", edm::InputTag(), true))
       ->setComment("input with high level selection");
 
   //descriptions.add("PATMuonProducer", iDesc);
 }

◆ fillHltTriggerInfo()

void PATMuonProducer::fillHltTriggerInfo	(	pat::Muon &	muon,
		edm::Handle< std::vector< pat::TriggerObjectStandAlone >> &	triggerObjects,
		const edm::TriggerNames &	names,
		const std::vector< std::string > &	collection_names
	)

private

Definition at line 560 of file PATMuonProducer.cc.

References PbPb_ZMuSkimMuonDPG_cff::deltaR, HLT_2023v12_cff::muon, Skims_PA_cff::name, names, getGTfromDQMFile::obj, trigger::TriggerMuon, and triggerMatchMonitor_cfi::triggerObjects.

Referenced by produce().

                                                                                               {
   // WARNING: in a case of close-by muons the dR matching may select both muons.
   // It's better to select the best match for a given collection.
   for (const auto& triggerObject : *triggerObjects) {
     if (triggerObject.hasTriggerObjectType(trigger::TriggerMuon)) {
       bool keepIt = false;
       for (const auto& name : collection_filter_names) {
         if (triggerObject.hasCollection(name)) {
           keepIt = true;
           break;
         }
       }
       if (not keepIt)
         continue;
       if (deltaR(triggerObject.p4(), muon) > 0.1)
         continue;
       pat::TriggerObjectStandAlone obj(triggerObject);
       obj.unpackPathNames(names);
       muon.addTriggerObjectMatch(obj);
     }
   }
 }

◆ fillL1TriggerInfo()

void PATMuonProducer::fillL1TriggerInfo	(	pat::Muon &	muon,
		edm::Handle< std::vector< pat::TriggerObjectStandAlone >> &	triggerObjects,
		const edm::TriggerNames &	names,
		const edm::ESHandle< GlobalTrackingGeometry > &	geometry
	)

private

Definition at line 508 of file PATMuonProducer.cc.

References funct::abs(), pat::PATObject< ObjectType >::addTriggerObjectMatch(), MuonSubdetId::CSC, SiPixelRawToDigiRegional_cfi::deltaPhi, PbPb_ZMuSkimMuonDPG_cff::deltaR, hcalRecHitTable_cff::detId, MuonSubdetId::DT, getMuonDirection(), reco::Muon::matches(), names, getGTfromDQMFile::obj, trigger::TriggerL1Mu, and triggerMatchMonitor_cfi::triggerObjects.

Referenced by produce().

                                                                                              {
   // L1 trigger object parameters are defined at MB2/ME2. Use the muon
   // chamber matching information to get the local direction of the
   // muon trajectory and convert it to a global direction to match the
   // trigger objects
 
   std::optional<GlobalPoint> muonPosition;
   // Loop over chambers
   // initialize muonPosition with any available match, just in case
   // the second station is missing - it's better folling back to
   // dR matching at IP
   for (const auto& chamberMatch : aMuon.matches()) {
     if (chamberMatch.id.subdetId() == MuonSubdetId::DT) {
       DTChamberId detId(chamberMatch.id.rawId());
       if (abs(detId.station()) > 3)
         continue;
       muonPosition = getMuonDirection(chamberMatch, geometry, detId);
       if (abs(detId.station()) == 2)
         break;
     }
     if (chamberMatch.id.subdetId() == MuonSubdetId::CSC) {
       CSCDetId detId(chamberMatch.id.rawId());
       if (abs(detId.station()) > 3)
         continue;
       muonPosition = getMuonDirection(chamberMatch, geometry, detId);
       if (abs(detId.station()) == 2)
         break;
     }
   }
   if (not muonPosition)
     return;
   for (const auto& triggerObject : *triggerObjects) {
     if (triggerObject.hasTriggerObjectType(trigger::TriggerL1Mu)) {
       if (std::abs(triggerObject.eta()) < 0.001) {
         // L1 is defined in X-Y plain
         if (deltaPhi(triggerObject.phi(), muonPosition->phi()) > 0.1)
           continue;
       } else {
         // 3D L1
         if (deltaR(triggerObject.p4(), *muonPosition) > 0.15)
           continue;
       }
       pat::TriggerObjectStandAlone obj(triggerObject);
       obj.unpackPathNames(names);
       aMuon.addTriggerObjectMatch(obj);
     }
   }
 }

◆ fillMuon()

void PATMuonProducer::fillMuon	(	Muon &	aMuon,
		const MuonBaseRef &	muonRef,
		const reco::CandidateBaseRef &	baseRef,
		const GenAssociations &	genMatches,
		const IsoDepositMaps &	deposits,
		const IsolationValueMaps &	isolationValues
	)		const

private

common muon filling, for both the standard and PF2PAT case

Definition at line 1039 of file PATMuonProducer.cc.

References addGenMatch_, pat::PATObject< ObjectType >::addGenParticleRef(), edm::contains(), CandIsolatorFromDeposits_cfi::deposits, reco::Muon::DYT, efficiencyLoader_, embedBestTrack_, pat::Muon::embedCombinedMuon(), embedCombinedMuon_, pat::Muon::embedDytMuon(), embedDytMuon_, embedGenMatch_, pat::PATObject< ObjectType >::embedGenParticle(), pat::Muon::embedMuonBestTrack(), pat::Muon::embedPickyMuon(), embedPickyMuon_, pat::Muon::embedStandAloneMuon(), embedStandAloneMuon_, pat::Muon::embedTpfmsMuon(), embedTpfmsMuon_, pat::Muon::embedTrack(), embedTrack_, embedTunePBestTrack_, pat::Muon::embedTunePMuonBestTrack(), pat::helper::EfficiencyLoader::enabled(), pat::helper::KinResolutionsLoader::enabled(), dqmdumpme::first, forceEmbedBestTrack_, TtFullHadEvtBuilder_cfi::genMatch, edm::RefToBase< T >::id(), reco::Muon::isAValidMuonTrack(), reco::Muon::isGlobalMuon(), isoDepositLabels_, isolationValueLabels_, displacedMuonProducer_cff::isolationValues, dqmiolumiharvest::j, pat::Muon::pfCandidateRef(), reco::Muon::Picky, resolutionLoader_, pat::helper::EfficiencyLoader::setEfficiencies(), pat::Lepton< LeptonType >::setIsoDeposit(), pat::Lepton< LeptonType >::setIsolation(), reco::LeafCandidate::setP4(), pat::helper::KinResolutionsLoader::setResolutions(), source, reco::Muon::TPFMS, and useParticleFlow_.

Referenced by produce().

                                                                                 {
   // in the particle flow algorithm,
   // the muon momentum is recomputed.
   // the new value is stored as the momentum of the
   // resulting PFCandidate of type Muon, and choosen
   // as the pat::Muon momentum
   if (useParticleFlow_)
     aMuon.setP4(aMuon.pfCandidateRef()->p4());
   if (embedTrack_)
     aMuon.embedTrack();
   if (embedStandAloneMuon_)
     aMuon.embedStandAloneMuon();
   if (embedCombinedMuon_)
     aMuon.embedCombinedMuon();
 
   // embed the TeV refit track refs (only available for globalMuons)
   if (aMuon.isGlobalMuon()) {
     if (embedPickyMuon_ && aMuon.isAValidMuonTrack(reco::Muon::Picky))
       aMuon.embedPickyMuon();
     if (embedTpfmsMuon_ && aMuon.isAValidMuonTrack(reco::Muon::TPFMS))
       aMuon.embedTpfmsMuon();
     if (embedDytMuon_ && aMuon.isAValidMuonTrack(reco::Muon::DYT))
       aMuon.embedDytMuon();
   }
 
   // embed best tracks (at the end, so unless forceEmbedBestTrack_ is true we can save some space not embedding them twice)
   if (embedBestTrack_)
     aMuon.embedMuonBestTrack(forceEmbedBestTrack_);
   if (embedTunePBestTrack_)
     aMuon.embedTunePMuonBestTrack(forceEmbedBestTrack_);
 
   // store the match to the generated final state muons
   if (addGenMatch_) {
     for (auto const& genMatch : genMatches) {
       reco::GenParticleRef genMuon = (*genMatch)[baseRef];
       aMuon.addGenParticleRef(genMuon);
     }
     if (embedGenMatch_)
       aMuon.embedGenParticle();
   }
   if (efficiencyLoader_.enabled()) {
     efficiencyLoader_.setEfficiencies(aMuon, muonRef);
   }
 
   for (size_t j = 0, nd = deposits.size(); j < nd; ++j) {
     if (useParticleFlow_) {
       if (deposits[j]->contains(baseRef.id())) {
         aMuon.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[baseRef]);
       } else if (deposits[j]->contains(muonRef.id())) {
         aMuon.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[muonRef]);
       } else {
         reco::CandidatePtr source = aMuon.pfCandidateRef()->sourceCandidatePtr(0);
         aMuon.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[source]);
       }
     } else {
       aMuon.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[muonRef]);
     }
   }
 
   for (size_t j = 0; j < isolationValues.size(); ++j) {
     if (useParticleFlow_) {
       if (isolationValues[j]->contains(baseRef.id())) {
         aMuon.setIsolation(isolationValueLabels_[j].first, (*isolationValues[j])[baseRef]);
       } else if (isolationValues[j]->contains(muonRef.id())) {
         aMuon.setIsolation(isolationValueLabels_[j].first, (*isolationValues[j])[muonRef]);
       } else {
         reco::CandidatePtr source = aMuon.pfCandidateRef()->sourceCandidatePtr(0);
         aMuon.setIsolation(isolationValueLabels_[j].first, (*isolationValues[j])[source]);
       }
     } else {
       aMuon.setIsolation(isolationValueLabels_[j].first, (*isolationValues[j])[muonRef]);
     }
   }
 
   if (resolutionLoader_.enabled()) {
     resolutionLoader_.setResolutions(aMuon);
   }
 }

◆ getMuonDirection()

std::optional< GlobalPoint > PATMuonProducer::getMuonDirection	(	const reco::MuonChamberMatch &	chamberMatch,
		const edm::ESHandle< GlobalTrackingGeometry > &	geometry,
		const DetId &	chamberId
	)

private

Definition at line 497 of file PATMuonProducer.cc.

References GeomDet::toGlobal(), reco::MuonChamberMatch::x, and reco::MuonChamberMatch::y.

Referenced by fillL1TriggerInfo().

                                                                                      {
   const GeomDet* chamberGeometry = geometry->idToDet(chamberId);
   if (chamberGeometry) {
     LocalPoint localPosition(chamberMatch.x, chamberMatch.y, 0);
     return std::optional<GlobalPoint>(std::in_place, chamberGeometry->toGlobal(localPosition));
   }
   return std::optional<GlobalPoint>();
 }

◆ getRelMiniIsoPUCorrected()

double PATMuonProducer::getRelMiniIsoPUCorrected	(	const pat::Muon &	muon,
		double	rho,
		const std::vector< double > &	area
	)

private

Definition at line 1138 of file PATMuonProducer.cc.

References custom_jme_cff::area, MTVHistoProducerAlgoForTrackerBlock_cfi::maxdr, MTVHistoProducerAlgoForTrackerBlock_cfi::mindr, pat::miniIsoDr(), miniIsoParams_, and pat::muonRelMiniIsoPUCorrected().

Referenced by produce().

                                                                                                                {
   double mindr(miniIsoParams_[0]);
   double maxdr(miniIsoParams_[1]);
   double kt_scale(miniIsoParams_[2]);
   double drcut = pat::miniIsoDr(muon.polarP4(), mindr, maxdr, kt_scale);
   return pat::muonRelMiniIsoPUCorrected(muon.miniPFIsolation(), muon.polarP4(), drcut, rho, area);
 }

◆ globalEndJob()

static void pat::PATMuonProducer::globalEndJob ( PATMuonHeavyObjectCache * )

inlinestatic

Definition at line 89 of file PATMuonProducer.cc.

89 {}

◆ initializeGlobalCache()

static std::unique_ptr<PATMuonHeavyObjectCache> pat::PATMuonProducer::initializeGlobalCache ( const edm::ParameterSet & iConfig )

inlinestatic

Definition at line 85 of file PATMuonProducer.cc.

                                                                                                         {
       return std::make_unique<PATMuonHeavyObjectCache>(iConfig);
     }

◆ isChargedHadron()

bool PATMuonProducer::isChargedHadron ( long pdgid )

private

Definition at line 1198 of file PATMuonProducer.cc.

References funct::abs(), and EgammaValidation_cff::pdgid.

Referenced by puppiCombinedIsolation().

1198 { return std::abs(pdgid) == 211; }

EgammaValidation_cff.pdgid

pdgid

Definition: EgammaValidation_cff.py:29

funct::abs

Abs< T >::type abs(const T &t)

Definition: Abs.h:22

◆ isNeutralHadron()

bool PATMuonProducer::isNeutralHadron ( long pdgid )

private

Definition at line 1196 of file PATMuonProducer.cc.

References funct::abs(), and EgammaValidation_cff::pdgid.

Referenced by puppiCombinedIsolation().

1196 { return std::abs(pdgid) == 130; }

EgammaValidation_cff.pdgid

pdgid

Definition: EgammaValidation_cff.py:29

funct::abs

Abs< T >::type abs(const T &t)

Definition: Abs.h:22

◆ isPhoton()

bool PATMuonProducer::isPhoton ( long pdgid )

private

Definition at line 1200 of file PATMuonProducer.cc.

References EgammaValidation_cff::pdgid.

Referenced by puppiCombinedIsolation().

1200 { return pdgid == 22; }

EgammaValidation_cff.pdgid

pdgid

Definition: EgammaValidation_cff.py:29

◆ produce()

void PATMuonProducer::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

override

everything that needs to be done during the event loop

Definition at line 586 of file PATMuonProducer.cc.

                                                                            {
   // get the tracking Geometry
   auto geometry = iSetup.getHandle(geometryToken_);
   if (!geometry.isValid())
     throw cms::Exception("FatalError") << "Unable to find GlobalTrackingGeometryRecord in event!\n";
 
   // switch off embedding (in unschedules mode)
   if (iEvent.isRealData()) {
     addGenMatch_ = false;
     embedGenMatch_ = false;
   }
 
   edm::Handle<edm::View<reco::Muon>> muons;
   iEvent.getByToken(muonToken_, muons);
 
   edm::Handle<pat::PackedCandidateCollection> pc;
   if (computeMiniIso_ || computePuppiCombinedIso_)
     iEvent.getByToken(pcToken_, pc);
 
   // get the ESHandle for the transient track builder,
   // if needed for high level selection embedding
   TransientTrackBuilder const* trackBuilder = nullptr;
 
   if (isolator_.enabled())
     isolator_.beginEvent(iEvent, iSetup);
   if (efficiencyLoader_.enabled())
     efficiencyLoader_.newEvent(iEvent);
   if (resolutionLoader_.enabled())
     resolutionLoader_.newEvent(iEvent, iSetup);
 
   IsoDepositMaps deposits(isoDepositTokens_.size());
   for (size_t j = 0; j < isoDepositTokens_.size(); ++j) {
     iEvent.getByToken(isoDepositTokens_[j], deposits[j]);
   }
 
   IsolationValueMaps isolationValues(isolationValueTokens_.size());
   for (size_t j = 0; j < isolationValueTokens_.size(); ++j) {
     iEvent.getByToken(isolationValueTokens_[j], isolationValues[j]);
   }
 
   //value maps for puppi isolation
   edm::Handle<edm::ValueMap<float>> PUPPIIsolation_charged_hadrons;
   edm::Handle<edm::ValueMap<float>> PUPPIIsolation_neutral_hadrons;
   edm::Handle<edm::ValueMap<float>> PUPPIIsolation_photons;
   //value maps for puppiNoLeptons isolation
   edm::Handle<edm::ValueMap<float>> PUPPINoLeptonsIsolation_charged_hadrons;
   edm::Handle<edm::ValueMap<float>> PUPPINoLeptonsIsolation_neutral_hadrons;
   edm::Handle<edm::ValueMap<float>> PUPPINoLeptonsIsolation_photons;
   if (addPuppiIsolation_) {
     //puppi
     iEvent.getByToken(PUPPIIsolation_charged_hadrons_, PUPPIIsolation_charged_hadrons);
     iEvent.getByToken(PUPPIIsolation_neutral_hadrons_, PUPPIIsolation_neutral_hadrons);
     iEvent.getByToken(PUPPIIsolation_photons_, PUPPIIsolation_photons);
     //puppiNoLeptons
     iEvent.getByToken(PUPPINoLeptonsIsolation_charged_hadrons_, PUPPINoLeptonsIsolation_charged_hadrons);
     iEvent.getByToken(PUPPINoLeptonsIsolation_neutral_hadrons_, PUPPINoLeptonsIsolation_neutral_hadrons);
     iEvent.getByToken(PUPPINoLeptonsIsolation_photons_, PUPPINoLeptonsIsolation_photons);
   }
 
   // inputs for muon mva
   edm::Handle<reco::JetTagCollection> mvaBTagCollectionTag;
   edm::Handle<reco::JetCorrector> mvaL1Corrector;
   edm::Handle<reco::JetCorrector> mvaL1L2L3ResCorrector;
   if (computeMiniIso_) {
     iEvent.getByToken(mvaBTagCollectionTag_, mvaBTagCollectionTag);
     iEvent.getByToken(mvaL1Corrector_, mvaL1Corrector);
     iEvent.getByToken(mvaL1L2L3ResCorrector_, mvaL1L2L3ResCorrector);
   }
 
   // prepare the MC genMatchTokens_
   GenAssociations genMatches(genMatchTokens_.size());
   if (addGenMatch_) {
     for (size_t j = 0, nd = genMatchTokens_.size(); j < nd; ++j) {
       iEvent.getByToken(genMatchTokens_[j], genMatches[j]);
     }
   }
 
   // prepare the high level selection: needs beamline
   // OR primary vertex, depending on user selection
   reco::Vertex primaryVertex;
   reco::BeamSpot beamSpot;
   bool beamSpotIsValid = false;
   bool primaryVertexIsValid = false;
   if (embedHighLevelSelection_) {
     // get the beamspot
     edm::Handle<reco::BeamSpot> beamSpotHandle;
     iEvent.getByToken(beamLineToken_, beamSpotHandle);
 
     // get the primary vertex
     edm::Handle<std::vector<reco::Vertex>> pvHandle;
     iEvent.getByToken(pvToken_, pvHandle);
 
     if (beamSpotHandle.isValid()) {
       beamSpot = *beamSpotHandle;
       beamSpotIsValid = true;
     } else {
       edm::LogError("DataNotAvailable") << "No beam spot available from EventSetup, not adding high level selection \n";
     }
     if (pvHandle.isValid() && !pvHandle->empty()) {
       primaryVertex = pvHandle->at(0);
       primaryVertexIsValid = true;
     } else {
       edm::LogError("DataNotAvailable")
           << "No primary vertex available from EventSetup, not adding high level selection \n";
     }
     // this is needed by the IPTools methods from the tracking group
     trackBuilder = &iSetup.getData(transientTrackBuilderToken_);
   }
 
   // MC info
   edm::Handle<edm::ValueMap<reco::MuonSimInfo>> simInfo;
   bool simInfoIsAvailalbe = iEvent.getByToken(simInfo_, simInfo);
 
   // this will be the new object collection
   std::vector<Muon> patMuons;
 
   edm::Handle<reco::PFCandidateCollection> pfMuons;
   if (useParticleFlow_) {
     // get the PFCandidates of type muons
     iEvent.getByToken(pfMuonToken_, pfMuons);
 
     unsigned index = 0;
     for (reco::PFCandidateConstIterator i = pfMuons->begin(); i != pfMuons->end(); ++i, ++index) {
       const reco::PFCandidate& pfmu = *i;
       //const reco::IsolaPFCandidate& pfmu = *i;
       const reco::MuonRef& muonRef = pfmu.muonRef();
       assert(muonRef.isNonnull());
 
       MuonBaseRef muonBaseRef(muonRef);
       Muon aMuon(muonBaseRef);
 
       if (useUserData_) {
         userDataHelper_.add(aMuon, iEvent, iSetup);
       }
 
       // embed high level selection
       if (embedHighLevelSelection_) {
         // get the tracks
         reco::TrackRef innerTrack = muonBaseRef->innerTrack();
         reco::TrackRef globalTrack = muonBaseRef->globalTrack();
         reco::TrackRef bestTrack = muonBaseRef->muonBestTrack();
         reco::TrackRef chosenTrack = innerTrack;
         // Make sure the collection it points to is there
         if (bestTrack.isNonnull() && bestTrack.isAvailable())
           chosenTrack = bestTrack;
 
         if (chosenTrack.isNonnull() && chosenTrack.isAvailable()) {
           unsigned int nhits = chosenTrack->numberOfValidHits();  // ????
           aMuon.setNumberOfValidHits(nhits);
 
           reco::TransientTrack tt = trackBuilder->build(chosenTrack);
           embedHighLevel(aMuon, chosenTrack, tt, primaryVertex, primaryVertexIsValid, beamSpot, beamSpotIsValid);
         }
 
         if (globalTrack.isNonnull() && globalTrack.isAvailable() && !embedCombinedMuon_) {
           double norm_chi2 = globalTrack->chi2() / globalTrack->ndof();
           aMuon.setNormChi2(norm_chi2);
         }
       }
       reco::PFCandidateRef pfRef(pfMuons, index);
       //reco::PFCandidatePtr ptrToMother(pfMuons,index);
       reco::CandidateBaseRef pfBaseRef(pfRef);
 
       aMuon.setPFCandidateRef(pfRef);
       if (embedPFCandidate_)
         aMuon.embedPFCandidate();
       fillMuon(aMuon, muonBaseRef, pfBaseRef, genMatches, deposits, isolationValues);
 
       if (computeMiniIso_)
         setMuonMiniIso(aMuon, pc.product());
 
       if (addPuppiIsolation_) {
         aMuon.setIsolationPUPPI((*PUPPIIsolation_charged_hadrons)[muonBaseRef],
                                 (*PUPPIIsolation_neutral_hadrons)[muonBaseRef],
                                 (*PUPPIIsolation_photons)[muonBaseRef]);
 
         aMuon.setIsolationPUPPINoLeptons((*PUPPINoLeptonsIsolation_charged_hadrons)[muonBaseRef],
                                          (*PUPPINoLeptonsIsolation_neutral_hadrons)[muonBaseRef],
                                          (*PUPPINoLeptonsIsolation_photons)[muonBaseRef]);
       } else {
         aMuon.setIsolationPUPPI(-999., -999., -999.);
         aMuon.setIsolationPUPPINoLeptons(-999., -999., -999.);
       }
 
       if (embedPfEcalEnergy_) {
         aMuon.setPfEcalEnergy(pfmu.ecalEnergy());
       }
 
       patMuons.push_back(aMuon);
     }
   } else {
     edm::Handle<edm::View<reco::Muon>> muons;
     iEvent.getByToken(muonToken_, muons);
 
     // embedding of muon MET corrections
     edm::Handle<edm::ValueMap<reco::MuonMETCorrectionData>> caloMETMuonCorrs;
     //edm::ValueMap<reco::MuonMETCorrectionData> caloMETmuCorValueMap;
     if (embedCaloMETMuonCorrs_) {
       iEvent.getByToken(caloMETMuonCorrsToken_, caloMETMuonCorrs);
       //caloMETmuCorValueMap  = *caloMETmuCorValueMap_h;
     }
     edm::Handle<edm::ValueMap<reco::MuonMETCorrectionData>> tcMETMuonCorrs;
     //edm::ValueMap<reco::MuonMETCorrectionData> tcMETmuCorValueMap;
     if (embedTcMETMuonCorrs_) {
       iEvent.getByToken(tcMETMuonCorrsToken_, tcMETMuonCorrs);
       //tcMETmuCorValueMap  = *tcMETmuCorValueMap_h;
     }
 
     if (embedPfEcalEnergy_ || embedPFCandidate_) {
       // get the PFCandidates of type muons
       iEvent.getByToken(pfMuonToken_, pfMuons);
     }
 
     edm::Handle<edm::ValueMap<reco::MuonTimeExtra>> muonsTimeExtra;
     if (addInverseBeta_) {
       // get MuonTimerExtra value map
       iEvent.getByToken(muonTimeExtraToken_, muonsTimeExtra);
     }
 
     for (edm::View<reco::Muon>::const_iterator itMuon = muons->begin(); itMuon != muons->end(); ++itMuon) {
       // construct the Muon from the ref -> save ref to original object
       unsigned int idx = itMuon - muons->begin();
       MuonBaseRef muonRef = muons->refAt(idx);
       reco::CandidateBaseRef muonBaseRef(muonRef);
 
       Muon aMuon(muonRef);
       fillMuon(aMuon, muonRef, muonBaseRef, genMatches, deposits, isolationValues);
       if (computeMiniIso_)
         setMuonMiniIso(aMuon, pc.product());
       if (addPuppiIsolation_) {
         aMuon.setIsolationPUPPI((*PUPPIIsolation_charged_hadrons)[muonRef],
                                 (*PUPPIIsolation_neutral_hadrons)[muonRef],
                                 (*PUPPIIsolation_photons)[muonRef]);
         aMuon.setIsolationPUPPINoLeptons((*PUPPINoLeptonsIsolation_charged_hadrons)[muonRef],
                                          (*PUPPINoLeptonsIsolation_neutral_hadrons)[muonRef],
                                          (*PUPPINoLeptonsIsolation_photons)[muonRef]);
       } else {
         aMuon.setIsolationPUPPI(-999., -999., -999.);
         aMuon.setIsolationPUPPINoLeptons(-999., -999., -999.);
       }
 
       // Isolation
       if (isolator_.enabled()) {
         //reco::CandidatePtr mother =  ptrToMother->sourceCandidatePtr(0);
         isolator_.fill(*muons, idx, isolatorTmpStorage_);
         typedef pat::helper::MultiIsolator::IsolationValuePairs IsolationValuePairs;
         // better to loop backwards, so the vector is resized less times
         for (IsolationValuePairs::const_reverse_iterator it = isolatorTmpStorage_.rbegin(),
                                                          ed = isolatorTmpStorage_.rend();
              it != ed;
              ++it) {
           aMuon.setIsolation(it->first, it->second);
         }
       }
 
       //       for (size_t j = 0, nd = deposits.size(); j < nd; ++j) {
       //    aMuon.setIsoDeposit(isoDepositLabels_[j].first,
       //                (*deposits[j])[muonRef]);
       //       }
 
       // add sel to selected
       edm::Ptr<reco::Muon> muonsPtr = muons->ptrAt(idx);
       if (useUserData_) {
         userDataHelper_.add(aMuon, iEvent, iSetup);
       }
 
       // embed high level selection
       if (embedHighLevelSelection_) {
         // get the tracks
         reco::TrackRef innerTrack = itMuon->innerTrack();
         reco::TrackRef globalTrack = itMuon->globalTrack();
         reco::TrackRef bestTrack = itMuon->muonBestTrack();
         reco::TrackRef chosenTrack = innerTrack;
         // Make sure the collection it points to is there
         if (bestTrack.isNonnull() && bestTrack.isAvailable())
           chosenTrack = bestTrack;
         if (chosenTrack.isNonnull() && chosenTrack.isAvailable()) {
           unsigned int nhits = chosenTrack->numberOfValidHits();  // ????
           aMuon.setNumberOfValidHits(nhits);
 
           reco::TransientTrack tt = trackBuilder->build(chosenTrack);
           embedHighLevel(aMuon, chosenTrack, tt, primaryVertex, primaryVertexIsValid, beamSpot, beamSpotIsValid);
         }
 
         if (globalTrack.isNonnull() && globalTrack.isAvailable()) {
           double norm_chi2 = globalTrack->chi2() / globalTrack->ndof();
           aMuon.setNormChi2(norm_chi2);
         }
       }
 
       // embed MET muon corrections
       if (embedCaloMETMuonCorrs_)
         aMuon.embedCaloMETMuonCorrs((*caloMETMuonCorrs)[muonRef]);
       if (embedTcMETMuonCorrs_)
         aMuon.embedTcMETMuonCorrs((*tcMETMuonCorrs)[muonRef]);
 
       if (embedPfEcalEnergy_ || embedPFCandidate_) {
         if (embedPfEcalEnergy_)
           aMuon.setPfEcalEnergy(-99.0);
         unsigned index = 0;
         for (const reco::PFCandidate& pfmu : *pfMuons) {
           if (pfmu.muonRef().isNonnull()) {
             if (pfmu.muonRef().id() != muonRef.id())
               throw cms::Exception("Configuration")
                   << "Muon reference within PF candidates does not point to the muon collection." << std::endl;
             if (pfmu.muonRef().key() == muonRef.key()) {
               reco::PFCandidateRef pfRef(pfMuons, index);
               aMuon.setPFCandidateRef(pfRef);
               if (embedPfEcalEnergy_)
                 aMuon.setPfEcalEnergy(pfmu.ecalEnergy());
               if (embedPFCandidate_)
                 aMuon.embedPFCandidate();
               break;
             }
           }
           index++;
         }
       }
 
       if (addInverseBeta_) {
         aMuon.readTimeExtra((*muonsTimeExtra)[muonRef]);
       }
       // MC info
       aMuon.initSimInfo();
       if (simInfoIsAvailalbe) {
         const auto& msi = (*simInfo)[muonBaseRef];
         aMuon.setSimType(msi.primaryClass);
         aMuon.setExtSimType(msi.extendedClass);
         aMuon.setSimFlavour(msi.flavour);
         aMuon.setSimHeaviestMotherFlavour(msi.heaviestMotherFlavour);
         aMuon.setSimPdgId(msi.pdgId);
         aMuon.setSimMotherPdgId(msi.motherPdgId);
         aMuon.setSimBX(msi.tpBX);
         aMuon.setSimTpEvent(msi.tpEvent);
         aMuon.setSimProdRho(msi.vertex.Rho());
         aMuon.setSimProdZ(msi.vertex.Z());
         aMuon.setSimPt(msi.p4.pt());
         aMuon.setSimEta(msi.p4.eta());
         aMuon.setSimPhi(msi.p4.phi());
         aMuon.setSimMatchQuality(msi.tpAssoQuality);
       }
       patMuons.push_back(aMuon);
     }
   }
 
   // sort muons in pt
   std::sort(patMuons.begin(), patMuons.end(), [](auto const& t1, auto const& t2) { return t1.pt() > t2.pt(); });
 
   // Store standard muon selection decisions and jet related
   // quantaties.
   // Need a separate loop over muons to have all inputs properly
   // computed and stored in the object.
   edm::Handle<double> rho;
   if (computeMiniIso_)
     iEvent.getByToken(rho_, rho);
   const reco::Vertex* pv(nullptr);
   if (primaryVertexIsValid)
     pv = &primaryVertex;
 
   edm::Handle<std::vector<pat::TriggerObjectStandAlone>> triggerObjects;
   edm::Handle<edm::TriggerResults> triggerResults;
   bool triggerObjectsAvailable = false;
   bool triggerResultsAvailable = false;
   if (addTriggerMatching_) {
     triggerObjectsAvailable = iEvent.getByToken(triggerObjects_, triggerObjects);
     triggerResultsAvailable = iEvent.getByToken(triggerResults_, triggerResults);
   }
 
   for (auto& muon : patMuons) {
     // trigger info
     if (addTriggerMatching_ and triggerObjectsAvailable and triggerResultsAvailable) {
       const edm::TriggerNames& triggerNames(iEvent.triggerNames(*triggerResults));
       fillL1TriggerInfo(muon, triggerObjects, triggerNames, geometry);
       fillHltTriggerInfo(muon, triggerObjects, triggerNames, hltCollectionFilters_);
     }
 
     if (recomputeBasicSelectors_) {
       muon.setSelectors(0);
       bool isRun2016BCDEF = (272728 <= iEvent.run() && iEvent.run() <= 278808);
       muon.setSelectors(muon::makeSelectorBitset(muon, pv, isRun2016BCDEF));
     }
     float miniIsoValue = -1;
     if (computeMiniIso_) {
       // MiniIsolation working points
 
       miniIsoValue = getRelMiniIsoPUCorrected(muon, *rho, effectiveAreaVec_);
 
       muon.setSelector(reco::Muon::MiniIsoLoose, miniIsoValue < 0.40);
       muon.setSelector(reco::Muon::MiniIsoMedium, miniIsoValue < 0.20);
       muon.setSelector(reco::Muon::MiniIsoTight, miniIsoValue < 0.10);
       muon.setSelector(reco::Muon::MiniIsoVeryTight, miniIsoValue < 0.05);
     }
 
     double puppiCombinedIsolationPAT = -1;
     if (computePuppiCombinedIso_) {
       puppiCombinedIsolationPAT = puppiCombinedIsolation(muon, pc.product());
       muon.setSelector(reco::Muon::PuppiIsoLoose, puppiCombinedIsolationPAT < 0.27);
       muon.setSelector(reco::Muon::PuppiIsoMedium, puppiCombinedIsolationPAT < 0.22);
       muon.setSelector(reco::Muon::PuppiIsoTight, puppiCombinedIsolationPAT < 0.12);
     }
 
     std::array<float, 2> jetPtRatioRel = {{0.0, 0.0}};
     if (primaryVertexIsValid && computeMiniIso_) {
       if (useJec_) {
         jetPtRatioRel = globalCache()->calculatePtRatioRel().computePtRatioRel(
             muon, *(mvaBTagCollectionTag.product()), mvaL1Corrector.product(), mvaL1L2L3ResCorrector.product());
       } else {
         jetPtRatioRel = globalCache()->calculatePtRatioRel().computePtRatioRel(muon, *mvaBTagCollectionTag);
       }
 
       muon.setJetPtRatio(jetPtRatioRel[0]);
       muon.setJetPtRel(jetPtRatioRel[1]);
 
       // multi-isolation
       if (computeMiniIso_) {
         muon.setSelector(reco::Muon::MultiIsoMedium,
                          miniIsoValue < 0.11 && (muon.jetPtRatio() > 0.74 || muon.jetPtRel() > 6.8));
       }
     }
 
     // MVA ID
     float mvaID = 0.0;
     constexpr int MVAsentinelValue = -99;
     if (computeMuonIDMVA_) {
       if (muon.isLooseMuon()) {
         mvaID = globalCache()->muonMvaIDEstimator().computeMVAID(muon)[1];
       } else {
         mvaID = MVAsentinelValue;
       }
       muon.setMvaIDValue(mvaID);
       muon.setSelector(reco::Muon::MvaIDwpMedium, muon.mvaIDValue() > mvaIDmediumCut_);
       muon.setSelector(reco::Muon::MvaIDwpTight, muon.mvaIDValue() > mvaIDtightCut_);
     }
 
     //SOFT MVA
     if (computeSoftMuonMVA_) {
       float mva = globalCache()->softMuonMvaEstimator().computeMva(muon);
       muon.setSoftMvaValue(mva);
       //preselection in SoftMuonMvaEstimator.cc
       muon.setSelector(reco::Muon::SoftMvaId, muon.softMvaValue() > 0.58);  //WP choose for bmm4
 
       // run3 soft mva
       muon.setSoftMvaRun3Value(computeSoftMvaRun3(*softMuonMvaRun3Booster_, muon));
     }
   }
 
   // put products in Event
   iEvent.emplace(patMuonPutToken_, std::move(patMuons));
 
   if (isolator_.enabled())
     isolator_.endEvent();
 }

◆ puppiCombinedIsolation()

double PATMuonProducer::puppiCombinedIsolation	(	const pat::Muon &	muon,
		const pat::PackedCandidateCollection *	pc
	)

private

Definition at line 1146 of file PATMuonProducer.cc.

References funct::abs(), L1DTConfigBti_cff::CH, ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), reco::deltaPhi(), reco::deltaR2(), ALPAKA_ACCELERATOR_NAMESPACE::dR2(), isChargedHadron(), isNeutralHadron(), isPhoton(), LogTrace, makePlotsFromDump::NH, dqm::qstatus::OTHER, and PbPb_ZMuSkimMuonDPG_cff::particleType.

Referenced by produce().

                                                                                                           {
   constexpr double dR_threshold = 0.4;
   constexpr double dR2_threshold = dR_threshold * dR_threshold;
   constexpr double mix_fraction = 0.5;
   enum particleType { CH = 0, NH = 1, PH = 2, OTHER = 100000 };
   double val_PuppiWithLep = 0.0;
   double val_PuppiWithoutLep = 0.0;
 
   for (const auto& cand : *pc) {  //pat::pat::PackedCandidate loop start
 
     const particleType pType = isChargedHadron(cand.pdgId())   ? CH
                                : isNeutralHadron(cand.pdgId()) ? NH
                                : isPhoton(cand.pdgId())        ? PH
                                                                : OTHER;
     if (pType == OTHER) {
       if (cand.pdgId() != 1 && cand.pdgId() != 2 && abs(cand.pdgId()) != 11 && abs(cand.pdgId()) != 13) {
         LogTrace("PATMuonProducer") << "candidate with PDGID = " << cand.pdgId()
                                     << " is not CH/NH/PH/e/mu or 1/2 (and this is removed from isolation calculation)"
                                     << std::endl;
       }
       continue;
     }
     double d_eta = std::abs(cand.eta() - muon.eta());
     if (d_eta > dR_threshold)
       continue;
 
     double d_phi = std::abs(reco::deltaPhi(cand.phi(), muon.phi()));
     if (d_phi > dR_threshold)
       continue;
 
     double dR2 = reco::deltaR2(cand, muon);
     if (dR2 > dR2_threshold)
       continue;
     if (pType == CH && dR2 < 0.0001 * 0.0001)
       continue;
     if (pType == NH && dR2 < 0.01 * 0.01)
       continue;
     if (pType == PH && dR2 < 0.01 * 0.01)
       continue;
     val_PuppiWithLep += cand.pt() * cand.puppiWeight();
     val_PuppiWithoutLep += cand.pt() * cand.puppiWeightNoLep();
 
   }  //pat::pat::PackedCandidate loop end
 
   double reliso_Puppi_withLep = val_PuppiWithLep / muon.pt();
   double reliso_Puppi_withoutlep = val_PuppiWithoutLep / muon.pt();
   double reliso_Puppi_combined = mix_fraction * reliso_Puppi_withLep + (1.0 - mix_fraction) * reliso_Puppi_withoutlep;
   return reliso_Puppi_combined;
 }

◆ readIsolationLabels()

template<typename T >

void pat::PATMuonProducer::readIsolationLabels	(	const edm::ParameterSet &	iConfig,
		const char *	psetName,
		IsolationLabels &	labels,
		std::vector< edm::EDGetTokenT< edm::ValueMap< T >>> &	tokens
	)

private

fill label vector from the contents of the parameter set, for the embedding of isoDeposits or userIsolation values

Definition at line 277 of file PATMuonProducer.cc.

References pat::EcalIso, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), pat::HcalIso, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, submitPVResolutionJobs::key, label, SummaryClient_cfi::labels, pat::PfAllParticleIso, pat::PfChargedAllIso, pat::PfChargedHadronIso, pat::PfGammaIso, pat::PfNeutralHadronIso, pat::PfPUChargedHadronIso, crabTemplate::psetName, pat::TrackIso, pat::UserBaseIso, and edm::vector_transform().

                                                                                                   {
   labels.clear();
 
   if (iConfig.exists(psetName)) {
     edm::ParameterSet depconf = iConfig.getParameter<edm::ParameterSet>(psetName);
 
     if (depconf.exists("tracker"))
       labels.emplace_back(pat::TrackIso, depconf.getParameter<edm::InputTag>("tracker"));
     if (depconf.exists("ecal"))
       labels.emplace_back(pat::EcalIso, depconf.getParameter<edm::InputTag>("ecal"));
     if (depconf.exists("hcal"))
       labels.emplace_back(pat::HcalIso, depconf.getParameter<edm::InputTag>("hcal"));
     if (depconf.exists("pfAllParticles")) {
       labels.emplace_back(pat::PfAllParticleIso, depconf.getParameter<edm::InputTag>("pfAllParticles"));
     }
     if (depconf.exists("pfChargedHadrons")) {
       labels.emplace_back(pat::PfChargedHadronIso, depconf.getParameter<edm::InputTag>("pfChargedHadrons"));
     }
     if (depconf.exists("pfChargedAll")) {
       labels.emplace_back(pat::PfChargedAllIso, depconf.getParameter<edm::InputTag>("pfChargedAll"));
     }
     if (depconf.exists("pfPUChargedHadrons")) {
       labels.emplace_back(pat::PfPUChargedHadronIso, depconf.getParameter<edm::InputTag>("pfPUChargedHadrons"));
     }
     if (depconf.exists("pfNeutralHadrons")) {
       labels.emplace_back(pat::PfNeutralHadronIso, depconf.getParameter<edm::InputTag>("pfNeutralHadrons"));
     }
     if (depconf.exists("pfPhotons")) {
       labels.emplace_back(pat::PfGammaIso, depconf.getParameter<edm::InputTag>("pfPhotons"));
     }
     if (depconf.exists("user")) {
       std::vector<edm::InputTag> userdeps = depconf.getParameter<std::vector<edm::InputTag>>("user");
       std::vector<edm::InputTag>::const_iterator it = userdeps.begin(), ed = userdeps.end();
       int key = pat::IsolationKeys::UserBaseIso;
       for (; it != ed; ++it, ++key) {
         labels.push_back(std::make_pair(pat::IsolationKeys(key), *it));
       }
     }
   }
   tokens = edm::vector_transform(labels, [this](pat::PATMuonProducer::IsolationLabel const& label) {
     return consumes<edm::ValueMap<T>>(label.second);
   });
 }

◆ relMiniIsoPUCorrected()

double pat::PATMuonProducer::relMiniIsoPUCorrected	(	const pat::Muon &	aMuon,
		double	rho
	)

private

◆ setMuonMiniIso()

void PATMuonProducer::setMuonMiniIso	(	pat::Muon &	aMuon,
		const pat::PackedCandidateCollection *	pc
	)

private

Definition at line 1123 of file PATMuonProducer.cc.

References pat::getMiniPFIsolation(), miniIsoParams_, reco::LeafCandidate::polarP4(), and pat::Lepton< LeptonType >::setMiniPFIsolation().

Referenced by produce().

                                                                                      {
   pat::PFIsolation miniiso = pat::getMiniPFIsolation(pc,
                                                      aMuon.polarP4(),
                                                      miniIsoParams_[0],
                                                      miniIsoParams_[1],
                                                      miniIsoParams_[2],
                                                      miniIsoParams_[3],
                                                      miniIsoParams_[4],
                                                      miniIsoParams_[5],
                                                      miniIsoParams_[6],
                                                      miniIsoParams_[7],
                                                      miniIsoParams_[8]);
   aMuon.setMiniPFIsolation(miniiso);
 }

Member Data Documentation

◆ addEfficiencies_

bool pat::PATMuonProducer::addEfficiencies_

private

add efficiencies to the muon (this will be data members of th muon even w/o embedding)

Definition at line 223 of file PATMuonProducer.cc.

◆ addGenMatch_

bool pat::PATMuonProducer::addGenMatch_

private

add generator match information

Definition at line 195 of file PATMuonProducer.cc.

Referenced by fillMuon(), and produce().

◆ addInverseBeta_

bool pat::PATMuonProducer::addInverseBeta_

private

add combined inverse beta measurement into the muon

Definition at line 191 of file PATMuonProducer.cc.

Referenced by produce().

◆ addPuppiIsolation_

bool pat::PATMuonProducer::addPuppiIsolation_

private

add puppi isolation

Definition at line 229 of file PATMuonProducer.cc.

Referenced by produce().

◆ addResolutions_

bool pat::PATMuonProducer::addResolutions_

private

add resolutions to the muon (this will be data members of th muon even w/o embedding)

Definition at line 201 of file PATMuonProducer.cc.

◆ addTriggerMatching_

bool pat::PATMuonProducer::addTriggerMatching_

private

Trigger.

Definition at line 263 of file PATMuonProducer.cc.

Referenced by produce().

◆ beamLineToken_

edm::EDGetTokenT<reco::BeamSpot> pat::PATMuonProducer::beamLineToken_

private

input source of the primary vertex/beamspot

Definition at line 213 of file PATMuonProducer.cc.

Referenced by produce().

◆ caloMETMuonCorrsToken_

edm::EDGetTokenT<edm::ValueMap<reco::MuonMETCorrectionData> > pat::PATMuonProducer::caloMETMuonCorrsToken_

private

source of caloMET muon corrections

Definition at line 179 of file PATMuonProducer.cc.

Referenced by produce().

◆ computeMiniIso_

bool pat::PATMuonProducer::computeMiniIso_

private

Definition at line 156 of file PATMuonProducer.cc.

Referenced by produce().

◆ computeMuonIDMVA_

bool pat::PATMuonProducer::computeMuonIDMVA_

private

standard muon selectors

Definition at line 239 of file PATMuonProducer.cc.

Referenced by produce().

◆ computePuppiCombinedIso_

bool pat::PATMuonProducer::computePuppiCombinedIso_

private

Definition at line 157 of file PATMuonProducer.cc.

Referenced by produce().

◆ computeSoftMuonMVA_

bool pat::PATMuonProducer::computeSoftMuonMVA_

private

Definition at line 240 of file PATMuonProducer.cc.

Referenced by produce().

◆ effectiveAreaVec_

std::vector<double> pat::PATMuonProducer::effectiveAreaVec_

private

Definition at line 158 of file PATMuonProducer.cc.

Referenced by produce().

◆ efficiencyLoader_

pat::helper::EfficiencyLoader pat::PATMuonProducer::efficiencyLoader_

private

helper class to add efficiencies to the muon

Definition at line 255 of file PATMuonProducer.cc.

Referenced by fillMuon(), and produce().

◆ embedBestTrack_

bool pat::PATMuonProducer::embedBestTrack_

private

embed the track from best muon measurement (global pflow)

Definition at line 165 of file PATMuonProducer.cc.

Referenced by fillMuon().

◆ embedCaloMETMuonCorrs_

bool pat::PATMuonProducer::embedCaloMETMuonCorrs_

private

embed muon MET correction info for caloMET into the muon

Definition at line 177 of file PATMuonProducer.cc.

Referenced by produce().

◆ embedCombinedMuon_

bool pat::PATMuonProducer::embedCombinedMuon_

private

embed track of the combined fit into the muon

Definition at line 175 of file PATMuonProducer.cc.

Referenced by fillMuon(), and produce().

◆ embedDytMuon_

bool pat::PATMuonProducer::embedDytMuon_

private

embed track from DYT muon fit into the muon

Definition at line 189 of file PATMuonProducer.cc.

Referenced by fillMuon().

◆ embedGenMatch_

bool pat::PATMuonProducer::embedGenMatch_

private

embed the gen match information into the muon

Definition at line 199 of file PATMuonProducer.cc.

Referenced by fillMuon(), and produce().

◆ embedHighLevelSelection_

bool pat::PATMuonProducer::embedHighLevelSelection_

private

embed high level selection variables

Definition at line 211 of file PATMuonProducer.cc.

Referenced by produce().

◆ embedPFCandidate_

bool pat::PATMuonProducer::embedPFCandidate_

private

embed pfCandidates into the muon

Definition at line 209 of file PATMuonProducer.cc.

Referenced by produce().

◆ embedPfEcalEnergy_

bool pat::PATMuonProducer::embedPfEcalEnergy_

private

add ecal PF energy

Definition at line 227 of file PATMuonProducer.cc.

Referenced by produce().

◆ embedPickyMuon_

bool pat::PATMuonProducer::embedPickyMuon_

private

embed track from picky muon fit into the muon

Definition at line 185 of file PATMuonProducer.cc.

Referenced by fillMuon().

◆ embedStandAloneMuon_

bool pat::PATMuonProducer::embedStandAloneMuon_

private

embed track from muon system into the muon

Definition at line 173 of file PATMuonProducer.cc.

Referenced by fillMuon().

◆ embedTcMETMuonCorrs_

bool pat::PATMuonProducer::embedTcMETMuonCorrs_

private

embed muon MET correction info for tcMET into the muon

Definition at line 181 of file PATMuonProducer.cc.

Referenced by produce().

◆ embedTpfmsMuon_

bool pat::PATMuonProducer::embedTpfmsMuon_

private

embed track from tpfms muon fit into the muon

Definition at line 187 of file PATMuonProducer.cc.

Referenced by fillMuon().

◆ embedTrack_

bool pat::PATMuonProducer::embedTrack_

private

embed the track from inner tracker into the muon

Definition at line 171 of file PATMuonProducer.cc.

Referenced by fillMuon().

◆ embedTunePBestTrack_

bool pat::PATMuonProducer::embedTunePBestTrack_

private

embed the track from best muon measurement (muon only)

Definition at line 167 of file PATMuonProducer.cc.

Referenced by fillMuon().

◆ forceEmbedBestTrack_

bool pat::PATMuonProducer::forceEmbedBestTrack_

private

force separate embed of the best track even if already embedded

Definition at line 169 of file PATMuonProducer.cc.

Referenced by fillMuon().

◆ genMatchTokens_

std::vector<edm::EDGetTokenT<edm::Association<reco::GenParticleCollection> > > pat::PATMuonProducer::genMatchTokens_

private

input tags for generator match information

Definition at line 197 of file PATMuonProducer.cc.

Referenced by produce().

◆ geometryToken_

const edm::ESGetToken<GlobalTrackingGeometry, GlobalTrackingGeometryRecord> pat::PATMuonProducer::geometryToken_

private

Definition at line 268 of file PATMuonProducer.cc.

Referenced by produce().

◆ hltCollectionFilters_

std::vector<std::string> pat::PATMuonProducer::hltCollectionFilters_

private

Definition at line 266 of file PATMuonProducer.cc.

Referenced by produce().

◆ isoDepositLabels_

IsolationLabels pat::PATMuonProducer::isoDepositLabels_

private

input source for isoDeposits

Definition at line 217 of file PATMuonProducer.cc.

Referenced by fillMuon().

◆ isoDepositTokens_

std::vector<edm::EDGetTokenT<edm::ValueMap<IsoDeposit> > > pat::PATMuonProducer::isoDepositTokens_

private

Definition at line 218 of file PATMuonProducer.cc.

Referenced by produce().

◆ isolationValueLabels_

IsolationLabels pat::PATMuonProducer::isolationValueLabels_

private

input source isolation value maps

Definition at line 220 of file PATMuonProducer.cc.

Referenced by fillMuon().

◆ isolationValueTokens_

std::vector<edm::EDGetTokenT<edm::ValueMap<double> > > pat::PATMuonProducer::isolationValueTokens_

private

Definition at line 221 of file PATMuonProducer.cc.

Referenced by produce().

◆ isolator_

pat::helper::MultiIsolator pat::PATMuonProducer::isolator_

private

— tools — helper class to add userdefined isolation values to the muon

Definition at line 251 of file PATMuonProducer.cc.

Referenced by produce().

◆ isolatorTmpStorage_

pat::helper::MultiIsolator::IsolationValuePairs pat::PATMuonProducer::isolatorTmpStorage_

private

isolation value pair for temporary storage before being folded into the muon

Definition at line 253 of file PATMuonProducer.cc.

Referenced by produce().

◆ miniIsoParams_

std::vector<double> pat::PATMuonProducer::miniIsoParams_

private

Definition at line 159 of file PATMuonProducer.cc.

Referenced by getRelMiniIsoPUCorrected(), and setMuonMiniIso().

◆ muonTimeExtraToken_

edm::EDGetTokenT<edm::ValueMap<reco::MuonTimeExtra> > pat::PATMuonProducer::muonTimeExtraToken_

private

input tag for reading inverse beta

Definition at line 193 of file PATMuonProducer.cc.

Referenced by produce().

◆ muonToken_

edm::EDGetTokenT<edm::View<reco::Muon> > pat::PATMuonProducer::muonToken_

private

input source

Definition at line 152 of file PATMuonProducer.cc.

Referenced by produce().

◆ mvaBTagCollectionTag_

edm::EDGetTokenT<reco::JetTagCollection> pat::PATMuonProducer::mvaBTagCollectionTag_

private

Definition at line 244 of file PATMuonProducer.cc.

Referenced by produce().

◆ mvaIDmediumCut_

double pat::PATMuonProducer::mvaIDmediumCut_

private

Definition at line 163 of file PATMuonProducer.cc.

Referenced by produce().

◆ mvaIDtightCut_

double pat::PATMuonProducer::mvaIDtightCut_

private

working points of the muon MVA ID

Definition at line 162 of file PATMuonProducer.cc.

Referenced by produce().

◆ mvaL1Corrector_

edm::EDGetTokenT<reco::JetCorrector> pat::PATMuonProducer::mvaL1Corrector_

private

Definition at line 245 of file PATMuonProducer.cc.

Referenced by produce().

◆ mvaL1L2L3ResCorrector_

edm::EDGetTokenT<reco::JetCorrector> pat::PATMuonProducer::mvaL1L2L3ResCorrector_

private

Definition at line 246 of file PATMuonProducer.cc.

Referenced by produce().

◆ patMuonPutToken_

const edm::EDPutTokenT<std::vector<Muon> > pat::PATMuonProducer::patMuonPutToken_

private

Definition at line 271 of file PATMuonProducer.cc.

Referenced by produce().

◆ pcToken_

edm::EDGetTokenT<pat::PackedCandidateCollection> pat::PATMuonProducer::pcToken_

private

Definition at line 155 of file PATMuonProducer.cc.

Referenced by produce().

◆ pfMuonToken_

edm::EDGetTokenT<reco::PFCandidateCollection> pat::PATMuonProducer::pfMuonToken_

private

input source pfCandidates that will be to be transformed into pat::Muons, when using PF2PAT

Definition at line 207 of file PATMuonProducer.cc.

Referenced by produce().

◆ PUPPIIsolation_charged_hadrons_

edm::EDGetTokenT<edm::ValueMap<float> > pat::PATMuonProducer::PUPPIIsolation_charged_hadrons_

private

Definition at line 231 of file PATMuonProducer.cc.

Referenced by produce().

◆ PUPPIIsolation_neutral_hadrons_

edm::EDGetTokenT<edm::ValueMap<float> > pat::PATMuonProducer::PUPPIIsolation_neutral_hadrons_

private

Definition at line 232 of file PATMuonProducer.cc.

Referenced by produce().

◆ PUPPIIsolation_photons_

edm::EDGetTokenT<edm::ValueMap<float> > pat::PATMuonProducer::PUPPIIsolation_photons_

private

Definition at line 233 of file PATMuonProducer.cc.

Referenced by produce().

◆ PUPPINoLeptonsIsolation_charged_hadrons_

edm::EDGetTokenT<edm::ValueMap<float> > pat::PATMuonProducer::PUPPINoLeptonsIsolation_charged_hadrons_

private

Definition at line 235 of file PATMuonProducer.cc.

Referenced by produce().

◆ PUPPINoLeptonsIsolation_neutral_hadrons_

edm::EDGetTokenT<edm::ValueMap<float> > pat::PATMuonProducer::PUPPINoLeptonsIsolation_neutral_hadrons_

private

Definition at line 236 of file PATMuonProducer.cc.

Referenced by produce().

◆ PUPPINoLeptonsIsolation_photons_

edm::EDGetTokenT<edm::ValueMap<float> > pat::PATMuonProducer::PUPPINoLeptonsIsolation_photons_

private

Definition at line 237 of file PATMuonProducer.cc.

Referenced by produce().

◆ pvToken_

edm::EDGetTokenT<std::vector<reco::Vertex> > pat::PATMuonProducer::pvToken_

private

input source of the primary vertex

Definition at line 215 of file PATMuonProducer.cc.

Referenced by produce().

◆ recomputeBasicSelectors_

bool pat::PATMuonProducer::recomputeBasicSelectors_

private

Definition at line 242 of file PATMuonProducer.cc.

Referenced by produce().

◆ relMiniIsoPUCorrected_

double pat::PATMuonProducer::relMiniIsoPUCorrected_

private

Definition at line 160 of file PATMuonProducer.cc.

◆ resolutionLoader_

pat::helper::KinResolutionsLoader pat::PATMuonProducer::resolutionLoader_

private

helper class to add resolutions to the muon

Definition at line 203 of file PATMuonProducer.cc.

Referenced by fillMuon(), and produce().

◆ rho_

edm::EDGetTokenT<double> pat::PATMuonProducer::rho_

private

Definition at line 247 of file PATMuonProducer.cc.

Referenced by produce().

◆ simInfo_

edm::EDGetTokenT<edm::ValueMap<reco::MuonSimInfo> > pat::PATMuonProducer::simInfo_

private

MC info.

Definition at line 260 of file PATMuonProducer.cc.

Referenced by produce().

◆ softMuonMvaRun3Booster_

std::unique_ptr<pat::XGBooster> pat::PATMuonProducer::softMuonMvaRun3Booster_

private

Definition at line 241 of file PATMuonProducer.cc.

Referenced by produce().

◆ tcMETMuonCorrsToken_

edm::EDGetTokenT<edm::ValueMap<reco::MuonMETCorrectionData> > pat::PATMuonProducer::tcMETMuonCorrsToken_

private

source of tcMET muon corrections

Definition at line 183 of file PATMuonProducer.cc.

Referenced by produce().

◆ transientTrackBuilderToken_

const edm::ESGetToken<TransientTrackBuilder, TransientTrackRecord> pat::PATMuonProducer::transientTrackBuilderToken_

private

Definition at line 269 of file PATMuonProducer.cc.

Referenced by produce().

◆ triggerObjects_

edm::EDGetTokenT<std::vector<pat::TriggerObjectStandAlone> > pat::PATMuonProducer::triggerObjects_

private

Definition at line 264 of file PATMuonProducer.cc.

Referenced by produce().

◆ triggerResults_

edm::EDGetTokenT<edm::TriggerResults> pat::PATMuonProducer::triggerResults_

private

Definition at line 265 of file PATMuonProducer.cc.

Referenced by produce().

◆ useJec_

bool pat::PATMuonProducer::useJec_

private

Definition at line 243 of file PATMuonProducer.cc.

Referenced by produce().

◆ useParticleFlow_

bool pat::PATMuonProducer::useParticleFlow_

private

switch to use particle flow (PF2PAT) or not

Definition at line 205 of file PATMuonProducer.cc.

Referenced by fillMuon(), and produce().

◆ userDataHelper_

pat::PATUserDataHelper<pat::Muon> pat::PATMuonProducer::userDataHelper_

private

helper class to add userData to the muon

Definition at line 257 of file PATMuonProducer.cc.

Referenced by produce().

◆ useUserData_

bool pat::PATMuonProducer::useUserData_

private

add user data to the muon (this will be data members of th muon even w/o embedding)

Definition at line 225 of file PATMuonProducer.cc.

Referenced by produce().

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ GenAssociations

◆ IsoDepositMaps

◆ IsolationLabel

◆ IsolationLabels

◆ IsolationValueMaps

◆ MuonBaseRef

Constructor & Destructor Documentation

◆ PATMuonProducer()

◆ ~PATMuonProducer()

Member Function Documentation

◆ embedHighLevel()

◆ fillDescriptions()

◆ fillHltTriggerInfo()

◆ fillL1TriggerInfo()

◆ fillMuon()

◆ getMuonDirection()

◆ getRelMiniIsoPUCorrected()

◆ globalEndJob()

◆ initializeGlobalCache()

◆ isChargedHadron()

◆ isNeutralHadron()

◆ isPhoton()

◆ produce()

◆ puppiCombinedIsolation()

◆ readIsolationLabels()

◆ relMiniIsoPUCorrected()

◆ setMuonMiniIso()

Member Data Documentation

◆ addEfficiencies_

◆ addGenMatch_

◆ addInverseBeta_

◆ addPuppiIsolation_

◆ addResolutions_

◆ addTriggerMatching_

◆ beamLineToken_

◆ caloMETMuonCorrsToken_

◆ computeMiniIso_

◆ computeMuonIDMVA_

◆ computePuppiCombinedIso_

◆ computeSoftMuonMVA_

◆ effectiveAreaVec_

◆ efficiencyLoader_

◆ embedBestTrack_

◆ embedCaloMETMuonCorrs_

◆ embedCombinedMuon_

◆ embedDytMuon_

◆ embedGenMatch_

◆ embedHighLevelSelection_

◆ embedPFCandidate_

◆ embedPfEcalEnergy_

◆ embedPickyMuon_

◆ embedStandAloneMuon_

◆ embedTcMETMuonCorrs_

◆ embedTpfmsMuon_

◆ embedTrack_

◆ embedTunePBestTrack_

◆ forceEmbedBestTrack_

◆ genMatchTokens_

◆ geometryToken_

◆ hltCollectionFilters_

◆ isoDepositLabels_

◆ isoDepositTokens_

◆ isolationValueLabels_

◆ isolationValueTokens_

◆ isolator_

◆ isolatorTmpStorage_

◆ miniIsoParams_

◆ muonTimeExtraToken_

◆ muonToken_

◆ mvaBTagCollectionTag_

◆ mvaIDmediumCut_

◆ mvaIDtightCut_