L1MuBMAssignmentUnit Class Reference

#include <L1MuBMAssignmentUnit.h>

Public Member Functions
	L1MuBMAssignmentUnit (L1MuBMSectorProcessor &sp, int id)
	constructor More...
void	PhiAU (const L1TMuonBarrelParams &)
	assign phi More...
void	PtAU (const L1TMuonBarrelParams &)
	assign pt and charge More...
void	QuaAU ()
	assign quality More...
unsigned int	Quality ()
void	reset ()
	reset Assignment Unit More...
void	run (const L1TMuonBarrelParams &mbtfParams)
	run Assignment Unit More...
	~L1MuBMAssignmentUnit ()
	destructor More...

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

Private Member Functions
int	getPt1Address (L1MuBMLUTHandler::PtAssMethod) const
L1MuBMLUTHandler::PtAssMethod	getPt1Method (L1MuBMLUTHandler::PtAssMethod) const
int	getPt2Address (L1MuBMLUTHandler::PtAssMethod) const
L1MuBMLUTHandler::PtAssMethod	getPt2Method (L1MuBMLUTHandler::PtAssMethod) const
int	getPtAddress (L1MuBMLUTHandler::PtAssMethod, int bendcharge=0) const
	calculate bend angle More...
L1MuBMLUTHandler::PtAssMethod	getPtMethod () const
	determine pt assignment method More...
const L1MuBMTrackSegPhi *	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 (L1MuBMLUTHandler::PtAssMethod)
	determine charge More...

Private Attributes
L1MuBMAddressArray	m_addArray
int	m_id
L1MuBMLUTHandler::PtAssMethod	m_ptAssMethod
L1MuBMSectorProcessor &	m_sp
std::vector< const L1MuBMTrackSegPhi * >	m_TSphi
L1MuBMLUTHandler *	thePhiLUTs
	phi-assignment look-up tables More...
L1MuBMLUTHandler *	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 51 of file L1MuBMAssignmentUnit.h.

Constructor & Destructor Documentation

L1MuBMAssignmentUnit::L1MuBMAssignmentUnit	(	L1MuBMSectorProcessor &	sp,
		int	id
	)

constructor

Definition at line 55 of file L1MuBMAssignmentUnit.cc.

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

    : m_sp(sp), m_id(id), m_addArray(), m_TSphi(), m_ptAssMethod(L1MuBMLUTHandler::NODEF) {
  m_TSphi.reserve(4);  // a track candidate can consist of max 4 TS
  reset();
  setPrecision();
}

L1MuBMAssignmentUnit::~L1MuBMAssignmentUnit

(

)

destructor

Definition at line 66 of file L1MuBMAssignmentUnit.cc.

{}

Member Function Documentation

int L1MuBMAssignmentUnit::convertSector ( int  sector )

staticprivate

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

Definition at line 409 of file L1MuBMAssignmentUnit.cc.

                                                  {
  //  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 L1MuBMAssignmentUnit::getCharge ( L1MuBMLUTHandler::PtAssMethod  method )

staticprivate

determine charge

Definition at line 419 of file L1MuBMAssignmentUnit.cc.

References L1MuBMLUTHandler::NODEF, L1MuBMLUTHandler::PT12H, L1MuBMLUTHandler::PT12L, L1MuBMLUTHandler::PT13H, L1MuBMLUTHandler::PT13L, L1MuBMLUTHandler::PT14H, L1MuBMLUTHandler::PT14L, L1MuBMLUTHandler::PT23H, L1MuBMLUTHandler::PT23L, L1MuBMLUTHandler::PT24H, L1MuBMLUTHandler::PT24L, L1MuBMLUTHandler::PT34H, and L1MuBMLUTHandler::PT34L.

Referenced by PtAU().

                                                                      {
  int chargesign = 0;
  switch (method) {
    case L1MuBMLUTHandler::PT12L: {
      chargesign = -1;
      break;
    }
    case L1MuBMLUTHandler::PT12H: {
      chargesign = -1;
      break;
    }
    case L1MuBMLUTHandler::PT13L: {
      chargesign = -1;
      break;
    }
    case L1MuBMLUTHandler::PT13H: {
      chargesign = -1;
      break;
    }
    case L1MuBMLUTHandler::PT14L: {
      chargesign = -1;
      break;
    }
    case L1MuBMLUTHandler::PT14H: {
      chargesign = -1;
      break;
    }
    case L1MuBMLUTHandler::PT23L: {
      chargesign = -1;
      break;
    }
    case L1MuBMLUTHandler::PT23H: {
      chargesign = -1;
      break;
    }
    case L1MuBMLUTHandler::PT24L: {
      chargesign = -1;
      break;
    }
    case L1MuBMLUTHandler::PT24H: {
      chargesign = -1;
      break;
    }
    case L1MuBMLUTHandler::PT34L: {
      chargesign = 1;
      break;
    }
    case L1MuBMLUTHandler::PT34H: {
      chargesign = 1;
      break;
    }

    case L1MuBMLUTHandler::NODEF: {
      chargesign = 0;
      //                    cerr << "AssignmentUnit::getCharge : undefined PtAssMethod!"
      //                         << endl;
      break;
    }
    default: {
      chargesign = 0;
    }
  }

  return chargesign;
}

int L1MuBMAssignmentUnit::getPt1Address ( L1MuBMLUTHandler::PtAssMethod  method ) const

private

Definition at line 755 of file L1MuBMAssignmentUnit.cc.

References getTSphi(), L1MuBMLUTHandler::NODEF, L1MuBMTrackSegPhi::phib(), L1MuBMLUTHandler::PT12H, L1MuBMLUTHandler::PT13H, L1MuBMLUTHandler::PT14H, L1MuBMLUTHandler::PT23H, L1MuBMLUTHandler::PT24H, and L1MuBMLUTHandler::PT34H.

Referenced by PtAU().

                                                                                {
  // phib values of track segments from stations 1, 2 and 4
  int phib1 = (getTSphi(1) != nullptr) ? getTSphi(1)->phib() : -999;
  int phib2 = (getTSphi(2) != nullptr) ? getTSphi(2)->phib() : -999;
  int phib4 = (getTSphi(4) != nullptr) ? getTSphi(4)->phib() : -999;

  int bendangle = -999;
  switch (method) {
    case L1MuBMLUTHandler::PT12H: {
      bendangle = phib1;
      break;
    }
    case L1MuBMLUTHandler::PT13H: {
      bendangle = phib1;
      break;
    }
    case L1MuBMLUTHandler::PT14H: {
      bendangle = phib1;
      break;
    }
    case L1MuBMLUTHandler::PT23H: {
      bendangle = phib2;
      break;
    }
    case L1MuBMLUTHandler::PT24H: {
      bendangle = phib2;
      break;
    }
    case L1MuBMLUTHandler::PT34H: {
      bendangle = phib4;
      break;
    }
    case L1MuBMLUTHandler::NODEF: {
      bendangle = -999;
      break;
    }
    default: {
      bendangle = -999;
    }
  }

  return bendangle;
}

L1MuBMLUTHandler::PtAssMethod L1MuBMAssignmentUnit::getPt1Method ( L1MuBMLUTHandler::PtAssMethod  method ) const

private

Definition at line 668 of file L1MuBMAssignmentUnit.cc.

References getTSphi(), L1MuBMLUTHandler::NODEF, L1MuBMLUTHandler::PB12H, L1MuBMLUTHandler::PB13H, L1MuBMLUTHandler::PB14H, L1MuBMLUTHandler::PB23H, L1MuBMLUTHandler::PB24H, L1MuBMLUTHandler::PB34H, L1MuBMLUTHandler::PT12H, L1MuBMLUTHandler::PT13H, L1MuBMLUTHandler::PT14H, L1MuBMLUTHandler::PT23H, L1MuBMLUTHandler::PT24H, L1MuBMLUTHandler::PT34H, and L1MuBMTrackSegPhi::quality().

Referenced by PtAU().

                                                                                                       {
  // quality values of track segments from stations 1, 2 and 4
  int qual1 = (getTSphi(1) != nullptr) ? getTSphi(1)->quality() : 0;
  int qual2 = (getTSphi(2) != nullptr) ? getTSphi(2)->quality() : 0;
  int qual4 = (getTSphi(4) != nullptr) ? getTSphi(4)->quality() : 0;

  L1MuBMLUTHandler::PtAssMethod pam = L1MuBMLUTHandler::NODEF;

  switch (method) {
    case L1MuBMLUTHandler::PT12H: {
      if (qual1 > 3)
        pam = L1MuBMLUTHandler::PB12H;
      break;
    }
    case L1MuBMLUTHandler::PT13H: {
      if (qual1 > 3)
        pam = L1MuBMLUTHandler::PB13H;
      break;
    }
    case L1MuBMLUTHandler::PT14H: {
      if (qual1 > 3)
        pam = L1MuBMLUTHandler::PB14H;
      break;
    }
    case L1MuBMLUTHandler::PT23H: {
      if (qual2 > 3)
        pam = L1MuBMLUTHandler::PB23H;
      break;
    }
    case L1MuBMLUTHandler::PT24H: {
      if (qual2 > 3)
        pam = L1MuBMLUTHandler::PB24H;
      break;
    }
    case L1MuBMLUTHandler::PT34H: {
      if (qual4 > 3)
        pam = L1MuBMLUTHandler::PB34H;
      break;
    }
    case L1MuBMLUTHandler::NODEF: {
      pam = L1MuBMLUTHandler::NODEF;
      break;
    }
    default: {
      pam = L1MuBMLUTHandler::NODEF;
    }
  }

  return pam;
}

int L1MuBMAssignmentUnit::getPt2Address ( L1MuBMLUTHandler::PtAssMethod  method ) const

private

Definition at line 802 of file L1MuBMAssignmentUnit.cc.

References getTSphi(), L1MuBMLUTHandler::NODEF, L1MuBMTrackSegPhi::phib(), L1MuBMLUTHandler::PT12H, L1MuBMLUTHandler::PT14H, and L1MuBMLUTHandler::PT24H.

Referenced by PtAU().

                                                                                {
  // phib values of track segments from stations 1, 2 and 4
  int phib2 = (getTSphi(2) != nullptr) ? getTSphi(2)->phib() : -999;
  int phib4 = (getTSphi(4) != nullptr) ? getTSphi(4)->phib() : -999;

  int bendangle = -999;
  switch (method) {
    case L1MuBMLUTHandler::PT12H: {
      bendangle = phib2;
      break;
    }
    case L1MuBMLUTHandler::PT14H: {
      bendangle = phib4;
      break;
    }
    case L1MuBMLUTHandler::PT24H: {
      bendangle = phib4;
      break;
    }
    //case L1MuBMLUTHandler::PT12HO : { bendangle = phib2;  break; }
    //case L1MuBMLUTHandler::PT14HO : { bendangle = phib4;  break; }
    //case L1MuBMLUTHandler::PT24HO : { bendangle = phib4;  break; }
    case L1MuBMLUTHandler::NODEF: {
      bendangle = -999;
      break;
    }
    default: {
      bendangle = -999;
    }
  }

  return bendangle;
}

L1MuBMLUTHandler::PtAssMethod L1MuBMAssignmentUnit::getPt2Method ( L1MuBMLUTHandler::PtAssMethod  method ) const

private

Definition at line 722 of file L1MuBMAssignmentUnit.cc.

References getTSphi(), L1MuBMLUTHandler::NODEF, L1MuBMLUTHandler::PB21H, L1MuBMLUTHandler::PT12H, and L1MuBMTrackSegPhi::quality().

Referenced by PtAU().

                                                                                                       {
  // quality values of track segments from stations 2 and 4
  int qual2 = (getTSphi(2) != nullptr) ? getTSphi(2)->quality() : 0;
  //  int qual4 = ( getTSphi(4) != 0 ) ? getTSphi(4)->quality() : 0;

  L1MuBMLUTHandler::PtAssMethod pam = L1MuBMLUTHandler::NODEF;

  switch (method) {
    case L1MuBMLUTHandler::PT12H: {
      if (qual2 > 3)
        pam = L1MuBMLUTHandler::PB21H;
      break;
    }
      //    case PT14H  : { if (qual4 > 3) pam = PB34H;  break; }
      //    case PT24H  : { if (qual4 > 3) pam = PB34H;  break; }
    //case PT12HO : { if (qual2 > 3) pam = PB21HO; break; }
    //    case PT14HO : { if (qual4 > 3) pam = PB34HO; break; }
    //    case PT24HO : { if (qual4 > 3) pam = PB34HO; break; }
    case L1MuBMLUTHandler::NODEF: {
      pam = L1MuBMLUTHandler::NODEF;
      break;
    }
    default: {
      pam = L1MuBMLUTHandler::NODEF;
    }
  }

  return pam;
}

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

private

calculate bend angle

Definition at line 555 of file L1MuBMAssignmentUnit.cc.

References L1MuBMLUTHandler::NODEF, phiDiff(), L1MuBMLUTHandler::PT12H, L1MuBMLUTHandler::PT12L, L1MuBMLUTHandler::PT13H, L1MuBMLUTHandler::PT13L, L1MuBMLUTHandler::PT14H, L1MuBMLUTHandler::PT14L, L1MuBMLUTHandler::PT23H, L1MuBMLUTHandler::PT23L, L1MuBMLUTHandler::PT24H, L1MuBMLUTHandler::PT24L, L1MuBMLUTHandler::PT34H, and L1MuBMLUTHandler::PT34L.

Referenced by PtAU().

                                                                                               {
  // calculate bend angle as difference of two azimuthal positions

  int bendangle = 0;
  switch (method) {
    case L1MuBMLUTHandler::PT12L: {
      bendangle = phiDiff(1, 2);
      break;
    }
    case L1MuBMLUTHandler::PT12H: {
      bendangle = phiDiff(1, 2);
      break;
    }
    case L1MuBMLUTHandler::PT13L: {
      bendangle = phiDiff(1, 3);
      break;
    }
    case L1MuBMLUTHandler::PT13H: {
      bendangle = phiDiff(1, 3);
      break;
    }
    case L1MuBMLUTHandler::PT14L: {
      bendangle = phiDiff(1, 4);
      break;
    }
    case L1MuBMLUTHandler::PT14H: {
      bendangle = phiDiff(1, 4);
      break;
    }
    case L1MuBMLUTHandler::PT23L: {
      bendangle = phiDiff(2, 3);
      break;
    }
    case L1MuBMLUTHandler::PT23H: {
      bendangle = phiDiff(2, 3);
      break;
    }
    case L1MuBMLUTHandler::PT24L: {
      bendangle = phiDiff(2, 4);
      break;
    }
    case L1MuBMLUTHandler::PT24H: {
      bendangle = phiDiff(2, 4);
      break;
    }
    case L1MuBMLUTHandler::PT34L: {
      bendangle = phiDiff(4, 3);
      break;
    }
    case L1MuBMLUTHandler::PT34H: {
      bendangle = phiDiff(4, 3);
      break;
    }
    case L1MuBMLUTHandler::NODEF: {
      bendangle = 0;
      //                    cerr << "AssignmentUnit::getPtAddress : undefined PtAssMethod" << endl;
      break;
    }
    default: {
      bendangle = 0;
    }
  }

  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;
}

L1MuBMLUTHandler::PtAssMethod L1MuBMAssignmentUnit::getPtMethod ( ) const

private

determine pt assignment method

Definition at line 489 of file L1MuBMAssignmentUnit.cc.

References funct::abs(), L1MuBMLUTHandler::getPtLutThreshold(), getTSphi(), m_id, m_sp, L1MuBMLUTHandler::NODEF, L1MuBMTrackSegPhi::phib(), L1MuBMLUTHandler::PT12H, L1MuBMLUTHandler::PT12L, L1MuBMLUTHandler::PT13H, L1MuBMLUTHandler::PT13L, L1MuBMLUTHandler::PT14H, L1MuBMLUTHandler::PT14L, L1MuBMLUTHandler::PT23H, L1MuBMLUTHandler::PT23L, L1MuBMLUTHandler::PT24H, L1MuBMLUTHandler::PT24L, L1MuBMLUTHandler::PT34H, L1MuBMLUTHandler::PT34L, alignCSCRings::s, L1MuBMSectorProcessor::TA(), thePtaLUTs, dtDQMClient_cfg::threshold, and L1MuBMTrackAssembler::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
  int threshold = thePtaLUTs->getPtLutThreshold(method);

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

  L1MuBMLUTHandler::PtAssMethod pam = L1MuBMLUTHandler::NODEF;

  switch (method) {
    case 0: {
      pam = (abs(phib1) < threshold) ? L1MuBMLUTHandler::PT12H : L1MuBMLUTHandler::PT12L;
      break;
    }
    case 1: {
      pam = (abs(phib1) < threshold) ? L1MuBMLUTHandler::PT13H : L1MuBMLUTHandler::PT13L;
      break;
    }
    case 2: {
      pam = (abs(phib1) < threshold) ? L1MuBMLUTHandler::PT14H : L1MuBMLUTHandler::PT14L;
      break;
    }
    case 3: {
      pam = (abs(phib2) < threshold) ? L1MuBMLUTHandler::PT23H : L1MuBMLUTHandler::PT23L;
      break;
    }
    case 4: {
      pam = (abs(phib2) < threshold) ? L1MuBMLUTHandler::PT24H : L1MuBMLUTHandler::PT24L;
      break;
    }
    case 5: {
      pam = (abs(phib4) < threshold) ? L1MuBMLUTHandler::PT34H : L1MuBMLUTHandler::PT34L;
      break;
    }
    default:;
      //cout << "L1MuBMAssignmentUnit : Error in PT ass method evaluation" << endl;
  }

  return pam;
}

const L1MuBMTrackSegPhi * L1MuBMAssignmentUnit::getTSphi ( int  station ) const

private

get track segment from a given station

Definition at line 393 of file L1MuBMAssignmentUnit.cc.

References m_TSphi, and edm_modernize_messagelogger::stat.

Referenced by getPt1Address(), getPt1Method(), getPt2Address(), getPt2Method(), getPtMethod(), PhiAU(), and phiDiff().

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

  return nullptr;
}

void L1MuBMAssignmentUnit::PhiAU

(

const L1TMuonBarrelParams &

bmtfParams

)

assign phi

< phi-assignment look-up tables

Definition at line 123 of file L1MuBMAssignmentUnit.cc.

References funct::abs(), first, L1MuBMLUTHandler::getDeltaPhi(), L1MuBMTFConfig::getNbitsPhiPhi(), L1MuBMTFConfig::getNbitsPhiPhib(), getTSphi(), L1MuBMSectorProcessor::id(), isotrackApplyRegressor::k, m_id, m_sp, phi, L1MuBMTrackSegPhi::phi(), L1MuBMTrackSegPhi::phib(), edm::second(), L1MuBMSecProcId::sector(), L1MuBMTrackSegPhi::sector(), L1MuBMTrack::setPhi(), thePhiLUTs, L1MuBMSectorProcessor::track(), and L1MuBMSectorProcessor::tracK().

Referenced by run().

                                                                      {
  thePhiLUTs = new L1MuBMLUTHandler(bmtfParams);  
  //thePhiLUTs->print();
  // calculate phi at station 2 using 8 bits (precision = 0.625 degrees)
  int sh_phi = 12 - L1MuBMTFConfig::getNbitsPhiPhi();
  int sh_phib = 10 - L1MuBMTFConfig::getNbitsPhiPhib();

  const L1MuBMTrackSegPhi* second = getTSphi(2);  // track segment at station 2
  const L1MuBMTrackSegPhi* first = getTSphi(1);   // track segment at station 1
  const L1MuBMTrackSegPhi* 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 == nullptr && first) {
    phi2 = first->phi() >> sh_phi;
    sector = first->sector();
  } else if (second == nullptr && 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;

  // convert phi to 0.625 degree precision
  int phi_precision = 4096 >> sh_phi;
  const double k = 57.2958 / 0.625 / static_cast<float>(phi_precision);
  double phi_f = static_cast<double>(phi2);
  int bit_div_phi = static_cast<int>(phi2) % 4;
  if (bit_div_phi < 0)
    bit_div_phi += 4;
  phi_f = phi_f - std::abs(bit_div_phi);
  int phi_8 = static_cast<int>(floor(phi_f * k));

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

  //If muon is found at the neighbour sector - second station
  //a shift is needed by 48
  phi_8 += sectordiff * 48;

  int phi = phi_8 + 24;
  // 78 phi bins (-8 to 69) correspond 30 degree sector plus
  // additional lower and higher bins for neighboring sectors.
  if (phi > 69)
    phi = 69;
  if (phi < -8)
    phi = -8;

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

  delete thePhiLUTs;
}

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

private

build difference of two phi values

Definition at line 638 of file L1MuBMAssignmentUnit.cc.

References getTSphi(), nbit_phi, hltrates_dqm_sourceclient-live_cfg::offset, L1MuBMTrackSegPhi::phi(), and L1MuBMTrackSegPhi::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 L1MuBMAssignmentUnit::PtAU

(

const L1TMuonBarrelParams &

bmtfParams1

)

assign pt and charge

< pt-assignment look-up tables

Definition at line 198 of file L1MuBMAssignmentUnit.cc.

References funct::abs(), RecoTauCleanerPlugins::charge, L1TMuonBarrelParamsAllPublic::get_DisableNewAlgo(), getCharge(), L1MuBMLUTHandler::getPt(), getPt1Address(), getPt1Method(), getPt2Address(), getPt2Method(), getPtAddress(), getPtMethod(), m_id, m_ptAssMethod, m_sp, L1MuBMLUTHandler::NODEF, DiDispStaMuonMonitor_cfi::pt, Quality(), L1MuBMTrack::setCharge(), L1MuBMTrack::setPt(), thePtaLUTs, L1MuBMSectorProcessor::track(), and L1MuBMSectorProcessor::tracK().

Referenced by run().

                                                                      {
  const L1TMuonBarrelParamsAllPublic bmtfParams(bmtfParams1);
  thePtaLUTs = new L1MuBMLUTHandler(bmtfParams);  
  //thePtaLUTs->print();
  // get pt-assignment method as function of track class and TS phib values
  //m_ptAssMethod = getPtMethod(bmtfParams);
  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);
  //int pt = getPt(lut_idx, bend_angle, bmtfParams->pta_lut());

  if (!bmtfParams.get_DisableNewAlgo()) {
    if (Quality() < 4) {
      int ptj = pt;
      L1MuBMLUTHandler::PtAssMethod jj1 = getPt1Method(m_ptAssMethod);
      L1MuBMLUTHandler::PtAssMethod jj2 = getPt2Method(m_ptAssMethod);
      if (jj1 != L1MuBMLUTHandler::NODEF) {
        lut_idx = jj1;
        bend_angle = getPt1Address(m_ptAssMethod);
        if (abs(bend_angle) < 512)
          ptj = thePtaLUTs->getPt(lut_idx, bend_angle);
      } else if (jj2 != L1MuBMLUTHandler::NODEF) {
        lut_idx = jj2;
        bend_angle = getPt2Address(m_ptAssMethod);
        if (abs(bend_angle) < 512)
          ptj = thePtaLUTs->getPt(lut_idx, bend_angle);
      }
      if (ptj < pt)
        pt = ptj;
    }
  }

  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);
  delete thePtaLUTs;
}

void L1MuBMAssignmentUnit::QuaAU

(

)

assign quality

Two LSBs of BMTF Q = Nstations-1

Two MSB of BMTF Q = 11

Definition at line 249 of file L1MuBMAssignmentUnit.cc.

References m_id, m_sp, quality, L1MuBMTrack::setQuality(), T12, T123, T1234, T124, T13, T134, T14, T23, T234, T24, T34, L1MuBMSectorProcessor::TA(), L1MuBMSectorProcessor::track(), L1MuBMSectorProcessor::tracK(), and L1MuBMTrackAssembler::trackClass().

Referenced by run().

                                 {
  unsigned int quality = 0;

  const TrackClass tc = m_sp.TA()->trackClass(m_id);

  switch (tc) {
    case T1234: {
      quality = 3;
      break;
    }
    case T123: {
      quality = 2;
      break;
    }
    case T124: {
      quality = 2;
      break;
    }
    case T134: {
      quality = 2;
      break;
    }
    case T234: {
      quality = 2;
      break;
    }
    case T12: {
      quality = 1;
      break;
    }
    case T13: {
      quality = 1;
      break;
    }
    case T14: {
      quality = 1;
      break;
    }
    case T23: {
      quality = 0;
      break;
    }
    case T24: {
      quality = 0;
      break;
    }
    case T34: {
      quality = 0;
      break;
    }
    default: {
      quality = 0;
      break;
    }
  }

  quality += 12;

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

unsigned int L1MuBMAssignmentUnit::Quality

(

)

Definition at line 316 of file L1MuBMAssignmentUnit.cc.

References m_id, m_sp, quality, T12, T123, T1234, T124, T13, T134, T14, T23, T234, T24, T34, L1MuBMSectorProcessor::TA(), and L1MuBMTrackAssembler::trackClass().

Referenced by PtAU().

                                           {
  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;
    }
  }

  return quality;
}

void L1MuBMAssignmentUnit::reset

(

void

)

reset Assignment Unit

Definition at line 114 of file L1MuBMAssignmentUnit.cc.

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

Referenced by L1MuBMAssignmentUnit().

                                 {
  m_addArray.reset();
  m_TSphi.clear();
  m_ptAssMethod = L1MuBMLUTHandler::NODEF;
}

void L1MuBMAssignmentUnit::run

(

const L1TMuonBarrelParams &

mbtfParams

)

run Assignment Unit

Definition at line 75 of file L1MuBMAssignmentUnit.cc.

References L1MuBMTrackAssembler::address(), makePileupJSON::bx, L1MuBMTrack::enable(), m_addArray, m_id, m_sp, m_TSphi, PhiAU(), PtAU(), QuaAU(), L1MuBMTrack::setAddresses(), L1MuBMTrack::setBx(), L1MuBMTrack::setTC(), L1MuBMTrack::setTSphi(), L1MuBMSectorProcessor::TA(), L1MuBMSectorProcessor::track(), L1MuBMSectorProcessor::tracK(), L1MuBMTrackAssembler::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 L1MuBMTrackSegPhi*>::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(bmtfParams);

  // assign pt and charge
  PtAU(bmtfParams);

  // assign quality
  QuaAU();
}

void L1MuBMAssignmentUnit::setPrecision ( )

static

set precision of phi and phib

Definition at line 840 of file L1MuBMAssignmentUnit.cc.

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

Referenced by L1MuBMAssignmentUnit().

                                        {
  nbit_phi = L1MuBMTFConfig::getNbitsPtaPhi();
  nbit_phib = L1MuBMTFConfig::getNbitsPtaPhib();
}

void L1MuBMAssignmentUnit::TSR ( )

private

Track Segment Router.

Definition at line 377 of file L1MuBMAssignmentUnit.cc.

References L1MuBMSectorProcessor::data(), L1MuBMDataBuffer::getTSphi(), m_addArray, m_sp, m_TSphi, edm_modernize_messagelogger::stat, and L1MuBMAddressArray::station().

Referenced by run().

                               {
  // get the track segments from the data buffer
  const L1MuBMTrackSegPhi* ts = nullptr;
  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 != nullptr)
        m_TSphi.push_back(ts);
    }
  }
}

Member Data Documentation

L1MuBMAddressArray L1MuBMAssignmentUnit::m_addArray

private

Definition at line 108 of file L1MuBMAssignmentUnit.h.

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

int L1MuBMAssignmentUnit::m_id

private

Definition at line 106 of file L1MuBMAssignmentUnit.h.

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

L1MuBMLUTHandler::PtAssMethod L1MuBMAssignmentUnit::m_ptAssMethod

private

Definition at line 110 of file L1MuBMAssignmentUnit.h.

Referenced by PtAU(), and reset().

L1MuBMSectorProcessor& L1MuBMAssignmentUnit::m_sp

private

Definition at line 105 of file L1MuBMAssignmentUnit.h.

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

std::vector<const L1MuBMTrackSegPhi*> L1MuBMAssignmentUnit::m_TSphi

private

Definition at line 109 of file L1MuBMAssignmentUnit.h.

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

unsigned short int L1MuBMAssignmentUnit::nbit_phi = 12

staticprivate

of bits used for pt-assignment

Definition at line 114 of file L1MuBMAssignmentUnit.h.

Referenced by phiDiff(), and setPrecision().

unsigned short int L1MuBMAssignmentUnit::nbit_phib = 10

staticprivate

of bits used for pt-assignment

Definition at line 115 of file L1MuBMAssignmentUnit.h.

Referenced by setPrecision().

L1MuBMLUTHandler* L1MuBMAssignmentUnit::thePhiLUTs

private

phi-assignment look-up tables

Definition at line 113 of file L1MuBMAssignmentUnit.h.

Referenced by PhiAU().

L1MuBMLUTHandler* L1MuBMAssignmentUnit::thePtaLUTs

private

pt-assignment look-up tables

Definition at line 112 of file L1MuBMAssignmentUnit.h.

Referenced by getPtMethod(), and PtAU().