ATLAS Offline Software
TrigThresholdDecisionTool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
3 */
4 
7 
8 namespace LVL1
9 {
10  namespace MURoIThresholdsToolParams {
11  const char ContainerName[] = "LVL1MuonRoIs";
12  const char ThresholdType[] = "MU";
13  }
14 
16  const std::string& name,
17  const IInterface* parent)
18  : base_class(type, name, parent) {}
19 
21  {
22  ATH_MSG_DEBUG( "========================================" );
23  ATH_MSG_DEBUG( "Initialize for TrigThresholdDecisionTool" );
24  ATH_MSG_DEBUG( "========================================" );
25 
27  ATH_CHECK( m_rpcTool.retrieve() );
28  ATH_CHECK( m_tgcTool.retrieve() );
29  return StatusCode::SUCCESS;
30  }
31 
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
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  auto thr = static_cast<TrigConf::L1Threshold_MU*>(thrBase.get());
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  }
77 
79  const ThrVec& menuThresholds,
80  const TrigConf::L1ThrExtraInfoBase& menuExtraInfo) const {
81  return getPattern(roi.roiWord(), menuThresholds, menuExtraInfo);
82  }
83 
85  const ThrVec& menuThresholds,
86  const TrigConf::L1ThrExtraInfoBase& menuExtraInfo) const {
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());
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;
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  auto thr = static_cast<TrigConf::L1Threshold_MU*>(thrBase.get());
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  }
180 
181  std::vector<std::pair<std::shared_ptr<TrigConf::L1Threshold>, bool> >
183  const EventContext& eventContext) const {
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  }
191 
192  std::vector<std::pair<std::shared_ptr<TrigConf::L1Threshold>, bool> >
194  const ThrVec& menuThresholds,
195  const TrigConf::L1ThrExtraInfoBase& menuExtraInfo) const {
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  }
208 
209  std::pair<std::string, double> TrigThresholdDecisionTool::getMinThresholdNameAndValue(const std::vector<std::pair<std::shared_ptr<TrigConf::L1Threshold>, bool> >& decisions, const double& eta) const
210  {
211  //find the highest pt threshold passed - depite the name of this function
212  std::string thrName="";
213  double thrVal=0;
214  for (unsigned idec=0;idec<decisions.size();++idec) {
215  if (!decisions[idec].second) continue;
216  std::shared_ptr<TrigConf::L1Threshold> thr = decisions[idec].first;
217  if (thr->thrValue(eta) > thrVal)
218  {
219  thrVal = thr->thrValue(eta);
220  thrName = thr->name();
221  }
222  }
223  return std::make_pair(thrName, thrVal);
224  }
225 
227  const std::string& rpcExclROIList,
228  const unsigned roi,
229  const unsigned sectorID,
230  const bool isSideC) const {
231  if (rpcExclROIList != "")
232  {
233  const std::map<std::string, std::vector<unsigned int> >& exclList = menuExtraInfo.exclusionList(rpcExclROIList);
234  if (exclList.size() != 0)
235  {
236  //build the sector name of this ROI to compare against the exclusion list
237  std::stringstream sectorName;
238  sectorName<<"B";
239  int sectorNumber=sectorID;
240  if (isSideC) sectorNumber += 32;
241  if (sectorNumber < 10) sectorName << "0";
242  sectorName << sectorNumber;
243 
244  //do the comparison
245  auto exclROIs = exclList.find(sectorName.str());
246  if (exclROIs != exclList.end())
247  {
248  for (auto roi_itr=exclROIs->second.begin();roi_itr!=exclROIs->second.end();roi_itr++)
249  {
250  if (*roi_itr == roi) return true;
251  }
252  }
253  }
254  } // rpcExclList != ""
255 
256  return false;
257  }
258 
259  bool TrigThresholdDecisionTool::getTGCDecision(const std::string& tgcFlags, const bool F, const bool C, const bool H) const
260  {
261  //check if the word has been checked before for this string of flags (it should always, as we've buffered them in 'start')
262  TGCFlagDecision decision(F,C,H);
263  auto previous_decisions = m_tgcFlag_decisions.find(tgcFlags);
264  if (previous_decisions == m_tgcFlag_decisions.end()) return false;
265 
266  auto previous_decision_itr = previous_decisions->second.find(decision);
267  if (previous_decision_itr != previous_decisions->second.end()) return previous_decision_itr->pass;
268  return false;
269  }
270 
271  void TrigThresholdDecisionTool::makeTGCDecision(const std::string& tgcFlags, const bool F, const bool C, const bool H)
272  {
273  //check if the word has been checked before for this string of flags
274  TGCFlagDecision decision(F,C,H);
275  auto previous_decisions = &m_tgcFlag_decisions[tgcFlags];
276  auto previous_decision_itr = previous_decisions->find(decision);
277  if (previous_decision_itr != previous_decisions->end()) return;
278  else if (tgcFlags == "") {
279  decision.pass=true;
280  previous_decisions->insert(decision);
281  }
282  else { // make the decision
283 
284  //check the quality based on the flags.
285  //loop over outer layer of "ors" and 'or' the results
286  bool passedFlags = false;
287  const std::vector<std::vector<std::string> >* vec_flags = &m_parsed_flags[tgcFlags];
288  for (auto or_itr = vec_flags->begin();or_itr!=vec_flags->end();or_itr++)
289  {
290  //loop over the inner layer of "ands" and 'and' the results
291  bool passedAnd = true;
292  for (auto and_itr = or_itr->begin();and_itr!=or_itr->end();and_itr++)
293  {
294  if (*and_itr == "F") passedAnd = passedAnd && F;
295  else if (*and_itr == "C") passedAnd = passedAnd && C;
296  else if (*and_itr == "H") passedAnd = passedAnd && H;
297  }
298  passedFlags = passedFlags || passedAnd;
299  }
300  //buffer the decision
301  decision.pass = passedFlags;
302  previous_decisions->insert(decision);
303  }
304  }
305 
306  bool TrigThresholdDecisionTool::getRPCDecision(const std::string& rpcFlags, const bool M) const
307  {
308  //check if the word has been checked before for this string of flags (it should always, as we've buffered them in 'start')
309  RPCFlagDecision decision(M);
310  auto previous_decisions = m_rpcFlag_decisions.find(rpcFlags);
311  if (previous_decisions == m_rpcFlag_decisions.end()) return false;
312 
313  auto previous_decision_itr = previous_decisions->second.find(decision);
314  if (previous_decision_itr != previous_decisions->second.end()) return previous_decision_itr->pass;
315  return false;
316  }
317 
318  void TrigThresholdDecisionTool::makeRPCDecision(const std::string& rpcFlags, const bool M)
319  {
320  //check if the word has been checked before for this string of flags
321  RPCFlagDecision decision(M);
322  auto previous_decisions = &m_rpcFlag_decisions[rpcFlags];
323  auto previous_decision_itr = previous_decisions->find(decision);
324  if (previous_decision_itr != previous_decisions->end()) return;
325  else if (rpcFlags == "") {
326  decision.pass=true;
327  previous_decisions->insert(decision);
328  }
329  else { // make the decision
330 
331  //check the quality based on the flags.
332  //loop over outer layer of "ors" and 'or' the results
333  bool passedFlags = false;
334  const std::vector<std::vector<std::string> >* vec_flags = &m_parsed_flags[rpcFlags];
335  for (auto or_itr = vec_flags->begin();or_itr!=vec_flags->end();or_itr++)
336  {
337  //loop over the inner layer of "ands" and 'and' the results
338  bool passedAnd = true;
339  for (auto and_itr = or_itr->begin();and_itr!=or_itr->end();and_itr++)
340  {
341  if (*and_itr == "M") passedAnd = passedAnd && M;
342  }
343  passedFlags = passedFlags || passedAnd;
344  }
345  //buffer the decision
346  decision.pass = passedFlags;
347  previous_decisions->insert(decision);
348  }
349  }
350 
352  {
353  //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.
354  //save the 2D vector in a map so we don't have to parse it each time we want to check the flags.
355  if (m_parsed_flags.find(flags) == m_parsed_flags.end())
356  {
357  std::vector<std::string> vec_ors = parseString(flags, "|");
358  std::vector<std::vector<std::string> > vec_flags;
359  for (unsigned ior=0;ior<vec_ors.size();ior++)
360  {
361  vec_flags.push_back(parseString(vec_ors[ior],"&"));
362  }
363  m_parsed_flags[flags] = vec_flags;
364  }
365  }
366 
367  std::vector<std::string> TrigThresholdDecisionTool::parseString(const std::string& str, const std::string& sep) const
368  {
369  std::vector<std::string> parsed;
370  int pos = 0;
371  bool first = true;
372  if (str.size() == 0) return parsed;
373  if (str.find(sep) == std::string::npos)
374  {
375  parsed.push_back(str);
376  return parsed;
377  }
378  while (true)
379  {
380  int newPos = str.find(sep, pos);
381  if (str.find(sep, pos) == std::string::npos)
382  {
383  if (!first) parsed.push_back(str.substr(pos, newPos-pos));
384  break;
385  }
386  std::string sub = str.substr(pos, newPos-pos);
387  parsed.push_back(sub);
388  pos = newPos+1;
389  first = false;
390  }
391  return parsed;
392  }
393  std::string TrigThresholdDecisionTool::getShapedFlags(const std::string& flags) const
394  {
395  std::string shapedFlags = flags;
396  shapedFlags.erase(std::remove_if(shapedFlags.begin(),shapedFlags.end(),::isspace),shapedFlags.end()); // remove spaces
397  std::vector<std::string> vec_ors = parseString(shapedFlags,"|");
398  std::set<std::string> set_ors;
399  for(const auto& ors : vec_ors){
400  std::vector<std::string> vec_ands = parseString(ors,"&");
401  std::set<std::string> set_ands;
402  for(const auto& ands : vec_ands){
403  set_ands.insert(ands);
404  }
405  std::string aa = "";
406  for(const auto& ands : set_ands){
407  aa += ands;
408  aa += "&";
409  }
410  std::string bb = aa.substr(0,aa.size()-1); // remove the last "&"
411  set_ors.insert(bb);
412  }
413  std::string aa = "";
414  for(const auto& ors : set_ors){
415  aa += ors;
416  aa += "|";
417  }
418  std::string bb = aa.substr(0,aa.size()-1); // remove the last "|"
419  return bb;
420  }
421 }
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::L1ThrExtraInfo_MU
Definition: L1ThrExtraInfo.h:655
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
LVL1::TrigThresholdDecisionTool::RPCFlagDecision
Definition: TrigThresholdDecisionTool.h:85
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
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
LVL1::ITrigT1MuonRecRoiTool::BW2Or3Mask
unsigned int BW2Or3Mask() const
Definition: ITrigT1MuonRecRoiTool.h:66
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthenaPoolTestRead.flags
flags
Definition: AthenaPoolTestRead.py:8
LVL1::MURoIThresholdsToolParams::ThresholdType
const char ThresholdType[]
Definition: TrigThresholdDecisionTool.cxx:12
LVL1::ITrigT1MuonRecRoiTool::BarrelRoIMask
unsigned int BarrelRoIMask() const
Definition: ITrigT1MuonRecRoiTool.h:57
LVL1::MURoIThresholdsToolParams::ContainerName
const char ContainerName[]
Definition: TrigThresholdDecisionTool.cxx:11
LVL1::TrigThresholdDecisionTool::getMinThresholdNameAndValue
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
Definition: TrigThresholdDecisionTool.cxx:209
LVL1::ITrigT1MuonRecRoiTool::MuonTriggerSystem
MuonTriggerSystem
Definition: ITrigT1MuonRecRoiTool.h:41
LVL1::TrigThresholdDecisionTool::initialize
virtual StatusCode initialize() override
Definition: TrigThresholdDecisionTool.cxx:20
LVL1::TrigThresholdDecisionTool::parseString
std::vector< std::string > parseString(const std::string &str, const std::string &sep) const
Definition: TrigThresholdDecisionTool.cxx:367
TrigConf::L1ThrExtraInfoBase
L1 extra information for certain threshold types.
Definition: L1ThresholdBase.h:72
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
LVL1
eFexTowerBuilder creates xAOD::eFexTowerContainer from supercells (LATOME) and triggerTowers (TREX) i...
Definition: ICMMCPHitsCnvTool.h:18
LVL1MUONIF::Lvl1MuCTPIInputPhase1::MuonSubSystem
MuonSubSystem
Definition: Lvl1MuCTPIInputPhase1.h:49
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:270
LVL1::TrigThresholdDecisionTool::parseFlags
void parseFlags(const std::string &flags)
Definition: TrigThresholdDecisionTool.cxx:351
Lvl1MuCTPIInputPhase1.h
LVL1::ITrigT1MuonRecRoiTool::BarrelSectorIDMask
unsigned int BarrelSectorIDMask() const
Definition: ITrigT1MuonRecRoiTool.h:51
H
#define H(x, y, z)
Definition: MD5.cxx:114
LVL1::TrigThresholdDecisionTool::RPCFlagDecision::pass
bool pass
Definition: TrigThresholdDecisionTool.h:92
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
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
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:318
xAOD::MuonRoI_v1
Class describing a LVL1 muon region of interest.
Definition: MuonRoI_v1.h:29
test_pyathena.parent
parent
Definition: test_pyathena.py:15
IDTPMcnv.parsed
parsed
Definition: IDTPMcnv.py:28
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:803
LVL1::TrigThresholdDecisionTool::getRPCDecision
bool getRPCDecision(const std::string &rpcFlags, bool M) const
Definition: TrigThresholdDecisionTool.cxx:306
LVL1::TrigThresholdDecisionTool::TGCFlagDecision
Definition: TrigThresholdDecisionTool.h:75
LVL1::TrigThresholdDecisionTool::getShapedFlags
std::string getShapedFlags(const std::string &flags) const
Definition: TrigThresholdDecisionTool.cxx:393
LVL1::TrigThresholdDecisionTool::start
virtual StatusCode start() override
Definition: TrigThresholdDecisionTool.cxx:32
LVL1::TrigThresholdDecisionTool::isExcludedRPCROI
bool isExcludedRPCROI(const TrigConf::L1ThrExtraInfo_MU &menuExtraInfo, const std::string &rpcExclROIList, unsigned roi, unsigned sectorID, bool isSideC) const
Definition: TrigThresholdDecisionTool.cxx:226
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
xAOD::decisions
decisions
Definition: TrigComposite_v1.cxx:101
LVL1::TrigThresholdDecisionTool::m_tgcTool
ToolHandle< LVL1::ITrigT1MuonRecRoiTool > m_tgcTool
Definition: TrigThresholdDecisionTool.h:112
TrigConf::name
Definition: HLTChainList.h:35
grepfile.sep
sep
Definition: grepfile.py:38
RoIThresholdsTool::initialize
virtual StatusCode initialize() override
Definition: IRoIThresholdsTool.h:31
LVL1::TrigThresholdDecisionTool::makeTGCDecision
void makeTGCDecision(const std::string &tgcFlags, bool F, bool C, bool H)
Definition: TrigThresholdDecisionTool.cxx:271
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
LVL1MUONIF::Lvl1MuCTPIInputPhase1::idEndcapSystem
static size_t idEndcapSystem()
Definition: Lvl1MuCTPIInputPhase1.h:137
TrigConf::L1Threshold_MU
Definition: L1Threshold.h:400
LVL1::TrigThresholdDecisionTool::getTGCDecision
bool getTGCDecision(const std::string &tgcFlags, bool F, bool C, bool H) const
Definition: TrigThresholdDecisionTool.cxx:259
LVL1::ITrigT1MuonRecRoiTool::Endcap
@ Endcap
Definition: ITrigT1MuonRecRoiTool.h:42
LVL1MUONIF::Lvl1MuCTPIInputPhase1::idSideC
static size_t idSideC()
Definition: Lvl1MuCTPIInputPhase1.h:142
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
LVL1::ITrigT1MuonRecRoiTool::OverflowPerRoIMask
unsigned int OverflowPerRoIMask() const
Definition: ITrigT1MuonRecRoiTool.h:64
TrigThresholdDecisionTool.h
DeMoScan.first
bool first
Definition: DeMoScan.py:536
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
LVL1::TrigThresholdDecisionTool::TGCFlagDecision::pass
bool pass
Definition: TrigThresholdDecisionTool.h:82
LVL1::TrigThresholdDecisionTool::TrigThresholdDecisionTool
TrigThresholdDecisionTool(const std::string &type, const std::string &name, const IInterface *parent)
Definition: TrigThresholdDecisionTool.cxx:15
test_AnalysisBaseEventLoopJob.aa
aa
Definition: test_AnalysisBaseEventLoopJob.py:37
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