CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
List of all members | Public Member Functions | Private Member Functions | Static Private Member Functions | Private Attributes
L1MuDTTrackAssembler Class Reference

#include <L1MuDTTrackAssembler.h>

Inheritance diagram for L1MuDTTrackAssembler:
L1AbstractProcessor

Public Member Functions

int address (int id, int stat) const
 get address of a single station of selected track candidate More...
 
L1MuDTAddressArray address (int id) const
 get address-array of selected track candidate More...
 
bool isEmpty (int id) const
 is it a valid Track Class? More...
 
 L1MuDTTrackAssembler (const L1MuDTSectorProcessor &)
 constructor More...
 
void print () const
 print result of Track Assembler More...
 
virtual void reset ()
 reset Track Assembler More...
 
virtual void run ()
 run Track Assembler More...
 
const std::bitset< 4 > & trackBitMap (int id) const
 return bitmap of found track More...
 
TrackClass trackClass (int id) const
 return Track Class of found track More...
 
virtual ~L1MuDTTrackAssembler ()
 destructor More...
 
- Public Member Functions inherited from L1AbstractProcessor
virtual void run (const edm::EventSetup &c)
 
virtual ~L1AbstractProcessor ()
 destructor More...
 

Private Member Functions

void runAddressAssignment1 (int global, int group)
 run the first Address Assignment Sub-Unit More...
 
void runAddressAssignment2 (int global, int group)
 run the second Address Assignment Sub-Unit More...
 
void runEncoderSubUnit1 (unsigned &global, unsigned &group, unsigned &priority)
 run the first Priority Encoder Sub-Unit More...
 
void runEncoderSubUnit2 (unsigned &global, unsigned &group, unsigned &priority)
 run the second Priority Encoder Sub-Unit More...
 

Static Private Member Functions

static unsigned int addressEncoder12 (const std::bitset< 12 > &input)
 12 bit address encoder More...
 
static unsigned int addressEncoder12s (const std::bitset< 12 > &input)
 special 12 bit address encoder More...
 
static std::bitset< 56 > getCancelationTable (unsigned int)
 cancel Out Table More...
 
static unsigned int priorityEncoder12 (const std::bitset< 12 > &input)
 12 bit priority encoder More...
 
static unsigned int priorityEncoder21 (const std::bitset< 21 > &input)
 21 bit priority encoder More...
 
static unsigned int priorityEncoder22 (const std::bitset< 22 > &input)
 22 bit priority encoder More...
 
static unsigned int priorityEncoder4 (const std::bitset< 4 > &input)
 4 bit priority encoder More...
 
static unsigned long subBitset56 (const std::bitset< 56 > &input, int pos, int length)
 get sub-bitmap of a 56-bit word More...
 
static unsigned long subBitset68 (const std::bitset< 68 > &input, int pos, int length)
 get sub-bitmap of a 68-bit word More...
 

Private Attributes

const L1MuDTSectorProcessor & m_sp
 
L1MuDTAddressArray m_theAddresses [2]
 
std::bitset< 4 > m_theBitMaps [2]
 
unsigned int m_theLastAddress [68]
 
unsigned int m_theLastAddressI [12]
 
std::bitset< 68 > m_thePriorityTable1
 
std::bitset< 56 > m_thePriorityTable2
 
TrackClass m_theTCs [2]
 

Detailed Description

Track Assembler:

The Track Assembler gets the 18 Bitmap tables from the Quality Sorter Unit and links the corresponding track segments to full tracks

(this version corresponds to the VHDL model b_sts_7 version 7 )

Date:
2007/02/27 11:44:00
Revision:
1.2

N. Neumeister CERN EP

Definition at line 51 of file L1MuDTTrackAssembler.h.

Constructor & Destructor Documentation

L1MuDTTrackAssembler::L1MuDTTrackAssembler ( const L1MuDTSectorProcessor &  sp)

constructor

Definition at line 47 of file L1MuDTTrackAssembler.cc.

47  :
48  m_sp(sp) {
49 
50 
51 }
L1MuDTTrackAssembler::m_sp
const L1MuDTSectorProcessor & m_sp
Definition: L1MuDTTrackAssembler.h:128
L1MuDTTrackAssembler::~L1MuDTTrackAssembler ( )
virtual

destructor

Definition at line 58 of file L1MuDTTrackAssembler.cc.

58  {
59 
60 }

Member Function Documentation

int L1MuDTTrackAssembler::address ( int  id,
int  stat 
) const
inline

get address of a single station of selected track candidate

Definition at line 80 of file L1MuDTTrackAssembler.h.

References ExpressReco_HICollisions_FallBack::id, m_theAddresses, and L1MuDTAddressArray::station().

Referenced by L1MuDTAssignmentUnit::run().

80 { return m_theAddresses[id].station(stat); }
L1MuDTTrackAssembler::m_theAddresses
L1MuDTAddressArray m_theAddresses[2]
Definition: L1MuDTTrackAssembler.h:137
ExpressReco_HICollisions_FallBack.id
tuple id
Definition: ExpressReco_HICollisions_FallBack.py:9307
L1MuDTAddressArray::station
unsigned short station(int stat) const
get address of a given station [1-4]
Definition: L1MuDTAddressArray.h:84
L1MuDTAddressArray L1MuDTTrackAssembler::address ( int  id) const
inline

get address-array of selected track candidate

Definition at line 83 of file L1MuDTTrackAssembler.h.

References ExpressReco_HICollisions_FallBack::id, and m_theAddresses.

83 { return m_theAddresses[id]; }
L1MuDTTrackAssembler::m_theAddresses
L1MuDTAddressArray m_theAddresses[2]
Definition: L1MuDTTrackAssembler.h:137
ExpressReco_HICollisions_FallBack.id
tuple id
Definition: ExpressReco_HICollisions_FallBack.py:9307
unsigned int L1MuDTTrackAssembler::addressEncoder12 ( const std::bitset< 12 > &  input)
staticprivate

12 bit address encoder

Definition at line 1006 of file L1MuDTTrackAssembler.cc.

References i, and query::result.

Referenced by run().

1006  {
1007 
1008  // inverse order priority encoder
1009 
1010  unsigned int result = 15;
1011 
1012  for ( int i = 0; i < 12; i++ ) {
1013  if ( input.test(i) ) {
1014  result = i;
1015  break;
1016  }
1017  }
1018 
1019  return result;
1020 
1021 }
i
int i
Definition: DBlmapReader.cc:9
query.result
tuple result
Definition: query.py:137
collect_tpl.input
tuple input
Definition: collect_tpl.py:10
unsigned int L1MuDTTrackAssembler::addressEncoder12s ( const std::bitset< 12 > &  input)
staticprivate

special 12 bit address encoder

Definition at line 1027 of file L1MuDTTrackAssembler.cc.

References i, and query::result.

Referenced by run().

1027  {
1028 
1029  // inverse order priority encoder which prefers second addresses
1030 
1031  unsigned int result = 15;
1032 
1033  for ( int i = 0; i < 11; i += 2 ) {
1034  if ( input.test(i) || input.test(i+1) ) {
1035  if ( input.test(i) ) result = i;
1036  if ( input.test(i+1) ) result = i+1;
1037  break;
1038  }
1039  }
1040 
1041  return result;
1042 
1043 }
i
int i
Definition: DBlmapReader.cc:9
query.result
tuple result
Definition: query.py:137
collect_tpl.input
tuple input
Definition: collect_tpl.py:10
bitset< 56 > L1MuDTTrackAssembler::getCancelationTable ( unsigned int  p)
staticprivate

cancel Out Table

Definition at line 1080 of file L1MuDTTrackAssembler.cc.

References b.

Referenced by run().

1080  {
1081 
1082  // Cancellation Table
1083  // Each 0 in this Table means a sub-track of the
1084  // previous found Track
1085 
1086  switch ( p ) {
1087  case 67 : { bitset<56> b(string("00000111111100000111000001110000011100000111010101010101")); return b; break; }
1088  case 66 : { bitset<56> b(string("00001011111100000111000001110000101100001011010101010110")); return b; break; }
1089  case 65 : { bitset<56> b(string("00001101010100000111000001110000110100001101010101010111")); return b; break; }
1090  case 64 : { bitset<56> b(string("00001110101000000111000001110000111000001110010101010111")); return b; break; }
1091  case 63 : { bitset<56> b(string("01110000111100001011000010110000011101110000010101101001")); return b; break; }
1092  case 62 : { bitset<56> b(string("10110000111100001011000010110000101110110000010101101010")); return b; break; }
1093  case 61 : { bitset<56> b(string("11010000111100001011000010110000110111010000010101101011")); return b; break; }
1094  case 60 : { bitset<56> b(string("11100000111100001011000010110000111011100000010101101011")); return b; break; }
1095  case 59 : { bitset<56> b(string("11011101000100001101000011010000110111011101010101111111")); return b; break; }
1096  case 58 : { bitset<56> b(string("11101110001000001101000011010000111011101110010101111111")); return b; break; }
1097  case 57 : { bitset<56> b(string("11011101010000001110000011100000110111011101010101111111")); return b; break; }
1098  case 56 : { bitset<56> b(string("11101110100000001110000011100000111011101110010101111111")); return b; break; }
1099 
1100  case 55 : { bitset<56> b(string("00000000000001110000011100000111000000000111101010010101")); return b; break; }
1101  case 54 : { bitset<56> b(string("00000000000001110000011100001011000000001011101010010110")); return b; break; }
1102  case 53 : { bitset<56> b(string("00000000000001110000011100001101000000001101101010010111")); return b; break; }
1103  case 52 : { bitset<56> b(string("00000000000001110000011100001110000000001110101010010111")); return b; break; }
1104  case 51 : { bitset<56> b(string("00000000000010110000101100000111000001110000101010101001")); return b; break; }
1105  case 50 : { bitset<56> b(string("00000000000010110000101100001011000010110000101010101010")); return b; break; }
1106  case 49 : { bitset<56> b(string("00000000000010110000101100001101000011010000101010101011")); return b; break; }
1107  case 48 : { bitset<56> b(string("00000000000010110000101100001110000011100000101010101011")); return b; break; }
1108  case 47 : { bitset<56> b(string("00000000000011010000110100001101000011011101101010111111")); return b; break; }
1109  case 46 : { bitset<56> b(string("00000000000011010000110100001110000011101110101010111111")); return b; break; }
1110  case 45 : { bitset<56> b(string("00000000000011100000111000001101000011011101101010111111")); return b; break; }
1111  case 44 : { bitset<56> b(string("00000000000011100000111000001110000011101110101010111111")); return b; break; }
1112 
1113  case 43 : { bitset<56> b(string("00000000000000000111000001110000111100001111010101010111")); return b; break; }
1114  case 42 : { bitset<56> b(string("00000000000000001011000010110000111111110000010101101011")); return b; break; }
1115  case 41 : { bitset<56> b(string("00000000000000001101000011010000111111111111010101111111")); return b; break; }
1116  case 40 : { bitset<56> b(string("00000000000000001110000011100000111111111111010101111111")); return b; break; }
1117 
1118  case 39 : { bitset<56> b(string("00000000000000000000011100001111000000001111101010010111")); return b; break; }
1119  case 38 : { bitset<56> b(string("00000000000000000000101100001111000011110000101010101011")); return b; break; }
1120  case 37 : { bitset<56> b(string("00000000000000000000110100001111000011111111101010111111")); return b; break; }
1121  case 36 : { bitset<56> b(string("00000000000000000000111000001111000011111111101010111111")); return b; break; }
1122 
1123  case 35 : { bitset<56> b(string("00000000000000000000000001110000111100001111010101010111")); return b; break; }
1124  case 34 : { bitset<56> b(string("00000000000000000000000010110000111111110000010101101011")); return b; break; }
1125  case 33 : { bitset<56> b(string("00000000000000000000000011010000111111111111010101111111")); return b; break; }
1126  case 32 : { bitset<56> b(string("00000000000000000000000011100000111111111111010101111111")); return b; break; }
1127 
1128  case 31 : { bitset<56> b(string("00000000000000000000011100001111000000001111101010010111")); return b; break; }
1129  case 30 : { bitset<56> b(string("00000000000000000000101100001111000011110000101010101011")); return b; break; }
1130  case 29 : { bitset<56> b(string("00000000000000000000110100001111000011111111101010111111")); return b; break; }
1131  case 28 : { bitset<56> b(string("00000000000000000000111000001111000011111111101010111111")); return b; break; }
1132 
1133  case 27 : { bitset<56> b(string("00000000000000000000000000000000011101110111010101111101")); return b; break; }
1134  case 26 : { bitset<56> b(string("00000000000000000000000000000000101110111011010101111110")); return b; break; }
1135  case 25 : { bitset<56> b(string("00000000000000000000000000000000110111011101010101111111")); return b; break; }
1136  case 24 : { bitset<56> b(string("00000000000000000000000000000000111011101110010101111111")); return b; break; }
1137 
1138  case 23 : { bitset<56> b(string("00000000000000000000000000000000000001110111101010111101")); return b; break; }
1139  case 22 : { bitset<56> b(string("00000000000000000000000000000000000010111011101010111110")); return b; break; }
1140  case 21 : { bitset<56> b(string("00000000000000000000000000000000000011011101101010111111")); return b; break; }
1141  case 20 : { bitset<56> b(string("00000000000000000000000000000000000011101110101010111111")); return b; break; }
1142 
1143  case 19 : { bitset<56> b(string("00000000000000000000000000000000000000000111111111010101")); return b; break; }
1144  case 18 : { bitset<56> b(string("00000000000000000000000000000000000000001011111111010110")); return b; break; }
1145  case 17 : { bitset<56> b(string("00000000000000000000000000000000000000001101111111010111")); return b; break; }
1146  case 16 : { bitset<56> b(string("00000000000000000000000000000000000000001110111111010111")); return b; break; }
1147 
1148  case 15 : { bitset<56> b(string("00000000000000000000000000000000000000000000111111101001")); return b; break; }
1149  case 14 : { bitset<56> b(string("00000000000000000000000000000000000000000000111111101010")); return b; break; }
1150  case 13 : { bitset<56> b(string("00000000000000000000000000000000000000000000111111101011")); return b; break; }
1151  case 12 : { bitset<56> b(string("00000000000000000000000000000000000000000000111111101011")); return b; break; }
1152 
1153  case 11 : { bitset<56> b(string("00000000000000000000000000000000000000000000010101111111")); return b; break; }
1154  case 10 : { bitset<56> b(string("00000000000000000000000000000000000000000000001010111111")); return b; break; }
1155 
1156  case 9 : { bitset<56> b(string("00000000000000000000000000000000000000000000000101111111")); return b; break; }
1157  case 8 : { bitset<56> b(string("00000000000000000000000000000000000000000000000010111111")); return b; break; }
1158 
1159  case 7 : { bitset<56> b(string("00000000000000000000000000000000000000000000000001111111")); return b; break; }
1160  case 6 : { bitset<56> b(string("00000000000000000000000000000000000000000000000000111111")); return b; break; }
1161 
1162  case 5 : { bitset<56> b(string("00000000000000000000000000000000000000000000000000010111")); return b; break; }
1163  case 4 : { bitset<56> b(string("00000000000000000000000000000000000000000000000000001011")); return b; break; }
1164 
1165  case 3 : { bitset<56> b(string("00000000000000000000000000000000000000000000000000000111")); return b; break; }
1166  case 2 : { bitset<56> b(string("00000000000000000000000000000000000000000000000000000011")); return b; break; }
1167 
1168  case 1 : { bitset<56> b(string("00000000000000000000000000000000000000000000000000000001")); return b; break; }
1169  case 0 : { bitset<56> b(string("00000000000000000000000000000000000000000000000000000000")); return b; break; }
1170  default : { bitset<56> b; return b; break; }
1171 
1172  }
1173 
1174 }
b
double b
Definition: hdecay.h:120
L1TEmulatorMonitor_cff.p
tuple p
Definition: L1TEmulatorMonitor_cff.py:48
bool L1MuDTTrackAssembler::isEmpty ( int  id) const
inline

is it a valid Track Class?

Definition at line 77 of file L1MuDTTrackAssembler.h.

References m_theTCs, and UNDEF.

Referenced by L1MuDTSectorProcessor::run().

77 { return (m_theTCs[id] == UNDEF); }
void L1MuDTTrackAssembler::print ( void  ) const

print result of Track Assembler

Definition at line 478 of file L1MuDTTrackAssembler.cc.

References gather_cfg::cout, m_theAddresses, m_theBitMaps, m_thePriorityTable1, m_thePriorityTable2, and m_theTCs.

Referenced by run(), and L1MuDTSectorProcessor::run().

478  {
479 
480  cout << "Track Assembler : " << endl;
481  cout << " Priority Table 1 : " << m_thePriorityTable1 << endl;
482  cout << " Priority Table 2 : " << " " << m_thePriorityTable2 << endl;
483 
484  // print result
485  cout << "Track 1: " << m_theTCs[0] << " " << m_theBitMaps[0] << '\t' << m_theAddresses[0] << endl;
486  cout << "Track 2: " << m_theTCs[1] << " " << m_theBitMaps[1] << '\t' << m_theAddresses[1] << endl;
487 
488 }
L1MuDTTrackAssembler::m_theAddresses
L1MuDTAddressArray m_theAddresses[2]
Definition: L1MuDTTrackAssembler.h:137
L1MuDTTrackAssembler::m_theBitMaps
std::bitset< 4 > m_theBitMaps[2]
Definition: L1MuDTTrackAssembler.h:136
L1MuDTTrackAssembler::m_thePriorityTable1
std::bitset< 68 > m_thePriorityTable1
Definition: L1MuDTTrackAssembler.h:130
L1MuDTTrackAssembler::m_thePriorityTable2
std::bitset< 56 > m_thePriorityTable2
Definition: L1MuDTTrackAssembler.h:131
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:41
unsigned int L1MuDTTrackAssembler::priorityEncoder12 ( const std::bitset< 12 > &  input)
staticprivate

12 bit priority encoder

Definition at line 942 of file L1MuDTTrackAssembler.cc.

References i, and query::result.

Referenced by runEncoderSubUnit1(), and runEncoderSubUnit2().

942  {
943 
944  unsigned int result = 15;
945 
946  for ( int i = 0; i < 12; i++ ) {
947  if ( input.test(i) ) result = i;
948  }
949 
950  return result;
951 
952 }
i
int i
Definition: DBlmapReader.cc:9
query.result
tuple result
Definition: query.py:137
collect_tpl.input
tuple input
Definition: collect_tpl.py:10
unsigned int L1MuDTTrackAssembler::priorityEncoder21 ( const std::bitset< 21 > &  input)
staticprivate

21 bit priority encoder

Definition at line 990 of file L1MuDTTrackAssembler.cc.

References i, and query::result.

Referenced by runEncoderSubUnit2().

990  {
991 
992  unsigned int result = 31;
993 
994  for ( int i = 0; i < 21; i++ ) {
995  if ( input.test(i) ) result = i;
996  }
997 
998  return result;
999 
1000 }
i
int i
Definition: DBlmapReader.cc:9
query.result
tuple result
Definition: query.py:137
collect_tpl.input
tuple input
Definition: collect_tpl.py:10
unsigned int L1MuDTTrackAssembler::priorityEncoder22 ( const std::bitset< 22 > &  input)
staticprivate

22 bit priority encoder

Definition at line 974 of file L1MuDTTrackAssembler.cc.

References i, and query::result.

Referenced by runEncoderSubUnit1().

974  {
975 
976  unsigned int result = 31;
977 
978  for ( int i = 0; i < 22; i++ ) {
979  if ( input.test(i) ) result = i;
980  }
981 
982  return result;
983 
984 }
i
int i
Definition: DBlmapReader.cc:9
query.result
tuple result
Definition: query.py:137
collect_tpl.input
tuple input
Definition: collect_tpl.py:10
unsigned int L1MuDTTrackAssembler::priorityEncoder4 ( const std::bitset< 4 > &  input)
staticprivate

4 bit priority encoder

Definition at line 958 of file L1MuDTTrackAssembler.cc.

References i, and query::result.

Referenced by runEncoderSubUnit1(), and runEncoderSubUnit2().

958  {
959 
960  unsigned int result = 3;
961 
962  for ( int i = 0; i < 4; i++ ) {
963  if ( input.test(i) ) result = i;
964  }
965 
966  return result;
967 
968 }
i
int i
Definition: DBlmapReader.cc:9
query.result
tuple result
Definition: query.py:137
collect_tpl.input
tuple input
Definition: collect_tpl.py:10
void L1MuDTTrackAssembler::reset ( void  )
virtual

reset Track Assembler

Implements L1AbstractProcessor.

Definition at line 459 of file L1MuDTTrackAssembler.cc.

References i, j, m_theAddresses, m_theBitMaps, m_theLastAddress, m_theLastAddressI, m_thePriorityTable1, m_thePriorityTable2, m_theTCs, L1MuDTAddressArray::reset(), and UNDEF.

Referenced by L1MuDTSectorProcessor::reset().

459  {
460 
461  for ( int i = 0; i < 68; i++ ) m_theLastAddress[i] = 15;
462  for ( int j = 0; j < 12; j++ ) m_theLastAddressI[j] = 15;
463  m_thePriorityTable1.reset();
464  m_thePriorityTable2.reset();
465  m_theTCs[0] = UNDEF;
466  m_theTCs[1] = UNDEF;
467  m_theBitMaps[0].reset();
468  m_theBitMaps[1].reset();
469  m_theAddresses[0].reset();
470  m_theAddresses[1].reset();
471 
472 }
i
int i
Definition: DBlmapReader.cc:9
L1MuDTAddressArray::reset
void reset()
reset address array
Definition: L1MuDTAddressArray.cc:118
L1MuDTTrackAssembler::m_theAddresses
L1MuDTAddressArray m_theAddresses[2]
Definition: L1MuDTTrackAssembler.h:137
L1MuDTTrackAssembler::m_theLastAddress
unsigned int m_theLastAddress[68]
Definition: L1MuDTTrackAssembler.h:132
j
int j
Definition: DBlmapReader.cc:9
L1MuDTTrackAssembler::m_theBitMaps
std::bitset< 4 > m_theBitMaps[2]
Definition: L1MuDTTrackAssembler.h:136
L1MuDTTrackAssembler::m_thePriorityTable1
std::bitset< 68 > m_thePriorityTable1
Definition: L1MuDTTrackAssembler.h:130
L1MuDTTrackAssembler::m_theLastAddressI
unsigned int m_theLastAddressI[12]
Definition: L1MuDTTrackAssembler.h:133
L1MuDTTrackAssembler::m_thePriorityTable2
std::bitset< 56 > m_thePriorityTable2
Definition: L1MuDTTrackAssembler.h:131
void L1MuDTTrackAssembler::run ( void  )
virtual

run Track Assembler

Reimplemented from L1AbstractProcessor.

Definition at line 70 of file L1MuDTTrackAssembler.cc.

References addressEncoder12(), addressEncoder12s(), gather_cfg::cout, L1MuDTTFConfig::Debug(), L1MuDTSectorProcessor::EU(), EX12, EX13, EX14, EX23, EX24, EX34, getCancelationTable(), L1MuDTExtrapolationUnit::getQSTable(), i, m_sp, m_theAddresses, m_theBitMaps, m_theLastAddress, m_theLastAddressI, m_thePriorityTable1, m_thePriorityTable2, m_theTCs, p1, p2, print(), L1MuDTAddressArray::reset(), runAddressAssignment1(), runAddressAssignment2(), runEncoderSubUnit1(), runEncoderSubUnit2(), L1MuDTAddressArray::setStation(), relativeConstraints::station, L1MuDTAddressArray::station(), T12, T123, T1234, T124, T13, T134, T14, T23, T234, T24, T34, and UNDEF.

Referenced by L1MuDTSectorProcessor::run().

70  {
71 
72  // get the 18 bitmap tables from the Quality Sorter Unit
73 
74  bitset<12> b_adr12_8 = m_sp.EU()->getQSTable(EX12, 0);
75  bitset<12> b_adr12_9 = m_sp.EU()->getQSTable(EX12, 1);
76  bitset<12> b_adr13_8 = m_sp.EU()->getQSTable(EX13, 0);
77  bitset<12> b_adr13_9 = m_sp.EU()->getQSTable(EX13, 1);
78  bitset<12> b_adr14_8 = m_sp.EU()->getQSTable(EX14, 0);
79  bitset<12> b_adr14_9 = m_sp.EU()->getQSTable(EX14, 1);
80  bitset<12> b_adr23_8 = m_sp.EU()->getQSTable(EX23, 0);
81  bitset<12> b_adr23_9 = m_sp.EU()->getQSTable(EX23, 1);
82  bitset<12> b_adr23_0 = m_sp.EU()->getQSTable(EX23, 2);
83  bitset<12> b_adr23_1 = m_sp.EU()->getQSTable(EX23, 3);
84  bitset<12> b_adr24_8 = m_sp.EU()->getQSTable(EX24, 0);
85  bitset<12> b_adr24_9 = m_sp.EU()->getQSTable(EX24, 1);
86  bitset<12> b_adr24_0 = m_sp.EU()->getQSTable(EX24, 2);
87  bitset<12> b_adr24_1 = m_sp.EU()->getQSTable(EX24, 3);
88  bitset<12> b_adr34_8 = m_sp.EU()->getQSTable(EX34, 0);
89  bitset<12> b_adr34_9 = m_sp.EU()->getQSTable(EX34, 1);
90  bitset<12> b_adr34_0 = m_sp.EU()->getQSTable(EX34, 2);
91  bitset<12> b_adr34_1 = m_sp.EU()->getQSTable(EX34, 3);
92 
93 
94  // Last segment node building
95 
96  bitset<12> n_1234_888 = ( b_adr14_8 & b_adr24_8 & b_adr34_8 );
97  bitset<12> n_1234_889 = ( b_adr14_8 & b_adr24_8 & b_adr34_9 );
98  bitset<12> n_1234_880 = ( b_adr14_8 & b_adr24_8 & b_adr34_0 );
99  bitset<12> n_1234_881 = ( b_adr14_8 & b_adr24_8 & b_adr34_1 );
100  bitset<12> n_1234_898 = ( b_adr14_8 & b_adr24_9 & b_adr34_8 );
101  bitset<12> n_1234_899 = ( b_adr14_8 & b_adr24_9 & b_adr34_9 );
102  bitset<12> n_1234_890 = ( b_adr14_8 & b_adr24_9 & b_adr34_0 );
103  bitset<12> n_1234_891 = ( b_adr14_8 & b_adr24_9 & b_adr34_1 );
104  bitset<12> n_1234_800 = ( b_adr14_8 & b_adr24_0 & b_adr34_0 );
105  bitset<12> n_1234_801 = ( b_adr14_8 & b_adr24_0 & b_adr34_1 );
106  bitset<12> n_1234_810 = ( b_adr14_8 & b_adr24_1 & b_adr34_0 );
107  bitset<12> n_1234_811 = ( b_adr14_8 & b_adr24_1 & b_adr34_1 );
108 
109  bitset<12> n_1234_988 = ( b_adr14_9 & b_adr24_8 & b_adr34_8 );
110  bitset<12> n_1234_989 = ( b_adr14_9 & b_adr24_8 & b_adr34_9 );
111  bitset<12> n_1234_980 = ( b_adr14_9 & b_adr24_8 & b_adr34_0 );
112  bitset<12> n_1234_981 = ( b_adr14_9 & b_adr24_8 & b_adr34_1 );
113  bitset<12> n_1234_998 = ( b_adr14_9 & b_adr24_9 & b_adr34_8 );
114  bitset<12> n_1234_999 = ( b_adr14_9 & b_adr24_9 & b_adr34_9 );
115  bitset<12> n_1234_990 = ( b_adr14_9 & b_adr24_9 & b_adr34_0 );
116  bitset<12> n_1234_991 = ( b_adr14_9 & b_adr24_9 & b_adr34_1 );
117  bitset<12> n_1234_900 = ( b_adr14_9 & b_adr24_0 & b_adr34_0 );
118  bitset<12> n_1234_901 = ( b_adr14_9 & b_adr24_0 & b_adr34_1 );
119  bitset<12> n_1234_910 = ( b_adr14_9 & b_adr24_1 & b_adr34_0 );
120  bitset<12> n_1234_911 = ( b_adr14_9 & b_adr24_1 & b_adr34_1 );
121 
122  bitset<12> n_123_88 = ( b_adr13_8 & b_adr23_8 );
123  bitset<12> n_123_89 = ( b_adr13_8 & b_adr23_9 );
124  bitset<12> n_123_80 = ( b_adr13_8 & b_adr23_0 );
125  bitset<12> n_123_81 = ( b_adr13_8 & b_adr23_1 );
126 
127  bitset<12> n_123_98 = ( b_adr13_9 & b_adr23_8 );
128  bitset<12> n_123_99 = ( b_adr13_9 & b_adr23_9 );
129  bitset<12> n_123_90 = ( b_adr13_9 & b_adr23_0 );
130  bitset<12> n_123_91 = ( b_adr13_9 & b_adr23_1 );
131 
132  bitset<12> n_124_88 = ( b_adr14_8 & b_adr24_8 );
133  bitset<12> n_124_89 = ( b_adr14_8 & b_adr24_9 );
134  bitset<12> n_124_80 = ( b_adr14_8 & b_adr24_0 );
135  bitset<12> n_124_81 = ( b_adr14_8 & b_adr24_1 );
136 
137  bitset<12> n_124_98 = ( b_adr14_9 & b_adr24_8 );
138  bitset<12> n_124_99 = ( b_adr14_9 & b_adr24_9 );
139  bitset<12> n_124_90 = ( b_adr14_9 & b_adr24_0 );
140  bitset<12> n_124_91 = ( b_adr14_9 & b_adr24_1 );
141 
142  bitset<12> n_134_88 = ( b_adr14_8 & b_adr34_8 );
143  bitset<12> n_134_89 = ( b_adr14_8 & b_adr34_9 );
144  bitset<12> n_134_80 = ( b_adr14_8 & b_adr34_0 );
145  bitset<12> n_134_81 = ( b_adr14_8 & b_adr34_1 );
146 
147  bitset<12> n_134_98 = ( b_adr14_9 & b_adr34_8 );
148  bitset<12> n_134_99 = ( b_adr14_9 & b_adr34_9 );
149  bitset<12> n_134_90 = ( b_adr14_9 & b_adr34_0 );
150  bitset<12> n_134_91 = ( b_adr14_9 & b_adr34_1 );
151 
152  bitset<12> n_234_88 = ( b_adr24_8 & b_adr34_8 );
153  bitset<12> n_234_89 = ( b_adr24_8 & b_adr34_9 );
154  bitset<12> n_234_80 = ( b_adr24_8 & b_adr34_0 );
155  bitset<12> n_234_81 = ( b_adr24_8 & b_adr34_1 );
156 
157  bitset<12> n_234_98 = ( b_adr24_9 & b_adr34_8 );
158  bitset<12> n_234_99 = ( b_adr24_9 & b_adr34_9 );
159  bitset<12> n_234_90 = ( b_adr24_9 & b_adr34_0 );
160  bitset<12> n_234_91 = ( b_adr24_9 & b_adr34_1 );
161 
162  bitset<12> n_12_8 = b_adr12_8;
163  bitset<12> n_12_9 = b_adr12_9;
164 
165  bitset<12> n_13_8 = b_adr13_8;
166  bitset<12> n_13_9 = b_adr13_9;
167 
168  bitset<12> n_14_8 = b_adr14_8;
169  bitset<12> n_14_9 = b_adr14_9;
170 
171  bitset<12> n_23_8 = b_adr23_8;
172  bitset<12> n_23_9 = b_adr23_9;
173 
174  bitset<12> n_24_8 = b_adr24_8;
175  bitset<12> n_24_9 = b_adr24_9;
176 
177  bitset<12> n_34_8 = b_adr34_8;
178  bitset<12> n_34_9 = b_adr34_9;
179 
180  // Last address encoders
181 
182  m_theLastAddress[67] = addressEncoder12(n_1234_888);
183  m_theLastAddress[66] = addressEncoder12(n_1234_889);
184  m_theLastAddress[65] = addressEncoder12(n_1234_880);
185  m_theLastAddress[64] = addressEncoder12(n_1234_881);
186 
187  m_theLastAddress[63] = addressEncoder12(n_1234_898);
188  m_theLastAddress[62] = addressEncoder12(n_1234_899);
189  m_theLastAddress[61] = addressEncoder12(n_1234_890);
190  m_theLastAddress[60] = addressEncoder12(n_1234_891);
191 
192  m_theLastAddress[59] = addressEncoder12(n_1234_800);
193  m_theLastAddress[58] = addressEncoder12(n_1234_801);
194  m_theLastAddress[57] = addressEncoder12(n_1234_810);
195  m_theLastAddress[56] = addressEncoder12(n_1234_811);
196 
197  m_theLastAddress[55] = addressEncoder12(n_1234_988);
198  m_theLastAddress[54] = addressEncoder12(n_1234_989);
199  m_theLastAddress[53] = addressEncoder12(n_1234_980);
200  m_theLastAddress[52] = addressEncoder12(n_1234_981);
201 
202  m_theLastAddress[51] = addressEncoder12(n_1234_998);
203  m_theLastAddress[50] = addressEncoder12(n_1234_999);
204  m_theLastAddress[49] = addressEncoder12(n_1234_990);
205  m_theLastAddress[48] = addressEncoder12(n_1234_991);
206 
207  m_theLastAddress[47] = addressEncoder12(n_1234_900);
208  m_theLastAddress[46] = addressEncoder12(n_1234_901);
209  m_theLastAddress[45] = addressEncoder12(n_1234_910);
210  m_theLastAddress[44] = addressEncoder12(n_1234_911);
211 
212  m_theLastAddress[43] = addressEncoder12(n_123_88);
213  m_theLastAddress[42] = addressEncoder12(n_123_89);
214  m_theLastAddress[41] = addressEncoder12(n_123_80);
215  m_theLastAddress[40] = addressEncoder12(n_123_81);
216 
217  m_theLastAddress[39] = addressEncoder12(n_123_98);
218  m_theLastAddress[38] = addressEncoder12(n_123_99);
219  m_theLastAddress[37] = addressEncoder12(n_123_90);
220  m_theLastAddress[36] = addressEncoder12(n_123_91);
221 
222  m_theLastAddress[35] = addressEncoder12(n_124_88);
223  m_theLastAddress[34] = addressEncoder12(n_124_89);
224  m_theLastAddress[33] = addressEncoder12(n_124_80);
225  m_theLastAddress[32] = addressEncoder12(n_124_81);
226 
227  m_theLastAddress[31] = addressEncoder12(n_124_98);
228  m_theLastAddress[30] = addressEncoder12(n_124_99);
229  m_theLastAddress[29] = addressEncoder12(n_124_90);
230  m_theLastAddress[28] = addressEncoder12(n_124_91);
231 
232  m_theLastAddress[27] = addressEncoder12(n_134_88);
233  m_theLastAddress[26] = addressEncoder12(n_134_89);
234  m_theLastAddress[25] = addressEncoder12(n_134_80);
235  m_theLastAddress[24] = addressEncoder12(n_134_81);
236 
237  m_theLastAddress[23] = addressEncoder12(n_134_98);
238  m_theLastAddress[22] = addressEncoder12(n_134_99);
239  m_theLastAddress[21] = addressEncoder12(n_134_90);
240  m_theLastAddress[20] = addressEncoder12(n_134_91);
241 
242  m_theLastAddress[19] = addressEncoder12(n_234_88);
243  m_theLastAddress[18] = addressEncoder12(n_234_89);
244  m_theLastAddress[17] = addressEncoder12(n_234_80);
245  m_theLastAddress[16] = addressEncoder12(n_234_81);
246 
247  m_theLastAddress[15] = addressEncoder12(n_234_98);
248  m_theLastAddress[14] = addressEncoder12(n_234_99);
249  m_theLastAddress[13] = addressEncoder12(n_234_90);
250  m_theLastAddress[12] = addressEncoder12(n_234_91);
251 
252  m_theLastAddress[11] = addressEncoder12(n_12_8);
253  m_theLastAddress[10] = addressEncoder12(n_12_9);
254 
255  m_theLastAddress[9] = addressEncoder12(n_13_8);
256  m_theLastAddress[8] = addressEncoder12(n_13_9);
257 
258  m_theLastAddress[7] = addressEncoder12(n_14_8);
259  m_theLastAddress[6] = addressEncoder12(n_14_9);
260 
261  m_theLastAddress[5] = addressEncoder12(n_23_8);
262  m_theLastAddress[4] = addressEncoder12(n_23_9);
263 
264  m_theLastAddress[3] = addressEncoder12(n_24_8);
265  m_theLastAddress[2] = addressEncoder12(n_24_9);
266 
267  m_theLastAddress[1] = addressEncoder12(n_34_8);
268  m_theLastAddress[0] = addressEncoder12(n_34_9);
269 
270  m_theLastAddressI[11] = addressEncoder12s(n_12_8);
271  m_theLastAddressI[10] = addressEncoder12s(n_12_9);
272  m_theLastAddressI[9] = addressEncoder12s(n_13_8);
273  m_theLastAddressI[8] = addressEncoder12s(n_13_9);
274  m_theLastAddressI[7] = addressEncoder12s(n_14_8);
275  m_theLastAddressI[6] = addressEncoder12s(n_14_9);
276  m_theLastAddressI[5] = addressEncoder12s(n_23_8);
277  m_theLastAddressI[4] = addressEncoder12s(n_23_9);
278  m_theLastAddressI[3] = addressEncoder12s(n_24_8);
279  m_theLastAddressI[2] = addressEncoder12s(n_24_9);
280  m_theLastAddressI[1] = addressEncoder12s(n_34_8);
281  m_theLastAddressI[0] = addressEncoder12s(n_34_9);
282 
283  // Main equations (68)
284 
285  m_thePriorityTable1[67] = ( b_adr12_8[0] & b_adr13_8[0] & b_adr23_8[0] & n_1234_888.any() );
286  m_thePriorityTable1[66] = ( b_adr12_8[0] & b_adr13_8[1] & b_adr23_8[1] & n_1234_889.any() );
287  m_thePriorityTable1[65] = ( b_adr12_8[0] & b_adr13_8[2] & b_adr23_8[2] & n_1234_880.any() );
288  m_thePriorityTable1[64] = ( b_adr12_8[0] & b_adr13_8[3] & b_adr23_8[3] & n_1234_881.any() );
289  m_thePriorityTable1[63] = ( b_adr12_8[1] & b_adr13_8[0] & b_adr23_9[0] & n_1234_898.any() );
290  m_thePriorityTable1[62] = ( b_adr12_8[1] & b_adr13_8[1] & b_adr23_9[1] & n_1234_899.any() );
291  m_thePriorityTable1[61] = ( b_adr12_8[1] & b_adr13_8[2] & b_adr23_9[2] & n_1234_890.any() );
292  m_thePriorityTable1[60] = ( b_adr12_8[1] & b_adr13_8[3] & b_adr23_9[3] & n_1234_891.any() );
293  m_thePriorityTable1[59] = ( b_adr12_8[2] & b_adr13_8[2] & b_adr23_0[2] & n_1234_800.any() );
294  m_thePriorityTable1[58] = ( b_adr12_8[2] & b_adr13_8[3] & b_adr23_0[3] & n_1234_801.any() );
295  m_thePriorityTable1[57] = ( b_adr12_8[3] & b_adr13_8[2] & b_adr23_1[2] & n_1234_810.any() );
296  m_thePriorityTable1[56] = ( b_adr12_8[3] & b_adr13_8[3] & b_adr23_1[3] & n_1234_811.any() );
297 
298  m_thePriorityTable1[55] = ( b_adr12_9[0] & b_adr13_9[0] & b_adr23_8[0] & n_1234_988.any() );
299  m_thePriorityTable1[54] = ( b_adr12_9[0] & b_adr13_9[1] & b_adr23_8[1] & n_1234_989.any() );
300  m_thePriorityTable1[53] = ( b_adr12_9[0] & b_adr13_9[2] & b_adr23_8[2] & n_1234_980.any() );
301  m_thePriorityTable1[52] = ( b_adr12_9[0] & b_adr13_9[3] & b_adr23_8[3] & n_1234_981.any() );
302  m_thePriorityTable1[51] = ( b_adr12_9[1] & b_adr13_9[0] & b_adr23_9[0] & n_1234_998.any() );
303  m_thePriorityTable1[50] = ( b_adr12_9[1] & b_adr13_9[1] & b_adr23_9[1] & n_1234_999.any() );
304  m_thePriorityTable1[49] = ( b_adr12_9[1] & b_adr13_9[2] & b_adr23_9[2] & n_1234_990.any() );
305  m_thePriorityTable1[48] = ( b_adr12_9[1] & b_adr13_9[3] & b_adr23_9[3] & n_1234_991.any() );
306  m_thePriorityTable1[47] = ( b_adr12_9[2] & b_adr13_9[2] & b_adr23_0[2] & n_1234_900.any() );
307  m_thePriorityTable1[46] = ( b_adr12_9[2] & b_adr13_9[3] & b_adr23_0[3] & n_1234_901.any() );
308  m_thePriorityTable1[45] = ( b_adr12_9[3] & b_adr13_9[2] & b_adr23_1[2] & n_1234_910.any() );
309  m_thePriorityTable1[44] = ( b_adr12_9[3] & b_adr13_9[3] & b_adr23_1[3] & n_1234_911.any() );
310 
311  m_thePriorityTable1[43] = ( b_adr12_8[0] & n_123_88.any() );
312  m_thePriorityTable1[42] = ( b_adr12_8[1] & n_123_89.any() );
313  m_thePriorityTable1[41] = ( b_adr12_8[2] & n_123_80.any() );
314  m_thePriorityTable1[40] = ( b_adr12_8[3] & n_123_81.any() );
315 
316  m_thePriorityTable1[39] = ( b_adr12_9[0] & n_123_98.any() );
317  m_thePriorityTable1[38] = ( b_adr12_9[1] & n_123_99.any() );
318  m_thePriorityTable1[37] = ( b_adr12_9[2] & n_123_90.any() );
319  m_thePriorityTable1[36] = ( b_adr12_9[3] & n_123_91.any() );
320 
321  m_thePriorityTable1[35] = ( b_adr12_8[0] & n_124_88.any() );
322  m_thePriorityTable1[34] = ( b_adr12_8[1] & n_124_89.any() );
323  m_thePriorityTable1[33] = ( b_adr12_8[2] & n_124_80.any() );
324  m_thePriorityTable1[32] = ( b_adr12_8[3] & n_124_81.any() );
325 
326  m_thePriorityTable1[31] = ( b_adr12_9[0] & n_124_98.any() );
327  m_thePriorityTable1[30] = ( b_adr12_9[1] & n_124_99.any() );
328  m_thePriorityTable1[29] = ( b_adr12_9[2] & n_124_90.any() );
329  m_thePriorityTable1[28] = ( b_adr12_9[3] & n_124_91.any() );
330 
331  m_thePriorityTable1[27] = ( b_adr13_8[0] & n_134_88.any() );
332  m_thePriorityTable1[26] = ( b_adr13_8[1] & n_134_89.any() );
333  m_thePriorityTable1[25] = ( b_adr13_8[2] & n_134_80.any() );
334  m_thePriorityTable1[24] = ( b_adr13_8[3] & n_134_81.any() );
335 
336  m_thePriorityTable1[23] = ( b_adr13_9[0] & n_134_98.any() );
337  m_thePriorityTable1[22] = ( b_adr13_9[1] & n_134_99.any() );
338  m_thePriorityTable1[21] = ( b_adr13_9[2] & n_134_90.any() );
339  m_thePriorityTable1[20] = ( b_adr13_9[3] & n_134_91.any() );
340 
341  m_thePriorityTable1[19] = ( b_adr23_8[0] & n_234_88.any() );
342  m_thePriorityTable1[18] = ( b_adr23_8[1] & n_234_89.any() );
343  m_thePriorityTable1[17] = ( b_adr23_8[2] & n_234_80.any() );
344  m_thePriorityTable1[16] = ( b_adr23_8[3] & n_234_81.any() );
345 
346  m_thePriorityTable1[15] = ( b_adr23_9[0] & n_234_98.any() );
347  m_thePriorityTable1[14] = ( b_adr23_9[1] & n_234_99.any() );
348  m_thePriorityTable1[13] = ( b_adr23_9[2] & n_234_90.any() );
349  m_thePriorityTable1[12] = ( b_adr23_9[3] & n_234_91.any() );
350 
351  m_thePriorityTable1[11] = n_12_8.any();
352  m_thePriorityTable1[10] = n_12_9.any();
353 
354  m_thePriorityTable1[9] = n_13_8.any();
355  m_thePriorityTable1[8] = n_13_9.any();
356 
357  m_thePriorityTable1[7] = n_14_8.any();
358  m_thePriorityTable1[6] = n_14_9.any();
359 
360  m_thePriorityTable1[5] = n_23_8.any();
361  m_thePriorityTable1[4] = n_23_9.any();
362 
363  m_thePriorityTable1[3] = n_24_8.any();
364  m_thePriorityTable1[2] = n_24_9.any();
365 
366  m_thePriorityTable1[1] = n_34_8.any();
367  m_thePriorityTable1[0] = n_34_9.any();
368 
369 
370  if ( !m_thePriorityTable1.any() ) return;
371 
372 
373  // first Priority Encoder Sub-Unit
374  unsigned int global1 = 0;
375  unsigned int group1 = 0;
376  unsigned int p1 = 0;
377  runEncoderSubUnit1(global1, group1, p1);
378 
379  // Address Assignment for the highest priority track
380  runAddressAssignment1(global1, group1);
381 
382  // Cancellation and second Track Finder Unit
383  for ( int i = 0; i < 56; i++ ) {
384  m_thePriorityTable2[i] = m_thePriorityTable1[i];
385  }
386  m_thePriorityTable2 &= getCancelationTable(p1);
387 
388  if ( !m_thePriorityTable2.any() ) return;
389 
390  // second Priority Encoder Sub-Unit
391  unsigned int global2 = 0;
392  unsigned int group2 = 0;
393  unsigned int p2 = 0;
394  runEncoderSubUnit2(global2, group2, p2);
395 
396  // Address Assignment for the second priority track
397  runAddressAssignment2(global2, group2);
398 
399  // Fake Pair Cancellation Unit
400 
401  unsigned int s1_2 = m_theAddresses[1].station(1);
402  unsigned int s2_2 = m_theAddresses[1].station(2);
403  unsigned int s3_2 = m_theAddresses[1].station(3);
404  unsigned int s4_2 = m_theAddresses[1].station(4);
405 
406  if ( s2_2 == m_theAddresses[0].station(2) ) {
407  s2_2 = 15; m_theBitMaps[1].reset(1); m_theAddresses[1].setStation(2,15);
408  if ( m_theTCs[1] == T1234 ) m_theTCs[1] = T134;
409  if ( m_theTCs[1] == T123 ) m_theTCs[1] = T13;
410  if ( m_theTCs[1] == T124 ) m_theTCs[1] = T14;
411  if ( m_theTCs[1] == T234 ) m_theTCs[1] = T34;
412  }
413  if ( s3_2 == m_theAddresses[0].station(3) ) {
414  s3_2 = 15; m_theBitMaps[1].reset(2); m_theAddresses[1].setStation(3,15);
415  if ( m_theTCs[1] == T1234 ) m_theTCs[1] = T124;
416  if ( m_theTCs[1] == T123 ) m_theTCs[1] = T12;
417  if ( m_theTCs[1] == T134 ) m_theTCs[1] = T14;
418  if ( m_theTCs[1] == T234 ) m_theTCs[1] = T24;
419  }
420  if ( s4_2 == m_theAddresses[0].station(4) ) {
421  s4_2 = 15; m_theBitMaps[1].reset(3); m_theAddresses[1].setStation(4,15);
422  if ( m_theTCs[1] == T1234 ) m_theTCs[1] = T123;
423  if ( m_theTCs[1] == T124 ) m_theTCs[1] = T12;
424  if ( m_theTCs[1] == T134 ) m_theTCs[1] = T13;
425  if ( m_theTCs[1] == T234 ) m_theTCs[1] = T23;
426  }
427 
428  if ( ( s2_2 == 15 && s3_2 == 15 && s4_2 == 15 ) ||
429  ( s1_2 == 15 && s3_2 == 15 && s4_2 == 15 ) ||
430  ( s1_2 == 15 && s2_2 == 15 && s4_2 == 15 ) ||
431  ( s1_2 == 15 && s2_2 == 15 && s3_2 == 15 ) ) {
432 
433  if ( L1MuDTTFConfig::Debug(5) ) cout << "L1MuDTTrackAssembler: second track has been cancelled" << endl;
434  if ( L1MuDTTFConfig::Debug(5) ) print();
435 
436  m_theTCs[1] = UNDEF;
437  m_theAddresses[1].reset();
438  m_theBitMaps[1].reset();
439 
440  }
441 
442 /*
443  if ( m_theBitMaps[1].to_ulong() != tc2bitmap(m_theTCs[1]) ) {
444  if ( L1MuDTTFConfig::Debug(5) ) cout << "L1MuDTTrackAssembler: second track has been cancelled" << endl;
445  if ( L1MuDTTFConfig::Debug(5) ) print();
446 
447  m_theTCs[1] = UNDEF;
448  m_theAddresses[1].reset();
449  m_theBitMaps[1].reset();
450  }
451 */
452 
453 }
i
int i
Definition: DBlmapReader.cc:9
L1MuDTTrackAssembler::addressEncoder12
static unsigned int addressEncoder12(const std::bitset< 12 > &input)
12 bit address encoder
Definition: L1MuDTTrackAssembler.cc:1006
L1MuDTAddressArray::reset
void reset()
reset address array
Definition: L1MuDTAddressArray.cc:118
L1MuDTTrackAssembler::addressEncoder12s
static unsigned int addressEncoder12s(const std::bitset< 12 > &input)
special 12 bit address encoder
Definition: L1MuDTTrackAssembler.cc:1027
L1MuDTTrackAssembler::runAddressAssignment1
void runAddressAssignment1(int global, int group)
run the first Address Assignment Sub-Unit
Definition: L1MuDTTrackAssembler.cc:689
L1MuDTTrackAssembler::print
void print() const
print result of Track Assembler
Definition: L1MuDTTrackAssembler.cc:478
L1MuDTTrackAssembler::m_theAddresses
L1MuDTAddressArray m_theAddresses[2]
Definition: L1MuDTTrackAssembler.h:137
L1MuDTTrackAssembler::m_theLastAddress
unsigned int m_theLastAddress[68]
Definition: L1MuDTTrackAssembler.h:132
L1MuDTExtrapolationUnit::getQSTable
const std::bitset< 12 > & getQSTable(Extrapolation ext, unsigned int startAdr) const
get Quality Sorter table for a given SEU
Definition: L1MuDTExtrapolationUnit.cc:252
L1MuDTTrackAssembler::m_sp
const L1MuDTSectorProcessor & m_sp
Definition: L1MuDTTrackAssembler.h:128
L1MuDTTrackAssembler::runEncoderSubUnit2
void runEncoderSubUnit2(unsigned &global, unsigned &group, unsigned &priority)
run the second Priority Encoder Sub-Unit
Definition: L1MuDTTrackAssembler.cc:596
L1MuDTTFConfig::Debug
static bool Debug()
Definition: L1MuDTTFConfig.h:52
L1MuDTTrackAssembler::m_theBitMaps
std::bitset< 4 > m_theBitMaps[2]
Definition: L1MuDTTrackAssembler.h:136
p2
double p2[4]
Definition: TauolaWrapper.h:90
L1MuDTTrackAssembler::getCancelationTable
static std::bitset< 56 > getCancelationTable(unsigned int)
cancel Out Table
Definition: L1MuDTTrackAssembler.cc:1080
L1MuDTTrackAssembler::m_thePriorityTable1
std::bitset< 68 > m_thePriorityTable1
Definition: L1MuDTTrackAssembler.h:130
L1MuDTTrackAssembler::m_theLastAddressI
unsigned int m_theLastAddressI[12]
Definition: L1MuDTTrackAssembler.h:133
L1MuDTTrackAssembler::runAddressAssignment2
void runAddressAssignment2(int global, int group)
run the second Address Assignment Sub-Unit
Definition: L1MuDTTrackAssembler.cc:824
L1MuDTAddressArray::setStation
void setStation(int stat, int adr)
set address of a given station [1-4]
Definition: L1MuDTAddressArray.cc:130
L1MuDTTrackAssembler::runEncoderSubUnit1
void runEncoderSubUnit1(unsigned &global, unsigned &group, unsigned &priority)
run the first Priority Encoder Sub-Unit
Definition: L1MuDTTrackAssembler.cc:494
p1
double p1[4]
Definition: TauolaWrapper.h:89
L1MuDTTrackAssembler::m_thePriorityTable2
std::bitset< 56 > m_thePriorityTable2
Definition: L1MuDTTrackAssembler.h:131
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:41
L1MuDTSectorProcessor::EU
const L1MuDTExtrapolationUnit * EU() const
return pointer to Extrapolation Unit
Definition: L1MuDTSectorProcessor.h:93
L1MuDTAddressArray::station
unsigned short station(int stat) const
get address of a given station [1-4]
Definition: L1MuDTAddressArray.h:84
void L1MuDTTrackAssembler::runAddressAssignment1 ( int  global,
int  group 
)
private

run the first Address Assignment Sub-Unit

Definition at line 689 of file L1MuDTTrackAssembler.cc.

References m_theAddresses, m_theBitMaps, m_theLastAddress, m_theTCs, L1MuDTAddressArray::setStations(), T12, T123, T1234, T124, T13, T134, T14, T23, T234, T24, T34, tc2bitmap(), and UNDEF.

Referenced by run().

689  {
690 
691  TrackClass tc(UNDEF);
692 
693  switch ( global ) {
694  case 21 : { tc = T1234;
695  switch ( group ) {
696  case 11 : m_theAddresses[0].setStations( 0, 0, 0, m_theLastAddress[67]); break;
697  case 10 : m_theAddresses[0].setStations( 0, 0, 1, m_theLastAddress[66]); break;
698  case 9 : m_theAddresses[0].setStations( 0, 0, 2, m_theLastAddress[65]); break;
699  case 8 : m_theAddresses[0].setStations( 0, 0, 3, m_theLastAddress[64]); break;
700  case 7 : m_theAddresses[0].setStations( 0, 1, 0, m_theLastAddress[63]); break;
701  case 6 : m_theAddresses[0].setStations( 0, 1, 1, m_theLastAddress[62]); break;
702  case 5 : m_theAddresses[0].setStations( 0, 1, 2, m_theLastAddress[61]); break;
703  case 4 : m_theAddresses[0].setStations( 0, 1, 3, m_theLastAddress[60]); break;
704  case 3 : m_theAddresses[0].setStations( 0, 2, 2, m_theLastAddress[59]); break;
705  case 2 : m_theAddresses[0].setStations( 0, 2, 3, m_theLastAddress[58]); break;
706  case 1 : m_theAddresses[0].setStations( 0, 3, 2, m_theLastAddress[57]); break;
707  case 0 : m_theAddresses[0].setStations( 0, 3, 3, m_theLastAddress[56]); break;
708  }
709  break;
710  }
711  case 20 : { tc = T1234;
712  switch ( group ) {
713  case 11 : m_theAddresses[0].setStations( 1, 0, 0, m_theLastAddress[55]); break;
714  case 10 : m_theAddresses[0].setStations( 1, 0, 1, m_theLastAddress[54]); break;
715  case 9 : m_theAddresses[0].setStations( 1, 0, 2, m_theLastAddress[53]); break;
716  case 8 : m_theAddresses[0].setStations( 1, 0, 3, m_theLastAddress[52]); break;
717  case 7 : m_theAddresses[0].setStations( 1, 1, 0, m_theLastAddress[51]); break;
718  case 6 : m_theAddresses[0].setStations( 1, 1, 1, m_theLastAddress[50]); break;
719  case 5 : m_theAddresses[0].setStations( 1, 1, 2, m_theLastAddress[49]); break;
720  case 4 : m_theAddresses[0].setStations( 1, 1, 3, m_theLastAddress[48]); break;
721  case 3 : m_theAddresses[0].setStations( 1, 2, 2, m_theLastAddress[47]); break;
722  case 2 : m_theAddresses[0].setStations( 1, 2, 3, m_theLastAddress[46]); break;
723  case 1 : m_theAddresses[0].setStations( 1, 3, 2, m_theLastAddress[45]); break;
724  case 0 : m_theAddresses[0].setStations( 1, 3, 3, m_theLastAddress[44]); break;
725  }
726  break;
727  }
728  case 19 : { tc = T123;
729  switch ( group ) {
730  case 3 : m_theAddresses[0].setStations( 0, 0, m_theLastAddress[43],15); break;
731  case 2 : m_theAddresses[0].setStations( 0, 1, m_theLastAddress[42],15); break;
732  case 1 : m_theAddresses[0].setStations( 0, 2, m_theLastAddress[41],15); break;
733  case 0 : m_theAddresses[0].setStations( 0, 3, m_theLastAddress[40],15); break;
734  }
735  break;
736  }
737  case 18 : { tc = T123;
738  switch ( group ) {
739  case 3 : m_theAddresses[0].setStations( 1, 0, m_theLastAddress[39],15); break;
740  case 2 : m_theAddresses[0].setStations( 1, 1, m_theLastAddress[38],15); break;
741  case 1 : m_theAddresses[0].setStations( 1, 2, m_theLastAddress[37],15); break;
742  case 0 : m_theAddresses[0].setStations( 1, 3, m_theLastAddress[36],15); break;
743  }
744  break;
745  }
746  case 17 : { tc = T124;
747  switch ( group ) {
748  case 3 : m_theAddresses[0].setStations( 0, 0,15, m_theLastAddress[35]); break;
749  case 2 : m_theAddresses[0].setStations( 0, 1,15, m_theLastAddress[34]); break;
750  case 1 : m_theAddresses[0].setStations( 0, 2,15, m_theLastAddress[33]); break;
751  case 0 : m_theAddresses[0].setStations( 0, 3,15, m_theLastAddress[32]); break;
752  }
753  break;
754  }
755  case 16 : { tc = T124;
756  switch ( group ) {
757  case 3 : m_theAddresses[0].setStations( 1, 0,15, m_theLastAddress[31]); break;
758  case 2 : m_theAddresses[0].setStations( 1, 1,15, m_theLastAddress[30]); break;
759  case 1 : m_theAddresses[0].setStations( 1, 2,15, m_theLastAddress[29]); break;
760  case 0 : m_theAddresses[0].setStations( 1, 3,15, m_theLastAddress[28]); break;
761  }
762  break;
763  }
764  case 15 : { tc = T134;
765  switch ( group ) {
766  case 3 : m_theAddresses[0].setStations( 0,15, 0, m_theLastAddress[27]); break;
767  case 2 : m_theAddresses[0].setStations( 0,15, 1, m_theLastAddress[26]); break;
768  case 1 : m_theAddresses[0].setStations( 0,15, 2, m_theLastAddress[25]); break;
769  case 0 : m_theAddresses[0].setStations( 0,15, 3, m_theLastAddress[24]); break;
770  }
771  break;
772  }
773  case 14 : { tc = T134;
774  switch ( group ) {
775  case 3 : m_theAddresses[0].setStations( 1,15, 0, m_theLastAddress[23]); break;
776  case 2 : m_theAddresses[0].setStations( 1,15, 1, m_theLastAddress[22]); break;
777  case 1 : m_theAddresses[0].setStations( 1,15, 2, m_theLastAddress[21]); break;
778  case 0 : m_theAddresses[0].setStations( 1,15, 3, m_theLastAddress[20]); break;
779  }
780  break;
781  }
782  case 13 : { tc = T234;
783  switch ( group ) {
784  case 3 : m_theAddresses[0].setStations(15, 0, 0, m_theLastAddress[19]); break;
785  case 2 : m_theAddresses[0].setStations(15, 0, 1, m_theLastAddress[18]); break;
786  case 1 : m_theAddresses[0].setStations(15, 0, 2, m_theLastAddress[17]); break;
787  case 0 : m_theAddresses[0].setStations(15, 0, 3, m_theLastAddress[16]); break;
788  }
789  break;
790  }
791  case 12 : { tc = T234;
792  switch ( group ) {
793  case 3 : m_theAddresses[0].setStations(15, 1, 0, m_theLastAddress[15]); break;
794  case 2 : m_theAddresses[0].setStations(15, 1, 1, m_theLastAddress[14]); break;
795  case 1 : m_theAddresses[0].setStations(15, 1, 2, m_theLastAddress[13]); break;
796  case 0 : m_theAddresses[0].setStations(15, 1, 3, m_theLastAddress[12]); break;
797  }
798  break;
799  }
800  case 11 : { tc = T12; m_theAddresses[0].setStations( 0, m_theLastAddress[11],15,15); break; }
801  case 10 : { tc = T12; m_theAddresses[0].setStations( 1, m_theLastAddress[10],15,15); break; }
802  case 9 : { tc = T13; m_theAddresses[0].setStations( 0,15, m_theLastAddress[9],15); break; }
803  case 8 : { tc = T13; m_theAddresses[0].setStations( 1,15, m_theLastAddress[8],15); break; }
804  case 7 : { tc = T14; m_theAddresses[0].setStations( 0,15,15, m_theLastAddress[7]); break; }
805  case 6 : { tc = T14; m_theAddresses[0].setStations( 1,15,15, m_theLastAddress[6]); break; }
806  case 5 : { tc = T23; m_theAddresses[0].setStations(15, 0, m_theLastAddress[5],15); break; }
807  case 4 : { tc = T23; m_theAddresses[0].setStations(15, 1, m_theLastAddress[4],15); break; }
808  case 3 : { tc = T24; m_theAddresses[0].setStations(15, 0,15, m_theLastAddress[3]); break; }
809  case 2 : { tc = T24; m_theAddresses[0].setStations(15, 1,15, m_theLastAddress[2]); break; }
810  case 1 : { tc = T34; m_theAddresses[0].setStations(15,15, 0, m_theLastAddress[1]); break; }
811  case 0 : { tc = T34; m_theAddresses[0].setStations(15,15, 1, m_theLastAddress[0]); break; }
812  }
813 
814  // set Track Class and covert to bitmap
815  m_theTCs[0] = tc;
816  m_theBitMaps[0] = tc2bitmap(tc);
817 
818 }
L1MuDTTrackAssembler::m_theAddresses
L1MuDTAddressArray m_theAddresses[2]
Definition: L1MuDTTrackAssembler.h:137
tc2bitmap
const unsigned int tc2bitmap(const TrackClass tc)
Definition: L1MuDTTrackAssParam.cc:45
L1MuDTTrackAssembler::m_theLastAddress
unsigned int m_theLastAddress[68]
Definition: L1MuDTTrackAssembler.h:132
L1MuDTTrackAssembler::m_theBitMaps
std::bitset< 4 > m_theBitMaps[2]
Definition: L1MuDTTrackAssembler.h:136
L1MuDTAddressArray::setStations
void setStations(int adr1, int adr2, int adr3, int adr4)
set addresses of all four stations
Definition: L1MuDTAddressArray.cc:142
void L1MuDTTrackAssembler::runAddressAssignment2 ( int  global,
int  group 
)
private

run the second Address Assignment Sub-Unit

Definition at line 824 of file L1MuDTTrackAssembler.cc.

References m_theAddresses, m_theBitMaps, m_theLastAddress, m_theLastAddressI, m_theTCs, L1MuDTAddressArray::setStations(), T12, T123, T1234, T124, T13, T134, T14, T23, T234, T24, T34, tc2bitmap(), and UNDEF.

Referenced by run().

824  {
825 
826  TrackClass tc(UNDEF);
827 
828  switch ( global ) {
829  case 20 : { tc = T1234;
830  switch ( group ) {
831  case 11 : m_theAddresses[1].setStations( 1, 0, 0, m_theLastAddress[55]); break;
832  case 10 : m_theAddresses[1].setStations( 1, 0, 1, m_theLastAddress[54]); break;
833  case 9 : m_theAddresses[1].setStations( 1, 0, 2, m_theLastAddress[53]); break;
834  case 8 : m_theAddresses[1].setStations( 1, 0, 3, m_theLastAddress[52]); break;
835  case 7 : m_theAddresses[1].setStations( 1, 1, 0, m_theLastAddress[51]); break;
836  case 6 : m_theAddresses[1].setStations( 1, 1, 1, m_theLastAddress[50]); break;
837  case 5 : m_theAddresses[1].setStations( 1, 1, 2, m_theLastAddress[49]); break;
838  case 4 : m_theAddresses[1].setStations( 1, 1, 3, m_theLastAddress[48]); break;
839  case 3 : m_theAddresses[1].setStations( 1, 2, 2, m_theLastAddress[47]); break;
840  case 2 : m_theAddresses[1].setStations( 1, 2, 3, m_theLastAddress[46]); break;
841  case 1 : m_theAddresses[1].setStations( 1, 3, 2, m_theLastAddress[45]); break;
842  case 0 : m_theAddresses[1].setStations( 1, 3, 3, m_theLastAddress[44]); break;
843  }
844  break;
845  }
846  case 19 : { tc = T123;
847  switch ( group ) {
848  case 3 : m_theAddresses[1].setStations( 0, 0, m_theLastAddress[43],15); break;
849  case 2 : m_theAddresses[1].setStations( 0, 1, m_theLastAddress[42],15); break;
850  case 1 : m_theAddresses[1].setStations( 0, 2, m_theLastAddress[41],15); break;
851  case 0 : m_theAddresses[1].setStations( 0, 3, m_theLastAddress[40],15); break;
852  }
853  break;
854  }
855  case 18 : { tc = T123;
856  switch ( group ) {
857  case 3 : m_theAddresses[1].setStations( 1, 0, m_theLastAddress[39],15); break;
858  case 2 : m_theAddresses[1].setStations( 1, 1, m_theLastAddress[38],15); break;
859  case 1 : m_theAddresses[1].setStations( 1, 2, m_theLastAddress[37],15); break;
860  case 0 : m_theAddresses[1].setStations( 1, 3, m_theLastAddress[36],15); break;
861  }
862  break;
863  }
864  case 17 : { tc = T124;
865  switch ( group ) {
866  case 3 : m_theAddresses[1].setStations( 0, 0,15, m_theLastAddress[35]); break;
867  case 2 : m_theAddresses[1].setStations( 0, 1,15, m_theLastAddress[34]); break;
868  case 1 : m_theAddresses[1].setStations( 0, 2,15, m_theLastAddress[33]); break;
869  case 0 : m_theAddresses[1].setStations( 0, 3,15, m_theLastAddress[32]); break;
870  }
871  break;
872  }
873  case 16 : { tc = T124;
874  switch ( group ) {
875  case 3 : m_theAddresses[1].setStations( 1, 0,15, m_theLastAddress[31]); break;
876  case 2 : m_theAddresses[1].setStations( 1, 1,15, m_theLastAddress[30]); break;
877  case 1 : m_theAddresses[1].setStations( 1, 2,15, m_theLastAddress[29]); break;
878  case 0 : m_theAddresses[1].setStations( 1, 3,15, m_theLastAddress[28]); break;
879  }
880  break;
881  }
882  case 15 : { tc = T134;
883  switch ( group ) {
884  case 3 : m_theAddresses[1].setStations( 0,15, 0, m_theLastAddress[27]); break;
885  case 2 : m_theAddresses[1].setStations( 0,15, 1, m_theLastAddress[26]); break;
886  case 1 : m_theAddresses[1].setStations( 0,15, 2, m_theLastAddress[25]); break;
887  case 0 : m_theAddresses[1].setStations( 0,15, 3, m_theLastAddress[24]); break;
888  }
889  break;
890  }
891  case 14 : { tc = T134;
892  switch ( group ) {
893  case 3 : m_theAddresses[1].setStations( 1,15, 0, m_theLastAddress[23]); break;
894  case 2 : m_theAddresses[1].setStations( 1,15, 1, m_theLastAddress[22]); break;
895  case 1 : m_theAddresses[1].setStations( 1,15, 2, m_theLastAddress[21]); break;
896  case 0 : m_theAddresses[1].setStations( 1,15, 3, m_theLastAddress[20]); break;
897  }
898  break;
899  }
900  case 13 : { tc = T234;
901  switch ( group ) {
902  case 3 : m_theAddresses[1].setStations(15, 0, 0, m_theLastAddress[19]); break;
903  case 2 : m_theAddresses[1].setStations(15, 0, 1, m_theLastAddress[18]); break;
904  case 1 : m_theAddresses[1].setStations(15, 0, 2, m_theLastAddress[17]); break;
905  case 0 : m_theAddresses[1].setStations(15, 0, 3, m_theLastAddress[16]); break;
906  }
907  break;
908  }
909  case 12 : { tc = T234;
910  switch ( group ) {
911  case 3 : m_theAddresses[1].setStations(15, 1, 0, m_theLastAddress[15]); break;
912  case 2 : m_theAddresses[1].setStations(15, 1, 1, m_theLastAddress[14]); break;
913  case 1 : m_theAddresses[1].setStations(15, 1, 2, m_theLastAddress[13]); break;
914  case 0 : m_theAddresses[1].setStations(15, 1, 3, m_theLastAddress[12]); break;
915  }
916  break;
917  }
918  case 11 : { tc = T12; m_theAddresses[1].setStations( 0, m_theLastAddressI[11],15,15); break; }
919  case 10 : { tc = T12; m_theAddresses[1].setStations( 1, m_theLastAddressI[10],15,15); break; }
920  case 9 : { tc = T13; m_theAddresses[1].setStations( 0,15, m_theLastAddressI[9],15); break; }
921  case 8 : { tc = T13; m_theAddresses[1].setStations( 1,15, m_theLastAddressI[8],15); break; }
922  case 7 : { tc = T14; m_theAddresses[1].setStations( 0,15,15, m_theLastAddressI[7]); break; }
923  case 6 : { tc = T14; m_theAddresses[1].setStations( 1,15,15, m_theLastAddressI[6]); break; }
924  case 5 : { tc = T23; m_theAddresses[1].setStations(15, 0, m_theLastAddressI[5],15); break; }
925  case 4 : { tc = T23; m_theAddresses[1].setStations(15, 1, m_theLastAddressI[4],15); break; }
926  case 3 : { tc = T24; m_theAddresses[1].setStations(15, 0,15, m_theLastAddressI[3]); break; }
927  case 2 : { tc = T24; m_theAddresses[1].setStations(15, 1,15, m_theLastAddressI[2]); break; }
928  case 1 : { tc = T34; m_theAddresses[1].setStations(15,15, 0, m_theLastAddressI[1]); break; }
929  case 0 : { tc = T34; m_theAddresses[1].setStations(15,15, 1, m_theLastAddressI[0]); break; }
930  }
931 
932  // set Track Class and covert to bitmap
933  m_theTCs[1] = tc;
934  m_theBitMaps[1] = tc2bitmap(tc);
935 
936 }
L1MuDTTrackAssembler::m_theAddresses
L1MuDTAddressArray m_theAddresses[2]
Definition: L1MuDTTrackAssembler.h:137
tc2bitmap
const unsigned int tc2bitmap(const TrackClass tc)
Definition: L1MuDTTrackAssParam.cc:45
L1MuDTTrackAssembler::m_theLastAddress
unsigned int m_theLastAddress[68]
Definition: L1MuDTTrackAssembler.h:132
L1MuDTTrackAssembler::m_theBitMaps
std::bitset< 4 > m_theBitMaps[2]
Definition: L1MuDTTrackAssembler.h:136
L1MuDTAddressArray::setStations
void setStations(int adr1, int adr2, int adr3, int adr4)
set addresses of all four stations
Definition: L1MuDTAddressArray.cc:142
L1MuDTTrackAssembler::m_theLastAddressI
unsigned int m_theLastAddressI[12]
Definition: L1MuDTTrackAssembler.h:133
void L1MuDTTrackAssembler::runEncoderSubUnit1 ( unsigned &  global,
unsigned &  group,
unsigned &  priority 
)
private

run the first Priority Encoder Sub-Unit

Definition at line 494 of file L1MuDTTrackAssembler.cc.

References m_thePriorityTable1, priorityEncoder12(), priorityEncoder22(), priorityEncoder4(), subBitset68(), ExpressReco_HICollisions_FallBack::x, and ExpressReco_HICollisions_FallBack::y.

Referenced by run().

494  {
495 
496  // Global Grouping
497 
498  bitset<22> exi;
499 
500  exi[21] = m_thePriorityTable1[67] || m_thePriorityTable1[66] ||
501  m_thePriorityTable1[65] || m_thePriorityTable1[64] ||
502  m_thePriorityTable1[63] || m_thePriorityTable1[62] ||
503  m_thePriorityTable1[61] || m_thePriorityTable1[60] ||
504  m_thePriorityTable1[59] || m_thePriorityTable1[58] ||
505  m_thePriorityTable1[57] || m_thePriorityTable1[56];
506  exi[20] = m_thePriorityTable1[55] || m_thePriorityTable1[54] ||
507  m_thePriorityTable1[53] || m_thePriorityTable1[52] ||
508  m_thePriorityTable1[51] || m_thePriorityTable1[50] ||
509  m_thePriorityTable1[49] || m_thePriorityTable1[48] ||
510  m_thePriorityTable1[47] || m_thePriorityTable1[46] ||
511  m_thePriorityTable1[45] || m_thePriorityTable1[44];
512  exi[19] = m_thePriorityTable1[43] || m_thePriorityTable1[42] ||
513  m_thePriorityTable1[41] || m_thePriorityTable1[40];
514  exi[18] = m_thePriorityTable1[39] || m_thePriorityTable1[38] ||
515  m_thePriorityTable1[37] || m_thePriorityTable1[36];
516  exi[17] = m_thePriorityTable1[35] || m_thePriorityTable1[34] ||
517  m_thePriorityTable1[33] || m_thePriorityTable1[32];
518  exi[16] = m_thePriorityTable1[31] || m_thePriorityTable1[30] ||
519  m_thePriorityTable1[29] || m_thePriorityTable1[28];
520  exi[15] = m_thePriorityTable1[27] || m_thePriorityTable1[26] ||
521  m_thePriorityTable1[25] || m_thePriorityTable1[24];
522  exi[14] = m_thePriorityTable1[23] || m_thePriorityTable1[22] ||
523  m_thePriorityTable1[21] || m_thePriorityTable1[20];
524  exi[13] = m_thePriorityTable1[19] || m_thePriorityTable1[18] ||
525  m_thePriorityTable1[17] || m_thePriorityTable1[16];
526  exi[12] = m_thePriorityTable1[15] || m_thePriorityTable1[14] ||
527  m_thePriorityTable1[13] || m_thePriorityTable1[12];
528  exi[11] = m_thePriorityTable1[11];
529  exi[10] = m_thePriorityTable1[10];
530  exi[9] = m_thePriorityTable1[9];
531  exi[8] = m_thePriorityTable1[8];
532  exi[7] = m_thePriorityTable1[7];
533  exi[6] = m_thePriorityTable1[6];
534  exi[5] = m_thePriorityTable1[5];
535  exi[4] = m_thePriorityTable1[4];
536  exi[3] = m_thePriorityTable1[3];
537  exi[2] = m_thePriorityTable1[2];
538  exi[1] = m_thePriorityTable1[1];
539  exi[0] = m_thePriorityTable1[0];
540 
541  // Global Priority Encoder
542 
543  global = priorityEncoder22(exi);
544  if ( global == 31 ) {
545  group = 15;
546  priority = 0;
547  return;
548  }
549 
550  // Group priority encoders
551 
552  bitset<12> x;
553  x = subBitset68(m_thePriorityTable1,56,12);
554  unsigned int prio1234a = priorityEncoder12(x);
555  x = subBitset68(m_thePriorityTable1,44,12);
556  unsigned int prio1234b = priorityEncoder12(x);
557 
558  bitset<4> y;
559  y = subBitset68(m_thePriorityTable1,40,4);
560  unsigned int prio123a = priorityEncoder4(y);
561  y = subBitset68(m_thePriorityTable1,36,4);
562  unsigned int prio123b = priorityEncoder4(y);
563  y = subBitset68(m_thePriorityTable1,32,4);
564  unsigned int prio124a = priorityEncoder4(y);
565  y = subBitset68(m_thePriorityTable1,28,4);
566  unsigned int prio124b = priorityEncoder4(y);
567  y = subBitset68(m_thePriorityTable1,24,4);
568  unsigned int prio134a = priorityEncoder4(y);
569  y = subBitset68(m_thePriorityTable1,20,4);
570  unsigned int prio134b = priorityEncoder4(y);
571  y = subBitset68(m_thePriorityTable1,16,4);
572  unsigned int prio234a = priorityEncoder4(y);
573  y = subBitset68(m_thePriorityTable1,12,4);
574  unsigned int prio234b = priorityEncoder4(y);
575 
576  switch ( global ) {
577  case 21 : { group = prio1234a; priority = 56 + group; break; }
578  case 20 : { group = prio1234b; priority = 44 + group; break; }
579  case 19 : { group = prio123a; priority = 40 + group; break; }
580  case 18 : { group = prio123b; priority = 36 + group; break; }
581  case 17 : { group = prio124a; priority = 32 + group; break; }
582  case 16 : { group = prio124b; priority = 28 + group; break; }
583  case 15 : { group = prio134a; priority = 24 + group; break; }
584  case 14 : { group = prio134b; priority = 20 + group; break; }
585  case 13 : { group = prio234a; priority = 16 + group; break; }
586  case 12 : { group = prio234b; priority = 12 + group; break; }
587  default : { group = 15; priority = global; break; }
588  }
589 
590 }
evf::utils::priority
num priority
Definition: procUtils.cc:93
L1MuDTTrackAssembler::priorityEncoder12
static unsigned int priorityEncoder12(const std::bitset< 12 > &input)
12 bit priority encoder
Definition: L1MuDTTrackAssembler.cc:942
L1MuDTTrackAssembler::priorityEncoder22
static unsigned int priorityEncoder22(const std::bitset< 22 > &input)
22 bit priority encoder
Definition: L1MuDTTrackAssembler.cc:974
ExpressReco_HICollisions_FallBack.y
tuple y
Definition: ExpressReco_HICollisions_FallBack.py:4645
L1MuDTTrackAssembler::m_thePriorityTable1
std::bitset< 68 > m_thePriorityTable1
Definition: L1MuDTTrackAssembler.h:130
L1MuDTTrackAssembler::priorityEncoder4
static unsigned int priorityEncoder4(const std::bitset< 4 > &input)
4 bit priority encoder
Definition: L1MuDTTrackAssembler.cc:958
ExpressReco_HICollisions_FallBack.x
tuple x
Definition: ExpressReco_HICollisions_FallBack.py:4646
L1MuDTTrackAssembler::subBitset68
static unsigned long subBitset68(const std::bitset< 68 > &input, int pos, int length)
get sub-bitmap of a 68-bit word
Definition: L1MuDTTrackAssembler.cc:1048
void L1MuDTTrackAssembler::runEncoderSubUnit2 ( unsigned &  global,
unsigned &  group,
unsigned &  priority 
)
private

run the second Priority Encoder Sub-Unit

Definition at line 596 of file L1MuDTTrackAssembler.cc.

References m_thePriorityTable2, priorityEncoder12(), priorityEncoder21(), priorityEncoder4(), subBitset56(), ExpressReco_HICollisions_FallBack::x, and ExpressReco_HICollisions_FallBack::y.

Referenced by run().

596  {
597 
598  // Global Grouping
599 
600  bitset<21> exi;
601 
602  exi[20] = m_thePriorityTable2[55] || m_thePriorityTable2[54] ||
603  m_thePriorityTable2[53] || m_thePriorityTable2[52] ||
604  m_thePriorityTable2[51] || m_thePriorityTable2[50] ||
605  m_thePriorityTable2[49] || m_thePriorityTable2[48] ||
606  m_thePriorityTable2[47] || m_thePriorityTable2[46] ||
607  m_thePriorityTable2[45] || m_thePriorityTable2[44];
608  exi[19] = m_thePriorityTable2[43] || m_thePriorityTable2[42] ||
609  m_thePriorityTable2[41] || m_thePriorityTable2[40];
610  exi[18] = m_thePriorityTable2[39] || m_thePriorityTable2[38] ||
611  m_thePriorityTable2[37] || m_thePriorityTable2[36];
612  exi[17] = m_thePriorityTable2[35] || m_thePriorityTable2[34] ||
613  m_thePriorityTable2[33] || m_thePriorityTable2[32];
614  exi[16] = m_thePriorityTable2[31] || m_thePriorityTable2[30] ||
615  m_thePriorityTable2[29] || m_thePriorityTable2[28];
616  exi[15] = m_thePriorityTable2[27] || m_thePriorityTable2[26] ||
617  m_thePriorityTable2[25] || m_thePriorityTable2[24];
618  exi[14] = m_thePriorityTable2[23] || m_thePriorityTable2[22] ||
619  m_thePriorityTable2[21] || m_thePriorityTable2[20];
620  exi[13] = m_thePriorityTable2[19] || m_thePriorityTable2[18] ||
621  m_thePriorityTable2[17] || m_thePriorityTable2[16];
622  exi[12] = m_thePriorityTable2[15] || m_thePriorityTable2[14] ||
623  m_thePriorityTable2[13] || m_thePriorityTable2[12];
624  exi[11] = m_thePriorityTable2[11];
625  exi[10] = m_thePriorityTable2[10];
626  exi[9] = m_thePriorityTable2[9];
627  exi[8] = m_thePriorityTable2[8];
628  exi[7] = m_thePriorityTable2[7];
629  exi[6] = m_thePriorityTable2[6];
630  exi[5] = m_thePriorityTable2[5];
631  exi[4] = m_thePriorityTable2[4];
632  exi[3] = m_thePriorityTable2[3];
633  exi[2] = m_thePriorityTable2[2];
634  exi[1] = m_thePriorityTable2[1];
635  exi[0] = m_thePriorityTable2[0];
636 
637  // Global Priority Encoder
638 
639  global = priorityEncoder21(exi);
640  if ( global == 31 ) {
641  group = 15;
642  priority = 0;
643  return;
644  }
645 
646  // Group priority encoders
647 
648  bitset<12> x;
649  x = subBitset56(m_thePriorityTable2,44,12);
650  unsigned int prio1234b = priorityEncoder12(x);
651 
652  bitset<4> y;
653  y = subBitset56(m_thePriorityTable2,40,4);
654  unsigned int prio123a = priorityEncoder4(y);
655  y = subBitset56(m_thePriorityTable2,36,4);
656  unsigned int prio123b = priorityEncoder4(y);
657  y = subBitset56(m_thePriorityTable2,32,4);
658  unsigned int prio124a = priorityEncoder4(y);
659  y = subBitset56(m_thePriorityTable2,28,4);
660  unsigned int prio124b = priorityEncoder4(y);
661  y = subBitset56(m_thePriorityTable2,24,4);
662  unsigned int prio134a = priorityEncoder4(y);
663  y = subBitset56(m_thePriorityTable2,20,4);
664  unsigned int prio134b = priorityEncoder4(y);
665  y = subBitset56(m_thePriorityTable2,16,4);
666  unsigned int prio234a = priorityEncoder4(y);
667  y = subBitset56(m_thePriorityTable2,12,4);
668  unsigned int prio234b = priorityEncoder4(y);
669 
670  switch ( global ) {
671  case 20 : { group = prio1234b; priority = 44 + group; break; }
672  case 19 : { group = prio123a; priority = 40 + group; break; }
673  case 18 : { group = prio123b; priority = 36 + group; break; }
674  case 17 : { group = prio124a; priority = 32 + group; break; }
675  case 16 : { group = prio124b; priority = 28 + group; break; }
676  case 15 : { group = prio134a; priority = 24 + group; break; }
677  case 14 : { group = prio134b; priority = 20 + group; break; }
678  case 13 : { group = prio234a; priority = 16 + group; break; }
679  case 12 : { group = prio234b; priority = 12 + group; break; }
680  default : { group = 15; priority = global; break; }
681  }
682 
683 }
evf::utils::priority
num priority
Definition: procUtils.cc:93
L1MuDTTrackAssembler::priorityEncoder12
static unsigned int priorityEncoder12(const std::bitset< 12 > &input)
12 bit priority encoder
Definition: L1MuDTTrackAssembler.cc:942
ExpressReco_HICollisions_FallBack.y
tuple y
Definition: ExpressReco_HICollisions_FallBack.py:4645
L1MuDTTrackAssembler::priorityEncoder21
static unsigned int priorityEncoder21(const std::bitset< 21 > &input)
21 bit priority encoder
Definition: L1MuDTTrackAssembler.cc:990
L1MuDTTrackAssembler::priorityEncoder4
static unsigned int priorityEncoder4(const std::bitset< 4 > &input)
4 bit priority encoder
Definition: L1MuDTTrackAssembler.cc:958
L1MuDTTrackAssembler::subBitset56
static unsigned long subBitset56(const std::bitset< 56 > &input, int pos, int length)
get sub-bitmap of a 56-bit word
Definition: L1MuDTTrackAssembler.cc:1064
ExpressReco_HICollisions_FallBack.x
tuple x
Definition: ExpressReco_HICollisions_FallBack.py:4646
L1MuDTTrackAssembler::m_thePriorityTable2
std::bitset< 56 > m_thePriorityTable2
Definition: L1MuDTTrackAssembler.h:131
unsigned long L1MuDTTrackAssembler::subBitset56 ( const std::bitset< 56 > &  input,
int  pos,
int  length 
)
staticprivate

get sub-bitmap of a 56-bit word

Definition at line 1064 of file L1MuDTTrackAssembler.cc.

References i, pos, and asciidump::s.

Referenced by runEncoderSubUnit2().

1064  {
1065 
1066  bitset<56> s(input);
1067 
1068  for ( int i = pos+length; i < 56; i++ ) s.reset(i);
1069 
1070  s >>= pos;
1071 
1072  return s.to_ulong();
1073 
1074 }
i
int i
Definition: DBlmapReader.cc:9
collect_tpl.input
tuple input
Definition: collect_tpl.py:10
asciidump.s
string s
Definition: asciidump.py:422
unsigned long L1MuDTTrackAssembler::subBitset68 ( const std::bitset< 68 > &  input,
int  pos,
int  length 
)
staticprivate

get sub-bitmap of a 68-bit word

Definition at line 1048 of file L1MuDTTrackAssembler.cc.

References i, pos, and asciidump::s.

Referenced by runEncoderSubUnit1().

1048  {
1049 
1050  bitset<68> s(input);
1051 
1052  for ( int i = pos+length; i < 68; i++ ) s.reset(i);
1053 
1054  s >>= pos;
1055 
1056  return s.to_ulong();
1057 
1058 }
i
int i
Definition: DBlmapReader.cc:9
collect_tpl.input
tuple input
Definition: collect_tpl.py:10
asciidump.s
string s
Definition: asciidump.py:422
const std::bitset<4>& L1MuDTTrackAssembler::trackBitMap ( int  id) const
inline

return bitmap of found track

Definition at line 74 of file L1MuDTTrackAssembler.h.

References ExpressReco_HICollisions_FallBack::id, and m_theBitMaps.

Referenced by L1MuDTAssignmentUnit::getPtMethod().

74 { return m_theBitMaps[id]; }
L1MuDTTrackAssembler::m_theBitMaps
std::bitset< 4 > m_theBitMaps[2]
Definition: L1MuDTTrackAssembler.h:136
ExpressReco_HICollisions_FallBack.id
tuple id
Definition: ExpressReco_HICollisions_FallBack.py:9307
TrackClass L1MuDTTrackAssembler::trackClass ( int  id) const
inline

return Track Class of found track

Definition at line 71 of file L1MuDTTrackAssembler.h.

References ExpressReco_HICollisions_FallBack::id, and m_theTCs.

Referenced by L1MuDTAssignmentUnit::QuaAU(), and L1MuDTAssignmentUnit::run().

71 { return m_theTCs[id]; }
ExpressReco_HICollisions_FallBack.id
tuple id
Definition: ExpressReco_HICollisions_FallBack.py:9307

Member Data Documentation

const L1MuDTSectorProcessor& L1MuDTTrackAssembler::m_sp
private

Definition at line 128 of file L1MuDTTrackAssembler.h.

Referenced by run().

L1MuDTAddressArray L1MuDTTrackAssembler::m_theAddresses[2]
private

Definition at line 137 of file L1MuDTTrackAssembler.h.

Referenced by address(), print(), reset(), run(), runAddressAssignment1(), and runAddressAssignment2().

std::bitset<4> L1MuDTTrackAssembler::m_theBitMaps[2]
private

Definition at line 136 of file L1MuDTTrackAssembler.h.

Referenced by print(), reset(), run(), runAddressAssignment1(), runAddressAssignment2(), and trackBitMap().

unsigned int L1MuDTTrackAssembler::m_theLastAddress[68]
private

Definition at line 132 of file L1MuDTTrackAssembler.h.

Referenced by reset(), run(), runAddressAssignment1(), and runAddressAssignment2().

unsigned int L1MuDTTrackAssembler::m_theLastAddressI[12]
private

Definition at line 133 of file L1MuDTTrackAssembler.h.

Referenced by reset(), run(), and runAddressAssignment2().

std::bitset<68> L1MuDTTrackAssembler::m_thePriorityTable1
private

Definition at line 130 of file L1MuDTTrackAssembler.h.

Referenced by print(), reset(), run(), and runEncoderSubUnit1().

std::bitset<56> L1MuDTTrackAssembler::m_thePriorityTable2
private

Definition at line 131 of file L1MuDTTrackAssembler.h.

Referenced by print(), reset(), run(), and runEncoderSubUnit2().

TrackClass L1MuDTTrackAssembler::m_theTCs[2]
private

Definition at line 135 of file L1MuDTTrackAssembler.h.

Referenced by isEmpty(), print(), reset(), run(), runAddressAssignment1(), runAddressAssignment2(), and trackClass().

Generated for CMSSW Reference Manual by doxygen 1.8.5