OMTFSorter Class Reference

#include <OMTFSorter.h>

Public Member Functions
void	sortProcessorAndFillCandidates (unsigned int iProcessor, l1t::tftype mtfType, const std::vector< AlgoMuon > &algoCands, l1t::RegionalMuonCandBxCollection &sortedCands, int bx, int charge=0)
void	sortRefHitResults (const std::vector< OMTFProcessor::resultsMap > &procResults, std::vector< AlgoMuon > &refHitCleanCands, int charge=0)
AlgoMuon	sortRefHitResults (const OMTFProcessor::resultsMap &aResultsMap, int charge=0)

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

Detailed Description

Definition at line 15 of file OMTFSorter.h.

Member Function Documentation

bool OMTFSorter::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 231 of file OMTFSorter.cc.

Referenced by sortProcessorAndFillCandidates().

                                                         {

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

void OMTFSorter::sortProcessorAndFillCandidates	(	unsigned int	iProcessor,
		l1t::tftype	mtfType,
		const std::vector< AlgoMuon > &	algoCands,
		l1t::RegionalMuonCandBxCollection &	sortedCands,
		int	bx,
		int	charge = 0
	)

conversion factor from OMTF to uGMT scale: 5400/576

Quality is set to number of leayers hit. DT bending and position hit is counted as one. thus we subtract 1 for each DT station hit.

Candidates with bad hit patterns get quality 0.

Now quality based on hit pattern

Definition at line 244 of file OMTFSorter.cc.

References bits, checkHitPatternValidity(), l1t::RegionalMuonCand::hwPt(), OMTFConfiguration::instance(), ecaldqm::binning::nPhiBins, OMTFConfiguration::nPhiBins, BXVector< T >::push_back(), HLT_FULL_cff::quality, l1t::RegionalMuonCand::setHwEta(), l1t::RegionalMuonCand::setHwPhi(), l1t::RegionalMuonCand::setHwPt(), l1t::RegionalMuonCand::setHwQual(), l1t::RegionalMuonCand::setHwSign(), l1t::RegionalMuonCand::setTFIdentifiers(), and l1t::RegionalMuonCand::setTrackAddress().

Referenced by OMTFReconstruction::getProcessorCandidates().

                                    {

  for(auto myCand: algoCands){
    l1t::RegionalMuonCand candidate;
    std::bitset<17> bits(myCand.getHits());
    candidate.setHwPt(myCand.getPt());
    candidate.setHwEta(myCand.getEta());

    float phiValue = myCand.getPhi();
    if(phiValue>=(int)OMTFConfiguration::instance()->nPhiBins) phiValue-=OMTFConfiguration::instance()->nPhiBins;
    phiValue/=9.375;
    candidate.setHwPhi(phiValue);
    
    candidate.setHwSign(myCand.getCharge()<0 ? 1:0  );
    //FIXME: Obsolete 
    //candidate.setHwQual(bits.count() - bits.test(0) - bits.test(2) - bits.test(4));
    //if(!checkHitPatternValidity(myCand.getHits())) candidate.setHwQual(0);

    unsigned int quality = checkHitPatternValidity(myCand.getHits()) ? 0 | (1 << 2) | (1 << 3) 
                                                                     : 0 | (1 << 2);
    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()) sortedCands.push_back(bx, candidate);
  }
}

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

Sort all processor results. First for each region cone find a best candidate using sortRegionResults() Then select best candidate amongs found for each logic region. The sorting is made for candidates with a given charge Sort all processor results. First for each region cone find a best candidate using sortRegionResults() Then select best candidate amongs found for each logic region

Definition at line 127 of file OMTFSorter.cc.

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

                         {
  
  for(auto itRefHit: procResults) refHitCands.push_back(sortRefHitResults(itRefHit,charge));
}

AlgoMuon OMTFSorter::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 69 of file OMTFSorter.cc.

References AlgoMuon::getDisc(), AlgoMuon::getEta(), AlgoMuon::getHits(), AlgoMuon::getPhi(), AlgoMuon::getPhiRHit(), AlgoMuon::getQ(), AlgoMuon::getRefLayer(), AlgoMuon::setPhiRHit(), sortSingleResult(), Key::theCharge, and Key::thePtCode.

                                 {

  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;

  for(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;
    }
    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;
    }
    else if(val.getQ() == (int)nHitsMax && val.getDisc() == (int)pdfValMax &&
      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;
    }
  }

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

  candidate.setPhiRHit(refPhiRHit); // for backward compatibility

  return candidate;
}

AlgoMuon OMTFSorter::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 16 of file OMTFSorter.cc.

References 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 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;
}