L1MuDTAssignmentUnit Class Reference

#include <L1MuDTAssignmentUnit.h>

Inheritance diagram for L1MuDTAssignmentUnit:

Public Member Functions
	L1MuDTAssignmentUnit (L1MuDTSectorProcessor &sp, int id)
	constructor More...
void	PhiAU (const edm::EventSetup &c)
	assign phi More...
void	PtAU (const edm::EventSetup &c)
	assign pt and charge More...
void	QuaAU ()
	assign quality More...
virtual void	reset ()
	reset Assignment Unit More...
virtual void	run (const edm::EventSetup &c)
	run Assignment Unit More...
virtual	~L1MuDTAssignmentUnit ()
	destructor More...
Public Member Functions inherited from L1AbstractProcessor
virtual void	run ()
	run processor logic More...
virtual void	run ()
	run processor logic More...
virtual	~L1AbstractProcessor ()
	destructor More...
virtual	~L1AbstractProcessor ()
	destructor More...

Static Public Member Functions
static void	setPrecision ()
	set precision of phi and phib More...

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

Static Private Member Functions
static int	convertSector (int)
	convert sector Id to 8 bit code (= sector center) More...
static int	getCharge (PtAssMethod)
	determine charge More...

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 More...
edm::ESHandle< L1MuDTPtaLut >	thePtaLUTs
	pt-assignment look-up tables More...

Static Private Attributes
static unsigned short	nbit_phi = 12
	of bits used for pt-assignment More...
static unsigned short	nbit_phib = 10
	of bits used for pt-assignment More...

Detailed Description

Assignment Unit:

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

N. Neumeister CERN EP J. Troconiz UAM Madrid

Definition at line 50 of file L1MuDTAssignmentUnit.h.

Constructor & Destructor Documentation

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

constructor

Definition at line 56 of file L1MuDTAssignmentUnit.cc.

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

                                                                            : 
                m_sp(sp), m_id(id), 
                m_addArray(), m_TSphi(), m_ptAssMethod(NODEF) {

  m_TSphi.reserve(4);  // a track candidate can consist of max 4 TS 
  reset();

  setPrecision();

}

L1MuDTAssignmentUnit::~L1MuDTAssignmentUnit ( )

virtual

destructor

Definition at line 72 of file L1MuDTAssignmentUnit.cc.

{}

Member Function Documentation

int L1MuDTAssignmentUnit::convertSector ( int  sector )

staticprivate

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

Definition at line 314 of file L1MuDTAssignmentUnit.cc.

Referenced by PhiAU().

                                                  {

  //  assert( sector >=0 && sector < 12 );
  const int sectorvalues[12] = {  0,  12,  24,  36, 48, 60, 72, 84, 
                                 96, 108, 120, 132 };

  return sectorvalues[sector];

}

int L1MuDTAssignmentUnit::getCharge ( PtAssMethod  method )

staticprivate

determine charge

Definition at line 328 of file L1MuDTAssignmentUnit.cc.

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

                                                      {

  int chargesign = 0;
  switch ( method ) {
    case PT12L  : { chargesign = -1; break; }
    case PT12H  : { chargesign = -1; break; }
    case PT13L  : { chargesign = -1; break; }
    case PT13H  : { chargesign = -1; break; }
    case PT14L  : { chargesign = -1; break; }
    case PT14H  : { chargesign = -1; break; }
    case PT23L  : { chargesign = -1; break; }
    case PT23H  : { chargesign = -1; break; }
    case PT24L  : { chargesign = -1; break; }
    case PT24H  : { chargesign = -1; break; }
    case PT34L  : { chargesign =  1; break; }
    case PT34H  : { chargesign =  1; break; }
    case PT12LO : { chargesign = -1; break; }
    case PT12HO : { chargesign = -1; break; }
    case PT13LO : { chargesign = -1; break; }
    case PT13HO : { chargesign = -1; break; }
    case PT14LO : { chargesign = -1; break; }
    case PT14HO : { chargesign = -1; break; }
    case PT23LO : { chargesign = -1; break; }
    case PT23HO : { chargesign = -1; break; }
    case PT24LO : { chargesign = -1; break; }
    case PT24HO : { chargesign = -1; break; }
    case PT34LO : { chargesign =  1; break; }
    case PT34HO : { chargesign =  1; break; }
    case PT15LO : { chargesign = -1; break; }
    case PT15HO : { chargesign = -1; break; }
    case PT25LO : { chargesign = -1; break; }
    case PT25HO : { chargesign = -1; break; }    
    case NODEF  : { chargesign = 0; 
    //                    cerr << "AssignmentUnit::getCharge : undefined PtAssMethod!"
    //                         << endl;
                    break;
                  }
  }

  return chargesign;

}

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

private

calculate bend angle

Definition at line 442 of file L1MuDTAssignmentUnit.cc.

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

                                                                               {

  // calculate bend angle as difference of two azimuthal positions 

  int bendangle = 0;
  switch (method) {
    case PT12L  : { bendangle = phiDiff(1,2); break; }
    case PT12H  : { bendangle = phiDiff(1,2); break; }
    case PT13L  : { bendangle = phiDiff(1,3); break; }
    case PT13H  : { bendangle = phiDiff(1,3); break; }
    case PT14L  : { bendangle = phiDiff(1,4); break; }
    case PT14H  : { bendangle = phiDiff(1,4); break; }
    case PT23L  : { bendangle = phiDiff(2,3); break; }
    case PT23H  : { bendangle = phiDiff(2,3); break; }
    case PT24L  : { bendangle = phiDiff(2,4); break; }
    case PT24H  : { bendangle = phiDiff(2,4); break; }
    case PT34L  : { bendangle = phiDiff(4,3); break; }
    case PT34H  : { bendangle = phiDiff(4,3); break; }
    case PT12LO : { bendangle = phiDiff(1,2); break; }
    case PT12HO : { bendangle = phiDiff(1,2); break; }
    case PT13LO : { bendangle = phiDiff(1,3); break; }
    case PT13HO : { bendangle = phiDiff(1,3); break; }
    case PT14LO : { bendangle = phiDiff(1,4); break; }
    case PT14HO : { bendangle = phiDiff(1,4); break; }
    case PT23LO : { bendangle = phiDiff(2,3); break; }
    case PT23HO : { bendangle = phiDiff(2,3); break; }
    case PT24LO : { bendangle = phiDiff(2,4); break; }
    case PT24HO : { bendangle = phiDiff(2,4); break; }
    case PT34LO : { bendangle = phiDiff(4,3); break; }
    case PT34HO : { bendangle = phiDiff(4,3); break; }    
    case PT15LO : { bendangle = phiDiff(1,3); break; }
    case PT15HO : { bendangle = phiDiff(1,3); break; }
    case PT25LO : { bendangle = phiDiff(2,3); break; }
    case PT25HO : { bendangle = phiDiff(2,3); break; }        
    case NODEF :  { bendangle = 0;
    //                    cerr << "AssignmentUnit::getPtAddress : undefined PtAssMethod" << endl;
                    break;
                  }
  }

  int signo = 1;
  bendangle = (bendangle+8192)%4096;
  if ( bendangle > 2047 ) bendangle -= 4096;
  if ( bendangle < 0 ) signo = -1;

  if (bendcharge) return signo;

  bendangle = (bendangle+2048)%1024;
  if ( bendangle > 511 ) bendangle -= 1024;

  return bendangle;

}

PtAssMethod L1MuDTAssignmentUnit::getPtMethod ( ) const

private

determine pt assignment method

Definition at line 375 of file L1MuDTAssignmentUnit.cc.

References funct::abs(), getTSphi(), m_addArray, m_id, m_sp, PFRecoTauDiscriminationAgainstElectronMVA3GBR_cfi::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, alignCSCRings::s, L1MuDTAddressArray::station(), L1MuDTSectorProcessor::TA(), thePtaLUTs, dtDQMClient_cfg::threshold, and L1MuDTTrackAssembler::trackBitMap().

Referenced by PtAU().

                                                    {
   
  // determine which pt-assignment method should be used as a function 
  // of the track class and
  // of the phib values of the track segments making up this track candidate.

  // get bitmap of track candidate
  const bitset<4> s = m_sp.TA()->trackBitMap(m_id);
  
  int method = -1;
  
  if (  s.test(0) &&  s.test(3) ) method = 2; // stations 1 and 4
  if (  s.test(0) &&  s.test(2) ) method = 1; // stations 1 and 3
  if (  s.test(0) &&  s.test(1) ) method = 0; // stations 1 and 2
  if ( !s.test(0) &&  s.test(1) && s.test(3) ) method = 4; // stations 2 and 4
  if ( !s.test(0) &&  s.test(1) && s.test(2) ) method = 3; // stations 2 and 3
  if ( !s.test(0) && !s.test(1) && s.test(2) && s.test(3) ) method = 5; // stations 3 and 4

  if ( m_sp.ovl() ) {
    int adr = m_addArray.station(3);
    bool s5 = (adr == 15) ? false : ((adr/2)%2 == 1);    
    if (  s.test(0) &&  s.test(3) ) method = 8;  // stations 1 and 4
    if (  s.test(0) &&  s.test(2) &&  s5 ) method = 12; // stations 1 and 5
    if (  s.test(0) &&  s.test(2) && !s5 ) method = 7;  // stations 1 and 3
    if (  s.test(0) &&  s.test(1) ) method = 6;  // stations 1 and 2
    if ( !s.test(0) &&  s.test(1) && s.test(3) ) method = 10; // stations 2 and 4
    if ( !s.test(0) &&  s.test(1) && s.test(2) &&  s5 ) method = 13; // stations 2 and 5
    if ( !s.test(0) &&  s.test(1) && s.test(2) && !s5 ) method = 9;  // stations 2 and 3
    if ( !s.test(0) && !s.test(1) && s.test(2) &&  s.test(3) ) method = 11; // stations 3 and 4
  }

  int threshold = thePtaLUTs->getPtLutThreshold(method);
  
  // phib values of track segments from stations 1, 2 and 4
  int phib1 = ( getTSphi(1) != 0 ) ? getTSphi(1)->phib() : 0;
  int phib2 = ( getTSphi(2) != 0 ) ? getTSphi(2)->phib() : 0;
  int phib4 = ( getTSphi(4) != 0 ) ? getTSphi(4)->phib() : 0;

  PtAssMethod pam = NODEF;
  
  switch ( method ) {
    case 0 :  { pam = ( abs(phib1) < threshold ) ? PT12H  : PT12L;  break; }
    case 1 :  { pam = ( abs(phib1) < threshold ) ? PT13H  : PT13L;  break; }
    case 2 :  { pam = ( abs(phib1) < threshold ) ? PT14H  : PT14L;  break; }
    case 3 :  { pam = ( abs(phib2) < threshold ) ? PT23H  : PT23L;  break; }
    case 4 :  { pam = ( abs(phib2) < threshold ) ? PT24H  : PT24L;  break; }
    case 5 :  { pam = ( abs(phib4) < threshold ) ? PT34H  : PT34L;  break; }
    case 6 :  { pam = ( abs(phib1) < threshold ) ? PT12HO : PT12LO; break; }
    case 7 :  { pam = ( abs(phib1) < threshold ) ? PT13HO : PT13LO; break; }
    case 8 :  { pam = ( abs(phib1) < threshold ) ? PT14HO : PT14LO; break; }
    case 9 :  { pam = ( abs(phib2) < threshold ) ? PT23HO : PT23LO; break; }
    case 10 : { pam = ( abs(phib2) < threshold ) ? PT24HO : PT24LO; break; }
    case 11 : { pam = ( abs(phib4) < threshold ) ? PT34HO : PT34LO; break; }
    case 12 : { pam = ( abs(phib1) < threshold ) ? PT15HO : PT15LO; break; }
    case 13 : { pam = ( abs(phib2) < threshold ) ? PT25HO : PT25LO; break; }
    default : ;
      //cout << "L1MuDTAssignmentUnit : Error in PT ass method evaluation" << endl;
  }
              
  return pam;

}

const L1MuDTTrackSegPhi * L1MuDTAssignmentUnit::getTSphi ( int  station ) const

private

get track segment from a given station

Definition at line 295 of file L1MuDTAssignmentUnit.cc.

References m_TSphi, and L1MuDTTrackSegPhi::station().

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

                                                                         {

  vector<const L1MuDTTrackSegPhi*>::const_iterator iter;
  for ( iter = m_TSphi.begin(); iter != m_TSphi.end(); iter++ ) {
    int stat = (*iter)->station();
    if ( station == stat ) {
      return (*iter);
      break;
    }
  }

  return 0;

}

void L1MuDTAssignmentUnit::PhiAU

(

const edm::EventSetup &

c

)

assign phi

Definition at line 143 of file L1MuDTAssignmentUnit.cc.

References convertSector(), plotBeamSpotDB::first, edm::EventSetup::get(), L1MuDTTFConfig::getNbitsPhiPhi(), L1MuDTTFConfig::getNbitsPhiPhib(), getTSphi(), L1MuDTSectorProcessor::id(), relval_2017::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().

                                                       {

  // calculate phi at station 2 using 8 bits (precision = 2.5 degrees) 

  c.get< L1MuDTPhiLutRcd >().get( thePhiLUTs );

  int sh_phi  = 12 - L1MuDTTFConfig::getNbitsPhiPhi();
  int sh_phib = 10 - L1MuDTTFConfig::getNbitsPhiPhib();

  const L1MuDTTrackSegPhi* second = getTSphi(2);  // track segment at station 2
  const L1MuDTTrackSegPhi* first  = getTSphi(1);  // track segment at station 1
  const L1MuDTTrackSegPhi* forth  = getTSphi(4);  // track segment at station 4

  int phi2 = 0;         // phi-value at station 2
  int sector = 0;

  if ( second ) {
    phi2 = second->phi() >> sh_phi;
    sector = second->sector();
  }
  else if ( second == 0 && first ) {
    phi2 = first->phi() >> sh_phi;
    sector = first->sector();
  }
  else if ( second == 0 && forth ) {
    phi2 = forth->phi() >> sh_phi;
    sector = forth->sector();
  }

  int sector0 = m_sp.id().sector();

  // convert sector difference to values in the range -6 to +5

  int sectordiff = (sector - sector0)%12;
  if ( sectordiff >= 6 ) sectordiff -= 12;
  if ( sectordiff < -6 ) sectordiff += 12;
  
  //  assert( abs(sectordiff) <= 1 );

  // get sector center in 8 bit coding
  int sector_8 = convertSector(sector0);

  // convert phi to 2.5 degree precision
  int phi_precision = 4096 >> sh_phi;
  const double k = 57.2958/2.5/static_cast<float>(phi_precision);
  double phi_f = static_cast<double>(phi2);
  int phi_8 = static_cast<int>(floor(phi_f*k));     

  if ( second == 0 && first ) {
    int bend_angle = (first->phib() >> sh_phib) << sh_phib;
    phi_8 = phi_8 + thePhiLUTs->getDeltaPhi(0,bend_angle);
  }
  else if ( second == 0 && forth ) {
    int bend_angle = (forth->phib() >> sh_phib) << sh_phib;
    phi_8 = phi_8 + thePhiLUTs->getDeltaPhi(1,bend_angle);
  }

  phi_8 += sectordiff*12;

  if (phi_8 >  15) phi_8 =  15;
  if (phi_8 < -16) phi_8 = -16;

  int phi = (sector_8 + phi_8 + 144)%144;
  phi_8 = (phi_8 + 32)%32;

  m_sp.track(m_id)->setPhi(phi);
  m_sp.tracK(m_id)->setPhi(phi_8);

}

int L1MuDTAssignmentUnit::phiDiff ( int  stat1, int  stat2  ) const

private

build difference of two phi values

Definition at line 500 of file L1MuDTAssignmentUnit.cc.

References getTSphi(), nbit_phi, hltrates_dqm_sourceclient-live_cfg::offset, L1MuDTTrackSegPhi::phi(), and L1MuDTTrackSegPhi::sector().

Referenced by getPtAddress().

                                                            {

  // calculate bit shift

  int sh_phi  = 12 - nbit_phi;

  // get 2 phi values and add offset (30 degrees ) for adjacent sector
  int sector1 = getTSphi(stat1)->sector();
  int sector2 = getTSphi(stat2)->sector();
  int phi1 = getTSphi(stat1)->phi() >> sh_phi;
  int phi2 = getTSphi(stat2)->phi() >> sh_phi; 

  // convert sector difference to values in the range -6 to +5

  int sectordiff = (sector2 - sector1)%12;
  if ( sectordiff >= 6 ) sectordiff -= 12;
  if ( sectordiff < -6 ) sectordiff += 12;
  
  //  assert( abs(sectordiff) <= 1 );
  
  int offset = (2144 >> sh_phi) * sectordiff;
  int bendangle = (phi2 - phi1 + offset) << sh_phi;

  return bendangle;
    
}    

void L1MuDTAssignmentUnit::PtAU

(

const edm::EventSetup &

c

)

assign pt and charge

Definition at line 217 of file L1MuDTAssignmentUnit.cc.

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

Referenced by run().

                                                      {

  c.get< L1MuDTPtaLutRcd >().get( thePtaLUTs );

  // get pt-assignment method as function of track class and TS phib values
  m_ptAssMethod = getPtMethod();

  // get input address for look-up table
  int bend_angle = getPtAddress(m_ptAssMethod);
  int bend_carga = getPtAddress(m_ptAssMethod, 1);

  // retrieve pt value from look-up table
  int lut_idx = m_ptAssMethod;
  int pt = thePtaLUTs->getPt(lut_idx,bend_angle );

  m_sp.track(m_id)->setPt(pt);
  m_sp.tracK(m_id)->setPt(pt);

  // assign charge
  int chsign = getCharge(m_ptAssMethod);
  int charge = ( bend_carga >= 0 ) ? chsign : -1 * chsign;
  m_sp.track(m_id)->setCharge(charge);
  m_sp.tracK(m_id)->setCharge(charge);

}

void L1MuDTAssignmentUnit::QuaAU

(

)

assign quality

Definition at line 247 of file L1MuDTAssignmentUnit.cc.

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

Referenced by run().

                                 {

  unsigned int quality = 0;
  
  const TrackClass tc = m_sp.TA()->trackClass(m_id);
  
  switch ( tc ) {
    case T1234 : { quality = 7; break; }
    case T123  : { quality = 6; break; }
    case T124  : { quality = 6; break; }
    case T134  : { quality = 5; break; }
    case T234  : { quality = 4; break; }
    case T12   : { quality = 3; break; }
    case T13   : { quality = 3; break; }
    case T14   : { quality = 3; break; } 
    case T23   : { quality = 2; break; }
    case T24   : { quality = 2; break; } 
    case T34   : { quality = 1; break; }
    default    : { quality = 0; break; }
  }

  m_sp.track(m_id)->setQuality(quality);
  m_sp.tracK(m_id)->setQuality(quality);

}

void L1MuDTAssignmentUnit::reset ( void  )

virtual

reset Assignment Unit

Implements L1AbstractProcessor.

Definition at line 131 of file L1MuDTAssignmentUnit.cc.

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

Referenced by L1MuDTAssignmentUnit().

                                 {

  m_addArray.reset();
  m_TSphi.clear();
  m_ptAssMethod = NODEF;

}

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

virtual

run Assignment Unit

Reimplemented from L1AbstractProcessor.

Definition at line 82 of file L1MuDTAssignmentUnit.cc.

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

                                                     {

  // enable track candidate
  m_sp.track(m_id)->enable();
  m_sp.tracK(m_id)->enable();

  // set track class
  TrackClass tc = m_sp.TA()->trackClass(m_id);
  m_sp.track(m_id)->setTC(tc);
  m_sp.tracK(m_id)->setTC(tc);

  // get relative addresses of matching track segments
  m_addArray = m_sp.TA()->address(m_id);
  m_sp.track(m_id)->setAddresses(m_addArray);
  m_sp.tracK(m_id)->setAddresses(m_addArray);

  // get track segments (track segment router)
  TSR();
  m_sp.track(m_id)->setTSphi(m_TSphi);
  m_sp.tracK(m_id)->setTSphi(m_TSphi);

  // set bunch-crossing (use first track segment)
  vector<const L1MuDTTrackSegPhi*>::const_iterator iter = m_TSphi.begin();
  int bx = (*iter)->bx();
  m_sp.track(m_id)->setBx(bx);
  m_sp.tracK(m_id)->setBx(bx);

  // assign phi
  PhiAU(c);

  // assign pt and charge
  PtAU(c);
  
  // assign quality
  QuaAU();
  
  // special hack for overlap region
  //  for ( iter = m_TSphi.begin(); iter != m_TSphi.end(); iter++ ) {
  //    int wheel = abs((*iter)->wheel());
    //    if ( wheel == 3 && (*iter)->etaFlag() ) m_sp.track(m_id)->disable();
    //    if ( wheel == 3 && (*iter)->etaFlag() ) m_sp.tracK(m_id)->disable();
  //  }

}

void L1MuDTAssignmentUnit::setPrecision ( )

static

set precision of phi and phib

Definition at line 532 of file L1MuDTAssignmentUnit.cc.

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

Referenced by L1MuDTAssignmentUnit().

                                        {

  nbit_phi  = L1MuDTTFConfig::getNbitsPtaPhi();
  nbit_phib = L1MuDTTFConfig::getNbitsPtaPhib();

}

void L1MuDTAssignmentUnit::TSR ( )

private

Track Segment Router.

Definition at line 277 of file L1MuDTAssignmentUnit.cc.

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

Referenced by run().

                               {

  // get the track segments from the data buffer 
  const L1MuDTTrackSegPhi* ts = 0;
  for ( int stat = 1; stat <= 4; stat++ ) {
    int adr = m_addArray.station(stat);
    if ( adr != 15 ) {
      ts = m_sp.data()->getTSphi(stat,adr);
      if ( ts != 0 ) m_TSphi.push_back( ts );
    }
  }

}

Member Data Documentation

L1MuDTAddressArray L1MuDTAssignmentUnit::m_addArray

private

Definition at line 106 of file L1MuDTAssignmentUnit.h.

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

int L1MuDTAssignmentUnit::m_id

private

Definition at line 104 of file L1MuDTAssignmentUnit.h.

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

PtAssMethod L1MuDTAssignmentUnit::m_ptAssMethod

private

Definition at line 108 of file L1MuDTAssignmentUnit.h.

Referenced by PtAU(), and reset().

L1MuDTSectorProcessor& L1MuDTAssignmentUnit::m_sp

private

Definition at line 103 of file L1MuDTAssignmentUnit.h.

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

std::vector<const L1MuDTTrackSegPhi*> L1MuDTAssignmentUnit::m_TSphi

private

Definition at line 107 of file L1MuDTAssignmentUnit.h.

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

unsigned short int L1MuDTAssignmentUnit::nbit_phi = 12

staticprivate

of bits used for pt-assignment

Definition at line 112 of file L1MuDTAssignmentUnit.h.

Referenced by phiDiff(), and setPrecision().

unsigned short int L1MuDTAssignmentUnit::nbit_phib = 10

staticprivate

of bits used for pt-assignment

Definition at line 113 of file L1MuDTAssignmentUnit.h.

Referenced by setPrecision().

edm::ESHandle< L1MuDTPhiLut > L1MuDTAssignmentUnit::thePhiLUTs

private

phi-assignment look-up tables

Definition at line 110 of file L1MuDTAssignmentUnit.h.

Referenced by PhiAU().

edm::ESHandle< L1MuDTPtaLut > L1MuDTAssignmentUnit::thePtaLUTs

private

pt-assignment look-up tables

Definition at line 111 of file L1MuDTAssignmentUnit.h.

Referenced by getPtMethod(), and PtAU().