MuonTGC_Cabling::TGCCabling Class Reference

#include <TGCCabling.h>

Public Types
enum	MAXMINREADOUTIDS {   MAXRODID = 12 , MINRODID = 1 , MAXSRODID = 3 , MINSRODID = 1 ,   MAXSSWID = 9 , MINSSWID = 0 , MAXSBLOC = 31 , MINSBLOC = 0 ,   MINCHANNELID = 40 , MAXCHANNELID = 199 }

Public Member Functions
	TGCCabling (const std::string &filenameASDToPP, const std::string &filenameInPP, const std::string &filenamePPToSL, const std::string &filenameSLBToROD)
virtual	~TGCCabling (void)
virtual TGCChannelId *	getASDOutChannel (const TGCChannelId *slb_in) const
const TGCModuleId *	getSLBFromReadout (TGCId::SideType side, int rodId, int sswId, int sbLoc) const
int	getRxIdFromReadout (TGCId::SideType side, int rodId, int sswId, int sbLoc) const
TGCModuleId *	getSLBFromRxId (TGCId::SideType side, int rodId, int sswId, int rxId) const
bool	getReadoutFromSLB (const TGCModuleSLB *slb, TGCId::SideType &side, int &rodId, int &sswId, int &sbLoc) const
TGCChannelId *	getASDOutFromReadout (TGCId::SideType side, int rodId, int sswId, int sbLoc, int channel, bool orChannel=false) const
bool	getReadoutFromASDOut (const TGCChannelASDOut *asdout, TGCId::SideType &side, int &rodId, int &sswId, int &sbLoc, int &channel, bool orChannel=false) const
bool	getHighPtIDFromReadout (TGCId::SideType side, int rodId, int sswId, int sbLoc, int channel, TGCId::SignalType &signal, TGCId::RegionType &region, int &sectorInReadout, int &hpbId, int &block, int &hitId, int &pos) const
bool	getReadoutFromHighPtID (TGCId::SideType side, int rodId, int &sswId, int &sbLoc, int &channel, TGCId::SignalType signal, TGCId::RegionType region, int sectorInReadout, int hpbId, int block, int hitId, int pos, TGCId::ModuleType moduleType, bool orChannel) const
bool	getLowPtCoincidenceFromReadout (TGCId::SideType side, int rodId, int sswId, int sbLoc, int channel, int &block, int &pos, bool middle=false) const
bool	getReadoutFromLowPtCoincidence (TGCId::SideType side, int rodId, int sswId, int sbLoc, int &channel, int block, int pos, bool middle=false) const
TGCChannelId *	getChannel (const TGCChannelId *channelId, TGCChannelId::ChannelIdType type, bool orChannel=false) const
TGCModuleMap *	getModule (const TGCModuleId *moduleId, TGCModuleId::ModuleIdType type) const
StatusCode	updateCableASDToPP ()

Private Member Functions
	TGCCabling ()=delete
	TGCCabling (const TGCCabling &)=delete
TGCCabling &	operator= (const TGCCabling &)=delete
int	getIndexFromReadoutWithoutChannel (const TGCId::SideType side, const int rodId, const int sswId, const int sbLoc) const

Private Attributes
TGCCableInASD *	m_cableInASD
TGCCableASDToPP *	m_cableASDToPP
TGCCableInPP *	m_cableInPP
TGCCablePPToSLB *	m_cablePPToSLB
TGCCableInSLB *	m_cableInSLB
TGCCableSLBToHPB *	m_cableSLBToHPB
TGCCableHPBToSL *	m_cableHPBToSL
TGCCableSLBToSSW *	m_cableSLBToSSW
TGCCableSSWToROD *	m_cableSSWToROD
std::map< int, TGCModuleId * > m_slbModuleIdMap	ATLAS_THREAD_SAFE
std::mutex	m_mutex

Detailed Description

Definition at line 34 of file TGCCabling.h.

Member Enumeration Documentation

MAXMINREADOUTIDS

enum MuonTGC_Cabling::TGCCabling::MAXMINREADOUTIDS

Enumerator
MAXRODID
MINRODID
MAXSRODID
MINSRODID
MAXSSWID
MINSSWID
MAXSBLOC
MINSBLOC
MINCHANNELID
MAXCHANNELID

Definition at line 51 of file TGCCabling.h.

                        { 
    MAXRODID = 12, 
    MINRODID = 1, 
    MAXSRODID = 3, 
    MINSRODID = 1, 
    MAXSSWID = 9, 
    MINSSWID = 0, 
    MAXSBLOC = 31, 
    MINSBLOC = 0, 
    MINCHANNELID = 40, 
    MAXCHANNELID = 199 
  }; 

Constructor & Destructor Documentation

TGCCabling() [1/3]

MuonTGC_Cabling::TGCCabling::TGCCabling ( )

privatedelete

TGCCabling() [2/3]

MuonTGC_Cabling::TGCCabling::TGCCabling ( const TGCCabling & )

privatedelete

TGCCabling() [3/3]

MuonTGC_Cabling::TGCCabling::TGCCabling	(	const std::string &	filenameASDToPP,
		const std::string &	filenameInPP,
		const std::string &	filenamePPToSL,
		const std::string &	filenameSLBToROD )

Definition at line 28 of file TGCCabling.cxx.

{
  m_cableInASD    = new TGCCableInASD(filenameASDToPP);
  m_cableASDToPP  = new TGCCableASDToPP(filenameASDToPP);
  m_cableInPP     = new TGCCableInPP(filenameInPP);
  m_cablePPToSLB  = new TGCCablePPToSLB(filenamePPToSL);
  m_cableInSLB    = new TGCCableInSLB();
  m_cableSLBToHPB = new TGCCableSLBToHPB(filenamePPToSL);
  m_cableHPBToSL  = new TGCCableHPBToSL(filenamePPToSL);
  m_cableSLBToSSW = new TGCCableSLBToSSW(filenameSLBToROD);
  m_cableSSWToROD = new TGCCableSSWToROD(filenameSLBToROD);
}

~TGCCabling()

MuonTGC_Cabling::TGCCabling::~TGCCabling ( void )

virtual

Definition at line 44 of file TGCCabling.cxx.

{
  delete m_cableInASD;
  delete m_cableASDToPP;
  delete m_cableInPP;
  delete m_cablePPToSLB;
  delete m_cableInSLB;
  delete m_cableSLBToHPB;
  delete m_cableHPBToSL;
  delete m_cableSLBToSSW;
  delete m_cableSSWToROD;
 
  for (auto& p : m_slbModuleIdMap) {
    delete p.second;
  }
}

Member Function Documentation

getASDOutChannel()

TGCChannelId * MuonTGC_Cabling::TGCCabling::getASDOutChannel ( const TGCChannelId * slb_in ) const

virtual

Definition at line 68 of file TGCCabling.cxx.

{
  TGCChannelSLBIn slb_in(in->getSideType(),
             in->getModuleType(),
             in->getRegionType(),
             in->getSector(),
             in->getId(),
             in->getChannel());
  return getChannel(&slb_in,
            TGCChannelId::ChannelIdType::ASDOut); 
}

getASDOutFromReadout()

TGCChannelId * MuonTGC_Cabling::TGCCabling::getASDOutFromReadout	(	TGCId::SideType	side,
		int	rodId,
		int	sswId,
		int	sbLoc,
		int	channel,
		bool	orChannel = false ) const

Definition at line 555 of file TGCCabling.cxx.

                                                 {
  const TGCModuleId* slb = getSLBFromReadout(side,
                         rodId,
                         sswId,
                         sbLoc);
  if(!slb) return nullptr;
  
  TGCChannelSLBIn slbin(slb->getSideType(),
            slb->getModuleType(),
            slb->getRegionType(),
            slb->getSector(),
            slb->getId(),
            channel);
  if(!slbin.isValid()) return nullptr;  
 
  return getChannel(&slbin,TGCChannelId::ChannelIdType::ASDOut,orChannel); 
}

getChannel()

TGCChannelId * MuonTGC_Cabling::TGCCabling::getChannel	(	const TGCChannelId *	channelId,
		TGCChannelId::ChannelIdType	type,
		bool	orChannel = false ) const

Definition at line 616 of file TGCCabling.cxx.

                                           {
  switch(channelId->getChannelIdType()){
  case TGCChannelId::ChannelIdType::ASDIn:
    if(type==TGCChannelId::ChannelIdType::ASDOut)
      return m_cableInASD->getChannel(channelId,orChannel);
    if(type==TGCChannelId::ChannelIdType::SLBIn){
      TGCChannelId* asdout = m_cableInASD->getChannel(channelId,false);
      if(!asdout) return nullptr;
      if(!asdout->isValid()){
    delete asdout;
    return nullptr;
      }
      TGCChannelId* ppin = m_cableASDToPP->getChannel(asdout,false);
      delete asdout;
      if(!ppin) return nullptr;
      if(!ppin->isValid()){
    delete ppin;
    return nullptr;
      }
      TGCChannelId* ppout = m_cableInPP->getChannel(ppin,orChannel);
      delete ppin;
      if(!ppout) return nullptr;
      if(!ppout->isValid()){
    delete ppout;
    return nullptr;
      }
      TGCChannelId* slbin = m_cablePPToSLB->getChannel(ppout,false);
      delete ppout;
      return slbin;
    } 
    break;
  case TGCChannelId::ChannelIdType::ASDOut:
    if(type==TGCChannelId::ChannelIdType::ASDIn)
      return m_cableInASD->getChannel(channelId,orChannel);
    if(type==TGCChannelId::ChannelIdType::PPIn)
      return m_cableASDToPP->getChannel(channelId,orChannel);
    if(type==TGCChannelId::ChannelIdType::SLBIn){
      TGCChannelId* ppin = m_cableASDToPP->getChannel(channelId,false);
      if(!ppin) return nullptr;
      if(!ppin->isValid()){
    delete ppin;
    return nullptr;
      }
      TGCChannelId* ppout = m_cableInPP->getChannel(ppin,orChannel);
      delete ppin;
      if(!ppout) return nullptr;
      if(!ppout->isValid()){
    delete ppout;
    return nullptr;
      }
      TGCChannelId* slbin = m_cablePPToSLB->getChannel(ppout,false);
      delete ppout;
      return slbin;
    } 
    break;
  case TGCChannelId::ChannelIdType::PPIn:
    if(type==TGCChannelId::ChannelIdType::ASDOut)
      return m_cableASDToPP->getChannel(channelId,orChannel);
    if(type==TGCChannelId::ChannelIdType::PPOut)
      return m_cableInPP->getChannel(channelId,orChannel);
    break;
  case TGCChannelId::ChannelIdType::PPOut:
    if(type==TGCChannelId::ChannelIdType::PPIn)
      return m_cableInPP->getChannel(channelId,orChannel);
    if(type==TGCChannelId::ChannelIdType::SLBIn)
      return m_cablePPToSLB->getChannel(channelId,orChannel);
    break;
  case TGCChannelId::ChannelIdType::SLBIn:
    if(type==TGCChannelId::ChannelIdType::SLBOut)
      return m_cableInSLB->getChannel(channelId,orChannel);
    if(type==TGCChannelId::ChannelIdType::HPBIn){
      TGCChannelId* slbout = m_cableInSLB->getChannel(channelId,orChannel);
      if(!slbout) return nullptr; 
      if(!slbout->isValid()) {
    delete slbout;
    return nullptr;
      } 
      TGCChannelId* hpbin = m_cableSLBToHPB->getChannel(slbout,false);
      delete slbout;
      return hpbin;
    }
    if(type==TGCChannelId::ChannelIdType::PPOut)
      return m_cablePPToSLB->getChannel(channelId,orChannel);
    if(type==TGCChannelId::ChannelIdType::ASDOut){
      TGCChannelId* ppout = m_cablePPToSLB->getChannel(channelId,false);
      if(!ppout) return nullptr;
      if(!ppout->isValid()){
    delete ppout;
    return nullptr;
      }
      TGCChannelId* ppin = m_cableInPP->getChannel(ppout,orChannel);
      delete ppout;
      if(!ppin) return nullptr;
      if(!ppin->isValid()){
    delete ppin;
    return nullptr;
      }
      TGCChannelId* asdout = m_cableASDToPP->getChannel(ppin,false);
      delete ppin;
      return asdout;
    } 
    if(type==TGCChannelId::ChannelIdType::ASDIn){
      TGCChannelId* ppout = m_cablePPToSLB->getChannel(channelId,false);
      if(!ppout) return nullptr;
      if(!ppout->isValid()){
    delete ppout;
    return nullptr;
      }
      TGCChannelId* ppin = m_cableInPP->getChannel(ppout,orChannel);
      delete ppout;
      if(!ppin) return nullptr;
      if(!ppin->isValid()){
    delete ppin;
    return nullptr;
      }
      TGCChannelId* asdout = m_cableASDToPP->getChannel(ppin,false);
      delete ppin;
      if(!asdout) return nullptr;
      if(!asdout->isValid()){
    delete asdout;
    return nullptr;
      }
      TGCChannelId* asdin = m_cableInASD->getChannel(asdout,false);
      delete asdout;
      return asdin;
    } 
    break;
  case TGCChannelId::ChannelIdType::SLBOut:
    if(type==TGCChannelId::ChannelIdType::SLBIn)
      return m_cableInSLB->getChannel(channelId,orChannel);
    if(type==TGCChannelId::ChannelIdType::HPBIn){
      return m_cableSLBToHPB->getChannel(channelId,orChannel);
    }
    break;
  case TGCChannelId::ChannelIdType::HPBIn:
    if(type==TGCChannelId::ChannelIdType::SLBIn){
      TGCChannelId* slbout = m_cableSLBToHPB->getChannel(channelId,false);
      if(!slbout) return nullptr;
      if(!slbout->isValid()){
    delete slbout;
    return nullptr;
      }
      TGCChannelId* slbin = m_cableInSLB->getChannel(slbout,orChannel);
      delete slbout;
      return slbin;
    }
    if(type==TGCChannelId::ChannelIdType::SLBOut)
      return m_cableSLBToHPB->getChannel(channelId,orChannel);
    break;
  default:
    break;
  }
  return nullptr;
}

getHighPtIDFromReadout()

bool MuonTGC_Cabling::TGCCabling::getHighPtIDFromReadout	(	TGCId::SideType	side,
		int	rodId,
		int	sswId,
		int	sbLoc,
		int	channel,
		TGCId::SignalType &	signal,
		TGCId::RegionType &	region,
		int &	sectorInReadout,
		int &	hpbId,
		int &	block,
		int &	hitId,
		int &	pos ) const

Definition at line 428 of file TGCCabling.cxx.

{
  signal = TGCId::NoSignalType;
  region = TGCId::NoRegionType;
  sectorInReadout = -1;
  hpbId  = -1;
  block  = -1;
  hitId  = -1;
  pos    = -1;
 
  const TGCModuleId* slb = getSLBFromReadout(side,
                         rodId,
                         sswId,
                         sbLoc);
  if(!slb) return 0;
  
  TGCChannelSLBIn slbin(slb->getSideType(),
                        slb->getModuleType(),
                        slb->getRegionType(),
                        slb->getSector(),
                        slb->getId(),
                        channel);
  
  TGCChannelId* hpbin = getChannel(&slbin,TGCChannelId::ChannelIdType::HPBIn,false); 
  if(!hpbin) return 0;
  if(!hpbin->isValid()) {
    delete hpbin;
    return 0;
  }
  signal = hpbin->getSignalType();
  region = hpbin->getRegionType();
  sectorInReadout = hpbin->getSectorInReadout();
  hpbId  = hpbin->getId();
  block  = hpbin->getBlock();
  pos    = hpbin->getChannel()%2;
  hitId  = (hpbin->getChannel() - pos)/2;
  
  delete hpbin;
  return true;
}

getIndexFromReadoutWithoutChannel()

int MuonTGC_Cabling::TGCCabling::getIndexFromReadoutWithoutChannel ( const TGCId::SideType side, const int rodId, const int sswId, const int sbLoc ) const

private

Definition at line 814 of file TGCCabling.cxx.

                                                 { 
  return ((((side-TGCId::Aside) 
        *(MAXRODID-MINRODID+1) + rodId-MINRODID) 
       *(MAXSSWID-MINSSWID+1) + sswId-MINSSWID) 
      *(MAXSBLOC-MINSBLOC+1) + sbLoc-MINSBLOC); 
}

getLowPtCoincidenceFromReadout()

bool MuonTGC_Cabling::TGCCabling::getLowPtCoincidenceFromReadout	(	TGCId::SideType	side,
		int	rodId,
		int	sswId,
		int	sbLoc,
		int	channel,
		int &	block,
		int &	pos,
		bool	middle = false ) const

Definition at line 520 of file TGCCabling.cxx.

                                           {
  
  const TGCModuleId* slb = getSLBFromReadout(side,
                         rodId,
                         sswId,
                         sbLoc);
  if(!slb) return 0;
  
  TGCChannelSLBIn slbin(slb->getSideType(),
            slb->getModuleType(),
            slb->getRegionType(),
            slb->getSector(),
            slb->getId(),
            channel);
  if(!slbin.isValid()) return false;
  
  TGCChannelId* slbout = getChannel(&slbin,TGCChannelId::ChannelIdType::SLBOut,middle); 
  if(!slbout) return false;
  
  block = slbout->getBlock();
  pos = slbout->getChannel();
  delete slbout;
  
  return true;
}

getModule()

TGCModuleMap * MuonTGC_Cabling::TGCCabling::getModule	(	const TGCModuleId *	moduleId,
		TGCModuleId::ModuleIdType	type ) const

Definition at line 773 of file TGCCabling.cxx.

                                                        {
  switch(moduleId->getModuleIdType()){
  case TGCModuleId::PP:
    if(type==TGCModuleId::SLB)
      return m_cablePPToSLB->getModule(moduleId);
    break;
  case TGCModuleId::SLB:
    if(type==TGCModuleId::PP)
      return m_cablePPToSLB->getModule(moduleId);
    if(type==TGCModuleId::HPB)
      return m_cableSLBToHPB->getModule(moduleId);
    if(type==TGCModuleId::SSW)
      return m_cableSLBToSSW->getModule(moduleId);
    break;
  case TGCModuleId::HPB:
    if(type==TGCModuleId::SLB)
      return m_cableSLBToHPB->getModule(moduleId);
    if(type==TGCModuleId::SL)
      return m_cableHPBToSL->getModule(moduleId);
    break;
  case TGCModuleId::SL:
    if(type==TGCModuleId::HPB)
      return m_cableHPBToSL->getModule(moduleId);
    break;
  case TGCModuleId::SSW:
    if(type==TGCModuleId::SLB)
      return m_cableSLBToSSW->getModule(moduleId);
    if(type==TGCModuleId::ROD)
      return m_cableSSWToROD->getModule(moduleId);
    break;
  case TGCModuleId::ROD:
    if(type==TGCModuleId::SSW)
      return m_cableSSWToROD->getModule(moduleId);
    break;
  default:
    break;
  }
  return nullptr;
} 

getReadoutFromASDOut()

bool MuonTGC_Cabling::TGCCabling::getReadoutFromASDOut	(	const TGCChannelASDOut *	asdout,
		TGCId::SideType &	side,
		int &	rodId,
		int &	sswId,
		int &	sbLoc,
		int &	channel,
		bool	orChannel = false ) const

Definition at line 580 of file TGCCabling.cxx.

                                            {
  // initialize
  side = TGCId::NoSideType;
  rodId = -1;
  sswId = -1;
  sbLoc = -1;
  channel = -1;
 
 
  // SLBIn channel
  TGCChannelId* slbin = getChannel(asdout,TGCChannelId::ChannelIdType::SLBIn,orChannel);
  
  if(!slbin) return false;
  channel = slbin->getChannel();
  
  TGCModuleSLB* slb = dynamic_cast<TGCModuleSLB*>(slbin->getModule());
  delete slbin;
  if(!slb) return false;
  
  // SLB Module -> readout ID
  bool status = getReadoutFromSLB(slb,
                  side,
                  rodId,
                  sswId,
                  sbLoc);
  delete slb;
  
  return status;
}

getReadoutFromHighPtID()

bool MuonTGC_Cabling::TGCCabling::getReadoutFromHighPtID	(	TGCId::SideType	side,
		int	rodId,
		int &	sswId,
		int &	sbLoc,
		int &	channel,
		TGCId::SignalType	signal,
		TGCId::RegionType	region,
		int	sectorInReadout,
		int	hpbId,
		int	block,
		int	hitId,
		int	pos,
		TGCId::ModuleType	moduleType,
		bool	orChannel ) const

Definition at line 349 of file TGCCabling.cxx.

{
  // initialize
  sswId = -1;
  sbLoc = -1;
  channel = -1;
 
  // get sector number
  
  int readoutSector = (rodId -1); 
  int sector = sectorInReadout;
  if (rodId<13){
    if(region==TGCId::Forward) {
      sector += readoutSector*(TGCId::NUM_FORWARD_SECTOR/TGCId::N_RODS);
    } else {
      sector += readoutSector*(TGCId::NUM_ENDCAP_SECTOR/TGCId::N_RODS);
    }
  }else if(rodId<20){
    readoutSector -= 16;
    if(region==TGCId::Forward) {
      sector += readoutSector*(TGCId::NUM_FORWARD_SECTOR/TGCModuleId::NumberOfSReadoutSector);
    } else {
      sector += readoutSector*(TGCId::NUM_ENDCAP_SECTOR/TGCModuleId::NumberOfSReadoutSector);
    }
  }
    
  TGCChannelHPBIn hpbin(side,
            signal,
            region,
            sector,
            hpbId,
            block,
            hitId*2+pos);
  if(!hpbin.isValid()) return false;
 
  TGCChannelId* slbout = m_cableSLBToHPB->getChannelInforHPB(&hpbin,moduleType,false);
  if(!slbout) return 0;
  if(!slbout->isValid()){
    delete slbout;
    return 0;
  }
  TGCChannelId* slbin = m_cableInSLB->getChannel(slbout,orChannel);
  delete slbout;
  
  if(!slbin) return false;
  channel = slbin->getChannel();
  
  TGCModuleSLB* slb = dynamic_cast<TGCModuleSLB*>(slbin->getModule());
  delete slbin;
  if(!slb) return false;
  
  // SLB Module -> readout ID
  TGCId::SideType sideType;
  int rodid; // dummy
  bool status = getReadoutFromSLB(slb,
                  sideType,
                  rodid, 
                  sswId,
                  sbLoc);
  
  delete slb;
  
  return status;
}

getReadoutFromLowPtCoincidence()

bool MuonTGC_Cabling::TGCCabling::getReadoutFromLowPtCoincidence	(	TGCId::SideType	side,
		int	rodId,
		int	sswId,
		int	sbLoc,
		int &	channel,
		int	block,
		int	pos,
		bool	middle = false ) const

Definition at line 482 of file TGCCabling.cxx.

{
  bool orChannel = flag;    
 
  const TGCModuleId* slb = getSLBFromReadout(side,
                         rodId,
                         sswId,
                         sbLoc);
  if(!slb) return 0;
 
  TGCChannelSLBOut slbout(slb->getSideType(),
              slb->getModuleType(),
              slb->getRegionType(),
              slb->getSector(),
              slb->getId(),
              block,
              pos);
 
  TGCChannelId* slbin = getChannel(&slbout,TGCChannelId::ChannelIdType::SLBIn, orChannel); 
  
  if(!slbin) return false;
  
  channel = slbin->getChannel();
  
  delete slbin;
  
  return true;
}

getReadoutFromSLB()

bool MuonTGC_Cabling::TGCCabling::getReadoutFromSLB	(	const TGCModuleSLB *	slb,
		TGCId::SideType &	side,
		int &	rodId,
		int &	sswId,
		int &	sbLoc ) const

Definition at line 259 of file TGCCabling.cxx.

{
  // initialize
  side = TGCId::NoSideType;
  rodId = -1;
  sswId = -1;
  sbLoc = -1;
 
  if(!slb) return false;
  
  // Fill side
  side = slb->getSideType();
 
  TGCModuleMap* sswMap = getModule(slb,TGCModuleId::SSW);
 
  if(!sswMap) return false;
  
  // SSW Module
  TGCModuleId* ssw = sswMap->popModuleId(0);
  delete sswMap;
  if(!ssw) return false;
 
    
  // Fill SSW ID
  sswId = ssw->getId();
 
 
  // Fill SBLoc
  sbLoc = slb->getSBLoc();
 
 
  if(sbLoc < 0) {
    TGCModuleMap* slbMap =  getModule(ssw,TGCModuleId::SLB);
    if(!slbMap){
      delete ssw; ssw = nullptr;
      return false;
    }
    
    TGCModuleSLB*   pSlb=nullptr;
    //bool found = false;
    const int size = slbMap->size();
    for(int i=0; i<size; i++){
      pSlb = dynamic_cast<TGCModuleSLB*>(slbMap->moduleId(i));
 
      if(pSlb &&
     slb->getRegionType() == pSlb->getRegionType() &&
     slb->getSector() == pSlb->getSector()  &&
     slb->getId() == pSlb->getId()){
    if(slb->getModuleType() == pSlb->getModuleType()) {
      sbLoc = pSlb->getSBLoc(); 
      //found = true;
      break;
    }
    // SI is connected to the SLB corrsponding WI 
    if((slb->getModuleType()==TGCId::SI) && (pSlb->getModuleType()==TGCId::WI)) {  
      sbLoc = pSlb->getSBLoc(); 
      //found = true;
      break;
    }
      }
    }
    delete slbMap;
    if(sbLoc < 0) {
      delete ssw;
      return false;
    }
  }  
    
 
  TGCModuleMap* rodMap = getModule(ssw,TGCModuleId::ROD);
  delete ssw;
  if(!rodMap) return false;
 
  // ROD Module
  TGCModuleId* rod = rodMap->popModuleId(0);
  delete rodMap;
  if(!rod) return false;
 
  // Fill ROD ID
  rodId = rod->getId();
  delete rod;
 
  return true;  
}

getRxIdFromReadout()

int MuonTGC_Cabling::TGCCabling::getRxIdFromReadout	(	TGCId::SideType	side,
		int	rodId,
		int	sswId,
		int	sbLoc ) const

Definition at line 159 of file TGCCabling.cxx.

{
  int rxId = -1;
 
  // ROD Module
  int readoutSector = rodId -1 ; //rodID = 1..12
  TGCModuleROD rod(side,readoutSector);
 
  // SSW Module
  TGCModuleMap* sswMap = getModule(&rod,TGCModuleId::SSW);
  if(!sswMap) return rxId;
 
  TGCModuleId* ssw = nullptr;
  bool found = false;
  const int sswMapsize = sswMap->size();
  for(int i=0; i<sswMapsize; i++){
    if((sswMap->moduleId(i))->getId()==sswId){
      ssw = sswMap->popModuleId(i);
      found = true;
      break;
    }
  }
  delete sswMap;
  if(!found || !ssw) return rxId; // Do not need to delete ssw here.  
                                  // We can delete ssw but nothing will be done.  
 
  // SLB Module
  TGCModuleMap* slbMap =  getModule(ssw,TGCModuleId::SLB);
  delete ssw;
  if(!slbMap) return rxId;
 
  TGCModuleSLB*   slb=nullptr; 
  found = false;
  const int slbMapsize = slbMap->size();
  for(int i=0; i<slbMapsize; i++){
    slb = dynamic_cast<TGCModuleSLB*>(slbMap->moduleId(i));
    if(slb && slb->getSBLoc()== sbLoc){
      rxId = slbMap->connector(i);
      break;
    }
  }
  delete slbMap;
 
  return rxId;
}

getSLBFromReadout()

const TGCModuleId * MuonTGC_Cabling::TGCCabling::getSLBFromReadout	(	TGCId::SideType	side,
		int	rodId,
		int	sswId,
		int	sbLoc ) const

Definition at line 83 of file TGCCabling.cxx.

{
  std::scoped_lock lock (m_mutex);
 
  int indexFromReadoutWithoutChannel  
    = getIndexFromReadoutWithoutChannel(side, rodId, sswId, sbLoc); 
  std::map<int, TGCModuleId*>::iterator it 
    = m_slbModuleIdMap.find(indexFromReadoutWithoutChannel); 
  if(it!=m_slbModuleIdMap.end()) { 
    // Already seen this ReadoutID without channel.  
    // Stored pointer is returned.  
    return (*it).second; 
  } 
  
  // ROD Module
  int readoutSector = rodId -1 ; //rodID = 1..12
  TGCModuleROD rod(side,readoutSector);
 
  // SSW Module
  TGCModuleMap* sswMap =  getModule(&rod,TGCModuleId::SSW);
  if(!sswMap) {
    m_slbModuleIdMap.insert(std::pair<int, TGCModuleId*>(indexFromReadoutWithoutChannel, 0));
    return nullptr;
  }
 
  TGCModuleId* ssw = nullptr;
  bool found = false;
  const int sswMapsize = sswMap->size();
  for(int i=0; i<sswMapsize; i++){
    if((sswMap->moduleId(i))->getId()==sswId){
      ssw = sswMap->popModuleId(i);
      found = true;
      break;
    }
  }
  delete sswMap;
  if(!found || !ssw) {
    m_slbModuleIdMap.insert(std::pair<int, TGCModuleId*>(indexFromReadoutWithoutChannel, 0));
    return nullptr; // Do not need to delete ssw here.  
              // We can delete ssw but nothing will be done.  
  }
 
  // SLB Module
  TGCModuleMap* slbMap =  getModule(ssw,TGCModuleId::SLB);
  delete ssw;
  if(!slbMap) {
    m_slbModuleIdMap.insert(std::pair<int, TGCModuleId*>(indexFromReadoutWithoutChannel, 0));
    return nullptr;
  }
 
  TGCModuleSLB* slb=nullptr; 
  found = false;
  const int slbMapsize = slbMap->size();
  for(int i=0; i<slbMapsize; i++){
    slb = dynamic_cast<TGCModuleSLB*>(slbMap->moduleId(i));
    if(slb && slb->getSBLoc()== sbLoc){
      found = true;
      slb = dynamic_cast<TGCModuleSLB*>(slbMap->popModuleId(i));
      break;
    }
  }
  delete slbMap;
 
  if(!found || !slb) {
    m_slbModuleIdMap.insert(std::pair<int, TGCModuleId*>(indexFromReadoutWithoutChannel, 0));
    return nullptr; // Do not delete slb here.  
  }
  
  m_slbModuleIdMap.insert(std::pair<int, TGCModuleId*>(indexFromReadoutWithoutChannel, slb));
  return slb;
}

getSLBFromRxId()

TGCModuleId * MuonTGC_Cabling::TGCCabling::getSLBFromRxId	(	TGCId::SideType	side,
		int	rodId,
		int	sswId,
		int	rxId ) const

Definition at line 209 of file TGCCabling.cxx.

{
  bool found;
 
  // ROD Module
  int readoutSector = rodId -1 ; //rodID = 1..12
  TGCModuleROD rod(side,readoutSector);
 
  // SSW Module
  TGCModuleMap* sswMap =  getModule(&rod,TGCModuleId::SSW);
  if(!sswMap) return nullptr;
 
  TGCModuleId* ssw = nullptr;
  found = false;
  const int size = sswMap->size();
  for(int i=0; i<size; i++){
    if((sswMap->moduleId(i))->getId()==sswId){
      ssw = sswMap->popModuleId(i);
      found = true;
      break;
    }
  }
  delete sswMap;
  if(!found || !ssw) return nullptr; // Do not need to delete ssw here.
                               // We can delete ssw but nothing will be done.
 
  // SLB Module
  TGCModuleMap* slbMap =  getModule(ssw,TGCModuleId::SLB);
  delete ssw;
  if(!slbMap) return nullptr;
 
  TGCModuleSLB*   slb=nullptr;  
  int ip = slbMap->find(rxId);
  if(ip <0 || ip >= slbMap->size()){
    delete slbMap; slbMap = nullptr;
    return nullptr;
  }
  slb =  dynamic_cast<TGCModuleSLB*>(slbMap->popModuleId(ip));
  delete slbMap;
 
  if(!slb) return nullptr; 
  
  return slb;
}

operator=()

TGCCabling & MuonTGC_Cabling::TGCCabling::operator= ( const TGCCabling & )

privatedelete

updateCableASDToPP()

StatusCode MuonTGC_Cabling::TGCCabling::updateCableASDToPP

(

)

Definition at line 62 of file TGCCabling.cxx.

{
  return m_cableASDToPP->updateDatabase(); 
} 

Member Data Documentation

ATLAS_THREAD_SAFE

std::map<int, TGCModuleId*> m_slbModuleIdMap MuonTGC_Cabling::TGCCabling::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 191 of file TGCCabling.h.

m_cableASDToPP

TGCCableASDToPP* MuonTGC_Cabling::TGCCabling::m_cableASDToPP

private

Definition at line 181 of file TGCCabling.h.

m_cableHPBToSL

TGCCableHPBToSL* MuonTGC_Cabling::TGCCabling::m_cableHPBToSL

private

Definition at line 186 of file TGCCabling.h.

m_cableInASD

TGCCableInASD* MuonTGC_Cabling::TGCCabling::m_cableInASD

private

Definition at line 180 of file TGCCabling.h.

m_cableInPP

TGCCableInPP* MuonTGC_Cabling::TGCCabling::m_cableInPP

private

Definition at line 182 of file TGCCabling.h.

m_cableInSLB

TGCCableInSLB* MuonTGC_Cabling::TGCCabling::m_cableInSLB

private

Definition at line 184 of file TGCCabling.h.

m_cablePPToSLB

TGCCablePPToSLB* MuonTGC_Cabling::TGCCabling::m_cablePPToSLB

private

Definition at line 183 of file TGCCabling.h.

m_cableSLBToHPB

TGCCableSLBToHPB* MuonTGC_Cabling::TGCCabling::m_cableSLBToHPB

private

Definition at line 185 of file TGCCabling.h.

m_cableSLBToSSW

TGCCableSLBToSSW* MuonTGC_Cabling::TGCCabling::m_cableSLBToSSW

private

Definition at line 187 of file TGCCabling.h.

m_cableSSWToROD

TGCCableSSWToROD* MuonTGC_Cabling::TGCCabling::m_cableSSWToROD

private

Definition at line 188 of file TGCCabling.h.

m_mutex

std::mutex MuonTGC_Cabling::TGCCabling::m_mutex

mutableprivate

Definition at line 192 of file TGCCabling.h.

---

The documentation for this class was generated from the following files:

• TGCCabling.h
• TGCCabling.cxx