L1MuDTAssignmentUnit Class Reference

#include <L1MuDTAssignmentUnit.h>

Inheritance diagram for L1MuDTAssignmentUnit:

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

                                                                            : 
                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 74 of file L1MuDTAssignmentUnit.cc.

{}

---

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

                                                  {

  //  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

)

[static, private]

determine charge

Definition at line 330 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 444 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 377 of file L1MuDTAssignmentUnit.cc.

References abs, getTSphi(), m_addArray, m_id, m_sp, PFRecoTauDiscriminationAgainstElectronMVA_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 297 of file L1MuDTAssignmentUnit.cc.

References m_TSphi, and testRegression::stat.

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 145 of file L1MuDTAssignmentUnit.cc.

References convertSector(), first, edm::EventSetup::get(), L1MuDTTFConfig::getNbitsPhiPhi(), L1MuDTTFConfig::getNbitsPhiPhib(), getTSphi(), L1MuDTSectorProcessor::id(), gen::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 502 of file L1MuDTAssignmentUnit.cc.

References getTSphi(), nbit_phi, evf::evtn::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 219 of file L1MuDTAssignmentUnit.cc.

References DeDxDiscriminatorTools::charge(), 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().

                                                      {

  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 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(), 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 133 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 84 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 534 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 279 of file L1MuDTAssignmentUnit.cc.

References L1MuDTSectorProcessor::data(), L1MuDTDataBuffer::getTSphi(), m_addArray, m_sp, m_TSphi, testRegression::stat, 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 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().