OMTFProcessor Class Reference

#include <OMTFProcessor.h>

Public Types
typedef std::map< Key, OMTFResult >	resultsMap

Public Member Functions
void	averagePatterns (int charge)
bool	configure (const OMTFConfiguration *omtfParams, const L1TMuonOverlapParams *omtfPatterns)
	Fill GP map with patterns from CondFormats object. More...
void	fillCounts (unsigned int iProcessor, const OMTFinput &aInput, const SimTrack *aSimMuon)
const std::map< Key, GoldenPattern * > &	getPatterns () const
	Return map of GoldenPatterns. More...
	OMTFProcessor ()
const std::vector< OMTFProcessor::resultsMap > &	processInput (unsigned int iProcessor, const OMTFinput &aInput)
	~OMTFProcessor ()

Private Member Functions
bool	addGP (GoldenPattern *aGP)
void	fillInputRange (unsigned int iProcessor, unsigned int iCone, const OMTFinput &aInput)
void	fillInputRange (unsigned int iProcessor, unsigned int iCone, unsigned int iRefLayer, unsigned int iHit)
void	resetConfiguration ()
	Reset all configuration parameters. More...
OMTFinput::vector1D	restrictInput (unsigned int iProcessor, unsigned int iCone, unsigned int iLayer, const OMTFinput::vector1D &layerHits)
void	shiftGP (GoldenPattern *aGP, const GoldenPattern::vector2D &meanDistPhiNew, const GoldenPattern::vector2D &meanDistPhiOld)

Private Attributes
const OMTFConfiguration *	myOmtfConfig
std::vector< OMTFProcessor::resultsMap >	myResults
std::map< Key, GoldenPattern * >	theGPs
	Map holding Golden Patterns. More...

Detailed Description

Definition at line 19 of file OMTFProcessor.h.

Member Typedef Documentation

typedef std::map<Key, OMTFResult> OMTFProcessor::resultsMap

Definition at line 21 of file OMTFProcessor.h.

Constructor & Destructor Documentation

OMTFProcessor::OMTFProcessor ( )

inline

Definition at line 23 of file OMTFProcessor.h.

References ALCARECOTkAlJpsiMuMu_cff::charge, and fakeOmtfParams_cff::omtfParams.

{};

OMTFProcessor::~OMTFProcessor

(

)

Definition at line 22 of file OMTFProcessor.cc.

References theGPs.

                              {
  for (auto it : theGPs)
    delete it.second;
}

Member Function Documentation

bool OMTFProcessor::addGP ( GoldenPattern *  aGP )

private

Add GoldenPattern to pattern map. If GP key already exists in map, a new entry is ignored

Definition at line 96 of file OMTFProcessor.cc.

References OMTFResult::configure(), Exception, GoldenPattern::key(), myOmtfConfig, myResults, and theGPs.

Referenced by configure().

                                            {
  if (theGPs.find(aGP->key()) != theGPs.end()) {
    throw cms::Exception("Corrupted Golden Patterns data")
        << "OMTFProcessor::addGP(...) "
        << " Reading two Golden Patterns with the same key: " << aGP->key() << std::endl;
  } else
    theGPs[aGP->key()] = aGP;

  for (auto &itRegion : myResults) {
    OMTFResult aResult;
    aResult.configure(myOmtfConfig);
    itRegion[aGP->key()] = aResult;
  }

  return true;
}

void OMTFProcessor::averagePatterns

(

int

charge

)

Average patterns. Use same meanDistPhi for two patterns neighboring in pt code. Averaging is made saparately fo each charge

Previously pt codes were going by steps of 1, now this is not the case

Definition at line 114 of file OMTFProcessor.cc.

References GoldenPattern::getMeanDistPhi(), myOmtfConfig, OMTFConfiguration::nLayers(), OMTFConfiguration::nRefLayers(), GoldenPattern::setMeanDistPhi(), shiftGP(), theGPs, and Key::thePtCode.

Referenced by OMTFPatternMaker::endJob().

                                              {
  Key aKey(0, 9, charge);

  while (theGPs.find(aKey) != theGPs.end()) {
    GoldenPattern *aGP1 = theGPs.find(aKey)->second;
    GoldenPattern *aGP2 = aGP1;
    GoldenPattern *aGP3 = aGP1;
    GoldenPattern *aGP4 = aGP1;

    ++aKey.thePtCode;
    while (theGPs.find(aKey) == theGPs.end() && aKey.thePtCode <= 401)
      ++aKey.thePtCode;
    if (aKey.thePtCode <= 401 && theGPs.find(aKey) != theGPs.end())
      aGP2 = theGPs.find(aKey)->second;

    if (aKey.thePtCode > 71) {
      ++aKey.thePtCode;
      while (theGPs.find(aKey) == theGPs.end() && aKey.thePtCode <= 401)
        ++aKey.thePtCode;
      if (aKey.thePtCode <= 401 && theGPs.find(aKey) != theGPs.end())
        aGP3 = theGPs.find(aKey)->second;

      ++aKey.thePtCode;
      while (theGPs.find(aKey) == theGPs.end() && aKey.thePtCode <= 401)
        ++aKey.thePtCode;
      if (aKey.thePtCode <= 401 && theGPs.find(aKey) != theGPs.end())
        aGP4 = theGPs.find(aKey)->second;
    } else {
      aGP3 = aGP1;
      aGP4 = aGP2;
    }
    //HACK. Have to clean this up.
    ++aKey.thePtCode;
    while (theGPs.find(aKey) == theGPs.end() && aKey.thePtCode <= 401)
      ++aKey.thePtCode;

    GoldenPattern::vector2D meanDistPhi = aGP1->getMeanDistPhi();

    GoldenPattern::vector2D meanDistPhi1 = aGP1->getMeanDistPhi();
    GoldenPattern::vector2D meanDistPhi2 = aGP2->getMeanDistPhi();
    GoldenPattern::vector2D meanDistPhi3 = aGP3->getMeanDistPhi();
    GoldenPattern::vector2D meanDistPhi4 = aGP4->getMeanDistPhi();

    for (unsigned int iLayer = 0; iLayer < myOmtfConfig->nLayers(); ++iLayer) {
      for (unsigned int iRefLayer = 0; iRefLayer < myOmtfConfig->nRefLayers(); ++iRefLayer) {
        meanDistPhi[iLayer][iRefLayer] += meanDistPhi2[iLayer][iRefLayer];
        meanDistPhi[iLayer][iRefLayer] += meanDistPhi3[iLayer][iRefLayer];
        meanDistPhi[iLayer][iRefLayer] += meanDistPhi4[iLayer][iRefLayer];
        meanDistPhi[iLayer][iRefLayer] /= 4;
      }
    }

    aGP1->setMeanDistPhi(meanDistPhi);
    aGP2->setMeanDistPhi(meanDistPhi);

    shiftGP(aGP1, meanDistPhi, meanDistPhi1);
    shiftGP(aGP2, meanDistPhi, meanDistPhi2);
    if (aGP3 != aGP1 && aGP4 != aGP2) {
      aGP3->setMeanDistPhi(meanDistPhi);
      aGP4->setMeanDistPhi(meanDistPhi);
      shiftGP(aGP3, meanDistPhi, meanDistPhi3);
      shiftGP(aGP4, meanDistPhi, meanDistPhi4);
    }
  }
}

bool OMTFProcessor::configure	(	const OMTFConfiguration *	omtfParams,
		const L1TMuonOverlapParams *	omtfPatterns
	)

Fill GP map with patterns from CondFormats object.

Mean dist phi data

Pdf data

Definition at line 36 of file OMTFProcessor.cc.

References addGP(), L1TMuonOverlapParams::chargeLUT(), l1t::LUT::data(), L1TMuonOverlapParams::etaLUT(), createfilelist::int, L1TMuonOverlapParams::meanDistPhiLUT(), myOmtfConfig, myResults, OMTFConfiguration::nGoldenPatterns(), OMTFConfiguration::nLayers(), OMTFConfiguration::nPdfAddrBits(), l1t::LUT::nrBitsData(), OMTFConfiguration::nRefLayers(), OMTFConfiguration::nTestRefHits(), L1TMuonOverlapParams::pdfLUT(), L1TMuonOverlapParams::ptLUT(), resetConfiguration(), GoldenPattern::setMeanDistPhi(), and GoldenPattern::setPdf().

Referenced by OMTFPatternMaker::beginRun(), and OMTFReconstruction::beginRun().

                                                                                                           {
  resetConfiguration();

  myOmtfConfig = omtfConfig;

  myResults.assign(myOmtfConfig->nTestRefHits(), OMTFProcessor::resultsMap());

  const l1t::LUT *chargeLUT = omtfPatterns->chargeLUT();
  const l1t::LUT *etaLUT = omtfPatterns->etaLUT();
  const l1t::LUT *ptLUT = omtfPatterns->ptLUT();
  const l1t::LUT *pdfLUT = omtfPatterns->pdfLUT();
  const l1t::LUT *meanDistPhiLUT = omtfPatterns->meanDistPhiLUT();

  unsigned int nGPs = myOmtfConfig->nGoldenPatterns();
  unsigned int address = 0;
  unsigned int iEta, iPt;
  int iCharge;
  for (unsigned int iGP = 0; iGP < nGPs; ++iGP) {
    address = iGP;
    iEta = etaLUT->data(address);
    iCharge = chargeLUT->data(address) == 0 ? -1 : 1;
    iPt = ptLUT->data(address);

    GoldenPattern::vector2D meanDistPhi2D(myOmtfConfig->nLayers());
    GoldenPattern::vector1D pdf1D(exp2(myOmtfConfig->nPdfAddrBits()));
    GoldenPattern::vector3D pdf3D(myOmtfConfig->nLayers());
    GoldenPattern::vector2D pdf2D(myOmtfConfig->nRefLayers());
    for (unsigned int iLayer = 0; iLayer < myOmtfConfig->nLayers(); ++iLayer) {
      GoldenPattern::vector1D meanDistPhi1D(myOmtfConfig->nRefLayers());
      for (unsigned int iRefLayer = 0; iRefLayer < myOmtfConfig->nRefLayers(); ++iRefLayer) {
        address = iRefLayer + iLayer * myOmtfConfig->nRefLayers() +
                  iGP * (myOmtfConfig->nRefLayers() * myOmtfConfig->nLayers());
        meanDistPhi1D[iRefLayer] = meanDistPhiLUT->data(address) - (1 << (meanDistPhiLUT->nrBitsData() - 1));
      }
      meanDistPhi2D[iLayer] = meanDistPhi1D;
      for (unsigned int iRefLayer = 0; iRefLayer < myOmtfConfig->nRefLayers(); ++iRefLayer) {
        pdf1D.assign(1 << myOmtfConfig->nPdfAddrBits(), 0);
        for (unsigned int iPdf = 0; iPdf < (unsigned int)(1 << myOmtfConfig->nPdfAddrBits()); ++iPdf) {
          address = iPdf + iRefLayer * (1 << myOmtfConfig->nPdfAddrBits()) +
                    iLayer * myOmtfConfig->nRefLayers() * (1 << myOmtfConfig->nPdfAddrBits()) +
                    iGP * myOmtfConfig->nLayers() * myOmtfConfig->nRefLayers() * (1 << myOmtfConfig->nPdfAddrBits());
          pdf1D[iPdf] = pdfLUT->data(address);
        }
        pdf2D[iRefLayer] = pdf1D;
      }
      pdf3D[iLayer] = pdf2D;
    }
    Key aKey(iEta, iPt, iCharge, iGP);

    GoldenPattern *aGP = new GoldenPattern(aKey, myOmtfConfig);
    aGP->setMeanDistPhi(meanDistPhi2D);
    aGP->setPdf(pdf3D);
    addGP(aGP);
  }
  return true;
}

void OMTFProcessor::fillCounts	(	unsigned int	iProcessor,
		const OMTFinput &	aInput,
		const SimTrack *	aSimMuon
	)

Fill counts for a GoldenPattern of this processor unit. Pattern key is selcted according to the SimTrack parameters.

Stupid conersion. Have to go through PAC pt scale, as we later shift resulting pt code by +1

Number of reference hits to be checked.

Definition at line 287 of file OMTFProcessor.cc.

References funct::abs(), OMTFConfiguration::getBendingLayers(), OMTFinput::getLayerData(), OMTFinput::getRefHits(), OMTFConfiguration::getRefHitsDefs(), OMTFConfiguration::getRefToLogicNumber(), RefHitDef::iInput, RPCConst::iptFromPt(), RefHitDef::iRefLayer, RefHitDef::iRegion, CoreSimTrack::momentum(), myOmtfConfig, OMTFConfiguration::nLayers(), OMTFConfiguration::nRefHits(), RPCConst::ptFromIpt(), restrictInput(), AlignmentTrackSelector_cfi::theCharge, theGPs, and CoreSimTrack::type().

Referenced by OMTFPatternMaker::analyze().

                                                                                                         {
  int theCharge = (abs(aSimMuon->type()) == 13) ? aSimMuon->type() / -13 : 0;
  unsigned int iPt = RPCConst::iptFromPt(aSimMuon->momentum().pt());
  iPt += 1;
  if (iPt > 31)
    iPt = 200 * 2 + 1;
  else
    iPt = RPCConst::ptFromIpt(iPt) * 2.0 +
          1;  //MicroGMT has 0.5 GeV step size, with lower bin edge  (uGMT_pt_code - 1)*step_size

  std::bitset<128> refHitsBits = aInput.getRefHits(iProcessor);
  if (refHitsBits.none())
    return;

  std::ostringstream myStr;
  myStr << "iProcessor: " << iProcessor << std::endl;
  myStr << "Input: ------------" << std::endl;
  myStr << aInput << std::endl;
  edm::LogInfo("OMTF processor") << myStr.str();

  for (unsigned int iLayer = 0; iLayer < myOmtfConfig->nLayers(); ++iLayer) {
    const OMTFinput::vector1D &layerHits = aInput.getLayerData(iLayer);
    if (layerHits.empty())
      continue;
    for (unsigned int iRefHit = 0; iRefHit < myOmtfConfig->nRefHits(); ++iRefHit) {
      if (!refHitsBits[iRefHit])
        continue;
      const RefHitDef &aRefHitDef = myOmtfConfig->getRefHitsDefs()[iProcessor][iRefHit];
      int phiRef = aInput.getLayerData(myOmtfConfig->getRefToLogicNumber()[aRefHitDef.iRefLayer])[aRefHitDef.iInput];
      unsigned int iRegion = aRefHitDef.iRegion;
      if (myOmtfConfig->getBendingLayers().count(iLayer))
        phiRef = 0;
      const OMTFinput::vector1D restrictedLayerHits = restrictInput(iProcessor, iRegion, iLayer, layerHits);
      for (auto itGP : theGPs) {
        if (itGP.first.theCharge != theCharge)
          continue;
        if (itGP.first.thePtCode != iPt)
          continue;
        itGP.second->addCount(aRefHitDef.iRefLayer, iLayer, phiRef, restrictedLayerHits);
      }
    }
  }
}

void OMTFProcessor::fillInputRange ( unsigned int  iProcessor, unsigned int  iCone, const OMTFinput &  aInput  )

private

Fill map of used inputs. FIXME: using hack from OMTFConfiguration

void OMTFProcessor::fillInputRange ( unsigned int  iProcessor, unsigned int  iCone, unsigned int  iRefLayer, unsigned int  iHit  )

private

const std::map< Key, GoldenPattern * > & OMTFProcessor::getPatterns

(

)

const

Return map of GoldenPatterns.

Definition at line 207 of file OMTFProcessor.cc.

References theGPs.

Referenced by OMTFPatternMaker::beginRun(), OMTFPatternMaker::endJob(), and OMTFPatternMaker::writeMergedGPs().

{ return theGPs; }

const std::vector< OMTFProcessor::resultsMap > & OMTFProcessor::processInput	(	unsigned int	iProcessor,
		const OMTFinput &	aInput
	)

Process input data from a single event Input data is represented by hits in logic layers expressed in local coordinates Vector index: logic region number Map key: GoldenPattern key

Number of reference hits to be checked.

Definition at line 210 of file OMTFProcessor.cc.

References OMTFConfiguration::getBendingLayers(), OMTFinput::getLayerData(), OMTFinput::getRefHits(), OMTFConfiguration::getRefHitsDefs(), OMTFConfiguration::getRefToLogicNumber(), RefHitDef::iInput, RefHitDef::iRefLayer, RefHitDef::iRegion, myOmtfConfig, myResults, OMTFConfiguration::nLayers(), OMTFConfiguration::nRefHits(), OMTFConfiguration::nTestRefHits(), restrictInput(), and theGPs.

Referenced by OMTFReconstruction::getProcessorCandidates().

                                                                                                   {
  for (auto &itRegion : myResults)
    for (auto &itKey : itRegion)
      itKey.second.clear();

  std::bitset<128> refHitsBits = aInput.getRefHits(iProcessor);
  if (refHitsBits.none())
    return myResults;

  for (unsigned int iLayer = 0; iLayer < myOmtfConfig->nLayers(); ++iLayer) {
    const OMTFinput::vector1D &layerHits = aInput.getLayerData(iLayer);
    if (layerHits.empty())
      continue;
    unsigned int nTestedRefHits = myOmtfConfig->nTestRefHits();
    for (unsigned int iRefHit = 0; iRefHit < myOmtfConfig->nRefHits(); ++iRefHit) {
      if (!refHitsBits[iRefHit])
        continue;
      if (nTestedRefHits-- == 0)
        break;
      const RefHitDef &aRefHitDef = myOmtfConfig->getRefHitsDefs()[iProcessor][iRefHit];

      int phiRef = aInput.getLayerData(myOmtfConfig->getRefToLogicNumber()[aRefHitDef.iRefLayer])[aRefHitDef.iInput];
      int etaRef =
          aInput.getLayerData(myOmtfConfig->getRefToLogicNumber()[aRefHitDef.iRefLayer], true)[aRefHitDef.iInput];
      unsigned int iRegion = aRefHitDef.iRegion;

      if (myOmtfConfig->getBendingLayers().count(iLayer))
        phiRef = 0;
      const OMTFinput::vector1D restrictedLayerHits = restrictInput(iProcessor, iRegion, iLayer, layerHits);
      for (auto itGP : theGPs) {
        GoldenPattern::layerResult aLayerResult =
            itGP.second->process1Layer1RefLayer(aRefHitDef.iRefLayer, iLayer, phiRef, restrictedLayerHits);
        int phiRefSt2 = itGP.second->propagateRefPhi(phiRef, etaRef, aRefHitDef.iRefLayer);
        myResults[myOmtfConfig->nTestRefHits() - nTestedRefHits - 1][itGP.second->key()].setRefPhiRHits(
            aRefHitDef.iRefLayer, phiRef);
        myResults[myOmtfConfig->nTestRefHits() - nTestedRefHits - 1][itGP.second->key()].addResult(
            aRefHitDef.iRefLayer, iLayer, aLayerResult.first, phiRefSt2, etaRef);
      }
    }
  }
  for (auto &itRefHit : myResults)
    for (auto &itKey : itRefHit)
      itKey.second.finalise();

  std::ostringstream myStr;
  myStr << "iProcessor: " << iProcessor << std::endl;
  myStr << "Input: ------------" << std::endl;
  myStr << aInput << std::endl;
  edm::LogInfo("OMTF processor") << myStr.str();

  return myResults;
}

void OMTFProcessor::resetConfiguration ( )

private

Reset all configuration parameters.

Definition at line 28 of file OMTFProcessor.cc.

References myResults, and theGPs.

Referenced by configure().

                                       {
  myResults.clear();
  for (auto it : theGPs)
    delete it.second;
  theGPs.clear();
}

OMTFinput::vector1D OMTFProcessor::restrictInput ( unsigned int  iProcessor, unsigned int  iCone, unsigned int  iLayer, const OMTFinput::vector1D &  layerHits  )

private

Remove hits whis are outside input range for given processor and cone

Definition at line 270 of file OMTFProcessor.cc.

References OMTFConfiguration::getConnections(), myOmtfConfig, and OMTFConfiguration::nPhiBins().

Referenced by fillCounts(), and processInput().

                                                                                     {
  OMTFinput::vector1D myHits = layerHits;

  unsigned int iStart = myOmtfConfig->getConnections()[iProcessor][iRegion][iLayer].first;
  unsigned int iEnd = iStart + myOmtfConfig->getConnections()[iProcessor][iRegion][iLayer].second - 1;

  for (unsigned int iInput = 0; iInput < 14; ++iInput) {
    if (iInput < iStart || iInput > iEnd)
      myHits[iInput] = myOmtfConfig->nPhiBins();
  }
  return myHits;
}

void OMTFProcessor::shiftGP ( GoldenPattern *  aGP, const GoldenPattern::vector2D &  meanDistPhiNew, const GoldenPattern::vector2D &  meanDistPhiOld  )

private

Shift pdf indexes by differecne between averaged and original meanDistPhi

Shift pdfs by differecne between original menaDistPhi, and the averaged value

Definition at line 183 of file OMTFProcessor.cc.

References GoldenPattern::getPdf(), myOmtfConfig, OMTFConfiguration::nLayers(), OMTFConfiguration::nPdfAddrBits(), OMTFConfiguration::nRefLayers(), GoldenPattern::pdfValue(), and GoldenPattern::setPdf().

Referenced by averagePatterns().

                                                                         {
  unsigned int nPdfBins = exp2(myOmtfConfig->nPdfAddrBits());
  GoldenPattern::vector3D pdfAllRef = aGP->getPdf();

  int indexShift = 0;
  for (unsigned int iLayer = 0; iLayer < myOmtfConfig->nLayers(); ++iLayer) {
    for (unsigned int iRefLayer = 0; iRefLayer < myOmtfConfig->nRefLayers(); ++iRefLayer) {
      indexShift = meanDistPhiOld[iLayer][iRefLayer] - meanDistPhiNew[iLayer][iRefLayer];
      for (unsigned int iPdfBin = 0; iPdfBin < nPdfBins; ++iPdfBin)
        pdfAllRef[iLayer][iRefLayer][iPdfBin] = 0;
      for (unsigned int iPdfBin = 0; iPdfBin < nPdfBins; ++iPdfBin) {
        if ((int)(iPdfBin) + indexShift >= 0 && iPdfBin + indexShift < nPdfBins)
          pdfAllRef[iLayer][iRefLayer][iPdfBin + indexShift] = aGP->pdfValue(iLayer, iRefLayer, iPdfBin);
      }
    }
  }
  aGP->setPdf(pdfAllRef);
}

Member Data Documentation

const OMTFConfiguration* OMTFProcessor::myOmtfConfig

private

Configuration of the algorithm. This object does not contain the patterns data.

Definition at line 86 of file OMTFProcessor.h.

Referenced by addGP(), averagePatterns(), configure(), fillCounts(), processInput(), restrictInput(), and shiftGP().

std::vector<OMTFProcessor::resultsMap> OMTFProcessor::myResults

private

Map holding results on current event data for each GP. Reference hit number is isued as a vector index.

Definition at line 82 of file OMTFProcessor.h.

Referenced by addGP(), configure(), processInput(), and resetConfiguration().

std::map<Key, GoldenPattern *> OMTFProcessor::theGPs

private

Map holding Golden Patterns.

Definition at line 77 of file OMTFProcessor.h.

Referenced by addGP(), averagePatterns(), fillCounts(), getPatterns(), processInput(), resetConfiguration(), and ~OMTFProcessor().