#include <PFMuonSelector.h>

Inheritance diagram for PFMuonSelector:

Public Types
enum	Version_t { TOPPAG12_LJETS, N_VERSIONS }

Public Types inherited from Selector< pat::Muon >
typedef std::binary_function < pat::Muon, pat::strbitset, bool >	base_type

typedef std::pair< index_type, size_t >	cut_flow_item

typedef std::vector < cut_flow_item >	cut_flow_map

typedef pat::Muon	data_type

typedef std::map< index_type, double >	double_map

typedef pat::strbitset::index_type	index_type

typedef std::map< index_type, int >	int_map

Public Member Functions
void	initialize (Version_t version, double chi2=10.0, int minTrackerLayers=6, int minValidMuonHits=1, double maxIp=0.2, int minPixelHits=1, int minNMatches=2, double pfiso=0.12)

bool	operator() (const pat::Muon &muon, pat::strbitset &ret)
	This provides the interface for base classes to select objects. More...

	PFMuonSelector ()

	PFMuonSelector (edm::ParameterSet const &parameters)

bool	TopPag12LjetsCuts (const pat::Muon &muon, pat::strbitset &ret)

Public Member Functions inherited from Selector< pat::Muon >
void	clear (std::string const &s)
	Turn off a given selection cut. More...

void	clear (index_type const &i)

bool	considerCut (std::string const &s) const
	consider the cut at index "s" More...

bool	considerCut (index_type const &i) const

int	cut (index_type const &i, int val) const
	Access the int cut values at index "s". More...

double	cut (index_type const &i, double val) const
	Access the double cut values at index "s". More...

int	cut (std::string s, int val) const
	Access the int cut values at index "s". More...

double	cut (std::string s, double val) const
	Access the double cut values at index "s". More...

pat::strbitset	getBitTemplate () const
	Get an empty bitset with the proper names. More...

double	getPasses (std::string const &s) const
	Return the number of passing cases. More...

double	getPasses (index_type const &i) const

bool	ignoreCut (std::string const &s) const
	ignore the cut at index "s" More...

bool	ignoreCut (index_type const &i) const

virtual bool	operator() (pat::Muonconst &t)
	This provides an alternative signature without the second ret. More...

virtual bool	operator() (pat::Muonconst &t, edm::EventBase const &e, pat::strbitset &ret)
	This provides an alternative signature that includes extra information. More...

virtual bool	operator() (pat::Muonconst &t, edm::EventBase const &e)
	This provides an alternative signature that includes extra information. More...

bool	operator[] (std::string const &s) const

bool	operator[] (index_type const &i) const

void	passCut (pat::strbitset &ret, std::string const &s)
	Passing cuts. More...

void	passCut (pat::strbitset &ret, index_type const &i)

void	print (std::ostream &out) const
	Print the cut flow. More...

void	printActiveCuts (std::ostream &out) const
	Print the cuts being considered. More...

virtual void	push_back (std::string const &s)
	This is the registration of an individual cut string. More...

virtual void	push_back (std::string const &s, int cut)
	This is the registration of an individual cut string, with an int cut value. More...

virtual void	push_back (std::string const &s, double cut)
	This is the registration of an individual cut string, with a double cut value. More...

	Selector ()
	Constructor clears the bits. More...

void	set (std::string const &s, bool val=true)
	Set a given selection cut, on or off. More...

void	set (index_type const &i, bool val=true)

void	set (std::string const &s, int cut, bool val=true)
	Set a given selection cut, on or off, and reset int cut value. More...

void	set (index_type const &i, int cut, bool val=true)

void	set (std::string const &s, double cut, bool val=true)
	Set a given selection cut, on or off, and reset int cut value. More...

void	set (index_type const &i, double cut, bool val=true)

void	setIgnored (pat::strbitset &ret)
	set ignored bits More...

void	setIgnoredCuts (std::vector< std::string > const &bitsToIgnore)
	set the bits to ignore from a vector More...

virtual	~Selector ()

Public Attributes
bool	verbose_

Private Attributes
index_type	indexChi2_

index_type	indexMaxIp_

index_type	indexmaxPfRelIso_

index_type	indexMinTrackerLayers_

index_type	indexminValidMuHits_

index_type	indexPixHits_

index_type	indexStations_

Version_t	version_

Additional Inherited Members
Protected Attributes inherited from Selector< pat::Muon >
pat::strbitset	bits_
	the bitset indexed by strings More...

cut_flow_map	cutFlow_
	map of cut flows in "human" order More...

double_map	doubleCuts_
	the double-value cut map More...

int_map	intCuts_
	the int-value cut map More...

pat::strbitset	retInternal_
	internal ret if users don't care about return bits More...

Detailed Description

Definition at line 13 of file PFMuonSelector.h.

Member Enumeration Documentation

enum PFMuonSelector::Version_t

Enumerator
TOPPAG12_LJETS
N_VERSIONS

Definition at line 19 of file PFMuonSelector.h.

19 { TOPPAG12_LJETS, N_VERSIONS };

PFMuonSelector::TOPPAG12_LJETS

Definition: PFMuonSelector.h:19

PFMuonSelector::N_VERSIONS

Definition: PFMuonSelector.h:19

Constructor & Destructor Documentation

PFMuonSelector::PFMuonSelector ( )

inline

Definition at line 21 of file PFMuonSelector.h.

21 {}

PFMuonSelector::PFMuonSelector ( edm::ParameterSet const & parameters )

inline

Definition at line 23 of file PFMuonSelector.h.

References edm::hlt::Exception, edm::ParameterSet::exists(), Selector< pat::Muon >::getBitTemplate(), edm::ParameterSet::getParameter(), initialize(), N_VERSIONS, Selector< pat::Muon >::retInternal_, Selector< pat::Muon >::setIgnoredCuts(), AlCaHLTBitMon_QueryRunRegistry::string, TOPPAG12_LJETS, verbose_, and BeamSplash_cfg::version.

                                                        {
 
     verbose_ = false;
 
     std::string versionStr = parameters.getParameter<std::string>("version");
 
     Version_t version = N_VERSIONS;
 
     if ( versionStr == "TOPPAG12_LJETS" ) {
       version = TOPPAG12_LJETS;
     }
     else {
       throw cms::Exception("InvalidInput") << "Expect version to be one of SPRING11" << std::endl;
     }
 
     initialize( version,
                 parameters.getParameter<double>("Chi2"),
                 parameters.getParameter<int>   ("minTrackerLayers"),
                 parameters.getParameter<int>   ("minValidMuHits"),
                 parameters.getParameter<double>("maxIp"),
                 parameters.getParameter<int>   ("minPixelHits"),
                 parameters.getParameter<int>   ("minMatchedStations"),
                 parameters.getParameter<double>("maxPfRelIso")
         );
     if ( parameters.exists("cutsToIgnore") )
       setIgnoredCuts( parameters.getParameter<std::vector<std::string> >("cutsToIgnore") );
 
     retInternal_ = getBitTemplate();
 
   }

Member Function Documentation

void PFMuonSelector::initialize	(	Version_t	version,
		double	chi2 = `10.0`,
		int	minTrackerLayers = `6`,
		int	minValidMuonHits = `1`,
		double	maxIp = `0.2`,
		int	minPixelHits = `1`,
		int	minNMatches = `2`,
		double	pfiso = `0.12`
	)

inline

Definition at line 54 of file PFMuonSelector.h.

References Selector< pat::Muon >::bits_, indexChi2_, indexMaxIp_, indexmaxPfRelIso_, indexMinTrackerLayers_, indexminValidMuHits_, indexPixHits_, indexStations_, Selector< pat::Muon >::push_back(), Selector< pat::Muon >::set(), TOPPAG12_LJETS, BeamSplash_cfg::version, and version_.

Referenced by PFMuonSelector().

   {
     version_ = version;
 
     push_back("GlobalMuon",         true);
     push_back("TrackerMuon",        true);
     push_back("Chi2",               chi2   );
     push_back("minTrackerLayers",   minTrackerLayers);
     push_back("minValidMuHits",     minValidMuonHits  );
     push_back("maxIp",              maxIp );
     push_back("minPixelHits",       minPixelHits);
     push_back("minMatchedStations", minNMatches);
     push_back("maxPfRelIso",        pfiso );
 
     set("GlobalMuon");
     set("TrackerMuon");
     set("Chi2");
     set("minTrackerLayers");
     set("minValidMuHits");
     set("maxIp");
     set("minPixelHits");
     set("minMatchedStations");
     set("maxPfRelIso");
 
     indexChi2_             = index_type(&bits_, "Chi2"            );
     indexMinTrackerLayers_ = index_type(&bits_, "minTrackerLayers" );
     indexminValidMuHits_   = index_type(&bits_, "minValidMuHits"      );
     indexMaxIp_            = index_type(&bits_, "maxIp"      );
     indexPixHits_          = index_type(&bits_, "minPixelHits"      );
     indexStations_         = index_type(&bits_, "minMatchedStations");
     indexmaxPfRelIso_      = index_type(&bits_, "maxPfRelIso"           );
 
 
     if (version_ == TOPPAG12_LJETS ){
       set("TrackerMuon", false);
     }
 
   }

bool PFMuonSelector::operator()	(	const pat::Muon &	t,
		pat::strbitset &	ret
	)

inlinevirtual

This provides the interface for base classes to select objects.

Implements Selector< pat::Muon >.

Definition at line 102 of file PFMuonSelector.h.

References TOPPAG12_LJETS, TopPag12LjetsCuts(), and version_.

   {
     if (version_ == TOPPAG12_LJETS ) return TopPag12LjetsCuts(muon, ret);
     else {
       return false;
     }
   }

bool PFMuonSelector::TopPag12LjetsCuts	(	const pat::Muon &	muon,
		pat::strbitset &	ret
	)

inline

Definition at line 112 of file PFMuonSelector.h.

References Selector< pat::Muon >::cut(), pat::Muon::dB(), pat::Muon::globalTrack(), Selector< pat::Muon >::ignoreCut(), indexChi2_, indexMaxIp_, indexmaxPfRelIso_, indexMinTrackerLayers_, indexminValidMuHits_, indexPixHits_, indexStations_, pat::Muon::innerTrack(), edm::Ref< C, T, F >::isAvailable(), reco::Muon::isGlobalMuon(), edm::Ref< C, T, F >::isNonnull(), reco::Muon::isTrackerMuon(), pat::Muon::normChi2(), reco::Muon::numberOfMatches(), Selector< pat::Muon >::passCut(), pat::PfChargedHadronIso, pat::PfGammaIso, pat::PfNeutralHadronIso, RecoTauCleanerPlugins::pt, reco::LeafCandidate::pt(), run_regression::ret, pat::strbitset::set(), Selector< pat::Muon >::setIgnored(), pat::Muon::track(), and pat::Lepton< LeptonType >::userIsolation().

Referenced by operator()().

                                                                    {
 
     ret.set(false);
 
     bool isGlobal  = muon.isGlobalMuon();
     bool isTracker = muon.isTrackerMuon();
 
     double norm_chi2     = 9999999.0;
     int minTrackerLayers = 0;
     int minValidMuonHits = 0;
     int _ip = 0.0;
     int minPixelHits = 0;
     if ( muon.globalTrack().isNonnull() && muon.globalTrack().isAvailable() ){
       norm_chi2        = muon.normChi2();
       minTrackerLayers = static_cast<int> (muon.track()->hitPattern().trackerLayersWithMeasurement());
       minValidMuonHits = static_cast<int> (muon.globalTrack()->hitPattern().numberOfValidMuonHits());
       _ip = muon.dB();
       minPixelHits = muon.innerTrack()->hitPattern().numberOfValidPixelHits();
     }
 
     int minMatchedStations = muon.numberOfMatches();
 
     double chIso = muon.userIsolation(pat::PfChargedHadronIso);
     double nhIso = muon.userIsolation(pat::PfNeutralHadronIso);
     double gIso  = muon.userIsolation(pat::PfGammaIso);
     double pt    = muon.pt() ;
 
     double pfIso = (chIso + nhIso + gIso) / pt;
 
     if ( isGlobal  || ignoreCut("GlobalMuon")  )  passCut(ret, "GlobalMuon" );
     if ( isTracker || ignoreCut("TrackerMuon")  )  passCut(ret, "TrackerMuon" );
     if ( norm_chi2          <  cut(indexChi2_,   double()) || ignoreCut(indexChi2_)    ) passCut(ret, indexChi2_   );
     if ( minTrackerLayers   >= cut(indexMinTrackerLayers_,int()) || ignoreCut(indexMinTrackerLayers_)) passCut(ret, indexMinTrackerLayers_  );
     if ( minValidMuonHits   >= cut(indexminValidMuHits_,int()) || ignoreCut(indexminValidMuHits_)) passCut(ret, indexminValidMuHits_  );
     if ( _ip                <  cut(indexMaxIp_,double()) || ignoreCut(indexMaxIp_)) passCut(ret, indexMaxIp_  );
     if ( minPixelHits       >= cut(indexPixHits_,int())    || ignoreCut(indexPixHits_))  passCut(ret, indexPixHits_);
     if ( minMatchedStations >= cut(indexStations_,int())  || ignoreCut(indexStations_))  passCut(ret, indexStations_);
     if ( pfIso              <  cut(indexmaxPfRelIso_, double())  || ignoreCut(indexmaxPfRelIso_)  ) passCut(ret, indexmaxPfRelIso_ );
 
     setIgnored(ret);
 
     return (bool)ret;
   }