ATLAS Offline Software
Classes | Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
LVL1::TrigThresholdDecisionTool Class Reference

#include <TrigThresholdDecisionTool.h>

Inheritance diagram for LVL1::TrigThresholdDecisionTool:
Collaboration diagram for LVL1::TrigThresholdDecisionTool:

Classes

struct  RPCFlagDecision
 
struct  TGCFlagDecision
 

Public Member Functions

 TrigThresholdDecisionTool (const std::string &type, const std::string &name, const IInterface *parent)
 
virtual StatusCode initialize () override
 
virtual StatusCode start () override
 
virtual uint64_t getPattern (const xAOD::MuonRoI &roi, const ThrVec &menuThresholds, const TrigConf::L1ThrExtraInfoBase &menuExtraInfo) const override
 
virtual uint64_t getPattern (uint32_t dataWord, const ThrVec &menuThresholds, const TrigConf::L1ThrExtraInfoBase &menuExtraInfo) const
 
virtual std::vector< std::pair< std::shared_ptr< TrigConf::L1Threshold >, bool > > getThresholdDecisions (uint32_t dataWord, const EventContext &eventContext) const override
 
virtual std::vector< std::pair< std::shared_ptr< TrigConf::L1Threshold >, bool > > getThresholdDecisions (uint32_t dataWord, const ThrVec &menuThresholds, const TrigConf::L1ThrExtraInfoBase &menuExtraInfo) const override
 
virtual std::pair< std::string, double > getMinThresholdNameAndValue (const std::vector< std::pair< std::shared_ptr< TrigConf::L1Threshold >, bool > > &decisions, const double &eta=0) const override
 

Protected Member Functions

bool isExcludedRPCROI (const TrigConf::L1ThrExtraInfo_MU &menuExtraInfo, const std::string &rpcExclROIList, unsigned roi, unsigned sectorID, bool isSideC) const
 
bool getTGCDecision (const std::string &tgcFlags, bool F, bool C, bool H) const
 
void makeTGCDecision (const std::string &tgcFlags, bool F, bool C, bool H)
 
bool getRPCDecision (const std::string &rpcFlags, bool M) const
 
void makeRPCDecision (const std::string &rpcFlags, bool M)
 
void parseFlags (const std::string &flags)
 
std::vector< std::string > parseString (const std::string &str, const std::string &sep) const
 
std::string getShapedFlags (const std::string &flags) const
 

Protected Attributes

ToolHandle< LVL1::ITrigT1MuonRecRoiTool > m_rpcTool {this, "RPCRecRoiTool", "LVL1::TrigT1RPCRecRoiTool/LVL1__TrigT1RPCRecRoiTool", "Tool to get the eta/phi coordinates in the RPC"}
 
ToolHandle< LVL1::ITrigT1MuonRecRoiTool > m_tgcTool {this, "TGCRecRoiTool", "LVL1::TrigT1TGCRecRoiTool/LVL1__TrigT1TGCRecRoiTool", "Tool to get the eta/phi coordinates in the TGC"}
 
std::map< std::string, std::vector< std::vector< std::string > > > m_parsed_flags
 
std::map< std::string, std::set< TGCFlagDecision > > m_tgcFlag_decisions
 
std::map< std::string, std::set< RPCFlagDecision > > m_rpcFlag_decisions
 

Detailed Description

Definition at line 39 of file TrigThresholdDecisionTool.h.

Constructor & Destructor Documentation

◆ TrigThresholdDecisionTool()

LVL1::TrigThresholdDecisionTool::TrigThresholdDecisionTool ( const std::string &  type,
const std::string &  name,
const IInterface *  parent 
)

Definition at line 15 of file TrigThresholdDecisionTool.cxx.

18  : base_class(type, name, parent) {}

Member Function Documentation

◆ getMinThresholdNameAndValue()

std::pair< std::string, double > LVL1::TrigThresholdDecisionTool::getMinThresholdNameAndValue ( const std::vector< std::pair< std::shared_ptr< TrigConf::L1Threshold >, bool > > &  decisions,
const double &  eta = 0 
) const
overridevirtual

Definition at line 209 of file TrigThresholdDecisionTool.cxx.

210  {
211  //find the highest pt threshold passed - depite the name of this function
212  std::string thrName="";
213  //just some high value ...
214  double thrVal=999999999999;
215  for (unsigned idec=0;idec<decisions.size();++idec) {
216  if (!decisions[idec].second) continue;
217  std::shared_ptr<TrigConf::L1Threshold> thr = decisions[idec].first;
218  if (thr->thrValue(eta) > thrVal)
219  {
220  thrVal = thr->thrValue(eta);
221  thrName = thr->name();
222  }
223  }
224  //if nothing is found set back to the old (broken default value)
225  if (thrVal==999999999999) thrVal=0;
226  return std::make_pair(thrName, thrVal);
227  }

◆ getPattern() [1/2]

uint64_t LVL1::TrigThresholdDecisionTool::getPattern ( const xAOD::MuonRoI &  roi,
const ThrVec &  menuThresholds,
const TrigConf::L1ThrExtraInfoBase &  menuExtraInfo 
) const
overridevirtual

Definition at line 78 of file TrigThresholdDecisionTool.cxx.

80  {
81  return getPattern(roi.roiWord(), menuThresholds, menuExtraInfo);
82  }

◆ getPattern() [2/2]

uint64_t LVL1::TrigThresholdDecisionTool::getPattern ( uint32_t  dataWord,
const ThrVec &  menuThresholds,
const TrigConf::L1ThrExtraInfoBase &  menuExtraInfo 
) const
virtual

Definition at line 84 of file TrigThresholdDecisionTool.cxx.

86  {
87  uint64_t thresholdsPattern = 0;
88 
89  //first figure out if we need to use the RPC or TGC tool for decoding the ROI
90  LVL1::ITrigT1MuonRecRoiTool::MuonTriggerSystem system = m_rpcTool->getSystem(dataWord);
91  const LVL1::ITrigT1MuonRecRoiTool* roiTool;
92  if (system == LVL1::ITrigT1MuonRecRoiTool::Barrel) roiTool = &(*m_rpcTool);
93  else roiTool = &(*m_tgcTool);
94 
95  //buffer the some information
96  unsigned isub = roiTool->getBitMaskValue(&dataWord, roiTool->SubSysIDMask());
97  LVL1MUONIF::Lvl1MuCTPIInputPhase1::MuonSubSystem side = static_cast<LVL1MUONIF::Lvl1MuCTPIInputPhase1::MuonSubSystem>(isub);
98  unsigned ptword = roiTool->getBitMaskValue(&dataWord, roiTool->ThresholdMask());
99  unsigned roi, sectorID;
100  if (system == LVL1::ITrigT1MuonRecRoiTool::Barrel) {
101  roi = roiTool->getBitMaskValue(&dataWord, roiTool->BarrelRoIMask());
102  sectorID = roiTool->getBitMaskValue(&dataWord, roiTool->BarrelSectorIDMask());
103  } else if (system == LVL1::ITrigT1MuonRecRoiTool::Endcap) {
104  roi = roiTool->getBitMaskValue(&dataWord, roiTool->EndcapRoIMask());
105  sectorID = roiTool->getBitMaskValue(&dataWord, roiTool->EndcapSectorIDMask());
106  } else { // Forward
107  roi = roiTool->getBitMaskValue(&dataWord, roiTool->ForwardRoIMask());
108  sectorID = roiTool->getBitMaskValue(&dataWord, roiTool->ForwardSectorIDMask());
109  }
110  const TrigConf::L1ThrExtraInfo_MU& muThrExtraInfo = dynamic_cast<const TrigConf::L1ThrExtraInfo_MU&>(menuExtraInfo);
111 
112  //buffer (notional) TGC/RPC flags
113  bool F=false, C=false, H=false, M=false;
114  if (system == LVL1::ITrigT1MuonRecRoiTool::Barrel)
115  {
116  M = dataWord & roiTool->OverflowPerRoIMask();
117  }
118  else
119  {
120  F = dataWord & roiTool->BW2Or3Mask();
121  C = dataWord & roiTool->InnerCoinMask();
122  H = dataWord & roiTool->GoodMFMask();
123  }
124 
125  //loop over the thresholds
126  for (const std::shared_ptr<TrigConf::L1Threshold>& thrBase : menuThresholds) {
127  std::shared_ptr<TrigConf::L1Threshold_MU> thr = std::static_pointer_cast<TrigConf::L1Threshold_MU>(thrBase);
128 
129  bool passed{false};
130  if (system == LVL1::ITrigT1MuonRecRoiTool::Barrel) {
131  //skip the threshold with regions not corresponding to ALL or barrel
132  if (thr->region().find("ALL") == std::string::npos &&
133  thr->region().find("BA") == std::string::npos) continue;
134 
135  //veto this candidate from this multiplicity if it's part of the excluded ROI list
136  const bool isSideC = (side == LVL1MUONIF::Lvl1MuCTPIInputPhase1::idSideC());
137  if (isExcludedRPCROI(muThrExtraInfo, thr->rpcExclROIList(), roi, sectorID, isSideC)) continue;
138 
139  if (ptword >= thr->idxBarrel()) {
140  // mark this threshold as passed
141  passed = true;
142  }
143 
144  passed &= getRPCDecision(getShapedFlags(thr->rpcFlags()), M);
145  }
146  else { // Endcap or Forward
147  if (system == LVL1MUONIF::Lvl1MuCTPIInputPhase1::idEndcapSystem()) { // Endcap
148  //skip the threshold with regions not corresponding to ALL or endcap
149  if (thr->region().find("ALL") == std::string::npos &&
150  thr->region().find("EC") == std::string::npos) continue;
151 
152  if (ptword >= thr->idxEndcap()) {
153  // mark this threshold as passed
154  passed = true;
155  }
156  }
157  else { // Forward
158  //skip the threshold with regions not corresponding to ALL or forward
159  if (thr->region().find("ALL") == std::string::npos &&
160  thr->region().find("FW") == std::string::npos) continue;
161 
162  if (ptword >= thr->idxForward()) {
163  // mark this threshold as passed
164  passed = true;
165  }
166  }
167 
168  passed &= getTGCDecision(getShapedFlags(thr->tgcFlags()), F, C, H);
169  } // end Endcap or Forward
170 
171  if (passed) {
172  // set the corresponding bit in the pattern
173  thresholdsPattern |= (1 << thr->mapping());
174  }
175 
176  } // loop over thresholds
177 
178  return thresholdsPattern;
179  }

◆ getRPCDecision()

bool LVL1::TrigThresholdDecisionTool::getRPCDecision ( const std::string &  rpcFlags,
bool  M 
) const
protected

Definition at line 309 of file TrigThresholdDecisionTool.cxx.

310  {
311  //check if the word has been checked before for this string of flags (it should always, as we've buffered them in 'start')
312  RPCFlagDecision decision(M);
313  auto previous_decisions = m_rpcFlag_decisions.find(rpcFlags);
314  if (previous_decisions == m_rpcFlag_decisions.end()) return false;
315 
316  auto previous_decision_itr = previous_decisions->second.find(decision);
317  if (previous_decision_itr != previous_decisions->second.end()) return previous_decision_itr->pass;
318  return false;
319  }

◆ getShapedFlags()

std::string LVL1::TrigThresholdDecisionTool::getShapedFlags ( const std::string &  flags) const
protected

Definition at line 396 of file TrigThresholdDecisionTool.cxx.

397  {
398  std::string shapedFlags = flags;
399  shapedFlags.erase(std::remove_if(shapedFlags.begin(),shapedFlags.end(),::isspace),shapedFlags.end()); // remove spaces
400  std::vector<std::string> vec_ors = parseString(shapedFlags,"|");
401  std::set<std::string> set_ors;
402  for(const auto& ors : vec_ors){
403  std::vector<std::string> vec_ands = parseString(ors,"&");
404  std::set<std::string> set_ands;
405  for(const auto& ands : vec_ands){
406  set_ands.insert(ands);
407  }
408  std::string aa = "";
409  for(const auto& ands : set_ands){
410  aa += ands;
411  aa += "&";
412  }
413  std::string bb = aa.substr(0,aa.size()-1); // remove the last "&"
414  set_ors.insert(bb);
415  }
416  std::string aa = "";
417  for(const auto& ors : set_ors){
418  aa += ors;
419  aa += "|";
420  }
421  std::string bb = aa.substr(0,aa.size()-1); // remove the last "|"
422  return bb;
423  }

◆ getTGCDecision()

bool LVL1::TrigThresholdDecisionTool::getTGCDecision ( const std::string &  tgcFlags,
bool  F,
bool  C,
bool  H 
) const
protected

Definition at line 262 of file TrigThresholdDecisionTool.cxx.

263  {
264  //check if the word has been checked before for this string of flags (it should always, as we've buffered them in 'start')
265  TGCFlagDecision decision(F,C,H);
266  auto previous_decisions = m_tgcFlag_decisions.find(tgcFlags);
267  if (previous_decisions == m_tgcFlag_decisions.end()) return false;
268 
269  auto previous_decision_itr = previous_decisions->second.find(decision);
270  if (previous_decision_itr != previous_decisions->second.end()) return previous_decision_itr->pass;
271  return false;
272  }

◆ getThresholdDecisions() [1/2]

std::vector< std::pair< std::shared_ptr< TrigConf::L1Threshold >, bool > > LVL1::TrigThresholdDecisionTool::getThresholdDecisions ( uint32_t  dataWord,
const EventContext &  eventContext 
) const
overridevirtual

Definition at line 182 of file TrigThresholdDecisionTool.cxx.

183  {
184  // Retrieve the L1 menu configuration
185  SG::ReadHandle<TrigConf::L1Menu> l1Menu = SG::makeHandle(m_l1MenuKey, eventContext);
186  std::optional<ThrVecRef> menuThresholds = getMenuThresholds(*l1Menu);
187  std::optional<ExtraInfoRef> menuExtraInfo = getMenuThresholdExtraInfo(*l1Menu);
188  // Call the other overload
189  return getThresholdDecisions(dataWord, menuThresholds.value().get(), menuExtraInfo.value().get());
190  }

◆ getThresholdDecisions() [2/2]

std::vector< std::pair< std::shared_ptr< TrigConf::L1Threshold >, bool > > LVL1::TrigThresholdDecisionTool::getThresholdDecisions ( uint32_t  dataWord,
const ThrVec &  menuThresholds,
const TrigConf::L1ThrExtraInfoBase &  menuExtraInfo 
) const
overridevirtual

Definition at line 193 of file TrigThresholdDecisionTool.cxx.

195  {
196 
197  const uint64_t pattern = getPattern(dataWord, menuThresholds, menuExtraInfo);
198 
199  //the object that will be returned: pairs of thresholds and pass/fail decisions
200  std::vector<std::pair<std::shared_ptr<TrigConf::L1Threshold>, bool> > threshold_decisions;
201  threshold_decisions.resize(menuThresholds.size());
202  for (const std::shared_ptr<TrigConf::L1Threshold>& thr : menuThresholds) {
203  const bool decision = pattern & (1 << thr->mapping());
204  threshold_decisions[thr->mapping()] = std::make_pair(thr, decision);
205  }
206  return threshold_decisions;
207  }

◆ initialize()

StatusCode LVL1::TrigThresholdDecisionTool::initialize ( )
overridevirtual

Definition at line 20 of file TrigThresholdDecisionTool.cxx.

21  {
22  ATH_MSG_DEBUG( "========================================" );
23  ATH_MSG_DEBUG( "Initialize for TrigThresholdDecisionTool" );
24  ATH_MSG_DEBUG( "========================================" );
25 
26  ATH_CHECK(RoIThresholdsTool::initialize());
27  ATH_CHECK( m_rpcTool.retrieve() );
28  ATH_CHECK( m_tgcTool.retrieve() );
29  return StatusCode::SUCCESS;
30  }

◆ isExcludedRPCROI()

bool LVL1::TrigThresholdDecisionTool::isExcludedRPCROI ( const TrigConf::L1ThrExtraInfo_MU &  menuExtraInfo,
const std::string &  rpcExclROIList,
unsigned  roi,
unsigned  sectorID,
bool  isSideC 
) const
protected

Definition at line 229 of file TrigThresholdDecisionTool.cxx.

233  {
234  if (rpcExclROIList != "")
235  {
236  const std::map<std::string, std::vector<unsigned int> >& exclList = menuExtraInfo.exclusionList(rpcExclROIList);
237  if (exclList.size() != 0)
238  {
239  //build the sector name of this ROI to compare against the exclusion list
240  std::stringstream sectorName;
241  sectorName<<"B";
242  int sectorNumber=sectorID;
243  if (isSideC) sectorNumber += 32;
244  if (sectorNumber < 10) sectorName << "0";
245  sectorName << sectorNumber;
246 
247  //do the comparison
248  auto exclROIs = exclList.find(sectorName.str());
249  if (exclROIs != exclList.end())
250  {
251  for (auto roi_itr=exclROIs->second.begin();roi_itr!=exclROIs->second.end();roi_itr++)
252  {
253  if (*roi_itr == roi) return true;
254  }
255  }
256  }
257  } // rpcExclList != ""
258 
259  return false;
260  }

◆ makeRPCDecision()

void LVL1::TrigThresholdDecisionTool::makeRPCDecision ( const std::string &  rpcFlags,
bool  M 
)
protected

Definition at line 321 of file TrigThresholdDecisionTool.cxx.

322  {
323  //check if the word has been checked before for this string of flags
324  RPCFlagDecision decision(M);
325  auto previous_decisions = &m_rpcFlag_decisions[rpcFlags];
326  auto previous_decision_itr = previous_decisions->find(decision);
327  if (previous_decision_itr != previous_decisions->end()) return;
328  else if (rpcFlags == "") {
329  decision.pass=true;
330  previous_decisions->insert(decision);
331  }
332  else { // make the decision
333 
334  //check the quality based on the flags.
335  //loop over outer layer of "ors" and 'or' the results
336  bool passedFlags = false;
337  const std::vector<std::vector<std::string> >* vec_flags = &m_parsed_flags[rpcFlags];
338  for (auto or_itr = vec_flags->begin();or_itr!=vec_flags->end();or_itr++)
339  {
340  //loop over the inner layer of "ands" and 'and' the results
341  bool passedAnd = true;
342  for (auto and_itr = or_itr->begin();and_itr!=or_itr->end();and_itr++)
343  {
344  if (*and_itr == "M") passedAnd = passedAnd && M;
345  }
346  passedFlags = passedFlags || passedAnd;
347  }
348  //buffer the decision
349  decision.pass = passedFlags;
350  previous_decisions->insert(decision);
351  }
352  }

◆ makeTGCDecision()

void LVL1::TrigThresholdDecisionTool::makeTGCDecision ( const std::string &  tgcFlags,
bool  F,
bool  C,
bool  H 
)
protected

Definition at line 274 of file TrigThresholdDecisionTool.cxx.

275  {
276  //check if the word has been checked before for this string of flags
277  TGCFlagDecision decision(F,C,H);
278  auto previous_decisions = &m_tgcFlag_decisions[tgcFlags];
279  auto previous_decision_itr = previous_decisions->find(decision);
280  if (previous_decision_itr != previous_decisions->end()) return;
281  else if (tgcFlags == "") {
282  decision.pass=true;
283  previous_decisions->insert(decision);
284  }
285  else { // make the decision
286 
287  //check the quality based on the flags.
288  //loop over outer layer of "ors" and 'or' the results
289  bool passedFlags = false;
290  const std::vector<std::vector<std::string> >* vec_flags = &m_parsed_flags[tgcFlags];
291  for (auto or_itr = vec_flags->begin();or_itr!=vec_flags->end();or_itr++)
292  {
293  //loop over the inner layer of "ands" and 'and' the results
294  bool passedAnd = true;
295  for (auto and_itr = or_itr->begin();and_itr!=or_itr->end();and_itr++)
296  {
297  if (*and_itr == "F") passedAnd = passedAnd && F;
298  else if (*and_itr == "C") passedAnd = passedAnd && C;
299  else if (*and_itr == "H") passedAnd = passedAnd && H;
300  }
301  passedFlags = passedFlags || passedAnd;
302  }
303  //buffer the decision
304  decision.pass = passedFlags;
305  previous_decisions->insert(decision);
306  }
307  }

◆ parseFlags()

void LVL1::TrigThresholdDecisionTool::parseFlags ( const std::string &  flags)
protected

Definition at line 354 of file TrigThresholdDecisionTool.cxx.

355  {
356  //parse the logic of the quality flag into a 2D vector, where outer layer contains the logic |'s and inner layer contains the logical &'s.
357  //save the 2D vector in a map so we don't have to parse it each time we want to check the flags.
358  if (m_parsed_flags.find(flags) == m_parsed_flags.end())
359  {
360  std::vector<std::string> vec_ors = parseString(flags, "|");
361  std::vector<std::vector<std::string> > vec_flags;
362  for (unsigned ior=0;ior<vec_ors.size();ior++)
363  {
364  vec_flags.push_back(parseString(vec_ors[ior],"&"));
365  }
366  m_parsed_flags[flags] = vec_flags;
367  }
368  }

◆ parseString()

std::vector< std::string > LVL1::TrigThresholdDecisionTool::parseString ( const std::string &  str,
const std::string &  sep 
) const
protected

Definition at line 370 of file TrigThresholdDecisionTool.cxx.

371  {
372  std::vector<std::string> parsed;
373  int pos = 0;
374  bool first = true;
375  if (str.size() == 0) return parsed;
376  if (str.find(sep) == std::string::npos)
377  {
378  parsed.push_back(str);
379  return parsed;
380  }
381  while (true)
382  {
383  int newPos = str.find(sep, pos);
384  if (str.find(sep, pos) == std::string::npos)
385  {
386  if (!first) parsed.push_back(str.substr(pos, newPos-pos));
387  break;
388  }
389  std::string sub = str.substr(pos, newPos-pos);
390  parsed.push_back(sub);
391  pos = newPos+1;
392  first = false;
393  }
394  return parsed;
395  }

◆ start()

StatusCode LVL1::TrigThresholdDecisionTool::start ( )
overridevirtual

Definition at line 32 of file TrigThresholdDecisionTool.cxx.

33  {
34  ATH_MSG_DEBUG( "==========================================" );
35  ATH_MSG_DEBUG( "Start for Phase1 TrigThresholdDecisionTool" );
36  ATH_MSG_DEBUG( "==========================================" );
37 
38  m_parsed_flags.clear();
39  m_tgcFlag_decisions.clear();
40 
41  //front-load the TGC flag parsing and all possible 3-bit decisions for the menu
42  SG::ReadHandle<TrigConf::L1Menu> l1Menu = SG::makeHandle(m_l1MenuKey);
43  ATH_CHECK(l1Menu.isValid());
44  std::optional<ThrVecRef> menuThresholds = getMenuThresholds(*l1Menu);
45  ATH_CHECK(menuThresholds.has_value());
46 
47  for (const std::shared_ptr<TrigConf::L1Threshold>& thrBase : menuThresholds.value().get()) {
48  std::shared_ptr<TrigConf::L1Threshold_MU> thr = std::static_pointer_cast<TrigConf::L1Threshold_MU>(thrBase);
49 
50  //parse the tgc flags and buffer them
51  std::string tgcFlags = getShapedFlags( thr->tgcFlags() );
52  parseFlags(tgcFlags);
53 
54  //loop over all 3-bit flag combinations
55  for (unsigned flags=0;flags<8;flags++)
56  {
57  bool F=flags&0b100;
58  bool C=flags&0b010;
59  bool H=flags&0b001;
60  makeTGCDecision(tgcFlags, F, C, H);
61  }
62 
63  //parse the rpc flags and buffer them
64  std::string rpcFlags = getShapedFlags( thr->rpcFlags() );
65  parseFlags(rpcFlags);
66 
67  //loop over all 2-bit flag combinations
68  for (unsigned flags=0;flags<2;flags++)
69  {
70  bool M=flags&0b1;
71  makeRPCDecision(rpcFlags, M);
72  }
73  }
74 
75  return StatusCode::SUCCESS;
76  }

Member Data Documentation

◆ m_parsed_flags

std::map<std::string, std::vector<std::vector<std::string> > > LVL1::TrigThresholdDecisionTool::m_parsed_flags
protected

Definition at line 115 of file TrigThresholdDecisionTool.h.

◆ m_rpcFlag_decisions

std::map<std::string, std::set<RPCFlagDecision> > LVL1::TrigThresholdDecisionTool::m_rpcFlag_decisions
protected

Definition at line 119 of file TrigThresholdDecisionTool.h.

◆ m_rpcTool

ToolHandle<LVL1::ITrigT1MuonRecRoiTool> LVL1::TrigThresholdDecisionTool::m_rpcTool {this, "RPCRecRoiTool", "LVL1::TrigT1RPCRecRoiTool/LVL1__TrigT1RPCRecRoiTool", "Tool to get the eta/phi coordinates in the RPC"}
protected

Definition at line 111 of file TrigThresholdDecisionTool.h.

◆ m_tgcFlag_decisions

std::map<std::string, std::set<TGCFlagDecision> > LVL1::TrigThresholdDecisionTool::m_tgcFlag_decisions
protected

Definition at line 118 of file TrigThresholdDecisionTool.h.

◆ m_tgcTool

ToolHandle<LVL1::ITrigT1MuonRecRoiTool> LVL1::TrigThresholdDecisionTool::m_tgcTool {this, "TGCRecRoiTool", "LVL1::TrigT1TGCRecRoiTool/LVL1__TrigT1TGCRecRoiTool", "Tool to get the eta/phi coordinates in the TGC"}
protected

Definition at line 112 of file TrigThresholdDecisionTool.h.

The documentation for this class was generated from the following files:
LVL1::ITrigT1MuonRecRoiTool::ThresholdMask
unsigned int ThresholdMask() const
Definition: ITrigT1MuonRecRoiTool.h:56
mergePhysValFiles.pattern
pattern
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:26
python.SystemOfUnits.second
int second
Definition: SystemOfUnits.py:120
TrigConf::L1Threshold::mapping
unsigned int mapping() const
Accessor to the mapping number The mapping is unique within a type.
Definition: L1ThresholdBase.h:163
TrigConf::L1ThrExtraInfo_MU
Definition: L1ThrExtraInfo.h:644
LVL1::TrigThresholdDecisionTool::getThresholdDecisions
virtual std::vector< std::pair< std::shared_ptr< TrigConf::L1Threshold >, bool > > getThresholdDecisions(uint32_t dataWord, const EventContext &eventContext) const override
Definition: TrigThresholdDecisionTool.cxx:182
LVL1::TrigThresholdDecisionTool::m_parsed_flags
std::map< std::string, std::vector< std::vector< std::string > > > m_parsed_flags
Definition: TrigThresholdDecisionTool.h:115
TrigCompositeUtils::passed
bool passed(DecisionID id, const DecisionIDContainer &idSet)
checks if required decision ID is in the set of IDs in the container
Definition: TrigCompositeUtilsRoot.cxx:117
LVL1::ITrigT1MuonRecRoiTool::InnerCoinMask
unsigned int InnerCoinMask() const
Definition: ITrigT1MuonRecRoiTool.h:67
LVL1::ITrigT1MuonRecRoiTool::BW2Or3Mask
unsigned int BW2Or3Mask() const
Definition: ITrigT1MuonRecRoiTool.h:66
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthenaPoolTestRead.flags
flags
Definition: AthenaPoolTestRead.py:8
DMTest::C
C_v1 C
Definition: C.h:26
LArG4FSStartPointFilterLegacy.parsed
list parsed
Definition: LArG4FSStartPointFilterLegacy.py:128
LVL1::ITrigT1MuonRecRoiTool::BarrelRoIMask
unsigned int BarrelRoIMask() const
Definition: ITrigT1MuonRecRoiTool.h:57
TrigConf::L1Threshold_MU::region
const std::string & region() const
Definition: L1Threshold.h:419
LVL1::ITrigT1MuonRecRoiTool::MuonTriggerSystem
MuonTriggerSystem
Definition: ITrigT1MuonRecRoiTool.h:41
LVL1::TrigThresholdDecisionTool::parseString
std::vector< std::string > parseString(const std::string &str, const std::string &sep) const
Definition: TrigThresholdDecisionTool.cxx:370
LVL1::ITrigT1MuonRecRoiTool::GoodMFMask
unsigned int GoodMFMask() const
Definition: ITrigT1MuonRecRoiTool.h:68
TrigConf::DataStructure::name
virtual const std::string & name() const final
Definition: DataStructure.cxx:109
LVL1::ITrigT1MuonRecRoiTool::Barrel
@ Barrel
Definition: ITrigT1MuonRecRoiTool.h:42
LVL1MUONIF::Lvl1MuCTPIInputPhase1::MuonSubSystem
MuonSubSystem
Definition: Lvl1MuCTPIInputPhase1.h:48
LVL1::ITrigT1MuonRecRoiTool
Definition: ITrigT1MuonRecRoiTool.h:13
TRT::Hit::side
@ side
Definition: HitInfo.h:83
LVL1::ITrigT1MuonRecRoiTool::EndcapSectorIDMask
unsigned int EndcapSectorIDMask() const
Definition: ITrigT1MuonRecRoiTool.h:52
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:269
LVL1::TrigThresholdDecisionTool::parseFlags
void parseFlags(const std::string &flags)
Definition: TrigThresholdDecisionTool.cxx:354
LVL1::ITrigT1MuonRecRoiTool::BarrelSectorIDMask
unsigned int BarrelSectorIDMask() const
Definition: ITrigT1MuonRecRoiTool.h:51
H
#define H(x, y, z)
Definition: MD5.cxx:114
LVL1::TrigThresholdDecisionTool::m_rpcTool
ToolHandle< LVL1::ITrigT1MuonRecRoiTool > m_rpcTool
Definition: TrigThresholdDecisionTool.h:111
LVL1::ITrigT1MuonRecRoiTool::ForwardRoIMask
unsigned int ForwardRoIMask() const
Definition: ITrigT1MuonRecRoiTool.h:59
LVL1::ITrigT1MuonRecRoiTool::EndcapRoIMask
unsigned int EndcapRoIMask() const
Definition: ITrigT1MuonRecRoiTool.h:58
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
LVL1::TrigThresholdDecisionTool::makeRPCDecision
void makeRPCDecision(const std::string &rpcFlags, bool M)
Definition: TrigThresholdDecisionTool.cxx:321
TrigConf::L1Threshold_MU::tgcFlags
const std::string & tgcFlags() const
Definition: L1Threshold.h:420
test_pyathena.parent
parent
Definition: test_pyathena.py:15
TrigConf::L1Threshold::thrValue
virtual float thrValue(int eta=0) const
Accessor to the threshold value for eta-dependent threholds.
Definition: L1ThresholdBase.cxx:127
xAOD::uint64_t
uint64_t
Definition: EventInfo_v1.cxx:123
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
TrigConf::L1ThrExtraInfo_MU::exclusionList
const std::map< std::string, std::vector< unsigned int > > & exclusionList(const std::string &listName) const
Definition: L1ThrExtraInfo.cxx:797
LVL1::TrigThresholdDecisionTool::getRPCDecision
bool getRPCDecision(const std::string &rpcFlags, bool M) const
Definition: TrigThresholdDecisionTool.cxx:309
LVL1::TrigThresholdDecisionTool::getShapedFlags
std::string getShapedFlags(const std::string &flags) const
Definition: TrigThresholdDecisionTool.cxx:396
LVL1::TrigThresholdDecisionTool::isExcludedRPCROI
bool isExcludedRPCROI(const TrigConf::L1ThrExtraInfo_MU &menuExtraInfo, const std::string &rpcExclROIList, unsigned roi, unsigned sectorID, bool isSideC) const
Definition: TrigThresholdDecisionTool.cxx:229
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
xAOD::decisions
decisions
Definition: TrigComposite_v1.cxx:81
LVL1::TrigThresholdDecisionTool::m_tgcTool
ToolHandle< LVL1::ITrigT1MuonRecRoiTool > m_tgcTool
Definition: TrigThresholdDecisionTool.h:112
TrigConf::L1Threshold_MU::idxBarrel
unsigned int idxBarrel() const
Definition: L1Threshold.h:416
grepfile.sep
sep
Definition: grepfile.py:38
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:192
RoIThresholdsTool::initialize
virtual StatusCode initialize() override
Definition: IRoIThresholdsTool.h:31
TrigConf::L1Threshold_MU::idxEndcap
unsigned int idxEndcap() const
Definition: L1Threshold.h:417
LVL1::TrigThresholdDecisionTool::makeTGCDecision
void makeTGCDecision(const std::string &tgcFlags, bool F, bool C, bool H)
Definition: TrigThresholdDecisionTool.cxx:274
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
LVL1MUONIF::Lvl1MuCTPIInputPhase1::idEndcapSystem
static size_t idEndcapSystem()
Definition: Lvl1MuCTPIInputPhase1.h:136
TrigConf::L1Threshold_MU::rpcFlags
const std::string & rpcFlags() const
Definition: L1Threshold.h:421
LVL1::TrigThresholdDecisionTool::getTGCDecision
bool getTGCDecision(const std::string &tgcFlags, bool F, bool C, bool H) const
Definition: TrigThresholdDecisionTool.cxx:262
LVL1::ITrigT1MuonRecRoiTool::Endcap
@ Endcap
Definition: ITrigT1MuonRecRoiTool.h:42
LVL1MUONIF::Lvl1MuCTPIInputPhase1::idSideC
static size_t idSideC()
Definition: Lvl1MuCTPIInputPhase1.h:141
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
LVL1::ITrigT1MuonRecRoiTool::OverflowPerRoIMask
unsigned int OverflowPerRoIMask() const
Definition: ITrigT1MuonRecRoiTool.h:64
DeMoScan.first
bool first
Definition: DeMoScan.py:534
F
#define F(x, y, z)
Definition: MD5.cxx:112
LVL1::ITrigT1MuonRecRoiTool::SubSysIDMask
unsigned int SubSysIDMask() const
Definition: ITrigT1MuonRecRoiTool.h:55
LVL1::TrigThresholdDecisionTool::getPattern
virtual uint64_t getPattern(const xAOD::MuonRoI &roi, const ThrVec &menuThresholds, const TrigConf::L1ThrExtraInfoBase &menuExtraInfo) const override
Definition: TrigThresholdDecisionTool.cxx:78
LVL1::TrigThresholdDecisionTool::m_tgcFlag_decisions
std::map< std::string, std::set< TGCFlagDecision > > m_tgcFlag_decisions
Definition: TrigThresholdDecisionTool.h:118
str
Definition: BTagTrackIpAccessor.cxx:11
TrigConf::L1Threshold_MU::idxForward
unsigned int idxForward() const
Definition: L1Threshold.h:418
test_AnalysisBaseEventLoopJob.aa
aa
Definition: test_AnalysisBaseEventLoopJob.py:37
TrigConf::L1Threshold_MU::rpcExclROIList
const std::string & rpcExclROIList() const
Definition: L1Threshold.h:422
LVL1::TrigThresholdDecisionTool::m_rpcFlag_decisions
std::map< std::string, std::set< RPCFlagDecision > > m_rpcFlag_decisions
Definition: TrigThresholdDecisionTool.h:119
xAOD::MuonRoI_v1::roiWord
uint32_t roiWord() const
The "raw" RoI word describing the muon candidate.
LVL1::ITrigT1MuonRecRoiTool::getBitMaskValue
unsigned int getBitMaskValue(const unsigned int *uintValue, const unsigned int mask) const
Definition: ITrigT1MuonRecRoiTool.cxx:10
LVL1::ITrigT1MuonRecRoiTool::ForwardSectorIDMask
unsigned int ForwardSectorIDMask() const
Definition: ITrigT1MuonRecRoiTool.h:53
Generated on Sun Jun 30 2024 22:19:50 for ATLAS Offline Software by   doxygen 1.8.18