muon Namespace Reference

Classes
struct	SelectionTypeStringToEnum
	a lightweight "map" for selection type string label and enum value More...
struct	SelectorStringToEnum

Enumerations
enum	AlgorithmType {   TMLastStation, TM2DCompatibility, TMOneStation, RPCMu,   ME0Mu, GEMMu }
enum	SelectionType {   All = 0, AllGlobalMuons = 1, AllStandAloneMuons = 2, AllTrackerMuons = 3,   TrackerMuonArbitrated = 4, AllArbitrated = 5, GlobalMuonPromptTight = 6, TMLastStationLoose = 7,   TMLastStationTight = 8, TM2DCompatibilityLoose = 9, TM2DCompatibilityTight = 10, TMOneStationLoose = 11,   TMOneStationTight = 12, TMLastStationOptimizedLowPtLoose = 13, TMLastStationOptimizedLowPtTight = 14, GMTkChiCompatibility = 15,   GMStaChiCompatibility = 16, GMTkKinkTight = 17, TMLastStationAngLoose = 18, TMLastStationAngTight = 19,   TMOneStationAngLoose = 20, TMOneStationAngTight = 21, TMLastStationOptimizedBarrelLowPtLoose = 22, TMLastStationOptimizedBarrelLowPtTight = 23,   RPCMuLoose = 24, AllME0Muons = 25, ME0MuonArbitrated = 26, AllGEMMuons = 27,   GEMMuonArbitrated = 28, TriggerIdLoose = 29 }
	Selector type. More...

Functions
float	caloCompatibility (const reco::Muon &muon)
reco::TrackRef	getTevRefitTrack (const reco::TrackRef &combinedTrack, const reco::TrackToTrackMap &map)
bool	isGoodMuon (const reco::Muon &muon, AlgorithmType type, double minCompatibility, reco::Muon::ArbitrationType arbitrationType)
bool	isGoodMuon (const reco::Muon &muon, AlgorithmType type, int minNumberOfMatches, double maxAbsDx, double maxAbsPullX, double maxAbsDy, double maxAbsPullY, double maxChamberDist, double maxChamberDistPull, reco::Muon::ArbitrationType arbitrationType, bool syncMinNMatchesNRequiredStationsInBarrelOnly=true, bool applyAlsoAngularCuts=false)
bool	isGoodMuon (const reco::Muon &muon, SelectionType type, reco::Muon::ArbitrationType arbitrationType=reco::Muon::SegmentAndTrackArbitration)
	main GoodMuon wrapper call More...
bool	isHighPtMuon (const reco::Muon &, const reco::Vertex &)
bool	isLooseMuon (const reco::Muon &)
bool	isLooseTriggerMuon (const reco::Muon &)
bool	isMediumMuon (const reco::Muon &, bool run2016_hip_mitigation=false)
bool	isSoftMuon (const reco::Muon &, const reco::Vertex &, bool run2016_hip_mitigation=false)
bool	isTightMuon (const reco::Muon &, const reco::Vertex &)
bool	isTrackerHighPtMuon (const reco::Muon &, const reco::Vertex &)
reco::Muon::Selector	makeSelectorBitset (reco::Muon const &muon, reco::Vertex const *vertex=nullptr, bool run2016_hip_mitigation=false)
bool	overlap (const reco::Muon &muon1, const reco::Muon &muon2, double pullX=1.0, double pullY=1.0, bool checkAdjacentChambers=false)
unsigned int	RequiredStationMask (const reco::Muon &muon, double maxChamberDist, double maxChamberDistPull, reco::Muon::ArbitrationType arbitrationType)
float	segmentCompatibility (const reco::Muon &muon, reco::Muon::ArbitrationType arbitrationType=reco::Muon::SegmentAndTrackArbitration)
SelectionType	selectionTypeFromString (const std::string &label)
reco::Muon::Selector	selectorFromString (const std::string &label)
int	sharedSegments (const reco::Muon &muon1, const reco::Muon &muon2, unsigned int segmentArbitrationMask=reco::MuonSegmentMatch::BestInChamberByDR)
reco::Muon::MuonTrackTypePair	sigmaSwitch (const reco::Muon &muon, const double nSigma=2., const double ptThreshold=200.)
reco::Muon::MuonTrackTypePair	sigmaSwitch (const reco::TrackRef &combinedTrack, const reco::TrackRef &trackerTrack, const double nSigma=2., const double ptThreshold=200.)
reco::Muon::MuonTrackTypePair	tevOptimized (const reco::Muon &muon, const double ptThreshold=200., const double tune1=17., const double tune2=40., const double dptcut=0.25)
reco::Muon::MuonTrackTypePair	tevOptimized (const reco::TrackRef &combinedTrack, const reco::TrackRef &trackerTrack, const reco::TrackRef &tpfmsTrack, const reco::TrackRef &pickyTrack, const reco::TrackRef &dytTrack, const double ptThreshold=200., const double tune1=17., const double tune2=40., const double dptcut=0.25)
reco::Muon::MuonTrackTypePair	TMR (const reco::TrackRef &trackerTrack, const reco::TrackRef &fmsTrack, const double tune=4.)
double	trackProbability (const reco::TrackRef track)

Variables
static const SelectionTypeStringToEnum	selectionTypeStringToEnumMap []
static const SelectorStringToEnum	selectorStringToEnumMap []

Enumeration Type Documentation

AlgorithmType

enum muon::AlgorithmType

Enumerator
TMLastStation
TM2DCompatibility
TMOneStation
RPCMu
ME0Mu
GEMMu

Definition at line 154 of file MuonSelectors.h.

{ TMLastStation, TM2DCompatibility, TMOneStation, RPCMu, ME0Mu, GEMMu };

SelectionType

enum muon::SelectionType

Selector type.

Enumerator
All
AllGlobalMuons
AllStandAloneMuons
AllTrackerMuons
TrackerMuonArbitrated
AllArbitrated
GlobalMuonPromptTight
TMLastStationLoose
TMLastStationTight
TM2DCompatibilityLoose
TM2DCompatibilityTight
TMOneStationLoose
TMOneStationTight
TMLastStationOptimizedLowPtLoose
TMLastStationOptimizedLowPtTight
GMTkChiCompatibility
GMStaChiCompatibility
GMTkKinkTight
TMLastStationAngLoose
TMLastStationAngTight
TMOneStationAngLoose
TMOneStationAngTight
TMLastStationOptimizedBarrelLowPtLoose
TMLastStationOptimizedBarrelLowPtTight
RPCMuLoose
AllME0Muons
ME0MuonArbitrated
AllGEMMuons
GEMMuonArbitrated
TriggerIdLoose

Definition at line 18 of file MuonSelectors.h.

                     {
    All = 0,                                // dummy options - always true
    AllGlobalMuons = 1,                     // checks isGlobalMuon flag
    AllStandAloneMuons = 2,                 // checks isStandAloneMuon flag
    AllTrackerMuons = 3,                    // checks isTrackerMuon flag
    TrackerMuonArbitrated = 4,              // resolve ambiguity of sharing segments
    AllArbitrated = 5,                      // all muons with the tracker muon arbitrated
    GlobalMuonPromptTight = 6,              // global muons with tighter fit requirements
    TMLastStationLoose = 7,                 // penetration depth loose selector
    TMLastStationTight = 8,                 // penetration depth tight selector
    TM2DCompatibilityLoose = 9,             // likelihood based loose selector
    TM2DCompatibilityTight = 10,            // likelihood based tight selector
    TMOneStationLoose = 11,                 // require one well matched segment
    TMOneStationTight = 12,                 // require one well matched segment
    TMLastStationOptimizedLowPtLoose = 13,  // combination of TMLastStation and TMOneStation
    TMLastStationOptimizedLowPtTight = 14,  // combination of TMLastStation and TMOneStation
    GMTkChiCompatibility = 15,              // require tk stub have good chi2 relative to glb track
    GMStaChiCompatibility = 16,             // require sta stub have good chi2 compatibility relative to glb track
    GMTkKinkTight = 17,                     // require a small kink value in the tracker stub
    TMLastStationAngLoose = 18,             // TMLastStationLoose with additional angular cuts
    TMLastStationAngTight = 19,             // TMLastStationTight with additional angular cuts
    TMOneStationAngLoose = 20,              // TMOneStationLoose with additional angular cuts
    TMOneStationAngTight = 21,              // TMOneStationTight with additional angular cuts
    // The two algorithms that follow are identical to what were known as
    // TMLastStationOptimizedLowPt* (sans the Barrel) as late as revision
    // 1.7 of this file. The names were changed because indeed the low pt
    // optimization applies only to the barrel region, whereas the sel-
    // ectors above are more efficient at low pt in the endcaps, which is
    // what we feel is more suggestive of the algorithm name. This will be
    // less confusing for future generations of CMS members, I hope...
    // combination of TMLastStation and TMOneStation but with low pT optimization in barrel only
    TMLastStationOptimizedBarrelLowPtLoose = 22,
    // combination of TMLastStation and TMOneStation but with low pT optimization in barrel only
    TMLastStationOptimizedBarrelLowPtTight = 23,
    RPCMuLoose = 24,  // checks isRPCMuon flag (require two well matched hits in different RPC layers)
    AllME0Muons = 25,
    ME0MuonArbitrated = 26,
    AllGEMMuons = 27,
    GEMMuonArbitrated = 28,
    TriggerIdLoose = 29
  };

Function Documentation

caloCompatibility()

float muon::caloCompatibility

(

const reco::Muon &

muon

)

Definition at line 58 of file MuonSelectors.cc.

{ return muon.caloCompatibility(); }

Referenced by CSCEfficiency::filter(), isGoodMuon(), and pat::MuonSelector::muIdSelection_().

getTevRefitTrack()

reco::TrackRef muon::getTevRefitTrack	(	const reco::TrackRef &	combinedTrack,
		const reco::TrackToTrackMap &	map
	)

Definition at line 131 of file MuonCocktails.cc.

                                                                                                     {
  reco::TrackToTrackMap::const_iterator it = map.find(combinedTrack);
  return it == map.end() ? reco::TrackRef() : it->val;
}

References genParticles_cff::map, and edm::helpers::KeyVal< K, V >::val.

Referenced by MuonIdProducer::makeMuon().

isGoodMuon() [1/3]

bool muon::isGoodMuon	(	const reco::Muon &	muon,
		AlgorithmType	type,
		double	minCompatibility,
		reco::Muon::ArbitrationType	arbitrationType
	)

Definition at line 293 of file MuonSelectors.cc.

                                                               {
  if (!muon.isMatchesValid())
    return false;
  bool goodMuon = false;
 
  switch (type) {
    case TM2DCompatibility:
      // Simplistic first cut in the 2D segment- vs calo-compatibility plane. Will have to be refined!
      if (((0.8 * caloCompatibility(muon)) + (1.2 * segmentCompatibility(muon, arbitrationType))) > minCompatibility)
        goodMuon = true;
      else
        goodMuon = false;
      return goodMuon;
      break;
    default:
      //    LogTrace("MuonIdentification")<<"            // Invalid Algorithm Type called!";
      goodMuon = false;
      return goodMuon;
      break;
  }
}

References caloCompatibility(), segmentCompatibility(), and TM2DCompatibility.

isGoodMuon() [2/3]

bool muon::isGoodMuon	(	const reco::Muon &	muon,
		AlgorithmType	type,
		int	minNumberOfMatches,
		double	maxAbsDx,
		double	maxAbsPullX,
		double	maxAbsDy,
		double	maxAbsPullY,
		double	maxChamberDist,
		double	maxChamberDistPull,
		reco::Muon::ArbitrationType	arbitrationType,
		bool	syncMinNMatchesNRequiredStationsInBarrelOnly = true,
		bool	applyAlsoAngularCuts = false
	)

Definition at line 318 of file MuonSelectors.cc.

                                                 {
  if (!muon.isMatchesValid())
    return false;
  bool goodMuon = false;
 
  if (type == TMLastStation) {
    // To satisfy my own paranoia, if the user specifies that the
    // minimum number of matches is zero, then return true.
    if (minNumberOfMatches == 0)
      return true;
 
    unsigned int theStationMask = muon.stationMask(arbitrationType);
    unsigned int theRequiredStationMask =
        RequiredStationMask(muon, maxChamberDist, maxChamberDistPull, arbitrationType);
 
    // Require that there be at least a minimum number of segments
    int numSegs = 0;
    int numRequiredStations = 0;
    for (int it = 0; it < 8; ++it) {
      if (theStationMask & 1 << it)
        ++numSegs;
      if (theRequiredStationMask & 1 << it)
        ++numRequiredStations;
    }
 
    // Make sure the minimum number of matches is not greater than
    // the number of required stations but still greater than zero
    if (syncMinNMatchesNRequiredStationsInBarrelOnly) {
      // Note that we only do this in the barrel region!
      if (std::abs(muon.eta()) < 1.2) {
        if (minNumberOfMatches > numRequiredStations)
          minNumberOfMatches = numRequiredStations;
        if (minNumberOfMatches < 1)  //SK: this only happens for negative values
          minNumberOfMatches = 1;
      }
    } else {
      if (minNumberOfMatches > numRequiredStations)
        minNumberOfMatches = numRequiredStations;
      if (minNumberOfMatches < 1)  //SK: this only happens for negative values
        minNumberOfMatches = 1;
    }
 
    if (numSegs >= minNumberOfMatches)
      goodMuon = true;
 
    // Require that last required station have segment
    // If there are zero required stations keep track
    // of the last station with a segment so that we may
    // apply the quality cuts below to it instead
    int lastSegBit = 0;
    if (theRequiredStationMask) {
      for (int stationIdx = 7; stationIdx >= 0; --stationIdx)
        if (theRequiredStationMask & 1 << stationIdx) {
          if (theStationMask & 1 << stationIdx) {
            lastSegBit = stationIdx;
            goodMuon &= 1;
            break;
          } else {
            goodMuon = false;
            break;
          }
        }
    } else {
      for (int stationIdx = 7; stationIdx >= 0; --stationIdx)
        if (theStationMask & 1 << stationIdx) {
          lastSegBit = stationIdx;
          break;
        }
    }
 
    if (!goodMuon)
      return false;
 
    // Impose pull cuts on last segment
    int station = 0, detector = 0;
    station = lastSegBit < 4 ? lastSegBit + 1 : lastSegBit - 3;
    detector = lastSegBit < 4 ? 1 : 2;
 
    // Check x information
    if (std::abs(muon.pullX(station, detector, arbitrationType, true)) > maxAbsPullX &&
        std::abs(muon.dX(station, detector, arbitrationType)) > maxAbsDx)
      return false;
 
    if (applyAlsoAngularCuts && std::abs(muon.pullDxDz(station, detector, arbitrationType, true)) > maxAbsPullX)
      return false;
 
    // Is this a tight algorithm, i.e. do we bother to check y information?
    if (maxAbsDy < 999999) {  // really if maxAbsDy < 1E9 as currently defined
 
      // Check y information
      if (detector == 2) {  // CSC
        if (std::abs(muon.pullY(station, 2, arbitrationType, true)) > maxAbsPullY &&
            std::abs(muon.dY(station, 2, arbitrationType)) > maxAbsDy)
          return false;
 
        if (applyAlsoAngularCuts && std::abs(muon.pullDyDz(station, 2, arbitrationType, true)) > maxAbsPullY)
          return false;
      } else {
        //
        // In DT, if this is a "Tight" algorithm and the last segment is
        // missing y information (always the case in station 4!!!), impose
        // respective cuts on the next station in the stationMask that has
        // a segment with y information.  If there are no segments with y
        // information then there is nothing to penalize. Should we
        // penalize in Tight for having zero segments with y information?
        // That is the fundamental question.  Of course I am being uber
        // paranoid; if this is a good muon then there will probably be at
        // least one segment with y information but not always.  Suppose
        // somehow a muon only creates segments in station 4, then we
        // definitely do not want to require that there be at least one
        // segment with y information because we will lose it completely.
        //
 
        for (int stationIdx = station; stationIdx > 0; --stationIdx) {
          if (!(theStationMask & 1 << (stationIdx - 1)))  // don't bother if the station is not in the stationMask
            continue;
 
          if (muon.dY(stationIdx, 1, arbitrationType) > 999998)  // no y-information
            continue;
 
          if (std::abs(muon.pullY(stationIdx, 1, arbitrationType, true)) > maxAbsPullY &&
              std::abs(muon.dY(stationIdx, 1, arbitrationType)) > maxAbsDy) {
            return false;
          }
 
          if (applyAlsoAngularCuts && std::abs(muon.pullDyDz(stationIdx, 1, arbitrationType, true)) > maxAbsPullY)
            return false;
 
          // If we get this far then great this is a good muon
          return true;
        }
      }
    }
 
    return goodMuon;
  }  // TMLastStation
 
  // TMOneStation requires only that there be one "good" segment, regardless
  // of the required stations.  We do not penalize if there are absolutely zero
  // segments with y information in the Tight algorithm.  Maybe I'm being
  // paranoid but so be it.  If it's really a good muon then we will probably
  // find at least one segment with both x and y information but you never
  // know, and I don't want to deal with a potential inefficiency in the DT
  // like we did with the original TMLastStation.  Incidentally, not penalizing
  // for total lack of y information in the Tight algorithm is what is done in
  // the new TMLastStation
  //
  if (type == TMOneStation) {
    unsigned int theStationMask = muon.stationMask(arbitrationType);
 
    // Of course there must be at least one segment
    if (!theStationMask)
      return false;
 
    int station = 0, detector = 0;
    // Keep track of whether or not there is a DT segment with y information.
    // In the end, if it turns out there are absolutely zero DT segments with
    // y information, require only that there was a segment with good x info.
    // This of course only applies to the Tight algorithms.
    bool existsGoodDTSegX = false;
    bool existsDTSegY = false;
 
    // Impose cuts on the segments in the station mask until we find a good one
    // Might as well start with the lowest bit to speed things up.
    for (int stationIdx = 0; stationIdx <= 7; ++stationIdx)
      if (theStationMask & 1 << stationIdx) {
        station = stationIdx < 4 ? stationIdx + 1 : stationIdx - 3;
        detector = stationIdx < 4 ? 1 : 2;
 
        if ((std::abs(muon.pullX(station, detector, arbitrationType, true)) > maxAbsPullX &&
             std::abs(muon.dX(station, detector, arbitrationType)) > maxAbsDx) ||
            (applyAlsoAngularCuts && std::abs(muon.pullDxDz(station, detector, arbitrationType, true)) > maxAbsPullX))
          continue;
        else if (detector == 1)
          existsGoodDTSegX = true;
 
        // Is this a tight algorithm?  If yes, use y information
        if (maxAbsDy < 999999) {
          if (detector == 2) {  // CSC
            if ((std::abs(muon.pullY(station, 2, arbitrationType, true)) > maxAbsPullY &&
                 std::abs(muon.dY(station, 2, arbitrationType)) > maxAbsDy) ||
                (applyAlsoAngularCuts && std::abs(muon.pullDyDz(station, 2, arbitrationType, true)) > maxAbsPullY))
              continue;
          } else {
            if (muon.dY(station, 1, arbitrationType) > 999998)  // no y-information
              continue;
            else
              existsDTSegY = true;
 
            if ((std::abs(muon.pullY(station, 1, arbitrationType, true)) > maxAbsPullY &&
                 std::abs(muon.dY(station, 1, arbitrationType)) > maxAbsDy) ||
                (applyAlsoAngularCuts && std::abs(muon.pullDyDz(station, 1, arbitrationType, true)) > maxAbsPullY)) {
              continue;
            }
          }
        }
 
        // If we get this far then great this is a good muon
        return true;
      }
 
    // If we get this far then for sure there are no "good" CSC segments. For
    // DT, check if there were any segments with y information.  If there
    // were none, but there was a segment with good x, then we're happy. If
    // there WERE segments with y information, then they must have been shit
    // since we are here so fail it.  Of course, if this is a Loose algorithm
    // then fail immediately since if we had good x we would already have
    // returned true
    if (maxAbsDy < 999999) {
      if (existsDTSegY)
        return false;
      else if (existsGoodDTSegX)
        return true;
    } else
      return false;
  }  // TMOneStation
 
  if (type == RPCMu) {
    if (minNumberOfMatches == 0)
      return true;
 
    int nMatch = 0;
    for (const auto& chamberMatch : muon.matches()) {
      if (chamberMatch.detector() != MuonSubdetId::RPC)
        continue;
 
      const float trkX = chamberMatch.x;
      const float errX = chamberMatch.xErr;
 
      for (const auto& rpcMatch : chamberMatch.rpcMatches) {
        const float rpcX = rpcMatch.x;
        const float dX = std::abs(rpcX - trkX);
        if (dX < maxAbsDx or dX < maxAbsPullX * errX) {
          ++nMatch;
          break;
        }
      }
    }
 
    if (nMatch >= minNumberOfMatches)
      return true;
    else
      return false;
  }  // RPCMu
 
  if (type == ME0Mu) {
    if (minNumberOfMatches == 0)
      return true;
 
    int nMatch = 0;
    for (const auto& chamberMatch : muon.matches()) {
      if (chamberMatch.detector() != MuonSubdetId::ME0)
        continue;
 
      const float trkX = chamberMatch.x;
      const float errX2 = chamberMatch.xErr * chamberMatch.xErr;
      const float trkY = chamberMatch.y;
      const float errY2 = chamberMatch.yErr * chamberMatch.yErr;
 
      for (const auto& segment : chamberMatch.me0Matches) {
        const float me0X = segment.x;
        const float me0ErrX2 = segment.xErr * segment.xErr;
        const float me0Y = segment.y;
        const float me0ErrY2 = segment.yErr * segment.yErr;
 
        const float dX = std::abs(me0X - trkX);
        const float dY = std::abs(me0Y - trkY);
        const float invPullX2 = errX2 + me0ErrX2;
        const float invPullY2 = errY2 + me0ErrY2;
 
        if ((dX < maxAbsDx or dX < maxAbsPullX * std::sqrt(invPullX2)) and
            (dY < maxAbsDy or dY < maxAbsPullY * std::sqrt(invPullY2))) {
          ++nMatch;
          break;
        }
      }
    }
 
    return (nMatch >= minNumberOfMatches);
  }  // ME0Mu
 
  if (type == GEMMu) {
    if (minNumberOfMatches == 0)
      return true;
 
    int nMatch = 0;
    for (const auto& chamberMatch : muon.matches()) {
      if (chamberMatch.detector() != MuonSubdetId::GEM)
        continue;
 
      const float trkX = chamberMatch.x;
      const float errX2 = chamberMatch.xErr * chamberMatch.xErr;
      const float trkY = chamberMatch.y;
      const float errY2 = chamberMatch.yErr * chamberMatch.yErr;
 
      for (const auto& segment : chamberMatch.gemMatches) {
        const float gemX = segment.x;
        const float gemErrX2 = segment.xErr * segment.xErr;
        const float gemY = segment.y;
        const float gemErrY2 = segment.yErr * segment.yErr;
 
        const float dX = std::abs(gemX - trkX);
        const float dY = std::abs(gemY - trkY);
        const float invPullX2 = errX2 + gemErrX2;
        const float invPullY2 = errY2 + gemErrY2;
 
        if ((dX < maxAbsDx or dX < maxAbsPullX * std::sqrt(invPullX2)) and
            (dY < maxAbsDy or dY < maxAbsPullY * std::sqrt(invPullY2))) {
          ++nMatch;
          break;
        }
      }
    }
 
    return (nMatch >= minNumberOfMatches);
  }  // GEMMu
 
  return goodMuon;
}

References funct::abs(), hgcalTestNeighbor_cfi::detector, fftjetvertexadder_cfi::errX, MuonSubdetId::GEM, GEMMu, HLT_FULL_cff::maxAbsDx, HLT_FULL_cff::maxAbsDy, HLT_FULL_cff::maxAbsPullX, HLT_FULL_cff::maxAbsPullY, MuonSubdetId::ME0, ME0Mu, HLT_FULL_cff::minNumberOfMatches, or, RequiredStationMask(), MuonSubdetId::RPC, RPCMu, mathSSE::sqrt(), relativeConstraints::station, TMLastStation, and TMOneStation.

isGoodMuon() [3/3]

bool muon::isGoodMuon	(	const reco::Muon &	muon,
		SelectionType	type,
		reco::Muon::ArbitrationType	arbitrationType = reco::Muon::SegmentAndTrackArbitration
	)

main GoodMuon wrapper call

Definition at line 649 of file MuonSelectors.cc.

                                                                                                       {
  switch (type) {
    case muon::All:
      return true;
      break;
    case muon::AllGlobalMuons:
      return muon.isGlobalMuon();
      break;
    case muon::AllTrackerMuons:
      return muon.isTrackerMuon();
      break;
    case muon::AllStandAloneMuons:
      return muon.isStandAloneMuon();
      break;
    case muon::TrackerMuonArbitrated:
      return muon.isTrackerMuon() && muon.numberOfMatches(arbitrationType) > 0;
      break;
    case muon::AllArbitrated:
      return !muon.isTrackerMuon() || muon.numberOfMatches(arbitrationType) > 0;
      break;
    case muon::GlobalMuonPromptTight:
      return muon.isGlobalMuon() && muon.globalTrack()->normalizedChi2() < 10. &&
             muon.globalTrack()->hitPattern().numberOfValidMuonHits() > 0;
      break;
      // For "Loose" algorithms we choose maximum y quantity cuts of 1E9 instead of
      // 9999 as before.  We do this because the muon methods return 999999 (note
      // there are six 9's) when the requested information is not available.  For
      // example, if a muon fails to traverse the z measuring superlayer in a station
      // in the DT, then all methods involving segmentY in this station return
      // 999999 to demonstrate that the information is missing.  In order to not
      // penalize muons for missing y information in Loose algorithms where we do
      // not care at all about y information, we raise these limits.  In the
      // TMLastStation and TMOneStation algorithms we actually use this huge number
      // to determine whether to consider y information at all.
    case muon::TMLastStationLoose:
      return muon.isTrackerMuon() &&
             isGoodMuon(muon, TMLastStation, 2, 3, 3, 1E9, 1E9, -3, -3, arbitrationType, true, false);
      break;
    case muon::TMLastStationTight:
      return muon.isTrackerMuon() &&
             isGoodMuon(muon, TMLastStation, 2, 3, 3, 3, 3, -3, -3, arbitrationType, true, false);
      break;
    case muon::TMOneStationLoose:
      return muon.isTrackerMuon() &&
             isGoodMuon(muon, TMOneStation, 1, 3, 3, 1E9, 1E9, 1E9, 1E9, arbitrationType, false, false);
      break;
    case muon::TMOneStationTight:
      return muon.isTrackerMuon() &&
             isGoodMuon(muon, TMOneStation, 1, 3, 3, 3, 3, 1E9, 1E9, arbitrationType, false, false);
      break;
    case muon::TMLastStationOptimizedLowPtLoose:
      if (muon.pt() < 8. && std::abs(muon.eta()) < 1.2)
        return muon.isTrackerMuon() &&
               isGoodMuon(muon, TMOneStation, 1, 3, 3, 1E9, 1E9, 1E9, 1E9, arbitrationType, false, false);
      else
        return muon.isTrackerMuon() &&
               isGoodMuon(muon, TMLastStation, 2, 3, 3, 1E9, 1E9, -3, -3, arbitrationType, false, false);
      break;
    case muon::TMLastStationOptimizedLowPtTight:
      if (muon.pt() < 8. && std::abs(muon.eta()) < 1.2)
        return muon.isTrackerMuon() &&
               isGoodMuon(muon, TMOneStation, 1, 3, 3, 3, 3, 1E9, 1E9, arbitrationType, false, false);
      else
        return muon.isTrackerMuon() &&
               isGoodMuon(muon, TMLastStation, 2, 3, 3, 3, 3, -3, -3, arbitrationType, false, false);
      break;
      //compatibility loose
    case muon::TM2DCompatibilityLoose:
      return muon.isTrackerMuon() && isGoodMuon(muon, TM2DCompatibility, 0.7, arbitrationType);
      break;
      //compatibility tight
    case muon::TM2DCompatibilityTight:
      return muon.isTrackerMuon() && isGoodMuon(muon, TM2DCompatibility, 1.0, arbitrationType);
      break;
    case muon::GMTkChiCompatibility:
      return muon.isGlobalMuon() && muon.isQualityValid() &&
             std::abs(muon.combinedQuality().trkRelChi2 - muon.innerTrack()->normalizedChi2()) < 2.0;
      break;
    case muon::GMStaChiCompatibility:
      return muon.isGlobalMuon() && muon.isQualityValid() &&
             std::abs(muon.combinedQuality().staRelChi2 - muon.outerTrack()->normalizedChi2()) < 2.0;
      break;
    case muon::GMTkKinkTight:
      return muon.isGlobalMuon() && muon.isQualityValid() && muon.combinedQuality().trkKink < 100.0;
      break;
    case muon::TMLastStationAngLoose:
      return muon.isTrackerMuon() &&
             isGoodMuon(muon, TMLastStation, 2, 3, 3, 1E9, 1E9, -3, -3, arbitrationType, false, true);
      break;
    case muon::TMLastStationAngTight:
      return muon.isTrackerMuon() &&
             isGoodMuon(muon, TMLastStation, 2, 3, 3, 3, 3, -3, -3, arbitrationType, false, true);
      break;
    case muon::TMOneStationAngLoose:
      return muon.isTrackerMuon() &&
             isGoodMuon(muon, TMOneStation, 1, 3, 3, 1E9, 1E9, 1E9, 1E9, arbitrationType, false, true);
      break;
    case muon::TMOneStationAngTight:
      return muon.isTrackerMuon() &&
             isGoodMuon(muon, TMOneStation, 1, 3, 3, 3, 3, 1E9, 1E9, arbitrationType, false, true);
      break;
    case muon::TMLastStationOptimizedBarrelLowPtLoose:
      if (muon.pt() < 8. && std::abs(muon.eta()) < 1.2)
        return muon.isTrackerMuon() &&
               isGoodMuon(muon, TMOneStation, 1, 3, 3, 1E9, 1E9, 1E9, 1E9, arbitrationType, false, false);
      else
        return muon.isTrackerMuon() &&
               isGoodMuon(muon, TMLastStation, 2, 3, 3, 1E9, 1E9, -3, -3, arbitrationType, true, false);
      break;
    case muon::TMLastStationOptimizedBarrelLowPtTight:
      if (muon.pt() < 8. && std::abs(muon.eta()) < 1.2)
        return muon.isTrackerMuon() &&
               isGoodMuon(muon, TMOneStation, 1, 3, 3, 3, 3, 1E9, 1E9, arbitrationType, false, false);
      else
        return muon.isTrackerMuon() &&
               isGoodMuon(muon, TMLastStation, 2, 3, 3, 3, 3, -3, -3, arbitrationType, true, false);
      break;
    case muon::RPCMuLoose:
      return muon.isRPCMuon() && isGoodMuon(muon, RPCMu, 2, 20, 4, 1e9, 1e9, 1e9, 1e9, arbitrationType, false, false);
      break;
    case muon::AllME0Muons:
      return muon.isME0Muon();
      break;
    case muon::ME0MuonArbitrated:
      return muon.isME0Muon() &&
             isGoodMuon(muon, ME0Mu, 1, 1e9, 1e9, 1e9, 1e9, 1e9, 1e9, arbitrationType, false, false);
      break;
    case muon::AllGEMMuons:
      return muon.isGEMMuon();
      break;
    case muon::GEMMuonArbitrated:
      return muon.isGEMMuon() &&
             isGoodMuon(muon, GEMMu, 1, 1e9, 1e9, 1e9, 1e9, 1e9, 1e9, arbitrationType, false, false);
      break;
    case muon::TriggerIdLoose:
      return isLooseTriggerMuon(muon);
      break;
    default:
      return false;
  }
}

References funct::abs(), All, AllArbitrated, AllGEMMuons, AllGlobalMuons, AllME0Muons, AllStandAloneMuons, AllTrackerMuons, GEMMu, GEMMuonArbitrated, GlobalMuonPromptTight, GMStaChiCompatibility, GMTkChiCompatibility, GMTkKinkTight, isLooseTriggerMuon(), ME0Mu, ME0MuonArbitrated, RPCMu, RPCMuLoose, TM2DCompatibility, TM2DCompatibilityLoose, TM2DCompatibilityTight, TMLastStation, TMLastStationAngLoose, TMLastStationAngTight, TMLastStationLoose, TMLastStationOptimizedBarrelLowPtLoose, TMLastStationOptimizedBarrelLowPtTight, TMLastStationOptimizedLowPtLoose, TMLastStationOptimizedLowPtTight, TMLastStationTight, TMOneStation, TMOneStationAngLoose, TMOneStationAngTight, TMOneStationLoose, TMOneStationTight, TrackerMuonArbitrated, and TriggerIdLoose.

Referenced by BPHSoftMuonSelect::accept(), BPhysicsOniaDQM::analyze(), ExampleMuonAnalyzer::analyze(), TrackEfficiencyMonitor::analyze(), HiggsDQM::analyze(), MuonIdVal::analyze(), MuonCosmicCompatibilityFiller::checkMuonID(), PFRecoTauDiscriminationAgainstMuon::discriminate(), ZtoMMEventSelector::filter(), HLTMuonTrkFilter::hltFilter(), HLTMuonTrkL1TFilter::hltFilter(), HLTDiMuonGlbTrkFilter::hltFilter(), HLTMuonL3PreFilter::hltFilter(), PFMuonAlgo::isGlobalLooseMuon(), PFMuonAlgo::isGlobalTightMuon(), isLooseTriggerMuon(), isSoftMuon(), MuonIDTableProducer::isSoftMuonHIP(), isTightMuon(), PFMuonAlgo::isTightMuonPOG(), PFMuonAlgo::isTrackerLooseMuon(), PFMuonAlgo::isTrackerTightMuon(), PFB::match(), JetPlusTrackCorrector::matchMuons(), pat::MuonSelector::muIdSelection_(), MuonSelectorVIDWrapper< selectionType, arbitrationType >::operator()(), MuonBadTrackFilter::printMuonProperties(), PFMuonAlgo::printMuonProperties(), MuonIDFilterProducerForHLT::produce(), MuonSelectionTypeValueMapProducer::produce(), MuonRefProducer::produce(), MuonTrackProducer::produce(), pat::PackedCandidateMuonSelectorProducer::produce(), SoftLepton::produce(), and MuonSelectorVIDWrapper< selectionType, arbitrationType >::value().

isHighPtMuon()

bool muon::isHighPtMuon	(	const reco::Muon &	muon,
		const reco::Vertex &	vtx
	)

Definition at line 933 of file MuonSelectors.cc.

                                                                   {
  if (!muon.isGlobalMuon())
    return false;
 
  bool muValHits = (muon.globalTrack()->hitPattern().numberOfValidMuonHits() > 0 ||
                    muon.tunePMuonBestTrack()->hitPattern().numberOfValidMuonHits() > 0);
 
  bool muMatchedSt = muon.numberOfMatchedStations() > 1;
  if (!muMatchedSt) {
    if (muon.isTrackerMuon() && muon.numberOfMatchedStations() == 1) {
      if (muon.expectedNnumberOfMatchedStations() < 2 || !(muon.stationMask() == 1 || muon.stationMask() == 16) ||
          muon.numberOfMatchedRPCLayers() > 2)
        muMatchedSt = true;
    }
  }
 
  bool muID = muValHits && muMatchedSt;
 
  bool hits = muon.innerTrack()->hitPattern().trackerLayersWithMeasurement() > 5 &&
              muon.innerTrack()->hitPattern().numberOfValidPixelHits() > 0;
 
  bool momQuality = muon.tunePMuonBestTrack()->ptError() / muon.tunePMuonBestTrack()->pt() < 0.3;
 
  bool ip =
      std::abs(muon.innerTrack()->dxy(vtx.position())) < 0.2 && std::abs(muon.innerTrack()->dz(vtx.position())) < 0.5;
 
  return muID && hits && momQuality && ip;
}

References funct::abs(), hfClusterShapes_cfi::hits, and extraflags_cff::vtx.

Referenced by MuonKinVsEtaAnalyzer::analyze(), makeSelectorBitset(), Muon.Muon::muonID(), MuonPOGStandardCut::operator()(), MuonMiniAOD::PassesCut_A(), HLTDQMMuonSelector::passMuonSel(), MuonIDTableProducer::produce(), and MuonPOGStandardCut::value().

isLooseMuon()

bool muon::isLooseMuon

(

const reco::Muon &

muon

)

Definition at line 895 of file MuonSelectors.cc.

                                           {
  return muon.isPFMuon() && (muon.isGlobalMuon() || muon.isTrackerMuon());
}

Referenced by DiMuonHistograms::analyze(), EfficiencyAnalyzer::analyze(), MuonKinVsEtaAnalyzer::analyze(), L1TTauOffline::getTightMuons(), isMediumMuon(), MuonIDTableProducer::isMediumMuonHIP(), Muon.Muon::looseId(), makeSelectorBitset(), Muon.Muon::muonID(), MuonPOGStandardCut::operator()(), MuonMiniAOD::PassesCut_A(), ZCounting::passMuonID(), HLTDQMMuonSelector::passMuonSel(), SoftPFMuonTagInfoProducer::produce(), and MuonPOGStandardCut::value().

isLooseTriggerMuon()

bool muon::isLooseTriggerMuon

(

const reco::Muon &

muon

)

Definition at line 866 of file MuonSelectors.cc.

                                                  {
  // Requirements:
  // - no depencence on information not availabe in the muon object
  // - use only robust inputs
  bool tk_id = muon::isGoodMuon(muon, TMOneStationTight);
  if (not tk_id)
    return false;
  bool layer_requirements = muon.innerTrack()->hitPattern().trackerLayersWithMeasurement() > 5 &&
                            muon.innerTrack()->hitPattern().pixelLayersWithMeasurement() > 0;
  bool match_requirements =
      (muon.expectedNnumberOfMatchedStations() < 2) or (muon.numberOfMatchedStations() > 1) or (muon.pt() < 8);
  return layer_requirements and match_requirements;
}

References isGoodMuon(), or, and TMOneStationTight.

Referenced by isGoodMuon(), makeSelectorBitset(), and MuonIDFilterProducerForHLT::produce().

isMediumMuon()

bool muon::isMediumMuon	(	const reco::Muon &	muon,
		bool	run2016_hip_mitigation = false
	)

Definition at line 899 of file MuonSelectors.cc.

                                                                         {
  if (not isLooseMuon(muon))
    return false;
  if (run2016_hip_mitigation) {
    if (muon.innerTrack()->validFraction() < 0.49)
      return false;
  } else {
    if (muon.innerTrack()->validFraction() < 0.8)
      return false;
  }
 
  bool goodGlb = muon.isGlobalMuon() && muon.globalTrack()->normalizedChi2() < 3. &&
                 muon.combinedQuality().chi2LocalPosition < 12. && muon.combinedQuality().trkKink < 20.;
 
  return (segmentCompatibility(muon) > (goodGlb ? 0.303 : 0.451));
}

References isLooseMuon(), and segmentCompatibility().

Referenced by DiMuonHistograms::analyze(), EfficiencyAnalyzer::analyze(), MuonKinVsEtaAnalyzer::analyze(), HcalHBHEMuonAnalyzer::analyze(), makeSelectorBitset(), MuonPOGStandardCut::operator()(), MuonMiniAOD::PassesCut_A(), ZCounting::passMuonID(), HLTDQMMuonSelector::passMuonSel(), MuonIDTableProducer::produce(), BadGlobalMuonTagger::tighterId(), and MuonPOGStandardCut::value().

isSoftMuon()

bool muon::isSoftMuon	(	const reco::Muon &	muon,
		const reco::Vertex &	vtx,
		bool	run2016_hip_mitigation = false
	)

Definition at line 916 of file MuonSelectors.cc.

                                                                                              {
  bool muID = muon::isGoodMuon(muon, TMOneStationTight);
 
  if (!muID)
    return false;
 
  bool layers = muon.innerTrack()->hitPattern().trackerLayersWithMeasurement() > 5 &&
                muon.innerTrack()->hitPattern().pixelLayersWithMeasurement() > 0;
 
  bool ishighq = muon.innerTrack()->quality(reco::Track::highPurity);
 
  bool ip =
      std::abs(muon.innerTrack()->dxy(vtx.position())) < 0.3 && std::abs(muon.innerTrack()->dz(vtx.position())) < 20.;
 
  return layers && ip && (ishighq | run2016_hip_mitigation);
}

References funct::abs(), reco::TrackBase::highPurity, isGoodMuon(), hgcalTopologyTester_cfi::layers, TMOneStationTight, and extraflags_cff::vtx.

Referenced by DiMuonHistograms::analyze(), MuonKinVsEtaAnalyzer::analyze(), LeptonSkimming::filter(), makeSelectorBitset(), Muon.Muon::muonID(), MuonPOGStandardCut::operator()(), MuonMiniAOD::PassesCut_A(), HLTDQMMuonSelector::passMuonSel(), MuonIDTableProducer::produce(), and MuonPOGStandardCut::value().

isTightMuon()

bool muon::isTightMuon	(	const reco::Muon &	muon,
		const reco::Vertex &	vtx
	)

Definition at line 880 of file MuonSelectors.cc.

                                                                  {
  if (!muon.isPFMuon() || !muon.isGlobalMuon())
    return false;
 
  bool muID = isGoodMuon(muon, GlobalMuonPromptTight) && (muon.numberOfMatchedStations() > 1);
 
  bool hits = muon.innerTrack()->hitPattern().trackerLayersWithMeasurement() > 5 &&
              muon.innerTrack()->hitPattern().numberOfValidPixelHits() > 0;
 
  bool ip = std::abs(muon.muonBestTrack()->dxy(vtx.position())) < 0.2 &&
            std::abs(muon.muonBestTrack()->dz(vtx.position())) < 0.5;
 
  return muID && hits && ip;
}

References funct::abs(), GlobalMuonPromptTight, hfClusterShapes_cfi::hits, isGoodMuon(), and extraflags_cff::vtx.

Referenced by METplusTrackMonitor::analyze(), RecoMuonValidator::analyze(), DiMuonHistograms::analyze(), EfficiencyAnalyzer::analyze(), MuonKinVsEtaAnalyzer::analyze(), MuonPFAnalyzer::analyze(), MuonRecoOneHLT::analyze(), HcalHBHEMuonAnalyzer::analyze(), L1TMuonDQMOffline::getTightMuons(), makeSelectorBitset(), Muon.Muon::muonID(), MuonPOGStandardCut::operator()(), MuonMiniAOD::PassesCut_A(), ZCounting::passMuonID(), HLTDQMMuonSelector::passMuonSel(), MuonIDTableProducer::produce(), and MuonPOGStandardCut::value().

isTrackerHighPtMuon()

bool muon::isTrackerHighPtMuon	(	const reco::Muon &	muon,
		const reco::Vertex &	vtx
	)

Definition at line 962 of file MuonSelectors.cc.

                                                                          {
  bool muID = muon.isTrackerMuon() && muon.track().isNonnull() && (muon.numberOfMatchedStations() > 1);
  if (!muID)
    return false;
 
  bool hits = muon.innerTrack()->hitPattern().trackerLayersWithMeasurement() > 5 &&
              muon.innerTrack()->hitPattern().numberOfValidPixelHits() > 0;
 
  bool momQuality = muon.tunePMuonBestTrack()->ptError() < 0.3 * muon.tunePMuonBestTrack()->pt();
 
  bool ip =
      std::abs(muon.innerTrack()->dxy(vtx.position())) < 0.2 && std::abs(muon.innerTrack()->dz(vtx.position())) < 0.5;
 
  return muID && hits && momQuality && ip;
}

References funct::abs(), hfClusterShapes_cfi::hits, and extraflags_cff::vtx.

Referenced by makeSelectorBitset().

makeSelectorBitset()

reco::Muon::Selector muon::makeSelectorBitset	(	reco::Muon const &	muon,
		reco::Vertex const *	vertex = nullptr,
		bool	run2016_hip_mitigation = false
	)

Definition at line 1033 of file MuonSelectors.cc.

                                                                           {
  // https://twiki.cern.ch/twiki/bin/viewauth/CMS/SWGuideMuonIdRun2
  unsigned int selectors = muon.selectors();
  // Compute Id and Isolation variables
  double chIso = muon.pfIsolationR04().sumChargedHadronPt;
  double nIso = muon.pfIsolationR04().sumNeutralHadronEt;
  double phoIso = muon.pfIsolationR04().sumPhotonEt;
  double puIso = muon.pfIsolationR04().sumPUPt;
  double dbCorrectedIsolation = chIso + std::max(nIso + phoIso - .5 * puIso, 0.);
  double dbCorrectedRelIso = dbCorrectedIsolation / muon.pt();
  double tkRelIso = muon.isolationR03().sumPt / muon.pt();
 
  // Base selectors
  if (muon::isLooseMuon(muon))
    selectors |= reco::Muon::CutBasedIdLoose;
  if (vertex) {
    if (muon::isTightMuon(muon, *vertex))
      selectors |= reco::Muon::CutBasedIdTight;
    if (muon::isSoftMuon(muon, *vertex, run2016_hip_mitigation))
      selectors |= reco::Muon::SoftCutBasedId;
    if (muon::isHighPtMuon(muon, *vertex))
      selectors |= reco::Muon::CutBasedIdGlobalHighPt;
    if (muon::isTrackerHighPtMuon(muon, *vertex))
      selectors |= reco::Muon::CutBasedIdTrkHighPt;
  }
  if (muon::isMediumMuon(muon, run2016_hip_mitigation)) {
    selectors |= reco::Muon::CutBasedIdMedium;
    if (vertex and std::abs(muon.muonBestTrack()->dz(vertex->position())) < 0.1 and
        std::abs(muon.muonBestTrack()->dxy(vertex->position())) < 0.02)
      selectors |= reco::Muon::CutBasedIdMediumPrompt;
  }
 
  // PF isolation
  if (dbCorrectedRelIso < 0.40)
    selectors |= reco::Muon::PFIsoVeryLoose;
  if (dbCorrectedRelIso < 0.25)
    selectors |= reco::Muon::PFIsoLoose;
  if (dbCorrectedRelIso < 0.20)
    selectors |= reco::Muon::PFIsoMedium;
  if (dbCorrectedRelIso < 0.15)
    selectors |= reco::Muon::PFIsoTight;
  if (dbCorrectedRelIso < 0.10)
    selectors |= reco::Muon::PFIsoVeryTight;
  if (dbCorrectedRelIso < 0.05)
    selectors |= reco::Muon::PFIsoVeryVeryTight;
 
  // Tracker isolation
  if (tkRelIso < 0.10)
    selectors |= reco::Muon::TkIsoLoose;
  if (tkRelIso < 0.05)
    selectors |= reco::Muon::TkIsoTight;
 
  // Trigger selectors
  if (isLooseTriggerMuon(muon))
    selectors |= reco::Muon::TriggerIdLoose;
 
  // Timing
  if (!outOfTimeMuon(muon))
    selectors |= reco::Muon::InTimeMuon;
 
  return static_cast<reco::Muon::Selector>(selectors);
}

References funct::abs(), reco::Muon::CutBasedIdGlobalHighPt, reco::Muon::CutBasedIdLoose, reco::Muon::CutBasedIdMedium, reco::Muon::CutBasedIdMediumPrompt, reco::Muon::CutBasedIdTight, reco::Muon::CutBasedIdTrkHighPt, reco::Muon::InTimeMuon, isHighPtMuon(), isLooseMuon(), isLooseTriggerMuon(), isMediumMuon(), isSoftMuon(), isTightMuon(), isTrackerHighPtMuon(), SiStripPI::max, outOfTimeMuon(), reco::Muon::PFIsoLoose, reco::Muon::PFIsoMedium, reco::Muon::PFIsoTight, reco::Muon::PFIsoVeryLoose, reco::Muon::PFIsoVeryTight, reco::Muon::PFIsoVeryVeryTight, reco::Muon::SoftCutBasedId, reco::Muon::TkIsoLoose, reco::Muon::TkIsoTight, muons_cff::tkRelIso, reco::Muon::TriggerIdLoose, and bphysicsOniaDQM_cfi::vertex.

Referenced by MuonProducer::produce(), pat::PATMuonProducer::produce(), and pat::LeptonUpdater< T >::recomputeMuonBasicSelectors().

overlap()

bool muon::overlap	(	const reco::Muon &	muon1,
		const reco::Muon &	muon2,
		double	pullX = 1.0,
		double	pullY = 1.0,
		bool	checkAdjacentChambers = false
	)

Definition at line 791 of file MuonSelectors.cc.

                                                                                                          {
  unsigned int nMatches1 = muon1.numberOfMatches(reco::Muon::SegmentAndTrackArbitration);
  unsigned int nMatches2 = muon2.numberOfMatches(reco::Muon::SegmentAndTrackArbitration);
  unsigned int betterMuon = (muon1.pt() > muon2.pt() ? 1 : 2);
  for (std::vector<reco::MuonChamberMatch>::const_iterator chamber1 = muon1.matches().begin();
       chamber1 != muon1.matches().end();
       ++chamber1)
    for (std::vector<reco::MuonChamberMatch>::const_iterator chamber2 = muon2.matches().begin();
         chamber2 != muon2.matches().end();
         ++chamber2) {
      // if ( (chamber1->segmentMatches.empty() || chamber2->segmentMatches.empty()) ) continue;
 
      // handle case where both muons have information about the same chamber
      // here we know how close they are
      if (chamber1->id == chamber2->id) {
        // found the same chamber
        if (std::abs(chamber1->x - chamber2->x) <
            pullX * sqrt(chamber1->xErr * chamber1->xErr + chamber2->xErr * chamber2->xErr)) {
          if (betterMuon == 1)
            nMatches2--;
          else
            nMatches1--;
          if (nMatches1 == 0 || nMatches2 == 0)
            return true;
          continue;
        }
        if (std::abs(chamber1->y - chamber2->y) <
            pullY * sqrt(chamber1->yErr * chamber1->yErr + chamber2->yErr * chamber2->yErr)) {
          if (betterMuon == 1)
            nMatches2--;
          else
            nMatches1--;
          if (nMatches1 == 0 || nMatches2 == 0)
            return true;
        }
      } else {
        if (!checkAdjacentChambers)
          continue;
        // check if tracks are pointing into overlaping region of the CSC detector
        if (chamber1->id.subdetId() != MuonSubdetId::CSC || chamber2->id.subdetId() != MuonSubdetId::CSC)
          continue;
        CSCDetId id1(chamber1->id);
        CSCDetId id2(chamber2->id);
        if (id1.endcap() != id2.endcap())
          continue;
        if (id1.station() != id2.station())
          continue;
        if (id1.ring() != id2.ring())
          continue;
        if (std::abs(id1.chamber() - id2.chamber()) > 1)
          continue;
        // FIXME: we don't handle 18->1; 36->1 transitions since
        // I don't know how to check for sure how many chambers
        // are there. Probably need to hard code some checks.
 
        // Now we have to make sure that both tracks are close to an edge
        // FIXME: ignored Y coordinate for now
        if (std::abs(chamber1->edgeX) > chamber1->xErr * pullX)
          continue;
        if (std::abs(chamber2->edgeX) > chamber2->xErr * pullX)
          continue;
        if (chamber1->x * chamber2->x < 0) {  // check if the same edge
          if (betterMuon == 1)
            nMatches2--;
          else
            nMatches1--;
          if (nMatches1 == 0 || nMatches2 == 0)
            return true;
        }
      }
    }
  return false;
}

References funct::abs(), MuonSubdetId::CSC, globals_cff::id1, globals_cff::id2, reco::Muon::matches(), reco::Muon::numberOfMatches(), reco::LeafCandidate::pt(), reco::Muon::SegmentAndTrackArbitration, and mathSSE::sqrt().

Referenced by MuonTiming::analyze(), CSCCFEBData::digis(), HcalQIEShape::expand(), TopDiLeptonOffline::MonitorEnsemble::fill(), generate(), trklet::VMRouterTable::getLookup(), trklet::MemoryBase::initSpecialSeeding(), main(), StraightTrackAlignment::processEvent(), IsolationProducerForTracks::produce(), MatchedProbeMaker< T >::produce(), HLTJetsCleanedFromLeadingLeptons< JetType >::produce(), TECLayer::searchNeighbors(), TOBRod::searchNeighbors(), TBPLayer::searchNeighbors(), Phase2OTBarrelRod::searchNeighbors(), CompositeTECPetal::searchNeighbors(), CSCEventData::selfTest(), FWGeoTopNode::setPopupMenu(), edm::EventSelector::testSelectionOverlap(), trklet::Tracklet::Tracklet(), and omtf::MuonUnpacker::unpack().

RequiredStationMask()

unsigned int muon::RequiredStationMask	(	const reco::Muon &	muon,
		double	maxChamberDist,
		double	maxChamberDistPull,
		reco::Muon::ArbitrationType	arbitrationType
	)

Definition at line 40 of file MuonSelectors.cc.

                                                                                {
  unsigned int theMask = 0;
 
  for (int stationIdx = 1; stationIdx < 5; ++stationIdx) {
    for (int detectorIdx = 1; detectorIdx < 3; ++detectorIdx) {
      float dist = muon.trackDist(stationIdx, detectorIdx, arbitrationType);
      if (dist < maxChamberDist &&
          dist < maxChamberDistPull * muon.trackDistErr(stationIdx, detectorIdx, arbitrationType))
        theMask += 1 << ((stationIdx - 1) + 4 * (detectorIdx - 1));
    }
  }
  return theMask;
}

Referenced by isGoodMuon().

segmentCompatibility()

float muon::segmentCompatibility	(	const reco::Muon &	muon,
		reco::Muon::ArbitrationType	arbitrationType = reco::Muon::SegmentAndTrackArbitration
	)

Definition at line 61 of file MuonSelectors.cc.

                                                                                              {
  bool use_weight_regain_at_chamber_boundary = true;
  bool use_match_dist_penalty = true;
 
  int nr_of_stations_crossed = 0;
  int nr_of_stations_with_segment = 0;
  std::vector<int> stations_w_track(8);
  std::vector<int> station_has_segmentmatch(8);
  std::vector<int> station_was_crossed(8);
  std::vector<float> stations_w_track_at_boundary(8);
  std::vector<float> station_weight(8);
  int position_in_stations = 0;
  float full_weight = 0.;
 
  for (int i = 1; i <= 8; ++i) {
    // ********************************************************;
    // *** fill local info for this muon (do some counting) ***;
    // ************** begin ***********************************;
    if (i <= 4) {  // this is the section for the DTs
      float thisTrackDist = muon.trackDist(i, 1, arbitrationType);
      if (thisTrackDist < 999999) {  //current "raw" info that a track is close to a chamber
        ++nr_of_stations_crossed;
        station_was_crossed[i - 1] = 1;
        if (thisTrackDist > -10.)
          stations_w_track_at_boundary[i - 1] = thisTrackDist;
        else
          stations_w_track_at_boundary[i - 1] = 0.;
      }
      //current "raw" info that a segment is matched to the current track
      if (muon.segmentX(i, 1, arbitrationType) < 999999) {
        ++nr_of_stations_with_segment;
        station_has_segmentmatch[i - 1] = 1;
      }
    } else {  // this is the section for the CSCs
      float thisTrackDist = muon.trackDist(i - 4, 2, arbitrationType);
      if (thisTrackDist < 999999) {  //current "raw" info that a track is close to a chamber
        ++nr_of_stations_crossed;
        station_was_crossed[i - 1] = 1;
        if (thisTrackDist > -10.)
          stations_w_track_at_boundary[i - 1] = thisTrackDist;
        else
          stations_w_track_at_boundary[i - 1] = 0.;
      }
      //current "raw" info that a segment is matched to the current track
      if (muon.segmentX(i - 4, 2, arbitrationType) < 999999) {
        ++nr_of_stations_with_segment;
        station_has_segmentmatch[i - 1] = 1;
      }
    }
    // rough estimation of chamber border efficiency (should be parametrized better, this is just a quick guess):
    // TF1 * merf = new TF1("merf","-0.5*(TMath::Erf(x/6.)-1)",-100,100);
    // use above value to "unpunish" missing segment if close to border, i.e. rather than not adding any weight, add
    // the one from the function. Only for dist ~> -10 cm, else full punish!.
 
    // ********************************************************;
    // *** fill local info for this muon (do some counting) ***;
    // ************** end *************************************;
  }
 
  // ********************************************************;
  // *** calculate weights for each station *****************;
  // ************** begin ***********************************;
  //    const float slope = 0.5;
  //    const float attenuate_weight_regain = 1.;
  // if attenuate_weight_regain < 1., additional punishment if track is close to boundary and no segment
  const float attenuate_weight_regain = 0.5;
 
  for (int i = 1; i <= 8; ++i) {  // loop over all possible stations
 
    // first set all weights if a station has been crossed
    // later penalize if a station did not have a matching segment
 
    //old logic      if(station_has_segmentmatch[i-1] > 0 ) { // the track has an associated segment at the current station
    if (station_was_crossed[i - 1] > 0) {  // the track crossed this chamber (or was nearby)
      // - Apply a weight depending on the "depth" of the muon passage.
      // - The station_weight is later reduced for stations with badly matched segments.
      // - Even if there is no segment but the track passes close to a chamber boundary, the
      //   weight is set non zero and can go up to 0.5 of the full weight if the track is quite
      //   far from any station.
      ++position_in_stations;
 
      switch (nr_of_stations_crossed) {  // define different weights depending on how many stations were crossed
        case 1:
          station_weight[i - 1] = 1.f;
          break;
        case 2:
          if (position_in_stations == 1)
            station_weight[i - 1] = 0.33f;
          else
            station_weight[i - 1] = 0.67f;
          break;
        case 3:
          if (position_in_stations == 1)
            station_weight[i - 1] = 0.23f;
          else if (position_in_stations == 2)
            station_weight[i - 1] = 0.33f;
          else
            station_weight[i - 1] = 0.44f;
          break;
        case 4:
          if (position_in_stations == 1)
            station_weight[i - 1] = 0.10f;
          else if (position_in_stations == 2)
            station_weight[i - 1] = 0.20f;
          else if (position_in_stations == 3)
            station_weight[i - 1] = 0.30f;
          else
            station_weight[i - 1] = 0.40f;
          break;
 
        default:
          //    LogTrace("MuonIdentification")<<"            // Message: A muon candidate track has more than 4 stations with matching segments.";
          //    LogTrace("MuonIdentification")<<"            // Did not expect this - please let me know: ibloch@fnal.gov";
          // for all other cases
          station_weight[i - 1] = 1.f / nr_of_stations_crossed;
      }
 
      if (use_weight_regain_at_chamber_boundary) {  // reconstitute some weight if there is no match but the segment is close to a boundary:
        if (station_has_segmentmatch[i - 1] <= 0 && stations_w_track_at_boundary[i - 1] != 0.) {
          // if segment is not present but track in inefficient region, do not count as "missing match" but add some reduced weight.
          // original "match weight" is currently reduced by at least attenuate_weight_regain, variing with an error function down to 0 if the track is
          // inside the chamber.
          // remark: the additional scale of 0.5 normalizes Err to run from 0 to 1 in y
          station_weight[i - 1] = station_weight[i - 1] * attenuate_weight_regain * 0.5f *
                                  (std::erf(stations_w_track_at_boundary[i - 1] / 6.f) + 1.f);
        } else if (station_has_segmentmatch[i - 1] <= 0 &&
                   stations_w_track_at_boundary[i - 1] == 0.f) {  // no segment match and track well inside chamber
          // full penalization
          station_weight[i - 1] = 0.f;
        }
      } else {  // always fully penalize tracks with no matching segment, whether the segment is close to the boundary or not.
        if (station_has_segmentmatch[i - 1] <= 0)
          station_weight[i - 1] = 0.f;
      }
 
      // if track has matching segment, but the matching is not high quality, penalize
      if (station_has_segmentmatch[i - 1] > 0) {
        if (i <= 4) {  // we are in the DTs
          if (muon.dY(i, 1, arbitrationType) < 999999.f &&
              muon.dX(i, 1, arbitrationType) < 999999.f) {  // have both X and Y match
            const float pullTot2 =
                std::pow(muon.pullX(i, 1, arbitrationType), 2.) + std::pow(muon.pullY(i, 1, arbitrationType), 2.);
            if (pullTot2 > 1.f) {
              const float dxy2 =
                  std::pow(muon.dX(i, 1, arbitrationType), 2.) + std::pow(muon.dY(i, 1, arbitrationType), 2.);
              // reduce weight
              if (use_match_dist_penalty) {
                // only use pull if 3 sigma is not smaller than 3 cm
                if (dxy2 < 9.f && pullTot2 > 9.f) {
                  if (dxy2 > 1.f)
                    station_weight[i - 1] *= 1.f / std::pow(dxy2, .125);
                } else {
                  station_weight[i - 1] *= 1.f / std::pow(pullTot2, .125);
                }
              }
            }
          } else if (muon.dY(i, 1, arbitrationType) >= 999999.f) {  // has no match in Y
            // has a match in X. Pull larger that 1 to avoid increasing the weight (just penalize, don't anti-penalize)
            if (muon.pullX(i, 1, arbitrationType) > 1.f) {
              // reduce weight
              if (use_match_dist_penalty) {
                // only use pull if 3 sigma is not smaller than 3 cm
                if (muon.dX(i, 1, arbitrationType) < 3.f && muon.pullX(i, 1, arbitrationType) > 3.f) {
                  if (muon.dX(i, 1, arbitrationType) > 1.f)
                    station_weight[i - 1] *= 1.f / std::pow(muon.dX(i, 1, arbitrationType), .25);
                } else {
                  station_weight[i - 1] *= 1.f / std::pow(muon.pullX(i, 1, arbitrationType), .25);
                }
              }
            }
          } else {  // has no match in X
            // has a match in Y. Pull larger that 1 to avoid increasing the weight (just penalize, don't anti-penalize)
            if (muon.pullY(i, 1, arbitrationType) > 1.f) {
              // reduce weight
              if (use_match_dist_penalty) {
                // only use pull if 3 sigma is not smaller than 3 cm
                if (muon.dY(i, 1, arbitrationType) < 3. && muon.pullY(i, 1, arbitrationType) > 3.) {
                  if (muon.dY(i, 1, arbitrationType) > 1.f)
                    station_weight[i - 1] *= 1.f / std::pow(muon.dY(i, 1, arbitrationType), .25);
                } else {
                  station_weight[i - 1] *= 1.f / std::pow(muon.pullY(i, 1, arbitrationType), .25);
                }
              }
            }
          }
        } else {  // We are in the CSCs
          const float pullTot2 =
              std::pow(muon.pullX(i - 4, 2, arbitrationType), 2.) + std::pow(muon.pullY(i - 4, 2, arbitrationType), 2.);
          if (pullTot2 > 1.f) {
            // reduce weight
            if (use_match_dist_penalty) {
              const float dxy2 =
                  std::pow(muon.dX(i - 4, 2, arbitrationType), 2.) + std::pow(muon.dY(i - 4, 2, arbitrationType), 2.);
              // only use pull if 3 sigma is not smaller than 3 cm
              if (dxy2 < 9.f && pullTot2 > 9.f) {
                if (dxy2 > 1.f)
                  station_weight[i - 1] *= 1.f / std::pow(dxy2, .125);
              } else {
                station_weight[i - 1] *= 1.f / std::pow(pullTot2, .125);
              }
            }
          }
        }
      }
 
      // Thoughts:
      // - should penalize if the segment has only x OR y info
      // - should also use the segment direction, as it now works!
 
    } else {  // track did not pass a chamber in this station - just reset weight
      station_weight[i - 1] = 0.f;
    }
 
    //increment final weight for muon:
    full_weight += station_weight[i - 1];
  }
 
  // if we don't expect any matches, we set the compatibility to
  // 0.5 as the track is as compatible with a muon as it is with
  // background - we should maybe rather set it to -0.5!
  if (nr_of_stations_crossed == 0) {
    //      full_weight = attenuate_weight_regain*0.5;
    full_weight = 0.5f;
  }
 
  // ********************************************************;
  // *** calculate weights for each station *****************;
  // ************** end *************************************;
 
  return full_weight;
}

References f, mps_fire::i, and funct::pow().

Referenced by ExampleMuonAnalyzer::analyze(), HiggsDQM::analyze(), StudyTriggerHLT::analyze(), MuonIdVal::analyze(), HcalHBHEMuonAnalyzer::analyze(), StudyCaloResponse::analyze(), HcalHBHEMuonHighEtaAnalyzer::analyzeMuon(), MuonCosmicCompatibilityFiller::checkMuonSegments(), PFRecoTauDiscriminationAgainstMuon::discriminate(), BadParticleFilter::filter(), isGoodMuon(), isMediumMuon(), isMediumMuonCustom(), MuonIDTableProducer::isMediumMuonHIP(), pat::MuonSelector::muIdSelection_(), Muon.Muon::muonID(), HcalIsoTrkAnalyzer::notaMuon(), MuonSegmentCompatibilityCut::operator()(), and MuonSegmentCompatibilityCut::value().

selectionTypeFromString()

SelectionType muon::selectionTypeFromString

(

const std::string &

label

)

Definition at line 9 of file MuonSelectors.cc.

                                                                {
    SelectionType value = (SelectionType)-1;
    bool found = false;
    for (int i = 0; selectionTypeStringToEnumMap[i].label && (!found); ++i)
      if (!strcmp(label.c_str(), selectionTypeStringToEnumMap[i].label)) {
        found = true;
        value = selectionTypeStringToEnumMap[i].value;
      }
 
    // in case of unrecognized selection type
    if (!found)
      throw cms::Exception("MuonSelectorError") << label << " is not a recognized SelectionType";
    return value;
  }

References Exception, newFWLiteAna::found, mps_fire::i, label, muon::SelectionTypeStringToEnum::label, selectionTypeStringToEnumMap, relativeConstraints::value, and muon::SelectionTypeStringToEnum::value.

Referenced by MuonSelectionTypeValueMapProducer::MuonSelectionTypeValueMapProducer(), MuonTrackProducer::produce(), and pat::PackedCandidateMuonSelectorProducer::produce().

selectorFromString()

reco::Muon::Selector muon::selectorFromString

(

const std::string &

label

)

Definition at line 24 of file MuonSelectors.cc.

                                                              {
    reco::Muon::Selector value = (reco::Muon::Selector)-1;
    bool found = false;
    for (int i = 0; selectorStringToEnumMap[i].label && (!found); ++i)
      if (!strcmp(label.c_str(), selectorStringToEnumMap[i].label)) {
        found = true;
        value = selectorStringToEnumMap[i].value;
      }
 
    // in case of unrecognized selection type
    if (!found)
      throw cms::Exception("MuonSelectorError") << label << " is not a recognized reco::Muon::Selector";
    return value;
  }

References Exception, newFWLiteAna::found, mps_fire::i, label, muon::SelectorStringToEnum::label, selectorStringToEnumMap, relativeConstraints::value, and muon::SelectorStringToEnum::value.

sharedSegments()

int muon::sharedSegments	(	const reco::Muon &	muon1,
		const reco::Muon &	muon2,
		unsigned int	segmentArbitrationMask = reco::MuonSegmentMatch::BestInChamberByDR
	)

Determine the number of shared segments between two muons. Comparison is done using the segment references in the reco::Muon object.

Definition at line 978 of file MuonSelectors.cc.

                                                                                                     {
  int ret = 0;
 
  // Will do with a stupid double loop, since creating and filling a map is probably _more_ inefficient for a single lookup.
  for (std::vector<reco::MuonChamberMatch>::const_iterator chamberMatch = mu.matches().begin();
       chamberMatch != mu.matches().end();
       ++chamberMatch) {
    if (chamberMatch->segmentMatches.empty())
      continue;
    for (std::vector<reco::MuonChamberMatch>::const_iterator chamberMatch2 = mu2.matches().begin();
         chamberMatch2 != mu2.matches().end();
         ++chamberMatch2) {
      if (chamberMatch2->segmentMatches.empty())
        continue;
      if (chamberMatch2->id() != chamberMatch->id())
        continue;
      for (std::vector<reco::MuonSegmentMatch>::const_iterator segmentMatch = chamberMatch->segmentMatches.begin();
           segmentMatch != chamberMatch->segmentMatches.end();
           ++segmentMatch) {
        if (!segmentMatch->isMask(segmentArbitrationMask))
          continue;
        for (std::vector<reco::MuonSegmentMatch>::const_iterator segmentMatch2 = chamberMatch2->segmentMatches.begin();
             segmentMatch2 != chamberMatch2->segmentMatches.end();
             ++segmentMatch2) {
          if (!segmentMatch2->isMask(segmentArbitrationMask))
            continue;
          if ((segmentMatch->cscSegmentRef.isNonnull() &&
               segmentMatch->cscSegmentRef == segmentMatch2->cscSegmentRef) ||
              (segmentMatch->dtSegmentRef.isNonnull() && segmentMatch->dtSegmentRef == segmentMatch2->dtSegmentRef)) {
            ++ret;
          }  // is the same
        }    // segment of mu2 in chamber
      }      // segment of mu1 in chamber
    }        // chamber of mu2
  }          // chamber of mu1
 
  return ret;
}

References reco::Muon::matches(), amptDefaultParameters_cff::mu, and runTheMatrix::ret.

Referenced by heppy::CMGMuonCleanerBySegmentsAlgo::clean(), BadGlobalMuonTagger::filter(), and modules::MuonCleanerBySegmentsT< T >::produce().

sigmaSwitch() [1/2]

reco::Muon::MuonTrackTypePair muon::sigmaSwitch ( const reco::Muon &  muon, const double  nSigma = 2., const double  ptThreshold = 200.  )

inline

Definition at line 57 of file MuonCocktails.h.

                                                                                    {
    return muon::sigmaSwitch(muon.globalTrack(), muon.innerTrack(), nSigma, ptThreshold);
  }

References HLTSiStripMonitoring_cff::nSigma, ewkMuLumiMonitorDQM_cfi::ptThreshold, and sigmaSwitch().

sigmaSwitch() [2/2]

reco::Muon::MuonTrackTypePair muon::sigmaSwitch	(	const reco::TrackRef &	combinedTrack,
		const reco::TrackRef &	trackerTrack,
		const double	nSigma = 2.,
		const double	ptThreshold = 200.
	)

Definition at line 139 of file MuonCocktails.cc.

                                                                          {
  // If either the global or tracker-only fits have pT below threshold
  // (default 200 GeV), return the tracker-only fit.
  if (combinedTrack->pt() < ptThreshold || trackerTrack->pt() < ptThreshold)
    return make_pair(trackerTrack, reco::Muon::InnerTrack);
 
  // If both are above the pT threshold, compare the difference in
  // q/p: if less than two sigma of the tracker-only track, switch to
  // global. Otherwise, use tracker-only.
  const double delta = fabs(trackerTrack->qoverp() - combinedTrack->qoverp());
  const double threshold = nSigma * trackerTrack->qoverpError();
  return delta > threshold ? make_pair(trackerTrack, reco::Muon::InnerTrack)
                           : make_pair(combinedTrack, reco::Muon::CombinedTrack);
}

References reco::Muon::CombinedTrack, dumpMFGeometry_cfg::delta, reco::Muon::InnerTrack, HLTSiStripMonitoring_cff::nSigma, ewkMuLumiMonitorDQM_cfi::ptThreshold, and remoteMonitoring_LED_IterMethod_cfg::threshold.

Referenced by MuonIdProducer::makeMuon(), and sigmaSwitch().

tevOptimized() [1/2]

reco::Muon::MuonTrackTypePair muon::tevOptimized ( const reco::Muon &  muon, const double  ptThreshold = 200., const double  tune1 = 17., const double  tune2 = 40., const double  dptcut = 0.25  )

inline

Definition at line 31 of file MuonCocktails.h.

                                                                                {
    return tevOptimized(muon.globalTrack(),
                        muon.innerTrack(),
                        muon.tpfmsTrack(),
                        muon.pickyTrack(),
                        muon.dytTrack(),
                        ptThreshold,
                        tune1,
                        tune2,
                        dptcut);
  }

References ewkMuLumiMonitorDQM_cfi::ptThreshold, and tevOptimized().

tevOptimized() [2/2]

reco::Muon::MuonTrackTypePair muon::tevOptimized	(	const reco::TrackRef &	combinedTrack,
		const reco::TrackRef &	trackerTrack,
		const reco::TrackRef &	tpfmsTrack,
		const reco::TrackRef &	pickyTrack,
		const reco::TrackRef &	dytTrack,
		const double	ptThreshold = 200.,
		const double	tune1 = 17.,
		const double	tune2 = 40.,
		const double	dptcut = 0.25
	)

Definition at line 9 of file MuonCocktails.cc.

                                                                {
  const unsigned int nAlgo = 5;
 
  // Array for convenience below.
  const reco::Muon::MuonTrackTypePair refit[nAlgo] = {make_pair(trackerTrack, reco::Muon::InnerTrack),
                                                      make_pair(combinedTrack, reco::Muon::CombinedTrack),
                                                      make_pair(tpfmsTrack, reco::Muon::TPFMS),
                                                      make_pair(pickyTrack, reco::Muon::Picky),
                                                      make_pair(dytTrack, reco::Muon::DYT)};
 
  // Calculate the log(tail probabilities). If there's a problem,
  // signify this with prob == 0. The current problems recognized are:
  // the track being not available, whether the (re)fit failed or it's
  // just not in the event, or if the (re)fit ended up with no valid
  // hits.
  double prob[nAlgo] = {0., 0., 0., 0., 0.};
  bool valid[nAlgo] = {false, false, false, false, false};
 
  double dptmin = 1.;
 
  if (dptcut > 0) {
    for (unsigned int i = 0; i < nAlgo; ++i)
      if (refit[i].first.isNonnull())
        if (refit[i].first->ptError() / refit[i].first->pt() < dptmin)
          dptmin = refit[i].first->ptError() / refit[i].first->pt();
 
    if (dptmin > dptcut)
      dptcut = dptmin + 0.15;
  }
 
  for (unsigned int i = 0; i < nAlgo; ++i)
    if (refit[i].first.isNonnull()) {
      valid[i] = true;
      if (refit[i].first->numberOfValidHits() &&
          (refit[i].first->ptError() / refit[i].first->pt() < dptcut || dptcut < 0))
        prob[i] = muon::trackProbability(refit[i].first);
    }
 
  // Start with picky.
  int chosen = 3;
 
  // If there's a problem with picky, make the default one of the
  // other tracks. Try TPFMS first, then global, then tracker-only.
  if (prob[3] == 0.) {
    // split so that passing dptcut<0 recreates EXACTLY the old tuneP behavior
    if (dptcut > 0) {
      if (prob[4] > 0.)
        chosen = 4;
      else if (prob[0] > 0.)
        chosen = 0;
      else if (prob[2] > 0.)
        chosen = 2;
      else if (prob[1] > 0.)
        chosen = 1;
    } else {
      if (prob[2] > 0.)
        chosen = 2;
      else if (prob[1] > 0.)
        chosen = 1;
      else if (prob[0] > 0.)
        chosen = 0;
    }
  }
 
  // Now the algorithm: switch from picky to dyt if the difference is lower than a tuned value. Then
  //  switch from picky to tracker-only if the
  // difference, log(tail prob(picky)) - log(tail prob(tracker-only))
  // is greater than a tuned value. Then compare the
  // so-picked track to TPFMS in the same manner using another tuned
  // value.
  if (prob[4] > 0. && prob[3] > 0.) {
    if (refit[3].first->pt() > 0 && refit[4].first->pt() > 0 &&
        (refit[4].first->ptError() / refit[4].first->pt() - refit[3].first->ptError() / refit[3].first->pt()) <= 0)
      chosen = 4;  // dyt
  }
 
  if (prob[0] > 0. && prob[chosen] > 0. && (prob[chosen] - prob[0]) > tune1)
    chosen = 0;
  if (prob[2] > 0. && (prob[chosen] - prob[2]) > tune2)
    chosen = 2;
 
  // Sanity checks
  if (chosen == 4 && !valid[4])
    chosen = 3;
  if (chosen == 3 && !valid[3])
    chosen = 2;
  if (chosen == 2 && !valid[2])
    chosen = 1;
  if (chosen == 1 && !valid[1])
    chosen = 0;
 
  // Done. If pT of the chosen track (or pT of the tracker track) is below the threshold value, return the tracker track.
  if (valid[chosen] && refit[chosen].first->pt() < ptThreshold && prob[0] > 0.)
    return make_pair(trackerTrack, reco::Muon::InnerTrack);
  if (trackerTrack->pt() < ptThreshold && prob[0] > 0.)
    return make_pair(trackerTrack, reco::Muon::InnerTrack);
 
  // Return the chosen track (which can be the global track in
  // very rare cases).
  return refit[chosen];
}

References reco::Muon::CombinedTrack, reco::Muon::DYT, first, mps_fire::i, reco::Muon::InnerTrack, reco::Muon::Picky, TtFullHadEvtBuilder_cfi::prob, ewkMuLumiMonitorDQM_cfi::ptThreshold, reco::Muon::TPFMS, trackProbability(), and RunInfoPI::valid.

Referenced by MuonIdProducer::makeMuon(), MuonsFromRefitTracksProducer::produce(), PFMuonAlgo::reconstructMuon(), and tevOptimized().

TMR()

reco::Muon::MuonTrackTypePair muon::TMR	(	const reco::TrackRef &	trackerTrack,
		const reco::TrackRef &	fmsTrack,
		const double	tune = 4.
	)

Definition at line 160 of file MuonCocktails.cc.

                                                           {
  double probTK = 0;
  double probFMS = 0;
 
  if (trackerTrack.isNonnull() && trackerTrack->numberOfValidHits())
    probTK = muon::trackProbability(trackerTrack);
  if (fmsTrack.isNonnull() && fmsTrack->numberOfValidHits())
    probFMS = muon::trackProbability(fmsTrack);
 
  bool TKok = probTK > 0;
  bool FMSok = probFMS > 0;
 
  if (TKok && FMSok) {
    if (probFMS - probTK > tune)
      return make_pair(trackerTrack, reco::Muon::InnerTrack);
    else
      return make_pair(fmsTrack, reco::Muon::TPFMS);
  } else if (FMSok)
    return make_pair(fmsTrack, reco::Muon::TPFMS);
  else if (TKok)
    return make_pair(trackerTrack, reco::Muon::InnerTrack);
  else
    return make_pair(reco::TrackRef(), reco::Muon::None);
}

References reco::Muon::InnerTrack, edm::Ref< C, T, F >::isNonnull(), reco::Muon::None, reco::Muon::TPFMS, and trackProbability().

trackProbability()

double muon::trackProbability

(

const reco::TrackRef

track

)

Definition at line 122 of file MuonCocktails.cc.

                                                      {
  int nDOF = (int)track->ndof();
  if (nDOF > 0 && track->chi2() > 0) {
    return -log(TMath::Prob(track->chi2(), nDOF));
  } else {
    return 0.0;
  }
}

References createfilelist::int, dqm-mbProfile::log, and HLT_FULL_cff::track.

Referenced by HistogramProbabilityEstimator::probability(), tevOptimized(), tevOptimizedTMR(), and TMR().

Variable Documentation

selectionTypeStringToEnumMap

const SelectionTypeStringToEnum muon::selectionTypeStringToEnumMap[]

static

Definition at line 66 of file MuonSelectors.h.

Referenced by selectionTypeFromString().

selectorStringToEnumMap

const SelectorStringToEnum muon::selectorStringToEnumMap[]

static

Definition at line 107 of file MuonSelectors.h.

Referenced by selectorFromString().