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)
	everything that needs to be done during the event loop More...

	~PATMuonProducer ()
	default destructur More...

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

virtual	~EDProducer ()

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

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

virtual	~ProducerBase ()

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)

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

void	readIsolationLabels (const edm::ParameterSet &iConfig, const char *psetName, IsolationLabels &labels)

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

bool	addTeVRefits_
	add TeV track refits for the muon More...

edm::InputTag	beamLineSrc_
	input source of the primary vertex/beamspot More...

edm::InputTag	caloMETMuonCorrs_
	source of caloMET muon corrections More...

pat::helper::EfficiencyLoader	efficiencyLoader_
	helper class to add efficiencies to the muon 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	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...

std::vector< edm::InputTag >	genMatchSrc_
	input tags for generator match information More...

IsolationLabels	isoDepositLabels_
	input source for isoDeposits More...

IsolationLabels	isolationValueLabels_
	input source isolation value maps More...

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::InputTag	linkToPFSource_

edm::InputTag	muonSrc_
	input source More...

edm::InputTag	pfMuonSrc_
	input source pfCandidates that will be to be transformed into pat::Muons, when using PF2PAT More...

edm::InputTag	pickySrc_
	input tag for picky muon refit More...

GreaterByPt< Muon >	pTComparator_

edm::InputTag	pvSrc_
	input source of the primary vertex More...

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

edm::InputTag	tcMETMuonCorrs_
	source of tcMET muon corrections More...

edm::InputTag	tpfmsSrc_
	input tag for tpfms muon refit 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

typedef WorkerT< EDProducer >	WorkerType

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

Protected Member Functions inherited from edm::EDProducer
CurrentProcessingContext const *	currentContext () const

Protected Member Functions inherited from edm::ProducerBase
template<class TProducer , class TMethod >
void	callWhenNewProductsRegistered (TProducer *iProd, TMethod iMethod)

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.27 2010/09/14 15:20:20 kukartse Exp

Definition at line 43 of file PATMuonProducer.h.

Member Typedef Documentation

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

private

Definition at line 58 of file PATMuonProducer.h.

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

private

Definition at line 59 of file PATMuonProducer.h.

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

private

Definition at line 61 of file PATMuonProducer.h.

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

private

Definition at line 62 of file PATMuonProducer.h.

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

private

Definition at line 60 of file PATMuonProducer.h.

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

private

typedefs for convenience

Definition at line 57 of file PATMuonProducer.h.

Constructor & Destructor Documentation

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

explicit

default constructir

Definition at line 47 of file PATMuonProducer.cc.

References addEfficiencies_, addGenMatch_, addResolutions_, addTeVRefits_, beamLineSrc_, caloMETMuonCorrs_, efficiencyLoader_, embedCaloMETMuonCorrs_, embedCombinedMuon_, embedGenMatch_, embedHighLevelSelection_, embedPFCandidate_, embedPickyMuon_, embedStandAloneMuon_, embedTcMETMuonCorrs_, embedTpfmsMuon_, embedTrack_, edm::ParameterSet::existsAs(), genMatchSrc_, edm::ParameterSet::getParameter(), isoDepositLabels_, isolationValueLabels_, linkToPFSource_, muonSrc_, pfMuonSrc_, pickySrc_, pvSrc_, readIsolationLabels(), resolutionLoader_, tcMETMuonCorrs_, tpfmsSrc_, useParticleFlow_, usePV_, userDataHelper_, and useUserData_.

                                                                 : useUserData_(iConfig.exists("userData")), 
   isolator_(iConfig.exists("userIsolation") ? iConfig.getParameter<edm::ParameterSet>("userIsolation") : edm::ParameterSet(), false)
 {
   // input source
   muonSrc_ = iConfig.getParameter<edm::InputTag>( "muonSource" );
   // embedding of tracks
   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"   );
   caloMETMuonCorrs_ = iConfig.getParameter<edm::InputTag>("caloMETMuonCorrs" );
   tcMETMuonCorrs_ = iConfig.getParameter<edm::InputTag>("tcMETMuonCorrs"   );
 
   // pflow specific configurables
   useParticleFlow_  = iConfig.getParameter<bool>( "useParticleFlow" );
   linkToPFSource_   = iConfig.getParameter<edm::InputTag>( "linkToPFSource" );  //SAK
   embedPFCandidate_ = iConfig.getParameter<bool>( "embedPFCandidate" );
   pfMuonSrc_ = iConfig.getParameter<edm::InputTag>( "pfMuonSource" );
 
   // TeV track refits
   addTeVRefits_ = iConfig.getParameter<bool>("addTeVRefits");
   if(addTeVRefits_){
     pickySrc_ = iConfig.getParameter<edm::InputTag>("pickySrc");
     tpfmsSrc_ = iConfig.getParameter<edm::InputTag>("tpfmsSrc");
   }
   // embedding of tracks from TeV refit
   embedPickyMuon_ = iConfig.getParameter<bool>( "embedPickyMuon" );
   embedTpfmsMuon_ = iConfig.getParameter<bool>( "embedTpfmsMuon" );
 
   // Monte Carlo matching
   addGenMatch_ = iConfig.getParameter<bool>( "addGenMatch" );
   if(addGenMatch_){
     embedGenMatch_ = iConfig.getParameter<bool>( "embedGenMatch" );
     if(iConfig.existsAs<edm::InputTag>("genParticleMatch")){
       genMatchSrc_.push_back(iConfig.getParameter<edm::InputTag>( "genParticleMatch" ));
     } else {
       genMatchSrc_ = iConfig.getParameter<std::vector<edm::InputTag> >( "genParticleMatch" );
     }
   }
   
   // efficiencies
   addEfficiencies_ = iConfig.getParameter<bool>("addEfficiencies");
   if(addEfficiencies_){
     efficiencyLoader_ = pat::helper::EfficiencyLoader(iConfig.getParameter<edm::ParameterSet>("efficiencies"));
   }
 
   // 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_);
   // read isolation value labels, for direct embedding
   readIsolationLabels(iConfig, "isolationValues", isolationValueLabels_);
   
   // check to see if the user wants to add user data
   if( useUserData_ ){
     userDataHelper_ = PATUserDataHelper<Muon>(iConfig.getParameter<edm::ParameterSet>("userData"));
   }
 
   // embed high level selection variables
   usePV_ = true;
   embedHighLevelSelection_ = iConfig.getParameter<bool>("embedHighLevelSelection");
   if ( embedHighLevelSelection_ ) {
     beamLineSrc_ = iConfig.getParameter<edm::InputTag>("beamLineSrc");
     usePV_ = iConfig.getParameter<bool>("usePV");
     pvSrc_ = iConfig.getParameter<edm::InputTag>("pvSrc");
   }
   
   // produces vector of muons
   produces<std::vector<Muon> >();
 }

PATMuonProducer::~PATMuonProducer ( )

default destructur

Definition at line 126 of file PATMuonProducer.cc.

127 {

128 }

Member Function Documentation

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

private

Definition at line 609 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(innerTrack->px(),
                               innerTrack->py(),
                               innerTrack->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(innerTrack->px(),
                           innerTrack->py(),
                           innerTrack->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(innerTrack->px(),
                               innerTrack->py(),
                               innerTrack->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(innerTrack->px(),
                           innerTrack->py(),
                             innerTrack->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 477 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(), 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>("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 muon");
   iDesc.add<bool>("embedTpfmsMuon", false)->setComment("embed external tpfms muon");
 
   // 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<edm::InputTag>("linkToPFSource", edm::InputTag())->setComment("alternative PF collection to link to (pfCandidateRef) -- traverses inheritance chain up to this");
   iDesc.add<bool>("embedPFCandidate", false)->setComment("embed external particle flow object");
 
   // TeV refit 
   iDesc.ifValue( edm::ParameterDescription<bool>("addTeVRefits", true, true),
          true >> (edm::ParameterDescription<edm::InputTag>("pickySrc", edm::InputTag(), true) and
               edm::ParameterDescription<edm::InputTag>("tpfmsSrc", edm::InputTag(), true)) 
          )->setComment("If TeV refits are added, their sources need to be specified");
 
   // 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>("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>("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 418 of file PATMuonProducer.cc.

References addGenMatch_, pat::PATObject< ObjectType >::addGenParticleRef(), edm::contains(), efficiencyLoader_, pat::Muon::embedCombinedMuon(), embedCombinedMuon_, embedGenMatch_, pat::PATObject< ObjectType >::embedGenParticle(), pat::Muon::embedStandAloneMuon(), embedStandAloneMuon_, pat::Muon::embedTrack(), embedTrack_, pat::helper::EfficiencyLoader::enabled(), pat::helper::KinResolutionsLoader::enabled(), first, i, edm::RefToBase< T >::id(), isoDepositLabels_, isolationValueLabels_, j, n, pat::Muon::pfCandidateRef(), resolutionLoader_, pat::helper::EfficiencyLoader::setEfficiencies(), pat::Lepton< LeptonType >::setIsoDeposit(), pat::Lepton< LeptonType >::setIsolation(), reco::LeafCandidate::setP4(), pat::helper::KinResolutionsLoader::setResolutions(), LaserTracksInput_cfi::source, 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();
 
   // 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 {
     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 {
     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
	)

virtual

everything that needs to be done during the event loop

Implements edm::EDProducer.

Definition at line 130 of file PATMuonProducer.cc.

References IPTools::absoluteTransverseImpactParameter(), addGenMatch_, addTeVRefits_, beamLineSrc_, pat::helper::MultiIsolator::beginEvent(), caloMETMuonCorrs_, efficiencyLoader_, pat::Muon::embedCaloMETMuonCorrs(), embedCaloMETMuonCorrs_, embedGenMatch_, embedHighLevel(), embedHighLevelSelection_, pat::Muon::embedPFCandidate(), embedPFCandidate_, pat::Muon::embedPickyMuon(), embedPickyMuon_, pat::Muon::embedTcMETMuonCorrs(), embedTcMETMuonCorrs_, pat::Muon::embedTpfmsMuon(), embedTpfmsMuon_, pat::helper::EfficiencyLoader::enabled(), pat::helper::KinResolutionsLoader::enabled(), pat::helper::MultiIsolator::enabled(), edm::InputTag::encode(), pat::helper::MultiIsolator::endEvent(), edm::HandleBase::failedToGet(), pat::helper::MultiIsolator::fill(), fillMuon(), genMatchSrc_, edm::EventSetup::get(), edm::Event::getByLabel(), i, edm::HandleBase::id(), edm::Ptr< T >::id(), edm::Ref< C, T, F >::id(), getHLTprescales::index, susybsm::HSCParticleType::innerTrack, edm::Ref< C, T, F >::isAvailable(), edm::Ref< C, T, F >::isNonnull(), edm::Ptr< T >::isNull(), isoDepositLabels_, isolationValueLabels_, isolator_, isolatorTmpStorage_, edm::EventBase::isRealData(), edm::HandleBase::isValid(), j, edm::Ptr< T >::key(), edm::InputTag::label(), linkToPFSource_, reco::PFCandidate::muonRef(), patZpeak::muons, muonSrc_, pat::helper::EfficiencyLoader::newEvent(), pat::helper::KinResolutionsLoader::newEvent(), muonProducer_cfi::patMuons, pat::Muon::pfCandidateRef(), pfMuonSrc_, pickySrc_, pTComparator_, edm::Event::put(), pvSrc_, resolutionLoader_, query::result, edm::second(), pat::Muon::setDB(), pat::Lepton< LeptonType >::setIsolation(), pat::Muon::setNormChi2(), pat::Muon::setNumberOfValidHits(), pat::Muon::setPFCandidateRef(), pat::Muon::setPickyMuon(), pat::Muon::setTpfmsMuon(), python.multivaluedict::sort(), LaserTracksInput_cfi::source, tcMETMuonCorrs_, tpfmsSrc_, useParticleFlow_, usePV_, userDataHelper_, useUserData_, edm::helpers::KeyVal< K, V >::val, reco::BeamSpot::x0(), reco::BeamSpot::y0(), and reco::BeamSpot::z0().

 {  
   edm::Handle<edm::View<reco::Muon> > muons;
   iEvent.getByLabel(muonSrc_, muons);
 
   if (iEvent.isRealData()){
     addGenMatch_ = false;
     embedGenMatch_ = false;
   }
 
   // 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(isoDepositLabels_.size());
   for (size_t j = 0; j<isoDepositLabels_.size(); ++j) {
     iEvent.getByLabel(isoDepositLabels_[j].second, deposits[j]);
   }
 
   IsolationValueMaps isolationValues(isolationValueLabels_.size());
   for (size_t j = 0; j<isolationValueLabels_.size(); ++j) {
     iEvent.getByLabel(isolationValueLabels_[j].second, isolationValues[j]);
   }  
 
   // prepare the MC matching
   GenAssociations  genMatches(genMatchSrc_.size());
   if (addGenMatch_) {
     for (size_t j = 0, nd = genMatchSrc_.size(); j < nd; ++j) {
       iEvent.getByLabel(genMatchSrc_[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.getByLabel(beamLineSrc_, beamSpotHandle);
 
     // get the primary vertex
     edm::Handle< std::vector<reco::Vertex> > pvHandle;
     iEvent.getByLabel( pvSrc_, 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.getByLabel(pfMuonSrc_, pfMuons);
     //-- SAK ------------------------------------------------------------------
     edm::Handle< reco::PFCandidateCollection >  pfForLinking;
     if (linkToPFSource_.label().length())
       iEvent.getByLabel(linkToPFSource_, pfForLinking);
     //-- SAK ------------------------------------------------------------------
 
     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();
     // Make sure the collection it points to is there
     if ( innerTrack.isNonnull() && innerTrack.isAvailable() ) {
       unsigned int nhits = innerTrack->numberOfValidHits();
       aMuon.setNumberOfValidHits( nhits );
 
       reco::TransientTrack tt = trackBuilder->build(innerTrack);
       embedHighLevel( aMuon, 
               innerTrack,
               tt,
               primaryVertex,
               primaryVertexIsValid,
               beamSpot,
               beamSpotIsValid );
 
       // Correct to PV, or beam spot
       if ( !usePV_ ) {
         double corr_d0 = -1.0 * innerTrack->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 );
 
       //-- SAK ----------------------------------------------------------------
       if (linkToPFSource_.label().length() && aMuon.pfCandidateRef().id() != pfForLinking.id()) {
         reco::CandidatePtr  source  = aMuon.pfCandidateRef()->sourceCandidatePtr(0);
         while (source.id() != pfForLinking.id()) {
           source  = source->sourceCandidatePtr(0);
           if (source.isNull())
             throw cms::Exception("InputSource", "Object in "+pfMuonSrc_.encode()+" does not link back to "+linkToPFSource_.encode());
         } // end loop over inheritance chain
         aMuon.setPFCandidateRef(reco::PFCandidateRef(pfForLinking, source.key()));
       }
       //-- SAK ----------------------------------------------------------------
       patMuons->push_back(aMuon); 
     } 
   }
   else {
     edm::Handle<edm::View<reco::Muon> > muons;
     iEvent.getByLabel(muonSrc_, muons);
 
     // prepare the TeV refit track retrieval
     edm::Handle<reco::TrackToTrackMap> pickyMap, tpfmsMap;
     if (addTeVRefits_) {
       iEvent.getByLabel(pickySrc_, pickyMap);
       iEvent.getByLabel(tpfmsSrc_, tpfmsMap);
     }
 
     // embedding of muon MET corrections
     edm::Handle<edm::ValueMap<reco::MuonMETCorrectionData> > caloMETMuonCorrs;
     //edm::ValueMap<reco::MuonMETCorrectionData> caloMETmuCorValueMap;
     if(embedCaloMETMuonCorrs_){
       iEvent.getByLabel(caloMETMuonCorrs_, caloMETMuonCorrs);
       //caloMETmuCorValueMap  = *caloMETmuCorValueMap_h;
     }
     edm::Handle<edm::ValueMap<reco::MuonMETCorrectionData> > tcMETMuonCorrs;
     //edm::ValueMap<reco::MuonMETCorrectionData> tcMETmuCorValueMap;
     if(embedTcMETMuonCorrs_) {
       iEvent.getByLabel(tcMETMuonCorrs_, 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);
 
       // store the TeV refit track refs (only available for globalMuons)
       if (addTeVRefits_ && itMuon->isGlobalMuon()) {
     reco::TrackToTrackMap::const_iterator it;
     const reco::TrackRef& globalTrack = itMuon->globalTrack();
     
     // If the getByLabel calls failed above (i.e. if the TeV refit
     // maps/collections were not in the event), then the TrackRefs
     // in the Muon object will remain null.
     if (!pickyMap.failedToGet()) {
       it = pickyMap->find(globalTrack);
       if (it != pickyMap->end()) aMuon.setPickyMuon(it->val);
       if (embedPickyMuon_) aMuon.embedPickyMuon();
     }
  
     if (!tpfmsMap.failedToGet()) {
       it = tpfmsMap->find(globalTrack);
       if (it != tpfmsMap->end()) aMuon.setTpfmsMuon(it->val);
       if (embedTpfmsMuon_) aMuon.embedTpfmsMuon();
     }
       }
       
       // 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();
     // Make sure the collection it points to is there
     if ( innerTrack.isNonnull() && innerTrack.isAvailable() ) {
       unsigned int nhits = innerTrack->numberOfValidHits();
       aMuon.setNumberOfValidHits( nhits );
 
       reco::TransientTrack tt = trackBuilder->build(innerTrack);
       embedHighLevel( aMuon, 
               innerTrack,
               tt,
               primaryVertex,
               primaryVertexIsValid,
               beamSpot,
               beamSpotIsValid );
 
       // Correct to PV, or beam spot
       if ( !usePV_ ) {
         double corr_d0 = -1.0 * innerTrack->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();
 }

void PATMuonProducer::readIsolationLabels	(	const edm::ParameterSet &	iConfig,
		const char *	psetName,
		IsolationLabels &	labels
	)

private

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

Definition at line 572 of file PATMuonProducer.cc.

References pat::EcalIso, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), pat::HcalIso, combine::key, pat::PfAllParticleIso, pat::PfChargedHadronIso, pat::PfGammaIso, pat::PfNeutralHadronIso, pat::TrackIso, and pat::UserBaseIso.

Referenced by PATMuonProducer().

 {
   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("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));
       }
     }
   }  
 }

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

Referenced by PATMuonProducer().

bool pat::PATMuonProducer::addGenMatch_

private

add generator match information

Definition at line 111 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 117 of file PATMuonProducer.h.

Referenced by PATMuonProducer().

bool pat::PATMuonProducer::addTeVRefits_

private

add TeV track refits for the muon

Definition at line 101 of file PATMuonProducer.h.

Referenced by PATMuonProducer(), and produce().

edm::InputTag pat::PATMuonProducer::beamLineSrc_

private

input source of the primary vertex/beamspot

Definition at line 130 of file PATMuonProducer.h.

Referenced by PATMuonProducer(), and produce().

edm::InputTag pat::PATMuonProducer::caloMETMuonCorrs_

private

source of caloMET muon corrections

Definition at line 95 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 152 of file PATMuonProducer.h.

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

bool pat::PATMuonProducer::embedCaloMETMuonCorrs_

private

embed muon MET correction info for caloMET into the muon

Definition at line 93 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 91 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 115 of file PATMuonProducer.h.

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

bool pat::PATMuonProducer::embedHighLevelSelection_

private

embed high level selection variables

Definition at line 128 of file PATMuonProducer.h.

Referenced by PATMuonProducer(), and produce().

bool pat::PATMuonProducer::embedPFCandidate_

private

embed pfCandidates into the muon

Definition at line 126 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 PATMuonProducer(), and produce().

bool pat::PATMuonProducer::embedStandAloneMuon_

private

embed track from muon system into the muon

Definition at line 89 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 97 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 PATMuonProducer(), and produce().

bool pat::PATMuonProducer::embedTrack_

private

embed the track from inner tracker into the muon

Definition at line 87 of file PATMuonProducer.h.

Referenced by fillMuon(), and PATMuonProducer().

std::vector<edm::InputTag> pat::PATMuonProducer::genMatchSrc_

private

input tags for generator match information

Definition at line 113 of file PATMuonProducer.h.

Referenced by PATMuonProducer(), and produce().

IsolationLabels pat::PATMuonProducer::isoDepositLabels_

private

input source for isoDeposits

Definition at line 136 of file PATMuonProducer.h.

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

IsolationLabels pat::PATMuonProducer::isolationValueLabels_

private

input source isolation value maps

Definition at line 138 of file PATMuonProducer.h.

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

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

private

helper class to add userdefined isolation values to the muon

Definition at line 148 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 150 of file PATMuonProducer.h.

Referenced by produce().

edm::InputTag pat::PATMuonProducer::linkToPFSource_

private

Definition at line 122 of file PATMuonProducer.h.

Referenced by PATMuonProducer(), and produce().

edm::InputTag pat::PATMuonProducer::muonSrc_

private

input source

Definition at line 85 of file PATMuonProducer.h.

Referenced by PATMuonProducer(), and produce().

edm::InputTag pat::PATMuonProducer::pfMuonSrc_

private

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

Definition at line 124 of file PATMuonProducer.h.

Referenced by PATMuonProducer(), and produce().

edm::InputTag pat::PATMuonProducer::pickySrc_

private

input tag for picky muon refit

Definition at line 103 of file PATMuonProducer.h.

Referenced by PATMuonProducer(), and produce().

GreaterByPt<Muon> pat::PATMuonProducer::pTComparator_

private

— tools — comparator for pt ordering

Definition at line 146 of file PATMuonProducer.h.

Referenced by produce().

edm::InputTag pat::PATMuonProducer::pvSrc_

private

input source of the primary vertex

Definition at line 134 of file PATMuonProducer.h.

Referenced by PATMuonProducer(), and produce().

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

private

helper class to add resolutions to the muon

Definition at line 119 of file PATMuonProducer.h.

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

edm::InputTag pat::PATMuonProducer::tcMETMuonCorrs_

private

source of tcMET muon corrections

Definition at line 99 of file PATMuonProducer.h.

Referenced by PATMuonProducer(), and produce().

edm::InputTag pat::PATMuonProducer::tpfmsSrc_

private

input tag for tpfms muon refit

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

Referenced by PATMuonProducer(), and produce().

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

private

helper class to add userData to the muon

Definition at line 154 of file PATMuonProducer.h.

Referenced by PATMuonProducer(), and 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 142 of file PATMuonProducer.h.

Referenced by PATMuonProducer(), and 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