ATLAS Offline Software
RpcCablingCondData.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3  */
4 
5 #include "RPC_CondCabling/RpcCablingCondData.h"
6 #include "RPC_CondCabling/RPCofflineId.h"
7 #include "MuonIdHelpers/RpcIdHelper.h"
8 #include "AthenaKernel/getMessageSvc.h"
9 #include "GaudiKernel/MsgStream.h"
10 
11 const RpcCablingCondData::RDOmap& RpcCablingCondData::give_RDOs(void) const { return m_RDOs; }
12 
13 bool RpcCablingCondData::give_ROBid(const Identifier& compactID, unsigned short int& id) const {
14  OfflineOnlineMap::const_iterator it = m_RDOmap.find(compactID);
15  if (it == m_RDOmap.end()) return false;
16  const RDOindex* index = (*m_RDOmap.find(compactID)).second;
17  if (!index) return false;
18  id = index->ROBid();
19  return true;
20 }
21 bool RpcCablingCondData::give_ROBid(const unsigned int hashID, unsigned short int& id) const {
22  if (hashID >= m_HashVec.size()) return false;
23  const RDOindex* index = m_HashVec[hashID];
24  if (!index) return false;
25  id = index->ROBid();
26  return true;
27 }
28 
29 bool RpcCablingCondData::give_RODid(const Identifier& compactID, unsigned short int& id) const {
30  OfflineOnlineMap::const_iterator it = m_RDOmap.find(compactID);
31  if (it == m_RDOmap.end()) return false;
32  const RDOindex* index = (*m_RDOmap.find(compactID)).second;
33  if (!index) return false;
34  id = index->RODid();
35  return true;
36 }
37 bool RpcCablingCondData::give_RODid(const unsigned int hashID, unsigned short int& id) const {
38  if (hashID >= m_HashVec.size()) return false;
39  const RDOindex* index = m_HashVec[hashID];
40  if (!index) return false;
41  id = index->RODid();
42  return true;
43 }
44 
45 bool RpcCablingCondData::give_side(const Identifier& compactID, unsigned short int& id) const {
46  OfflineOnlineMap::const_iterator it = m_RDOmap.find(compactID);
47  if (it == m_RDOmap.end()) return false;
48  const RDOindex* index = (*m_RDOmap.find(compactID)).second;
49  if (!index) return false;
50  id = index->side();
51  return true;
52 }
53 bool RpcCablingCondData::give_side(const unsigned int hashID, unsigned short int& id) const {
54  if (hashID >= m_HashVec.size()) return false;
55  const RDOindex* index = m_HashVec[hashID];
56  if (!index) return false;
57  id = index->side();
58  return true;
59 }
60 
61 bool RpcCablingCondData::give_SLid(const Identifier& compactID, unsigned short int& id) const {
62  OfflineOnlineMap::const_iterator it = m_RDOmap.find(compactID);
63  if (it == m_RDOmap.end()) return false;
64  const RDOindex* index = (*m_RDOmap.find(compactID)).second;
65  if (!index) return false;
66  id = index->SLid();
67  return true;
68 }
69 bool RpcCablingCondData::give_SLid(const unsigned int hashID, unsigned short int& id) const {
70  if (hashID >= m_HashVec.size()) return false;
71  const RDOindex* index = m_HashVec[hashID];
72  if (!index) return false;
73  id = index->SLid();
74  return true;
75 }
76 
77 bool RpcCablingCondData::give_RXid(const Identifier& compactID, unsigned short int& id) const {
78  OfflineOnlineMap::const_iterator it = m_RDOmap.find(compactID);
79  if (it == m_RDOmap.end()) return false;
80  const RDOindex* index = (*m_RDOmap.find(compactID)).second;
81  if (!index) return false;
82  id = index->RXid();
83  return true;
84 }
85 bool RpcCablingCondData::give_RXid(const unsigned int hashID, unsigned short int& id) const {
86  if (hashID >= m_HashVec.size()) return false;
87  const RDOindex* index = m_HashVec[hashID];
88  if (!index) return false;
89  id = index->RXid();
90  return true;
91 }
92 
93 bool RpcCablingCondData::give_PADid(const Identifier& compactID, unsigned short int& id) const {
94  OfflineOnlineMap::const_iterator it = m_RDOmap.find(compactID);
95  if (it == m_RDOmap.end()) return false;
96  const RDOindex* index = (*m_RDOmap.find(compactID)).second;
97  if (!index) return false;
98  id = index->PADid();
99  return true;
100 }
101 bool RpcCablingCondData::give_PADid(const unsigned int hashID, unsigned short int& id) const {
102  if (hashID >= m_HashVec.size()) return false;
103  const RDOindex* index = m_HashVec[hashID];
104  if (!index) return false;
105  id = index->PADid();
106  return true;
107 }
108 
109 const std::vector<uint32_t>& RpcCablingCondData::giveFullListOfRobIds() const { return m_fullListOfRobIds; }
110 
111 Identifier RpcCablingCondData::identifier(int index) const {
112  int size = m_int2id.size();
113  if (index >= 0 && index < size) { return m_int2id[index]; }
114 
115  Identifier id;
116  return id;
117 }
118 
119 int RpcCablingCondData::operator()(const Identifier& id) const {
120  std::map<Identifier, int>::const_iterator it = m_lookup.find(id);
121  if (it != m_lookup.end()) { return (*it).second; }
122 
123  // FIXME -1 for invalid ID?
124  return -1;
125 }
126 
127 int RpcCablingCondData::max() const { return m_int2id.size(); }
128 
129 int RpcCablingCondData::offset() { return 0; }
130 
131 std::vector<IdentifierHash> RpcCablingCondData::rod2hash(uint16_t subsystem_id, uint16_t rod_id) const {
132  if ((subsystem_id != 0x66 && subsystem_id != 0x65) || (rod_id >= 16)) return std::vector<IdentifierHash>();
133  return m_rod2hash[(subsystem_id == 0x66) ? 0 : 1][rod_id];
134 }
135 
136 uint32_t RpcCablingCondData::hash2source(unsigned int h) const {
137  unsigned short int side;
138  unsigned short int RODid;
139  if (give_side(h, side) && give_RODid(h, RODid)) {
140  uint32_t sub = side;
141  uint32_t rod = RODid;
142  return (sub << 16) | rod;
143  }
144  return 0;
145 }
146 
147 StatusCode RpcCablingCondData::giveROB_fromRDO(const IdentifierHash rdoHashId, uint32_t& robId) const {
148  StatusCode sc = StatusCode::SUCCESS;
149  unsigned int hash = (unsigned int)rdoHashId;
150 
151  if (hash >= m_HashVec.size()) { return StatusCode::FAILURE; }
152 
153  unsigned short int rob_id = m_HashVec[hash]->ROBid();
154  unsigned short int side = m_HashVec[hash]->side();
155 
156  robId = (side << 16) | rob_id;
157 
158  return sc;
159 }
160 
161 StatusCode RpcCablingCondData::giveROB_fromRDO(const std::vector<IdentifierHash>& rdoHashVec, std::vector<uint32_t>& robIdVec) const {
162  StatusCode sc = StatusCode::SUCCESS;
163 
164  robIdVec.clear();
165 
166  for (IdentifierHash rdoHashId : rdoHashVec) {
167  uint32_t robid = 0xffffffff;
168  if (!giveROB_fromRDO(rdoHashId, robid)) sc = StatusCode::FAILURE;
169  robIdVec.push_back(robid);
170  }
171 
172  // sort and remove duplicates
173  std::sort(robIdVec.begin(), robIdVec.end());
174  robIdVec.erase(unique(robIdVec.begin(), robIdVec.end()), robIdVec.end());
175 
176  return sc;
177 }
178 
179 const CMAparameters::CMAlist RpcCablingCondData::give_CMAs(const int logic_sector, const ViewType side, const int station,
180  const int cabling_code) const {
181  const RPC_CondCabling::SectorLogicSetup& s = m_SectorType[m_SectorMap[logic_sector] - 1];
182  CMAparameters::CMAlist result = s.give_CMAs(logic_sector, side, station, cabling_code);
183  return result;
184 }
185 
186 unsigned long int RpcCablingCondData::strip_code_fromOffId(const std::string& stationName, int stationEta, int stationPhi, int doubletR,
187  int doubletZ, int doubletPhi, int gasGap, int measuresPhi, int strip) const {
188  unsigned long int code = 0;
189 
190  unsigned long int etaPhiView = 2;
191  unsigned long int phi1_16 = 2. * stationPhi;
192  if (largeSector(stationName)) phi1_16 = phi1_16 - 1;
193  int logicSector = (phi1_16 - 1) * 2 + doubletPhi - 2;
194  if (logicSector < 0) logicSector = 31;
195  if (measuresPhi > 0) etaPhiView = 1;
196  if (stationEta >= 0) logicSector += 32;
197 
198  unsigned long int cabStat = doubletR;
199  if (stationName.substr(0, 2) == "BO") {
200  cabStat = 2 + cabStat;
201  if (cabStat > 3) cabStat = 2; // special case of BOF and BOG with dbr=2
202  } else if (stationName.substr(0, 3) == "BML") {
203  if (abs(stationEta) == 7 || (abs(stationEta) == 6 && stationPhi == 7)) {
204  cabStat = 2; // special case of single RPC Chambers at the same R or dbr2
205  }
206  }
207  if (stationName.substr(0,3)=="BIS" && logicSector>31) logicSector+=1; // BIS78 are in doubPhi==1
208 
209  if (logicSector < 0 || logicSector > 63) { return 999999; }
210 
211  int zIndexInCablingStation = computeZIndexInCablingStation(stationName, logicSector, stationEta, doubletR, doubletZ, cabStat);
212  if (zIndexInCablingStation > 99) return 0;
213  int cablingStation = cabStat;
214 
215  unsigned long int gg = gasGap - 1;
216  code = strip_code_fromOffline(etaPhiView, logicSector, cablingStation, gg, zIndexInCablingStation, strip);
217 
218  return code;
219 }
220 
221 unsigned long int RpcCablingCondData::strip_code_fromOffline(int etaPhiView, int logicSector, int cablingStation, int gasGap,
222  int zIndexInCablingStation, int strip) {
223  unsigned long int code = 0;
224  code = etaPhiView * 100000000 + logicSector * 1000000 + cablingStation * 100000 + gasGap * 10000 + zIndexInCablingStation * 100 +
225  (strip - 1);
226  return code;
227 }
228 
229 bool RpcCablingCondData::largeSector(const std::string& stName) {
230  bool ls = false;
231  if (stName == "BML" || // 2
232  stName == "BOL" || // 4
233  stName == "BME" || // 53
234  stName == "BIR" // 52
235  )
236  ls = true;
237  return ls;
238 }
239 
240 unsigned int RpcCablingCondData::computeZIndexInCablingStation(const std::string& stationName, int logicSector, int stationEta,
241  int doubletR, int doubletZ, int cabStat) const {
242  unsigned int zIndexInCablingStation = 999;
243  int cablingStation = -1;
244  int sectType = m_SectorMap[logicSector];
245  assert(m_MaxType != -999999);
246  if (sectType < 1 || sectType > m_MaxType + 1) { return 99999; }
247  const RPC_CondCabling::SectorLogicSetup& sec = m_SectorType[sectType - 1];
248 
249  for (unsigned int jStat = 1; jStat < 4; ++jStat) {
250  if (cablingStation != -1) break;
251  for (unsigned int jCham = 0; jCham < 20; ++jCham) {
252  const RPC_CondCabling::RPCchamber* rpcC = sec.find_chamber(jStat, jCham);
253  if (rpcC == nullptr) continue;
254 
255  if ((rpcC->chamber_name()).substr(0, 3) != stationName) { continue; }
256  if (rpcC->stationEta() != abs(stationEta)) { continue; }
257  if (rpcC->doubletR() != doubletR) { continue; }
258  if (rpcC->doubletZ() != doubletZ) { continue; }
259  cablingStation = jStat;
260  zIndexInCablingStation = jCham;
261  break;
262  }
263  }
264  if (cablingStation < 1 || cablingStation > 3 || (cabStat != cablingStation)) { return 99999; }
265  if (zIndexInCablingStation > 19) { return 99999; }
266 
267  return zIndexInCablingStation;
268 }
269 
270 std::list<Identifier> RpcCablingCondData::give_strip_id(unsigned short int SubsystemId, unsigned short int SectorId,
271  unsigned short int PADId, unsigned short int CMAId, unsigned short ijk,
272  unsigned short int Channel, const RpcIdHelper* rpcId) const {
273  std::list<unsigned int> CodeList;
274 
275  int logic_sector = SectorId + SubsystemId * 32;
276  unsigned short int Ixx = CMAId & 1;
277  unsigned short int ep = (CMAId >> 1) & 1;
278  unsigned short int lh = (CMAId >> 2) & 1;
279 
280  ep = (ep == 1) ? 0 : 1;
281 
282  // retrieve the Sector Logic setup
283  const RPC_CondCabling::SectorLogicSetup& s = m_SectorType[m_SectorMap[logic_sector] - 1];
284 
285  // retrieve the CMAparameters associated to the identifiers
286  if (ep) {
287  CMAcoverage PhiCov = (logic_sector % 2) ? OddSectors : EvenSectors;
288  CMAidentity PHI(Phi, PhiCov, PADId, Ixx);
289  CodeList = s.give_strip_code(PHI, logic_sector, lh, ijk, Channel);
290  } else {
291  CMAidentity ETA(Eta, AllSectors, PADId, Ixx);
292  CodeList = s.give_strip_code(ETA, logic_sector, lh, ijk, Channel);
293  }
294 
295  std::list<RPCofflineId> offlineIdList;
296  std::list<unsigned int>::const_iterator it = CodeList.begin();
297  while (it != CodeList.end()) {
298  RPCdecoder decode(*it);
299  RPCofflineId rpcId;
300 
301  int RPC_strip = decode.strip_number();
302  int RPC_chamber = decode.rpc_z_index();
303  int RPC_layer = decode.rpc_layer();
304  int RPC_station = decode.lvl1_station();
305  int sector = (decode.logic_sector()) % 32;
306 
307  const RPC_CondCabling::RPCchamber* rpc = s.find_chamber(RPC_station, RPC_chamber);
308 
309  rpcId.stationName = rpc->stationName();
310  rpcId.stationEta = (decode.half_barrel() == Positive) ? rpc->stationEta() : -rpc->stationEta();
311  rpcId.stationPhi = (sector == 31) ? 1 : (sector + 1) / 4 + 1;
312  rpcId.doubletR = rpc->doubletR();
313  rpcId.doubletZ = rpc->doubletZ();
314  rpcId.doubletPhi = (rpc->phiReadoutPannels() == 2) ? (sector + 1) % 2 + 1 : 1;
315  rpcId.gasGap = RPC_layer + 1;
316  rpcId.measuresPhi = static_cast<int>(decode.view());
317  rpcId.strip = RPC_strip + 1;
318 
319  offlineIdList.push_back(std::move(rpcId));
320 
321  ++it;
322  }
323 
324  std::list<Identifier> ids;
325  std::list<RPCofflineId>::const_iterator iterator = offlineIdList.begin();
326  while (iterator != offlineIdList.end()) {
327  Identifier id =
328  rpcId->channelID((*iterator).stationName, (*iterator).stationEta, (*iterator).stationPhi, (*iterator).doubletR,
329  (*iterator).doubletZ, (*iterator).doubletPhi, (*iterator).gasGap, (*iterator).measuresPhi, (*iterator).strip);
330  ids.push_back(id);
331  ++iterator;
332  }
333 
334  return ids;
335 }
336 
337 StatusCode RpcCablingCondData::giveRDO_fromPRD(const IdentifierHash prdHashId, std::vector<IdentifierHash>& rdoHashVec) const {
338  StatusCode sc = StatusCode::SUCCESS;
339 
340  rdoHashVec.clear();
341 
342  PRD_RDO_Map::const_iterator it = m_PRD_RDO_map.find(prdHashId);
343 
344  if (it == m_PRD_RDO_map.cend()) return sc;
345 
346  for (IdentifierHash rdoId : (*it).second) rdoHashVec.push_back(rdoId);
347 
348  return sc;
349 }
350 
351 StatusCode RpcCablingCondData::giveRDO_fromPRD(const std::vector<IdentifierHash>& prdHashVec,
352  std::vector<IdentifierHash>& rdoHashVec) const {
353  StatusCode sc = StatusCode::SUCCESS;
354 
355  rdoHashVec.clear();
356  std::set<IdentifierHash> requestedRdoHashSet;
357 
358  for (IdentifierHash prdHashId : prdHashVec) {
359  // find the requested PRD HashId in the map
360  PRD_RDO_Map::const_iterator it = m_PRD_RDO_map.find(prdHashId);
361  if (it == m_PRD_RDO_map.cend()) { continue; }
362  // if the PRD was found in the map, add the corresponding set of RDO HashIds to the set of requested RDO HashIds
363  requestedRdoHashSet.insert((*it).second.begin(), (*it).second.end());
364  }
365 
366  // convert set to vector
367  for (IdentifierHash rdoHashId : requestedRdoHashSet) { rdoHashVec.push_back(rdoHashId); }
368 
369  return sc;
370 }
371 
372 StatusCode RpcCablingCondData::giveRDO_fromROB(const std::vector<uint32_t>& robIdVec, std::vector<IdentifierHash>& rdoHashVec) const {
373  StatusCode sc = StatusCode::SUCCESS;
374 
375  rdoHashVec.clear();
376  std::set<IdentifierHash> requestedRdoHashSet;
377 
378  for (uint32_t robId : robIdVec) {
379  // find the requested ROB Id in the map
380  ROB_RDO_Map::const_iterator it = m_ROB_RDO_map.find(robId);
381  if (it == m_ROB_RDO_map.cend()) { continue; }
382  // if the ROB Id was found in the map, add the corresponding set of RDO HashIds to the set of requested RDO HashIds
383  requestedRdoHashSet.insert((*it).second.begin(), (*it).second.end());
384  }
385 
386  // convert set to vector
387  for (IdentifierHash rdoHashId : requestedRdoHashSet) { rdoHashVec.push_back(rdoHashId); }
388 
389  return sc;
390 }
391 
392 StatusCode RpcCablingCondData::giveROB_fromPRD(const IdentifierHash prdHashId, std::vector<uint32_t>& robIdVec) const {
393  StatusCode sc = StatusCode::SUCCESS;
394 
395  robIdVec.clear();
396 
397  PRD_ROB_Map::const_iterator it = m_PRD_ROB_map.find(prdHashId);
398 
399  if (it == m_PRD_ROB_map.cend()) return sc;
400 
401  for (uint32_t robId : (*it).second) robIdVec.push_back(robId);
402 
403  return sc;
404 }
405 
406 bool RpcCablingCondData::give_Pad_Parameters(unsigned short int logic_sector, unsigned short int PADId, bool& feet, bool& eta_and_phi,
407  unsigned short int& cma_mask, unsigned short int& feet_th0, unsigned short int& feet_th1,
408  unsigned short int& feet_th2) const {
409  if (logic_sector >= MAX_LOGICSECTOR || PADId >= MAX_PADID) return false;
410 
411  feet = m_RPCPadParameters_array[logic_sector][PADId].feet_on();
412  eta_and_phi = m_RPCPadParameters_array[logic_sector][PADId].eta_and_phi();
413  cma_mask = m_RPCPadParameters_array[logic_sector][PADId].cma_mask();
414  feet_th0 = m_RPCPadParameters_array[logic_sector][PADId].feet_threshold(0);
415  feet_th1 = m_RPCPadParameters_array[logic_sector][PADId].feet_threshold(1);
416  feet_th2 = m_RPCPadParameters_array[logic_sector][PADId].feet_threshold(2);
417 
418  return true;
419 }
420 
421 bool RpcCablingCondData::give_PAD_address(unsigned short int SubsystemId, unsigned short int SectorId, unsigned short int RoIId,
422  unsigned int& padIdHash) const {
423  unsigned short int PADId = (RoIId) / 4;
424 
425  int key = SubsystemId * 10000 + SectorId * 100 + PADId;
426 
427  // checks if the key is in the map
428  RDOmap::const_iterator it = m_RDOs.find(key);
429  if (it == m_RDOs.end()) return false;
430 
431  // Retrieve the identifier elements from the map
432  const RDOindex index = (*it).second;
433 
434  padIdHash = index.hash();
435 
436  return true;
437 }
438 
439 bool RpcCablingCondData::give_RoI_borders_id(unsigned short int SubsystemId, unsigned short int SectorId, unsigned short int RoIId,
440  Identifier& EtaLowBorder_id, Identifier& EtaHighBorder_id, Identifier& PhiLowBorder_id,
441  Identifier& PhiHighBorder_id, const RpcIdHelper* rpcId) const {
442  unsigned int EtaLowBorder = 0;
443  unsigned int EtaHighBorder = 0;
444  unsigned int PhiLowBorder = 0;
445  unsigned int PhiHighBorder = 0;
446  bool ok = give_RoI_borders(SubsystemId, SectorId, RoIId, EtaLowBorder, EtaHighBorder, PhiLowBorder, PhiHighBorder);
447  // give_RoI_borders() already complains if the return code is false
448  if (ok) {
449  EtaLowBorder_id = protected_strip_OffId_fromCode(EtaLowBorder, rpcId);
450  EtaHighBorder_id = protected_strip_OffId_fromCode(EtaHighBorder, rpcId);
451  PhiLowBorder_id = protected_strip_OffId_fromCode(PhiLowBorder, rpcId);
452  PhiHighBorder_id = protected_strip_OffId_fromCode(PhiHighBorder, rpcId);
453  }
454  return ok;
455 }
456 
457 bool RpcCablingCondData::give_RoI_borders(unsigned short int SubsystemId, unsigned short int SectorId, unsigned short int RoIId,
458  unsigned int& EtaLowBorder, unsigned int& EtaHighBorder, unsigned int& PhiLowBorder,
459  unsigned int& PhiHighBorder) const {
460  int logic_sector = SectorId + SubsystemId * 32;
461  int PadId = (RoIId) / 4;
462  int PadRoI = (RoIId) % 4;
463  int PhiIxx = PadRoI / 2;
464  int EtaIxx = PadRoI % 2;
465 
466  CMAcoverage PhiCov = (logic_sector % 2) ? OddSectors : EvenSectors;
467 
468  const RPC_CondCabling::SectorLogicSetup& s = m_SectorType[m_SectorMap[logic_sector] - 1];
469 
470  CMAidentity ETA(Eta, AllSectors, PadId, EtaIxx);
471  CMAidentity PHI(Phi, PhiCov, PadId, PhiIxx);
472 
473  if (!s.give_RoI_borders(ETA, PHI, EtaLowBorder, EtaHighBorder, PhiLowBorder, PhiHighBorder)) {
474  MsgStream log(Athena::getMessageSvc(), "RpcCablingCondData");
475  if (log.level() <= MSG::WARNING)
476  log << MSG::WARNING
477  << "give_RoI_borders() - failed to call give_RoI_borders() on SectorLogicSetup, borders not set, return false..." << endmsg;
478  return false;
479  }
480 
481  EtaLowBorder += logic_sector * 1000000;
482  EtaHighBorder += logic_sector * 1000000;
483  PhiLowBorder += logic_sector * 1000000;
484  PhiHighBorder += logic_sector * 1000000;
485 
486  return true;
487 }
488 
489 Identifier RpcCablingCondData::protected_strip_OffId_fromCode(unsigned long int strip_code, const RpcIdHelper* rpcId) const {
490  RPCofflineId rpc_strip = strip_id_fromCode(strip_code);
491  if (rpc_strip.stationName == "BOG") {
492  if (std::abs(rpc_strip.stationEta) == 4 && rpc_strip.doubletR == 2 && rpc_strip.measuresPhi == 1) {
493  if (rpc_strip.strip > 48) rpc_strip.strip = 48;
494  }
495  }
496  if (rpc_strip.stationName == "BME") {
497  if (rpc_strip.doubletR == 2 && rpc_strip.measuresPhi == 1) {
498  if (rpc_strip.strip > 36) rpc_strip.strip = 36;
499  }
500  }
501  return rpcId->channelID(rpc_strip.stationName, rpc_strip.stationEta, rpc_strip.stationPhi, rpc_strip.doubletR, rpc_strip.doubletZ,
502  rpc_strip.doubletPhi, rpc_strip.gasGap, rpc_strip.measuresPhi, rpc_strip.strip);
503 }
504 
505 RPCofflineId RpcCablingCondData::strip_id_fromCode(unsigned long int strip_code) const {
506  RPCdecoder decode(strip_code);
507  RPCofflineId rpcId;
508  rpcId.init();
509  if (!decode) { return rpcId; }
510  int RPC_logic_sector = decode.logic_sector();
511  int RPC_strip = decode.strip_number();
512  int RPC_chamber = decode.rpc_z_index();
513  int RPC_layer = decode.rpc_layer();
514  int RPC_station = decode.lvl1_station();
515  int sector = (decode.logic_sector()) % 32;
516 
517  // retrieve the Sector Logic setup
518  const RPC_CondCabling::SectorLogicSetup& s = m_SectorType[m_SectorMap[RPC_logic_sector] - 1];
519  // retrieve chamber
520  const RPC_CondCabling::RPCchamber* rpc = s.find_chamber(RPC_station, RPC_chamber);
521 
522  rpcId.stationName = rpc->stationName();
523  rpcId.stationEta = (decode.half_barrel() == Positive) ? rpc->stationEta() : -rpc->stationEta();
524  rpcId.stationPhi = (sector == 31) ? 1 : (sector + 1) / 4 + 1;
525  rpcId.doubletR = rpc->doubletR();
526  rpcId.doubletZ = rpc->doubletZ();
527  rpcId.doubletPhi = (rpc->phiReadoutPannels() == 2) ? (sector + 1) % 2 + 1 : 1;
528  rpcId.gasGap = RPC_layer + 1;
529  rpcId.measuresPhi = static_cast<int>(decode.view());
530  rpcId.strip = RPC_strip + 1;
531 
532  return rpcId;
533 }
534 
535 bool RpcCablingCondData::give_LowPt_borders(unsigned short int SubsystemId, unsigned short int SectorId, unsigned short int RoIId,
536  unsigned int& EtaLowBorder, unsigned int& EtaHighBorder, unsigned int& PhiLowBorder,
537  unsigned int& PhiHighBorder) const {
538  int logic_sector = SectorId + SubsystemId * 32;
539  int PadId = (RoIId) / 4;
540  int PadRoI = (RoIId) % 4;
541  int PhiIxx = PadRoI / 2;
542  int EtaIxx = PadRoI % 2;
543 
544  CMAcoverage PhiCov = (logic_sector % 2) ? OddSectors : EvenSectors;
545 
546  const RPC_CondCabling::SectorLogicSetup& s = m_SectorType[m_SectorMap[logic_sector] - 1];
547 
548  CMAidentity ETA(Eta, AllSectors, PadId, EtaIxx);
549  CMAidentity PHI(Phi, PhiCov, PadId, PhiIxx);
550 
551  if (!s.give_LowPt_borders(ETA, PHI, EtaLowBorder, EtaHighBorder, PhiLowBorder, PhiHighBorder)) {
552  return false; // Added for HLT
553  /* Commented for HLT
554  // LOCAL RoI within the pad may be wrong if triggering only phi vew only, try the other local eta
555  EtaIxx = (EtaIxx + 1)%2;
556  CMAidentity ETA1(Eta,AllSectors,PadId,EtaIxx);
557  if(!s.give_LowPt_borders(ETA1,PHI,EtaLowBorder,EtaHighBorder,PhiLowBorder,
558  PhiHighBorder)){
559  DISP << " Unmatched RoIId= " << RoIId
560  << " Side=" << SubsystemId << ", Sector=" << SectorId;
561  DISP_DEBUG;
562  return false;
563  }
564  */
565  }
566  if (EtaLowBorder == 0 || EtaHighBorder == 0 || PhiLowBorder == 0 || PhiHighBorder == 0) return false;
567 
568  EtaLowBorder += logic_sector * 1000000;
569  EtaHighBorder += logic_sector * 1000000;
570  PhiLowBorder += logic_sector * 1000000;
571  PhiHighBorder += logic_sector * 1000000;
572 
573  return true;
574 }
575 
576 bool RpcCablingCondData::give_LowPt_borders_id(unsigned short int SubsystemId, unsigned short int SectorId, unsigned short int RoIId,
577  Identifier& EtaLowBorder_id, Identifier& EtaHighBorder_id, Identifier& PhiLowBorder_id,
578  Identifier& PhiHighBorder_id, const RpcIdHelper* rpcId) const {
579  unsigned int EtaLowBorder = 0;
580  unsigned int EtaHighBorder = 0;
581  unsigned int PhiLowBorder = 0;
582  unsigned int PhiHighBorder = 0;
583  bool ok = give_LowPt_borders(SubsystemId, SectorId, RoIId, EtaLowBorder, EtaHighBorder, PhiLowBorder, PhiHighBorder);
584  if (ok) {
585  EtaLowBorder_id = strip_OffId_fromCode(EtaLowBorder, rpcId);
586  EtaHighBorder_id = strip_OffId_fromCode(EtaHighBorder, rpcId);
587  PhiLowBorder_id = strip_OffId_fromCode(PhiLowBorder, rpcId);
588  PhiHighBorder_id = strip_OffId_fromCode(PhiHighBorder, rpcId);
589  }
590  return ok;
591 }
592 
593 bool RpcCablingCondData::give_HighPt_borders(unsigned short int SubsystemId, unsigned short int SectorId, unsigned short int RoIId,
594  unsigned int& EtaLowBorder, unsigned int& EtaHighBorder, unsigned int& PhiLowBorder,
595  unsigned int& PhiHighBorder) const {
596  int logic_sector = SectorId + SubsystemId * 32;
597  int PadId = (RoIId) / 4;
598  int PadRoI = (RoIId) % 4;
599  int PhiIxx = PadRoI / 2;
600  int EtaIxx = PadRoI % 2;
601 
602  CMAcoverage PhiCov = (logic_sector % 2) ? OddSectors : EvenSectors;
603 
604  const RPC_CondCabling::SectorLogicSetup& s = m_SectorType[m_SectorMap[logic_sector] - 1];
605 
606  CMAidentity ETA(Eta, AllSectors, PadId, EtaIxx);
607  CMAidentity PHI(Phi, PhiCov, PadId, PhiIxx);
608 
609  if (!s.give_HighPt_borders(ETA, PHI, EtaLowBorder, EtaHighBorder, PhiLowBorder, PhiHighBorder)) {
610  return false; // Added for HLT
611  /* commented for HLT
612  // LOCAL RoI within the pad may be wrong if triggering only phi vew only, try the other local eta
613  EtaIxx = (EtaIxx + 1)%2;
614  CMAidentity ETA1(Eta,AllSectors,PadId,EtaIxx);
615  if(!s.give_HighPt_borders(ETA1,PHI,EtaLowBorder,EtaHighBorder,PhiLowBorder,
616  PhiHighBorder)){
617  DISP << " Unmatched RoIId= " << RoIId
618  << " Side=" << SubsystemId << ", Sector=" << SectorId;
619  DISP_DEBUG;
620  return false;
621  }
622  */
623  }
624  if (EtaLowBorder == 0 || EtaHighBorder == 0 || PhiLowBorder == 0 || PhiHighBorder == 0) return false;
625 
626  EtaLowBorder += logic_sector * 1000000;
627  EtaHighBorder += logic_sector * 1000000;
628  PhiLowBorder += logic_sector * 1000000;
629  PhiHighBorder += logic_sector * 1000000;
630 
631  return true;
632 }
633 
634 bool RpcCablingCondData::give_HighPt_borders_id(unsigned short int SubsystemId, unsigned short int SectorId, unsigned short int RoIId,
635  Identifier& EtaLowBorder_id, Identifier& EtaHighBorder_id, Identifier& PhiLowBorder_id,
636  Identifier& PhiHighBorder_id, const RpcIdHelper* rpcId) const {
637  unsigned int EtaLowBorder = 0;
638  unsigned int EtaHighBorder = 0;
639  unsigned int PhiLowBorder = 0;
640  unsigned int PhiHighBorder = 0;
641  bool ok = give_HighPt_borders(SubsystemId, SectorId, RoIId, EtaLowBorder, EtaHighBorder, PhiLowBorder, PhiHighBorder);
642 
643  if (ok) {
644  EtaLowBorder_id = strip_OffId_fromCode(EtaLowBorder, rpcId);
645  EtaHighBorder_id = strip_OffId_fromCode(EtaHighBorder, rpcId);
646  PhiLowBorder_id = strip_OffId_fromCode(PhiLowBorder, rpcId);
647  PhiHighBorder_id = strip_OffId_fromCode(PhiHighBorder, rpcId);
648  }
649  return ok;
650 }
651 
652 Identifier RpcCablingCondData::strip_OffId_fromCode(unsigned long int strip_code, const RpcIdHelper* rpcId) const {
653  RPCofflineId rpc_strip = strip_id_fromCode(strip_code);
654  return rpcId->channelID(rpc_strip.stationName, rpc_strip.stationEta, rpc_strip.stationPhi, rpc_strip.doubletR, rpc_strip.doubletZ,
655  rpc_strip.doubletPhi, rpc_strip.gasGap, rpc_strip.measuresPhi, rpc_strip.strip);
656 }
657 
658 bool RpcCablingCondData::giveOfflineId(const unsigned short int side, const unsigned short int sector, const unsigned short int padId,
659  Identifier& id) const {
660  if (side >= 2) return false;
661  if (sector >= 32) return false;
662  if (padId >= 10) return false;
663  id = m_offline_id[side][sector][padId];
664  return id.is_valid();
665 }
666 
667 void RpcCablingCondData::setIds(const std::vector<Identifier>& int2id) { m_int2id = int2id; }
668 
669 void RpcCablingCondData::setLookup(const std::vector<Identifier>& ids) {
670  for (size_t i = 0; i < ids.size(); i++) { m_lookup.emplace(ids[i], i); }
671 }
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
RpcCablingCondData::give_LowPt_borders
bool give_LowPt_borders(unsigned short int SubsystemId, unsigned short int SectorId, unsigned short int RoIId, unsigned int &EtaLowBorder, unsigned int &EtaHighBorder, unsigned int &PhiLowBorder, unsigned int &PhiHighBorder) const
Definition: RpcCablingCondData.cxx:535
RpcCablingCondData::give_PADid
bool give_PADid(const Identifier &compactID, unsigned short int &id) const
Definition: RpcCablingCondData.cxx:93
RPCdecoder
Definition: RPCdecoder.h:13
AtlasMcWeight::decode
double decode(number_type binnedWeight)
Convert weight from unsigned to double.
Definition: AtlasMcWeight.cxx:32
OddSectors
@ OddSectors
Definition: CMAidentity.h:14
Muon::nsw::STGTPSegments::moduleIDBits::stationPhi
constexpr uint8_t stationPhi
station Phi 1 to 8
Definition: NSWSTGTPDecodeBitmaps.h:161
dumpTgcDigiDeadChambers.gasGap
list gasGap
Definition: dumpTgcDigiDeadChambers.py:33
RPC_CondCabling::RPCchamber::doubletZ
int doubletZ() const
Definition: RPCchamber.cxx:37
DiTauMassTools::TauTypes::lh
@ lh
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:53
RpcCablingCondData::give_strip_id
std::list< Identifier > give_strip_id(unsigned short int SubsystemId, unsigned short int SectorId, unsigned short int PADId, unsigned short int CMAId, unsigned short ijk, unsigned short int Channel, const RpcIdHelper *rpcId) const
Definition: RpcCablingCondData.cxx:270
RpcCablingCondData::give_RoI_borders_id
bool give_RoI_borders_id(unsigned short int SubsystemId, unsigned short int SectorId, unsigned short int RoIId, Identifier &EtaLowBorder_id, Identifier &EtaHighBorder_id, Identifier &PhiLowBorder_id, Identifier &PhiHighBorder_id, const RpcIdHelper *rpcId) const
Definition: RpcCablingCondData.cxx:439
get_generator_info.result
result
Definition: get_generator_info.py:21
SiliconTech::strip
@ strip
RpcCablingCondData::setIds
void setIds(const std::vector< Identifier > &int2id)
Definition: RpcCablingCondData.cxx:667
RPCofflineId::doubletR
int doubletR
Definition: RPCofflineId.h:12
getMessageSvc.h
singleton-like access to IMessageSvc via open function and helper
LArBadChanBlobUtils::Channel
Identifier32::value_type Channel
Definition: LArBadChanBlobUtils.h:24
RpcCablingCondData::setLookup
void setLookup(const std::vector< Identifier > &ids)
Definition: RpcCablingCondData.cxx:669
dumpTgcDigiDeadChambers.stationName
dictionary stationName
Definition: dumpTgcDigiDeadChambers.py:30
RPCofflineId
Definition: RPCofflineId.h:8
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
index
Definition: index.py:1
RpcCablingCondData::give_RODid
bool give_RODid(const Identifier &compactID, unsigned short int &id) const
Definition: RpcCablingCondData.cxx:29
RPCPadParameters::eta_and_phi
bool eta_and_phi(void) const
Definition: RPCPadParameters.h:33
RpcCablingCondData::m_RPCPadParameters_array
RPCPadParameters m_RPCPadParameters_array[MAX_LOGICSECTOR][MAX_PADID]
Definition: RpcCablingCondData.h:171
Muon::MuonStationIndex::stName
const std::string & stName(StIndex index)
convert StIndex into a string
Definition: MuonStationIndex.cxx:104
CMAcoverage
CMAcoverage
Definition: CMAidentity.h:14
skel.it
it
Definition: skel.GENtoEVGEN.py:407
python.SystemOfUnits.second
float second
Definition: SystemOfUnits.py:135
RpcCablingCondData::give_HighPt_borders
bool give_HighPt_borders(unsigned short int SubsystemId, unsigned short int SectorId, unsigned short int RoIId, unsigned int &EtaLowBorder, unsigned int &EtaHighBorder, unsigned int &PhiLowBorder, unsigned int &PhiHighBorder) const
Definition: RpcCablingCondData.cxx:593
createCablingJSON.doubletR
int doubletR
Definition: createCablingJSON.py:15
RpcCablingCondData::m_HashVec
OfflineOnlineHashMap m_HashVec
Definition: RpcCablingCondData.h:136
RpcCablingCondData::m_fullListOfRobIds
std::vector< uint32_t > m_fullListOfRobIds
Definition: RpcCablingCondData.h:157
CMAparameters::CMAlist
std::list< const CMAparameters * > CMAlist
Definition: CMAparameters.h:25
Phi
@ Phi
Definition: RPCdef.h:8
RpcCablingCondData::m_RDOs
RDOmap m_RDOs
Definition: RpcCablingCondData.h:134
RoiUtil::PHI
@ PHI
Definition: RoiSerialise.cxx:31
RPCPadParameters::feet_threshold
unsigned short int feet_threshold(unsigned short int it) const
Definition: RPCPadParameters.cxx:40
RpcIdHelper::channelID
Identifier channelID(int stationName, int stationEta, int stationPhi, int doubletR, int doubletZ, int doubletPhi, int gasGap, int measuresPhi, int strip) const
Definition: RpcIdHelper.cxx:936
RpcCablingCondData::m_rod2hash
std::vector< IdentifierHash > m_rod2hash[2][16]
Definition: RpcCablingCondData.h:154
RpcCablingCondData::strip_code_fromOffline
static unsigned long int strip_code_fromOffline(int etaPhiView, int logicSector, int cablingStation, int gasGap, int zIndexInCablingStation, int strip)
Definition: RpcCablingCondData.cxx:221
Identifier::is_valid
bool is_valid() const
Check if id is in a valid state.
RpcIdHelper
Definition: RpcIdHelper.h:51
Athena::getMessageSvc
IMessageSvc * getMessageSvc(bool quiet=false)
Definition: getMessageSvc.cxx:20
RpcIdHelper.h
RpcCablingCondData::strip_OffId_fromCode
Identifier strip_OffId_fromCode(unsigned long int strip_code, const RpcIdHelper *rpcId) const
Definition: RpcCablingCondData.cxx:652
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
RpcCablingCondData::give_LowPt_borders_id
bool give_LowPt_borders_id(unsigned short int SubsystemId, unsigned short int SectorId, unsigned short int RoIId, Identifier &EtaLowBorder_id, Identifier &EtaHighBorder_id, Identifier &PhiLowBorder_id, Identifier &PhiHighBorder_id, const RpcIdHelper *rpcId) const
Definition: RpcCablingCondData.cxx:576
RpcCablingCondData::strip_id_fromCode
RPCofflineId strip_id_fromCode(unsigned long int strip_code) const
Definition: RpcCablingCondData.cxx:505
RpcCablingCondData::offset
static int offset()
Definition: RpcCablingCondData.cxx:129
TRT::Hit::side
@ side
Definition: HitInfo.h:83
RPCPadParameters::feet_on
bool feet_on(void) const
Definition: RPCPadParameters.h:32
RPC_CondCabling::SectorLogicSetup::find_chamber
const RPCchamber * find_chamber(int, int) const
Definition: SectorLogicSetup.cxx:133
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
RpcCablingCondData::give_RXid
bool give_RXid(const Identifier &compactID, unsigned short int &id) const
Definition: RpcCablingCondData.cxx:77
histSizes.code
code
Definition: histSizes.py:129
RpcCablingCondData::m_lookup
std::map< Identifier, int > m_lookup
Definition: RpcCablingCondData.h:155
RpcCablingCondData::m_ROB_RDO_map
ROB_RDO_Map m_ROB_RDO_map
Definition: RpcCablingCondData.h:163
RpcCablingCondData::give_side
bool give_side(const Identifier &compactID, unsigned short int &id) const
Definition: RpcCablingCondData.cxx:45
RpcCablingCondData::give_PAD_address
bool give_PAD_address(unsigned short int SubsystemId, unsigned short int SectorId, unsigned short int RoIId, unsigned int &padIdHash) const
Definition: RpcCablingCondData.cxx:421
RpcCablingCondData::m_offline_id
Identifier m_offline_id[2][32][10]
Definition: RpcCablingCondData.h:173
RpcCablingCondData::max
int max() const
Definition: RpcCablingCondData.cxx:127
RpcCablingCondData::m_SectorMap
int m_SectorMap[64]
Definition: RpcCablingCondData.h:158
RPCofflineId::stationPhi
int stationPhi
Definition: RPCofflineId.h:11
xAOD::uint16_t
setWord1 uint16_t
Definition: eFexEMRoI_v1.cxx:93
RpcCablingCondData::hash2source
uint32_t hash2source(unsigned int h) const
Definition: RpcCablingCondData.cxx:136
lumiFormat.i
int i
Definition: lumiFormat.py:85
RPC_CondCabling::RPCchamber::doubletR
int doubletR() const
Definition: RPCchamber.cxx:36
RPC_CondCabling::RPCchamber::stationEta
int stationEta() const
Definition: RPCchamber.cxx:35
RpcCablingCondData::give_Pad_Parameters
virtual bool give_Pad_Parameters(unsigned short int logic_sector, unsigned short int PADId, bool &feet, bool &eta_and_phi, unsigned short int &cma_mask, unsigned short int &feet_th0, unsigned short int &feet_th1, unsigned short int &feet_th2) const
Definition: RpcCablingCondData.cxx:406
ViewType
ViewType
Definition: RPCdef.h:8
EvenSectors
@ EvenSectors
Definition: CMAidentity.h:14
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
RpcCablingCondData::giveOfflineId
bool giveOfflineId(const unsigned short int side, const unsigned short int sector, const unsigned short int padId, Identifier &id) const
Definition: RpcCablingCondData.cxx:658
RPCofflineId::strip
int strip
Definition: RPCofflineId.h:17
RpcCablingCondData::RDOmap
std::map< int, RDOindex, std::less< int > > RDOmap
Definition: RpcCablingCondData.h:27
RPCofflineId.h
RpcCablingCondData::MAX_LOGICSECTOR
static constexpr unsigned MAX_LOGICSECTOR
Definition: RpcCablingCondData.h:170
RpcCablingCondData::giveRDO_fromPRD
StatusCode giveRDO_fromPRD(const IdentifierHash prdHashId, std::vector< IdentifierHash > &rdoHashVec) const
Definition: RpcCablingCondData.cxx:337
AllSectors
@ AllSectors
Definition: CMAidentity.h:14
RpcCablingCondData::identifier
Identifier identifier(int i) const
Definition: RpcCablingCondData.cxx:111
RPC_CondCabling::SectorLogicSetup
Definition: SectorLogicSetup.h:23
RunTileMonitoring.rod
rod
Definition: RunTileMonitoring.py:134
RPCofflineId::measuresPhi
int measuresPhi
Definition: RPCofflineId.h:16
RpcCablingCondData::m_PRD_ROB_map
PRD_ROB_Map m_PRD_ROB_map
Definition: RpcCablingCondData.h:162
RPCofflineId::gasGap
int gasGap
Definition: RPCofflineId.h:15
RPCofflineId::stationEta
int stationEta
Definition: RPCofflineId.h:10
RPCofflineId::stationName
std::string stationName
Definition: RPCofflineId.h:9
RPCofflineId::init
void init()
Definition: RPCofflineId.h:18
Positive
@ Positive
Definition: RPCdef.h:9
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:239
python.subdetectors.mmg.ids
ids
Definition: mmg.py:8
RpcCablingCondData::give_ROBid
bool give_ROBid(const Identifier &compactID, unsigned short int &id) const
Definition: RpcCablingCondData.cxx:13
RpcCablingCondData::giveROB_fromRDO
StatusCode giveROB_fromRDO(const IdentifierHash rdoHashId, uint32_t &robId) const
Definition: RpcCablingCondData.cxx:147
RPC_CondCabling::RPCchamber
Definition: RPCchamber.h:23
RpcCablingCondData::give_RoI_borders
bool give_RoI_borders(unsigned short int SubsystemId, unsigned short int SectorId, unsigned short int RoIId, unsigned int &EtaLowBorder, unsigned int &EtaHighBorder, unsigned int &PhiLowBorder, unsigned int &PhiHighBorder) const
Definition: RpcCablingCondData.cxx:457
RoiUtil::ETA
@ ETA
Definition: RoiSerialise.cxx:30
RpcCablingCondData::largeSector
static bool largeSector(const std::string &stName)
Definition: RpcCablingCondData.cxx:229
RpcCablingCondData::strip_code_fromOffId
unsigned long int strip_code_fromOffId(const std::string &stationName, int stationEta, int stationPhi, int doubletR, int doubletZ, int doubletPhi, int gasGap, int measuresPhi, int strip) const
Definition: RpcCablingCondData.cxx:186
RPC_CondCabling::RPCchamber::stationName
std::string stationName() const
Definition: RPCchamber.cxx:34
RpcCablingCondData::m_MaxType
int m_MaxType
Definition: RpcCablingCondData.h:165
RPCofflineId::doubletZ
int doubletZ
Definition: RPCofflineId.h:13
DeMoScan.index
string index
Definition: DeMoScan.py:362
RpcCablingCondData::computeZIndexInCablingStation
unsigned int computeZIndexInCablingStation(const std::string &stationName, int logicSector, int stationEta, int doubletR, int doubletZ, int cabStat) const
Definition: RpcCablingCondData.cxx:240
CMAidentity
Definition: CMAidentity.h:16
RpcCablingCondData::m_RDOmap
OfflineOnlineMap m_RDOmap
Definition: RpcCablingCondData.h:135
RpcCablingCondData::giveROB_fromPRD
StatusCode giveROB_fromPRD(const IdentifierHash prdHashId, std::vector< uint32_t > &robIdVec) const
Definition: RpcCablingCondData.cxx:392
h
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
CaloCondBlobAlgs_fillNoiseFromASCII.hash
dictionary hash
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:108
RPCPadParameters::cma_mask
unsigned short int cma_mask(void) const
Definition: RPCPadParameters.h:35
RpcCablingCondData::giveFullListOfRobIds
const std::vector< uint32_t > & giveFullListOfRobIds() const
Definition: RpcCablingCondData.cxx:109
RpcCablingCondData.h
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
RpcCablingCondData::MAX_PADID
static constexpr unsigned MAX_PADID
Definition: RpcCablingCondData.h:169
python.SystemOfUnits.s
float s
Definition: SystemOfUnits.py:147
RpcCablingCondData::give_SLid
bool give_SLid(const Identifier &compactID, unsigned short int &id) const
Definition: RpcCablingCondData.cxx:61
RpcCablingCondData::give_HighPt_borders_id
bool give_HighPt_borders_id(unsigned short int SubsystemId, unsigned short int SectorId, unsigned short int RoIId, Identifier &EtaLowBorder_id, Identifier &EtaHighBorder_id, Identifier &PhiLowBorder_id, Identifier &PhiHighBorder_id, const RpcIdHelper *rpcId) const
Definition: RpcCablingCondData.cxx:634
RpcCablingCondData::giveRDO_fromROB
StatusCode giveRDO_fromROB(const std::vector< uint32_t > &robIdVec, std::vector< IdentifierHash > &rdoHashVec) const
Definition: RpcCablingCondData.cxx:372
createCablingJSON.doubletPhi
int doubletPhi
Definition: createCablingJSON.py:16
python.DiskUtils.ls
def ls(path, longls=False)
Definition: DiskUtils.py:111
Muon::nsw::STGTPSegments::moduleIDBits::stationEta
constexpr uint8_t stationEta
1 to 3
Definition: NSWSTGTPDecodeBitmaps.h:159
RpcCablingCondData::protected_strip_OffId_fromCode
Identifier protected_strip_OffId_fromCode(unsigned long int strip_code, const RpcIdHelper *rpcId) const
Definition: RpcCablingCondData.cxx:489
IdentifierHash
This is a "hash" representation of an Identifier. This encodes a 32 bit index which can be used to lo...
Definition: IdentifierHash.h:25
RpcCablingCondData::m_SectorType
STvec m_SectorType
Definition: RpcCablingCondData.h:160
RpcCablingCondData::m_int2id
std::vector< Identifier > m_int2id
Definition: RpcCablingCondData.h:153
RPC_CondCabling::RPCchamber::chamber_name
const std::string & chamber_name() const
Definition: RPCchamber.cxx:33
RpcCablingCondData::operator()
int operator()(const Identifier &id) const
Definition: RpcCablingCondData.cxx:119
RpcCablingCondData::m_PRD_RDO_map
PRD_RDO_Map m_PRD_RDO_map
Definition: RpcCablingCondData.h:161
RpcCablingCondData::give_CMAs
const CMAparameters::CMAlist give_CMAs(const int logic_sector, const ViewType side, const int station, const int cabling_code) const
Definition: RpcCablingCondData.cxx:179
Eta
@ Eta
Definition: RPCdef.h:8
RPC_CondCabling::RPCchamber::phiReadoutPannels
int phiReadoutPannels() const
Definition: RPCchamber.cxx:38
RPCofflineId::doubletPhi
int doubletPhi
Definition: RPCofflineId.h:14
RpcCablingCondData::rod2hash
std::vector< IdentifierHash > rod2hash(uint16_t subsystem, uint16_t rod) const
Definition: RpcCablingCondData.cxx:131
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
RDOindex
Definition: RDOindex.h:85
RpcCablingCondData::give_RDOs
const RDOmap & give_RDOs(void) const
Definition: RpcCablingCondData.cxx:11
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Thu Nov 6 2025 21:20:46 for ATLAS Offline Software by   doxygen 1.8.18