CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
List of all members | Public Types | Public Member Functions | Private Member Functions | Private Attributes
OMTFProcessor< GoldenPatternType > Class Template Reference

#include <OMTFProcessor.h>

Inheritance diagram for OMTFProcessor< GoldenPatternType >:
ProcessorBase< GoldenPatternType > IProcessorEmulator

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

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

Definition at line 21 of file OMTFProcessor.h.

Constructor & Destructor Documentation

template<class GoldenPatternType >
OMTFProcessor< GoldenPatternType >::OMTFProcessor ( )
inline

Definition at line 23 of file OMTFProcessor.h.

23 {};
template<class GoldenPatternType >
OMTFProcessor< GoldenPatternType >::~OMTFProcessor ( )

Definition at line 22 of file OMTFProcessor.cc.

References OMTFProcessor< GoldenPatternType >::theGPs.

22  {
23  for (auto it : theGPs)
24  delete it.second;
25 }
OMTFProcessor::theGPs
std::map< Key, GoldenPattern * > theGPs
Map holding Golden Patterns.
Definition: OMTFProcessor.h:77
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().

35  : ProcessorBase<GoldenPatternType>(omtfConfig, omtfPatterns) {
36  init(edmCfg, evSetup);
37 };
omtfConfig
omtfConfig(omtfConfig)
Definition: GoldenPatternResult.cc:17
OMTFProcessor::init
virtual void init(const edm::ParameterSet &edmCfg, edm::EventSetup const &evSetup)
Definition: OMTFProcessor.cc:52
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().

44  : ProcessorBase<GoldenPatternType>(omtfConfig, std::forward<GoldenPatternVec<GoldenPatternType> >(gps)) {
45  init(edmCfg, evSetup);
46 };
omtfConfig
omtfConfig(omtfConfig)
Definition: GoldenPatternResult.cc:17
OMTFProcessor::init
virtual void init(const edm::ParameterSet &edmCfg, edm::EventSetup const &evSetup)
Definition: OMTFProcessor.cc:52
template<class GoldenPatternType >
OMTFProcessor< GoldenPatternType >::~OMTFProcessor ( )
override

Member Function Documentation

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().

96  {
97  if (theGPs.find(aGP->key()) != theGPs.end()) {
98  throw cms::Exception("Corrupted Golden Patterns data")
99  << "OMTFProcessor::addGP(...) "
100  << " Reading two Golden Patterns with the same key: " << aGP->key() << std::endl;
101  } else
102  theGPs[aGP->key()] = aGP;
103 
104  for (auto &itRegion : myResults) {
105  OMTFResult aResult;
106  aResult.configure(myOmtfConfig);
107  itRegion[aGP->key()] = aResult;
108  }
109 
110  return true;
111 }
GoldenPattern::key
Key key() const
Definition: GoldenPattern.h:56
OMTFProcessor::myResults
std::vector< OMTFProcessor::resultsMap > myResults
Definition: OMTFProcessor.h:82
OMTFProcessor::theGPs
std::map< Key, GoldenPattern * > theGPs
Map holding Golden Patterns.
Definition: OMTFProcessor.h:77
OMTFResult::configure
void configure(const OMTFConfiguration *omtfConfig)
Definition: OMTFResult.cc:10
OMTFProcessor::myOmtfConfig
const OMTFConfiguration * myOmtfConfig
Definition: OMTFProcessor.h:86
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 GoldenPattern::getMeanDistPhi(), if(), OMTFProcessor< GoldenPatternType >::myOmtfConfig, OMTFConfiguration::nLayers(), OMTFConfiguration::nRefLayers(), GoldenPattern::setMeanDistPhi(), OMTFProcessor< GoldenPatternType >::shiftGP(), OMTFProcessor< GoldenPatternType >::theGPs, and Key::thePtCode.

Referenced by OMTFPatternMaker::endJob().

114  {
115  Key aKey(0, 9, charge);
116 
117  while (theGPs.find(aKey) != theGPs.end()) {
118  GoldenPattern *aGP1 = theGPs.find(aKey)->second;
119  GoldenPattern *aGP2 = aGP1;
120  GoldenPattern *aGP3 = aGP1;
121  GoldenPattern *aGP4 = aGP1;
122 
123  ++aKey.thePtCode;
124  while (theGPs.find(aKey) == theGPs.end() && aKey.thePtCode <= 401)
125  ++aKey.thePtCode;
126  if (aKey.thePtCode <= 401 && theGPs.find(aKey) != theGPs.end())
127  aGP2 = theGPs.find(aKey)->second;
128 
129  if (aKey.thePtCode > 71) {
130  ++aKey.thePtCode;
131  while (theGPs.find(aKey) == theGPs.end() && aKey.thePtCode <= 401)
132  ++aKey.thePtCode;
133  if (aKey.thePtCode <= 401 && theGPs.find(aKey) != theGPs.end())
134  aGP3 = theGPs.find(aKey)->second;
135 
136  ++aKey.thePtCode;
137  while (theGPs.find(aKey) == theGPs.end() && aKey.thePtCode <= 401)
138  ++aKey.thePtCode;
139  if (aKey.thePtCode <= 401 && theGPs.find(aKey) != theGPs.end())
140  aGP4 = theGPs.find(aKey)->second;
141  } else {
142  aGP3 = aGP1;
143  aGP4 = aGP2;
144  }
145  //HACK. Have to clean this up.
147  ++aKey.thePtCode;
148  while (theGPs.find(aKey) == theGPs.end() && aKey.thePtCode <= 401)
149  ++aKey.thePtCode;
151 
152  GoldenPattern::vector2D meanDistPhi = aGP1->getMeanDistPhi();
153 
154  GoldenPattern::vector2D meanDistPhi1 = aGP1->getMeanDistPhi();
155  GoldenPattern::vector2D meanDistPhi2 = aGP2->getMeanDistPhi();
156  GoldenPattern::vector2D meanDistPhi3 = aGP3->getMeanDistPhi();
157  GoldenPattern::vector2D meanDistPhi4 = aGP4->getMeanDistPhi();
158 
159  for (unsigned int iLayer = 0; iLayer < myOmtfConfig->nLayers(); ++iLayer) {
160  for (unsigned int iRefLayer = 0; iRefLayer < myOmtfConfig->nRefLayers(); ++iRefLayer) {
161  meanDistPhi[iLayer][iRefLayer] += meanDistPhi2[iLayer][iRefLayer];
162  meanDistPhi[iLayer][iRefLayer] += meanDistPhi3[iLayer][iRefLayer];
163  meanDistPhi[iLayer][iRefLayer] += meanDistPhi4[iLayer][iRefLayer];
164  meanDistPhi[iLayer][iRefLayer] /= 4;
165  }
166  }
167 
168  aGP1->setMeanDistPhi(meanDistPhi);
169  aGP2->setMeanDistPhi(meanDistPhi);
170 
171  shiftGP(aGP1, meanDistPhi, meanDistPhi1);
172  shiftGP(aGP2, meanDistPhi, meanDistPhi2);
173  if (aGP3 != aGP1 && aGP4 != aGP2) {
174  aGP3->setMeanDistPhi(meanDistPhi);
175  aGP4->setMeanDistPhi(meanDistPhi);
176  shiftGP(aGP3, meanDistPhi, meanDistPhi3);
177  shiftGP(aGP4, meanDistPhi, meanDistPhi4);
178  }
179  }
180 }
OMTFConfiguration::nRefLayers
unsigned int nRefLayers() const
Definition: OMTFConfiguration.h:89
GoldenPattern::getMeanDistPhi
const vector2D & getMeanDistPhi() const
Definition: GoldenPattern.h:60
OMTFConfiguration::nLayers
unsigned int nLayers() const
Definition: OMTFConfiguration.h:87
OMTFProcessor::theGPs
std::map< Key, GoldenPattern * > theGPs
Map holding Golden Patterns.
Definition: OMTFProcessor.h:77
GoldenPattern::vector2D
std::vector< vector1D > vector2D
Definition: GoldenPattern.h:47
if
if(conf_.getParameter< bool >("UseStripCablingDB"))
Definition: SiStripLAProfileBooker.cc:72
OMTFProcessor::shiftGP
void shiftGP(GoldenPattern *aGP, const GoldenPattern::vector2D &meanDistPhiNew, const GoldenPattern::vector2D &meanDistPhiOld)
Definition: OMTFProcessor.cc:183
OMTFProcessor::myOmtfConfig
const OMTFConfiguration * myOmtfConfig
Definition: OMTFProcessor.h:86
GoldenPattern::setMeanDistPhi
void setMeanDistPhi(const vector2D &aMeanDistPhi)
Definition: GoldenPattern.h:58
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.

252  {
254  std::vector<unsigned int> badPatterns = {
255  99840, 34304, 3075, 36928, 12300, 98816, 98944, 33408, 66688, 66176, 7171, 20528, 33856, 35840, 4156, 34880};
256 
257  /*
258 99840 01100001 1000 000000 011000011000000000
259 34304 00100001 1000 000000 001000011000000000
260  3075 00000011 0000 000011 000000110000000011
261 36928 00100100 0001 000000 001001000001000000
262 12300 00001100 0000 001100 000011000000001100
263 98816 01100000 1000 000000 011000001000000000
264 98944 01100000 1010 000000 011000001010000000
265 33408 00100000 1010 000000 001000001010000000
266 66688 01000001 0010 000000 010000010010000000
267 66176 01000000 1010 000000 010000001010000000
268  7171 00000111 0000 000011 000001110000000011
269 20528 00010100 0000 110000 000101000000110000
270 33856 00100001 0001 000000 001000010001000000
271 35840 00100011 0000 000000 001000110000000000
272  4156 00000100 0000 111100 000001000000111100
273 34880 00100010 0001 000000 001000100001000000
274  */
275  for (auto aHitPattern : badPatterns) {
276  if (hits == aHitPattern)
277  return false;
278  }
279 
280  return true;
281 }
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(), L1TMuonOverlapParams::etaLUT(), L1TMuonOverlapParams::meanDistPhiLUT(), OMTFProcessor< GoldenPatternType >::myOmtfConfig, OMTFProcessor< GoldenPatternType >::myResults, OMTFConfiguration::nGoldenPatterns(), OMTFConfiguration::nLayers(), OMTFConfiguration::nPdfAddrBits(), l1t::LUT::nrBitsData(), OMTFConfiguration::nRefLayers(), OMTFConfiguration::nTestRefHits(), omtfConfig(), L1TMuonOverlapParams::pdfLUT(), L1TMuonOverlapParams::ptLUT(), OMTFProcessor< GoldenPatternType >::resetConfiguration(), GoldenPattern::setMeanDistPhi(), and GoldenPattern::setPdf().

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

36  {
37  resetConfiguration();
38 
39  myOmtfConfig = omtfConfig;
40 
41  myResults.assign(myOmtfConfig->nTestRefHits(), OMTFProcessor::resultsMap());
42 
43  const l1t::LUT *chargeLUT = omtfPatterns->chargeLUT();
44  const l1t::LUT *etaLUT = omtfPatterns->etaLUT();
45  const l1t::LUT *ptLUT = omtfPatterns->ptLUT();
46  const l1t::LUT *pdfLUT = omtfPatterns->pdfLUT();
47  const l1t::LUT *meanDistPhiLUT = omtfPatterns->meanDistPhiLUT();
48 
49  unsigned int nGPs = myOmtfConfig->nGoldenPatterns();
50  unsigned int address = 0;
51  unsigned int iEta, iPt;
52  int iCharge;
53  for (unsigned int iGP = 0; iGP < nGPs; ++iGP) {
54  address = iGP;
55  iEta = etaLUT->data(address);
56  iCharge = chargeLUT->data(address) == 0 ? -1 : 1;
57  iPt = ptLUT->data(address);
58 
59  GoldenPattern::vector2D meanDistPhi2D(myOmtfConfig->nLayers());
60  GoldenPattern::vector1D pdf1D(exp2(myOmtfConfig->nPdfAddrBits()));
61  GoldenPattern::vector3D pdf3D(myOmtfConfig->nLayers());
62  GoldenPattern::vector2D pdf2D(myOmtfConfig->nRefLayers());
64  for (unsigned int iLayer = 0; iLayer < myOmtfConfig->nLayers(); ++iLayer) {
65  GoldenPattern::vector1D meanDistPhi1D(myOmtfConfig->nRefLayers());
66  for (unsigned int iRefLayer = 0; iRefLayer < myOmtfConfig->nRefLayers(); ++iRefLayer) {
67  address = iRefLayer + iLayer * myOmtfConfig->nRefLayers() +
68  iGP * (myOmtfConfig->nRefLayers() * myOmtfConfig->nLayers());
69  meanDistPhi1D[iRefLayer] = meanDistPhiLUT->data(address) - (1 << (meanDistPhiLUT->nrBitsData() - 1));
70  }
71  meanDistPhi2D[iLayer] = meanDistPhi1D;
73  for (unsigned int iRefLayer = 0; iRefLayer < myOmtfConfig->nRefLayers(); ++iRefLayer) {
74  pdf1D.assign(1 << myOmtfConfig->nPdfAddrBits(), 0);
75  for (unsigned int iPdf = 0; iPdf < (unsigned int)(1 << myOmtfConfig->nPdfAddrBits()); ++iPdf) {
76  address = iPdf + iRefLayer * (1 << myOmtfConfig->nPdfAddrBits()) +
77  iLayer * myOmtfConfig->nRefLayers() * (1 << myOmtfConfig->nPdfAddrBits()) +
78  iGP * myOmtfConfig->nLayers() * myOmtfConfig->nRefLayers() * (1 << myOmtfConfig->nPdfAddrBits());
79  pdf1D[iPdf] = pdfLUT->data(address);
80  }
81  pdf2D[iRefLayer] = pdf1D;
82  }
83  pdf3D[iLayer] = pdf2D;
84  }
85  Key aKey(iEta, iPt, iCharge, iGP);
86 
87  GoldenPattern *aGP = new GoldenPattern(aKey, myOmtfConfig);
88  aGP->setMeanDistPhi(meanDistPhi2D);
89  aGP->setPdf(pdf3D);
90  addGP(aGP);
91  }
92  return true;
93 }
OMTFProcessor::myResults
std::vector< OMTFProcessor::resultsMap > myResults
Definition: OMTFProcessor.h:82
OMTFConfiguration::nRefLayers
unsigned int nRefLayers() const
Definition: OMTFConfiguration.h:89
GoldenPattern::vector1D
std::vector< int > vector1D
Definition: GoldenPattern.h:46
OMTFProcessor::addGP
bool addGP(GoldenPattern *aGP)
Definition: OMTFProcessor.cc:96
OMTFConfiguration::nLayers
unsigned int nLayers() const
Definition: OMTFConfiguration.h:87
omtfConfig
omtfConfig(omtfConfig)
Definition: GoldenPatternResult.cc:17
OMTFProcessor::resultsMap
std::map< Key, OMTFResult > resultsMap
Definition: OMTFProcessor.h:21
L1TMuonOverlapParams::chargeLUT
const l1t::LUT * chargeLUT() const
Golden Patterns definitions.
Definition: L1TMuonOverlapParams.h:203
l1t::LUT::nrBitsData
unsigned int nrBitsData() const
Definition: LUT.h:53
GoldenPattern::vector2D
std::vector< vector1D > vector2D
Definition: GoldenPattern.h:47
GoldenPattern::vector3D
std::vector< vector2D > vector3D
Definition: GoldenPattern.h:48
GoldenPattern::setPdf
void setPdf(const vector3D &aPdf)
Definition: GoldenPattern.h:64
OMTFConfiguration::nPdfAddrBits
unsigned int nPdfAddrBits() const
Definition: OMTFConfiguration.h:91
L1TMuonOverlapParams::etaLUT
const l1t::LUT * etaLUT() const
Definition: L1TMuonOverlapParams.h:204
OMTFConfiguration::nGoldenPatterns
unsigned int nGoldenPatterns() const
Definition: OMTFConfiguration.h:99
L1TMuonOverlapParams::pdfLUT
const l1t::LUT * pdfLUT() const
Definition: L1TMuonOverlapParams.h:206
l1t::LUT
Definition: LUT.h:29
L1TMuonOverlapParams::ptLUT
const l1t::LUT * ptLUT() const
Definition: L1TMuonOverlapParams.h:205
OMTFProcessor::myOmtfConfig
const OMTFConfiguration * myOmtfConfig
Definition: OMTFProcessor.h:86
OMTFProcessor::resetConfiguration
void resetConfiguration()
Reset all configuration parameters.
Definition: OMTFProcessor.cc:28
GoldenPattern::setMeanDistPhi
void setMeanDistPhi(const vector2D &aMeanDistPhi)
Definition: GoldenPattern.h:58
l1t::LUT::data
int data(unsigned int address) const
Definition: LUT.h:46
L1TMuonOverlapParams::meanDistPhiLUT
const l1t::LUT * meanDistPhiLUT() const
Definition: L1TMuonOverlapParams.h:207
OMTFConfiguration::nTestRefHits
unsigned int nTestRefHits() const
Definition: OMTFConfiguration.h:95
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(), if(), RefHitDef::iInput, RPCConst::iptFromPt(), RefHitDef::iRefLayer, RefHitDef::iRegion, CoreSimTrack::momentum(), OMTFProcessor< GoldenPatternType >::myOmtfConfig, OMTFConfiguration::nLayers(), OMTFConfiguration::nRefHits(), RPCConst::ptFromIpt(), OMTFProcessor< GoldenPatternType >::restrictInput(), OMTFProcessor< GoldenPatternType >::theGPs, and CoreSimTrack::type().

Referenced by OMTFPatternMaker::analyze().

287  {
288  int theCharge = (abs(aSimMuon->type()) == 13) ? aSimMuon->type() / -13 : 0;
289  unsigned int iPt = RPCConst::iptFromPt(aSimMuon->momentum().pt());
292  iPt += 1;
293  if (iPt > 31)
294  iPt = 200 * 2 + 1;
295  else
296  iPt = RPCConst::ptFromIpt(iPt) * 2.0 +
297  1; //MicroGMT has 0.5 GeV step size, with lower bin edge (uGMT_pt_code - 1)*step_size
299 
301  std::bitset<128> refHitsBits = aInput.getRefHits(iProcessor);
302  if (refHitsBits.none())
303  return;
304 
305  std::ostringstream myStr;
306  myStr << "iProcessor: " << iProcessor << std::endl;
307  myStr << "Input: ------------" << std::endl;
308  myStr << aInput << std::endl;
309  edm::LogInfo("OMTF processor") << myStr.str();
310 
311  for (unsigned int iLayer = 0; iLayer < myOmtfConfig->nLayers(); ++iLayer) {
312  const OMTFinput::vector1D &layerHits = aInput.getLayerData(iLayer);
313  if (layerHits.empty())
314  continue;
316  for (unsigned int iRefHit = 0; iRefHit < myOmtfConfig->nRefHits(); ++iRefHit) {
317  if (!refHitsBits[iRefHit])
318  continue;
319  const RefHitDef &aRefHitDef = myOmtfConfig->getRefHitsDefs()[iProcessor][iRefHit];
320  int phiRef = aInput.getLayerData(myOmtfConfig->getRefToLogicNumber()[aRefHitDef.iRefLayer])[aRefHitDef.iInput];
321  unsigned int iRegion = aRefHitDef.iRegion;
322  if (myOmtfConfig->getBendingLayers().count(iLayer))
323  phiRef = 0;
324  const OMTFinput::vector1D restrictedLayerHits = restrictInput(iProcessor, iRegion, iLayer, layerHits);
325  for (auto itGP : theGPs) {
326  if (itGP.first.theCharge != theCharge)
327  continue;
328  if (itGP.first.thePtCode != iPt)
329  continue;
330  itGP.second->addCount(aRefHitDef.iRefLayer, iLayer, phiRef, restrictedLayerHits);
331  }
332  }
333  }
334 }
OMTFConfiguration::getBendingLayers
const std::set< int > & getBendingLayers() const
Definition: OMTFConfiguration.h:104
OMTFConfiguration::nRefHits
unsigned int nRefHits() const
Definition: OMTFConfiguration.h:94
OMTFConfiguration::nLayers
unsigned int nLayers() const
Definition: OMTFConfiguration.h:87
RefHitDef::iInput
unsigned int iInput
Hit input number within a cone.
Definition: OMTFConfiguration.h:29
OMTFinput::vector1D
std::vector< int > vector1D
Definition: OMTFinput.h:13
OMTFinput::getLayerData
const OMTFinput::vector1D & getLayerData(unsigned int iLayer, bool giveEta=false) const
Definition: OMTFinput.cc:17
OMTFProcessor::theGPs
std::map< Key, GoldenPattern * > theGPs
Map holding Golden Patterns.
Definition: OMTFProcessor.h:77
OMTFConfiguration::getRefHitsDefs
const std::vector< std::vector< RefHitDef > > & getRefHitsDefs() const
Definition: OMTFConfiguration.h:118
if
if(conf_.getParameter< bool >("UseStripCablingDB"))
Definition: SiStripLAProfileBooker.cc:72
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
OMTFinput::getRefHits
std::bitset< 128 > getRefHits(unsigned int iProcessor) const
Definition: OMTFinput.cc:26
OMTFProcessor::restrictInput
OMTFinput::vector1D restrictInput(unsigned int iProcessor, unsigned int iCone, unsigned int iLayer, const OMTFinput::vector1D &layerHits)
Definition: OMTFProcessor.cc:270
RPCConst::ptFromIpt
static double ptFromIpt(const int ipt)
Definition: RPCConst.cc:29
edm::LogInfo
Log< level::Info, false > LogInfo
Definition: MessageLogger.h:125
OMTFConfiguration::getRefToLogicNumber
const std::vector< int > & getRefToLogicNumber() const
Definition: OMTFConfiguration.h:105
CoreSimTrack::type
int type() const
particle type (HEP PDT convension)
Definition: CoreSimTrack.h:22
OMTFProcessor::myOmtfConfig
const OMTFConfiguration * myOmtfConfig
Definition: OMTFProcessor.h:86
CoreSimTrack::momentum
const math::XYZTLorentzVectorD & momentum() const
Definition: CoreSimTrack.h:19
RefHitDef::iRefLayer
unsigned int iRefLayer
Reference layer logic number (0-7)
Definition: OMTFConfiguration.h:35
RefHitDef::iRegion
unsigned int iRegion
Region number assigned to this referecne hit.
Definition: OMTFConfiguration.h:32
RPCConst::iptFromPt
static int iptFromPt(const double pt)
Definition: RPCConst.cc:10
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

template<class GoldenPatternType >
void OMTFProcessor< GoldenPatternType >::fillInputRange ( unsigned int  iProcessor,
unsigned int  iCone,
unsigned int  iRefLayer,
unsigned int  iHit 
)
private
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().

71  {
72  std::vector<l1t::RegionalMuonCand> result;
73 
74  for (auto& myCand : algoCands) {
75  l1t::RegionalMuonCand candidate;
76  candidate.setHwPt(myCand->getPt());
77  candidate.setHwEta(myCand->getEtaHw());
78 
79  int phiValue = myCand->getPhi();
80  if (phiValue >= int(this->myOmtfConfig->nPhiBins()))
81  phiValue -= this->myOmtfConfig->nPhiBins();
82  phiValue = this->myOmtfConfig->procPhiToGmtPhi(phiValue);
83  candidate.setHwPhi(phiValue);
84 
85  candidate.setHwSign(myCand->getCharge() < 0 ? 1 : 0);
86  candidate.setHwSignValid(1);
87 
88  unsigned int quality = 12;
89  if (this->myOmtfConfig->fwVersion() <= 6)
90  quality = checkHitPatternValidity(myCand->getFiredLayerBits()) ? 0 | (1 << 2) | (1 << 3) : 0 | (1 << 2);
91 
92  if (abs(myCand->getEtaHw()) == 115 &&
93  (static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("100000001110000000").to_ulong() ||
94  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000001110000000").to_ulong() ||
95  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("100000000110000000").to_ulong() ||
96  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("100000001100000000").to_ulong() ||
97  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("100000001010000000").to_ulong())) {
98  if (this->myOmtfConfig->fwVersion() <= 6)
99  quality = 4;
100  else
101  quality = 1;
102  }
103 
104  if (this->myOmtfConfig->fwVersion() >= 5 && this->myOmtfConfig->fwVersion() <= 6) {
105  if (static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000010000000011").to_ulong() ||
106  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000100000000011").to_ulong() ||
107  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001000000000011").to_ulong() ||
108  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000010000000000011").to_ulong() ||
109  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000100000000000011").to_ulong() ||
110  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001000000000000011").to_ulong() ||
111  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("010000000000000011").to_ulong() ||
112  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("100000000000000011").to_ulong() ||
113  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000010000001100").to_ulong() ||
114  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000100000001100").to_ulong() ||
115  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001000000001100").to_ulong() ||
116  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000010000000001100").to_ulong() ||
117  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000100000000001100").to_ulong() ||
118  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001000000000001100").to_ulong() ||
119  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("010000000000001100").to_ulong() ||
120  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("100000000000001100").to_ulong() ||
121  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000010000110000").to_ulong() ||
122  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000100000110000").to_ulong() ||
123  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001000000110000").to_ulong() ||
124  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000010000000110000").to_ulong() ||
125  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000100000000110000").to_ulong() ||
126  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001000000000110000").to_ulong() ||
127  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("010000000000110000").to_ulong() ||
128  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("100000000000110000").to_ulong())
129  quality = 1;
130  } else if (this->myOmtfConfig->fwVersion() >= 8) { //TODO fix the fwVersion
131  if (static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000110000000011").to_ulong() ||
132  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000100000000011").to_ulong() ||
133  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000010000000011").to_ulong() ||
134  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000110000000001").to_ulong() ||
135 
136  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001000000001100").to_ulong() ||
137  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000011000000001100").to_ulong() ||
138  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000010000000001100").to_ulong() ||
139  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000011000000000100").to_ulong() ||
140 
141  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000011000000001").to_ulong() ||
142  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001000010000000001").to_ulong())
143  quality = 1;
144  else if (
145  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000010000000101").to_ulong() ||
146  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000010001000001").to_ulong() ||
147  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000011000000001").to_ulong() ||
148  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000011000000011").to_ulong() ||
149  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000011100000001").to_ulong() ||
150  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000100000000011").to_ulong() ||
151  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000100001000100").to_ulong() ||
152  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000100100000001").to_ulong() ||
153  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000110100000001").to_ulong() ||
154  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000111000000000").to_ulong() ||
155  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000111000000001").to_ulong() ||
156  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000111000000011").to_ulong() ||
157  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001000001000100").to_ulong() ||
158  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001010000000001").to_ulong() ||
159  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001010000000011").to_ulong() ||
160  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001010000000100").to_ulong() ||
161  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001100000000001").to_ulong() ||
162  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001100000000100").to_ulong() ||
163  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001100000000111").to_ulong() ||
164  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001100001000000").to_ulong() ||
165  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001110000000100").to_ulong() ||
166  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001110000000101").to_ulong() ||
167  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000010000000000101").to_ulong() ||
168  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000010010000000001").to_ulong() ||
169  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000010010000000100").to_ulong() ||
170  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000010010000000101").to_ulong() ||
171  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000010100000000001").to_ulong() ||
172  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000010100000000101").to_ulong() ||
173  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000011110000000100").to_ulong() ||
174  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000011110000000101").to_ulong() ||
175  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000101000000010101").to_ulong() ||
176  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001000010000000001").to_ulong() ||
177  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001000011000000000").to_ulong() ||
178  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001000011000000001").to_ulong() ||
179  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001000100000000001").to_ulong() ||
180  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001000110000000000").to_ulong() ||
181  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001001000000000100").to_ulong() ||
182  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001001100000000100").to_ulong() ||
183  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001010000000000100").to_ulong() ||
184  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("010000000010000001").to_ulong() ||
185  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("010000000011000100").to_ulong() ||
186  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("010000010000000001").to_ulong() ||
187  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("010000100000000001").to_ulong() ||
188  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("100000011000000000").to_ulong() ||
189  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000110000000001").to_ulong() ||
190  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000010000000011").to_ulong() ||
191  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000110000000011").to_ulong() ||
192  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000011000000001100").to_ulong() ||
193  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000011000000000100").to_ulong() ||
194  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000010010000001").to_ulong() ||
195  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000010000000001100").to_ulong() ||
196  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001001000001000100").to_ulong() ||
197  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001100000000101").to_ulong() ||
198  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000100000000101").to_ulong() ||
199  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001100000000011").to_ulong() ||
200  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001110000000111").to_ulong() ||
201  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001000110001000001").to_ulong() ||
202  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001110000000011").to_ulong() ||
203  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001000000001000100").to_ulong() ||
204  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000110001000001").to_ulong() ||
205  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001000000000101").to_ulong() ||
206  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001010000001000000").to_ulong() ||
207  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001100000001000000").to_ulong() ||
208  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("100000010000000001").to_ulong() ||
209  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("010000010010000000").to_ulong() ||
210  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000010100000001100").to_ulong() ||
211  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001000110000000011").to_ulong() ||
212  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001000000001100").to_ulong() ||
213  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000000000000111101").to_ulong() ||
214  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000001100000110001").to_ulong() ||
215  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000100000000010100").to_ulong() ||
216  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001000100000000011").to_ulong() ||
217  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("001000110000000001").to_ulong() ||
218  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("010000100010000001").to_ulong() ||
219  static_cast<unsigned int>(myCand->getFiredLayerBits()) == std::bitset<18>("000100000000110000").to_ulong())
220  quality = 8;
221  } // if (abs(myCand->getEta()) == 121) quality = 4;
222  if (abs(myCand->getEtaHw()) == 121)
223  quality = 0; // changed from 4 on request from HI
224 
225  candidate.setHwQual(quality);
226 
227  std::map<int, int> trackAddr;
228  trackAddr[0] = myCand->getFiredLayerBits();
229  trackAddr[1] = myCand->getRefLayer();
230  trackAddr[2] = myCand->getDisc();
231  if (candidate.hwPt() > 0) {
232  if (ptAssignment) {
233  auto pts = ptAssignment->getPts(myCand);
234  for (unsigned int i = 0; i < pts.size(); i++) {
235  trackAddr[10 + i] = this->myOmtfConfig->ptGevToHw(pts[i]);
236  }
237  }
238 
239  candidate.setTrackAddress(trackAddr);
240  candidate.setTFIdentifiers(iProcessor, mtfType);
241  result.push_back(candidate);
242  }
243  }
244  return result;
245 }
l1t::RegionalMuonCand::setHwPhi
void setHwPhi(int bits)
Set compressed relative phi as transmitted by hardware LSB = 2*pi/576 (8 bits)
Definition: RegionalMuonCand.h:132
mps_fire.i
i
Definition: mps_fire.py:428
OMTFConfiguration::fwVersion
unsigned int fwVersion() const
Definition: OMTFConfiguration.h:81
quality
uint32_t const *__restrict__ Quality * quality
Definition: CAHitNtupletGeneratorKernelsImpl.h:122
OMTFConfiguration::nPhiBins
unsigned int nPhiBins() const
Definition: OMTFConfiguration.h:93
l1t::RegionalMuonCand::setTrackAddress
void setTrackAddress(const std::map< int, int > &address)
Set the whole track address.
Definition: RegionalMuonCand.h:158
mps_fire.result
tuple result
Definition: mps_fire.py:311
RPCpg::pts
static const double pts[33]
Definition: Constants.h:30
PtAssignmentBase::getPts
virtual std::vector< float > getPts(const AlgoMuons::value_type &algoMuon)=0
l1t::RegionalMuonCand::setTFIdentifiers
void setTFIdentifiers(int processor, tftype trackFinder)
Set the processor ID, track-finder type. From these two, the link is set.
Definition: RegionalMuonCand.cc:5
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
OMTFConfiguration::procPhiToGmtPhi
int procPhiToGmtPhi(int procPhi) const
Definition: OMTFConfiguration.h:172
OMTFProcessor::ptAssignment
PtAssignmentBase * ptAssignment
Definition: OMTFProcessor.h:104
l1t::RegionalMuonCand::setHwQual
void setHwQual(int bits)
Set compressed quality code as transmitted by hardware (4 bits)
Definition: RegionalMuonCand.h:140
l1t::RegionalMuonCand::setHwPt
void setHwPt(int bits)
Set compressed pT as transmitted by hardware LSB = 0.5 (9 bits)
Definition: RegionalMuonCand.h:126
l1t::RegionalMuonCand::setHwEta
void setHwEta(int bits)
Set compressed eta as transmitted by hardware LSB = 0.010875 (9 bits)
Definition: RegionalMuonCand.h:134
OMTFConfiguration::ptGevToHw
int ptGevToHw(double ptGev) const override
uGMT pt scale conversion: [0GeV, 0.5GeV) = 1 [0.5GeV, 1 Gev) = 2
Definition: OMTFConfiguration.h:146
OMTFProcessor::checkHitPatternValidity
bool checkHitPatternValidity(unsigned int hits) override
Definition: OMTFProcessor.cc:252
OMTFProcessor::myOmtfConfig
const OMTFConfiguration * myOmtfConfig
Definition: OMTFProcessor.h:86
l1t::RegionalMuonCand::hwPt
const int hwPt() const
Get compressed pT (returned int * 0.5 = pT (GeV))
Definition: RegionalMuonCand.h:161
l1t::RegionalMuonCand::setHwSignValid
void setHwSignValid(int bits)
Set whether charge measurement is valid (0 for high pT muons)
Definition: RegionalMuonCand.h:138
l1t::RegionalMuonCand::setHwSign
void setHwSign(int bits)
Set charge sign bit (charge = (-1)^(sign))
Definition: RegionalMuonCand.h:136
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().

207 { return theGPs; }
OMTFProcessor::theGPs
std::map< Key, GoldenPattern * > theGPs
Map holding Golden Patterns.
Definition: OMTFProcessor.h:77
template<class GoldenPatternType >
AlgoMuons OMTFProcessor< GoldenPatternType >::ghostBust ( AlgoMuons  refHitCands,
int  charge = 0 
)
inlineoverridevirtual

Implements IProcessorEmulator.

Definition at line 63 of file OMTFProcessor.h.

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

63  {
64  return ghostBuster->select(refHitCands, charge);
65  }
OMTFProcessor::ghostBuster
std::unique_ptr< IGhostBuster > ghostBuster
Definition: OMTFProcessor.h:101
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().

52  {
53  setSorter(new OMTFSorter<GoldenPatternType>(this->myOmtfConfig->getSorterType()));
54  //initialize with the default sorter
55 
56  if (this->myOmtfConfig->getGhostBusterType() == "GhostBusterPreferRefDt" ||
57  this->myOmtfConfig->getGhostBusterType() == "byLLH") {
58  setGhostBuster(new GhostBusterPreferRefDt(this->myOmtfConfig));
59  edm::LogVerbatim("OMTFReconstruction") << "setting " << this->myOmtfConfig->getGhostBusterType() << std::endl;
60  } else {
61  setGhostBuster(new GhostBuster(this->myOmtfConfig)); //initialize with the default sorter
62  edm::LogVerbatim("OMTFReconstruction") << "setting GhostBuster" << std::endl;
63  }
64 
65  edm::LogVerbatim("OMTFReconstruction") << "fwVersion 0x" << hex << this->myOmtfConfig->fwVersion() << std::endl;
66 }
edm::LogVerbatim
Log< level::Info, true > LogVerbatim
Definition: MessageLogger.h:128
OMTFConfiguration::fwVersion
unsigned int fwVersion() const
Definition: OMTFConfiguration.h:81
OMTFConfiguration::getGhostBusterType
const std::string & getGhostBusterType() const
Definition: OMTFConfiguration.h:252
OMTFProcessor::setGhostBuster
void setGhostBuster(IGhostBuster *ghostBuster) override
allows to use other IGhostBuster implementation than the default one
Definition: OMTFProcessor.h:76
OMTFConfiguration::getSorterType
int getSorterType() const
Definition: OMTFConfiguration.h:248
OMTFProcessor::setSorter
virtual void setSorter(SorterBase< GoldenPatternType > *sorter)
allows to use other sorter implementation than the default one
Definition: OMTFProcessor.h:73
OMTFProcessor::myOmtfConfig
const OMTFConfiguration * myOmtfConfig
Definition: OMTFProcessor.h:86
template<class GoldenPatternType >
void OMTFProcessor< GoldenPatternType >::printInfo ( ) const
overridevirtual

Implements IProcessorEmulator.

Definition at line 420 of file OMTFProcessor.cc.

References ProcessorBase< GoldenPatternType >::printInfo().

420  {
421  edm::LogVerbatim("OMTFReconstruction") << __PRETTY_FUNCTION__ << std::endl;
422 
423  ProcessorBase<GoldenPatternType>::printInfo();
424 }
edm::LogVerbatim
Log< level::Info, true > LogVerbatim
Definition: MessageLogger.h:128
ProcessorBase::printInfo
virtual void printInfo() const
Definition: ProcessorBase.cc:220
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(), 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().

211  {
212  for (auto &itRegion : myResults)
213  for (auto &itKey : itRegion)
214  itKey.second.clear();
215 
218  std::bitset<128> refHitsBits = aInput.getRefHits(iProcessor);
219  if (refHitsBits.none())
220  return myResults;
221 
222  for (unsigned int iLayer = 0; iLayer < myOmtfConfig->nLayers(); ++iLayer) {
223  const OMTFinput::vector1D &layerHits = aInput.getLayerData(iLayer);
224  if (layerHits.empty())
225  continue;
227  unsigned int nTestedRefHits = myOmtfConfig->nTestRefHits();
228  for (unsigned int iRefHit = 0; iRefHit < myOmtfConfig->nRefHits(); ++iRefHit) {
229  if (!refHitsBits[iRefHit])
230  continue;
231  if (nTestedRefHits-- == 0)
232  break;
233  const RefHitDef &aRefHitDef = myOmtfConfig->getRefHitsDefs()[iProcessor][iRefHit];
234 
235  int phiRef = aInput.getLayerData(myOmtfConfig->getRefToLogicNumber()[aRefHitDef.iRefLayer])[aRefHitDef.iInput];
236  int etaRef =
237  aInput.getLayerData(myOmtfConfig->getRefToLogicNumber()[aRefHitDef.iRefLayer], true)[aRefHitDef.iInput];
238  unsigned int iRegion = aRefHitDef.iRegion;
239 
240  if (myOmtfConfig->getBendingLayers().count(iLayer))
241  phiRef = 0;
242  const OMTFinput::vector1D restrictedLayerHits = restrictInput(iProcessor, iRegion, iLayer, layerHits);
243  for (auto itGP : theGPs) {
244  GoldenPattern::layerResult aLayerResult =
245  itGP.second->process1Layer1RefLayer(aRefHitDef.iRefLayer, iLayer, phiRef, restrictedLayerHits);
246  int phiRefSt2 = itGP.second->propagateRefPhi(phiRef, etaRef, aRefHitDef.iRefLayer);
247  myResults[myOmtfConfig->nTestRefHits() - nTestedRefHits - 1][itGP.second->key()].setRefPhiRHits(
248  aRefHitDef.iRefLayer, phiRef);
249  myResults[myOmtfConfig->nTestRefHits() - nTestedRefHits - 1][itGP.second->key()].addResult(
250  aRefHitDef.iRefLayer, iLayer, aLayerResult.first, phiRefSt2, etaRef);
251  }
252  }
253  }
256  for (auto &itRefHit : myResults)
257  for (auto &itKey : itRefHit)
258  itKey.second.finalise();
259 
260  std::ostringstream myStr;
261  myStr << "iProcessor: " << iProcessor << std::endl;
262  myStr << "Input: ------------" << std::endl;
263  myStr << aInput << std::endl;
264  edm::LogInfo("OMTF processor") << myStr.str();
265 
266  return myResults;
267 }
OMTFConfiguration::getBendingLayers
const std::set< int > & getBendingLayers() const
Definition: OMTFConfiguration.h:104
OMTFProcessor::myResults
std::vector< OMTFProcessor::resultsMap > myResults
Definition: OMTFProcessor.h:82
OMTFConfiguration::nRefHits
unsigned int nRefHits() const
Definition: OMTFConfiguration.h:94
OMTFConfiguration::nLayers
unsigned int nLayers() const
Definition: OMTFConfiguration.h:87
RefHitDef::iInput
unsigned int iInput
Hit input number within a cone.
Definition: OMTFConfiguration.h:29
OMTFinput::vector1D
std::vector< int > vector1D
Definition: OMTFinput.h:13
GoldenPattern::layerResult
std::pair< int, bool > layerResult
Definition: GoldenPattern.h:49
OMTFinput::getLayerData
const OMTFinput::vector1D & getLayerData(unsigned int iLayer, bool giveEta=false) const
Definition: OMTFinput.cc:17
OMTFProcessor::theGPs
std::map< Key, GoldenPattern * > theGPs
Map holding Golden Patterns.
Definition: OMTFProcessor.h:77
OMTFConfiguration::getRefHitsDefs
const std::vector< std::vector< RefHitDef > > & getRefHitsDefs() const
Definition: OMTFConfiguration.h:118
if
if(conf_.getParameter< bool >("UseStripCablingDB"))
Definition: SiStripLAProfileBooker.cc:72
OMTFinput::getRefHits
std::bitset< 128 > getRefHits(unsigned int iProcessor) const
Definition: OMTFinput.cc:26
OMTFProcessor::restrictInput
OMTFinput::vector1D restrictInput(unsigned int iProcessor, unsigned int iCone, unsigned int iLayer, const OMTFinput::vector1D &layerHits)
Definition: OMTFProcessor.cc:270
edm::LogInfo
Log< level::Info, false > LogInfo
Definition: MessageLogger.h:125
OMTFConfiguration::getRefToLogicNumber
const std::vector< int > & getRefToLogicNumber() const
Definition: OMTFConfiguration.h:105
OMTFProcessor::myOmtfConfig
const OMTFConfiguration * myOmtfConfig
Definition: OMTFProcessor.h:86
RefHitDef::iRefLayer
unsigned int iRefLayer
Reference layer logic number (0-7)
Definition: OMTFConfiguration.h:35
RefHitDef::iRegion
unsigned int iRegion
Region number assigned to this referecne hit.
Definition: OMTFConfiguration.h:32
OMTFConfiguration::nTestRefHits
unsigned int nTestRefHits() const
Definition: OMTFConfiguration.h:95
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.

295  {
296  unsigned int procIndx = this->myOmtfConfig->getProcIndx(iProcessor, mtfType);
297  for (auto& itGP : this->theGPs) {
298  for (auto& result : itGP->getResults()[procIndx]) {
299  result.reset();
300  }
301  }
302 
305  std::bitset<128> refHitsBits = aInput.getRefHits(iProcessor);
306  if (refHitsBits.none())
307  return; // myResults;
308 
309  for (unsigned int iLayer = 0; iLayer < this->myOmtfConfig->nLayers(); ++iLayer) {
310  //debug
311  /*for(auto& h : layerHits) {
312  if(h != 5400)
313  LogTrace("l1tOmtfEventPrint")<<__FUNCTION__<<" "<<__LINE__<<" iLayer "<<iLayer<<" layerHit "<<h<<std::endl;
314  }*/
316  unsigned int nTestedRefHits = this->myOmtfConfig->nTestRefHits();
317  for (unsigned int iRefHit = 0; iRefHit < this->myOmtfConfig->nRefHits();
318  ++iRefHit) { //loop over all possible refHits, i.e. 128
319  if (!refHitsBits[iRefHit])
320  continue;
321  if (nTestedRefHits-- == 0)
322  break;
323 
324  const RefHitDef& aRefHitDef = this->myOmtfConfig->getRefHitsDefs()[iProcessor][iRefHit];
325 
326  unsigned int refLayerLogicNum = this->myOmtfConfig->getRefToLogicNumber()[aRefHitDef.iRefLayer];
327  const MuonStubPtr refStub = aInput.getMuonStub(refLayerLogicNum, aRefHitDef.iInput);
328  int phiRef = refStub->phiHw;
329  int etaRef = refStub->etaHw;
330 
331  unsigned int iRegion = aRefHitDef.iRegion;
332 
333  if (this->myOmtfConfig->getBendingLayers().count(iLayer)) //this iLayer is a bending layer
334  phiRef = 0; //then in the delta_phi in process1Layer1RefLayer one obtains simply the iLayer phi
335 
336  MuonStubPtrs1D restrictedLayerStubs = this->restrictInput(iProcessor, iRegion, iLayer, aInput);
337 
338  //LogTrace("l1tOmtfEventPrint")<<__FUNCTION__<<" "<<__LINE__<<" iLayer "<<iLayer<<" iRefLayer "<<aRefHitDef.iRefLayer<<" hits.size "<<restrictedLayerHits.size()<<std::endl;
339  //LogTrace("l1tOmtfEventPrint")<<"iLayer "<<iLayer<<" refHitNum "<<myOmtfConfig->nTestRefHits()-nTestedRefHits-1<<" iRefHit "<<iRefHit;
340  //LogTrace("l1tOmtfEventPrint")<<" nTestedRefHits "<<nTestedRefHits<<" aRefHitDef "<<aRefHitDef<<std::endl;
341 
342  unsigned int refHitNumber = this->myOmtfConfig->nTestRefHits() - nTestedRefHits - 1;
343  for (auto& itGP : this->theGPs) {
344  if (itGP->key().thePt == 0) //empty pattern
345  continue;
346 
347  StubResult stubResult =
348  itGP->process1Layer1RefLayer(aRefHitDef.iRefLayer, iLayer, restrictedLayerStubs, refStub);
349 
350  //fixme this unnecessary repeated for every layer - but in this layout of loops must be like that
351  int phiRefSt2 = itGP->propagateRefPhi(phiRef, etaRef, aRefHitDef.iRefLayer);
352 
353  //LogTrace("l1tOmtfEventPrint")<<__FUNCTION__<<":"<<__LINE__<<" layerResult: valid"<<layerResult.valid<<" pdfVal "<<layerResult.pdfVal<<std::endl;
354  itGP->getResults()[procIndx][refHitNumber].setStubResult(iLayer, stubResult);
355  //fixme this unnecessary repeated for every layer - but in this layout of loops must be like that
356  itGP->getResults()[procIndx][refHitNumber].set(aRefHitDef.iRefLayer, phiRefSt2, etaRef, phiRef);
357  }
358  }
359  }
362  {
363  for (auto& itGP : this->theGPs) {
364  itGP->finalise(procIndx);
365  //debug
366  /*for(unsigned int iRefHit = 0; iRefHit < itGP->getResults()[procIndx].size(); ++iRefHit) {
367  if(itGP->getResults()[procIndx][iRefHit].isValid()) {
368  LogTrace("l1tOmtfEventPrint")<<__FUNCTION__<<":"<<"__LINE__"<<itGP->getResults()[procIndx][iRefHit]<<std::endl;
369  }
370  }*/
371  }
372  }
373 
374  return;
375 }
OMTFConfiguration::getBendingLayers
const std::set< int > & getBendingLayers() const
Definition: OMTFConfiguration.h:104
OMTFConfiguration::nRefHits
unsigned int nRefHits() const
Definition: OMTFConfiguration.h:94
OMTFConfiguration::nLayers
unsigned int nLayers() const
Definition: OMTFConfiguration.h:87
RefHitDef::iInput
unsigned int iInput
Hit input number within a cone.
Definition: OMTFConfiguration.h:29
mps_fire.result
tuple result
Definition: mps_fire.py:311
OMTFProcessor::theGPs
std::map< Key, GoldenPattern * > theGPs
Map holding Golden Patterns.
Definition: OMTFProcessor.h:77
OMTFConfiguration::getRefHitsDefs
const std::vector< std::vector< RefHitDef > > & getRefHitsDefs() const
Definition: OMTFConfiguration.h:118
OMTFinput::getRefHits
std::bitset< 128 > getRefHits(unsigned int iProcessor) const
Definition: OMTFinput.cc:26
OMTFProcessor::restrictInput
OMTFinput::vector1D restrictInput(unsigned int iProcessor, unsigned int iCone, unsigned int iLayer, const OMTFinput::vector1D &layerHits)
Definition: OMTFProcessor.cc:270
MuonStubPtrs1D
std::vector< MuonStubPtr > MuonStubPtrs1D
Definition: MuonStub.h:65
MuonStubPtr
std::shared_ptr< const MuonStub > MuonStubPtr
Definition: MuonStub.h:64
OMTFConfiguration::getProcIndx
unsigned int getProcIndx(unsigned int iProcessor, l1t::tftype mtfType) const
input phi should be in the hardware scale (nPhiBins units for 2pi), can be in range -nPhiBins ...
Definition: OMTFConfiguration.h:183
OMTFConfiguration::getRefToLogicNumber
const std::vector< int > & getRefToLogicNumber() const
Definition: OMTFConfiguration.h:105
OMTFProcessor::myOmtfConfig
const OMTFConfiguration * myOmtfConfig
Definition: OMTFProcessor.h:86
RefHitDef::iRefLayer
unsigned int iRefLayer
Reference layer logic number (0-7)
Definition: OMTFConfiguration.h:35
OMTFinput::getMuonStub
const MuonStubPtr getMuonStub(unsigned int iLayer, unsigned int iInput) const
Definition: OMTFinput.h:30
RefHitDef::iRegion
unsigned int iRegion
Region number assigned to this referecne hit.
Definition: OMTFConfiguration.h:32
OMTFConfiguration::nTestRefHits
unsigned int nTestRefHits() const
Definition: OMTFConfiguration.h:95
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().

28  {
29  myResults.clear();
30  for (auto it : theGPs)
31  delete it.second;
32  theGPs.clear();
33 }
OMTFProcessor::myResults
std::vector< OMTFProcessor::resultsMap > myResults
Definition: OMTFProcessor.h:82
OMTFProcessor::theGPs
std::map< Key, GoldenPattern * > theGPs
Map holding Golden Patterns.
Definition: OMTFProcessor.h:77
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().

273  {
274  OMTFinput::vector1D myHits = layerHits;
275 
276  unsigned int iStart = myOmtfConfig->getConnections()[iProcessor][iRegion][iLayer].first;
277  unsigned int iEnd = iStart + myOmtfConfig->getConnections()[iProcessor][iRegion][iLayer].second - 1;
278 
279  for (unsigned int iInput = 0; iInput < 14; ++iInput) {
280  if (iInput < iStart || iInput > iEnd)
281  myHits[iInput] = myOmtfConfig->nPhiBins();
282  }
283  return myHits;
284 }
OMTFConfiguration::nPhiBins
unsigned int nPhiBins() const
Definition: OMTFConfiguration.h:93
OMTFinput::vector1D
std::vector< int > vector1D
Definition: OMTFinput.h:13
OMTFConfiguration::getConnections
const vector3D_pair & getConnections() const
Definition: OMTFConfiguration.h:120
OMTFProcessor::myOmtfConfig
const OMTFConfiguration * myOmtfConfig
Definition: OMTFProcessor.h:86
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(), makePileupJSON::bx, and input.

385  {
386  //uncomment if you want to check execution time of each method
387  //boost::timer::auto_cpu_timer t("%ws wall, %us user in getProcessorCandidates\n");
388 
389  std::shared_ptr<OMTFinput> input = std::make_shared<OMTFinput>(this->myOmtfConfig);
390  inputMaker->buildInputForProcessor(input->getMuonStubs(), iProcessor, mtfType, bx, bx);
391 
392  //LogTrace("l1tOmtfEventPrint")<<"buildInputForProce "; t.report();
393  processInput(iProcessor, mtfType, *(input.get()));
394 
395  //LogTrace("l1tOmtfEventPrint")<<"processInput "; t.report();
396  AlgoMuons algoCandidates = sortResults(iProcessor, mtfType);
397 
398  //LogTrace("l1tOmtfEventPrint")<<"sortResults "; t.report();
399  // perform GB
400  AlgoMuons gbCandidates = ghostBust(algoCandidates);
401 
402  //LogTrace("l1tOmtfEventPrint")<<"ghostBust"; t.report();
403  // fill RegionalMuonCand colleciton
404  std::vector<l1t::RegionalMuonCand> candMuons = getFinalcandidates(iProcessor, mtfType, gbCandidates);
405 
406  //LogTrace("l1tOmtfEventPrint")<<"getFinalcandidates "; t.report();
407  //fill outgoing collection
408  for (auto& candMuon : candMuons) {
409  candMuon.setHwQual(candMuon.hwQual());
410  }
411 
412  for (auto& obs : observers) {
413  obs->observeProcesorEmulation(iProcessor, mtfType, input, algoCandidates, gbCandidates, candMuons);
414  }
415 
416  return candMuons;
417 }
OMTFinputMaker::buildInputForProcessor
OMTFinput buildInputForProcessor(const L1MuDTChambPhContainer *dtPhDigis, const L1MuDTChambThContainer *dtThDigis, const CSCCorrelatedLCTDigiCollection *cscDigis, const RPCDigiCollection *rpcDigis, unsigned int iProcessor, l1t::tftype type=l1t::tftype::omtf_pos, int bx=0)
Method translating trigger digis into input matrix with global phi coordinates.
Definition: OMTFinputMaker.cc:383
OMTFProcessor::getFinalcandidates
std::vector< l1t::RegionalMuonCand > getFinalcandidates(unsigned int iProcessor, l1t::tftype mtfType, const AlgoMuons &algoCands) override
Definition: OMTFProcessor.cc:69
input
static std::string const input
Definition: EdmProvDump.cc:47
OMTFProcessor::processInput
const std::vector< OMTFProcessor::resultsMap > & processInput(unsigned int iProcessor, const OMTFinput &aInput)
Definition: OMTFProcessor.cc:210
OMTFProcessor::ghostBust
AlgoMuons ghostBust(AlgoMuons refHitCands, int charge=0) override
Definition: OMTFProcessor.h:63
OMTFProcessor::sortResults
AlgoMuons sortResults(unsigned int iProcessor, l1t::tftype mtfType, int charge=0) override
Definition: OMTFProcessor.cc:285
AlgoMuons
std::vector< AlgoMuonPtr > AlgoMuons
Definition: AlgoMuon.h:102
OMTFProcessor::myOmtfConfig
const OMTFConfiguration * myOmtfConfig
Definition: OMTFProcessor.h:86
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.

76 { this->ghostBuster.reset(ghostBuster); }
template<class GoldenPatternType >
virtual void OMTFProcessor< GoldenPatternType >::setPtAssignment ( PtAssignmentBase *  ptAssignment)
inlinevirtual

Definition at line 78 of file OMTFProcessor.h.

References OMTFProcessor< GoldenPatternType >::ptAssignment.

78 { this->ptAssignment = ptAssignment; }
OMTFProcessor::ptAssignment
PtAssignmentBase * ptAssignment
Definition: OMTFProcessor.h:104
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.

73 { this->sorter.reset(sorter); }
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().

185  {
188  unsigned int nPdfBins = exp2(myOmtfConfig->nPdfAddrBits());
189  GoldenPattern::vector3D pdfAllRef = aGP->getPdf();
190 
191  int indexShift = 0;
192  for (unsigned int iLayer = 0; iLayer < myOmtfConfig->nLayers(); ++iLayer) {
193  for (unsigned int iRefLayer = 0; iRefLayer < myOmtfConfig->nRefLayers(); ++iRefLayer) {
194  indexShift = meanDistPhiOld[iLayer][iRefLayer] - meanDistPhiNew[iLayer][iRefLayer];
195  for (unsigned int iPdfBin = 0; iPdfBin < nPdfBins; ++iPdfBin)
196  pdfAllRef[iLayer][iRefLayer][iPdfBin] = 0;
197  for (unsigned int iPdfBin = 0; iPdfBin < nPdfBins; ++iPdfBin) {
198  if ((int)(iPdfBin) + indexShift >= 0 && iPdfBin + indexShift < nPdfBins)
199  pdfAllRef[iLayer][iRefLayer][iPdfBin + indexShift] = aGP->pdfValue(iLayer, iRefLayer, iPdfBin);
200  }
201  }
202  }
203  aGP->setPdf(pdfAllRef);
204 }
OMTFConfiguration::nRefLayers
unsigned int nRefLayers() const
Definition: OMTFConfiguration.h:89
OMTFConfiguration::nLayers
unsigned int nLayers() const
Definition: OMTFConfiguration.h:87
GoldenPattern::vector3D
std::vector< vector2D > vector3D
Definition: GoldenPattern.h:48
GoldenPattern::setPdf
void setPdf(const vector3D &aPdf)
Definition: GoldenPattern.h:64
OMTFConfiguration::nPdfAddrBits
unsigned int nPdfAddrBits() const
Definition: OMTFConfiguration.h:91
GoldenPattern::pdfValue
int pdfValue(unsigned int iLayer, unsigned int iRefLayer, unsigned int iBin) const
Definition: GoldenPattern.h:68
OMTFProcessor::myOmtfConfig
const OMTFConfiguration * myOmtfConfig
Definition: OMTFProcessor.h:86
GoldenPattern::getPdf
const vector3D & getPdf() const
Definition: GoldenPattern.h:62
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.

285  {
286  unsigned int procIndx = this->myOmtfConfig->getProcIndx(iProcessor, mtfType);
287  return sorter->sortResults(procIndx, this->getPatterns(), charge);
288 }
OMTFProcessor::getPatterns
const std::map< Key, GoldenPattern * > & getPatterns() const
Return map of GoldenPatterns.
Definition: OMTFProcessor.cc:207
OMTFConfiguration::getProcIndx
unsigned int getProcIndx(unsigned int iProcessor, l1t::tftype mtfType) const
input phi should be in the hardware scale (nPhiBins units for 2pi), can be in range -nPhiBins ...
Definition: OMTFConfiguration.h:183
OMTFProcessor::myOmtfConfig
const OMTFConfiguration * myOmtfConfig
Definition: OMTFProcessor.h:86

Member Data Documentation

template<class GoldenPatternType >
std::unique_ptr<IGhostBuster> OMTFProcessor< GoldenPatternType >::ghostBuster
private

Definition at line 101 of file OMTFProcessor.h.

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

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().

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().

template<class GoldenPatternType >
PtAssignmentBase* OMTFProcessor< GoldenPatternType >::ptAssignment = nullptr
private

Definition at line 104 of file OMTFProcessor.h.

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

template<class GoldenPatternType >
std::unique_ptr<SorterBase<GoldenPatternType> > OMTFProcessor< GoldenPatternType >::sorter
private

Definition at line 99 of file OMTFProcessor.h.

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().

Generated for CMSSW Reference Manual by doxygen 1.8.5