CMS 3D CMS Logo
csc::L1TrackId

csc::L1TrackId Class Reference

#include <DataFormats/L1CSCTrackFinder/interface/L1TrackId.h>

List of all members.

Public Types

enum  { kRankBitWidth = 6 }

Public Member Functions

unsigned encodeLUTMode (const unsigned &rank) const
unsigned endcap () const
bool erase () const
bool hasMB1 (const unsigned &rank) const
bool hasME1 (const unsigned &rank) const
 Functions to determine which stations are in this track.
bool hasME2 (const unsigned &rank) const
bool hasME3 (const unsigned &rank) const
bool hasME4 (const unsigned &rank) const
bool inOverlap () const
 L1TrackId (const csc::L1TrackId &)
 L1TrackId (const unsigned &side, const unsigned &sector)
 L1TrackId ()
unsigned mode () const
unsigned numSegments () const
const L1TrackId & operator= (const csc::L1TrackId &)
void overlapMode (const unsigned &rank, int &mode, int &stnA, int &stnB)
unsigned rank () const
unsigned sector () const
void setMode (const unsigned &mode)
void setOverlap (const unsigned &rank)
void setRank (const unsigned &rank)
bool sharesHit (const csc::L1TrackId &) const
unsigned station () const

Private Attributes

CSCDetId id_
bool m_erase
unsigned m_mode
bool m_overlap
unsigned m_rank

Detailed Description

Definition at line 19 of file L1TrackId.h.

Member Enumeration Documentation

anonymous enum

Enumerator:
kRankBitWidth 

Definition at line 22 of file L1TrackId.h.

00022 { kRankBitWidth = 6 };

Constructor & Destructor Documentation

L1TrackId::L1TrackId (  ) 

Definition at line 5 of file L1TrackId.cc.

00006   {}

L1TrackId::L1TrackId ( const unsigned &  side,
const unsigned &  sector 
)

Use a fake cscid and station... We just need to know endcap and sector

Definition at line 8 of file L1TrackId.cc.

References CSCTriggerNumbering::chamberFromTriggerLabels().

00009   {    
00011     id_ = CSCDetId(side, 2, 1, 
00012                    CSCTriggerNumbering::chamberFromTriggerLabels(sector, 0, 2, 1),
00013                    0);
00014                    
00015   }

L1TrackId::L1TrackId ( const csc::L1TrackId &  id  ) 

Definition at line 17 of file L1TrackId.cc.

00018   {
00019     m_rank = id.m_rank;
00020     m_mode = id.m_mode;
00021     m_erase = id.m_erase;
00022     m_overlap = id.m_overlap;
00023     id_ = id.id_;
00024     //stubs = id.stubs;  // add stubs back later
00025   }

Member Function Documentation

unsigned L1TrackId::encodeLUTMode ( const unsigned &  rank  )  const

Definition at line 145 of file L1TrackId.cc.

References mode.

00146   {
00147     int mode;
00148     switch (rank) 
00149       {
00150       case 0:
00151         mode = 0;
00152         break;
00153       case 1:
00154         mode = 10;
00155         break;
00156       case 2:
00157         mode = 9;
00158         break;
00159       case 3:
00160         mode = 8;
00161         break;
00162       case 4:
00163         mode = 5;
00164         break;
00165       case 5:
00166         mode = 7;
00167         break;
00168       case 6:
00169         mode = 6;
00170         break;
00171       case 7:
00172         mode = 15;
00173         break;
00174       case 8:
00175         mode = 13;
00176         break;
00177       case 9:
00178         mode = 14;
00179         break;
00180       case 10:
00181         mode = 7;
00182         break;
00183       case 11:
00184         mode = 6;
00185         break;
00186       case 12:
00187         mode = 14;
00188         break;
00189       case 13:
00190         mode = 7;
00191         break;
00192       case 14:
00193         mode = 6;
00194         break;
00195       case 15:
00196         mode = 14;
00197         break;
00198       case 16:
00199         mode = 4;
00200         break;
00201       case 17:
00202         mode = 3;
00203         break;
00204       case 18:
00205         mode = 2;
00206         break;
00207       case 19:
00208         mode = 12;
00209         break;
00210       case 20:
00211         mode = 11;
00212         break;
00213       case 21:
00214         mode = 4;
00215         break;
00216       case 22:
00217         mode = 3;
00218         break;
00219       case 23:
00220         mode = 2;
00221         break;
00222       case 24:
00223         mode = 12;
00224         break;
00225       case 25:
00226         mode = 11;
00227         break;
00228       case 26:
00229         mode = 4;
00230         break;
00231       case 27:
00232         mode = 3;
00233         break;
00234       case 28:
00235         mode = 2;
00236         break;
00237       case 29:
00238         mode = 12;
00239         break;
00240       case 30:
00241         mode = 11;
00242         break;
00243       case 31:
00244         mode = 2;
00245         break;
00246       case 32:
00247         mode = 11;
00248         break;
00249       case 33:
00250         mode = 2;
00251         break;
00252       case 34:
00253         mode = 11;
00254         break;
00255       case 35:
00256         mode = 2;
00257         break;
00258       case 36:
00259         mode = 11;
00260         break;
00261       default:
00262         mode = 0;
00263       }
00264     return mode;
00265   }

unsigned csc::L1TrackId::endcap (  )  const [inline]

Definition at line 30 of file L1TrackId.h.

References CSCDetId::endcap(), and id_.

00030 { return id_.endcap(); }

bool csc::L1TrackId::erase (  )  const [inline]

Definition at line 57 of file L1TrackId.h.

References m_erase.

00057 { return m_erase; }

bool L1TrackId::hasMB1 ( const unsigned &  rank  )  const

Definition at line 394 of file L1TrackId.cc.

00395   {
00396     bool mb = false;
00397     switch (rank) 
00398       {
00399       case 9:
00400       case 12:
00401       case 15:
00402       case 19:
00403       case 20:
00404       case 24:
00405       case 25:
00406       case 29:
00407       case 30:
00408       case 32:
00409       case 34:
00410       case 36:
00411         mb = true;
00412         break;
00413       default:
00414         mb = false;
00415       }
00416     return mb;
00417   }

bool L1TrackId::hasME1 ( const unsigned &  rank  )  const

Functions to determine which stations are in this track.

Definition at line 267 of file L1TrackId.cc.

References me.

00268   {
00269     bool me = false;
00270     switch (rank) 
00271       {
00272       case 5: 
00273       case 6:
00274       case 10:
00275       case 11:          
00276       case 12:
00277       case 13:
00278       case 14:
00279       case 16:
00280       case 17:
00281       case 18:
00282       case 21:          
00283       case 22:
00284       case 23:
00285       case 26:
00286       case 27:
00287       case 28:
00288       case 31:
00289       case 33:
00290       case 35:
00291         me = true;
00292         break;
00293       default:
00294         me = false;
00295       }
00296     return me;
00297   }

bool L1TrackId::hasME2 ( const unsigned &  rank  )  const

Definition at line 299 of file L1TrackId.cc.

References me.

00300   {
00301     bool me = false;
00302     switch (rank) 
00303       {
00304       case 2: 
00305       case 3:
00306       case 4:
00307       case 6:          
00308       case 7:
00309       case 8:
00310       case 9:
00311       case 11:
00312       case 12:
00313       case 14:
00314       case 15:          
00315       case 17:
00316       case 18:
00317       case 19:
00318       case 20:
00319       case 22:
00320       case 23:
00321       case 24:
00322       case 25:
00323       case 27:
00324       case 28:
00325       case 29:
00326       case 30:
00327       case 31:
00328       case 32:
00329       case 33:
00330       case 34:
00331       case 35:
00332       case 36:
00333         me = true;
00334         break;
00335       default:
00336         me = false;
00337       }
00338     return me;
00339   }

bool L1TrackId::hasME3 ( const unsigned &  rank  )  const

Definition at line 341 of file L1TrackId.cc.

References me.

00342   {
00343     bool me = false;
00344     switch (rank) 
00345       {
00346       case 1:
00347       case 3:
00348       case 4:
00349       case 5:
00350       case 10:
00351       case 13:
00352       case 16:
00353       case 18:
00354       case 21:
00355       case 23:
00356       case 26:
00357       case 28:
00358       case 31:
00359       case 33:
00360       case 35:
00361         me = true;
00362         break;
00363       default:
00364         me = false;
00365       }
00366     return me;
00367   }

bool L1TrackId::hasME4 ( const unsigned &  rank  )  const

Definition at line 369 of file L1TrackId.cc.

References me.

00370   {
00371     bool me = false;
00372     switch (rank) 
00373       {
00374       case 1: 
00375       case 2:
00376       case 4:
00377       case 16:
00378       case 17:
00379       case 21: 
00380       case 22:
00381       case 26:
00382       case 27:
00383       case 31:
00384       case 33:
00385       case 35:
00386         me = true;
00387         break;
00388       default:
00389         me = false;
00390       }
00391     return me;
00392   }

bool csc::L1TrackId::inOverlap (  )  const [inline]

Definition at line 43 of file L1TrackId.h.

References m_overlap.

00043 { return m_overlap; }

unsigned csc::L1TrackId::mode (  )  const [inline]

Definition at line 35 of file L1TrackId.h.

References m_mode.

00035 { return m_mode; }

unsigned csc::L1TrackId::numSegments (  )  const [inline]

Definition at line 36 of file L1TrackId.h.

00036 { return 0; } // finish later

const csc::L1TrackId & L1TrackId::operator= ( const csc::L1TrackId &  rhs  ) 

Definition at line 27 of file L1TrackId.cc.

References id_, m_erase, m_mode, m_overlap, and m_rank.

00028   {
00029     if(&rhs != this)
00030       {
00031         m_rank = rhs.m_rank;
00032         m_mode = rhs.m_mode;
00033         m_erase = rhs.m_erase;
00034         m_overlap = rhs.m_overlap;
00035         id_ = rhs.id_;
00036         //stubs = rhs.stubs;
00037       }
00038     return *this;
00039   }

void L1TrackId::overlapMode ( const unsigned &  rank,
int &  mode,
int &  stnA,
int &  stnB 
)

Definition at line 78 of file L1TrackId.cc.

00079   {
00080     switch (rank) 
00081       {
00082       case 7:
00083         stnA = 2; stnB = 1;
00084         mode = 4;
00085         break;
00086       case 8:
00087         stnA = 3; stnB = 2;
00088         mode = 4;
00089         break;
00090       case 9:
00091         stnA = 2; stnB = 1;
00092         mode = 2;
00093         break;
00094       case 12:
00095         stnA = 2; stnB = 1;
00096         mode = 2;
00097         break;
00098       case 15:
00099         stnA = 2; stnB = 1;
00100         mode = 2;
00101         break;
00102       case 19:
00103         stnA = 3; stnB = 2;
00104         mode = 2;
00105         break;
00106       case 20:
00107         stnA = 2; stnB = 1;
00108         mode = 2;
00109         break;
00110       case 24:
00111         stnA = 3; stnB = 2;
00112         mode = 2;
00113         break;
00114       case 25:
00115         stnA = 2; stnB = 1;
00116         mode = 2;
00117         break;
00118       case 29:
00119         stnA = 3; stnB = 2;
00120         mode = 2;
00121         break;
00122       case 30:
00123         stnA = 2; stnB = 1;
00124         mode = 2;
00125         break;
00126       case 32:
00127         stnA = 3; stnB = 2;
00128         mode = 2;
00129         break;
00130       case 34:
00131         stnA = 3; stnB = 2;
00132         mode = 2;
00133         break;
00134       case 36:
00135         stnA = 3; stnB = 2;
00136         mode = 2;
00137         break;
00138       default:
00139         // standard case for CSC tracks
00140         stnA = 1; stnB = 2;
00141         mode = 0;
00142       }
00143   }

unsigned csc::L1TrackId::rank (  )  const [inline]

Definition at line 34 of file L1TrackId.h.

References m_rank.

00034 { return m_rank; }

unsigned csc::L1TrackId::sector (  )  const [inline]

Definition at line 31 of file L1TrackId.h.

References id_, and CSCTriggerNumbering::triggerSectorFromLabels().

00031 { return CSCTriggerNumbering::triggerSectorFromLabels(id_); }

void csc::L1TrackId::setMode ( const unsigned &  mode  )  [inline]

Definition at line 39 of file L1TrackId.h.

References m_mode.

Referenced by CSCTFSPCoreLogic::run().

00039 { m_mode = mode; }

void L1TrackId::setOverlap ( const unsigned &  rank  ) 

Definition at line 46 of file L1TrackId.cc.

00047   {
00048     if (  (rank == 7)  || (rank == 8)  || 
00049           (rank == 9)  || (rank == 12) || (rank == 15)  ||
00050           (rank == 19) || (rank == 20) || 
00051           (rank == 24) || (rank == 25) || 
00052           (rank == 29) || (rank == 30) || 
00053           (rank == 32) || (rank == 34) || (rank == 36) ) {
00054       m_overlap = true;
00055     }
00056     else m_overlap = false;
00057   }

void L1TrackId::setRank ( const unsigned &  rank  ) 

Definition at line 59 of file L1TrackId.cc.

00060   {
00061     if (rank>=0 && rank<(1<<kRankBitWidth)) 
00062       {
00063         m_rank = rank;
00064         setOverlap(rank);
00065       }
00066     else 
00067       {
00068         m_rank = 0;
00069       }
00070   }

bool L1TrackId::sharesHit ( const csc::L1TrackId &  a_id  )  const

Definition at line 41 of file L1TrackId.cc.

00042   {
00043     return false; // finish later
00044   }

unsigned csc::L1TrackId::station (  )  const [inline]

Definition at line 32 of file L1TrackId.h.

References id_, and CSCDetId::station().

00032 { return id_.station(); }

Member Data Documentation

CSCDetId csc::L1TrackId::id_ [private]

Definition at line 63 of file L1TrackId.h.

Referenced by endcap(), operator=(), sector(), and station().

bool csc::L1TrackId::m_erase [private]

Definition at line 61 of file L1TrackId.h.

Referenced by erase(), and operator=().

unsigned csc::L1TrackId::m_mode [private]

Definition at line 60 of file L1TrackId.h.

Referenced by mode(), operator=(), and setMode().

bool csc::L1TrackId::m_overlap [private]

Definition at line 61 of file L1TrackId.h.

Referenced by inOverlap(), and operator=().

unsigned csc::L1TrackId::m_rank [private]

Definition at line 60 of file L1TrackId.h.

Referenced by operator=(), and rank().

The documentation for this class was generated from the following files:
Generated on Tue Jun 9 18:36:55 2009 for CMSSW by  doxygen 1.5.4