tmtt::Utility Namespace Reference

Enumerations
enum	AlgoStep { HT, SEED, DUP, FIT }

Functions
unsigned int	countLayers (const Settings *settings, const std::vector< const Stub *> &stubs, bool disableReducedLayerID=false, bool onlyPS=false)
unsigned int	countLayers (const Settings *settings, const std::vector< Stub *> &stubs, bool disableReducedLayerID=false, bool onlyPS=false)
const TP *	matchingTP (const Settings *settings, const std::vector< const Stub *> &vstubs, unsigned int &nMatchedLayersBest, std::vector< const Stub *> &matchedStubsBest)
const TP *	matchingTP (const Settings *settings, const std::vector< Stub *> &vstubs, unsigned int &nMatchedLayersBest, std::vector< const Stub *> &matchedStubsBest)
unsigned int	numLayerCut (Utility::AlgoStep algo, const Settings *settings, unsigned int iPhiSec, unsigned int iEtaReg, float invPt, float eta=0.)

Enumeration Type Documentation

AlgoStep

enum tmtt::Utility::AlgoStep

Enumerator
HT
SEED
DUP
FIT

Definition at line 28 of file Utility.h.

{ HT, SEED, DUP, FIT };

Function Documentation

countLayers() [1/2]

unsigned int tmtt::Utility::countLayers	(	const Settings *	settings,
		const std::vector< const Stub *> &	stubs,
		bool	disableReducedLayerID = false,
		bool	onlyPS = false
	)

Definition at line 25 of file Utility.cc.

References tmtt::Settings::reduceLayerID().

Referenced by tmtt::HTcell::calcNumFilteredLayers(), tmtt::TP::calcNumLayers(), tmtt::L1track3D::cheat(), countLayers(), tmtt::Histos::fillInputData(), tmtt::TP::fillUseForAlgEff(), tmtt::TrkRZfilter::filterTracks(), tmtt::ChiSquaredFitBase::fit(), tmtt::L1fittedTrack::L1fittedTrack(), tmtt::L1track2D::L1track2D(), tmtt::L1track3D::L1track3D(), matchingTP(), and tmtt::TrkRZfilter::seedFilter().

                                                 {
    //=== Unpack configuration parameters

    // Note if using reduced layer ID, so tracker layer can be encoded in 3 bits.
    const bool reduceLayerID = settings->reduceLayerID();

    // Disable use of reduced layer ID if requested, otherwise take from cfg.
    bool reduce = (disableReducedLayerID) ? false : reduceLayerID;

    // Count layers using CMSSW layer ID.
    unordered_set<unsigned int> foundLayers;
    for (const Stub* stub : vstubs) {
      if ((!onlyPS) || stub->psModule()) {  // Consider only stubs in PS modules if that option specified.
        // Use either normal or reduced layer ID depending on request.
        int layerID = reduce ? stub->layerIdReduced() : stub->layerId();
        foundLayers.insert(layerID);
      }
    }

    return foundLayers.size();
  }

countLayers() [2/2]

unsigned int tmtt::Utility::countLayers	(	const Settings *	settings,
		const std::vector< Stub *> &	stubs,
		bool	disableReducedLayerID = false,
		bool	onlyPS = false
	)

Definition at line 17 of file Utility.cc.

References countLayers().

                                                 {
    std::vector<const Stub*> stubsConst(stubs.begin(), stubs.end());
    return countLayers(settings, stubsConst, disableReducedLayerID, onlyPS);
  }

matchingTP() [1/2]

const TP * tmtt::Utility::matchingTP	(	const Settings *	settings,
		const std::vector< const Stub *> &	vstubs,
		unsigned int &	nMatchedLayersBest,
		std::vector< const Stub *> &	matchedStubsBest
	)

Definition at line 63 of file Utility.cc.

References countLayers(), tmtt::Settings::minFracMatchStubsOnReco(), tmtt::Settings::minFracMatchStubsOnTP(), tmtt::Settings::minNumMatchLayers(), tmtt::Settings::minNumMatchPSLayers(), alignCSCRings::s, and cmsswSequenceInfo::tp.

Referenced by tmtt::L1track3D::cheat(), tmtt::L1fittedTrack::L1fittedTrack(), tmtt::L1track2D::L1track2D(), tmtt::L1track3D::L1track3D(), and matchingTP().

                                                                       {
    // Get matching criteria
    const double minFracMatchStubsOnReco = settings->minFracMatchStubsOnReco();
    const double minFracMatchStubsOnTP = settings->minFracMatchStubsOnTP();
    const unsigned int minNumMatchLayers = settings->minNumMatchLayers();
    const unsigned int minNumMatchPSLayers = settings->minNumMatchPSLayers();

    // Loop over the given stubs, looking at the TP that produced each one.

    map<const TP*, vector<const Stub*> > tpsToStubs;
    map<const TP*, vector<const Stub*> > tpsToStubsStrict;

    for (const Stub* s : vstubs) {
      // If this stub was produced by one or more TPs, store a link from the TPs to the stub.
      // (The assocated TPs here are influenced by config param "StubMatchStrict").
      for (const TP* tp_i : s->assocTPs()) {
        tpsToStubs[tp_i].push_back(s);
      }
      // To resolve tie-break situations, do the same, but now only considering strictly associated TP, where the TP contributed
      // to both clusters making up stub.
      if (s->assocTP() != nullptr) {
        tpsToStubsStrict[s->assocTP()].push_back(s);
      }
    }

    // Loop over all the TP that matched the given stubs, looking for the best matching TP.

    nMatchedLayersBest = 0;
    unsigned int nMatchedLayersStrictBest = 0;
    matchedStubsBest.clear();
    const TP* tpBest = nullptr;

    for (const auto& iter : tpsToStubs) {
      const TP* tp = iter.first;
      const vector<const Stub*> matchedStubsFromTP = iter.second;

      const vector<const Stub*> matchedStubsStrictFromTP =
          tpsToStubsStrict[tp];  // Empty vector, if this TP didnt produce both clusters in stub.

      // Count number of the given stubs that came from this TP.
      unsigned int nMatchedStubs = matchedStubsFromTP.size();
      // Count number of tracker layers in which the given stubs came from this TP.
      unsigned int nMatchedLayers = Utility::countLayers(settings, matchedStubsFromTP, true);
      unsigned int nMatchedPSLayers = Utility::countLayers(settings, matchedStubsFromTP, true, true);

      // For tie-breaks, count number of tracker layers in which both clusters of the given stubs came from this TP.
      unsigned int nMatchedLayersStrict = Utility::countLayers(settings, matchedStubsStrictFromTP, true);

      // If enough layers matched, then accept this tracking particle.
      // Of the three criteria used here, usually only one is used, with the cuts on the other two set ultra loose.

      if (nMatchedStubs >=
              minFracMatchStubsOnReco * vstubs.size() &&  // Fraction of matched stubs relative to number of given stubs
          nMatchedStubs >= minFracMatchStubsOnTP *
                               tp->numAssocStubs() &&  // Fraction of matched stubs relative to number of stubs on TP.
          nMatchedLayers >= minNumMatchLayers &&
          nMatchedPSLayers >= minNumMatchPSLayers) {  // Number of matched layers
        // In case more than one matching TP found in this cell, note best match based on number of matching layers.
        // In tie-break situation, count layers in which both clusters in stub came from same TP.
        if (nMatchedLayersBest < nMatchedLayers ||
            (nMatchedLayersBest == nMatchedLayers && nMatchedLayersStrictBest < nMatchedLayersStrict)) {
          // Store data for this TP match.
          nMatchedLayersBest = nMatchedLayers;
          matchedStubsBest = matchedStubsFromTP;
          tpBest = tp;
        }
      }
    }

    return tpBest;
  }

matchingTP() [2/2]

const TP * tmtt::Utility::matchingTP	(	const Settings *	settings,
		const std::vector< Stub *> &	vstubs,
		unsigned int &	nMatchedLayersBest,
		std::vector< const Stub *> &	matchedStubsBest
	)

Definition at line 55 of file Utility.cc.

References matchingTP().

                                                                          {
    std::vector<const Stub*> stubsConst(vstubs.begin(), vstubs.end());
    return matchingTP(settings, stubsConst, nMatchedLayersBest, matchedStubsBest);
  }

numLayerCut()

unsigned int tmtt::Utility::numLayerCut	(	Utility::AlgoStep	algo,
		const Settings *	settings,
		unsigned int	iPhiSec,
		unsigned int	iEtaReg,
		float	invPt,
		float	eta = 0.
	)

Definition at line 141 of file Utility.cc.

References funct::abs(), ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), submitPVResolutionJobs::count, DUP, tmtt::Settings::etaSecsReduceLayers(), Exception, FIT, SiStripPI::max, tmtt::Settings::minPtToReduceLayers(), tmtt::Settings::minStubLayers(), and SEED.

Referenced by tmtt::SimpleLR4::fit(), tmtt::ChiSquaredFitBase::fit(), tmtt::TrkRZfilter::seedFilter(), and tmtt::HTcell::trackCandFound().

                                               {
    if (algo == HT || algo == SEED || algo == DUP || algo == FIT) {
      unsigned int nLayCut = settings->minStubLayers();

      //--- Check if should reduce cut on number of layers by 1 for any reason.

      bool reduce = false;

      // to increase efficiency for high Pt tracks.
      bool applyMinPt = (settings->minPtToReduceLayers() > 0);
      if (applyMinPt && std::abs(invPt) < 1 / settings->minPtToReduceLayers())
        reduce = true;

      // or to increase efficiency in the barrel-endcap transition or very forward regions.
      const vector<unsigned int>& etaSecsRed = settings->etaSecsReduceLayers();
      if (std::count(etaSecsRed.begin(), etaSecsRed.end(), iEtaReg) != 0)
        reduce = true;

      // or to increase efficiency in sectors containing dead modules (hard-wired in KF only)
      // Not implemented here.

      if (reduce)
        nLayCut--;

      constexpr unsigned int minLayCut = 4;  // Minimum viable layer cut.
      nLayCut = std::max(nLayCut, minLayCut);

      // Seed Filter & Track Fitters require only 4 layers.
      constexpr unsigned int nFitLayCut = 4;
      if (algo == SEED || algo == FIT)
        nLayCut = nFitLayCut;

      return nLayCut;
    } else {
      throw cms::Exception("LogicError") << "Utility::numLayerCut() called with invalid algo argument! " << algo;
    }
  }