heppy::CMGMuonCleanerBySegmentsAlgo Class Reference

#include <CMGMuonCleanerBySegmentsAlgo.h>

Public Member Functions
std::vector< bool >	clean (const std::vector< pat::Muon > &muons) const
	Return a vector of boolean marking the muons to be considered clean. More...
	CMGMuonCleanerBySegmentsAlgo (double sharedFraction=0.499, const std::string &preselection="track.isNonnull", const std::string &passthrough="isGlobalMuon && numberOfMatches >= 2")
	~CMGMuonCleanerBySegmentsAlgo ()

Private Member Functions
bool	isBetterMuon (const pat::Muon &mu1, bool mu1PF, const pat::Muon &mu2, bool mu2PF) const
bool	isSameMuon (const pat::Muon &mu1, const pat::Muon &mu2) const
	Methods. More...

Private Attributes
StringCutObjectSelector< pat::Muon >	passthrough_
	Always-accept cut. More...
StringCutObjectSelector< pat::Muon >	preselection_
	Preselection cut. More...
double	sharedFraction_
	Fraction of shared segments. More...

Detailed Description

Definition at line 10 of file CMGMuonCleanerBySegmentsAlgo.h.

Constructor & Destructor Documentation

CMGMuonCleanerBySegmentsAlgo()

heppy::CMGMuonCleanerBySegmentsAlgo::CMGMuonCleanerBySegmentsAlgo ( double  sharedFraction = 0.499, const std::string &  preselection = "track.isNonnull", const std::string &  passthrough = "isGlobalMuon && numberOfMatches >= 2"  )

inline

Definition at line 12 of file CMGMuonCleanerBySegmentsAlgo.h.

        : sharedFraction_(sharedFraction), preselection_(preselection, true), passthrough_(passthrough, true) {}

~CMGMuonCleanerBySegmentsAlgo()

heppy::CMGMuonCleanerBySegmentsAlgo::~CMGMuonCleanerBySegmentsAlgo

(

)

Definition at line 5 of file CMGMuonCleanerBySegmentsAlgo.cc.

{}

Member Function Documentation

clean()

std::vector< bool > heppy::CMGMuonCleanerBySegmentsAlgo::clean

(

const std::vector< pat::Muon > &

muons

)

const

Return a vector of boolean marking the muons to be considered clean.

Definition at line 7 of file CMGMuonCleanerBySegmentsAlgo.cc.

                                                                                         {
    unsigned int nsrc = src.size();
    std::vector<bool> good(nsrc, true);
    for (unsigned int i = 0; i < nsrc; ++i) {
      const pat::Muon &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 pat::Muon &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, mu1.isPFMuon(), mu2, mu2.isPFMuon())) {
            good[j] = false;
          } else {
            good[i] = false;
          }
        }
      }
    }
 
    for (unsigned int i = 0; i < nsrc; ++i) {
      const pat::Muon &mu1 = src[i];
      if (passthrough_(mu1))
        good[i] = true;
    }
 
    return good;
  }

References mps_fire::i, isBetterMuon(), reco::Muon::isPFMuon(), isSameMuon(), dqmiolumiharvest::j, reco::Muon::numberOfMatches(), passthrough_, preselection_, reco::Muon::SegmentArbitration, sharedFraction_, muon::sharedSegments(), and TrackRefitter_38T_cff::src.

isBetterMuon()

bool heppy::CMGMuonCleanerBySegmentsAlgo::isBetterMuon ( const pat::Muon &  mu1, bool  mu1PF, const pat::Muon &  mu2, bool  mu2PF  ) const

private

Definition at line 52 of file CMGMuonCleanerBySegmentsAlgo.cc.

                                                                    {
    if (mu2.track().isNull())
      return true;
    if (mu1.track().isNull())
      return false;
    if (mu1PF != mu2PF)
      return mu1PF;
    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 reco::LeafCandidate::charge(), HLTMuonOfflineAnalyzer_cfi::deltaR2, reco::Muon::isGlobalMuon(), edm::Ref< C, T, F >::isNull(), reco::Muon::numberOfMatches(), reco::LeafCandidate::pt(), reco::Muon::SegmentArbitration, and pat::Muon::track().

Referenced by clean().

isSameMuon()

bool heppy::CMGMuonCleanerBySegmentsAlgo::isSameMuon ( const pat::Muon &  mu1, const pat::Muon &  mu2  ) const

private

Methods.

Definition at line 46 of file CMGMuonCleanerBySegmentsAlgo.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().

Referenced by clean().

Member Data Documentation

passthrough_

StringCutObjectSelector<pat::Muon> heppy::CMGMuonCleanerBySegmentsAlgo::passthrough_

private

Always-accept cut.

Definition at line 28 of file CMGMuonCleanerBySegmentsAlgo.h.

Referenced by clean().

preselection_

StringCutObjectSelector<pat::Muon> heppy::CMGMuonCleanerBySegmentsAlgo::preselection_

private

Preselection cut.

Definition at line 26 of file CMGMuonCleanerBySegmentsAlgo.h.

Referenced by clean().

sharedFraction_

double heppy::CMGMuonCleanerBySegmentsAlgo::sharedFraction_

private

Fraction of shared segments.

Definition at line 23 of file CMGMuonCleanerBySegmentsAlgo.h.

Referenced by clean().