OMTFProcessor< GoldenPatternType > Class Template Reference

#include <OMTFProcessor.h>

Inheritance diagram for OMTFProcessor< GoldenPatternType >:

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)
std::vector< l1t::RegionalMuonCand >	getFinalcandidates (unsigned int iProcessor, l1t::tftype mtfType, const AlgoMuons &algoCands) override
const std::map< Key, GoldenPattern * > &	getPatterns () const
	Return map of GoldenPatterns. More...
AlgoMuons	ghostBust (AlgoMuons refHitCands, int charge=0) override
	OMTFProcessor ()
	OMTFProcessor (OMTFConfiguration *omtfConfig, const edm::ParameterSet &edmCfg, edm::EventSetup const &evSetup, const L1TMuonOverlapParams *omtfPatterns)
	OMTFProcessor (OMTFConfiguration *omtfConfig, const edm::ParameterSet &edmCfg, edm::EventSetup const &evSetup, GoldenPatternVec< GoldenPatternType > &&gps)
void	printInfo () const override
const std::vector< OMTFProcessor::resultsMap > &	processInput (unsigned int iProcessor, const OMTFinput &aInput)
void	processInput (unsigned int iProcessor, l1t::tftype mtfType, const OMTFinput &aInput) override
	Fill GP vec with patterns from CondFormats object. More...
std::vector< l1t::RegionalMuonCand >	run (unsigned int iProcessor, l1t::tftype mtfType, int bx, OMTFinputMaker *inputMaker, std::vector< std::unique_ptr< IOMTFEmulationObserver > > &observers) override
void	setGhostBuster (IGhostBuster *ghostBuster) override
	allows to use other IGhostBuster implementation than the default one More...
virtual void	setPtAssignment (PtAssignmentBase *ptAssignment)
virtual void	setSorter (SorterBase< GoldenPatternType > *sorter)
	allows to use other sorter implementation than the default one More...
AlgoMuons	sortResults (unsigned int iProcessor, l1t::tftype mtfType, int charge=0) override
	~OMTFProcessor ()
	~OMTFProcessor () override
Public Member Functions inherited from ProcessorBase< GoldenPatternType >
virtual void	addGP (GoldenPatternType *aGP)
	Add GoldenPattern to pattern vec. More...
virtual bool	configure (OMTFConfiguration *omtfParams, const L1TMuonOverlapParams *omtfPatterns)
	Fill GP vec with patterns from CondFormats object. More...
const std::vector< OMTFConfiguration::PatternPt > &	getPatternPtRange () const
virtual GoldenPatternVec< GoldenPatternType > &	getPatterns ()
	Return vector of GoldenPatterns. More...
virtual void	initPatternPtRange (bool firstPatFrom0)
	ProcessorBase (OMTFConfiguration *omtfConfig, const L1TMuonOverlapParams *omtfPatterns)
	ProcessorBase (OMTFConfiguration *omtfConfig, GoldenPatternVec< GoldenPatternType > &&gps)
virtual	~ProcessorBase ()
Public Member Functions inherited from IProcessorEmulator
virtual	~IProcessorEmulator ()

Private Member Functions
bool	addGP (GoldenPattern *aGP)
bool	checkHitPatternValidity (unsigned int hits) override
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)
virtual void	init (const edm::ParameterSet &edmCfg, edm::EventSetup const &evSetup)
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
std::unique_ptr< IGhostBuster >	ghostBuster
const OMTFConfiguration *	myOmtfConfig
std::vector< OMTFProcessor::resultsMap >	myResults
PtAssignmentBase *	ptAssignment = nullptr
std::unique_ptr< SorterBase< GoldenPatternType > >	sorter
std::map< Key, GoldenPattern * >	theGPs
	Map holding Golden Patterns. More...

Additional Inherited Members
Protected Member Functions inherited from ProcessorBase< GoldenPatternType >
virtual MuonStubPtrs1D	restrictInput (unsigned int iProcessor, unsigned int iCone, unsigned int iLayer, const OMTFinput &input)
Protected Attributes inherited from ProcessorBase< GoldenPatternType >
const OMTFConfiguration *	myOmtfConfig
std::vector< OMTFConfiguration::PatternPt >	patternPts
GoldenPatternVec< GoldenPatternType >	theGPs
	vector holding Golden Patterns More...

Detailed Description

template<class GoldenPatternType>
class OMTFProcessor< GoldenPatternType >

Definition at line 19 of file OMTFProcessor.h.

Member Typedef Documentation

resultsMap

template<class GoldenPatternType >

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

Definition at line 21 of file OMTFProcessor.h.

Constructor & Destructor Documentation

OMTFProcessor() [1/3]

template<class GoldenPatternType >

OMTFProcessor< GoldenPatternType >::OMTFProcessor ( )

inline

Definition at line 23 of file OMTFProcessor.h.

{};

~OMTFProcessor() [1/2]

template<class GoldenPatternType >

OMTFProcessor< GoldenPatternType >::~OMTFProcessor

(

)

Definition at line 22 of file OMTFProcessor.cc.

References OMTFProcessor< GoldenPatternType >::theGPs.

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

OMTFProcessor() [2/3]

template<class GoldenPatternType >

OMTFProcessor< GoldenPatternType >::OMTFProcessor	(	OMTFConfiguration *	omtfConfig,
		const edm::ParameterSet &	edmCfg,
		edm::EventSetup const &	evSetup,
		const L1TMuonOverlapParams *	omtfPatterns
	)

Definition at line 31 of file OMTFProcessor.cc.

References OMTFProcessor< GoldenPatternType >::init().

    : ProcessorBase<GoldenPatternType>(omtfConfig, omtfPatterns) {
  init(edmCfg, evSetup);
};

OMTFProcessor() [3/3]

template<class GoldenPatternType >

OMTFProcessor< GoldenPatternType >::OMTFProcessor	(	OMTFConfiguration *	omtfConfig,
		const edm::ParameterSet &	edmCfg,
		edm::EventSetup const &	evSetup,
		GoldenPatternVec< GoldenPatternType > &&	gps
	)

Definition at line 40 of file OMTFProcessor.cc.

References OMTFProcessor< GoldenPatternType >::init().

    : ProcessorBase<GoldenPatternType>(omtfConfig, std::forward<GoldenPatternVec<GoldenPatternType> >(gps)) {
  init(edmCfg, evSetup);
};

~OMTFProcessor() [2/2]

template<class GoldenPatternType >

OMTFProcessor< GoldenPatternType >::~OMTFProcessor ( )

override

Member Function Documentation

addGP()

template<class GoldenPatternType >

bool OMTFProcessor< GoldenPatternType >::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(), OMTFProcessor< GoldenPatternType >::myOmtfConfig, OMTFProcessor< GoldenPatternType >::myResults, and OMTFProcessor< GoldenPatternType >::theGPs.

Referenced by OMTFProcessor< GoldenPatternType >::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;
}

averagePatterns()

template<class GoldenPatternType >

void OMTFProcessor< GoldenPatternType >::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 ALCARECOTkAlJpsiMuMu_cff::charge, GoldenPattern::getMeanDistPhi(), caHitNtupletGeneratorKernels::if(), OMTFProcessor< GoldenPatternType >::myOmtfConfig, OMTFConfiguration::nLayers(), OMTFConfiguration::nRefLayers(), GoldenPattern::setMeanDistPhi(), OMTFProcessor< GoldenPatternType >::shiftGP(), OMTFProcessor< GoldenPatternType >::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);
    }
  }
}

checkHitPatternValidity()

template<class GoldenPatternType >

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

overrideprivatevirtual

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.

Implements IProcessorEmulator.

Definition at line 252 of file OMTFProcessor.cc.

References hfClusterShapes_cfi::hits.

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

  /*
99840 01100001 1000 000000      011000011000000000
34304 00100001 1000 000000      001000011000000000
 3075 00000011 0000 000011      000000110000000011
36928 00100100 0001 000000      001001000001000000
12300 00001100 0000 001100      000011000000001100
98816 01100000 1000 000000      011000001000000000
98944 01100000 1010 000000      011000001010000000
33408 00100000 1010 000000      001000001010000000
66688 01000001 0010 000000      010000010010000000
66176 01000000 1010 000000      010000001010000000
 7171 00000111 0000 000011      000001110000000011
20528 00010100 0000 110000      000101000000110000
33856 00100001 0001 000000      001000010001000000
35840 00100011 0000 000000      001000110000000000
 4156 00000100 0000 111100      000001000000111100
34880 00100010 0001 000000      001000100001000000
   */
  for (auto aHitPattern : badPatterns) {
    if (hits == aHitPattern)
      return false;
  }

  return true;
}

configure()

template<class GoldenPatternType >

bool OMTFProcessor< GoldenPatternType >::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 OMTFProcessor< GoldenPatternType >::addGP(), L1TMuonOverlapParams::chargeLUT(), l1t::LUT::data(), Phase2L1GMT::etaLUT, L1TMuonOverlapParams::etaLUT(), l1tTowerCalibrationProducer_cfi::iEta, createfilelist::int, L1TMuonOverlapParams::meanDistPhiLUT(), OMTFProcessor< GoldenPatternType >::myOmtfConfig, OMTFProcessor< GoldenPatternType >::myResults, OMTFConfiguration::nGoldenPatterns(), OMTFConfiguration::nLayers(), OMTFConfiguration::nPdfAddrBits(), l1t::LUT::nrBitsData(), OMTFConfiguration::nRefLayers(), OMTFConfiguration::nTestRefHits(), L1TMuonOverlapParams::pdfLUT(), Phase2L1GMT::ptLUT, L1TMuonOverlapParams::ptLUT(), OMTFProcessor< GoldenPatternType >::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;
}

fillCounts()

template<class GoldenPatternType >

void OMTFProcessor< GoldenPatternType >::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(), caHitNtupletGeneratorKernels::if(), RefHitDef::iInput, RPCConst::iptFromPt(), RefHitDef::iRefLayer, RefHitDef::iRegion, CoreSimTrack::momentum(), OMTFProcessor< GoldenPatternType >::myOmtfConfig, OMTFConfiguration::nLayers(), OMTFConfiguration::nRefHits(), RPCConst::ptFromIpt(), OMTFProcessor< GoldenPatternType >::restrictInput(), AlignmentTrackSelector_cfi::theCharge, OMTFProcessor< GoldenPatternType >::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);
      }
    }
  }
}

fillInputRange() [1/2]

template<class GoldenPatternType >

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

private

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

fillInputRange() [2/2]

template<class GoldenPatternType >

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

private

getFinalcandidates()

template<class GoldenPatternType >

std::vector< l1t::RegionalMuonCand > OMTFProcessor< GoldenPatternType >::getFinalcandidates ( unsigned int  iProcessor, l1t::tftype  mtfType, const AlgoMuons &  algoCands  )

overridevirtual

Implements IProcessorEmulator.

Definition at line 69 of file OMTFProcessor.cc.

References funct::abs(), l1t::RegionalMuonCand::hwPt(), mps_fire::i, RPCpg::pts, 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().

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

  for (auto& myCand : algoCands) {
    l1t::RegionalMuonCand candidate;
    candidate.setHwPt(myCand->getPt());
    candidate.setHwEta(myCand->getEtaHw());

    int phiValue = myCand->getPhi();
    if (phiValue >= int(this->myOmtfConfig->nPhiBins()))
      phiValue -= this->myOmtfConfig->nPhiBins();
    phiValue = this->myOmtfConfig->procPhiToGmtPhi(phiValue);
    candidate.setHwPhi(phiValue);

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

    unsigned int quality = 12;
    if (this->myOmtfConfig->fwVersion() <= 6)
      quality = checkHitPatternValidity(myCand->getFiredLayerBits()) ? 0 | (1 << 2) | (1 << 3) : 0 | (1 << 2);

    if (abs(myCand->getEtaHw()) == 115 &&
        (static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("100000001110000000").to_ulong() ||
         static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000001110000000").to_ulong() ||
         static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("100000000110000000").to_ulong() ||
         static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("100000001100000000").to_ulong() ||
         static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("100000001010000000").to_ulong())) {
      if (this->myOmtfConfig->fwVersion() <= 6)
        quality = 4;
      else
        quality = 1;
    }

    if (this->myOmtfConfig->fwVersion() >= 5 && this->myOmtfConfig->fwVersion() <= 6) {
      if (static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000010000000011").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000100000000011").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001000000000011").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000010000000000011").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000100000000000011").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001000000000000011").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("010000000000000011").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("100000000000000011").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000010000001100").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000100000001100").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001000000001100").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000010000000001100").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000100000000001100").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001000000000001100").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("010000000000001100").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("100000000000001100").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000010000110000").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000100000110000").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001000000110000").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000010000000110000").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000100000000110000").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001000000000110000").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("010000000000110000").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("100000000000110000").to_ulong())
        quality = 1;
    } else if (this->myOmtfConfig->fwVersion() >= 8) {  //TODO fix the fwVersion
      if (static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000110000000011").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000100000000011").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000010000000011").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000110000000001").to_ulong() ||

          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001000000001100").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000011000000001100").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000010000000001100").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000011000000000100").to_ulong() ||

          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000011000000001").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001000010000000001").to_ulong())
        quality = 1;
      else if (
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000010000000101").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000010001000001").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000011000000001").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000011000000011").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000011100000001").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000100000000011").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000100001000100").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000100100000001").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000110100000001").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000111000000000").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000111000000001").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000111000000011").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001000001000100").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001010000000001").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001010000000011").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001010000000100").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001100000000001").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001100000000100").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001100000000111").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001100001000000").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001110000000100").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001110000000101").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000010000000000101").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000010010000000001").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000010010000000100").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000010010000000101").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000010100000000001").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000010100000000101").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000011110000000100").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000011110000000101").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000101000000010101").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001000010000000001").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001000011000000000").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001000011000000001").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001000100000000001").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001000110000000000").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001001000000000100").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001001100000000100").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001010000000000100").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("010000000010000001").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("010000000011000100").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("010000010000000001").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("010000100000000001").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("100000011000000000").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000110000000001").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000010000000011").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000110000000011").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000011000000001100").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000011000000000100").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000010010000001").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000010000000001100").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001001000001000100").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001100000000101").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000100000000101").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001100000000011").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001110000000111").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001000110001000001").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001110000000011").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001000000001000100").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000110001000001").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001000000000101").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001010000001000000").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001100000001000000").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("100000010000000001").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("010000010010000000").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000010100000001100").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001000110000000011").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001000000001100").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000000000111101").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001100000110001").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000100000000010100").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001000100000000011").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001000110000000001").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("010000100010000001").to_ulong() ||
          static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000100000000110000").to_ulong())
        quality = 8;
    }  //  if (abs(myCand->getEta()) == 121) quality = 4;
    if (abs(myCand->getEtaHw()) == 121)
      quality = 0;  // changed from 4 on request from HI

    candidate.setHwQual(quality);

    std::map<int, int> trackAddr;
    trackAddr[0] = myCand->getFiredLayerBits();
    trackAddr[1] = myCand->getRefLayer();
    trackAddr[2] = myCand->getDisc();
    if (candidate.hwPt() > 0) {
      if (ptAssignment) {
        auto pts = ptAssignment->getPts(myCand);
        for (unsigned int i = 0; i < pts.size(); i++) {
          trackAddr[10 + i] = this->myOmtfConfig->ptGevToHw(pts[i]);
        }
      }

      candidate.setTrackAddress(trackAddr);
      candidate.setTFIdentifiers(iProcessor, mtfType);
      result.push_back(candidate);
    }
  }
  return result;
}

getPatterns()

template<class GoldenPatternType >

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

(

)

const

Return map of GoldenPatterns.

Definition at line 207 of file OMTFProcessor.cc.

References OMTFProcessor< GoldenPatternType >::theGPs.

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

{ return theGPs; }

ghostBust()

template<class GoldenPatternType >

AlgoMuons OMTFProcessor< GoldenPatternType >::ghostBust ( AlgoMuons  refHitCands, int  charge = 0  )

inlineoverridevirtual

Implements IProcessorEmulator.

Definition at line 63 of file OMTFProcessor.h.

References ALCARECOTkAlJpsiMuMu_cff::charge, and OMTFProcessor< GoldenPatternType >::ghostBuster.

                                                                      {
    return ghostBuster->select(refHitCands, charge);
  }

init()

template<class GoldenPatternType >

void OMTFProcessor< GoldenPatternType >::init ( const edm::ParameterSet &  edmCfg, edm::EventSetup const &  evSetup  )

privatevirtual

Definition at line 52 of file OMTFProcessor.cc.

Referenced by OMTFProcessor< GoldenPatternType >::OMTFProcessor().

                                                                                                       {
  setSorter(new OMTFSorter<GoldenPatternType>(this->myOmtfConfig->getSorterType()));
  //initialize with the default sorter

  if (this->myOmtfConfig->getGhostBusterType() == "GhostBusterPreferRefDt" ||
      this->myOmtfConfig->getGhostBusterType() == "byLLH") {
    setGhostBuster(new GhostBusterPreferRefDt(this->myOmtfConfig));
    edm::LogVerbatim("OMTFReconstruction") << "setting " << this->myOmtfConfig->getGhostBusterType() << std::endl;
  } else {
    setGhostBuster(new GhostBuster(this->myOmtfConfig));  //initialize with the default sorter
    edm::LogVerbatim("OMTFReconstruction") << "setting GhostBuster" << std::endl;
  }

  edm::LogVerbatim("OMTFReconstruction") << "fwVersion 0x" << hex << this->myOmtfConfig->fwVersion() << std::endl;
}

printInfo()

template<class GoldenPatternType >

void OMTFProcessor< GoldenPatternType >::printInfo ( ) const

overridevirtual

Implements IProcessorEmulator.

Definition at line 421 of file OMTFProcessor.cc.

References ProcessorBase< GoldenPatternType >::printInfo().

                                                       {
  edm::LogVerbatim("OMTFReconstruction") << __PRETTY_FUNCTION__ << std::endl;

  ProcessorBase<GoldenPatternType>::printInfo();
}

processInput() [1/2]

template<class GoldenPatternType >

const std::vector< OMTFProcessor::resultsMap > & OMTFProcessor< GoldenPatternType >::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(), caHitNtupletGeneratorKernels::if(), RefHitDef::iInput, RefHitDef::iRefLayer, RefHitDef::iRegion, OMTFProcessor< GoldenPatternType >::myOmtfConfig, OMTFProcessor< GoldenPatternType >::myResults, OMTFConfiguration::nLayers(), OMTFConfiguration::nRefHits(), OMTFConfiguration::nTestRefHits(), OMTFProcessor< GoldenPatternType >::restrictInput(), and OMTFProcessor< GoldenPatternType >::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;
}

processInput() [2/2]

template<class GoldenPatternType >

void OMTFProcessor< GoldenPatternType >::processInput ( unsigned int  iProcessor, l1t::tftype  mtfType, const OMTFinput &  aInput  )

overridevirtual

Fill GP vec with patterns from CondFormats object.

Process input data from a single event Input data is represented by hits in logic layers expressed in local coordinates

Number of reference hits to be checked.

Implements IProcessorEmulator.

Definition at line 293 of file OMTFProcessor.cc.

References OMTFinput::getMuonStub(), OMTFinput::getRefHits(), RefHitDef::iInput, RefHitDef::iRefLayer, RefHitDef::iRegion, and mps_fire::result.

                                                                             {
  unsigned int procIndx = this->myOmtfConfig->getProcIndx(iProcessor, mtfType);
  for (auto& itGP : this->theGPs) {
    for (auto& result : itGP->getResults()[procIndx]) {
      result.reset();
    }
  }

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

  for (unsigned int iLayer = 0; iLayer < this->myOmtfConfig->nLayers(); ++iLayer) {
    //debug
    /*for(auto& h : layerHits) {
      if(h != 5400)
        LogTrace("l1tOmtfEventPrint")<<__FUNCTION__<<" "<<__LINE__<<" iLayer "<<iLayer<<" layerHit "<<h<<std::endl;
    }*/
    unsigned int nTestedRefHits = this->myOmtfConfig->nTestRefHits();
    for (unsigned int iRefHit = 0; iRefHit < this->myOmtfConfig->nRefHits();
         ++iRefHit) {  //loop over all possible refHits, i.e. 128
      if (!refHitsBits[iRefHit])
        continue;
      if (nTestedRefHits-- == 0)
        break;

      const RefHitDef& aRefHitDef = this->myOmtfConfig->getRefHitsDefs()[iProcessor][iRefHit];

      unsigned int refLayerLogicNum = this->myOmtfConfig->getRefToLogicNumber()[aRefHitDef.iRefLayer];
      const MuonStubPtr refStub = aInput.getMuonStub(refLayerLogicNum, aRefHitDef.iInput);
      int phiRef = refStub->phiHw;
      int etaRef = refStub->etaHw;

      unsigned int iRegion = aRefHitDef.iRegion;

      if (this->myOmtfConfig->getBendingLayers().count(iLayer))  //this iLayer is a bending layer
        phiRef = 0;  //then in the delta_phi in process1Layer1RefLayer one obtains simply the iLayer phi

      MuonStubPtrs1D restrictedLayerStubs = this->restrictInput(iProcessor, iRegion, iLayer, aInput);

      //LogTrace("l1tOmtfEventPrint")<<__FUNCTION__<<" "<<__LINE__<<" iLayer "<<iLayer<<" iRefLayer "<<aRefHitDef.iRefLayer<<" hits.size "<<restrictedLayerHits.size()<<std::endl;
      //LogTrace("l1tOmtfEventPrint")<<"iLayer "<<iLayer<<" refHitNum "<<myOmtfConfig->nTestRefHits()-nTestedRefHits-1<<" iRefHit "<<iRefHit;
      //LogTrace("l1tOmtfEventPrint")<<" nTestedRefHits "<<nTestedRefHits<<" aRefHitDef "<<aRefHitDef<<std::endl;

      unsigned int refHitNumber = this->myOmtfConfig->nTestRefHits() - nTestedRefHits - 1;
      for (auto& itGP : this->theGPs) {
        if (itGP->key().thePt == 0)  //empty pattern
          continue;

        StubResult stubResult =
            itGP->process1Layer1RefLayer(aRefHitDef.iRefLayer, iLayer, restrictedLayerStubs, refStub);

        //fixme this unnecessary repeated  for every layer - but in this layout of loops must be like that
        int phiRefSt2 = itGP->propagateRefPhi(phiRef, etaRef, aRefHitDef.iRefLayer);

        //LogTrace("l1tOmtfEventPrint")<<__FUNCTION__<<":"<<__LINE__<<" layerResult: valid"<<layerResult.valid<<" pdfVal "<<layerResult.pdfVal<<std::endl;
        itGP->getResults()[procIndx][refHitNumber].setStubResult(iLayer, stubResult);
        //fixme this unnecessary repeated  for every layer - but in this layout of loops must be like that
        itGP->getResults()[procIndx][refHitNumber].set(aRefHitDef.iRefLayer, phiRefSt2, etaRef, phiRef);
      }
    }
  }
  {
    for (auto& itGP : this->theGPs) {
      itGP->finalise(procIndx);
      //debug
      /*for(unsigned int iRefHit = 0; iRefHit < itGP->getResults()[procIndx].size(); ++iRefHit) {
        if(itGP->getResults()[procIndx][iRefHit].isValid()) {
          LogTrace("l1tOmtfEventPrint")<<__FUNCTION__<<":"<<"__LINE__"<<itGP->getResults()[procIndx][iRefHit]<<std::endl;
        }
      }*/
    }
  }

  return;
}

resetConfiguration()

template<class GoldenPatternType >

void OMTFProcessor< GoldenPatternType >::resetConfiguration ( )

privatevirtual

Reset all configuration parameters.

Reimplemented from ProcessorBase< GoldenPatternType >.

Definition at line 28 of file OMTFProcessor.cc.

References OMTFProcessor< GoldenPatternType >::myResults, and OMTFProcessor< GoldenPatternType >::theGPs.

Referenced by OMTFProcessor< GoldenPatternType >::configure().

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

restrictInput()

template<class GoldenPatternType >

OMTFinput::vector1D OMTFProcessor< GoldenPatternType >::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(), OMTFProcessor< GoldenPatternType >::myOmtfConfig, and OMTFConfiguration::nPhiBins().

Referenced by OMTFProcessor< GoldenPatternType >::fillCounts(), and OMTFProcessor< GoldenPatternType >::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;
}

run()

template<class GoldenPatternType >

std::vector< l1t::RegionalMuonCand > OMTFProcessor< GoldenPatternType >::run ( unsigned int  iProcessor, l1t::tftype  mtfType, int  bx, OMTFinputMaker *  inputMaker, std::vector< std::unique_ptr< IOMTFEmulationObserver > > &  observers  )

overridevirtual

Implements IProcessorEmulator.

Definition at line 380 of file OMTFProcessor.cc.

References OMTFinputMaker::buildInputForProcessor(), nano_mu_digi_cff::bx, and input.

                                                                  {
  //uncomment if you want to check execution time of each method
  //boost::timer::auto_cpu_timer t("%ws wall, %us user in getProcessorCandidates\n");

  //input is shared_ptr because the observers may need them after the run() method execution is finished
  std::shared_ptr<OMTFinput> input = std::make_shared<OMTFinput>(this->myOmtfConfig);
  inputMaker->buildInputForProcessor(input->getMuonStubs(), iProcessor, mtfType, bx, bx);

  //LogTrace("l1tOmtfEventPrint")<<"buildInputForProce "; t.report();
  processInput(iProcessor, mtfType, *(input.get()));

  //LogTrace("l1tOmtfEventPrint")<<"processInput       "; t.report();
  AlgoMuons algoCandidates = sortResults(iProcessor, mtfType);

  //LogTrace("l1tOmtfEventPrint")<<"sortResults        "; t.report();
  // perform GB
  AlgoMuons gbCandidates = ghostBust(algoCandidates);

  //LogTrace("l1tOmtfEventPrint")<<"ghostBust"; t.report();
  // fill RegionalMuonCand colleciton
  std::vector<l1t::RegionalMuonCand> candMuons = getFinalcandidates(iProcessor, mtfType, gbCandidates);

  //LogTrace("l1tOmtfEventPrint")<<"getFinalcandidates "; t.report();
  //fill outgoing collection
  for (auto& candMuon : candMuons) {
    candMuon.setHwQual(candMuon.hwQual());
  }

  for (auto& obs : observers) {
    obs->observeProcesorEmulation(iProcessor, mtfType, input, algoCandidates, gbCandidates, candMuons);
  }

  return candMuons;
}

setGhostBuster()

template<class GoldenPatternType >

void OMTFProcessor< GoldenPatternType >::setGhostBuster ( IGhostBuster *  ghostBuster )

inlineoverridevirtual

allows to use other IGhostBuster implementation than the default one

Implements IProcessorEmulator.

Definition at line 76 of file OMTFProcessor.h.

References OMTFProcessor< GoldenPatternType >::ghostBuster.

{ this->ghostBuster.reset(ghostBuster); }

setPtAssignment()

template<class GoldenPatternType >

virtual void OMTFProcessor< GoldenPatternType >::setPtAssignment ( PtAssignmentBase *  ptAssignment )

inlinevirtual

Definition at line 78 of file OMTFProcessor.h.

References OMTFProcessor< GoldenPatternType >::ptAssignment.

{ this->ptAssignment = ptAssignment; }

setSorter()

template<class GoldenPatternType >

virtual void OMTFProcessor< GoldenPatternType >::setSorter ( SorterBase< GoldenPatternType > *  sorter )

inlinevirtual

allows to use other sorter implementation than the default one

Definition at line 73 of file OMTFProcessor.h.

{ this->sorter.reset(sorter); }

shiftGP()

template<class GoldenPatternType >

void OMTFProcessor< GoldenPatternType >::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(), OMTFProcessor< GoldenPatternType >::myOmtfConfig, OMTFConfiguration::nLayers(), OMTFConfiguration::nPdfAddrBits(), OMTFConfiguration::nRefLayers(), GoldenPattern::pdfValue(), and GoldenPattern::setPdf().

Referenced by OMTFProcessor< GoldenPatternType >::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);
}

sortResults()

template<class GoldenPatternType >

AlgoMuons OMTFProcessor< GoldenPatternType >::sortResults ( unsigned int  iProcessor, l1t::tftype  mtfType, int  charge = 0  )

overridevirtual

Implements IProcessorEmulator.

Definition at line 285 of file OMTFProcessor.cc.

References ALCARECOTkAlJpsiMuMu_cff::charge.

                                                                                                              {
  unsigned int procIndx = this->myOmtfConfig->getProcIndx(iProcessor, mtfType);
  return sorter->sortResults(procIndx, this->getPatterns(), charge);
}

Member Data Documentation

ghostBuster

template<class GoldenPatternType >

std::unique_ptr<IGhostBuster> OMTFProcessor< GoldenPatternType >::ghostBuster

private

Definition at line 101 of file OMTFProcessor.h.

Referenced by OMTFProcessor< GoldenPatternType >::ghostBust(), and OMTFProcessor< GoldenPatternType >::setGhostBuster().

myOmtfConfig

template<class GoldenPatternType >

const OMTFConfiguration* OMTFProcessor< GoldenPatternType >::myOmtfConfig

private

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

Definition at line 86 of file OMTFProcessor.h.

Referenced by OMTFProcessor< GoldenPatternType >::addGP(), OMTFProcessor< GoldenPatternType >::averagePatterns(), OMTFProcessor< GoldenPatternType >::configure(), OMTFProcessor< GoldenPatternType >::fillCounts(), OMTFProcessor< GoldenPatternType >::processInput(), OMTFProcessor< GoldenPatternType >::restrictInput(), and OMTFProcessor< GoldenPatternType >::shiftGP().

myResults

template<class GoldenPatternType >

std::vector<OMTFProcessor::resultsMap> OMTFProcessor< GoldenPatternType >::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 OMTFProcessor< GoldenPatternType >::addGP(), OMTFProcessor< GoldenPatternType >::configure(), OMTFProcessor< GoldenPatternType >::processInput(), and OMTFProcessor< GoldenPatternType >::resetConfiguration().

ptAssignment

template<class GoldenPatternType >

PtAssignmentBase* OMTFProcessor< GoldenPatternType >::ptAssignment = nullptr

private

Definition at line 104 of file OMTFProcessor.h.

Referenced by OMTFProcessor< GoldenPatternType >::setPtAssignment().

sorter

template<class GoldenPatternType >

std::unique_ptr<SorterBase<GoldenPatternType> > OMTFProcessor< GoldenPatternType >::sorter

private

Definition at line 99 of file OMTFProcessor.h.

theGPs

template<class GoldenPatternType >

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

private

Map holding Golden Patterns.

Definition at line 77 of file OMTFProcessor.h.

Referenced by OMTFProcessor< GoldenPatternType >::addGP(), OMTFProcessor< GoldenPatternType >::averagePatterns(), OMTFProcessor< GoldenPatternType >::fillCounts(), OMTFProcessor< GoldenPatternType >::getPatterns(), OMTFProcessor< GoldenPatternType >::processInput(), OMTFProcessor< GoldenPatternType >::resetConfiguration(), and OMTFProcessor< GoldenPatternType >::~OMTFProcessor().