RecJetRoI.cxx

Go to the documentation of this file.

// Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
 
/***************************************************************************
                         RecJetRoI.cxx  -  description
                            -------------------
   begin                : Mon Jan 22 2001
   email                : moyse@heppch.ph.qmw.ac.uk
***************************************************************************/
 
// STL include(s):
#include <cmath>
 
// Trigger config includes:
#include "TrigConfL1Data/L1DataDef.h"
#include "TrigConfL1Data/TriggerThreshold.h"
#include "TrigConfL1Data/TriggerThresholdValue.h"
#include "TrigConfL1Data/JetThresholdValue.h"
#include "TrigConfL1Data/CaloInfo.h"
#include "TrigConfData/L1Menu.h"
 
// Local include(s):
#include "TrigT1Interfaces/RecJetRoI.h"
#include "TrigT1Interfaces/JEPRoIDecoder.h"
 
using namespace std;
using namespace TrigConf;
 
LVL1::RecJetRoI::RecJetRoI( unsigned int RoIWord,
                            const std::vector<TriggerThreshold *> *caloThresholds) {
 
  m_roiWord = RoIWord;
  m_decoder = new JEPRoIDecoder();
  m_version = m_decoder->jetRoIVersion(m_roiWord);
  m_coordRange = m_decoder->coordinate(m_roiWord);
 
  if (m_version > 1)
    this->constructRun2(caloThresholds);
  else
    this->constructRun1(caloThresholds);
}
 
LVL1::RecJetRoI::RecJetRoI( unsigned int RoIWord,
                            const TrigConf::L1Menu * const l1menu) :
  m_roiWord(RoIWord),
  m_decoder(new JEPRoIDecoder()),
  m_version(m_decoder->jetRoIVersion(m_roiWord)),
  m_coordRange(m_decoder->coordinate(m_roiWord))
{
  constructRun3(l1menu);
}
 
// copy constructor
LVL1::RecJetRoI::RecJetRoI( const RecJetRoI &obj ) :
   m_roiWord(obj.m_roiWord),
   m_decoder(new JEPRoIDecoder()),
   m_version(obj.m_version),
   m_coordRange(obj.m_coordRange),
   m_triggerThresholdValue(obj.m_triggerThresholdValue),
   m_windowSize(obj.m_windowSize)
{}
 
// assignment operator
LVL1::RecJetRoI&
LVL1::RecJetRoI::operator=( const RecJetRoI & rhs ) {
   if(this != &rhs) {
      m_roiWord = rhs.m_roiWord;
      delete m_decoder;
      m_decoder = new JEPRoIDecoder();
      m_version = rhs.m_version;
      m_coordRange = rhs.m_coordRange;
      m_thresholdMask = rhs.m_thresholdMask;
      m_triggerThresholdValue = rhs.m_triggerThresholdValue;
      m_windowSize = rhs.m_windowSize;
   }
   return *this;
}
 
LVL1::RecJetRoI::~RecJetRoI() { delete m_decoder; }
 
void LVL1::RecJetRoI::constructRun1(const std::vector<TriggerThreshold *> *caloThresholds)
{
 
   m_thresholdMask = m_roiWord & 0xfff;
 
   std::string jetTriggerType = L1DataDef::jetType();
   if (this->isForwardJet())
      jetTriggerType =
          ((this->eta() > 0) ? L1DataDef::jfType() : L1DataDef::jbType());
 
   //
   // Copy the thresholds into a map - makes matching up the passed ones very
   // easy
   //
 
   std::map<unsigned int, TriggerThreshold *> thrMap;
   for (std::vector<TriggerThreshold *>::const_iterator it =
            caloThresholds->begin();
        it != caloThresholds->end(); ++it)
   {
      if ((*it)->type() == jetTriggerType)
      {
         unsigned int num = static_cast<unsigned int>((*it)->thresholdNumber());
         thrMap.insert(std::map<unsigned int, TriggerThreshold *>::value_type(num, (*it)));
      }
   }
 
   //
   // Extract the properties of the passed thresholds:
   //
   const vector<unsigned int> passed_thresholds =
       (this->isForwardJet() ? m_decoder->fwdThresholdsPassed(m_roiWord)
                             : m_decoder->thresholdsPassed(m_roiWord));
 
   int iphi = int((m_coordRange.phiRange().min() + 0.025) * 32 / M_PI);
   int ieta =
       int((this->eta() + ((this->eta() > 0.01) ? 0.025 : -0.025)) / 0.1) - 1;
   // Adjustment due to irregular geometries
   if (ieta > 24)
      ieta += 2;
 
   for (vector<unsigned int>::const_iterator itp = passed_thresholds.begin();
        itp != passed_thresholds.end(); ++itp)
   {
      std::map<unsigned int, TriggerThreshold *>::const_iterator thr =
          thrMap.find(*itp - 1);
      if (thr != thrMap.end())
      {
         TriggerThresholdValue *ttv =
             thr->second->triggerThresholdValue(ieta, iphi);
         JetThresholdValue *jtv = dynamic_cast<JetThresholdValue *>(ttv);
         if (jtv)
         {
            m_triggerThresholdValue.insert(std::map<unsigned int, unsigned int>::value_type(
                *itp, jtv->thresholdValueCount()));
            m_windowSize.insert(
                std::map<unsigned int, unsigned int>::value_type(*itp, jtv->window()));
         }
      } // end "found threshold in map"
   }    // end loop through passed thresholds
 
   return;
}
 
void 
LVL1::RecJetRoI::constructRun2(const std::vector<TriggerThreshold *> *caloThresholds)
{
 
  m_thresholdMask = 0;
  m_triggerThresholdValue.clear();
  m_windowSize.clear();
 
  int ieta =
      int((this->eta() + ((this->eta() > 0.01) ? 0.025 : -0.025)) / 0.1) - 1;
  // Adjustment due to irregular geometries
  if (ieta > 24)
    ieta += 2;
  int iphi = int((m_coordRange.phiRange().min() + 0.025) * 32 / M_PI);
  //
  // Iterate through vector of thresholds and see which ones this RoI satisfies
  //
  for (std::vector<TriggerThreshold *>::const_iterator it =
           caloThresholds->begin();
       it != caloThresholds->end(); ++it) {
    if ((*it)->type() == L1DataDef::jetType()) {
      // Does it satisfy this one?
      // Start by extracting threshold values
      TriggerThresholdValue *ttv = (*it)->triggerThresholdValue(ieta, iphi);
      JetThresholdValue *jtv = dynamic_cast<JetThresholdValue *>(ttv);
      if (jtv) {
        float scale = jtv->caloInfo().globalJetScale();
        unsigned int etCut = jtv->ptcut();
        unsigned int threshold = etCut * scale;
        JetWindowSize::Size window = jtv->windowSize();
        unsigned int roiET =
            (window == JetWindowSize::LARGE ? etLarge() : etSmall());
        if (roiET > threshold) {
          unsigned int num = static_cast<unsigned int>((*it)->thresholdNumber());
          m_triggerThresholdValue.insert(
              std::map<unsigned int, unsigned int>::value_type(num, etCut));
          m_windowSize.insert(
              std::map<unsigned int, unsigned int>::value_type(num, window));
          m_thresholdMask |= (1 << num);
        } // passes cuts
      }   // JetThresholdValue pointer valid
    }     // correct threshold type
  }       // Loop over thresholds
}
 
void
LVL1::RecJetRoI::constructRun3(const TrigConf::L1Menu * const l1menu)
{
   int ieta = int((this->eta() + ((this->eta() > 0.01) ? 0.025 : -0.025)) / 0.1) - 1;
   // Adjustment due to irregular geometries
   if (ieta > 24)
   {
      ieta += 2;
   }
 
   // Iterate through vector of thresholds and see which ones this RoI satisfies
   for (shared_ptr<TrigConf::L1Threshold> thr : l1menu->thresholds("JET"))
   {
      // Does it satisfy this one?
      // Start by extracting threshold values
      auto jetThr = std::dynamic_pointer_cast<TrigConf::L1Threshold_JET>(thr);
      if (!jetThr)
      {
         continue;
      }
 
      // test eT
      unsigned int etCut = std::round(jetThr->thrValue(ieta)); // threshold value in GeV (integer for legacy thr)
      unsigned int etCounts = jetThr->thrValueCounts(ieta);    // threshold counts (threshold value * emscale)
      TrigConf::JetWindowSize::Size window = (jetThr->window() == 8) ? TrigConf::JetWindowSize::LARGE : TrigConf::JetWindowSize::SMALL;
      unsigned int roiET = (window == TrigConf::JetWindowSize::LARGE) ? RecJetRoI::etLarge() : RecJetRoI::etSmall();
      bool eTPassed = (roiET > etCounts);
 
      if (eTPassed)
      {
         const unsigned int num = thr->mapping();
         m_triggerThresholdValue[num] = etCut;
         m_windowSize[num] = window;
         m_thresholdMask |= (1 << num);
      } // passes cuts
   }    // Loop over thresholds
}
 
unsigned int
LVL1::RecJetRoI::roiWord() const { return m_roiWord; }
 
double
LVL1::RecJetRoI::phi() const
{
  double roiPhi = m_coordRange.phi();
  if (roiPhi > M_PI)
    roiPhi -= 2 * M_PI;
  return roiPhi;
}
 
double
LVL1::RecJetRoI::eta() const { return m_coordRange.eta(); }
 
unsigned int
LVL1::RecJetRoI::crate() const { return m_decoder->crate(m_roiWord); }
 
unsigned int 
LVL1::RecJetRoI::module() const { return m_decoder->module(m_roiWord); }
 
unsigned int 
LVL1::RecJetRoI::frame() const {
  unsigned int row = m_decoder->row(m_roiWord);
  unsigned int col = m_decoder->column(m_roiWord);
  return ((col & 2) << 1) + (row >> 1);
}
 
unsigned int 
LVL1::RecJetRoI::localcoord() const {
  unsigned int row = m_decoder->row(m_roiWord);
  unsigned int col = m_decoder->column(m_roiWord);
  return (col & 1) + ((row & 1) << 1);
}
 
unsigned int 
LVL1::RecJetRoI::etLarge() const {
  if (m_version > 1) {
    return m_decoder->etLarge(m_roiWord);
  } else {
    float highest = 0;
    std::map<unsigned int, unsigned int>::const_iterator it =
        m_triggerThresholdValue.begin();
    for (; it != m_triggerThresholdValue.end(); ++it)
      if (it->second > highest)
        highest = it->second;
    return highest;
  }
}
 
unsigned int
LVL1::RecJetRoI::etSmall() const {
  if (m_version > 1) {
    return m_decoder->etSmall(m_roiWord);
  } else {
    float highest = 0;
    std::map<unsigned int, unsigned int>::const_iterator it =
        m_triggerThresholdValue.begin();
    for (; it != m_triggerThresholdValue.end(); ++it)
      if (it->second > highest)
        highest = it->second;
    return highest;
  }
}
 
unsigned int
LVL1::RecJetRoI::thresholdPattern() const { return m_thresholdMask; }
 
bool
LVL1::RecJetRoI::passedThreshold(unsigned int thresholdNumber) const {
 
  bool value = false;
 
  std::map<unsigned int, unsigned int>::const_iterator it =
      m_triggerThresholdValue.find(thresholdNumber);
  if (it != m_triggerThresholdValue.end())
    value = true;
 
  return value;
}
 
bool
LVL1::RecJetRoI::passedFwdThreshold(unsigned int thresholdNumber) const {
 
  if ((m_version < 2) && this->isValidThreshold(thresholdNumber)) {
    return (((1 << (thresholdNumber + 7)) & m_roiWord) > 0);
  }
  return false;
}
 
LVL1::CoordinateRange
LVL1::RecJetRoI::coord() const { return m_coordRange; }
 
std::vector<unsigned int>
LVL1::RecJetRoI::thresholdsPassed() const {
 
  std::vector<unsigned int> newVec;// = new std::vector<unsigned int>;
 
  unsigned int nThresh = TrigT1CaloDefs::numOfJetCMXThresholds;
  if (m_version == 1) {
    if (this->isForwardJet())
      nThresh = TrigT1CaloDefs::numOfFwdJetThresholds;
    else
      nThresh = TrigT1CaloDefs::numOfJetThresholds;
  }
 
  for (unsigned int iTh = 0; iTh <= nThresh; ++iTh) {
    std::map<unsigned int, unsigned int>::const_iterator it =
        m_triggerThresholdValue.find(iTh);
    if (it != m_triggerThresholdValue.end())
      newVec.push_back(iTh);
  }
 
  return newVec;
}
 
 
unsigned int
LVL1::RecJetRoI::triggerThreshold(const unsigned int thresh) const {
  map<unsigned int, unsigned int>::const_iterator it =
      m_triggerThresholdValue.find(thresh);
  if (it != m_triggerThresholdValue.end()) {
    return it->second;
  }
  return TrigT1CaloDefs::Error;
}
 
unsigned int
LVL1::RecJetRoI::windowSize(const unsigned int thresh) const {
  map<unsigned int, unsigned int>::const_iterator it = m_windowSize.find(thresh);
  if (it != m_windowSize.end()) {
    return it->second;
  }
  return TrigT1CaloDefs::Error;
}
 
bool
LVL1::RecJetRoI::isValidThreshold(const unsigned int thresh) const
{
  if (!this->isForwardJet()) {
    return (thresh <= TrigT1CaloDefs::numOfJetThresholds);
  } else {
    return (thresh <= TrigT1CaloDefs::numOfFwdJetThresholds);
  }
}
 
bool
LVL1::RecJetRoI::isForwardJet() const
{
  if (m_version <= 1 && ((1 << 18) & m_roiWord))
    return true;
  return false;
}