modules::MuonCleanerBySegmentsT< T > Class Template Reference

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)
void	produce (edm::Event &iEvent, const edm::EventSetup &iSetup) override
	~MuonCleanerBySegmentsT () override
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
	EDProducer (const EDProducer &)=delete
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final
const EDProducer &	operator= (const EDProducer &)=delete

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::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >
using	GlobalCache = typename CacheTypes::GlobalCache
using	HasAbility = AbilityChecker< T... >
using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
using	RunCache = typename CacheTypes::RunCache
using	RunContext = RunContextT< RunCache, GlobalCache >
using	RunSummaryCache = typename CacheTypes::RunSummaryCache

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.

{}

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.

References HLTMuonOfflineAnalyzer_cfi::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());
  }
}

isSameMuon() [1/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());
    }

isSameMuon() [2/3]

template<>

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

isSameMuon() [3/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.

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

produce()

template<typename T >

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

override

Definition at line 90 of file MuonCleanerBySegments.cc.

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

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

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.