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

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

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

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

	MuonCleanerBySegmentsT (const edm::ParameterSet &iConfig)

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

	~MuonCleanerBySegmentsT () override

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

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

	~EDProducer () override

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

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

std::vector< bool > const &	recordProvenanceList () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

TypeLabelList const &	typeLabelList () const
	used by the fwk to register the list of products of this module More...

	~ProducerBase () noexcept(false) override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase &&)=default

	EDConsumerBase (EDConsumerBase const &)=delete

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

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

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

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

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

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

EDConsumerBase &	operator= (EDConsumerBase &&)=default

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

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
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex > >

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)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

Protected Member Functions inherited from edm::ProducerBase
template<class ProductType >
BranchAliasSetterT< ProductType >	produces ()
	declare what type of product will make and with which optional label More...

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces ()

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces ()

BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<BranchType B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<Transition B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<class ProductType >
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

ProducesCollector	producesCollector ()

Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

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

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

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (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 38 of file MuonCleanerBySegments.cc.

Member Typedef Documentation

◆ MuonPointerPair

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 67 of file MuonCleanerBySegments.cc.

Constructor & Destructor Documentation

◆ MuonCleanerBySegmentsT()

template<typename T >

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

explicit

Definition at line 76 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> >();
 }

◆ ~MuonCleanerBySegmentsT()

template<typename T >

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

inlineoverride

Definition at line 41 of file MuonCleanerBySegments.cc.

41 {}

Member Function Documentation

◆ isBetterMuon()

template<typename T >

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

Definition at line 136 of file MuonCleanerBySegments.cc.

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

References HLTMuonOfflineAnalyzer_cfi::deltaR2, and reco::Muon::SegmentArbitration.

◆ isSameMuon() [1/3]

template<>

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

◆ isSameMuon() [2/3]

template<>

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

Definition at line 159 of file MuonCleanerBySegments.cc.

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

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

◆ isSameMuon() [3/3]

template<typename T >

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

inline

Definition at line 45 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());
     }

◆ produce()

template<typename T >

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

overridevirtual

Implements edm::EDProducer.

Definition at line 90 of file MuonCleanerBySegments.cc.

                                                                                             {
   using namespace edm;
   using namespace std;
  
   Handle<View<T> > src;
   unique_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(std::move(out));
 }

References mps_fire::i, iEvent, dqmiolumiharvest::j, eostools::move(), MillePedeFileConverter_cfg::out, reco::Muon::SegmentArbitration, muon::sharedSegments(), and TrackRefitter_38T_cff::src.

Member Data Documentation

◆ bestMuonSelector_

template<typename T >

StringCutObjectSelector<MuonPointerPair, true> modules::MuonCleanerBySegmentsT< T >::bestMuonSelector_

private

Definition at line 68 of file MuonCleanerBySegments.cc.

◆ defaultBestMuon_

template<typename T >

bool modules::MuonCleanerBySegmentsT< T >::defaultBestMuon_

private

Use default criteria to choose the best muon.

Definition at line 65 of file MuonCleanerBySegments.cc.

◆ passthrough_

template<typename T >

StringCutObjectSelector<T> modules::MuonCleanerBySegmentsT< T >::passthrough_

private

Always-accept cut.

Definition at line 59 of file MuonCleanerBySegments.cc.

◆ preselection_

template<typename T >

StringCutObjectSelector<T> modules::MuonCleanerBySegmentsT< T >::preselection_

private

Preselection cut.

Definition at line 57 of file MuonCleanerBySegments.cc.

◆ sharedFraction_

template<typename T >

double modules::MuonCleanerBySegmentsT< T >::sharedFraction_

private

Fraction of shared segments.

Definition at line 62 of file MuonCleanerBySegments.cc.

◆ srcToken_

template<typename T >

edm::EDGetTokenT<edm::View<T> > modules::MuonCleanerBySegmentsT< T >::srcToken_

private

Tokens for input collections.

Definition at line 54 of file MuonCleanerBySegments.cc.

Public Member Functions

Private Types

Private Attributes

Additional Inherited Members

Detailed Description

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

Member Typedef Documentation

◆ MuonPointerPair

Constructor & Destructor Documentation

◆ MuonCleanerBySegmentsT()

◆ ~MuonCleanerBySegmentsT()

Member Function Documentation

◆ isBetterMuon()

◆ isSameMuon() [1/3]

◆ isSameMuon() [2/3]

◆ isSameMuon() [3/3]

◆ produce()

Member Data Documentation

◆ bestMuonSelector_

◆ defaultBestMuon_

◆ passthrough_

◆ preselection_

◆ sharedFraction_

◆ srcToken_

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