ATLAS Offline Software
Loading...
Searching...
No Matches
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>

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 23 of file RpcCablingCondData.h.

Member Typedef Documentation

◆ OfflineOnlineHashMap

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

Definition at line 28 of file RpcCablingCondData.h.

◆ OfflineOnlineMap

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

Definition at line 29 of file RpcCablingCondData.h.

◆ PRD_RDO_Map

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

Definition at line 31 of file RpcCablingCondData.h.

◆ PRD_ROB_Map

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

Definition at line 32 of file RpcCablingCondData.h.

◆ RDOmap

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

Definition at line 27 of file RpcCablingCondData.h.

◆ ROB_RDO_Map

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

Definition at line 33 of file RpcCablingCondData.h.

◆ STvec

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

Definition at line 30 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 240 of file RpcCablingCondData.cxx.

241 {
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
266 return zIndexInCablingStation;
267}
RPC_CondCabling::RPCchamber::doubletR
int doubletR() const
Definition RPCchamber.cxx:36
RPC_CondCabling::RPCchamber::stationEta
int stationEta() const
Definition RPCchamber.cxx:35
RPC_CondCabling::RPCchamber::doubletZ
int doubletZ() const
Definition RPCchamber.cxx:37
RPC_CondCabling::RPCchamber::chamber_name
const std::string & chamber_name() const
Definition RPCchamber.cxx:33
RPC_CondCabling::SectorLogicSetup::find_chamber
const RPCchamber * find_chamber(int, int) const
Definition SectorLogicSetup.cxx:133

◆ 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 179 of file RpcCablingCondData.cxx.

180 {
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}
CMAparameters::CMAlist
std::list< const CMAparameters * > CMAlist
Definition CMAparameters.h:25
get_generator_info.result
result
Definition get_generator_info.py:21

◆ 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}
CMAcoverage
CMAcoverage
Definition CMAidentity.h:14
OddSectors
@ OddSectors
Definition CMAidentity.h:14
AllSectors
@ AllSectors
Definition CMAidentity.h:14
EvenSectors
@ EvenSectors
Definition CMAidentity.h:14
Phi
@ Phi
Definition RPCdef.h:8
Eta
@ Eta
Definition RPCdef.h:8

◆ 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}
RpcCablingCondData::strip_OffId_fromCode
Identifier strip_OffId_fromCode(unsigned long int strip_code, const RpcIdHelper *rpcId) const
Definition RpcCablingCondData.cxx:651
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

◆ 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}
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

◆ 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}
DeMoScan.index
str index
Definition DeMoScan.py:362

◆ 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}
RpcCablingCondData::MAX_LOGICSECTOR
static constexpr unsigned MAX_LOGICSECTOR
Definition RpcCablingCondData.h:170
RpcCablingCondData::MAX_PADID
static constexpr unsigned MAX_PADID
Definition RpcCablingCondData.h:169
RpcCablingCondData::m_RPCPadParameters_array
RPCPadParameters m_RPCPadParameters_array[MAX_LOGICSECTOR][MAX_PADID]
Definition RpcCablingCondData.h:171

◆ give_PADid() [1/2]

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

Definition at line 93 of file RpcCablingCondData.cxx.

93 {
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}
RpcCablingCondData::m_RDOmap
OfflineOnlineMap m_RDOmap
Definition RpcCablingCondData.h:135

◆ give_PADid() [2/2]

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

Definition at line 101 of file RpcCablingCondData.cxx.

101 {
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}
RpcCablingCondData::m_HashVec
OfflineOnlineHashMap m_HashVec
Definition RpcCablingCondData.h:136

◆ give_RDOs()

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

Definition at line 11 of file RpcCablingCondData.cxx.

11{ return m_RDOs; }

◆ give_ROBid() [1/2]

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

Definition at line 13 of file RpcCablingCondData.cxx.

13 {
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}

◆ give_ROBid() [2/2]

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

Definition at line 21 of file RpcCablingCondData.cxx.

21 {
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}

◆ give_RODid() [1/2]

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

Definition at line 29 of file RpcCablingCondData.cxx.

29 {
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}

◆ give_RODid() [2/2]

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

Definition at line 37 of file RpcCablingCondData.cxx.

37 {
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}

◆ 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}
endmsg
#define endmsg
Definition AnalysisConfig_Ntuple.cxx:63
Athena::getMessageSvc
IMessageSvc * getMessageSvc(bool quiet=false)
Definition getMessageSvc.cxx:20

◆ 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}
RpcCablingCondData::protected_strip_OffId_fromCode
Identifier protected_strip_OffId_fromCode(unsigned long int strip_code, const RpcIdHelper *rpcId) const
Definition RpcCablingCondData.cxx:488
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

◆ give_RXid() [1/2]

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

Definition at line 77 of file RpcCablingCondData.cxx.

77 {
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}

◆ give_RXid() [2/2]

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

Definition at line 85 of file RpcCablingCondData.cxx.

85 {
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}

◆ give_side() [1/2]

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

Definition at line 45 of file RpcCablingCondData.cxx.

45 {
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}

◆ give_side() [2/2]

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

Definition at line 53 of file RpcCablingCondData.cxx.

53 {
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}

◆ give_SLid() [1/2]

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

Definition at line 61 of file RpcCablingCondData.cxx.

61 {
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}

◆ give_SLid() [2/2]

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

Definition at line 69 of file RpcCablingCondData.cxx.

69 {
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}

◆ 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 thisRpcId;
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 thisRpcId.stationName = rpc->stationName();
309 thisRpcId.stationEta = (decode.half_barrel() == Positive) ? rpc->stationEta() : -rpc->stationEta();
310 thisRpcId.stationPhi = (sector == 31) ? 1 : (sector + 1) / 4 + 1;
311 thisRpcId.doubletR = rpc->doubletR();
312 thisRpcId.doubletZ = rpc->doubletZ();
313 thisRpcId.doubletPhi = (rpc->phiReadoutPannels() == 2) ? (sector + 1) % 2 + 1 : 1;
314 thisRpcId.gasGap = RPC_layer + 1;
315 thisRpcId.measuresPhi = static_cast<int>(decode.view());
316 thisRpcId.strip = RPC_strip + 1;
317
318 offlineIdList.push_back(std::move(thisRpcId));
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}
Positive
@ Positive
Definition RPCdef.h:9
RPC_CondCabling::RPCchamber::stationName
std::string stationName() const
Definition RPCchamber.cxx:34
RPC_CondCabling::RPCchamber::phiReadoutPannels
int phiReadoutPannels() const
Definition RPCchamber.cxx:38
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:938
AtlasMcWeight::decode
double decode(number_type binnedWeight)
Convert weight from unsigned to double.
Definition AtlasMcWeight.cxx:32
xAOD::iterator
JetConstituentVector::iterator iterator
Definition JetConstituentVector.cxx:68
RPCofflineId::stationName
std::string stationName
Definition RPCofflineId.h:9

◆ giveFullListOfRobIds()

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

Definition at line 109 of file RpcCablingCondData.cxx.

109{ return m_fullListOfRobIds; }
RpcCablingCondData::m_fullListOfRobIds
std::vector< uint32_t > m_fullListOfRobIds
Definition RpcCablingCondData.h:157

◆ 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}
RpcCablingCondData::m_offline_id
Identifier m_offline_id[2][32][10]
Definition RpcCablingCondData.h:173

◆ 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}
sc
static Double_t sc
Definition LArPhysWaveHECTool.cxx:37
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22

◆ 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 147 of file RpcCablingCondData.cxx.

147 {
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}
CaloCondBlobAlgs_fillNoiseFromASCII.hash
dict hash
Definition CaloCondBlobAlgs_fillNoiseFromASCII.py:108

◆ giveROB_fromRDO() [2/2]

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

Definition at line 161 of file RpcCablingCondData.cxx.

161 {
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}
RpcCablingCondData::giveROB_fromRDO
StatusCode giveROB_fromRDO(const IdentifierHash rdoHashId, uint32_t &robId) const
Definition RpcCablingCondData.cxx:147
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
std::sort
void sort(typename DataModel_detail::iterator< DVL > beg, typename DataModel_detail::iterator< DVL > end)
Specialization of sort for DataVector/List.
Definition DVL_algorithms.h:554
xAOD::uint32_t
setEventNumber uint32_t
Definition EventInfo_v1.cxx:127

◆ hash2source()

uint32_t RpcCablingCondData::hash2source ( unsigned int h) const

Definition at line 136 of file RpcCablingCondData.cxx.

136 {
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}
RpcCablingCondData::give_RODid
bool give_RODid(const Identifier &compactID, unsigned short int &id) const
Definition RpcCablingCondData.cxx:29
RpcCablingCondData::give_side
bool give_side(const Identifier &compactID, unsigned short int &id) const
Definition RpcCablingCondData.cxx:45

◆ identifier()

Identifier RpcCablingCondData::identifier ( int i) const

Definition at line 111 of file RpcCablingCondData.cxx.

111 {
112 int size = m_int2id.size();
113 if (index >= 0 && index < size) { return m_int2id[index]; }
114
115 Identifier id;
116 return id;
117}
RpcCablingCondData::m_int2id
std::vector< Identifier > m_int2id
Definition RpcCablingCondData.h:153
Base_Fragment.id
id
Definition Sherpa_i/share/common/Base_Fragment.py:59

◆ largeSector()

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

Definition at line 229 of file RpcCablingCondData.cxx.

229 {
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}
python.DiskUtils.ls
ls(path, longls=False)
Definition DiskUtils.py:111

◆ max()

int RpcCablingCondData::max ( ) const

Definition at line 127 of file RpcCablingCondData.cxx.

127{ return m_int2id.size(); }

◆ offset()

int RpcCablingCondData::offset ( )
static

Definition at line 129 of file RpcCablingCondData.cxx.

129{ return 0; }

◆ operator()()

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

Definition at line 119 of file RpcCablingCondData.cxx.

119 {
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}
RpcCablingCondData::m_lookup
std::map< Identifier, int > m_lookup
Definition RpcCablingCondData.h:155

◆ 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}
RpcCablingCondData::strip_id_fromCode
RPCofflineId strip_id_fromCode(unsigned long int strip_code) const
Definition RpcCablingCondData.cxx:504

◆ rod2hash()

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

Definition at line 131 of file RpcCablingCondData.cxx.

131 {
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}
RpcCablingCondData::m_rod2hash
std::vector< IdentifierHash > m_rod2hash[2][16]
Definition RpcCablingCondData.h:154

◆ 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 186 of file RpcCablingCondData.cxx.

187 {
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}
RpcCablingCondData::computeZIndexInCablingStation
unsigned int computeZIndexInCablingStation(const std::string &stationName, int logicSector, int stationEta, int doubletR, int doubletZ, int cabStat) const
Definition RpcCablingCondData.cxx:240
RpcCablingCondData::largeSector
static bool largeSector(const std::string &stName)
Definition RpcCablingCondData.cxx:229
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
Muon::nsw::STGTPSegments::moduleIDBits::stationPhi
constexpr uint8_t stationPhi
station Phi 1 to 8
Definition NSWSTGTPDecodeBitmaps.h:161

◆ 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 221 of file RpcCablingCondData.cxx.

222 {
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}

◆ 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}

◆ RpcCablingCondAlg

friend class RpcCablingCondAlg
friend

Definition at line 24 of file RpcCablingCondData.h.

Member Data Documentation

◆ m_corr

std::string RpcCablingCondData::m_corr
private

Definition at line 139 of file RpcCablingCondData.h.

◆ m_fullListOfRobIds

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

Definition at line 157 of file RpcCablingCondData.h.

◆ m_HashVec

OfflineOnlineHashMap RpcCablingCondData::m_HashVec
private

Definition at line 136 of file RpcCablingCondData.h.

◆ m_int2id

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

Definition at line 153 of file RpcCablingCondData.h.

◆ m_lookup

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

Definition at line 155 of file RpcCablingCondData.h.

◆ m_map

std::string RpcCablingCondData::m_map
private

Definition at line 138 of file RpcCablingCondData.h.

◆ m_MaxType

int RpcCablingCondData::m_MaxType =-999999
private

Definition at line 165 of file RpcCablingCondData.h.

◆ m_offline_id

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

Definition at line 173 of file RpcCablingCondData.h.

◆ m_PRD_RDO_map

PRD_RDO_Map RpcCablingCondData::m_PRD_RDO_map
private

Definition at line 161 of file RpcCablingCondData.h.

◆ m_PRD_ROB_map

PRD_ROB_Map RpcCablingCondData::m_PRD_ROB_map
private

Definition at line 162 of file RpcCablingCondData.h.

◆ m_RDOmap

OfflineOnlineMap RpcCablingCondData::m_RDOmap
private

Definition at line 135 of file RpcCablingCondData.h.

◆ m_RDOs

RDOmap RpcCablingCondData::m_RDOs
private

Definition at line 134 of file RpcCablingCondData.h.

◆ m_ROB_RDO_map

ROB_RDO_Map RpcCablingCondData::m_ROB_RDO_map
private

Definition at line 163 of file RpcCablingCondData.h.

◆ m_rod2hash

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

Definition at line 154 of file RpcCablingCondData.h.

◆ m_RPCPadParameters_array

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

Definition at line 171 of file RpcCablingCondData.h.

◆ m_SectorMap

int RpcCablingCondData::m_SectorMap[64] {}
private

Definition at line 158 of file RpcCablingCondData.h.

158{};

◆ m_SectorType

STvec RpcCablingCondData::m_SectorType
private

Definition at line 160 of file RpcCablingCondData.h.

◆ m_trigroads

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

Definition at line 146 of file RpcCablingCondData.h.

◆ m_vecetaCM_File

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

Definition at line 141 of file RpcCablingCondData.h.

◆ m_vecetaInfo

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

Definition at line 144 of file RpcCablingCondData.h.

◆ m_vecetaSequence_Th

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

Definition at line 143 of file RpcCablingCondData.h.

◆ m_vecetaTh0

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

Definition at line 142 of file RpcCablingCondData.h.

◆ m_vecphiCM_File

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

Definition at line 148 of file RpcCablingCondData.h.

◆ m_vecphiInfo

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

Definition at line 150 of file RpcCablingCondData.h.

◆ m_vecphiTh0

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

Definition at line 149 of file RpcCablingCondData.h.

◆ MAX_LOGICSECTOR

unsigned RpcCablingCondData::MAX_LOGICSECTOR = 64
staticconstexprprivate

Definition at line 170 of file RpcCablingCondData.h.

◆ MAX_PADID

unsigned RpcCablingCondData::MAX_PADID = 10
staticconstexprprivate

Definition at line 169 of file RpcCablingCondData.h.

The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.14.0