CMS 3D CMS Logo

L1MuDTAssignmentUnit Class Reference

Assignment Unit:. More...

#include <L1Trigger/DTTrackFinder/src/L1MuDTAssignmentUnit.h>

Inheritance diagram for L1MuDTAssignmentUnit:

L1AbstractProcessor

List of all members.

Public Member Functions

 L1MuDTAssignmentUnit (L1MuDTSectorProcessor &sp, int id)
 constructor
void PhiAU (const edm::EventSetup &c)
 assign phi
void PtAU (const edm::EventSetup &c)
 assign pt and charge
void QuaAU ()
 assign quality
virtual void reset ()
 reset Assignment Unit
virtual void run (const edm::EventSetup &c)
 run Assignment Unit
virtual ~L1MuDTAssignmentUnit ()
 destructor

Static Public Member Functions

static void setPrecision ()
 set precision of phi and phib

Private Member Functions

int getPtAddress (PtAssMethod, int bendcharge=0) const
 calculate bend angle
PtAssMethod getPtMethod () const
 determine pt assignment method
const L1MuDTTrackSegPhi * getTSphi (int station) const
 get track segment from a given station
int phiDiff (int stat1, int stat2) const
 build difference of two phi values
void TSR ()
 Track Segment Router.

Static Private Member Functions

static int convertSector (int)
 convert sector Id to 8 bit code (= sector center)
static int getCharge (PtAssMethod)
 determine charge

Private Attributes

L1MuDTAddressArray m_addArray
int m_id
PtAssMethod m_ptAssMethod
L1MuDTSectorProcessor & m_sp
std::vector< const
L1MuDTTrackSegPhi * > 		m_TSphi
edm::ESHandle< L1MuDTPhiLut > thePhiLUTs
 phi-assignment look-up tables
edm::ESHandle< L1MuDTPtaLut > thePtaLUTs
 pt-assignment look-up tables

Static Private Attributes

static unsigned short nbit_phi = 12
 # of bits used for pt-assignment
static unsigned short nbit_phib = 10
 # of bits used for pt-assignment

Detailed Description

Assignment Unit:.

assigns pt, charge, phi and quality to a muon candidate found by the Track Assembler

Date
2008/02/18 17:38:04
Revision
1.4

N. Neumeister CERN EP J. Troconiz UAM Madrid

Definition at line 52 of file L1MuDTAssignmentUnit.h.

Constructor & Destructor Documentation

L1MuDTAssignmentUnit::L1MuDTAssignmentUnit ( L1MuDTSectorProcessor &  sp,
int  id 
)

constructor

Definition at line 58 of file L1MuDTAssignmentUnit.cc.

References m_TSphi, reset(), and setPrecision().

00058                                                                             : 
00059                 m_sp(sp), m_id(id), 
00060                 m_addArray(), m_TSphi(), m_ptAssMethod(NODEF) {
00061 
00062   m_TSphi.reserve(4);  // a track candidate can consist of max 4 TS 
00063   reset();
00064 
00065   setPrecision();
00066 
00067 }

L1MuDTAssignmentUnit::~L1MuDTAssignmentUnit (  )  [virtual]

destructor

Definition at line 74 of file L1MuDTAssignmentUnit.cc.

00074 {}

Member Function Documentation

int L1MuDTAssignmentUnit::convertSector ( int  sector  )  [static, private]

convert sector Id to 8 bit code (= sector center)

Definition at line 316 of file L1MuDTAssignmentUnit.cc.

Referenced by PhiAU().

00316                                                   {
00317 
00318   assert( sector >=0 && sector < 12 );
00319   const int sectorvalues[12] = {  0,  12,  24,  36, 48, 60, 72, 84, 
00320                                  96, 108, 120, 132 };
00321 
00322   return sectorvalues[sector];
00323 
00324 }

int L1MuDTAssignmentUnit::getCharge ( PtAssMethod  method  )  [static, private]

determine charge

Definition at line 330 of file L1MuDTAssignmentUnit.cc.

References TestMuL1L2Filter_cff::cerr, lat::endl(), NODEF, PT12H, PT12HO, PT12L, PT12LO, PT13H, PT13HO, PT13L, PT13LO, PT14H, PT14HO, PT14L, PT14LO, PT15HO, PT15LO, PT23H, PT23HO, PT23L, PT23LO, PT24H, PT24HO, PT24L, PT24LO, PT25HO, PT25LO, PT34H, PT34HO, PT34L, and PT34LO.

Referenced by PtAU().

00330                                                       {
00331 
00332   int chargesign = 0;
00333   switch ( method ) {
00334     case PT12L  : { chargesign = -1; break; }
00335     case PT12H  : { chargesign = -1; break; }
00336     case PT13L  : { chargesign = -1; break; }
00337     case PT13H  : { chargesign = -1; break; }
00338     case PT14L  : { chargesign = -1; break; }
00339     case PT14H  : { chargesign = -1; break; }
00340     case PT23L  : { chargesign = -1; break; }
00341     case PT23H  : { chargesign = -1; break; }
00342     case PT24L  : { chargesign = -1; break; }
00343     case PT24H  : { chargesign = -1; break; }
00344     case PT34L  : { chargesign =  1; break; }
00345     case PT34H  : { chargesign =  1; break; }
00346     case PT12LO : { chargesign = -1; break; }
00347     case PT12HO : { chargesign = -1; break; }
00348     case PT13LO : { chargesign = -1; break; }
00349     case PT13HO : { chargesign = -1; break; }
00350     case PT14LO : { chargesign = -1; break; }
00351     case PT14HO : { chargesign = -1; break; }
00352     case PT23LO : { chargesign = -1; break; }
00353     case PT23HO : { chargesign = -1; break; }
00354     case PT24LO : { chargesign = -1; break; }
00355     case PT24HO : { chargesign = -1; break; }
00356     case PT34LO : { chargesign =  1; break; }
00357     case PT34HO : { chargesign =  1; break; }
00358     case PT15LO : { chargesign = -1; break; }
00359     case PT15HO : { chargesign = -1; break; }
00360     case PT25LO : { chargesign = -1; break; }
00361     case PT25HO : { chargesign = -1; break; }    
00362     case NODEF  : { chargesign = 0; 
00363                     cerr << "AssignmentUnit::getCharge : undefined PtAssMethod!"
00364                          << endl;
00365                     break;
00366                   }
00367   }
00368 
00369   return chargesign;
00370 
00371 }

int L1MuDTAssignmentUnit::getPtAddress ( PtAssMethod  method,
int  bendcharge = 0 
) const [private]

calculate bend angle

Definition at line 443 of file L1MuDTAssignmentUnit.cc.

References TestMuL1L2Filter_cff::cerr, lat::endl(), NODEF, phiDiff(), PT12H, PT12HO, PT12L, PT12LO, PT13H, PT13HO, PT13L, PT13LO, PT14H, PT14HO, PT14L, PT14LO, PT15HO, PT15LO, PT23H, PT23HO, PT23L, PT23LO, PT24H, PT24HO, PT24L, PT24LO, PT25HO, PT25LO, PT34H, PT34HO, PT34L, and PT34LO.

Referenced by PtAU().

00443                                                                                {
00444 
00445   // calculate bend angle as difference of two azimuthal positions 
00446 
00447   int bendangle = 0;
00448   switch (method) {
00449     case PT12L  : { bendangle = phiDiff(1,2); break; }
00450     case PT12H  : { bendangle = phiDiff(1,2); break; }
00451     case PT13L  : { bendangle = phiDiff(1,3); break; }
00452     case PT13H  : { bendangle = phiDiff(1,3); break; }
00453     case PT14L  : { bendangle = phiDiff(1,4); break; }
00454     case PT14H  : { bendangle = phiDiff(1,4); break; }
00455     case PT23L  : { bendangle = phiDiff(2,3); break; }
00456     case PT23H  : { bendangle = phiDiff(2,3); break; }
00457     case PT24L  : { bendangle = phiDiff(2,4); break; }
00458     case PT24H  : { bendangle = phiDiff(2,4); break; }
00459     case PT34L  : { bendangle = phiDiff(4,3); break; }
00460     case PT34H  : { bendangle = phiDiff(4,3); break; }
00461     case PT12LO : { bendangle = phiDiff(1,2); break; }
00462     case PT12HO : { bendangle = phiDiff(1,2); break; }
00463     case PT13LO : { bendangle = phiDiff(1,3); break; }
00464     case PT13HO : { bendangle = phiDiff(1,3); break; }
00465     case PT14LO : { bendangle = phiDiff(1,4); break; }
00466     case PT14HO : { bendangle = phiDiff(1,4); break; }
00467     case PT23LO : { bendangle = phiDiff(2,3); break; }
00468     case PT23HO : { bendangle = phiDiff(2,3); break; }
00469     case PT24LO : { bendangle = phiDiff(2,4); break; }
00470     case PT24HO : { bendangle = phiDiff(2,4); break; }
00471     case PT34LO : { bendangle = phiDiff(4,3); break; }
00472     case PT34HO : { bendangle = phiDiff(4,3); break; }    
00473     case PT15LO : { bendangle = phiDiff(1,3); break; }
00474     case PT15HO : { bendangle = phiDiff(1,3); break; }
00475     case PT25LO : { bendangle = phiDiff(2,3); break; }
00476     case PT25HO : { bendangle = phiDiff(2,3); break; }        
00477     case NODEF :  { bendangle = 0;
00478                     cerr << "AssignmentUnit::getPtAddress : undefined PtAssMethod" << endl;
00479                     break;
00480                   }
00481   }
00482 
00483   int signo = 1;
00484   bendangle = (bendangle+8192)%4096;
00485   if ( bendangle > 2047 ) bendangle -= 4096;
00486   if ( bendangle < 0 ) signo = -1;
00487 
00488   if (bendcharge) return signo;
00489 
00490   bendangle = (bendangle+2048)%1024;
00491   if ( bendangle > 511 ) bendangle -= 1024;
00492 
00493   return bendangle;
00494 
00495 }

PtAssMethod L1MuDTAssignmentUnit::getPtMethod (  )  const [private]

determine pt assignment method

Definition at line 377 of file L1MuDTAssignmentUnit.cc.

References funct::abs(), GenMuonPlsPt100GeV_cfg::cout, lat::endl(), getTSphi(), m_addArray, m_id, m_sp, method, NODEF, L1MuDTSectorProcessor::ovl(), L1MuDTTrackSegPhi::phib(), PT12H, PT12HO, PT12L, PT12LO, PT13H, PT13HO, PT13L, PT13LO, PT14H, PT14HO, PT14L, PT14LO, PT15HO, PT15LO, PT23H, PT23HO, PT23L, PT23LO, PT24H, PT24HO, PT24L, PT24LO, PT25HO, PT25LO, PT34H, PT34HO, PT34L, PT34LO, s, L1MuDTAddressArray::station(), L1MuDTSectorProcessor::TA(), thePtaLUTs, dimuonsSequences_cff::threshold, and L1MuDTTrackAssembler::trackBitMap().

Referenced by PtAU().

00377                                                     {
00378    
00379   // determine which pt-assignment method should be used as a function 
00380   // of the track class and
00381   // of the phib values of the track segments making up this track candidate.
00382 
00383   // get bitmap of track candidate
00384   const bitset<4> s = m_sp.TA()->trackBitMap(m_id);
00385   
00386   int method = -1;
00387   
00388   if (  s.test(0) &&  s.test(3) ) method = 2; // stations 1 and 4
00389   if (  s.test(0) &&  s.test(2) ) method = 1; // stations 1 and 3
00390   if (  s.test(0) &&  s.test(1) ) method = 0; // stations 1 and 2
00391   if ( !s.test(0) &&  s.test(1) && s.test(3) ) method = 4; // stations 2 and 4
00392   if ( !s.test(0) &&  s.test(1) && s.test(2) ) method = 3; // stations 2 and 3
00393   if ( !s.test(0) && !s.test(1) && s.test(2) && s.test(3) ) method = 5; // stations 3 and 4
00394 
00395   if ( m_sp.ovl() ) {
00396     int adr = m_addArray.station(3);
00397     bool s5 = (adr == 15) ? false : ((adr/2)%2 == 1);    
00398     if (  s.test(0) &&  s.test(3) ) method = 8;  // stations 1 and 4
00399     if (  s.test(0) &&  s.test(2) &&  s5 ) method = 12; // stations 1 and 5
00400     if (  s.test(0) &&  s.test(2) && !s5 ) method = 7;  // stations 1 and 3
00401     if (  s.test(0) &&  s.test(1) ) method = 6;  // stations 1 and 2
00402     if ( !s.test(0) &&  s.test(1) && s.test(3) ) method = 10; // stations 2 and 4
00403     if ( !s.test(0) &&  s.test(1) && s.test(2) &&  s5 ) method = 13; // stations 2 and 5
00404     if ( !s.test(0) &&  s.test(1) && s.test(2) && !s5 ) method = 9;  // stations 2 and 3
00405     if ( !s.test(0) && !s.test(1) && s.test(2) &&  s.test(3) ) method = 11; // stations 3 and 4
00406   }
00407 
00408   int threshold = thePtaLUTs->getPtLutThreshold(method);
00409   
00410   // phib values of track segments from stations 1, 2 and 4
00411   int phib1 = ( getTSphi(1) != 0 ) ? getTSphi(1)->phib() : 0;
00412   int phib2 = ( getTSphi(2) != 0 ) ? getTSphi(2)->phib() : 0;
00413   int phib4 = ( getTSphi(4) != 0 ) ? getTSphi(4)->phib() : 0;
00414 
00415   PtAssMethod pam = NODEF;
00416   
00417   switch ( method ) {
00418     case 0 :  { pam = ( abs(phib1) < threshold ) ? PT12H  : PT12L;  break; }
00419     case 1 :  { pam = ( abs(phib1) < threshold ) ? PT13H  : PT13L;  break; }
00420     case 2 :  { pam = ( abs(phib1) < threshold ) ? PT14H  : PT14L;  break; }
00421     case 3 :  { pam = ( abs(phib2) < threshold ) ? PT23H  : PT23L;  break; }
00422     case 4 :  { pam = ( abs(phib2) < threshold ) ? PT24H  : PT24L;  break; }
00423     case 5 :  { pam = ( abs(phib4) < threshold ) ? PT34H  : PT34L;  break; }
00424     case 6 :  { pam = ( abs(phib1) < threshold ) ? PT12HO : PT12LO; break; }
00425     case 7 :  { pam = ( abs(phib1) < threshold ) ? PT13HO : PT13LO; break; }
00426     case 8 :  { pam = ( abs(phib1) < threshold ) ? PT14HO : PT14LO; break; }
00427     case 9 :  { pam = ( abs(phib2) < threshold ) ? PT23HO : PT23LO; break; }
00428     case 10 : { pam = ( abs(phib2) < threshold ) ? PT24HO : PT24LO; break; }
00429     case 11 : { pam = ( abs(phib4) < threshold ) ? PT34HO : PT34LO; break; }
00430     case 12 : { pam = ( abs(phib4) < threshold ) ? PT15HO : PT15LO; break; }
00431     case 13 : { pam = ( abs(phib4) < threshold ) ? PT25HO : PT25LO; break; }
00432     default : cout << "L1MuDTAssignmentUnit : Error in PT ass method evaluation" << endl;
00433   }
00434               
00435   return pam;
00436 
00437 }

const L1MuDTTrackSegPhi * L1MuDTAssignmentUnit::getTSphi ( int  station  )  const [private]

get track segment from a given station

Definition at line 297 of file L1MuDTAssignmentUnit.cc.

References iter, and m_TSphi.

Referenced by getPtMethod(), PhiAU(), and phiDiff().

00297                                                                          {
00298 
00299   vector<const L1MuDTTrackSegPhi*>::const_iterator iter;
00300   for ( iter = m_TSphi.begin(); iter != m_TSphi.end(); iter++ ) {
00301     int stat = (*iter)->station();
00302     if ( station == stat ) {
00303       return (*iter);
00304       break;
00305     }
00306   }
00307 
00308   return 0;
00309 
00310 }

void L1MuDTAssignmentUnit::PhiAU ( const edm::EventSetup &  c  ) 

assign phi

Definition at line 145 of file L1MuDTAssignmentUnit.cc.

References funct::abs(), convertSector(), first, edm::EventSetup::get(), L1MuDTTFConfig::getNbitsPhiPhi(), L1MuDTTFConfig::getNbitsPhiPhib(), getTSphi(), L1MuDTSectorProcessor::id(), k, m_id, m_sp, phi, L1MuDTTrackSegPhi::phi(), L1MuDTTrackSegPhi::phib(), edm::second(), L1MuDTSecProcId::sector(), L1MuDTTrackSegPhi::sector(), L1MuDTTrack::setPhi(), thePhiLUTs, L1MuDTSectorProcessor::track(), and L1MuDTSectorProcessor::tracK().

Referenced by run().

00145                                                        {
00146 
00147   // calculate phi at station 2 using 8 bits (precision = 2.5 degrees) 
00148 
00149   c.get< L1MuDTPhiLutRcd >().get( thePhiLUTs );
00150 
00151   int sh_phi  = 12 - L1MuDTTFConfig::getNbitsPhiPhi();
00152   int sh_phib = 10 - L1MuDTTFConfig::getNbitsPhiPhib();
00153 
00154   const L1MuDTTrackSegPhi* second = getTSphi(2);  // track segment at station 2
00155   const L1MuDTTrackSegPhi* first  = getTSphi(1);  // track segment at station 1
00156   const L1MuDTTrackSegPhi* forth  = getTSphi(4);  // track segment at station 4
00157 
00158   int phi2 = 0;         // phi-value at station 2
00159   int sector = 0;
00160 
00161   if ( second ) {
00162     phi2 = second->phi() >> sh_phi;
00163     sector = second->sector();
00164   }
00165   else if ( second == 0 && first ) {
00166     phi2 = first->phi() >> sh_phi;
00167     sector = first->sector();
00168   }
00169   else if ( second == 0 && forth ) {
00170     phi2 = forth->phi() >> sh_phi;
00171     sector = forth->sector();
00172   }
00173 
00174   int sector0 = m_sp.id().sector();
00175 
00176   // convert sector difference to values in the range -6 to +5
00177 
00178   int sectordiff = (sector - sector0)%12;
00179   if ( sectordiff >= 6 ) sectordiff -= 12;
00180   if ( sectordiff < -6 ) sectordiff += 12;
00181   
00182   assert( abs(sectordiff) <= 1 );
00183 
00184   // get sector center in 8 bit coding
00185   int sector_8 = convertSector(sector0);
00186 
00187   // convert phi to 2.5 degree precision
00188   int phi_precision = 4096 >> sh_phi;
00189   const double k = 57.2958/2.5/static_cast<float>(phi_precision);
00190   double phi_f = static_cast<double>(phi2);
00191   int phi_8 = static_cast<int>(floor(phi_f*k));     
00192 
00193   if ( second == 0 && first ) {
00194     int bend_angle = (first->phib() >> sh_phib) << sh_phib;
00195     phi_8 = phi_8 + thePhiLUTs->getDeltaPhi(0,bend_angle);
00196   }
00197   else if ( second == 0 && forth ) {
00198     int bend_angle = (forth->phib() >> sh_phib) << sh_phib;
00199     phi_8 = phi_8 + thePhiLUTs->getDeltaPhi(1,bend_angle);
00200   }
00201 
00202   phi_8 += sectordiff*12;
00203 
00204   if (phi_8 >  15) phi_8 =  15;
00205   if (phi_8 < -16) phi_8 = -16;
00206 
00207   int phi = (sector_8 + phi_8 + 144)%144;
00208   phi_8 = (phi_8 + 32)%32;
00209 
00210   m_sp.track(m_id)->setPhi(phi);
00211   m_sp.tracK(m_id)->setPhi(phi_8);
00212 
00213 }

int L1MuDTAssignmentUnit::phiDiff ( int  stat1,
int  stat2 
) const [private]

build difference of two phi values

Definition at line 501 of file L1MuDTAssignmentUnit.cc.

References funct::abs(), getTSphi(), nbit_phi, offset, L1MuDTTrackSegPhi::phi(), and L1MuDTTrackSegPhi::sector().

Referenced by getPtAddress().

00501                                                             {
00502 
00503   // calculate bit shift
00504 
00505   int sh_phi  = 12 - nbit_phi;
00506 
00507   // get 2 phi values and add offset (30 degrees ) for adjacent sector
00508   int sector1 = getTSphi(stat1)->sector();
00509   int sector2 = getTSphi(stat2)->sector();
00510   int phi1 = getTSphi(stat1)->phi() >> sh_phi;
00511   int phi2 = getTSphi(stat2)->phi() >> sh_phi; 
00512 
00513   // convert sector difference to values in the range -6 to +5
00514 
00515   int sectordiff = (sector2 - sector1)%12;
00516   if ( sectordiff >= 6 ) sectordiff -= 12;
00517   if ( sectordiff < -6 ) sectordiff += 12;
00518   
00519   assert( abs(sectordiff) <= 1 );
00520   
00521   int offset = (2144 >> sh_phi) * sectordiff;
00522   int bendangle = (phi2 - phi1 + offset) << sh_phi;
00523 
00524   return bendangle;
00525     
00526 }

void L1MuDTAssignmentUnit::PtAU ( const edm::EventSetup &  c  ) 

assign pt and charge

Definition at line 219 of file L1MuDTAssignmentUnit.cc.

References edm::EventSetup::get(), getCharge(), getPtAddress(), getPtMethod(), m_id, m_ptAssMethod, m_sp, L1MuDTTrack::setCharge(), L1MuDTTrack::setPt(), thePtaLUTs, L1MuDTSectorProcessor::track(), and L1MuDTSectorProcessor::tracK().

Referenced by run().

00219                                                       {
00220 
00221   c.get< L1MuDTPtaLutRcd >().get( thePtaLUTs );
00222 
00223   // get pt-assignment method as function of track class and TS phib values
00224   m_ptAssMethod = getPtMethod();
00225 
00226   // get input address for look-up table
00227   int bend_angle = getPtAddress(m_ptAssMethod);
00228   int bend_carga = getPtAddress(m_ptAssMethod, 1);
00229 
00230   // retrieve pt value from look-up table
00231   int lut_idx = m_ptAssMethod;
00232   int pt = thePtaLUTs->getPt(lut_idx,bend_angle );
00233 
00234   m_sp.track(m_id)->setPt(pt);
00235   m_sp.tracK(m_id)->setPt(pt);
00236 
00237   // assign charge
00238   int chsign = getCharge(m_ptAssMethod);
00239   int charge = ( bend_carga >= 0 ) ? chsign : -1 * chsign;
00240   m_sp.track(m_id)->setCharge(charge);
00241   m_sp.tracK(m_id)->setCharge(charge);
00242 
00243 }

void L1MuDTAssignmentUnit::QuaAU (  ) 

assign quality

Definition at line 249 of file L1MuDTAssignmentUnit.cc.

References m_id, m_sp, L1MuDTTrack::setQuality(), T12, T123, T1234, T124, T13, T134, T14, T23, T234, T24, T34, L1MuDTSectorProcessor::TA(), tc, L1MuDTSectorProcessor::track(), L1MuDTSectorProcessor::tracK(), and L1MuDTTrackAssembler::trackClass().

Referenced by run().

00249                                  {
00250 
00251   unsigned int quality = 0;
00252   
00253   const TrackClass tc = m_sp.TA()->trackClass(m_id);
00254   
00255   switch ( tc ) {
00256     case T1234 : { quality = 7; break; }
00257     case T123  : { quality = 6; break; }
00258     case T124  : { quality = 6; break; }
00259     case T134  : { quality = 5; break; }
00260     case T234  : { quality = 4; break; }
00261     case T12   : { quality = 3; break; }
00262     case T13   : { quality = 3; break; }
00263     case T14   : { quality = 3; break; } 
00264     case T23   : { quality = 2; break; }
00265     case T24   : { quality = 2; break; } 
00266     case T34   : { quality = 1; break; }
00267     default    : { quality = 0; break; }
00268   }
00269 
00270   m_sp.track(m_id)->setQuality(quality);
00271   m_sp.tracK(m_id)->setQuality(quality);
00272 
00273 }

void L1MuDTAssignmentUnit::reset ( void   )  [virtual]

reset Assignment Unit

Implements L1AbstractProcessor.

Definition at line 133 of file L1MuDTAssignmentUnit.cc.

References m_addArray, m_ptAssMethod, m_TSphi, NODEF, and L1MuDTAddressArray::reset().

Referenced by L1MuDTAssignmentUnit().

00133                                  {
00134 
00135   m_addArray.reset();
00136   m_TSphi.clear();
00137   m_ptAssMethod = NODEF;
00138 
00139 }

void L1MuDTAssignmentUnit::run ( const edm::EventSetup &  c  )  [virtual]

run Assignment Unit

Reimplemented from L1AbstractProcessor.

Definition at line 84 of file L1MuDTAssignmentUnit.cc.

References funct::abs(), L1MuDTTrackAssembler::address(), L1MuDTTrack::disable(), L1MuDTTrack::enable(), iter, m_addArray, m_id, m_sp, m_TSphi, PhiAU(), PtAU(), QuaAU(), L1MuDTTrack::setAddresses(), L1MuRegionalCand::setBx(), L1MuDTTrack::setTC(), L1MuDTTrack::setTSphi(), L1MuDTSectorProcessor::TA(), tc, L1MuDTSectorProcessor::track(), L1MuDTSectorProcessor::tracK(), L1MuDTTrackAssembler::trackClass(), TSR(), and muonGeometry::wheel.

00084                                                      {
00085 
00086   // enable track candidate
00087   m_sp.track(m_id)->enable();
00088   m_sp.tracK(m_id)->enable();
00089 
00090   // set track class
00091   TrackClass tc = m_sp.TA()->trackClass(m_id);
00092   m_sp.track(m_id)->setTC(tc);
00093   m_sp.tracK(m_id)->setTC(tc);
00094 
00095   // get relative addresses of matching track segments
00096   m_addArray = m_sp.TA()->address(m_id);
00097   m_sp.track(m_id)->setAddresses(m_addArray);
00098   m_sp.tracK(m_id)->setAddresses(m_addArray);
00099 
00100   // get track segments (track segment router)
00101   TSR();
00102   m_sp.track(m_id)->setTSphi(m_TSphi);
00103   m_sp.tracK(m_id)->setTSphi(m_TSphi);
00104 
00105   // set bunch-crossing (use first track segment)
00106   vector<const L1MuDTTrackSegPhi*>::const_iterator iter = m_TSphi.begin();
00107   int bx = (*iter)->bx();
00108   m_sp.track(m_id)->setBx(bx);
00109   m_sp.tracK(m_id)->setBx(bx);
00110 
00111   // assign phi
00112   PhiAU(c);
00113 
00114   // assign pt and charge
00115   PtAU(c);
00116   
00117   // assign quality
00118   QuaAU();
00119   
00120   // special hack for overlap region
00121   for ( iter = m_TSphi.begin(); iter != m_TSphi.end(); iter++ ) {
00122     int wheel = abs((*iter)->wheel());
00123     if ( wheel == 3 && (*iter)->etaFlag() ) m_sp.track(m_id)->disable();
00124     if ( wheel == 3 && (*iter)->etaFlag() ) m_sp.tracK(m_id)->disable();
00125   }
00126 
00127 }

void L1MuDTAssignmentUnit::setPrecision (  )  [static]

set precision of phi and phib

Definition at line 533 of file L1MuDTAssignmentUnit.cc.

References L1MuDTTFConfig::getNbitsPtaPhi(), L1MuDTTFConfig::getNbitsPtaPhib(), nbit_phi, and nbit_phib.

Referenced by L1MuDTAssignmentUnit().

00533                                         {
00534 
00535   nbit_phi  = L1MuDTTFConfig::getNbitsPtaPhi();
00536   nbit_phib = L1MuDTTFConfig::getNbitsPtaPhib();
00537 
00538 }

void L1MuDTAssignmentUnit::TSR (  )  [private]

Track Segment Router.

Definition at line 279 of file L1MuDTAssignmentUnit.cc.

References L1MuDTSectorProcessor::data(), L1MuDTDataBuffer::getTSphi(), m_addArray, m_sp, m_TSphi, and L1MuDTAddressArray::station().

Referenced by run().

00279                                {
00280 
00281   // get the track segments from the data buffer 
00282   const L1MuDTTrackSegPhi* ts = 0;
00283   for ( int stat = 1; stat <= 4; stat++ ) {
00284     int adr = m_addArray.station(stat);
00285     if ( adr != 15 ) {
00286       ts = m_sp.data()->getTSphi(stat,adr);
00287       if ( ts != 0 ) m_TSphi.push_back( ts );
00288     }
00289   }
00290 
00291 }

Member Data Documentation

L1MuDTAddressArray L1MuDTAssignmentUnit::m_addArray [private]

Definition at line 108 of file L1MuDTAssignmentUnit.h.

Referenced by getPtMethod(), reset(), run(), and TSR().

int L1MuDTAssignmentUnit::m_id [private]

Definition at line 106 of file L1MuDTAssignmentUnit.h.

Referenced by getPtMethod(), PhiAU(), PtAU(), QuaAU(), and run().

PtAssMethod L1MuDTAssignmentUnit::m_ptAssMethod [private]

Definition at line 110 of file L1MuDTAssignmentUnit.h.

Referenced by PtAU(), and reset().

L1MuDTSectorProcessor& L1MuDTAssignmentUnit::m_sp [private]

Definition at line 105 of file L1MuDTAssignmentUnit.h.

Referenced by getPtMethod(), PhiAU(), PtAU(), QuaAU(), run(), and TSR().

std::vector<const L1MuDTTrackSegPhi*> L1MuDTAssignmentUnit::m_TSphi [private]

Definition at line 109 of file L1MuDTAssignmentUnit.h.

Referenced by getTSphi(), L1MuDTAssignmentUnit(), reset(), run(), and TSR().

unsigned short int L1MuDTAssignmentUnit::nbit_phi = 12 [static, private]

# of bits used for pt-assignment

Definition at line 114 of file L1MuDTAssignmentUnit.h.

Referenced by phiDiff(), and setPrecision().

unsigned short int L1MuDTAssignmentUnit::nbit_phib = 10 [static, private]

# of bits used for pt-assignment

Definition at line 115 of file L1MuDTAssignmentUnit.h.

Referenced by setPrecision().

edm::ESHandle< L1MuDTPhiLut > L1MuDTAssignmentUnit::thePhiLUTs [private]

phi-assignment look-up tables

Definition at line 112 of file L1MuDTAssignmentUnit.h.

Referenced by PhiAU().

edm::ESHandle< L1MuDTPtaLut > L1MuDTAssignmentUnit::thePtaLUTs [private]

pt-assignment look-up tables

Definition at line 113 of file L1MuDTAssignmentUnit.h.

Referenced by getPtMethod(), and PtAU().

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