LVL1MUCTPIPHASE1::MuonSectorProcessor Class Reference

#include <MuonSectorProcessor.h>

Collaboration diagram for LVL1MUCTPIPHASE1::MuonSectorProcessor:

Public Member Functions
	MuonSectorProcessor (bool side)
	~MuonSectorProcessor ()
	MuonSectorProcessor (MuonSectorProcessor &&o) noexcept
	MuonSectorProcessor (const MuonSectorProcessor &)=delete
void	setMenu (const TrigConf::L1Menu *l1menu)
void	setL1TopoLUT (const L1TopoLUT *l1topoLUT)
void	configureOverlapRemoval (const std::string &lutFile)
bool	configurePtEncoding ()
void	runOverlapRemoval (LVL1MUONIF::Lvl1MuCTPIInputPhase1 *inputs, int bcid) const
std::string	makeL1TopoData (LVL1MUONIF::Lvl1MuCTPIInputPhase1 *inputs, int bcid, LVL1::MuCTPIL1Topo &l1topoData) const
bool	getSide () const

Private Attributes
std::unique_ptr< OverlapHelper >	m_overlapHelper
const TrigConf::L1Menu *	m_l1menu = nullptr
const L1TopoLUT *	m_l1topoLUT = nullptr
bool	m_side = false
std::vector< std::map< int, int > >	m_ptEncoding

Detailed Description

Definition at line 36 of file MuonSectorProcessor.h.

Constructor & Destructor Documentation

MuonSectorProcessor() [1/3]

LVL1MUCTPIPHASE1::MuonSectorProcessor::MuonSectorProcessor

(

bool

side

)

Definition at line 186 of file MuonSectorProcessor.cxx.

    :
    m_overlapHelper(std::make_unique<OverlapHelper>()),
    m_l1menu(nullptr),
    m_l1topoLUT(nullptr),
    m_side(side)
  {
  }

~MuonSectorProcessor()

LVL1MUCTPIPHASE1::MuonSectorProcessor::~MuonSectorProcessor

(

)

Definition at line 195 of file MuonSectorProcessor.cxx.

  {
  }

MuonSectorProcessor() [2/3]

LVL1MUCTPIPHASE1::MuonSectorProcessor::MuonSectorProcessor ( MuonSectorProcessor && o )

noexcept

Definition at line 199 of file MuonSectorProcessor.cxx.

      : m_overlapHelper(std::move(o.m_overlapHelper)) {}

MuonSectorProcessor() [3/3]

LVL1MUCTPIPHASE1::MuonSectorProcessor::MuonSectorProcessor ( const MuonSectorProcessor & )

delete

Member Function Documentation

configureOverlapRemoval()

void LVL1MUCTPIPHASE1::MuonSectorProcessor::configureOverlapRemoval

(

const std::string &

lutFile

)

Definition at line 207 of file MuonSectorProcessor.cxx.

  {
    m_overlapHelper->configure(lutFile);
  }

configurePtEncoding()

bool LVL1MUCTPIPHASE1::MuonSectorProcessor::configurePtEncoding

(

)

Definition at line 212 of file MuonSectorProcessor.cxx.

  {
    if (!m_l1menu) return false;
 
    m_ptEncoding.clear();
    m_ptEncoding.resize(3);
 
    //build the map between index and pt threshold.
    //the index is the 3- or 4-bit pt word, and has a different
    //pt threshold meaning depending on the subsystem.
    //the value part of the map is the pt value for the 3 subsystems,
    //and the key is the index for an arbitrary subsystem.
    //not all indices will be covered by all subsystems since
    //barrel only has 3 bits, so initialize the value tuple with -1
    const auto & exMU = &m_l1menu->thrExtraInfo().MU();
    auto rpcPtValues = exMU->knownRpcPtValues();
    auto tgcPtValues = exMU->knownTgcPtValues();
    for ( unsigned i=0; i<rpcPtValues.size(); i++){
       m_ptEncoding[0][i] = exMU->ptForRpcIdx(i);
    }
    for ( unsigned i=0; i<tgcPtValues.size(); i++){
       m_ptEncoding[1][i] = exMU->ptForTgcIdx(i);
       m_ptEncoding[2][i] = exMU->ptForTgcIdx(i);
    }
 
    return true;
  }

getSide()

bool LVL1MUCTPIPHASE1::MuonSectorProcessor::getSide ( ) const

inline

Definition at line 54 of file MuonSectorProcessor.h.

{ return m_side; };

makeL1TopoData()

std::string LVL1MUCTPIPHASE1::MuonSectorProcessor::makeL1TopoData	(	LVL1MUONIF::Lvl1MuCTPIInputPhase1 *	inputs,
		int	bcid,
		LVL1::MuCTPIL1Topo &	l1topoData ) const

Definition at line 310 of file MuonSectorProcessor.cxx.

  {
    // Barrel + EC + Fwd
    for (unsigned short isys=0;isys<LVL1MUONIF::Lvl1MuCTPIInputPhase1::numberOfSystems();isys++)
    {
      // Sectors per system
      LVL1MUONIF::Lvl1MuCTPIInputPhase1::MuonSystem system = static_cast<LVL1MUONIF::Lvl1MuCTPIInputPhase1::MuonSystem>(isys);
      for (unsigned short isec=0;isec<LVL1MUONIF::Lvl1MuCTPIInputPhase1::numberOfSector(system);isec++)
      {
    // A+C sides
    for (unsigned short isub=0;isub<2;isub++)
    {
      if (isub != (unsigned short)(m_side)) continue;
      std::shared_ptr<LVL1MUONIF::Lvl1MuSectorLogicDataPhase1> sectorData = inputs->getSectorLogicDataPtr(isys, isub, isec, bcid);
      if (!sectorData) continue;
 
      //build the sector name
      std::stringstream sectorName;
      if (isys == 0) sectorName<<"B";
      else if (isys == 1) sectorName<<"E";
      else if (isys == 2) sectorName<<"F";
 
      LVL1MUONIF::Lvl1MuCTPIInputPhase1::MuonSubSystem side = static_cast<LVL1MUONIF::Lvl1MuCTPIInputPhase1::MuonSubSystem>(isub);
      if (isys == 0)
      {
        int sectorNumber=isec;
        if (side == LVL1MUONIF::Lvl1MuCTPIInputPhase1::idSideC()) sectorNumber += 32;
        if (sectorNumber < 10) sectorName << "0";
        sectorName << sectorNumber;
      }
      else
      {
        if (side == LVL1MUONIF::Lvl1MuCTPIInputPhase1::idSideA()) sectorName << "A";
        else sectorName << "C";
        if (isec < 10) sectorName << "0";
        sectorName << isec;
      }
 
 
      for (unsigned int icand=0;icand<LVL1MUONIF::NCAND[isys];icand++)
      {
        //find the eta/phi
        int roiID = sectorData->roi(icand);
        if (roiID < 0) continue;
        int ptword = sectorData->pt(icand);
        if (ptword < 0) continue;
 
        // the following doesn't quite follow the correct nomenclature, should be (side, isub, isec, roiID) thus there was a typo chain in L399+ using isub instead of the correct isys
        // see: https://gitlab.cern.ch/atlas/athena/-/blob/master/Trigger/TrigT1/TrigT1MuctpiPhase1/src/L1TopoLUT.cxx#L161
        L1TopoCoordinates coord = m_l1topoLUT->getCoordinates(isub, isys, isec, roiID);
 
        //check for invalid decoding
        if (coord == L1TopoCoordinates())
        {
          std::stringstream err;
          err << "Couldn't decode L1Topo coordinates: Side = " << isub << ", subsystem = " << isys << ", sector = " << isec << ", roi = " << roiID;
          return err.str();
        }
 
        int ptValue = 0;
        auto enc = m_ptEncoding[isys].find(ptword);
        if (enc == m_ptEncoding[isys].end())
        {
          auto last_enc = m_ptEncoding[isys].rbegin();
          if (last_enc != m_ptEncoding[isys].rend() && ptword > last_enc->first)
          {
        ptValue = m_ptEncoding[isys].rbegin()->second;
          }
          else
          {
        std::stringstream err;
        err << "Pt threshold not found in L1Topo encoding. Thr: " << ptword << ", subsys: " << isys;
        return err.str();
          }
        }
        else ptValue=enc->second;
 
        if (ptValue < 0)
        {
          std::stringstream err;
          err << "Default value returned for pt encoding. Thr: " << ptword << ", isys: " << isys;
          return err.str();
        }
 
 
        // no longer needed, but keep for backwards compatibility
        int etacode=0;
        int phicode = 0;
        unsigned int mioctID = 0;
        unsigned int ptCode=0;
 
        LVL1::MuCTPIL1TopoCandidate cand;
        cand.setCandidateData(sectorName.str(),
                  roiID,
                  bcid,
                  (unsigned int)ptword,
                  ptCode, //removed Run3
                  (unsigned int)ptValue,
                  coord.eta,
                  coord.phi,
                  etacode, //removed Run3
                  phicode, //removed Run3
                  coord.eta_min,
                  coord.eta_max,
                  coord.phi_min,
                  coord.phi_max,
                  mioctID, //removed Run3
                  coord.ieta,
                  coord.iphi);
 
        if (isys == 0) cand.setRPCFlags(sectorData->is2candidates(icand),
                        sectorData->ovl(icand));
        else cand.setTGCFlags(sectorData->bw2or3(icand),
                  sectorData->innercoin(icand),
                  sectorData->goodmf(icand),
                  sectorData->charge(icand));
 
 
        l1topoData.addCandidate(cand);
      }
    }
      }
    }
    return "";
  }

runOverlapRemoval()

void LVL1MUCTPIPHASE1::MuonSectorProcessor::runOverlapRemoval	(	LVL1MUONIF::Lvl1MuCTPIInputPhase1 *	inputs,
		int	bcid ) const

Definition at line 241 of file MuonSectorProcessor.cxx.

  {
    std::map<std::string,std::vector<std::pair<std::shared_ptr<LVL1MUONIF::Lvl1MuSectorLogicDataPhase1>, unsigned> > > buckets;
 
    for (size_t isys=0;isys<LVL1MUONIF::Lvl1MuCTPIInputPhase1::numberOfSystems();isys++)
    {
      // Sectors per system
      LVL1MUONIF::Lvl1MuCTPIInputPhase1::MuonSystem system = static_cast<LVL1MUONIF::Lvl1MuCTPIInputPhase1::MuonSystem>(isys);
      for (size_t isec=0;isec<LVL1MUONIF::Lvl1MuCTPIInputPhase1::numberOfSector(system);isec++)
      {
    // A+C sides
    for (size_t isub=0;isub<2;isub++)
    {
      if (isub != size_t(m_side)) continue;
 
      //get a pointer to this since we'll need to modify the 'veto' flag of the SL data
      std::shared_ptr<LVL1MUONIF::Lvl1MuSectorLogicDataPhase1> sectorData = inputs->getSectorLogicDataPtr(isys, isub, isec, bcid);
      if (!sectorData) continue;
 
      for (unsigned int icand=0;icand<LVL1MUONIF::NCAND[isys];icand++)
      {
        //build the sector name
        std::string sectorName="";
        if (isys == 0) sectorName="B";
        else if (isys == 1) sectorName="E";
        else if (isys == 2) sectorName="F";
 
        int roiID = sectorData->roi(icand);
        if (roiID < 0) continue;
        int ptword = sectorData->pt(icand);
        if (ptword < 0) continue;
 
        // initializing veto flag for the latter removal step
        sectorData->veto(icand,0);
 
        for(auto rr : m_overlapHelper->relevant_regions(m_side,sectorName,roiID,isec))
        {
          // for the barrel-barrel overlap removal, only the muons having the phi-overlap flag are considered
              if( std::count(rr.begin(),rr.end(),'B') == 2 && isys == 0 && sectorData->ovl(icand) == 0 )continue;
          buckets[rr].push_back(std::make_pair(sectorData, icand));
        }
      }
    }
      }
    }
 
    for(auto candidate_vector : buckets){ // loop over candidates in OL region pair
 
      // sorting (to be tuned)
      unsigned i_notRemove = 0;
      int ptMax = 0;
      for (unsigned i=0;i<candidate_vector.second.size();i++){
    if( candidate_vector.second[i].first->veto(candidate_vector.second[i].second)==1 ) continue; // skipping already-flagged candidate
    int pt = candidate_vector.second[i].first->pt(candidate_vector.second[i].second);
    if(pt > ptMax){
      ptMax = pt;
      i_notRemove = i;
    }
      }
 
      //for each candidate except the highest pt, mark them for removal
      for (unsigned i=0;i<candidate_vector.second.size();i++)
      {
    if( candidate_vector.second[i].first->veto(candidate_vector.second[i].second)==1 ) continue; // skipping already-flagged candidate
    candidate_vector.second[i].first->veto(candidate_vector.second[i].second, (i==i_notRemove)?0:1 );
      }
    }
  }

setL1TopoLUT()

void LVL1MUCTPIPHASE1::MuonSectorProcessor::setL1TopoLUT ( const L1TopoLUT * l1topoLUT )

inline

Definition at line 47 of file MuonSectorProcessor.h.

{m_l1topoLUT=l1topoLUT;}

setMenu()

void LVL1MUCTPIPHASE1::MuonSectorProcessor::setMenu

(

const TrigConf::L1Menu *

l1menu

)

Definition at line 202 of file MuonSectorProcessor.cxx.

  {
    m_l1menu = l1menu;
  }

Member Data Documentation

m_l1menu

const TrigConf::L1Menu* LVL1MUCTPIPHASE1::MuonSectorProcessor::m_l1menu = nullptr

private

Definition at line 59 of file MuonSectorProcessor.h.

m_l1topoLUT

const L1TopoLUT* LVL1MUCTPIPHASE1::MuonSectorProcessor::m_l1topoLUT = nullptr

private

Definition at line 60 of file MuonSectorProcessor.h.

m_overlapHelper

std::unique_ptr<OverlapHelper> LVL1MUCTPIPHASE1::MuonSectorProcessor::m_overlapHelper

private

Definition at line 58 of file MuonSectorProcessor.h.

m_ptEncoding

std::vector<std::map<int, int> > LVL1MUCTPIPHASE1::MuonSectorProcessor::m_ptEncoding

private

Definition at line 64 of file MuonSectorProcessor.h.

m_side

bool LVL1MUCTPIPHASE1::MuonSectorProcessor::m_side = false

private

Definition at line 61 of file MuonSectorProcessor.h.

---

The documentation for this class was generated from the following files:

• MuonSectorProcessor.h
• MuonSectorProcessor.cxx