test
CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
L1MuBMAssignmentUnit.cc
Go to the documentation of this file.
1 //-------------------------------------------------
2 //
3 // Class: L1MuBMAssignmentUnit
4 //
5 // Description: Assignment Unit
6 //
7 //
8 //
9 // Author :
10 // N. Neumeister CERN EP
11 // J. Troconiz UAM Madrid
12 // Modifications:
13 // G. Flouris U. Ioannina
14 //--------------------------------------------------
15 
16 //-----------------------
17 // This Class's Header --
18 //-----------------------
19 
20 #include "L1MuBMAssignmentUnit.h"
21 
22 //---------------
23 // C++ Headers --
24 //---------------
25 
26 #include <iostream>
27 #include <cmath>
28 #include <cassert>
29 
30 //-------------------------------
31 // Collaborating Class Headers --
32 //-------------------------------
33 
34 #include "L1MuBMTFConfig.h"
35 #include "L1MuBMSectorProcessor.h"
36 #include "L1MuBMDataBuffer.h"
37 #include "L1MuBMTrackSegPhi.h"
38 #include "L1MuBMTrackSegLoc.h"
39 #include "L1MuBMTrackAssembler.h"
40 #include "L1MuBMTrackAssParam.h"
41 
42 #include <iostream>
43 #include <iomanip>
44 
45 using namespace std;
46 // --------------------------------
47 // class L1MuBMAssignmentUnit
48 //---------------------------------
49 
50 //----------------
51 // Constructors --
52 //----------------
53 
54 L1MuBMAssignmentUnit::L1MuBMAssignmentUnit(L1MuBMSectorProcessor& sp, int id) :
55  m_sp(sp), m_id(id),
56  m_addArray(), m_TSphi(), m_ptAssMethod(L1MuBMLUTHandler::NODEF ) {
57 
58  m_TSphi.reserve(4); // a track candidate can consist of max 4 TS
59  reset();
60  setPrecision();
61 
62 }
63 
64 
65 //--------------
66 // Destructor --
67 //--------------
68 
69 L1MuBMAssignmentUnit::~L1MuBMAssignmentUnit() {
70 }
71 
72 
73 //--------------
74 // Operations --
75 //--------------
76 
77 //
78 // run Assignment Unit
79 //
80 void L1MuBMAssignmentUnit::run(const edm::EventSetup& c) {
81 
82  // enable track candidate
83  m_sp.track(m_id)->enable();
84  m_sp.tracK(m_id)->enable();
85 
86  // set track class
87  TrackClass tc = m_sp.TA()->trackClass(m_id);
88  m_sp.track(m_id)->setTC(tc);
89  m_sp.tracK(m_id)->setTC(tc);
90 
91  // get relative addresses of matching track segments
92  m_addArray = m_sp.TA()->address(m_id);
93  m_sp.track(m_id)->setAddresses(m_addArray);
94  m_sp.tracK(m_id)->setAddresses(m_addArray);
95 
96  // get track segments (track segment router)
97  TSR();
98  m_sp.track(m_id)->setTSphi(m_TSphi);
99  m_sp.tracK(m_id)->setTSphi(m_TSphi);
100 
101  // set bunch-crossing (use first track segment)
102  vector<const L1MuBMTrackSegPhi*>::const_iterator iter = m_TSphi.begin();
103  int bx = (*iter)->bx();
104  m_sp.track(m_id)->setBx(bx);
105  m_sp.tracK(m_id)->setBx(bx);
106 
107  // assign phi
108  PhiAU(c);
109 
110  // assign pt and charge
111  PtAU(c);
112 
113  // assign quality
114  QuaAU();
115 
116 }
117 
118 
119 //
120 // reset Assignment Unit
121 //
122 void L1MuBMAssignmentUnit::reset() {
123 
124  m_addArray.reset();
125  m_TSphi.clear();
126  m_ptAssMethod = L1MuBMLUTHandler::NODEF;
127 
128 }
129 
130 
131 //
132 // assign phi with 8 bit precision
133 //
134 void L1MuBMAssignmentUnit::PhiAU(const edm::EventSetup& c) {
135 
136  const L1TMuonBarrelParamsRcd& bmtfParamsRcd = c.get<L1TMuonBarrelParamsRcd>();
137  bmtfParamsRcd.get(bmtfParamsHandle);
138  const L1TMuonBarrelParams& bmtfParams = *bmtfParamsHandle.product();
139  thePhiLUTs = new L1MuBMLUTHandler(bmtfParams);
140  //thePhiLUTs->print();
141  // calculate phi at station 2 using 8 bits (precision = 0.625 degrees)
142  int sh_phi = 12 - L1MuBMTFConfig::getNbitsPhiPhi();
143  int sh_phib = 10 - L1MuBMTFConfig::getNbitsPhiPhib();
144 
145  const L1MuBMTrackSegPhi* second = getTSphi(2); // track segment at station 2
146  const L1MuBMTrackSegPhi* first = getTSphi(1); // track segment at station 1
147  const L1MuBMTrackSegPhi* forth = getTSphi(4); // track segment at station 4
148 
149  int phi2 = 0; // phi-value at station 2
150  int sector = 0;
151  if ( second ) {
152  phi2 = second->phi() >> sh_phi;
153  sector = second->sector();
154  }
155  else if ( second == 0 && first ) {
156  phi2 = first->phi() >> sh_phi;
157  sector = first->sector();
158  }
159  else if ( second == 0 && forth ) {
160  phi2 = forth->phi() >> sh_phi;
161  sector = forth->sector();
162  }
163 
164  int sector0 = m_sp.id().sector();
165 
166  // convert sector difference to values in the range -6 to +5
167 
168  int sectordiff = (sector - sector0)%12;
169  if ( sectordiff >= 6 ) sectordiff -= 12;
170  if ( sectordiff < -6 ) sectordiff += 12;
171 
172  // convert phi to 0.625 degree precision
173  int phi_precision = 4096 >> sh_phi;
174  const double k = 57.2958/0.625/static_cast<float>(phi_precision);
175  double phi_f = static_cast<double>(phi2);
176  int phi_8 = static_cast<int>(floor(phi_f*k));
177 
178  if ( second == 0 && first ) {
179  int bend_angle = (first->phib() >> sh_phib) << sh_phib;
180  phi_8 = phi_8 + thePhiLUTs->getDeltaPhi(0,bend_angle);
181  //phi_8 = phi_8 + getDeltaPhi(0, bend_angle, bmtfParams->phi_lut());
182  }
183  else if ( second == 0 && forth ) {
184 
185  int bend_angle = (forth->phib() >> sh_phib) << sh_phib;
186  phi_8 = phi_8 + thePhiLUTs->getDeltaPhi(1,bend_angle);
187  //phi_8 = phi_8 + getDeltaPhi(1, bend_angle, bmtfParams->phi_lut());
188  }
189 
190  //If muon is found at the neighbour sector - second station
191  //a shift is needed by 48
192  phi_8 += sectordiff*48;
193 
194  int phi = phi_8 + 24;
195  if (phi > 55) phi = 55;
196  if (phi < -8) phi = -8;
197 
198  m_sp.track(m_id)->setPhi(phi); // Regional
199  m_sp.tracK(m_id)->setPhi(phi);
200 
201 delete thePhiLUTs;
202 }
203 
204 
205 //
206 // assign pt with 5 bit precision
207 //
208 void L1MuBMAssignmentUnit::PtAU(const edm::EventSetup& c) {
209 
210  const L1TMuonBarrelParamsRcd& bmtfParamsRcd = c.get<L1TMuonBarrelParamsRcd>();
211  bmtfParamsRcd.get(bmtfParamsHandle);
212  const L1TMuonBarrelParams& bmtfParams1 = *bmtfParamsHandle.product();
213  const L1TMuonBarrelParamsAllPublic& bmtfParams = L1TMuonBarrelParamsAllPublic(bmtfParams1);
214  thePtaLUTs = new L1MuBMLUTHandler(bmtfParams);
215  //thePtaLUTs->print();
216  // get pt-assignment method as function of track class and TS phib values
217  //m_ptAssMethod = getPtMethod(bmtfParams);
218  m_ptAssMethod = getPtMethod();
219  // get input address for look-up table
220  int bend_angle = getPtAddress(m_ptAssMethod);
221  int bend_carga = getPtAddress(m_ptAssMethod, 1);
222 
223  // retrieve pt value from look-up table
224  int lut_idx = m_ptAssMethod;
225  int pt = thePtaLUTs->getPt(lut_idx,bend_angle );
226  //int pt = getPt(lut_idx, bend_angle, bmtfParams->pta_lut());
227 
228 if(!bmtfParams.get_DisableNewAlgo()){
229 
230  if (Quality() < 4) {
231  int ptj = pt;
232  L1MuBMLUTHandler::PtAssMethod jj1 = getPt1Method(m_ptAssMethod);
233  L1MuBMLUTHandler::PtAssMethod jj2 = getPt2Method(m_ptAssMethod);
234  if (jj1 != L1MuBMLUTHandler::NODEF) {
235  lut_idx = jj1;
236  bend_angle = getPt1Address(m_ptAssMethod);
237  if (abs(bend_angle) < 512) ptj = thePtaLUTs->getPt(lut_idx,bend_angle );
238  }
239  else if (jj2 != L1MuBMLUTHandler::NODEF) {
240  lut_idx = jj2;
241  bend_angle = getPt2Address(m_ptAssMethod);
242  if (abs(bend_angle) < 512) ptj = thePtaLUTs->getPt(lut_idx,bend_angle );
243  }
244  if (ptj < pt) pt = ptj;
245  }
246 }
247 
248  m_sp.track(m_id)->setPt(pt);
249  m_sp.tracK(m_id)->setPt(pt);
250 
251  // assign charge
252  int chsign = getCharge(m_ptAssMethod);
253  int charge = ( bend_carga >= 0 ) ? chsign : -1 * chsign;
254  m_sp.track(m_id)->setCharge(charge);
255  m_sp.tracK(m_id)->setCharge(charge);
256  delete thePtaLUTs;
257 
258 }
259 
260 
261 //
262 // assign 4 bit quality code
263 //
264 void L1MuBMAssignmentUnit::QuaAU() {
265 
266  unsigned int quality = 0;
267 
268  const TrackClass tc = m_sp.TA()->trackClass(m_id);
269 
271  switch ( tc ) {
272  case T1234 : { quality = 3; break; }
273  case T123 : { quality = 2; break; }
274  case T124 : { quality = 2; break; }
275  case T134 : { quality = 2; break; }
276  case T234 : { quality = 2; break; }
277  case T12 : { quality = 1; break; }
278  case T13 : { quality = 1; break; }
279  case T14 : { quality = 1; break; }
280  case T23 : { quality = 0; break; }
281  case T24 : { quality = 0; break; }
282  case T34 : { quality = 0; break; }
283  default : { quality = 0; break; }
284  }
285 
287  quality += 12;
288 
289  m_sp.track(m_id)->setQuality(quality);
290  m_sp.tracK(m_id)->setQuality(quality);
291 
292 }
293 
294 
295 //
296 // assign 3 bit quality code
297 //
298 unsigned int L1MuBMAssignmentUnit::Quality() {
299 
300  unsigned int quality = 0;
301 
302  const TrackClass tc = m_sp.TA()->trackClass(m_id);
303 
304  switch ( tc ) {
305  case T1234 : { quality = 7; break; }
306  case T123 : { quality = 6; break; }
307  case T124 : { quality = 6; break; }
308  case T134 : { quality = 5; break; }
309  case T234 : { quality = 4; break; }
310  case T12 : { quality = 3; break; }
311  case T13 : { quality = 3; break; }
312  case T14 : { quality = 3; break; }
313  case T23 : { quality = 2; break; }
314  case T24 : { quality = 2; break; }
315  case T34 : { quality = 1; break; }
316  default : { quality = 0; }
317  }
318 
319  return quality;
320 
321 }
322 
323 //
324 // Track Segment Router (TSR)
325 //
326 void L1MuBMAssignmentUnit::TSR() {
327 
328  // get the track segments from the data buffer
329  const L1MuBMTrackSegPhi* ts = 0;
330  for ( int stat = 1; stat <= 4; stat++ ) {
331  int adr = m_addArray.station(stat);
332  if ( adr != 15 ) {
333  ts = m_sp.data()->getTSphi(stat,adr);
334  if ( ts != 0 ) m_TSphi.push_back( ts );
335  }
336  }
337 
338 }
339 
340 
341 //
342 // get track segment from a given station
343 //
344 const L1MuBMTrackSegPhi* L1MuBMAssignmentUnit::getTSphi(int station) const {
345 
346  vector<const L1MuBMTrackSegPhi*>::const_iterator iter;
347  for ( iter = m_TSphi.begin(); iter != m_TSphi.end(); iter++ ) {
348  int stat = (*iter)->station();
349  if ( station == stat ) {
350  return (*iter);
351  break;
352  }
353  }
354 
355  return 0;
356 
357 }
358 
359 
360 //
361 // convert sector Id to a precision of 2.5 degrees using 8 bits (= sector center)
362 //
363 int L1MuBMAssignmentUnit::convertSector(int sector) {
364 
365  // assert( sector >=0 && sector < 12 );
366  const int sectorvalues[12] = { 0, 12, 24, 36, 48, 60, 72, 84,
367  96, 108, 120, 132 };
368 
369  return sectorvalues[sector];
370 
371 }
372 
373 
374 //
375 // determine charge
376 //
377 int L1MuBMAssignmentUnit::getCharge(L1MuBMLUTHandler::PtAssMethod method) {
378 
379  int chargesign = 0;
380  switch ( method ) {
381  case L1MuBMLUTHandler::PT12L : { chargesign = -1; break; }
382  case L1MuBMLUTHandler::PT12H : { chargesign = -1; break; }
383  case L1MuBMLUTHandler::PT13L : { chargesign = -1; break; }
384  case L1MuBMLUTHandler::PT13H : { chargesign = -1; break; }
385  case L1MuBMLUTHandler::PT14L : { chargesign = -1; break; }
386  case L1MuBMLUTHandler::PT14H : { chargesign = -1; break; }
387  case L1MuBMLUTHandler::PT23L : { chargesign = -1; break; }
388  case L1MuBMLUTHandler::PT23H : { chargesign = -1; break; }
389  case L1MuBMLUTHandler::PT24L : { chargesign = -1; break; }
390  case L1MuBMLUTHandler::PT24H : { chargesign = -1; break; }
391  case L1MuBMLUTHandler::PT34L : { chargesign = 1; break; }
392  case L1MuBMLUTHandler::PT34H : { chargesign = 1; break; }
393 
394  case L1MuBMLUTHandler::NODEF : { chargesign = 0;
395  // cerr << "AssignmentUnit::getCharge : undefined PtAssMethod!"
396  // << endl;
397  break;
398  }
399  default : { chargesign = 0; }
400  }
401 
402  return chargesign;
403 
404 }
405 
406 
407 //
408 // determine pt-assignment method
409 //
410 //PtAssMethod L1MuBMAssignmentUnit::getPtMethod(L1TMuonBarrelParams *l1tbmparams) const {
411 L1MuBMLUTHandler::PtAssMethod L1MuBMAssignmentUnit::getPtMethod() const {
412 
413  // determine which pt-assignment method should be used as a function
414  // of the track class and
415  // of the phib values of the track segments making up this track candidate.
416 
417  // get bitmap of track candidate
418  const bitset<4> s = m_sp.TA()->trackBitMap(m_id);
419 
420  int method = -1;
421 
422  if ( s.test(0) && s.test(3) ) method = 2; // stations 1 and 4
423  if ( s.test(0) && s.test(2) ) method = 1; // stations 1 and 3
424  if ( s.test(0) && s.test(1) ) method = 0; // stations 1 and 2
425  if ( !s.test(0) && s.test(1) && s.test(3) ) method = 4; // stations 2 and 4
426  if ( !s.test(0) && s.test(1) && s.test(2) ) method = 3; // stations 2 and 3
427  if ( !s.test(0) && !s.test(1) && s.test(2) && s.test(3) ) method = 5; // stations 3 and 4
428  int threshold = thePtaLUTs->getPtLutThreshold(method);
429 
430  // phib values of track segments from stations 1, 2 and 4
431  int phib1 = ( getTSphi(1) != 0 ) ? getTSphi(1)->phib() : 0;
432  int phib2 = ( getTSphi(2) != 0 ) ? getTSphi(2)->phib() : 0;
433  int phib4 = ( getTSphi(4) != 0 ) ? getTSphi(4)->phib() : 0;
434 
435  L1MuBMLUTHandler::PtAssMethod pam = L1MuBMLUTHandler::NODEF;
436 
437  switch ( method ) {
438  case 0 : { pam = ( abs(phib1) < threshold ) ? L1MuBMLUTHandler::PT12H : L1MuBMLUTHandler::PT12L; break; }
439  case 1 : { pam = ( abs(phib1) < threshold ) ? L1MuBMLUTHandler::PT13H : L1MuBMLUTHandler::PT13L; break; }
440  case 2 : { pam = ( abs(phib1) < threshold ) ? L1MuBMLUTHandler::PT14H : L1MuBMLUTHandler::PT14L; break; }
441  case 3 : { pam = ( abs(phib2) < threshold ) ? L1MuBMLUTHandler::PT23H : L1MuBMLUTHandler::PT23L; break; }
442  case 4 : { pam = ( abs(phib2) < threshold ) ? L1MuBMLUTHandler::PT24H : L1MuBMLUTHandler::PT24L; break; }
443  case 5 : { pam = ( abs(phib4) < threshold ) ? L1MuBMLUTHandler::PT34H : L1MuBMLUTHandler::PT34L; break; }
444  default : ;
445  //cout << "L1MuBMAssignmentUnit : Error in PT ass method evaluation" << endl;
446  }
447 
448  return pam;
449 
450 }
451 
452 
453 //
454 // calculate bend angle
455 //
456 int L1MuBMAssignmentUnit::getPtAddress(L1MuBMLUTHandler::PtAssMethod method, int bendcharge) const {
457 
458  // calculate bend angle as difference of two azimuthal positions
459 
460  int bendangle = 0;
461  switch (method) {
462  case L1MuBMLUTHandler::PT12L : { bendangle = phiDiff(1,2); break; }
463  case L1MuBMLUTHandler::PT12H : { bendangle = phiDiff(1,2); break; }
464  case L1MuBMLUTHandler::PT13L : { bendangle = phiDiff(1,3); break; }
465  case L1MuBMLUTHandler::PT13H : { bendangle = phiDiff(1,3); break; }
466  case L1MuBMLUTHandler::PT14L : { bendangle = phiDiff(1,4); break; }
467  case L1MuBMLUTHandler::PT14H : { bendangle = phiDiff(1,4); break; }
468  case L1MuBMLUTHandler::PT23L : { bendangle = phiDiff(2,3); break; }
469  case L1MuBMLUTHandler::PT23H : { bendangle = phiDiff(2,3); break; }
470  case L1MuBMLUTHandler::PT24L : { bendangle = phiDiff(2,4); break; }
471  case L1MuBMLUTHandler::PT24H : { bendangle = phiDiff(2,4); break; }
472  case L1MuBMLUTHandler::PT34L : { bendangle = phiDiff(4,3); break; }
473  case L1MuBMLUTHandler::PT34H : { bendangle = phiDiff(4,3); break; }
474  case L1MuBMLUTHandler::NODEF : { bendangle = 0;
475  // cerr << "AssignmentUnit::getPtAddress : undefined PtAssMethod" << endl;
476  break;
477  }
478  default : { bendangle = 0; }
479 
480  }
481 
482  int signo = 1;
483  bendangle = (bendangle+8192)%4096;
484  if ( bendangle > 2047 ) bendangle -= 4096;
485  if ( bendangle < 0 ) signo = -1;
486 
487  if (bendcharge) return signo;
488 
489  bendangle = (bendangle+2048)%1024;
490  if ( bendangle > 511 ) bendangle -= 1024;
491 
492  return bendangle;
493 
494 }
495 
496 
497 //
498 // build difference of two phi values
499 //
500 int L1MuBMAssignmentUnit::phiDiff(int stat1, int stat2) const {
501 
502  // calculate bit shift
503 
504  int sh_phi = 12 - nbit_phi;
505 
506  // get 2 phi values and add offset (30 degrees ) for adjacent sector
507  int sector1 = getTSphi(stat1)->sector();
508  int sector2 = getTSphi(stat2)->sector();
509  int phi1 = getTSphi(stat1)->phi() >> sh_phi;
510  int phi2 = getTSphi(stat2)->phi() >> sh_phi;
511 
512  // convert sector difference to values in the range -6 to +5
513 
514  int sectordiff = (sector2 - sector1)%12;
515  if ( sectordiff >= 6 ) sectordiff -= 12;
516  if ( sectordiff < -6 ) sectordiff += 12;
517 
518  // assert( abs(sectordiff) <= 1 );
519 
520  int offset = (2144 >> sh_phi) * sectordiff;
521  int bendangle = (phi2 - phi1 + offset) << sh_phi;
522 
523  return bendangle;
524 
525 }
526 
527 
528 
529 //
530 // determine pt-assignment method
531 //
532 L1MuBMLUTHandler::PtAssMethod L1MuBMAssignmentUnit::getPt1Method(L1MuBMLUTHandler::PtAssMethod method) const {
533 
534  // quality values of track segments from stations 1, 2 and 4
535  int qual1 = ( getTSphi(1) != 0 ) ? getTSphi(1)->quality() : 0;
536  int qual2 = ( getTSphi(2) != 0 ) ? getTSphi(2)->quality() : 0;
537  int qual4 = ( getTSphi(4) != 0 ) ? getTSphi(4)->quality() : 0;
538 
539  L1MuBMLUTHandler::PtAssMethod pam = L1MuBMLUTHandler::NODEF;
540 
541  switch ( method ) {
542  case L1MuBMLUTHandler::PT12H : { if (qual1 > 3) pam = L1MuBMLUTHandler::PB12H; break; }
543  case L1MuBMLUTHandler::PT13H : { if (qual1 > 3) pam = L1MuBMLUTHandler::PB13H; break; }
544  case L1MuBMLUTHandler::PT14H : { if (qual1 > 3) pam = L1MuBMLUTHandler::PB14H; break; }
545  case L1MuBMLUTHandler::PT23H : { if (qual2 > 3) pam = L1MuBMLUTHandler::PB23H; break; }
546  case L1MuBMLUTHandler::PT24H : { if (qual2 > 3) pam = L1MuBMLUTHandler::PB24H; break; }
547  case L1MuBMLUTHandler::PT34H : { if (qual4 > 3) pam = L1MuBMLUTHandler::PB34H; break; }
548  case L1MuBMLUTHandler::NODEF : { pam = L1MuBMLUTHandler::NODEF; break;}
549  default : { pam = L1MuBMLUTHandler::NODEF; }
550  }
551 
552  return pam;
553 
554 }
555 
556 
557 //
558 // determine pt-assignment method
559 //
560 L1MuBMLUTHandler::PtAssMethod L1MuBMAssignmentUnit::getPt2Method(L1MuBMLUTHandler::PtAssMethod method) const {
561 
562  // quality values of track segments from stations 2 and 4
563  int qual2 = ( getTSphi(2) != 0 ) ? getTSphi(2)->quality() : 0;
564  // int qual4 = ( getTSphi(4) != 0 ) ? getTSphi(4)->quality() : 0;
565 
566  L1MuBMLUTHandler::PtAssMethod pam = L1MuBMLUTHandler::NODEF;
567 
568  switch ( method ) {
569  case L1MuBMLUTHandler::PT12H : { if (qual2 > 3) pam = L1MuBMLUTHandler::PB21H; break; }
570  // case PT14H : { if (qual4 > 3) pam = PB34H; break; }
571  // case PT24H : { if (qual4 > 3) pam = PB34H; break; }
572  //case PT12HO : { if (qual2 > 3) pam = PB21HO; break; }
573  // case PT14HO : { if (qual4 > 3) pam = PB34HO; break; }
574  // case PT24HO : { if (qual4 > 3) pam = PB34HO; break; }
575  case L1MuBMLUTHandler::NODEF : { pam = L1MuBMLUTHandler::NODEF; break; }
576  default : { pam = L1MuBMLUTHandler::NODEF; }
577  }
578 
579  return pam;
580 
581 }
582 
583 
584 //
585 // calculate bend angle
586 //
587 int L1MuBMAssignmentUnit::getPt1Address(L1MuBMLUTHandler::PtAssMethod method) const {
588 
589  // phib values of track segments from stations 1, 2 and 4
590  int phib1 = ( getTSphi(1) != 0 ) ? getTSphi(1)->phib() : -999;
591  int phib2 = ( getTSphi(2) != 0 ) ? getTSphi(2)->phib() : -999;
592  int phib4 = ( getTSphi(4) != 0 ) ? getTSphi(4)->phib() : -999;
593 
594 
595  int bendangle = -999;
596  switch (method) {
597  case L1MuBMLUTHandler::PT12H : { bendangle = phib1; break; }
598  case L1MuBMLUTHandler::PT13H : { bendangle = phib1; break; }
599  case L1MuBMLUTHandler::PT14H : { bendangle = phib1; break; }
600  case L1MuBMLUTHandler::PT23H : { bendangle = phib2; break; }
601  case L1MuBMLUTHandler::PT24H : { bendangle = phib2; break; }
602  case L1MuBMLUTHandler::PT34H : { bendangle = phib4; break; }
603  case L1MuBMLUTHandler::NODEF : { bendangle = -999; break; }
604  default : { bendangle = -999; }
605  }
606 
607  return bendangle;
608 
609 }
610 
611 
612 //
613 // calculate bend angle
614 //
615 int L1MuBMAssignmentUnit::getPt2Address(L1MuBMLUTHandler::PtAssMethod method) const {
616 
617  // phib values of track segments from stations 1, 2 and 4
618  int phib2 = ( getTSphi(2) != 0 ) ? getTSphi(2)->phib() : -999;
619  int phib4 = ( getTSphi(4) != 0 ) ? getTSphi(4)->phib() : -999;
620 
621 
622  int bendangle = -999;
623  switch (method) {
624  case L1MuBMLUTHandler::PT12H : { bendangle = phib2; break; }
625  case L1MuBMLUTHandler::PT14H : { bendangle = phib4; break; }
626  case L1MuBMLUTHandler::PT24H : { bendangle = phib4; break; }
627  //case L1MuBMLUTHandler::PT12HO : { bendangle = phib2; break; }
628  //case L1MuBMLUTHandler::PT14HO : { bendangle = phib4; break; }
629  //case L1MuBMLUTHandler::PT24HO : { bendangle = phib4; break; }
630  case L1MuBMLUTHandler::NODEF : { bendangle = -999; break; }
631  default : { bendangle = -999; }
632  }
633 
634  return bendangle;
635 
636 }
637 
638 //
639 // set precision for pt-assignment of phi and phib
640 // default is 12 bits for phi and 10 bits for phib
641 //
642 void L1MuBMAssignmentUnit::setPrecision() {
643 
644  nbit_phi = L1MuBMTFConfig::getNbitsPtaPhi();
645  nbit_phib = L1MuBMTFConfig::getNbitsPtaPhib();
646 
647 }
648 
649 
650 // static data members
651 
652 unsigned short int L1MuBMAssignmentUnit::nbit_phi = 12;
653 unsigned short int L1MuBMAssignmentUnit::nbit_phib = 10;
L1MuBMAssignmentUnit::getPtMethod
L1MuBMLUTHandler::PtAssMethod getPtMethod() const
determine pt assignment method
Definition: L1MuBMAssignmentUnit.cc:411
L1MuBMTrack::setTC
void setTC(TrackClass tc)
set track-class of muon candidate
Definition: L1MuBMTrack.h:145
L1MuBMTFConfig::getNbitsPhiPhi
static int getNbitsPhiPhi()
Definition: L1MuBMTFConfig.h:74
L1MuBMTrack::setPt
void setPt(int pt)
set pt-code of muon candidate
Definition: L1MuBMTrack.h:157
L1MuBMTFConfig::getNbitsPhiPhib
static int getNbitsPhiPhib()
Definition: L1MuBMTFConfig.h:75
L1MuBMAssignmentUnit::L1MuBMAssignmentUnit
L1MuBMAssignmentUnit(L1MuBMSectorProcessor &sp, int id)
constructor
Definition: L1MuBMAssignmentUnit.cc:54
L1MuBMAssignmentUnit::bmtfParamsHandle
edm::ESHandle< L1TMuonBarrelParams > bmtfParamsHandle
Definition: L1MuBMAssignmentUnit.h:116
L1MuBMAssignmentUnit::QuaAU
void QuaAU()
assign quality
Definition: L1MuBMAssignmentUnit.cc:264
L1MuBMLUTHandler::getPt
int getPt(int pta_ind, int address) const
get pt-value for a given address
Definition: L1MuBMLUTHandler.cc:135
HLT_25ns10e33_v2_cff.quality
tuple quality
Definition: HLT_25ns10e33_v2_cff.py:42796
relval_2017.k
list k
Definition: relval_2017.py:23
L1MuBMAssignmentUnit::PtAU
void PtAU(const edm::EventSetup &c)
assign pt and charge
Definition: L1MuBMAssignmentUnit.cc:208
L1MuBMTrack::setQuality
void setQuality(unsigned int quality)
set quality of muon candidate
Definition: L1MuBMTrack.h:166
L1MuBMTrack::setPhi
void setPhi(int phi)
set phi-code of muon candidate
Definition: L1MuBMTrack.h:148
L1MuBMAssignmentUnit::getPtAddress
int getPtAddress(L1MuBMLUTHandler::PtAssMethod, int bendcharge=0) const
calculate bend angle
Definition: L1MuBMAssignmentUnit.cc:456
L1MuBMTrack::setAddresses
void setAddresses(const L1MuBMAddressArray &addr)
set relative addresses of muon candidate
Definition: L1MuBMTrack.h:169
PFRecoTauDiscriminationAgainstElectronMVA3GBR_cfi.method
tuple method
Definition: PFRecoTauDiscriminationAgainstElectronMVA3GBR_cfi.py:15
L1MuBMTFConfig::getNbitsPtaPhi
static int getNbitsPtaPhi()
Definition: L1MuBMTFConfig.h:72
L1MuBMTrack::setCharge
void setCharge(int charge)
set charge of muon candidate
Definition: L1MuBMTrack.h:160
L1MuBMAssignmentUnit::thePtaLUTs
L1MuBMLUTHandler * thePtaLUTs
pt-assignment look-up tables
Definition: L1MuBMAssignmentUnit.h:117
L1MuBMLUTHandler::getPtLutThreshold
int getPtLutThreshold(int pta_ind) const
get pt-assignment LUT threshold
Definition: L1MuBMLUTHandler.cc:156
L1MuBMAddressArray::station
unsigned short station(int stat) const
get address of a given station [1-4]
Definition: L1MuBMAddressArray.h:82
L1MuBMAssignmentUnit::TSR
void TSR()
Track Segment Router.
Definition: L1MuBMAssignmentUnit.cc:326
L1MuBMTrack::enable
void enable()
enable muon candidate
Definition: L1MuBMTrack.h:136
L1MuBMAssignmentUnit::m_TSphi
std::vector< const L1MuBMTrackSegPhi * > m_TSphi
Definition: L1MuBMAssignmentUnit.h:113
L1MuBMAssignmentUnit::getPt1Method
L1MuBMLUTHandler::PtAssMethod getPt1Method(L1MuBMLUTHandler::PtAssMethod) const
Definition: L1MuBMAssignmentUnit.cc:532
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:250
L1MuBMSectorProcessor::tracK
L1MuBMTrack * tracK(int id) const
return pointer to muon candidate, index [0,1]
Definition: L1MuBMSectorProcessor.h:105
L1MuBMSecProcId::sector
int sector() const
return sector number
Definition: L1MuBMSecProcId.h:61
L1MuBMTrackSegPhi::phib
int phib() const
return phib
Definition: L1MuBMTrackSegPhi.h:89
L1MuBMTFConfig::getNbitsPtaPhib
static int getNbitsPtaPhib()
Definition: L1MuBMTFConfig.h:73
L1MuBMAssignmentUnit::convertSector
static int convertSector(int)
convert sector Id to 8 bit code (= sector center)
Definition: L1MuBMAssignmentUnit.cc:363
L1MuBMAssignmentUnit::thePhiLUTs
L1MuBMLUTHandler * thePhiLUTs
phi-assignment look-up tables
Definition: L1MuBMAssignmentUnit.h:118
L1MuBMAssignmentUnit::nbit_phib
static unsigned short nbit_phib
of bits used for pt-assignment
Definition: L1MuBMAssignmentUnit.h:120
L1MuBMAssignmentUnit::setPrecision
static void setPrecision()
set precision of phi and phib
Definition: L1MuBMAssignmentUnit.cc:642
L1MuBMTrackAssembler::trackClass
TrackClass trackClass(int id) const
return Track Class of found track
Definition: L1MuBMTrackAssembler.h:69
L1AbstractProcessor::run
virtual void run()
run processor logic
Definition: L1AbstractProcessor.h:42
edm::eventsetup::EventSetupRecord::get
void get(HolderT &iHolder) const
Definition: EventSetupRecord.h:93
L1MuBMAssignmentUnit::~L1MuBMAssignmentUnit
virtual ~L1MuBMAssignmentUnit()
destructor
Definition: L1MuBMAssignmentUnit.cc:69
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
L1MuBMSectorProcessor::TA
const L1MuBMTrackAssembler * TA() const
return pointer to Track Assembler
Definition: L1MuBMSectorProcessor.h:96
dtDQMClient_cfg.threshold
tuple threshold
Definition: dtDQMClient_cfg.py:16
L1MuBMTrack::setBx
void setBx(int bx)
set charge of muon candidate
Definition: L1MuBMTrack.h:163
L1MuBMSectorProcessor::id
const L1MuBMSecProcId & id() const
return Sector Processor identifier
Definition: L1MuBMSectorProcessor.h:77
L1MuBMSectorProcessor::track
L1MuBMTrack * track(int id) const
return pointer to muon candidate, index [0,1]
Definition: L1MuBMSectorProcessor.h:102
L1MuBMTrackSegPhi::phi
int phi() const
return phi
Definition: L1MuBMTrackSegPhi.h:86
L1MuBMAssignmentUnit::getPt1Address
int getPt1Address(L1MuBMLUTHandler::PtAssMethod) const
Definition: L1MuBMAssignmentUnit.cc:587
m_id
m_id("(unknown)")
L1MuBMLUTHandler::getDeltaPhi
int getDeltaPhi(int idx, int address) const
get delta-phi for a given address (bend-angle)
Definition: L1MuBMLUTHandler.cc:171
L1MuBMTrack::setTSphi
void setTSphi(const std::vector< const L1MuBMTrackSegPhi * > &tsList)
set phi track segments used to form the muon candidate
Definition: L1MuBMTrack.cc:171
edm::EventSetup::get
const T & get() const
Definition: EventSetup.h:56
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86
L1MuBMAssignmentUnit::m_addArray
L1MuBMAddressArray m_addArray
Definition: L1MuBMAssignmentUnit.h:112
L1MuBMAssignmentUnit::reset
virtual void reset()
reset Assignment Unit
Definition: L1MuBMAssignmentUnit.cc:122
L1MuBMAssignmentUnit::getTSphi
const L1MuBMTrackSegPhi * getTSphi(int station) const
get track segment from a given station
Definition: L1MuBMAssignmentUnit.cc:344
hltrates_dqm_sourceclient-live_cfg.offset
tuple offset
Definition: hltrates_dqm_sourceclient-live_cfg.py:81
L1MuBMDataBuffer::getTSphi
const TSPhivector & getTSphi() const
get all track segments from the buffer
Definition: L1MuBMDataBuffer.h:58
L1MuBMAssignmentUnit::getCharge
static int getCharge(L1MuBMLUTHandler::PtAssMethod)
determine charge
Definition: L1MuBMAssignmentUnit.cc:377
L1MuBMAddressArray::reset
void reset()
reset address array
Definition: L1MuBMAddressArray.cc:116
L1MuBMTrackAssembler::trackBitMap
const std::bitset< 4 > & trackBitMap(int id) const
return bitmap of found track
Definition: L1MuBMTrackAssembler.h:72
L1MuBMSectorProcessor::data
const L1MuBMDataBuffer * data() const
return pointer to Data Buffer
Definition: L1MuBMSectorProcessor.h:89
L1MuBMTrackSegPhi::station
int station() const
return station
Definition: L1MuBMTrackSegPhi.h:80
L1MuBMAssignmentUnit::getPt2Address
int getPt2Address(L1MuBMLUTHandler::PtAssMethod) const
Definition: L1MuBMAssignmentUnit.cc:615
L1MuBMAssignmentUnit::getPt2Method
L1MuBMLUTHandler::PtAssMethod getPt2Method(L1MuBMLUTHandler::PtAssMethod) const
Definition: L1MuBMAssignmentUnit.cc:560
L1MuBMAssignmentUnit::phiDiff
int phiDiff(int stat1, int stat2) const
build difference of two phi values
Definition: L1MuBMAssignmentUnit.cc:500
sp
Definition: sp.h:21
L1MuBMAssignmentUnit::m_sp
L1MuBMSectorProcessor & m_sp
Definition: L1MuBMAssignmentUnit.h:109
L1MuBMAssignmentUnit::PhiAU
void PhiAU(const edm::EventSetup &c)
assign phi
Definition: L1MuBMAssignmentUnit.cc:134
L1MuBMAssignmentUnit::nbit_phi
static unsigned short nbit_phi
of bits used for pt-assignment
Definition: L1MuBMAssignmentUnit.h:119
L1MuBMTrackSegPhi::sector
int sector() const
return sector
Definition: L1MuBMTrackSegPhi.h:77
L1MuBMAssignmentUnit::m_ptAssMethod
L1MuBMLUTHandler::PtAssMethod m_ptAssMethod
Definition: L1MuBMAssignmentUnit.h:114
L1MuBMTrackAssembler::address
int address(int id, int stat) const
get address of a single station of selected track candidate
Definition: L1MuBMTrackAssembler.h:78
L1MuBMTrackSegPhi::quality
int quality() const
return quality code
Definition: L1MuBMTrackSegPhi.h:92
Generated for CMSSW Reference Manual by doxygen 1.8.5