OMTFSorter Class Reference

#include <OMTFSorter.h>

Public Member Functions
void	setNphiBins (unsigned int phiBins)
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)

Private Attributes
unsigned int	nPhiBins

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 135 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::setNphiBins ( unsigned int  phiBins )

inline

Definition at line 19 of file OMTFSorter.h.

References nPhiBins.

Referenced by OMTFReconstruction::beginRun().

{ nPhiBins = phiBins;}

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

Definition at line 148 of file OMTFSorter.cc.

References funct::abs(), checkHitPatternValidity(), l1t::RegionalMuonCand::hwPt(), nPhiBins, BXVector< T >::push_back(), HLT_25ns10e33_v2_cff::quality, 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().

                                    {

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

    float phiValue = myCand.getPhi();
    if(phiValue>=nPhiBins) phiValue-=nPhiBins;
    phiValue/=9.375;
    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 (abs(myCand.getEta()) == 121) quality = 4;
    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
	)

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

Member Data Documentation

unsigned int OMTFSorter::nPhiBins

private

Definition at line 57 of file OMTFSorter.h.

Referenced by setNphiBins(), and sortProcessorAndFillCandidates().