Class for storing the 32-bit muon RoI word. More...

#include <MuCTPIRoI.h>

Collaboration diagram for ROIB::MuCTPIRoI:

Public Member Functions
	MuCTPIRoI (uint32_t)
	Constructor with the actual RoI word.
	MuCTPIRoI ()
	Default constructor.
	~MuCTPIRoI ()=default
	Destructor.
uint32_t	roIWord () const
	Method returning the RoI word.
unsigned int	pt () const
	Method returning the p_T of the RoI candidate.
unsigned int	getSectorAddress () const
	Method returning the "electronics address" of the candidate.
uint16_t	getHemisphere () const
	Method returning the hemisphere of the candidate.
uint16_t	getSectorOverflow () const
	Method telling whether there were more than two candidates in this candidate's sector.
uint16_t	getRoiOverflow () const
	Method telling whether there were more than one candidates in this candidate's RoI.
uint16_t	getRoiNumber () const
	Method returning the RoI in which the candidate was detected.
uint16_t	getOverlapBits () const
	Method returning the "overlap bits" of the candidate.
MuCTPI_RDO::SectorLocation	getSectorLocation () const
	Method returning the name of the system that produced the RoI.
uint16_t	getSectorID () const
	Method returning the number of the trigger sector producing the candidate.
uint16_t	getCandidateIsHighestPt () const
	Method telling whether the candidate had the highest p_T in the sector.

Static Public Attributes
static const uint32_t	ROI_CAND_SECTOR_ADDRESS_SHIFT = 14
	Position of the sector address in the RoI word.
static const uint32_t	ROI_CAND_HIGHEST_PT_SHIFT = 22
	Position of the "highest p<sub>T</sub> bit" in the RoI word.

Private Attributes
uint32_t	m_roIWord
	The RoI word itself.

Detailed Description

Class for storing the 32-bit muon RoI word.

Date: 2007-07-04 17:28:03

   This class is used to store one muon RoI as collected by the RoI Builder.
   The RoI itself is a simple 32-bit unsigned integer, so the whole class
   rather exists for its access methods only.

   For a detailed description of the data format of the MuCTPI, see
   the MIROD documentation (https://edms.cern.ch/file/248757/1/mirod.pdf).

See also: ROIB::MuCTPIResult; ROIB::RoIBResult

Author: Thomas Schoerner-Sadenius thoma.nosp@m.s.sc.nosp@m.hoern.nosp@m.er@c.nosp@m.ern.c.nosp@m.h; Attila Krasznahorkay Attil.nosp@m.a.Kr.nosp@m.aszna.nosp@m.hork.nosp@m.ay@ce.nosp@m.rn.c.nosp@m.h; David Berge David.nosp@m..Ber.nosp@m.ge@ce.nosp@m.rn.c.nosp@m.h

Version

Revision: 1.4

Definition at line 39 of file MuCTPIRoI.h.

Constructor & Destructor Documentation

◆ MuCTPIRoI() [1/2]

ROIB::MuCTPIRoI::MuCTPIRoI ( uint32_t RoIWord )

Constructor with the actual RoI word.

This constructor should be used in any useful code, as this is the only way of giving a non-zero value to the RoI word variable of the object.

Parameters

RoIWord The 32-bit RoI word as collected by the RoI Builder

Definition at line 20 of file MuCTPIRoI.cxx.

21 : m_roIWord( RoIWord ) {}

ROIB::MuCTPIRoI::m_roIWord

uint32_t m_roIWord

The RoI word itself.

Definition MuCTPIRoI.h:79

◆ MuCTPIRoI() [2/2]

ROIB::MuCTPIRoI::MuCTPIRoI ( )

Default constructor.

Default constructor needed to be able to use POOL to stream the object.

It initialises the RoI word to zero.

Definition at line 27 of file MuCTPIRoI.cxx.

28 : m_roIWord( 0 ) {}

◆ ~MuCTPIRoI()

ROIB::MuCTPIRoI::~MuCTPIRoI ( )

default

Destructor.

Member Function Documentation

◆ getCandidateIsHighestPt()

uint16_t ROIB::MuCTPIRoI::getCandidateIsHighestPt ( ) const

Method telling whether the candidate had the highest p_T in the sector.

This method returns bit 22 of the RoI word, just like MuCTPIRoI::firstBit() does.

I just realised this duplication while writing the documentation, eventually this should be removed.

See also: MuCTPIRoI::firstBit()

Returns: 0 or 1 depending on whether the candidate had the highest p_T in its sector

Definition at line 217 of file MuCTPIRoI.cxx.

                                                    {
    return ((m_roIWord >> MuCTPIRoI::ROI_CAND_HIGHEST_PT_SHIFT) &
        LVL1::MuCTPIBits::CAND_HIGHEST_PT_MASK);
  }

◆ getHemisphere()

uint16_t ROIB::MuCTPIRoI::getHemisphere ( ) const

Method returning the hemisphere of the candidate.

Returns the hemisphere in which the candidate was detected.

Returns: 1 if the candidate has eta > 0, 0 if eta < 0.

Definition at line 76 of file MuCTPIRoI.cxx.

                                          {
    return (getSectorAddress() & LVL1::MuCTPIBits::SECTOR_HEMISPHERE_MASK);
  }

◆ getOverlapBits()

uint16_t ROIB::MuCTPIRoI::getOverlapBits ( ) const

Method returning the "overlap bits" of the candidate.

The barrel sectors can flag the muon candidates coming from a part of the trigger sector that overlaps with another one.

In theory both the barrel and endcap sectors should be able to flag the candidates from around η = 1.05 that could be detected by both a barrel and endcap sector, but they don't do that.

So even though all the following should be possible, only the first two are implemented:

00 : the candidate is not coming from an overlap-area
01 : the candidate is coming from a part of a barrel sector overlapping with another barrel sector
10 : the candidate is coming from a part of a barrel/endcap sector overlapping with another endcap/barrel sector
11 : the candidate is coming from a part of a barrel sector overlapping both with another barrel and an endcap sector

Returns: The overlap bits of the candidate

Definition at line 153 of file MuCTPIRoI.cxx.

                                           {
 
    uint16_t ol = 0;
    switch( getSectorLocation() ) {
    case MuCTPI_RDO::ENDCAP:
      ol = (m_roIWord >> LVL1::MuCTPIBits::ENDCAP_OL_SHIFT) & LVL1::MuCTPIBits::ENDCAP_OL_MASK;
      break;
    case MuCTPI_RDO::FORWARD:
      ol = 0;
      break;
    case MuCTPI_RDO::BARREL:
      ol = (m_roIWord >> LVL1::MuCTPIBits::BARREL_OL_SHIFT) & LVL1::MuCTPIBits::BARREL_OL_MASK;
      break;
    default:
      ol = 99;
      break;
    }
 
    return ol;
  }

◆ getRoiNumber()

uint16_t ROIB::MuCTPIRoI::getRoiNumber ( ) const

Method returning the RoI in which the candidate was detected.

The muon trigger sectors are divided into "RoIs", which are small parts of the detector (in η and φ) in this context.

The number of RoIs in the different sectors (especially in the barrel) are varying, but in general:

barrel sectors have <26 RoIs
endcap sectors have 148 RoIs
forward sectors have 64 RoIs

Returns: The RoI in which the muon candidate was detected

Definition at line 115 of file MuCTPIRoI.cxx.

                                         {
 
    uint16_t roi = 0;
    switch ( getSectorLocation() ) {
    case MuCTPI_RDO::ENDCAP:
      roi = (m_roIWord >> LVL1::MuCTPIBits::ROI_SHIFT) & LVL1::MuCTPIBits::ENDCAP_ROI_MASK;
      break;
    case MuCTPI_RDO::FORWARD:
      roi = (m_roIWord >> LVL1::MuCTPIBits::ROI_SHIFT) & LVL1::MuCTPIBits::FORWARD_ROI_MASK;
      break;
    case MuCTPI_RDO::BARREL:
      roi = (m_roIWord >> LVL1::MuCTPIBits::ROI_SHIFT) & LVL1::MuCTPIBits::BARREL_ROI_MASK;
      break;
    default:
      roi = 99;
      break;
    }
 
    return roi;
  }

◆ getRoiOverflow()

uint16_t ROIB::MuCTPIRoI::getRoiOverflow ( ) const

Method telling whether there were more than one candidates in this candidate's RoI.

The muon trigger sectors can't handle more than one muon candidates in a single RoI.

(RoI in this context a part of the muon detector, not the 32-bit word sent by the hardware!) If more than 1 are detected, the one with the highest p_T threshold is submitted, and this bit is raised.

Returns: 1 if the overflow bit was set, 0 otherwise

Definition at line 100 of file MuCTPIRoI.cxx.

                                           {
    return ((m_roIWord >> LVL1::MuCTPIBits::ROI_OVERFLOW_SHIFT) &
        LVL1::MuCTPIBits::ROI_OVERFLOW_MASK);
  }

◆ getSectorAddress()

unsigned int ROIB::MuCTPIRoI::getSectorAddress ( ) const

Method returning the "electronics address" of the candidate.

Returns the address of the sector that the candidate came from.

The sector address is actually a combination of the sector number and 2 bits showing the sector type. Both of which can be accessed by other member functions.

See also: MuCTPIRoI::getSectorID(); MuCTPIRoI::getSectorLocation()

Returns: The 8-bit sector address of the candidate

Definition at line 66 of file MuCTPIRoI.cxx.

                                                 {
    return ((m_roIWord >> MuCTPIRoI::ROI_CAND_SECTOR_ADDRESS_SHIFT) &
        LVL1::MuCTPIBits::CAND_SECTOR_ADDRESS_MASK);
  }

◆ getSectorID()

uint16_t ROIB::MuCTPIRoI::getSectorID ( ) const

Method returning the number of the trigger sector producing the candidate.

This is practically the number of the sector that produced the muon candidate.

Sectors are numbered in the following ranges:

0 - 31 for the barrel
0 - 47 for the endcap
0 - 23 for the forward

Returns: Number of the sector producing the muon candidate

Definition at line 200 of file MuCTPIRoI.cxx.

                                        {
 
    if( getSectorLocation() == MuCTPI_RDO::ENDCAP ) {
      return ((getSectorAddress() >> 1) & LVL1::MuCTPIBits::ENDCAP_SECTORID_MASK);
    } else {
      return ((getSectorAddress() >> 1) & LVL1::MuCTPIBits::BARREL_SECTORID_MASK);
    }
    return 0;
  }

◆ getSectorLocation()

MuCTPI_RDO::SectorLocation ROIB::MuCTPIRoI::getSectorLocation ( ) const

Method returning the name of the system that produced the RoI.

The system producing the muon candidate is encoded in the RoI word by the MuCTPI.

Using that, it's quite easy to decode which system produced the candidate.

Returns: The name of the system that produced the muon candidate

Definition at line 180 of file MuCTPIRoI.cxx.

                                                              {
 
    if( getSectorAddress() & LVL1::MuCTPIBits::ENDCAP_ADDRESS_MASK ) {
      return MuCTPI_RDO::ENDCAP;
    } else if(getSectorAddress() & LVL1::MuCTPIBits::FORWARD_ADDRESS_MASK) {
      return MuCTPI_RDO::FORWARD;
    } else {
      return MuCTPI_RDO::BARREL;
    }
  }

◆ getSectorOverflow()

uint16_t ROIB::MuCTPIRoI::getSectorOverflow ( ) const

Method telling whether there were more than two candidates in this candidate's sector.

The muon trigger sectors can only transmit information about 2 muon candidates each.

If one of them detects more than 2, it transmits the 2 with the highest p_T threshold, and raises this bit.

Returns: 1 if the overflow bit was set, 0 otherwise

Definition at line 87 of file MuCTPIRoI.cxx.

                                              {
    return ((m_roIWord >> LVL1::MuCTPIBits::CAND_OVERFLOW_SHIFT) &
        LVL1::MuCTPIBits::CAND_OVERFLOW_MASK);
  }

◆ pt()

unsigned int ROIB::MuCTPIRoI::pt ( ) const

Method returning the p_T of the RoI candidate.

The candidate's p_T is stored as a 3-bit threshold number, with the following meanings:

000 : Non-defined behaviour
001 : low-p_T threshold 1
010 : low-p_T threshold 2
011 : low-p_T threshold 3
100 : high-p_T threshold 1
101 : high-p_T threshold 2
110 : high-p_T threshold 3
111 : no candidate

Returns: The 3-bit threshold number of the candidate

Definition at line 52 of file MuCTPIRoI.cxx.

                                   {
    return ((m_roIWord >> LVL1::MuCTPIBits::CAND_PT_SHIFT) &
        LVL1::MuCTPIBits::CAND_PT_MASK);
  }

◆ roIWord()

uint32_t ROIB::MuCTPIRoI::roIWord ( ) const

Method returning the RoI word.

This method can be used to access the "original" RoI word.

Returns: The 32-bit RoI word

Definition at line 35 of file MuCTPIRoI.cxx.

                                    {
    return m_roIWord;
  }

Member Data Documentation

◆ m_roIWord

uint32_t ROIB::MuCTPIRoI::m_roIWord

private

The RoI word itself.

Definition at line 79 of file MuCTPIRoI.h.

◆ ROI_CAND_HIGHEST_PT_SHIFT

const uint32_t ROIB::MuCTPIRoI::ROI_CAND_HIGHEST_PT_SHIFT = 22

static

Position of the "highest p<sub>T</sub> bit" in the RoI word.

Definition at line 75 of file MuCTPIRoI.h.

◆ ROI_CAND_SECTOR_ADDRESS_SHIFT

const uint32_t ROIB::MuCTPIRoI::ROI_CAND_SECTOR_ADDRESS_SHIFT = 14