Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
Public Types | Public Member Functions | Static Public Member Functions | Private Attributes | Static Private Attributes | Friends | List of all members
RpcCablingCondData Class Reference

#include <RpcCablingCondData.h>

Collaboration diagram for RpcCablingCondData:

Public Types

typedef std::map< int, RDOindex, std::less< int > > RDOmap
 
typedef std::vector< const RDOindex * > OfflineOnlineHashMap
 
typedef std::map< Identifier, const RDOindex *, std::less< Identifier > > OfflineOnlineMap
 
typedef std::vector< RPC_CondCabling::SectorLogicSetup > STvec
 
typedef std::map< IdentifierHash, std::set< IdentifierHash > > PRD_RDO_Map
 
typedef std::map< IdentifierHash, std::set< uint32_t > > PRD_ROB_Map
 
typedef std::map< uint32_t, std::set< IdentifierHash > > ROB_RDO_Map
 

Public Member Functions

 RpcCablingCondData ()=default
 
virtual ~RpcCablingCondData ()=default
 
const RDOmap & give_RDOs (void) const
 
bool give_ROBid (const Identifier &compactID, unsigned short int &id) const
 
bool give_ROBid (const unsigned int hashID, unsigned short int &id) const
 
bool give_RODid (const Identifier &compactID, unsigned short int &id) const
 
bool give_RODid (const unsigned int hashID, unsigned short int &id) const
 
bool give_side (const Identifier &compactID, unsigned short int &id) const
 
bool give_side (const unsigned int hashID, unsigned short int &id) const
 
bool give_SLid (const Identifier &compactID, unsigned short int &id) const
 
bool give_SLid (const unsigned int hashID, unsigned short int &id) const
 
bool give_RXid (const Identifier &compactID, unsigned short int &id) const
 
bool give_RXid (const unsigned int hashID, unsigned short int &id) const
 
bool give_PADid (const Identifier &compactID, unsigned short int &id) const
 
bool give_PADid (const unsigned int hashID, unsigned short int &id) const
 
const std::vector< uint32_t > & giveFullListOfRobIds () const
 
StatusCode giveROB_fromRDO (const IdentifierHash rdoHashId, uint32_t &robId) const
 
StatusCode giveROB_fromRDO (const std::vector< IdentifierHash > &rdoHashVec, std::vector< uint32_t > &robIdVec) const
 
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
 
const CMAparameters::CMAlist give_CMAs (const int logic_sector, const ViewType side, const int station, const int cabling_code) const
 
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
 
unsigned int computeZIndexInCablingStation (const std::string &stationName, int logicSector, int stationEta, int doubletR, int doubletZ, int cabStat) const
 
StatusCode giveRDO_fromPRD (const IdentifierHash prdHashId, std::vector< IdentifierHash > &rdoHashVec) const
 
StatusCode giveRDO_fromPRD (const std::vector< IdentifierHash > &prdHashVec, std::vector< IdentifierHash > &rdoHashVec) const
 
StatusCode giveRDO_fromROB (const std::vector< uint32_t > &robIdVec, std::vector< IdentifierHash > &rdoHashVec) const
 
StatusCode giveROB_fromPRD (const IdentifierHash prdHashId, std::vector< uint32_t > &robIdVec) const
 
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
 
bool give_PAD_address (unsigned short int SubsystemId, unsigned short int SectorId, unsigned short int RoIId, unsigned int &padIdHash) const
 
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
 
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
 
Identifier protected_strip_OffId_fromCode (unsigned long int strip_code, const RpcIdHelper *rpcId) const
 
RPCofflineId strip_id_fromCode (unsigned long int strip_code) const
 
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
 
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
 
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
 
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
 
Identifier strip_OffId_fromCode (unsigned long int strip_code, const RpcIdHelper *rpcId) const
 
bool giveOfflineId (const unsigned short int side, const unsigned short int sector, const unsigned short int padId, Identifier &id) const
 
Identifier identifier (int i) const
 
int operator() (const Identifier &id) const
 
int max () const
 
std::vector< IdentifierHash > rod2hash (uint16_t subsystem, uint16_t rod) const
 
uint32_t hash2source (unsigned int h) const
 
void setIds (const std::vector< Identifier > &int2id)
 
void setLookup (const std::vector< Identifier > &ids)
 

Static Public Member Functions

static unsigned long int strip_code_fromOffline (int etaPhiView, int logicSector, int cablingStation, int gasGap, int zIndexInCablingStation, int strip)
 
static bool largeSector (const std::string &stName)
 
static int offset ()
 

Private Attributes

RDOmap m_RDOs
 
OfflineOnlineMap m_RDOmap
 
OfflineOnlineHashMap m_HashVec
 
std::string m_map
 
std::string m_corr
 
std::vector< std::string > m_vecetaCM_File
 
std::vector< std::string > m_vecetaTh0
 
std::vector< std::string > m_vecetaSequence_Th
 
std::vector< std::string > m_vecetaInfo
 
std::map< std::string, std::string > m_trigroads
 
std::vector< std::string > m_vecphiCM_File
 
std::vector< std::string > m_vecphiTh0
 
std::vector< std::string > m_vecphiInfo
 
std::vector< Identifier > m_int2id
 
std::vector< IdentifierHash > m_rod2hash [2][16]
 
std::map< Identifier, int > m_lookup
 
std::vector< uint32_t > m_fullListOfRobIds
 
int m_SectorMap [64] {}
 
STvec m_SectorType
 
PRD_RDO_Map m_PRD_RDO_map
 
PRD_ROB_Map m_PRD_ROB_map
 
ROB_RDO_Map m_ROB_RDO_map
 
int m_MaxType =-999999
 
RPCPadParameters m_RPCPadParameters_array [MAX_LOGICSECTOR][MAX_PADID]
 
Identifier m_offline_id [2][32][10]
 

Static Private Attributes

static constexpr unsigned MAX_PADID = 10
 
static constexpr unsigned MAX_LOGICSECTOR = 64
 

Friends

class RpcCablingCondAlg
 

Detailed Description

Definition at line 21 of file RpcCablingCondData.h.

Member Typedef Documentation

◆ OfflineOnlineHashMap

typedef std::vector<const RDOindex*> RpcCablingCondData::OfflineOnlineHashMap

Definition at line 26 of file RpcCablingCondData.h.

◆ OfflineOnlineMap

typedef std::map<Identifier, const RDOindex*, std::less<Identifier> > RpcCablingCondData::OfflineOnlineMap

Definition at line 27 of file RpcCablingCondData.h.

◆ PRD_RDO_Map

typedef std::map<IdentifierHash, std::set<IdentifierHash> > RpcCablingCondData::PRD_RDO_Map

Definition at line 29 of file RpcCablingCondData.h.

◆ PRD_ROB_Map

typedef std::map<IdentifierHash, std::set<uint32_t> > RpcCablingCondData::PRD_ROB_Map

Definition at line 30 of file RpcCablingCondData.h.

◆ RDOmap

typedef std::map<int, RDOindex, std::less<int> > RpcCablingCondData::RDOmap

Definition at line 25 of file RpcCablingCondData.h.

◆ ROB_RDO_Map

typedef std::map<uint32_t, std::set<IdentifierHash> > RpcCablingCondData::ROB_RDO_Map

Definition at line 31 of file RpcCablingCondData.h.

◆ STvec

typedef std::vector<RPC_CondCabling::SectorLogicSetup> RpcCablingCondData::STvec

Definition at line 28 of file RpcCablingCondData.h.

Constructor & Destructor Documentation

◆ RpcCablingCondData()

RpcCablingCondData::RpcCablingCondData ( )
default

◆ ~RpcCablingCondData()

virtual RpcCablingCondData::~RpcCablingCondData ( )
virtualdefault

Member Function Documentation

◆ computeZIndexInCablingStation()

unsigned int RpcCablingCondData::computeZIndexInCablingStation ( const std::string &  stationName,
int  logicSector,
int  stationEta,
int  doubletR,
int  doubletZ,
int  cabStat 
) const

Definition at line 239 of file RpcCablingCondData.cxx.

240  {
241  unsigned int zIndexInCablingStation = 999;
242  int cablingStation = -1;
243  int sectType = m_SectorMap[logicSector];
244  assert(m_MaxType != -999999);
245  if (sectType < 1 || sectType > m_MaxType + 1) { return 99999; }
246  const RPC_CondCabling::SectorLogicSetup& sec = m_SectorType[sectType - 1];
247 
248  for (unsigned int jStat = 1; jStat < 4; ++jStat) {
249  if (cablingStation != -1) break;
250  for (unsigned int jCham = 0; jCham < 20; ++jCham) {
251  const RPC_CondCabling::RPCchamber* rpcC = sec.find_chamber(jStat, jCham);
252  if (rpcC == nullptr) continue;
253 
254  if ((rpcC->chamber_name()).substr(0, 3) != stationName) { continue; }
255  if (rpcC->stationEta() != abs(stationEta)) { continue; }
256  if (rpcC->doubletR() != doubletR) { continue; }
257  if (rpcC->doubletZ() != doubletZ) { continue; }
258  cablingStation = jStat;
259  zIndexInCablingStation = jCham;
260  break;
261  }
262  }
263  if (cablingStation < 1 || cablingStation > 3 || (cabStat != cablingStation)) { return 99999; }
264  if (zIndexInCablingStation > 19) { return 99999; }
265 
266  return zIndexInCablingStation;
267 }

◆ give_CMAs()

const CMAparameters::CMAlist RpcCablingCondData::give_CMAs ( const int  logic_sector,
const ViewType  side,
const int  station,
const int  cabling_code 
) const

Definition at line 178 of file RpcCablingCondData.cxx.

179  {
180  const RPC_CondCabling::SectorLogicSetup& s = m_SectorType[m_SectorMap[logic_sector] - 1];
181  CMAparameters::CMAlist result = s.give_CMAs(logic_sector, side, station, cabling_code);
182  return result;
183 }

◆ give_HighPt_borders()

bool RpcCablingCondData::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 at line 592 of file RpcCablingCondData.cxx.

594  {
595  int logic_sector = SectorId + SubsystemId * 32;
596  int PadId = (RoIId) / 4;
597  int PadRoI = (RoIId) % 4;
598  int PhiIxx = PadRoI / 2;
599  int EtaIxx = PadRoI % 2;
600 
601  CMAcoverage PhiCov = (logic_sector % 2) ? OddSectors : EvenSectors;
602 
603  const RPC_CondCabling::SectorLogicSetup& s = m_SectorType[m_SectorMap[logic_sector] - 1];
604 
605  CMAidentity ETA(Eta, AllSectors, PadId, EtaIxx);
606  CMAidentity PHI(Phi, PhiCov, PadId, PhiIxx);
607 
608  if (!s.give_HighPt_borders(ETA, PHI, EtaLowBorder, EtaHighBorder, PhiLowBorder, PhiHighBorder)) {
609  return false; // Added for HLT
610  /* commented for HLT
611  // LOCAL RoI within the pad may be wrong if triggering only phi vew only, try the other local eta
612  EtaIxx = (EtaIxx + 1)%2;
613  CMAidentity ETA1(Eta,AllSectors,PadId,EtaIxx);
614  if(!s.give_HighPt_borders(ETA1,PHI,EtaLowBorder,EtaHighBorder,PhiLowBorder,
615  PhiHighBorder)){
616  DISP << " Unmatched RoIId= " << RoIId
617  << " Side=" << SubsystemId << ", Sector=" << SectorId;
618  DISP_DEBUG;
619  return false;
620  }
621  */
622  }
623  if (EtaLowBorder == 0 || EtaHighBorder == 0 || PhiLowBorder == 0 || PhiHighBorder == 0) return false;
624 
625  EtaLowBorder += logic_sector * 1000000;
626  EtaHighBorder += logic_sector * 1000000;
627  PhiLowBorder += logic_sector * 1000000;
628  PhiHighBorder += logic_sector * 1000000;
629 
630  return true;
631 }

◆ give_HighPt_borders_id()

bool RpcCablingCondData::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 at line 633 of file RpcCablingCondData.cxx.

635  {
636  unsigned int EtaLowBorder = 0;
637  unsigned int EtaHighBorder = 0;
638  unsigned int PhiLowBorder = 0;
639  unsigned int PhiHighBorder = 0;
640  bool ok = give_HighPt_borders(SubsystemId, SectorId, RoIId, EtaLowBorder, EtaHighBorder, PhiLowBorder, PhiHighBorder);
641 
642  if (ok) {
643  EtaLowBorder_id = strip_OffId_fromCode(EtaLowBorder, rpcId);
644  EtaHighBorder_id = strip_OffId_fromCode(EtaHighBorder, rpcId);
645  PhiLowBorder_id = strip_OffId_fromCode(PhiLowBorder, rpcId);
646  PhiHighBorder_id = strip_OffId_fromCode(PhiHighBorder, rpcId);
647  }
648  return ok;
649 }

◆ give_LowPt_borders()

bool RpcCablingCondData::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 at line 534 of file RpcCablingCondData.cxx.

536  {
537  int logic_sector = SectorId + SubsystemId * 32;
538  int PadId = (RoIId) / 4;
539  int PadRoI = (RoIId) % 4;
540  int PhiIxx = PadRoI / 2;
541  int EtaIxx = PadRoI % 2;
542 
543  CMAcoverage PhiCov = (logic_sector % 2) ? OddSectors : EvenSectors;
544 
545  const RPC_CondCabling::SectorLogicSetup& s = m_SectorType[m_SectorMap[logic_sector] - 1];
546 
547  CMAidentity ETA(Eta, AllSectors, PadId, EtaIxx);
548  CMAidentity PHI(Phi, PhiCov, PadId, PhiIxx);
549 
550  if (!s.give_LowPt_borders(ETA, PHI, EtaLowBorder, EtaHighBorder, PhiLowBorder, PhiHighBorder)) {
551  return false; // Added for HLT
552  /* Commented for HLT
553  // LOCAL RoI within the pad may be wrong if triggering only phi vew only, try the other local eta
554  EtaIxx = (EtaIxx + 1)%2;
555  CMAidentity ETA1(Eta,AllSectors,PadId,EtaIxx);
556  if(!s.give_LowPt_borders(ETA1,PHI,EtaLowBorder,EtaHighBorder,PhiLowBorder,
557  PhiHighBorder)){
558  DISP << " Unmatched RoIId= " << RoIId
559  << " Side=" << SubsystemId << ", Sector=" << SectorId;
560  DISP_DEBUG;
561  return false;
562  }
563  */
564  }
565  if (EtaLowBorder == 0 || EtaHighBorder == 0 || PhiLowBorder == 0 || PhiHighBorder == 0) return false;
566 
567  EtaLowBorder += logic_sector * 1000000;
568  EtaHighBorder += logic_sector * 1000000;
569  PhiLowBorder += logic_sector * 1000000;
570  PhiHighBorder += logic_sector * 1000000;
571 
572  return true;
573 }

◆ give_LowPt_borders_id()

bool RpcCablingCondData::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 at line 575 of file RpcCablingCondData.cxx.

577  {
578  unsigned int EtaLowBorder = 0;
579  unsigned int EtaHighBorder = 0;
580  unsigned int PhiLowBorder = 0;
581  unsigned int PhiHighBorder = 0;
582  bool ok = give_LowPt_borders(SubsystemId, SectorId, RoIId, EtaLowBorder, EtaHighBorder, PhiLowBorder, PhiHighBorder);
583  if (ok) {
584  EtaLowBorder_id = strip_OffId_fromCode(EtaLowBorder, rpcId);
585  EtaHighBorder_id = strip_OffId_fromCode(EtaHighBorder, rpcId);
586  PhiLowBorder_id = strip_OffId_fromCode(PhiLowBorder, rpcId);
587  PhiHighBorder_id = strip_OffId_fromCode(PhiHighBorder, rpcId);
588  }
589  return ok;
590 }

◆ give_PAD_address()

bool RpcCablingCondData::give_PAD_address ( unsigned short int  SubsystemId,
unsigned short int  SectorId,
unsigned short int  RoIId,
unsigned int &  padIdHash 
) const

Definition at line 420 of file RpcCablingCondData.cxx.

421  {
422  unsigned short int PADId = (RoIId) / 4;
423 
424  int key = SubsystemId * 10000 + SectorId * 100 + PADId;
425 
426  // checks if the key is in the map
427  RDOmap::const_iterator it = m_RDOs.find(key);
428  if (it == m_RDOs.end()) return false;
429 
430  // Retrieve the identifier elements from the map
431  const RDOindex index = (*it).second;
432 
433  padIdHash = index.hash();
434 
435  return true;
436 }

◆ give_Pad_Parameters()

bool RpcCablingCondData::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
virtual

Definition at line 405 of file RpcCablingCondData.cxx.

407  {
408  if (logic_sector >= MAX_LOGICSECTOR || PADId >= MAX_PADID) return false;
409 
410  feet = m_RPCPadParameters_array[logic_sector][PADId].feet_on();
411  eta_and_phi = m_RPCPadParameters_array[logic_sector][PADId].eta_and_phi();
412  cma_mask = m_RPCPadParameters_array[logic_sector][PADId].cma_mask();
413  feet_th0 = m_RPCPadParameters_array[logic_sector][PADId].feet_threshold(0);
414  feet_th1 = m_RPCPadParameters_array[logic_sector][PADId].feet_threshold(1);
415  feet_th2 = m_RPCPadParameters_array[logic_sector][PADId].feet_threshold(2);
416 
417  return true;
418 }

◆ give_PADid() [1/2]

bool RpcCablingCondData::give_PADid ( const Identifier &  compactID,
unsigned short int &  id 
) const

Definition at line 92 of file RpcCablingCondData.cxx.

92  {
93  OfflineOnlineMap::const_iterator it = m_RDOmap.find(compactID);
94  if (it == m_RDOmap.end()) return false;
95  const RDOindex* index = (*m_RDOmap.find(compactID)).second;
96  if (!index) return false;
97  id = index->PADid();
98  return true;
99 }

◆ give_PADid() [2/2]

bool RpcCablingCondData::give_PADid ( const unsigned int  hashID,
unsigned short int &  id 
) const

Definition at line 100 of file RpcCablingCondData.cxx.

100  {
101  if (hashID >= m_HashVec.size()) return false;
102  const RDOindex* index = m_HashVec[hashID];
103  if (!index) return false;
104  id = index->PADid();
105  return true;
106 }

◆ give_RDOs()

const RpcCablingCondData::RDOmap & RpcCablingCondData::give_RDOs ( void  ) const

Definition at line 10 of file RpcCablingCondData.cxx.

10 { return m_RDOs; }

◆ give_ROBid() [1/2]

bool RpcCablingCondData::give_ROBid ( const Identifier &  compactID,
unsigned short int &  id 
) const

Definition at line 12 of file RpcCablingCondData.cxx.

12  {
13  OfflineOnlineMap::const_iterator it = m_RDOmap.find(compactID);
14  if (it == m_RDOmap.end()) return false;
15  const RDOindex* index = (*m_RDOmap.find(compactID)).second;
16  if (!index) return false;
17  id = index->ROBid();
18  return true;
19 }

◆ give_ROBid() [2/2]

bool RpcCablingCondData::give_ROBid ( const unsigned int  hashID,
unsigned short int &  id 
) const

Definition at line 20 of file RpcCablingCondData.cxx.

20  {
21  if (hashID >= m_HashVec.size()) return false;
22  const RDOindex* index = m_HashVec[hashID];
23  if (!index) return false;
24  id = index->ROBid();
25  return true;
26 }

◆ give_RODid() [1/2]

bool RpcCablingCondData::give_RODid ( const Identifier &  compactID,
unsigned short int &  id 
) const

Definition at line 28 of file RpcCablingCondData.cxx.

28  {
29  OfflineOnlineMap::const_iterator it = m_RDOmap.find(compactID);
30  if (it == m_RDOmap.end()) return false;
31  const RDOindex* index = (*m_RDOmap.find(compactID)).second;
32  if (!index) return false;
33  id = index->RODid();
34  return true;
35 }

◆ give_RODid() [2/2]

bool RpcCablingCondData::give_RODid ( const unsigned int  hashID,
unsigned short int &  id 
) const

Definition at line 36 of file RpcCablingCondData.cxx.

36  {
37  if (hashID >= m_HashVec.size()) return false;
38  const RDOindex* index = m_HashVec[hashID];
39  if (!index) return false;
40  id = index->RODid();
41  return true;
42 }

◆ give_RoI_borders()

bool RpcCablingCondData::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 at line 456 of file RpcCablingCondData.cxx.

458  {
459  int logic_sector = SectorId + SubsystemId * 32;
460  int PadId = (RoIId) / 4;
461  int PadRoI = (RoIId) % 4;
462  int PhiIxx = PadRoI / 2;
463  int EtaIxx = PadRoI % 2;
464 
465  CMAcoverage PhiCov = (logic_sector % 2) ? OddSectors : EvenSectors;
466 
467  const RPC_CondCabling::SectorLogicSetup& s = m_SectorType[m_SectorMap[logic_sector] - 1];
468 
469  CMAidentity ETA(Eta, AllSectors, PadId, EtaIxx);
470  CMAidentity PHI(Phi, PhiCov, PadId, PhiIxx);
471 
472  if (!s.give_RoI_borders(ETA, PHI, EtaLowBorder, EtaHighBorder, PhiLowBorder, PhiHighBorder)) {
473  MsgStream log(Athena::getMessageSvc(), "RpcCablingCondData");
474  if (log.level() <= MSG::WARNING)
475  log << MSG::WARNING
476  << "give_RoI_borders() - failed to call give_RoI_borders() on SectorLogicSetup, borders not set, return false..." << endmsg;
477  return false;
478  }
479 
480  EtaLowBorder += logic_sector * 1000000;
481  EtaHighBorder += logic_sector * 1000000;
482  PhiLowBorder += logic_sector * 1000000;
483  PhiHighBorder += logic_sector * 1000000;
484 
485  return true;
486 }

◆ give_RoI_borders_id()

bool RpcCablingCondData::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 at line 438 of file RpcCablingCondData.cxx.

440  {
441  unsigned int EtaLowBorder = 0;
442  unsigned int EtaHighBorder = 0;
443  unsigned int PhiLowBorder = 0;
444  unsigned int PhiHighBorder = 0;
445  bool ok = give_RoI_borders(SubsystemId, SectorId, RoIId, EtaLowBorder, EtaHighBorder, PhiLowBorder, PhiHighBorder);
446  // give_RoI_borders() already complains if the return code is false
447  if (ok) {
448  EtaLowBorder_id = protected_strip_OffId_fromCode(EtaLowBorder, rpcId);
449  EtaHighBorder_id = protected_strip_OffId_fromCode(EtaHighBorder, rpcId);
450  PhiLowBorder_id = protected_strip_OffId_fromCode(PhiLowBorder, rpcId);
451  PhiHighBorder_id = protected_strip_OffId_fromCode(PhiHighBorder, rpcId);
452  }
453  return ok;
454 }

◆ give_RXid() [1/2]

bool RpcCablingCondData::give_RXid ( const Identifier &  compactID,
unsigned short int &  id 
) const

Definition at line 76 of file RpcCablingCondData.cxx.

76  {
77  OfflineOnlineMap::const_iterator it = m_RDOmap.find(compactID);
78  if (it == m_RDOmap.end()) return false;
79  const RDOindex* index = (*m_RDOmap.find(compactID)).second;
80  if (!index) return false;
81  id = index->RXid();
82  return true;
83 }

◆ give_RXid() [2/2]

bool RpcCablingCondData::give_RXid ( const unsigned int  hashID,
unsigned short int &  id 
) const

Definition at line 84 of file RpcCablingCondData.cxx.

84  {
85  if (hashID >= m_HashVec.size()) return false;
86  const RDOindex* index = m_HashVec[hashID];
87  if (!index) return false;
88  id = index->RXid();
89  return true;
90 }

◆ give_side() [1/2]

bool RpcCablingCondData::give_side ( const Identifier &  compactID,
unsigned short int &  id 
) const

Definition at line 44 of file RpcCablingCondData.cxx.

44  {
45  OfflineOnlineMap::const_iterator it = m_RDOmap.find(compactID);
46  if (it == m_RDOmap.end()) return false;
47  const RDOindex* index = (*m_RDOmap.find(compactID)).second;
48  if (!index) return false;
49  id = index->side();
50  return true;
51 }

◆ give_side() [2/2]

bool RpcCablingCondData::give_side ( const unsigned int  hashID,
unsigned short int &  id 
) const

Definition at line 52 of file RpcCablingCondData.cxx.

52  {
53  if (hashID >= m_HashVec.size()) return false;
54  const RDOindex* index = m_HashVec[hashID];
55  if (!index) return false;
56  id = index->side();
57  return true;
58 }

◆ give_SLid() [1/2]

bool RpcCablingCondData::give_SLid ( const Identifier &  compactID,
unsigned short int &  id 
) const

Definition at line 60 of file RpcCablingCondData.cxx.

60  {
61  OfflineOnlineMap::const_iterator it = m_RDOmap.find(compactID);
62  if (it == m_RDOmap.end()) return false;
63  const RDOindex* index = (*m_RDOmap.find(compactID)).second;
64  if (!index) return false;
65  id = index->SLid();
66  return true;
67 }

◆ give_SLid() [2/2]

bool RpcCablingCondData::give_SLid ( const unsigned int  hashID,
unsigned short int &  id 
) const

Definition at line 68 of file RpcCablingCondData.cxx.

68  {
69  if (hashID >= m_HashVec.size()) return false;
70  const RDOindex* index = m_HashVec[hashID];
71  if (!index) return false;
72  id = index->SLid();
73  return true;
74 }

◆ give_strip_id()

std::list< Identifier > RpcCablingCondData::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 at line 269 of file RpcCablingCondData.cxx.

271  {
272  std::list<unsigned int> CodeList;
273 
274  int logic_sector = SectorId + SubsystemId * 32;
275  unsigned short int Ixx = CMAId & 1;
276  unsigned short int ep = (CMAId >> 1) & 1;
277  unsigned short int lh = (CMAId >> 2) & 1;
278 
279  ep = (ep == 1) ? 0 : 1;
280 
281  // retrieve the Sector Logic setup
282  const RPC_CondCabling::SectorLogicSetup& s = m_SectorType[m_SectorMap[logic_sector] - 1];
283 
284  // retrieve the CMAparameters associated to the identifiers
285  if (ep) {
286  CMAcoverage PhiCov = (logic_sector % 2) ? OddSectors : EvenSectors;
287  CMAidentity PHI(Phi, PhiCov, PADId, Ixx);
288  CodeList = s.give_strip_code(PHI, logic_sector, lh, ijk, Channel);
289  } else {
290  CMAidentity ETA(Eta, AllSectors, PADId, Ixx);
291  CodeList = s.give_strip_code(ETA, logic_sector, lh, ijk, Channel);
292  }
293 
294  std::list<RPCofflineId> offlineIdList;
295  std::list<unsigned int>::const_iterator it = CodeList.begin();
296  while (it != CodeList.end()) {
297  RPCdecoder decode(*it);
298  RPCofflineId rpcId;
299 
300  int RPC_strip = decode.strip_number();
301  int RPC_chamber = decode.rpc_z_index();
302  int RPC_layer = decode.rpc_layer();
303  int RPC_station = decode.lvl1_station();
304  int sector = (decode.logic_sector()) % 32;
305 
306  const RPC_CondCabling::RPCchamber* rpc = s.find_chamber(RPC_station, RPC_chamber);
307 
308  rpcId.stationName = rpc->stationName();
309  rpcId.stationEta = (decode.half_barrel() == Positive) ? rpc->stationEta() : -rpc->stationEta();
310  rpcId.stationPhi = (sector == 31) ? 1 : (sector + 1) / 4 + 1;
311  rpcId.doubletR = rpc->doubletR();
312  rpcId.doubletZ = rpc->doubletZ();
313  rpcId.doubletPhi = (rpc->phiReadoutPannels() == 2) ? (sector + 1) % 2 + 1 : 1;
314  rpcId.gasGap = RPC_layer + 1;
315  rpcId.measuresPhi = static_cast<int>(decode.view());
316  rpcId.strip = RPC_strip + 1;
317 
318  offlineIdList.push_back(rpcId);
319 
320  ++it;
321  }
322 
323  std::list<Identifier> ids;
324  std::list<RPCofflineId>::const_iterator iterator = offlineIdList.begin();
325  while (iterator != offlineIdList.end()) {
326  Identifier id =
327  rpcId->channelID((*iterator).stationName, (*iterator).stationEta, (*iterator).stationPhi, (*iterator).doubletR,
328  (*iterator).doubletZ, (*iterator).doubletPhi, (*iterator).gasGap, (*iterator).measuresPhi, (*iterator).strip);
329  ids.push_back(id);
330  ++iterator;
331  }
332 
333  return ids;
334 }

◆ giveFullListOfRobIds()

const std::vector< uint32_t > & RpcCablingCondData::giveFullListOfRobIds ( ) const

Definition at line 108 of file RpcCablingCondData.cxx.

108 { return m_fullListOfRobIds; }

◆ giveOfflineId()

bool RpcCablingCondData::giveOfflineId ( const unsigned short int  side,
const unsigned short int  sector,
const unsigned short int  padId,
Identifier &  id 
) const

Definition at line 657 of file RpcCablingCondData.cxx.

658  {
659  if (side >= 2) return false;
660  if (sector >= 32) return false;
661  if (padId >= 10) return false;
662  id = m_offline_id[side][sector][padId];
663  return id.is_valid();
664 }

◆ giveRDO_fromPRD() [1/2]

StatusCode RpcCablingCondData::giveRDO_fromPRD ( const IdentifierHash  prdHashId,
std::vector< IdentifierHash > &  rdoHashVec 
) const

Definition at line 336 of file RpcCablingCondData.cxx.

336  {
337  StatusCode sc = StatusCode::SUCCESS;
338 
339  rdoHashVec.clear();
340 
341  PRD_RDO_Map::const_iterator it = m_PRD_RDO_map.find(prdHashId);
342 
343  if (it == m_PRD_RDO_map.cend()) return sc;
344 
345  for (IdentifierHash rdoId : (*it).second) rdoHashVec.push_back(rdoId);
346 
347  return sc;
348 }

◆ giveRDO_fromPRD() [2/2]

StatusCode RpcCablingCondData::giveRDO_fromPRD ( const std::vector< IdentifierHash > &  prdHashVec,
std::vector< IdentifierHash > &  rdoHashVec 
) const

Definition at line 350 of file RpcCablingCondData.cxx.

351  {
352  StatusCode sc = StatusCode::SUCCESS;
353 
354  rdoHashVec.clear();
355  std::set<IdentifierHash> requestedRdoHashSet;
356 
357  for (IdentifierHash prdHashId : prdHashVec) {
358  // find the requested PRD HashId in the map
359  PRD_RDO_Map::const_iterator it = m_PRD_RDO_map.find(prdHashId);
360  if (it == m_PRD_RDO_map.cend()) { continue; }
361  // if the PRD was found in the map, add the corresponding set of RDO HashIds to the set of requested RDO HashIds
362  requestedRdoHashSet.insert((*it).second.begin(), (*it).second.end());
363  }
364 
365  // convert set to vector
366  for (IdentifierHash rdoHashId : requestedRdoHashSet) { rdoHashVec.push_back(rdoHashId); }
367 
368  return sc;
369 }

◆ giveRDO_fromROB()

StatusCode RpcCablingCondData::giveRDO_fromROB ( const std::vector< uint32_t > &  robIdVec,
std::vector< IdentifierHash > &  rdoHashVec 
) const

Definition at line 371 of file RpcCablingCondData.cxx.

371  {
372  StatusCode sc = StatusCode::SUCCESS;
373 
374  rdoHashVec.clear();
375  std::set<IdentifierHash> requestedRdoHashSet;
376 
377  for (uint32_t robId : robIdVec) {
378  // find the requested ROB Id in the map
379  ROB_RDO_Map::const_iterator it = m_ROB_RDO_map.find(robId);
380  if (it == m_ROB_RDO_map.cend()) { continue; }
381  // if the ROB Id was found in the map, add the corresponding set of RDO HashIds to the set of requested RDO HashIds
382  requestedRdoHashSet.insert((*it).second.begin(), (*it).second.end());
383  }
384 
385  // convert set to vector
386  for (IdentifierHash rdoHashId : requestedRdoHashSet) { rdoHashVec.push_back(rdoHashId); }
387 
388  return sc;
389 }

◆ giveROB_fromPRD()

StatusCode RpcCablingCondData::giveROB_fromPRD ( const IdentifierHash  prdHashId,
std::vector< uint32_t > &  robIdVec 
) const

Definition at line 391 of file RpcCablingCondData.cxx.

391  {
392  StatusCode sc = StatusCode::SUCCESS;
393 
394  robIdVec.clear();
395 
396  PRD_ROB_Map::const_iterator it = m_PRD_ROB_map.find(prdHashId);
397 
398  if (it == m_PRD_ROB_map.cend()) return sc;
399 
400  for (uint32_t robId : (*it).second) robIdVec.push_back(robId);
401 
402  return sc;
403 }

◆ giveROB_fromRDO() [1/2]

StatusCode RpcCablingCondData::giveROB_fromRDO ( const IdentifierHash  rdoHashId,
uint32_t &  robId 
) const

Definition at line 146 of file RpcCablingCondData.cxx.

146  {
147  StatusCode sc = StatusCode::SUCCESS;
148  unsigned int hash = (unsigned int)rdoHashId;
149 
150  if (hash >= m_HashVec.size()) { return StatusCode::FAILURE; }
151 
152  unsigned short int rob_id = m_HashVec[hash]->ROBid();
153  unsigned short int side = m_HashVec[hash]->side();
154 
155  robId = (side << 16) | rob_id;
156 
157  return sc;
158 }

◆ giveROB_fromRDO() [2/2]

StatusCode RpcCablingCondData::giveROB_fromRDO ( const std::vector< IdentifierHash > &  rdoHashVec,
std::vector< uint32_t > &  robIdVec 
) const

Definition at line 160 of file RpcCablingCondData.cxx.

160  {
161  StatusCode sc = StatusCode::SUCCESS;
162 
163  robIdVec.clear();
164 
165  for (IdentifierHash rdoHashId : rdoHashVec) {
166  uint32_t robid = 0xffffffff;
167  if (!giveROB_fromRDO(rdoHashId, robid)) sc = StatusCode::FAILURE;
168  robIdVec.push_back(robid);
169  }
170 
171  // sort and remove duplicates
172  std::sort(robIdVec.begin(), robIdVec.end());
173  robIdVec.erase(unique(robIdVec.begin(), robIdVec.end()), robIdVec.end());
174 
175  return sc;
176 }

◆ hash2source()

uint32_t RpcCablingCondData::hash2source ( unsigned int  h) const

Definition at line 135 of file RpcCablingCondData.cxx.

135  {
136  unsigned short int side;
137  unsigned short int RODid;
138  if (give_side(h, side) && give_RODid(h, RODid)) {
139  uint32_t sub = side;
140  uint32_t rod = RODid;
141  return (sub << 16) | rod;
142  }
143  return 0;
144 }

◆ identifier()

Identifier RpcCablingCondData::identifier ( int  i) const

Definition at line 110 of file RpcCablingCondData.cxx.

110  {
111  int size = m_int2id.size();
112  if (index >= 0 && index < size) { return m_int2id[index]; }
113 
114  Identifier id;
115  return id;
116 }

◆ largeSector()

bool RpcCablingCondData::largeSector ( const std::string &  stName)
static

Definition at line 228 of file RpcCablingCondData.cxx.

228  {
229  bool ls = false;
230  if (stName == "BML" || // 2
231  stName == "BOL" || // 4
232  stName == "BME" || // 53
233  stName == "BIR" // 52
234  )
235  ls = true;
236  return ls;
237 }

◆ max()

int RpcCablingCondData::max ( ) const

Definition at line 126 of file RpcCablingCondData.cxx.

126 { return m_int2id.size(); }

◆ offset()

int RpcCablingCondData::offset ( )
static

Definition at line 128 of file RpcCablingCondData.cxx.

128 { return 0; }

◆ operator()()

int RpcCablingCondData::operator() ( const Identifier &  id) const

Definition at line 118 of file RpcCablingCondData.cxx.

118  {
119  std::map<Identifier, int>::const_iterator it = m_lookup.find(id);
120  if (it != m_lookup.end()) { return (*it).second; }
121 
122  // FIXME -1 for invalid ID?
123  return -1;
124 }

◆ protected_strip_OffId_fromCode()

Identifier RpcCablingCondData::protected_strip_OffId_fromCode ( unsigned long int  strip_code,
const RpcIdHelper *  rpcId 
) const

Definition at line 488 of file RpcCablingCondData.cxx.

488  {
489  RPCofflineId rpc_strip = strip_id_fromCode(strip_code);
490  if (rpc_strip.stationName == "BOG") {
491  if (std::abs(rpc_strip.stationEta) == 4 && rpc_strip.doubletR == 2 && rpc_strip.measuresPhi == 1) {
492  if (rpc_strip.strip > 48) rpc_strip.strip = 48;
493  }
494  }
495  if (rpc_strip.stationName == "BME") {
496  if (rpc_strip.doubletR == 2 && rpc_strip.measuresPhi == 1) {
497  if (rpc_strip.strip > 36) rpc_strip.strip = 36;
498  }
499  }
500  return rpcId->channelID(rpc_strip.stationName, rpc_strip.stationEta, rpc_strip.stationPhi, rpc_strip.doubletR, rpc_strip.doubletZ,
501  rpc_strip.doubletPhi, rpc_strip.gasGap, rpc_strip.measuresPhi, rpc_strip.strip);
502 }

◆ rod2hash()

std::vector< IdentifierHash > RpcCablingCondData::rod2hash ( uint16_t  subsystem,
uint16_t  rod 
) const

Definition at line 130 of file RpcCablingCondData.cxx.

130  {
131  if ((subsystem_id != 0x66 && subsystem_id != 0x65) || (rod_id >= 16)) return std::vector<IdentifierHash>();
132  return m_rod2hash[(subsystem_id == 0x66) ? 0 : 1][rod_id];
133 }

◆ setIds()

void RpcCablingCondData::setIds ( const std::vector< Identifier > &  int2id)

Definition at line 666 of file RpcCablingCondData.cxx.

666 { m_int2id = int2id; }

◆ setLookup()

void RpcCablingCondData::setLookup ( const std::vector< Identifier > &  ids)

Definition at line 668 of file RpcCablingCondData.cxx.

668  {
669  for (size_t i = 0; i < ids.size(); i++) { m_lookup.emplace(ids[i], i); }
670 }

◆ strip_code_fromOffId()

unsigned long int RpcCablingCondData::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 at line 185 of file RpcCablingCondData.cxx.

186  {
187  unsigned long int code = 0;
188 
189  unsigned long int etaPhiView = 2;
190  unsigned long int phi1_16 = 2. * stationPhi;
191  if (largeSector(stationName)) phi1_16 = phi1_16 - 1;
192  int logicSector = (phi1_16 - 1) * 2 + doubletPhi - 2;
193  if (logicSector < 0) logicSector = 31;
194  if (measuresPhi > 0) etaPhiView = 1;
195  if (stationEta >= 0) logicSector += 32;
196 
197  unsigned long int cabStat = doubletR;
198  if (stationName.substr(0, 2) == "BO") {
199  cabStat = 2 + cabStat;
200  if (cabStat > 3) cabStat = 2; // special case of BOF and BOG with dbr=2
201  } else if (stationName.substr(0, 3) == "BML") {
202  if (abs(stationEta) == 7 || (abs(stationEta) == 6 && stationPhi == 7)) {
203  cabStat = 2; // special case of single RPC Chambers at the same R or dbr2
204  }
205  }
206  if (stationName.substr(0,3)=="BIS" && logicSector>31) logicSector+=1; // BIS78 are in doubPhi==1
207 
208  if (logicSector < 0 || logicSector > 63) { return 999999; }
209 
210  int zIndexInCablingStation = computeZIndexInCablingStation(stationName, logicSector, stationEta, doubletR, doubletZ, cabStat);
211  if (zIndexInCablingStation > 99) return 0;
212  int cablingStation = cabStat;
213 
214  unsigned long int gg = gasGap - 1;
215  code = strip_code_fromOffline(etaPhiView, logicSector, cablingStation, gg, zIndexInCablingStation, strip);
216 
217  return code;
218 }

◆ strip_code_fromOffline()

unsigned long int RpcCablingCondData::strip_code_fromOffline ( int  etaPhiView,
int  logicSector,
int  cablingStation,
int  gasGap,
int  zIndexInCablingStation,
int  strip 
)
static

Definition at line 220 of file RpcCablingCondData.cxx.

221  {
222  unsigned long int code = 0;
223  code = etaPhiView * 100000000 + logicSector * 1000000 + cablingStation * 100000 + gasGap * 10000 + zIndexInCablingStation * 100 +
224  (strip - 1);
225  return code;
226 }

◆ strip_id_fromCode()

RPCofflineId RpcCablingCondData::strip_id_fromCode ( unsigned long int  strip_code) const

Definition at line 504 of file RpcCablingCondData.cxx.

504  {
505  RPCdecoder decode(strip_code);
506  RPCofflineId rpcId;
507  rpcId.init();
508  if (!decode) { return rpcId; }
509  int RPC_logic_sector = decode.logic_sector();
510  int RPC_strip = decode.strip_number();
511  int RPC_chamber = decode.rpc_z_index();
512  int RPC_layer = decode.rpc_layer();
513  int RPC_station = decode.lvl1_station();
514  int sector = (decode.logic_sector()) % 32;
515 
516  // retrieve the Sector Logic setup
517  const RPC_CondCabling::SectorLogicSetup& s = m_SectorType[m_SectorMap[RPC_logic_sector] - 1];
518  // retrieve chamber
519  const RPC_CondCabling::RPCchamber* rpc = s.find_chamber(RPC_station, RPC_chamber);
520 
521  rpcId.stationName = rpc->stationName();
522  rpcId.stationEta = (decode.half_barrel() == Positive) ? rpc->stationEta() : -rpc->stationEta();
523  rpcId.stationPhi = (sector == 31) ? 1 : (sector + 1) / 4 + 1;
524  rpcId.doubletR = rpc->doubletR();
525  rpcId.doubletZ = rpc->doubletZ();
526  rpcId.doubletPhi = (rpc->phiReadoutPannels() == 2) ? (sector + 1) % 2 + 1 : 1;
527  rpcId.gasGap = RPC_layer + 1;
528  rpcId.measuresPhi = static_cast<int>(decode.view());
529  rpcId.strip = RPC_strip + 1;
530 
531  return rpcId;
532 }

◆ strip_OffId_fromCode()

Identifier RpcCablingCondData::strip_OffId_fromCode ( unsigned long int  strip_code,
const RpcIdHelper *  rpcId 
) const

Definition at line 651 of file RpcCablingCondData.cxx.

651  {
652  RPCofflineId rpc_strip = strip_id_fromCode(strip_code);
653  return rpcId->channelID(rpc_strip.stationName, rpc_strip.stationEta, rpc_strip.stationPhi, rpc_strip.doubletR, rpc_strip.doubletZ,
654  rpc_strip.doubletPhi, rpc_strip.gasGap, rpc_strip.measuresPhi, rpc_strip.strip);
655 }

Friends And Related Function Documentation

◆ RpcCablingCondAlg

friend class RpcCablingCondAlg
friend

Definition at line 22 of file RpcCablingCondData.h.

Member Data Documentation

◆ m_corr

std::string RpcCablingCondData::m_corr
private

Definition at line 137 of file RpcCablingCondData.h.

◆ m_fullListOfRobIds

std::vector<uint32_t> RpcCablingCondData::m_fullListOfRobIds
private

Definition at line 155 of file RpcCablingCondData.h.

◆ m_HashVec

OfflineOnlineHashMap RpcCablingCondData::m_HashVec
private

Definition at line 134 of file RpcCablingCondData.h.

◆ m_int2id

std::vector<Identifier> RpcCablingCondData::m_int2id
private

Definition at line 151 of file RpcCablingCondData.h.

◆ m_lookup

std::map<Identifier, int> RpcCablingCondData::m_lookup
private

Definition at line 153 of file RpcCablingCondData.h.

◆ m_map

std::string RpcCablingCondData::m_map
private

Definition at line 136 of file RpcCablingCondData.h.

◆ m_MaxType

int RpcCablingCondData::m_MaxType =-999999
private

Definition at line 163 of file RpcCablingCondData.h.

◆ m_offline_id

Identifier RpcCablingCondData::m_offline_id[2][32][10]
private

Definition at line 171 of file RpcCablingCondData.h.

◆ m_PRD_RDO_map

PRD_RDO_Map RpcCablingCondData::m_PRD_RDO_map
private

Definition at line 159 of file RpcCablingCondData.h.

◆ m_PRD_ROB_map

PRD_ROB_Map RpcCablingCondData::m_PRD_ROB_map
private

Definition at line 160 of file RpcCablingCondData.h.

◆ m_RDOmap

OfflineOnlineMap RpcCablingCondData::m_RDOmap
private

Definition at line 133 of file RpcCablingCondData.h.

◆ m_RDOs

RDOmap RpcCablingCondData::m_RDOs
private

Definition at line 132 of file RpcCablingCondData.h.

◆ m_ROB_RDO_map

ROB_RDO_Map RpcCablingCondData::m_ROB_RDO_map
private

Definition at line 161 of file RpcCablingCondData.h.

◆ m_rod2hash

std::vector<IdentifierHash> RpcCablingCondData::m_rod2hash[2][16]
private

Definition at line 152 of file RpcCablingCondData.h.

◆ m_RPCPadParameters_array

RPCPadParameters RpcCablingCondData::m_RPCPadParameters_array[MAX_LOGICSECTOR][MAX_PADID]
private

Definition at line 169 of file RpcCablingCondData.h.

◆ m_SectorMap

int RpcCablingCondData::m_SectorMap[64] {}
private

Definition at line 156 of file RpcCablingCondData.h.

◆ m_SectorType

STvec RpcCablingCondData::m_SectorType
private

Definition at line 158 of file RpcCablingCondData.h.

◆ m_trigroads

std::map<std::string, std::string> RpcCablingCondData::m_trigroads
private

Definition at line 144 of file RpcCablingCondData.h.

◆ m_vecetaCM_File

std::vector<std::string> RpcCablingCondData::m_vecetaCM_File
private

Definition at line 139 of file RpcCablingCondData.h.

◆ m_vecetaInfo

std::vector<std::string> RpcCablingCondData::m_vecetaInfo
private

Definition at line 142 of file RpcCablingCondData.h.

◆ m_vecetaSequence_Th

std::vector<std::string> RpcCablingCondData::m_vecetaSequence_Th
private

Definition at line 141 of file RpcCablingCondData.h.

◆ m_vecetaTh0

std::vector<std::string> RpcCablingCondData::m_vecetaTh0
private

Definition at line 140 of file RpcCablingCondData.h.

◆ m_vecphiCM_File

std::vector<std::string> RpcCablingCondData::m_vecphiCM_File
private

Definition at line 146 of file RpcCablingCondData.h.

◆ m_vecphiInfo

std::vector<std::string> RpcCablingCondData::m_vecphiInfo
private

Definition at line 148 of file RpcCablingCondData.h.

◆ m_vecphiTh0

std::vector<std::string> RpcCablingCondData::m_vecphiTh0
private

Definition at line 147 of file RpcCablingCondData.h.

◆ MAX_LOGICSECTOR

constexpr unsigned RpcCablingCondData::MAX_LOGICSECTOR = 64
staticconstexprprivate

Definition at line 168 of file RpcCablingCondData.h.

◆ MAX_PADID

constexpr unsigned RpcCablingCondData::MAX_PADID = 10
staticconstexprprivate

Definition at line 167 of file RpcCablingCondData.h.

The documentation for this class was generated from the following files:
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:534
RPCdecoder
Definition: RPCdecoder.h:13
AtlasMcWeight::decode
double decode(number_type binnedWeight)
Convert weight from unsigned to double.
Definition: AtlasMcWeight.cxx:32
python.SystemOfUnits.second
int second
Definition: SystemOfUnits.py:120
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
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
get_generator_info.result
result
Definition: get_generator_info.py:21
SiliconTech::strip
@ strip
RPCofflineId::doubletR
int doubletR
Definition: RPCofflineId.h:12
LArBadChanBlobUtils::Channel
Identifier32::value_type Channel
Definition: LArBadChanBlobUtils.h:24
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:28
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:169
CMAcoverage
CMAcoverage
Definition: CMAidentity.h:14
skel.it
it
Definition: skel.GENtoEVGEN.py:407
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:592
createCablingJSON.doubletR
int doubletR
Definition: createCablingJSON.py:15
RpcCablingCondData::m_HashVec
OfflineOnlineHashMap m_HashVec
Definition: RpcCablingCondData.h:134
RpcCablingCondData::m_fullListOfRobIds
std::vector< uint32_t > m_fullListOfRobIds
Definition: RpcCablingCondData.h:155
CMAparameters::CMAlist
std::list< const CMAparameters * > CMAlist
Definition: CMAparameters.h:24
Phi
@ Phi
Definition: RPCdef.h:8
RpcCablingCondData::m_RDOs
RDOmap m_RDOs
Definition: RpcCablingCondData.h:132
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:931
RpcCablingCondData::m_rod2hash
std::vector< IdentifierHash > m_rod2hash[2][16]
Definition: RpcCablingCondData.h:152
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:220
Identifier::is_valid
bool is_valid() const
Check if id is in a valid state.
Athena::getMessageSvc
IMessageSvc * getMessageSvc(bool quiet=false)
Definition: getMessageSvc.cxx:20
RpcCablingCondData::strip_OffId_fromCode
Identifier strip_OffId_fromCode(unsigned long int strip_code, const RpcIdHelper *rpcId) const
Definition: RpcCablingCondData.cxx:651
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
RpcCablingCondData::strip_id_fromCode
RPCofflineId strip_id_fromCode(unsigned long int strip_code) const
Definition: RpcCablingCondData.cxx:504
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
histSizes.code
code
Definition: histSizes.py:129
RpcCablingCondData::m_lookup
std::map< Identifier, int > m_lookup
Definition: RpcCablingCondData.h:153
RpcCablingCondData::m_ROB_RDO_map
ROB_RDO_Map m_ROB_RDO_map
Definition: RpcCablingCondData.h:161
RpcCablingCondData::give_side
bool give_side(const Identifier &compactID, unsigned short int &id) const
Definition: RpcCablingCondData.cxx:44
RpcCablingCondData::m_offline_id
Identifier m_offline_id[2][32][10]
Definition: RpcCablingCondData.h:171
RpcCablingCondData::m_SectorMap
int m_SectorMap[64]
Definition: RpcCablingCondData.h:156
RPCofflineId::stationPhi
int stationPhi
Definition: RPCofflineId.h:11
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
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
python.LArMinBiasAlgConfig.int
int
Definition: LArMinBiasAlgConfig.py:59
RPCofflineId::strip
int strip
Definition: RPCofflineId.h:17
RpcCablingCondData::MAX_LOGICSECTOR
static constexpr unsigned MAX_LOGICSECTOR
Definition: RpcCablingCondData.h:168
AllSectors
@ AllSectors
Definition: CMAidentity.h:14
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:160
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::giveROB_fromRDO
StatusCode giveROB_fromRDO(const IdentifierHash rdoHashId, uint32_t &robId) const
Definition: RpcCablingCondData.cxx:146
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:456
RoiUtil::ETA
@ ETA
Definition: RoiSerialise.cxx:30
RpcCablingCondData::largeSector
static bool largeSector(const std::string &stName)
Definition: RpcCablingCondData.cxx:228
RPC_CondCabling::RPCchamber::stationName
std::string stationName() const
Definition: RPCchamber.cxx:34
RpcCablingCondData::m_MaxType
int m_MaxType
Definition: RpcCablingCondData.h:163
RPCofflineId::doubletZ
int doubletZ
Definition: RPCofflineId.h:13
DeMoScan.index
string index
Definition: DeMoScan.py:364
std::unique
DataModel_detail::iterator< DVL > unique(typename DataModel_detail::iterator< DVL > beg, typename DataModel_detail::iterator< DVL > end)
Specialization of unique for DataVector/List.
Definition: DVL_algorithms.h:135
RpcCablingCondData::computeZIndexInCablingStation
unsigned int computeZIndexInCablingStation(const std::string &stationName, int logicSector, int stationEta, int doubletR, int doubletZ, int cabStat) const
Definition: RpcCablingCondData.cxx:239
CMAidentity
Definition: CMAidentity.h:16
RpcCablingCondData::m_RDOmap
OfflineOnlineMap m_RDOmap
Definition: RpcCablingCondData.h:133
h
CaloCondBlobAlgs_fillNoiseFromASCII.hash
dictionary hash
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:109
RPCPadParameters::cma_mask
unsigned short int cma_mask(void) const
Definition: RPCPadParameters.h:35
std::sort
void sort(typename std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, typename std::reverse_iterator< DataModel_detail::iterator< DVL > > end, const Compare &comp)
Specialization of sort for DataVector/List.
Definition: DVL_algorithms.h:623
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
RpcCablingCondData::MAX_PADID
static constexpr unsigned MAX_PADID
Definition: RpcCablingCondData.h:167
createCablingJSON.doubletPhi
int doubletPhi
Definition: createCablingJSON.py:16
python.DiskUtils.ls
def ls(path, longls=False)
Definition: DiskUtils.py:112
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:488
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:158
RpcCablingCondData::m_int2id
std::vector< Identifier > m_int2id
Definition: RpcCablingCondData.h:151
RPC_CondCabling::RPCchamber::chamber_name
const std::string & chamber_name() const
Definition: RPCchamber.cxx:33
RpcCablingCondData::m_PRD_RDO_map
PRD_RDO_Map m_PRD_RDO_map
Definition: RpcCablingCondData.h:159
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
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
RDOindex
Definition: RDOindex.h:85
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Sun Apr 20 2025 21:43:07 for ATLAS Offline Software by   doxygen 1.8.18