Removes duplicates from a muon collection using segment references. More...

Inheritance diagram for modules::MuonCleanerBySegmentsT< T >:

Public Member Functions
bool	isBetterMuon (const T &mu1, const T &mu2) const

bool	isSameMuon (const T &mu1, const T &mu2) const

template<>
bool	isSameMuon (const pat::Muon &mu1, const pat::Muon &mu2) const

template<>
bool	isSameMuon (const pat::Muon &mu1, const pat::Muon &mu2) const

	MuonCleanerBySegmentsT (const edm::ParameterSet &iConfig)

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

virtual	~MuonCleanerBySegmentsT ()

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

ModuleDescription const &	moduleDescription () const

virtual	~EDProducer ()

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

	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
std::vector< ConsumesInfo >	consumesInfo () const

	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

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Types
typedef std::pair< const reco::Muon , const reco::Muon >	MuonPointerPair
	Cut on the pair of objects together. More...

Private Attributes
StringCutObjectSelector < MuonPointerPair, true >	bestMuonSelector_

bool	defaultBestMuon_
	Use default criteria to choose the best muon. More...

StringCutObjectSelector< T >	passthrough_
	Always-accept cut. More...

StringCutObjectSelector< T >	preselection_
	Preselection cut. More...

double	sharedFraction_
	Fraction of shared segments. More...

edm::EDGetTokenT< edm::View< T > >	srcToken_
	Tokens for input collections. More...

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType

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

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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

template<typename T>
class modules::MuonCleanerBySegmentsT< T >

Removes duplicates from a muon collection using segment references.

      This module removes duplicates from a muon collection using segment references.

      All muons that don't pass the preselection are discarded first

      Then, for each pair of muons that share at least a given fraction of segments,
      the worse one is flagged as ghost.

      Finally, all muons that are not flagged as ghosts, or which pass a 'passthrough' selection,
      are saved in the output.

Author: Giovanni Petrucciani

Version

Id:: MuonCleanerBySegments.cc,v 1.1 2012/08/11 13:00:50 gpetrucc Exp

Definition at line 40 of file MuonCleanerBySegments.cc.

Member Typedef Documentation

template<typename T >

typedef std::pair<const reco::Muon *, const reco::Muon *> modules::MuonCleanerBySegmentsT< T >::MuonPointerPair

private

Cut on the pair of objects together.

Definition at line 69 of file MuonCleanerBySegments.cc.

Constructor & Destructor Documentation

template<typename T >

modules::MuonCleanerBySegmentsT< T >::MuonCleanerBySegmentsT ( const edm::ParameterSet & iConfig )

explicit

Definition at line 79 of file MuonCleanerBySegments.cc.

                                                                                         :
     srcToken_(consumes<edm::View<T> >(iConfig.getParameter<edm::InputTag>("src"))),
     preselection_(iConfig.existsAs<std::string>("preselection") ? iConfig.getParameter<std::string>("preselection") : ""),
     passthrough_(iConfig.existsAs<std::string>("passthrough") ? iConfig.getParameter<std::string>("passthrough") : "0"),
     sharedFraction_(iConfig.getParameter<double>("fractionOfSharedSegments")),
     defaultBestMuon_(!iConfig.existsAs<std::string>("customArbitration")),
     bestMuonSelector_(defaultBestMuon_ ? std::string("") : iConfig.getParameter<std::string>("customArbitration"))
 {
     // this is the basic output (edm::Association is not generic)
     produces<std::vector<T> >();
 }

template<typename T >

virtual modules::MuonCleanerBySegmentsT< T >::~MuonCleanerBySegmentsT ( )

inlinevirtual

Definition at line 43 of file MuonCleanerBySegments.cc.

43 { }

Member Function Documentation

template<typename T >

bool modules::MuonCleanerBySegmentsT< T >::isBetterMuon	(	const T &	mu1,
		const T &	mu2
	)		const

Definition at line 134 of file MuonCleanerBySegments.cc.

References reco::deltaR2(), and reco::Muon::SegmentArbitration.

                                                                                {
     if (!defaultBestMuon_) {
         MuonPointerPair pair = { &mu1, &mu2 };
         return bestMuonSelector_(pair);
     }
     if (mu2.track().isNull()) return true;
     if (mu1.track().isNull()) return false;
     if (mu1.isPFMuon()     != mu2.isPFMuon())     return mu1.isPFMuon();
     if (mu1.isGlobalMuon() != mu2.isGlobalMuon()) return mu1.isGlobalMuon();
     if (mu1.charge() == mu2.charge() && deltaR2(mu1,mu2) < 0.0009) {
         return mu1.track()->ptError()/mu1.track()->pt() < mu2.track()->ptError()/mu2.track()->pt();
     } else {
         int nm1 = mu1.numberOfMatches(reco::Muon::SegmentArbitration);
         int nm2 = mu2.numberOfMatches(reco::Muon::SegmentArbitration);
         return (nm1 != nm2 ? nm1 > nm2 : mu1.pt() > mu2.pt());
     }
 }

template<typename T >

bool modules::MuonCleanerBySegmentsT< T >::isSameMuon	(	const T &	mu1,
		const T &	mu2
	)		const

inline

Definition at line 47 of file MuonCleanerBySegments.cc.

                                                         {
         return (& mu1 == & mu2)  ||
                (mu1.reco::Muon::innerTrack().isNonnull() ?
                        mu1.reco::Muon::innerTrack() == mu2.reco::Muon::innerTrack() :
                        mu1.reco::Muon::outerTrack() == mu2.reco::Muon::outerTrack());
       }

template<>

bool modules::MuonCleanerBySegmentsT< pat::Muon >::isSameMuon	(	const pat::Muon &	mu1,
		const pat::Muon &	mu2
	)		const

template<>

bool modules::MuonCleanerBySegmentsT< pat::Muon >::isSameMuon	(	const pat::Muon &	mu1,
		const pat::Muon &	mu2
	)		const

Definition at line 154 of file MuonCleanerBySegments.cc.

References pat::PATObject< ObjectType >::originalObjectRef().

                                                                                                {
     return (& mu1 == & mu2)  ||
            (mu1.originalObjectRef() == mu2.originalObjectRef()) ||
            (mu1.reco::Muon::innerTrack().isNonnull() ?
                    mu1.reco::Muon::innerTrack() == mu2.reco::Muon::innerTrack() :
                    mu1.reco::Muon::outerTrack() == mu2.reco::Muon::outerTrack());
 }

template<typename T >

void modules::MuonCleanerBySegmentsT< T >::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overridevirtual

Implements edm::EDProducer.

Definition at line 93 of file MuonCleanerBySegments.cc.

References edm::Event::getByToken(), i, j, dbtoconf::out, edm::Event::put(), reco::Muon::SegmentArbitration, muon::sharedSegments(), and alcazmumu_cfi::src.

                                                                                          {
     using namespace edm;
     using namespace std;
 
     Handle<View<T> > src;
     auto_ptr<vector<T> > out(new vector<T>());
 
     iEvent.getByToken(srcToken_, src);
     unsigned int nsrc = src->size();
     out->reserve(nsrc);
     std::vector<int> good(nsrc, true);
     for (unsigned int i = 0; i < nsrc; ++i) {
         const T &mu1 = (*src)[i];
         if (!preselection_(mu1)) good[i] = false;
         if (!good[i]) continue;
         int  nSegments1 = mu1.numberOfMatches(reco::Muon::SegmentArbitration);
         for (unsigned int j = i+1; j < nsrc; ++j) {
             const T &mu2 = (*src)[j];
             if (isSameMuon(mu1,mu2)) continue;
             if (!good[j] || !preselection_(mu2)) continue;
             int nSegments2 = mu2.numberOfMatches(reco::Muon::SegmentArbitration);
             if (nSegments2 == 0 || nSegments1 == 0) continue;
             double sf = muon::sharedSegments(mu1,mu2)/std::min<double>(nSegments1,nSegments2);
             if (sf > sharedFraction_) {
                 if (isBetterMuon(mu1,mu2)) {
                     good[j] = false;
                 } else {
                     good[i] = false;
                 }
             }
         }
     }
     for (unsigned int i = 0; i < nsrc; ++i) {
         const T &mu1 = (*src)[i];
         if (good[i] || passthrough_(mu1)) out->push_back(mu1);
     }
     iEvent.put(out);
 }