class definition More...

#include "PhysicsTools/PatAlgos/interface/PATMuonProducer.h"

Inheritance diagram for pat::PATMuonProducer:

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

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

	~PATMuonProducer ()
	default destructur More...

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducer ()

Public Member Functions inherited from edm::ProducerBase
	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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

Static Public Member Functions inherited from edm::EDProducer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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

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

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	addResolutions_
	add resolutions to the muon (this will be data members of th muon even w/o embedding) 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...

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

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_
	helper class to add userdefined isolation values to the muon More...

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

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

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

GreaterByPt< Muon >	pTComparator_

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

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

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

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

bool	usePV_
	use the primary vertex or the beamspot 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::EDProducer
typedef EDProducer	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Protected Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

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 42 of file PATMuonProducer.h.

Member Typedef Documentation

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

private

Definition at line 57 of file PATMuonProducer.h.

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

private

Definition at line 58 of file PATMuonProducer.h.

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

private

Definition at line 60 of file PATMuonProducer.h.

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

private

Definition at line 61 of file PATMuonProducer.h.

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

private

Definition at line 59 of file PATMuonProducer.h.

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

private

typedefs for convenience

Definition at line 56 of file PATMuonProducer.h.

Constructor & Destructor Documentation

PATMuonProducer::PATMuonProducer ( const edm::ParameterSet & iConfig )

explicit

default constructir

Definition at line 46 of file PATMuonProducer.cc.

References addGenMatch_, caloMETMuonCorrsToken_, edm::EDConsumerBase::consumes(), embedBestTrack_, embedCaloMETMuonCorrs_, embedCombinedMuon_, embedDytMuon_, embedGenMatch_, embedPFCandidate_, embedPickyMuon_, embedStandAloneMuon_, embedTcMETMuonCorrs_, embedTpfmsMuon_, embedTrack_, embedTunePBestTrack_, edm::ParameterSet::existsAs(), forceEmbedBestTrack_, genMatchTokens_, edm::ParameterSet::getParameter(), muonToken_, pfMuonToken_, GlobalPosition_Frontier_DevDB_cff::tag, tcMETMuonCorrsToken_, useParticleFlow_, and edm::vector_transform().

                                                                 : useUserData_(iConfig.exists("userData")),
   isolator_(iConfig.exists("userIsolation") ? iConfig.getParameter<edm::ParameterSet>("userIsolation") : edm::ParameterSet(), consumesCollector(), false)
 {
   // 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" ));
   // embedding of tracks from TeV refit
   embedPickyMuon_ = iConfig.getParameter<bool>( "embedPickyMuon" );
   embedTpfmsMuon_ = iConfig.getParameter<bool>( "embedTpfmsMuon" );
   embedDytMuon_ = iConfig.getParameter<bool>( "embedDytMuon" );
   // 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"));
   }
   // 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
   usePV_ = true;
   embedHighLevelSelection_ = iConfig.getParameter<bool>("embedHighLevelSelection");
   if ( embedHighLevelSelection_ ) {
     beamLineToken_ = consumes<reco::BeamSpot>(iConfig.getParameter<edm::InputTag>("beamLineSrc"));
     usePV_ = iConfig.getParameter<bool>("usePV");
     pvToken_ = consumes<std::vector<reco::Vertex> >(iConfig.getParameter<edm::InputTag>("pvSrc"));
   }
   // produces vector of muons
   produces<std::vector<Muon> >();
 }

PATMuonProducer::~PATMuonProducer ( )

default destructur

Definition at line 113 of file PATMuonProducer.cc.

114 {

115 }

Member Function Documentation

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 546 of file PATMuonProducer.cc.

References pat::Muon::BS2D, pat::Muon::BS3D, reco::BeamSpot::position(), pat::Muon::PV2D, pat::Muon::PV3D, query::result, reco::BeamSpot::rotatedCovariance3D(), pat::Muon::setDB(), IPTools::signedImpactParameter3D(), and IPTools::signedTransverseImpactParameter().

Referenced by produce().

 {
   // Correct to PV
 
   // PV2D
   std::pair<bool,Measurement1D> result =
     IPTools::signedTransverseImpactParameter(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::PV2D);
 
 
   // PV3D
   result =
     IPTools::signedImpactParameter3D(tt,
                      GlobalVector(track->px(),
                           track->py(),
                           track->pz()),
                      primaryVertex);
   d0_corr = result.second.value();
   d0_err = primaryVertexIsValid ? result.second.error() : -1.0;
   aMuon.setDB( d0_corr, d0_err, pat::Muon::PV3D);
 
 
   // Correct to beam spot
   // make a fake vertex out of beam spot
   reco::Vertex vBeamspot(beamspot.position(), beamspot.rotatedCovariance3D());
 
   // BS2D
   result =
     IPTools::signedTransverseImpactParameter(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::BS2D);
 
     // 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);
 }

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

static

description of config file parameters

Definition at line 447 of file PATMuonProducer.cc.

References edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addNode(), edm::ParameterSetDescription::addOptional(), pat::helper::KinResolutionsLoader::fillDescription(), pat::PATUserDataHelper< ObjectType >::fillDescription(), 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");
 
   // 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");
 
   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);
 
   // 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");
   iDesc.addNode( edm::ParameterDescription<bool>("usePV", bool(), true)
                  )->setComment("input with high level selection, use primary vertex (true) or beam line (false)");
 
   //descriptions.add("PATMuonProducer", iDesc);
 }

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 370 of file PATMuonProducer.cc.

References addGenMatch_, pat::PATObject< ObjectType >::addGenParticleRef(), edm::contains(), 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(), first, forceEmbedBestTrack_, i, edm::RefToBase< T >::id(), reco::Muon::isAValidMuonTrack(), reco::Muon::isGlobalMuon(), isoDepositLabels_, isolationValueLabels_, j, n, 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(size_t i = 0, n = genMatches.size(); i < n; ++i) {
       reco::GenParticleRef genMuon = (*genMatches[i])[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);
   }
 }

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

overridevirtual

everything that needs to be done during the event loop

Implements edm::EDProducer.

Definition at line 117 of file PATMuonProducer.cc.

References IPTools::absoluteTransverseImpactParameter(), addGenMatch_, beamLineToken_, SiPixelRawToDigiRegional_cfi::beamSpot, pat::helper::MultiIsolator::beginEvent(), caloMETMuonCorrsToken_, efficiencyLoader_, pat::Muon::embedCaloMETMuonCorrs(), embedCaloMETMuonCorrs_, embedGenMatch_, embedHighLevel(), embedHighLevelSelection_, pat::Muon::embedPFCandidate(), embedPFCandidate_, pat::Muon::embedTcMETMuonCorrs(), embedTcMETMuonCorrs_, pat::helper::EfficiencyLoader::enabled(), pat::helper::KinResolutionsLoader::enabled(), pat::helper::MultiIsolator::enabled(), pat::helper::MultiIsolator::endEvent(), pat::helper::MultiIsolator::fill(), fillMuon(), genMatchTokens_, edm::EventSetup::get(), edm::Event::getByToken(), i, customizeTrackingMonitorSeedNumber::idx, cmsHarvester::index, susybsm::HSCParticleType::innerTrack, edm::Ref< C, T, F >::isAvailable(), edm::Ref< C, T, F >::isNonnull(), isoDepositTokens_, isolationValueTokens_, isolator_, isolatorTmpStorage_, edm::EventBase::isRealData(), edm::HandleBase::isValid(), j, reco::PFCandidate::muonRef(), patZpeak::muons, muonToken_, pat::helper::EfficiencyLoader::newEvent(), pat::helper::KinResolutionsLoader::newEvent(), muonProducer_cfi::patMuons, pfMuons_cff::pfMuons, pfMuonToken_, HWWFunctions::primaryVertex(), pTComparator_, edm::Event::put(), pvToken_, resolutionLoader_, query::result, pat::Muon::setDB(), pat::Lepton< LeptonType >::setIsolation(), pat::Muon::setNormChi2(), pat::Muon::setNumberOfValidHits(), pat::Muon::setPFCandidateRef(), python.multivaluedict::sort(), tcMETMuonCorrsToken_, groupFilesInBlocks::tt, useParticleFlow_, usePV_, userDataHelper_, useUserData_, reco::BeamSpot::x0(), reco::BeamSpot::y0(), and reco::BeamSpot::z0().

 {
   // switch off embedding (in unschedules mode)
   if (iEvent.isRealData()){
     addGenMatch_   = false;
     embedGenMatch_ = false;
   }
 
   edm::Handle<edm::View<reco::Muon> > muons;
   iEvent.getByToken(muonToken_, muons);
 
   // get the ESHandle for the transient track builder,
   // if needed for high level selection embedding
   edm::ESHandle<TransientTrackBuilder> trackBuilder;
 
   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]);
   }
 
   // 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::TrackBase::Point beamPoint(0,0,0);
   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";
     }
     beamPoint = reco::TrackBase::Point ( beamSpot.x0(), beamSpot.y0(), beamSpot.z0() );
     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
     iSetup.get<TransientTrackRecord>().get("TransientTrackBuilder", trackBuilder);
   }
 
   // this will be the new object collection
   std::vector<Muon> * patMuons = new std::vector<Muon>();
 
   if( useParticleFlow_ ){
     // get the PFCandidates of type muons
     edm::Handle< reco::PFCandidateCollection >  pfMuons;
     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 );
 
       // Correct to PV, or beam spot
       if ( !usePV_ ) {
         double corr_d0 = -1.0 * chosenTrack->dxy( beamPoint );
         aMuon.setDB( corr_d0, -1.0 );
       } else {
         std::pair<bool,Measurement1D> result = IPTools::absoluteTransverseImpactParameter(tt, primaryVertex);
         double d0_corr = result.second.value();
         double d0_err = result.second.error();
         aMuon.setDB( d0_corr, d0_err );
       }
     }
 
     if ( globalTrack.isNonnull() && globalTrack.isAvailable() ) {
       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 );
       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;
     }
     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);
 
       // 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 );
 
       // Correct to PV, or beam spot
       if ( !usePV_ ) {
         double corr_d0 = -1.0 * chosenTrack->dxy( beamPoint );
         aMuon.setDB( corr_d0, -1.0 );
       } else {
         std::pair<bool,Measurement1D> result = IPTools::absoluteTransverseImpactParameter(tt, primaryVertex);
         double d0_corr = result.second.value();
         double d0_err = result.second.error();
         aMuon.setDB( d0_corr, d0_err );
       }
     }
 
     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]);
 
       patMuons->push_back(aMuon);
     }
   }
 
   // sort muons in pt
   std::sort(patMuons->begin(), patMuons->end(), pTComparator_);
 
   // put genEvt object in Event
   std::auto_ptr<std::vector<Muon> > ptr(patMuons);
   iEvent.put(ptr);
 
   if (isolator_.enabled()) isolator_.endEvent();
 }

template<typename T >

void 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 167 of file PATMuonProducer.h.

References pat::EcalIso, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), pat::HcalIso, combine::key, diffTwoXMLs::label, pat::PfAllParticleIso, pat::PfChargedAllIso, pat::PfChargedHadronIso, pat::PfGammaIso, pat::PfNeutralHadronIso, pat::PfPUChargedHadronIso, 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.push_back(std::make_pair(pat::TrackIso, depconf.getParameter<edm::InputTag>("tracker")));
     if (depconf.exists("ecal"))    labels.push_back(std::make_pair(pat::EcalIso, depconf.getParameter<edm::InputTag>("ecal")));
     if (depconf.exists("hcal"))    labels.push_back(std::make_pair(pat::HcalIso, depconf.getParameter<edm::InputTag>("hcal")));
     if (depconf.exists("pfAllParticles"))  {
       labels.push_back(std::make_pair(pat::PfAllParticleIso, depconf.getParameter<edm::InputTag>("pfAllParticles")));
     }
     if (depconf.exists("pfChargedHadrons"))  {
       labels.push_back(std::make_pair(pat::PfChargedHadronIso, depconf.getParameter<edm::InputTag>("pfChargedHadrons")));
     }
     if (depconf.exists("pfChargedAll"))  {
       labels.push_back(std::make_pair(pat::PfChargedAllIso, depconf.getParameter<edm::InputTag>("pfChargedAll")));
     }
     if (depconf.exists("pfPUChargedHadrons"))  {
       labels.push_back(std::make_pair(pat::PfPUChargedHadronIso, depconf.getParameter<edm::InputTag>("pfPUChargedHadrons")));
     }
     if (depconf.exists("pfNeutralHadrons"))  {
       labels.push_back(std::make_pair(pat::PfNeutralHadronIso, depconf.getParameter<edm::InputTag>("pfNeutralHadrons")));
     }
     if (depconf.exists("pfPhotons")) {
       labels.push_back(std::make_pair(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 = UserBaseIso;
       for ( ; it != ed; ++it, ++key) {
        labels.push_back(std::make_pair(IsolationKeys(key), *it));
       }
     }
   }
   tokens = edm::vector_transform(labels, [this](IsolationLabel const & label){return consumes<edm::ValueMap<T> >(label.second);});
 }

Member Data Documentation

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 143 of file PATMuonProducer.h.

bool pat::PATMuonProducer::addGenMatch_

private

add generator match information

Definition at line 113 of file PATMuonProducer.h.

Referenced by fillMuon(), PATMuonProducer(), and produce().

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 119 of file PATMuonProducer.h.

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

private

input source of the primary vertex/beamspot

Definition at line 131 of file PATMuonProducer.h.

Referenced by produce().

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

private

source of caloMET muon corrections

Definition at line 101 of file PATMuonProducer.h.

Referenced by PATMuonProducer(), and produce().

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

private

helper class to add efficiencies to the muon

Definition at line 155 of file PATMuonProducer.h.

Referenced by fillMuon(), and produce().

bool pat::PATMuonProducer::embedBestTrack_

private

embed the track from best muon measurement (global pflow)

Definition at line 87 of file PATMuonProducer.h.

Referenced by fillMuon(), and PATMuonProducer().

bool pat::PATMuonProducer::embedCaloMETMuonCorrs_

private

embed muon MET correction info for caloMET into the muon

Definition at line 99 of file PATMuonProducer.h.

Referenced by PATMuonProducer(), and produce().

bool pat::PATMuonProducer::embedCombinedMuon_

private

embed track of the combined fit into the muon

Definition at line 97 of file PATMuonProducer.h.

Referenced by fillMuon(), and PATMuonProducer().

bool pat::PATMuonProducer::embedDytMuon_

private

embed track from DYT muon fit into the muon

Definition at line 111 of file PATMuonProducer.h.

Referenced by fillMuon(), and PATMuonProducer().

bool pat::PATMuonProducer::embedGenMatch_

private

embed the gen match information into the muon

Definition at line 117 of file PATMuonProducer.h.

Referenced by fillMuon(), PATMuonProducer(), and produce().

bool pat::PATMuonProducer::embedHighLevelSelection_

private

embed high level selection variables

Definition at line 129 of file PATMuonProducer.h.

Referenced by produce().

bool pat::PATMuonProducer::embedPFCandidate_

private

embed pfCandidates into the muon

Definition at line 127 of file PATMuonProducer.h.

Referenced by PATMuonProducer(), and produce().

bool pat::PATMuonProducer::embedPickyMuon_

private

embed track from picky muon fit into the muon

Definition at line 107 of file PATMuonProducer.h.

Referenced by fillMuon(), and PATMuonProducer().

bool pat::PATMuonProducer::embedStandAloneMuon_

private

embed track from muon system into the muon

Definition at line 95 of file PATMuonProducer.h.

Referenced by fillMuon(), and PATMuonProducer().

bool pat::PATMuonProducer::embedTcMETMuonCorrs_

private

embed muon MET correction info for tcMET into the muon

Definition at line 103 of file PATMuonProducer.h.

Referenced by PATMuonProducer(), and produce().

bool pat::PATMuonProducer::embedTpfmsMuon_

private

embed track from tpfms muon fit into the muon

Definition at line 109 of file PATMuonProducer.h.

Referenced by fillMuon(), and PATMuonProducer().

bool pat::PATMuonProducer::embedTrack_

private

embed the track from inner tracker into the muon

Definition at line 93 of file PATMuonProducer.h.

Referenced by fillMuon(), and PATMuonProducer().

bool pat::PATMuonProducer::embedTunePBestTrack_

private

embed the track from best muon measurement (muon only)

Definition at line 89 of file PATMuonProducer.h.

Referenced by fillMuon(), and PATMuonProducer().

bool pat::PATMuonProducer::forceEmbedBestTrack_

private

force separate embed of the best track even if already embedded

Definition at line 91 of file PATMuonProducer.h.

Referenced by fillMuon(), and PATMuonProducer().

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

private

input tags for generator match information

Definition at line 115 of file PATMuonProducer.h.

Referenced by PATMuonProducer(), and produce().

IsolationLabels pat::PATMuonProducer::isoDepositLabels_

private

input source for isoDeposits

Definition at line 137 of file PATMuonProducer.h.

Referenced by fillMuon().

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

private

Definition at line 138 of file PATMuonProducer.h.

Referenced by produce().

IsolationLabels pat::PATMuonProducer::isolationValueLabels_

private

input source isolation value maps

Definition at line 140 of file PATMuonProducer.h.

Referenced by fillMuon().

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

private

Definition at line 141 of file PATMuonProducer.h.

Referenced by produce().

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

private

helper class to add userdefined isolation values to the muon

Definition at line 151 of file PATMuonProducer.h.

Referenced by produce().

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

private

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

Definition at line 153 of file PATMuonProducer.h.

Referenced by produce().

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

private

input source

Definition at line 84 of file PATMuonProducer.h.

Referenced by PATMuonProducer(), and produce().

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 125 of file PATMuonProducer.h.

Referenced by PATMuonProducer(), and produce().

GreaterByPt<Muon> pat::PATMuonProducer::pTComparator_

private

— tools — comparator for pt ordering

Definition at line 149 of file PATMuonProducer.h.

Referenced by produce().

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

private

input source of the primary vertex

Definition at line 135 of file PATMuonProducer.h.

Referenced by produce().

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

private

helper class to add resolutions to the muon

Definition at line 121 of file PATMuonProducer.h.

Referenced by fillMuon(), and produce().

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

private

source of tcMET muon corrections

Definition at line 105 of file PATMuonProducer.h.

Referenced by PATMuonProducer(), and produce().

bool pat::PATMuonProducer::useParticleFlow_

private

switch to use particle flow (PF2PAT) or not

Definition at line 123 of file PATMuonProducer.h.

Referenced by fillMuon(), PATMuonProducer(), and produce().

bool pat::PATMuonProducer::usePV_

private

use the primary vertex or the beamspot

Definition at line 133 of file PATMuonProducer.h.

Referenced by produce().

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

private

helper class to add userData to the muon

Definition at line 157 of file PATMuonProducer.h.

Referenced by produce().

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 145 of file PATMuonProducer.h.

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

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation