LVL1MUCTPIPHASE1::TriggerProcessor Class Reference

#include <TriggerProcessor.h>

Collaboration diagram for LVL1MUCTPIPHASE1::TriggerProcessor:

Public Member Functions
	TriggerProcessor ()=default
void	setMenu (const TrigConf::L1Menu *l1menu)
void	setTrigTool (LVL1::TrigThresholdDecisionTool &tool)
LVL1MUONIF::Lvl1MuCTPIInputPhase1	mergeInputs (const std::vector< const LVL1MUONIF::Lvl1MuCTPIInputPhase1 * > &inputs) const
std::string	computeMultiplicities (LVL1MUONIF::Lvl1MuCTPIInputPhase1 &mergedInputs, int bcid, MUCTPIResults &results) const

Private Attributes
const TrigConf::L1Menu *	m_l1menu {nullptr}
LVL1::TrigThresholdDecisionTool *	m_trigThresholdDecisionTool {nullptr}

Detailed Description

Definition at line 27 of file TriggerProcessor.h.

Constructor & Destructor Documentation

TriggerProcessor()

LVL1MUCTPIPHASE1::TriggerProcessor::TriggerProcessor ( )

default

Member Function Documentation

computeMultiplicities()

std::string LVL1MUCTPIPHASE1::TriggerProcessor::computeMultiplicities	(	LVL1MUONIF::Lvl1MuCTPIInputPhase1 &	mergedInputs,
		int	bcid,
		MUCTPIResults &	results ) const

Definition at line 40 of file TriggerProcessor.cxx.

  {
    results.ctp_words.clear();
    results.daq_data.clear();
 
    //initialize the vector to hold the threshold multiplicities
    const std::vector<std::shared_ptr<TrigConf::L1Threshold> > & thresholds = m_l1menu->thresholds("MU");
    int nThresholds = thresholds.size();
    std::vector<unsigned int> multiplicities(nThresholds,0);
 
 
    // Barrel + EC + Fwd
    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++)
        {
      std::shared_ptr<LVL1MUONIF::Lvl1MuSectorLogicDataPhase1> sectorData = mergedInputs.getSectorLogicDataPtr(isys, isub, isec, bcid);
          if (!sectorData) continue;
 
          const unsigned int& ncand_max = LVL1MUONIF::NCAND[isys];
          for (unsigned int icand=0;icand<ncand_max;icand++)
          {
            int thresh = sectorData->pt(icand);
            if (thresh == -1) continue; // no candidate
            int roiID = sectorData->roi(icand);
            if (roiID < 0) continue;
 
            // Build the DAQ word
            uint32_t daq_word=0;
 
            // Some definitions that are different between subsystems
            uint32_t ROI_MASK=0;
            uint32_t SECTOR_MASK = 0;
            uint32_t SUBSYS_MASK = 0x3;
            uint32_t SUBSYS_ID = 0; // default for barrel
            if (isys == 0) 
            {
              ROI_MASK = LVL1::MuCTPIBits::BARREL_ROI_MASK;
              SECTOR_MASK = LVL1::MuCTPIBits::BARREL_SECTORID_MASK;
            }
            else if (isys == 1) 
            {
              ROI_MASK = LVL1::MuCTPIBits::ENDCAP_ROI_MASK;
              SECTOR_MASK = LVL1::MuCTPIBits::ENDCAP_SECTORID_MASK;
              SUBSYS_ID = 2; // not a typo!
            }
            else if (isys == 2) 
            {
              ROI_MASK = LVL1::MuCTPIBits::FORWARD_ROI_MASK;
              SECTOR_MASK = LVL1::MuCTPIBits::FORWARD_SECTORID_MASK;
              SUBSYS_ID = 1; // not a typo!
            }
 
            //General formula for each subword:
            //daq_word |= (subword & LVL1::MuCTPIBits::MASK) << LVL1::MuCTPIBits::SHIFT
            
            //ROI word
            daq_word |= (sectorData->roi(icand)              & ROI_MASK)                       << LVL1::MuCTPIBits::RUN3_ROI_SHIFT;
 
            //PT word
            daq_word |= (thresh                              & LVL1::MuCTPIBits::RUN3_CAND_PT_MASK)       << LVL1::MuCTPIBits::RUN3_CAND_PT_SHIFT;
 
            //CANDIDIATE FLAGS
            if (isys == 0) 
            {
              daq_word |= (sectorData->ovl(icand)              & LVL1::MuCTPIBits::RUN3_CAND_WORD_CANDFLAGS_BA_PHIOVERLAP_MASK) << LVL1::MuCTPIBits::RUN3_CAND_WORD_CANDFLAGS_BA_PHIOVERLAP_SHIFT;
              daq_word |= (sectorData->is2candidates(icand)    & LVL1::MuCTPIBits::ROI_OVERFLOW_MASK)   << LVL1::MuCTPIBits::RUN3_ROI_OVERFLOW_SHIFT;
            }
            else
            {
              daq_word |= (sectorData->charge(icand)           & 0x1) << LVL1::MuCTPIBits::RUN3_CAND_TGC_CHARGE_SIGN_SHIFT;
              daq_word |= (sectorData->bw2or3(icand)           & 0x1) << LVL1::MuCTPIBits::RUN3_CAND_TGC_BW2OR3_SHIFT;
              daq_word |= (sectorData->innercoin(icand)        & 0x1) << LVL1::MuCTPIBits::RUN3_CAND_TGC_INNERCOIN_SHIFT;
              daq_word |= (sectorData->goodmf(icand)           & 0x1) << LVL1::MuCTPIBits::RUN3_CAND_TGC_GOODMF_SHIFT;
            }
 
            //CANDIDATE VETO FLAG
            daq_word |= (sectorData->veto(icand)             & 0x1)                            << LVL1::MuCTPIBits::RUN3_CAND_VETO_SHIFT;
 
            //SECTOR FLAGS
            daq_word |= (sectorData->is2candidatesInSector() & LVL1::MuCTPIBits::CAND_OVERFLOW_MASK) << LVL1::MuCTPIBits::RUN3_CAND_OVERFLOW_SHIFT;
 
            //SECTOR ADDRESS
            daq_word |= (isub      & LVL1::MuCTPIBits::SECTOR_HEMISPHERE_MASK)   << LVL1::MuCTPIBits::RUN3_CAND_SECTOR_ADDRESS_SHIFT;
            daq_word |= (isec      & SECTOR_MASK)                          << LVL1::MuCTPIBits::RUN3_CAND_SECTORID_SHIFT;
            daq_word |= (SUBSYS_ID & SUBSYS_MASK)                          << LVL1::MuCTPIBits::RUN3_SUBSYS_ADDRESS_SHIFT;
 
 
            // Add extra bit in front to flag that this is a RUN3 RoI
            daq_word |= 1u << 31;
 
            //find the trigger decisions
            std::vector<std::pair<std::shared_ptr<TrigConf::L1Threshold>, bool> > decisions = m_trigThresholdDecisionTool->getThresholdDecisions(
              daq_word, m_l1menu->thresholds("MU"), m_l1menu->thrExtraInfo().MU());
            results.daq_data.push_back(DAQData(daq_word, decisions));
 
            //
            // Perform multiplicity counting
            //
 
            //if this candidate has been flagged as overlapping, stop here and don't count it in the multiplicity
            if (sectorData->veto(icand)) continue;
 
            //basic check that the size vectors are equal
            if (decisions.size() != thresholds.size()) return "Threshold vector different size than decision vector";
 
            //loop over each muon threshold passed and see if this candidate satisfies it.
            //if so, increment the multiplicity of this threshold
            for (unsigned ithresh=0;ithresh<decisions.size();ithresh++)
            {
              //check that the pointers are ordered correctly
              if (decisions[ithresh].first != thresholds[ithresh]) return "Invalid threshold ordering";
              if (decisions[ithresh].second) 
              {
                ++multiplicities[ithresh];
              }
            }
          } // N Cand
        } // N Subsys
      } // N Sectors
    } // N Systems
 
    //build the CTP words with bitset:
    //first build the bitset that contains the full word
    const TrigConf::L1Connector & optConn = m_l1menu->connector("MuCTPiOpt0");
 
    std::bitset<256> full_ctp_word = 0;
    unsigned int lastPos = 0;
    for (int i=0;i<nThresholds;i++)
    {
      if(!optConn.hasLine(thresholds[i]->name())) { // not all thresholds are on the multiplicity output line
        continue;
      }
      auto & triggerline = optConn.triggerLine(thresholds[i]->name());
      unsigned nbits = triggerline.endbit() - triggerline.startbit() + 1;
      lastPos = std::max(lastPos,triggerline.endbit()); // keep track of highest bit
 
      unsigned int maxMult = pow2.at(nbits)-1; // multiplicity caped at 2**nbits-1
      std::bitset<256> mult = ( multiplicities[i]>maxMult ? maxMult : multiplicities[i] ); // needs to be a bitset<256> in order to shift it by more than 32
 
      full_ctp_word |= (mult << triggerline.startbit());
    }
 
    // now divide up into a vector of 32-bit unsigned ints
    const std::bitset<256> u32i_mask = 0xffffffff;
    unsigned n32_ints = lastPos/32 + 1;
    // if (lastPos % 32 != 0) n32_ints += 1;
    for (unsigned i=0;i<n32_ints;i++)
    {
      unsigned int word = static_cast<unsigned int>((full_ctp_word & u32i_mask).to_ulong());
      results.ctp_words.push_back(word);
      full_ctp_word >>= 32;
    }
 
    return "";
  }

mergeInputs()

LVL1MUONIF::Lvl1MuCTPIInputPhase1 LVL1MUCTPIPHASE1::TriggerProcessor::mergeInputs

(

const std::vector< const LVL1MUONIF::Lvl1MuCTPIInputPhase1 * > &

inputs

)

const

Definition at line 32 of file TriggerProcessor.cxx.

  {
    LVL1MUONIF::Lvl1MuCTPIInputPhase1 mergedInputs;
    int nrInputs = inputs.size();
    for (int i=0;i<nrInputs;i++) mergedInputs.merge(*inputs[i]);
    return mergedInputs;
  }

setMenu()

void LVL1MUCTPIPHASE1::TriggerProcessor::setMenu

(

const TrigConf::L1Menu *

l1menu

)

Definition at line 27 of file TriggerProcessor.cxx.

  {
    m_l1menu = l1menu;
  }

setTrigTool()

void LVL1MUCTPIPHASE1::TriggerProcessor::setTrigTool ( LVL1::TrigThresholdDecisionTool & tool )

inline

Definition at line 36 of file TriggerProcessor.h.

{m_trigThresholdDecisionTool=&tool;}

Member Data Documentation

m_l1menu

const TrigConf::L1Menu* LVL1MUCTPIPHASE1::TriggerProcessor::m_l1menu {nullptr}

private

Definition at line 44 of file TriggerProcessor.h.

{nullptr};

m_trigThresholdDecisionTool

LVL1::TrigThresholdDecisionTool* LVL1MUCTPIPHASE1::TriggerProcessor::m_trigThresholdDecisionTool {nullptr}

private

Definition at line 45 of file TriggerProcessor.h.

{nullptr};

---

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

• TriggerProcessor.h
• TriggerProcessor.cxx