OMTFSorter< GoldenPatternType > Class Template Reference

#include <OMTFSorter.h>

Inheritance diagram for OMTFSorter< GoldenPatternType >:

Public Member Functions
std::vector< l1t::RegionalMuonCand >	candidates (unsigned int iProcessor, l1t::tftype mtfType, const std::vector< AlgoMuon > &algoCands)
void	initialize (const OMTFConfiguration *cfg)
	OMTFSorter (int sorterTypeFlag)
void	setNphiBins (unsigned int phiBins)
AlgoMuons::value_type	sortRefHitResults (unsigned int procIndx, unsigned int iRefHit, const GoldenPatternVec< GoldenPatternType > &gPatterns, int charge=0) override
void	sortRefHitResults (const std::vector< OMTFProcessor::resultsMap > &procResults, std::vector< AlgoMuon > &refHitCleanCands, int charge=0)
AlgoMuon	sortRefHitResults (const OMTFProcessor::resultsMap &aResultsMap, int charge=0)
	~OMTFSorter () override
Public Member Functions inherited from SorterBase< GoldenPatternType >
virtual AlgoMuons	sortResults (unsigned int procIndx, const GoldenPatternVec< GoldenPatternType > &gPatterns, int charge=0)
virtual	~SorterBase ()

Private Member Functions
bool	checkHitPatternValidity (unsigned int hits)
AlgoMuon	sortSingleResult (const OMTFResult &aResult)

Private Attributes
const OMTFConfiguration *	myOmtfConfig
int	myType
unsigned int	nPhiBins

Detailed Description

template<class GoldenPatternType>
class OMTFSorter< GoldenPatternType >

Definition at line 17 of file OMTFSorter.h.

Constructor & Destructor Documentation

OMTFSorter()

template<class GoldenPatternType >

OMTFSorter< GoldenPatternType >::OMTFSorter ( int  sorterTypeFlag )

inline

Definition at line 10 of file OMTFSorter.h.

: myType(sorterTypeFlag) {}

~OMTFSorter()

template<class GoldenPatternType >

OMTFSorter< GoldenPatternType >::~OMTFSorter ( )

inlineoverride

Definition at line 12 of file OMTFSorter.h.

{}

Member Function Documentation

candidates()

template<class GoldenPatternType >

std::vector< l1t::RegionalMuonCand > OMTFSorter< GoldenPatternType >::candidates	(	unsigned int	iProcessor,
		l1t::tftype	mtfType,
		const std::vector< AlgoMuon > &	algoCands
	)

conversion factor from OMTF to uGMT scale is 5400/576 i.e. phiValue/=9.375;

Definition at line 156 of file OMTFSorter.cc.

References funct::abs(), OMTFSorter< GoldenPatternType >::checkHitPatternValidity(), OMTFConfiguration::fwVersion(), l1t::RegionalMuonCand::hwPt(), OMTFSorter< GoldenPatternType >::myOmtfConfig, OMTFSorter< GoldenPatternType >::nPhiBins, funct::pow(), quality, mps_fire::result, l1t::RegionalMuonCand::setHwEta(), l1t::RegionalMuonCand::setHwPhi(), l1t::RegionalMuonCand::setHwPt(), l1t::RegionalMuonCand::setHwQual(), l1t::RegionalMuonCand::setHwSign(), l1t::RegionalMuonCand::setHwSignValid(), l1t::RegionalMuonCand::setTFIdentifiers(), and l1t::RegionalMuonCand::setTrackAddress().

Referenced by OMTFReconstruction::getProcessorCandidates().

                                                                                                {
  std::vector<l1t::RegionalMuonCand> result;

  for (const auto& myCand : algoCands) {
    l1t::RegionalMuonCand candidate;
    candidate.setHwPt(myCand.getPt());
    candidate.setHwEta(myCand.getEta());

    int phiValue = myCand.getPhi();
    if (phiValue >= int(nPhiBins))
      phiValue -= nPhiBins;
    phiValue = floor(phiValue * 437. / pow(2, 12));  // ie. use as in hw: 9.3729977
    candidate.setHwPhi(phiValue);

    candidate.setHwSign(myCand.getCharge() < 0 ? 1 : 0);
    candidate.setHwSignValid(1);

    unsigned int quality = checkHitPatternValidity(myCand.getHits()) ? 0 | (1 << 2) | (1 << 3) : 0 | (1 << 2);
    if (abs(myCand.getEta()) == 115 &&
        (static_cast<unsigned int>(myCand.getHits()) == std::bitset<18>("100000001110000000").to_ulong() ||
         static_cast<unsigned int>(myCand.getHits()) == std::bitset<18>("000000001110000000").to_ulong() ||
         static_cast<unsigned int>(myCand.getHits()) == std::bitset<18>("100000000110000000").to_ulong() ||
         static_cast<unsigned int>(myCand.getHits()) == std::bitset<18>("100000001100000000").to_ulong() ||
         static_cast<unsigned int>(myCand.getHits()) == std::bitset<18>("100000001010000000").to_ulong()))
      quality = 4;
    if (myOmtfConfig->fwVersion() >= 5) {
      if (static_cast<unsigned int>(myCand.getHits()) == std::bitset<18>("000000010000000011").to_ulong() ||
          static_cast<unsigned int>(myCand.getHits()) == std::bitset<18>("000000100000000011").to_ulong() ||
          static_cast<unsigned int>(myCand.getHits()) == std::bitset<18>("000001000000000011").to_ulong() ||
          static_cast<unsigned int>(myCand.getHits()) == std::bitset<18>("000010000000000011").to_ulong() ||
          static_cast<unsigned int>(myCand.getHits()) == std::bitset<18>("000100000000000011").to_ulong() ||
          static_cast<unsigned int>(myCand.getHits()) == std::bitset<18>("001000000000000011").to_ulong() ||
          static_cast<unsigned int>(myCand.getHits()) == std::bitset<18>("010000000000000011").to_ulong() ||
          static_cast<unsigned int>(myCand.getHits()) == std::bitset<18>("100000000000000011").to_ulong() ||
          static_cast<unsigned int>(myCand.getHits()) == std::bitset<18>("000000010000001100").to_ulong() ||
          static_cast<unsigned int>(myCand.getHits()) == std::bitset<18>("000000100000001100").to_ulong() ||
          static_cast<unsigned int>(myCand.getHits()) == std::bitset<18>("000001000000001100").to_ulong() ||
          static_cast<unsigned int>(myCand.getHits()) == std::bitset<18>("000010000000001100").to_ulong() ||
          static_cast<unsigned int>(myCand.getHits()) == std::bitset<18>("000100000000001100").to_ulong() ||
          static_cast<unsigned int>(myCand.getHits()) == std::bitset<18>("001000000000001100").to_ulong() ||
          static_cast<unsigned int>(myCand.getHits()) == std::bitset<18>("010000000000001100").to_ulong() ||
          static_cast<unsigned int>(myCand.getHits()) == std::bitset<18>("100000000000001100").to_ulong() ||
          static_cast<unsigned int>(myCand.getHits()) == std::bitset<18>("000000010000110000").to_ulong() ||
          static_cast<unsigned int>(myCand.getHits()) == std::bitset<18>("000000100000110000").to_ulong() ||
          static_cast<unsigned int>(myCand.getHits()) == std::bitset<18>("000001000000110000").to_ulong() ||
          static_cast<unsigned int>(myCand.getHits()) == std::bitset<18>("000010000000110000").to_ulong() ||
          static_cast<unsigned int>(myCand.getHits()) == std::bitset<18>("000100000000110000").to_ulong() ||
          static_cast<unsigned int>(myCand.getHits()) == std::bitset<18>("001000000000110000").to_ulong() ||
          static_cast<unsigned int>(myCand.getHits()) == std::bitset<18>("010000000000110000").to_ulong() ||
          static_cast<unsigned int>(myCand.getHits()) == std::bitset<18>("100000000000110000").to_ulong())
        quality = 1;
    }

    //  if (abs(myCand.getEta()) == 121) quality = 4;
    if (abs(myCand.getEta()) == 121)
      quality = 0;  // changed on request from HI

    candidate.setHwQual(quality);

    std::map<int, int> trackAddr;
    trackAddr[0] = myCand.getHits();
    trackAddr[1] = myCand.getRefLayer();
    trackAddr[2] = myCand.getDisc();
    candidate.setTrackAddress(trackAddr);
    candidate.setTFIdentifiers(iProcessor, mtfType);
    if (candidate.hwPt())
      result.push_back(candidate);
  }
  return result;
}

checkHitPatternValidity()

template<class GoldenPatternType >

bool OMTFSorter< GoldenPatternType >::checkHitPatternValidity ( unsigned int  hits )

private

Check if the hit pattern of given OMTF candite is not on the list of invalid hit patterns. Invalid hit patterns provode very little to efficiency, but gives high contribution to rate. Candidate with invalid hit patterns is assigned quality=0. Currently the list of invalid patterns is hardcoded. This has to be read from configuration.

FIXME: read the list from configuration so this can be controlled at runtime.

Definition at line 142 of file OMTFSorter.cc.

References hfClusterShapes_cfi::hits.

Referenced by OMTFSorter< GoldenPatternType >::candidates().

                                                          {
  std::vector<unsigned int> badPatterns = {
      99840, 34304, 3075, 36928, 12300, 98816, 98944, 33408, 66688, 66176, 7171, 20528, 33856, 35840, 4156, 34880};

  for (auto aHitPattern : badPatterns) {
    if (hits == aHitPattern)
      return false;
  }

  return true;
}

initialize()

template<class GoldenPatternType >

void OMTFSorter< GoldenPatternType >::initialize ( const OMTFConfiguration *  cfg )

inline

Definition at line 19 of file OMTFSorter.h.

References looper::cfg, and OMTFSorter< GoldenPatternType >::myOmtfConfig.

Referenced by OMTFReconstruction::beginRun().

{ myOmtfConfig = cfg; }

setNphiBins()

template<class GoldenPatternType >

void OMTFSorter< GoldenPatternType >::setNphiBins ( unsigned int  phiBins )

inline

Definition at line 20 of file OMTFSorter.h.

References OMTFSorter< GoldenPatternType >::nPhiBins, and l1tTrackJets_cfi::phiBins.

Referenced by OMTFReconstruction::beginRun().

{ nPhiBins = phiBins; }

sortRefHitResults() [1/3]

template<class GoldenPatternType >

AlgoMuons::value_type OMTFSorter< GoldenPatternType >::sortRefHitResults ( unsigned int  procIndx, unsigned int  iRefHit, const GoldenPatternVec< GoldenPatternType > &  gPatterns, int  charge = 0  )

overridevirtual

Sort results from a single reference hit. Select candidate with highest number of hit layers Then select a candidate with largest likelihood value and given charge as we allow two candidates with opposite charge from single 10deg region

Accept only candidates with >2 hits

Implements SorterBase< GoldenPatternType >.

Definition at line 17 of file OMTFSorter.cc.

References ALCARECOTkAlJpsiMuMu_cff::charge.

                                                                                                                   {
  GoldenPatternType* bestGP = nullptr;  //the GoldenPattern with the best result for this iRefHit

  GoldenPatternType* bestGpUnconstr = nullptr;

  for (auto& itGP : gPatterns) {
    if (!itGP->getResults()[procIndx][iRefHit].isValid())
      continue;

    if (charge != 0 && itGP->key().theCharge != charge)
      continue;  //charge==0 means ignore charge

    if (itGP->getResults()[procIndx][iRefHit].getFiredLayerCnt() < 3)  //TODO - move 3 to the configuration??
      continue;

    if (bestGP == nullptr) {
      bestGP = itGP.get();
    } else if (myType == 0 && itGP->getResults()[procIndx][iRefHit].getFiredLayerCnt() >
                                  bestGP->getResults()[procIndx][iRefHit].getFiredLayerCnt()) {
      bestGP = itGP.get();
    } else if (myType == 1 || (itGP->getResults()[procIndx][iRefHit].getFiredLayerCnt() ==
                               bestGP->getResults()[procIndx][iRefHit].getFiredLayerCnt())) {
      if (itGP->getResults()[procIndx][iRefHit].getPdfSum() > bestGP->getResults()[procIndx][iRefHit].getPdfSum()) {
        //if the PdfWeigtSum is equal, we take the GP with the lower number, i.e. lower pt = check if this is ok for physics FIXME (KB)
        bestGP = itGP.get();
      }
    }

    if (bestGpUnconstr == nullptr) {
      if (itGP->getResults()[procIndx][iRefHit].getPdfSumUnconstr() > 0)
        bestGpUnconstr = itGP.get();
    } else if (myType == 0 && itGP->getResults()[procIndx][iRefHit].getFiredLayerCnt() >
                                  bestGpUnconstr->getResults()[procIndx][iRefHit].getFiredLayerCnt()) {
      bestGpUnconstr = itGP.get();
    } else if (myType == 1 || (itGP->getResults()[procIndx][iRefHit].getFiredLayerCnt() ==
                               bestGpUnconstr->getResults()[procIndx][iRefHit].getFiredLayerCnt())) {
      if (itGP->getResults()[procIndx][iRefHit].getPdfSumUnconstr() >
          bestGpUnconstr->getResults()[procIndx][iRefHit].getPdfSumUnconstr()) {
        //if the PdfWeigtSum is equal, we take the GP with the lower number, i.e. lower pt = check if this is ok for physics FIXME (KB)
        bestGpUnconstr = itGP.get();
      }
    }
  }
  if (bestGP) {
    //this is needed to obtain the same results as in the firmware. for the actual performance it should not matter
    if (bestGP->getResults()[procIndx][iRefHit].getPdfSum() == 0)
      bestGP = gPatterns.at(0).get();

    AlgoMuons::value_type candidate(new AlgoMuon(bestGP->getResults()[procIndx][iRefHit], bestGP, iRefHit));

    if (bestGpUnconstr) {
      candidate->setGpResultUnconstr(bestGpUnconstr->getResults()[procIndx][iRefHit]);
      candidate->setGoldenPaternUnconstr(bestGpUnconstr);
    }

    return candidate;
  } else {
    AlgoMuons::value_type candidate(new AlgoMuon());
    candidate->setRefHitNumber(iRefHit);
    return candidate;
  }
}

sortRefHitResults() [2/3]

template<class GoldenPatternType >

void OMTFSorter< GoldenPatternType >::sortRefHitResults	(	const std::vector< OMTFProcessor::resultsMap > &	procResults,
		std::vector< AlgoMuon > &	refHitCleanCands,
		int	charge = 0
	)

Definition at line 130 of file OMTFSorter.cc.

References ALCARECOTkAlJpsiMuMu_cff::charge, and amptDefaultParameters_cff::mu.

Referenced by OMTFReconstruction::getProcessorCandidates(), and OMTFReconstruction::writeResultToXML().

                                               {
  //  for(auto itRefHit: procResults) refHitCands.push_back(sortRefHitResults(itRefHit,charge));
  for (unsigned int iRefHit = 0; iRefHit < procResults.size(); iRefHit++) {
    AlgoMuon mu = sortRefHitResults(procResults[iRefHit], charge);
    mu.setRefHitNumber(iRefHit);
    refHitCands.push_back(mu);
  }
}

sortRefHitResults() [3/3]

template<class GoldenPatternType >

AlgoMuon OMTFSorter< GoldenPatternType >::sortRefHitResults	(	const OMTFProcessor::resultsMap &	aResultsMap,
		int	charge = 0
	)

Sort results from a single reference hit. Select candidate with highest number of hit layers Then select a candidate with largest likelihood value and given charge as we allow two candidates with opposite charge from single 10deg region

Accept only candidates with >2 hits

Definition at line 68 of file OMTFSorter.cc.

References ALCARECOTkAlJpsiMuMu_cff::charge, createfilelist::int, Key::number(), AlgoMuon::setPatternNumber(), AlgoMuon::setPhiRHit(), OMTFSorter< GoldenPatternType >::sortSingleResult(), Key::theCharge, Key::thePtCode, and heppy_batch::val.

                                                                                             {
  unsigned int pdfValMax = 0;
  unsigned int nHitsMax = 0;
  unsigned int hitsWord = 0;
  int refPhi = 9999;
  int refEta = 999;
  int refLayer = -1;
  int refPhiRHit = 9999;
  Key bestKey;

  //  std::cout <<" ====== sortRefHitResults: " << std::endl;
  for (const auto& itKey : aResultsMap) {
    if (charge != 0 && itKey.first.theCharge != charge)
      continue;  //charge==0 means ignore charge
    AlgoMuon val = sortSingleResult(itKey.second);
    if (val.getQ() < 3)
      continue;

    if (val.getQ() > (int)nHitsMax) {
      nHitsMax = val.getQ();
      pdfValMax = val.getDisc();
      refPhi = val.getPhi();
      refEta = val.getEta();
      refLayer = val.getRefLayer();
      hitsWord = val.getHits();
      refPhiRHit = val.getPhiRHit();
      bestKey = itKey.first;
      //      std::cout <<" sorter, byQual, now best is: "<<bestKey << std::endl;
    } else if (val.getQ() == (int)nHitsMax && val.getDisc() > (int)pdfValMax) {
      pdfValMax = val.getDisc();
      refPhi = val.getPhi();
      refEta = val.getEta();
      refLayer = val.getRefLayer();
      hitsWord = val.getHits();
      refPhiRHit = val.getPhiRHit();
      bestKey = itKey.first;
      //      std::cout <<" sorter, byDisc, now best is: "<<bestKey << std::endl;
    } else if (val.getQ() == (int)nHitsMax && val.getDisc() == (int)pdfValMax &&
               itKey.first.number() < bestKey.number()) {
      //      itKey.first.thePtCode < bestKey.thePtCode){
      pdfValMax = val.getDisc();
      refPhi = val.getPhi();
      refEta = val.getEta();
      refLayer = val.getRefLayer();
      hitsWord = val.getHits();
      refPhiRHit = val.getPhiRHit();
      bestKey = itKey.first;
      //      std::cout <<" sorter, byNumb, now best is: "<<bestKey << std::endl;
    }
  }

  AlgoMuon candidate(pdfValMax, refPhi, refEta, refLayer, hitsWord, nHitsMax, 0, bestKey.thePtCode, bestKey.theCharge);

  candidate.setPhiRHit(refPhiRHit);  // for backward compatibility
  candidate.setPatternNumber(bestKey.number());

  //  std::cout <<" return: " << candidate << std::endl;
  return candidate;
}

sortSingleResult()

template<class GoldenPatternType >

AlgoMuon OMTFSorter< GoldenPatternType >::sortSingleResult ( const OMTFResult &  aResult )

private

Find a candidate with best parameters for given GoldenPattern Sorting is made amongs candidates with different reference layers The output tuple contains (nHitsMax, pdfValMax, refPhi, refLayer, hitsWord, refEta) hitsWord codes number of layers hit: hitsWord= sum 2**iLogicLayer, where sum runs over layers which were hit

Find a result with biggest number of hits

Definition at line 14 of file OMTFSorter.cc.

References cms::cuda::assert(), OMTFResult::getHitsWord(), OMTFResult::getRefEtas(), OMTFResult::getRefPhiRHits(), OMTFResult::getRefPhis(), OMTFResult::getSummaryHits(), OMTFResult::getSummaryVals(), AlgoMuon::setDisc(), AlgoMuon::setEta(), AlgoMuon::setHits(), AlgoMuon::setPhi(), AlgoMuon::setPhiRHit(), AlgoMuon::setQ(), and AlgoMuon::setRefLayer().

Referenced by OMTFSorter< GoldenPatternType >::sortRefHitResults().

                                                               {
  OMTFResult::vector1D pdfValsVec = aResult.getSummaryVals();
  OMTFResult::vector1D nHitsVec = aResult.getSummaryHits();
  OMTFResult::vector1D refPhiVec = aResult.getRefPhis();
  OMTFResult::vector1D refEtaVec = aResult.getRefEtas();
  OMTFResult::vector1D hitsVec = aResult.getHitsWord();
  OMTFResult::vector1D refPhiRHitVec = aResult.getRefPhiRHits();

  assert(pdfValsVec.size() == nHitsVec.size());

  unsigned int nHitsMax = 0;
  unsigned int pdfValMax = 0;
  unsigned int hitsWord = 0;
  int refPhi = 1024;
  int refEta = -10;
  int refLayer = -1;
  int refPhiRHit = 1024;

  AlgoMuon sortedResult(pdfValMax, refPhi, refEta, refLayer, hitsWord, nHitsMax);

  for (auto itHits : nHitsVec) {
    if (itHits > nHitsMax)
      nHitsMax = itHits;
  }

  if (!nHitsMax)
    return sortedResult;

  for (unsigned int ipdfVal = 0; ipdfVal < pdfValsVec.size(); ++ipdfVal) {
    if (nHitsVec[ipdfVal] == nHitsMax) {
      if (pdfValsVec[ipdfVal] > pdfValMax) {
        pdfValMax = pdfValsVec[ipdfVal];
        refPhi = refPhiVec[ipdfVal];
        refEta = refEtaVec[ipdfVal];
        refLayer = ipdfVal;
        hitsWord = hitsVec[ipdfVal];
        refPhiRHit = refPhiRHitVec[ipdfVal];
      }
    }
  }

  sortedResult.setDisc(pdfValMax);
  sortedResult.setPhi(refPhi);
  sortedResult.setEta(refEta);
  sortedResult.setRefLayer(refLayer);
  sortedResult.setHits(hitsWord);
  sortedResult.setQ(nHitsMax);
  sortedResult.setPhiRHit(refPhiRHit);

  return sortedResult;
}

Member Data Documentation

myOmtfConfig

template<class GoldenPatternType >

const OMTFConfiguration* OMTFSorter< GoldenPatternType >::myOmtfConfig

private

Definition at line 55 of file OMTFSorter.h.

Referenced by OMTFSorter< GoldenPatternType >::candidates(), and OMTFSorter< GoldenPatternType >::initialize().

myType

template<class GoldenPatternType >

int OMTFSorter< GoldenPatternType >::myType

private

Definition at line 24 of file OMTFSorter.h.

nPhiBins

template<class GoldenPatternType >

unsigned int OMTFSorter< GoldenPatternType >::nPhiBins

private

Definition at line 54 of file OMTFSorter.h.

Referenced by OMTFSorter< GoldenPatternType >::candidates(), and OMTFSorter< GoldenPatternType >::setNphiBins().