#include <TGCCableASDToPP.h>

Inheritance diagram for MuonTGC_Cabling::TGCCableASDToPP:

Collaboration diagram for MuonTGC_Cabling::TGCCableASDToPP:

Public Types
enum	CableType { NoCableType =-1 , InASD , ASDToPP , InPP , PPToSLB , InSLB , SLBToHPB , HPBToSL , SLBToSSW , SSWToROD , MaxCableType }

Public Member Functions
	TGCCableASDToPP (const std::string &filename)
virtual	~TGCCableASDToPP ()
virtual TGCChannelId *	getChannel (const TGCChannelId *channelId, bool orChannel=false) const
StatusCode	updateDatabase ()
CableType	getCableType (void) const

Protected Member Functions
virtual TGCModuleMap *	getModuleIn (const TGCModuleId *) const
virtual TGCModuleMap *	getModuleOut (const TGCModuleId *) const

Private Types
using	ForwardSectorDB = std::array<std::array<std::shared_ptr<TGCDatabaseASDToPP>, TGCId::NUM_FORWARD_SECTOR>, TGCId::MaxSideType>
using	InnerSectorDB = std::array<std::array<std::shared_ptr<TGCDatabaseASDToPP>, TGCId::NUM_INNER_SECTOR>, TGCId::MaxSideType>
using	EndcapSectorDB = std::array<std::array<std::shared_ptr<TGCDatabaseASDToPP>, TGCId::NUM_ENDCAP_SECTOR>, TGCId::MaxSideType>
using	CommonDB = std::array<std::array<std::shared_ptr<TGCDatabaseASDToPP>, TGCId::MaxModuleType>, TGCId::MaxRegionType>
	Pointers of common databases are recorded in this array.

Private Member Functions
	TGCCableASDToPP ()
void	initialize (const std::string &filename)
virtual TGCChannelId *	getChannelIn (const TGCChannelId *ppin, bool orChannel=false) const
virtual TGCChannelId *	getChannelOut (const TGCChannelId *asdout, bool orChannel=false) const
StatusCode	getUpdateInfo (const int side, const int sector, const std::string &blockname, std::vector< std::vector< int > > &info)
TGCDatabaseASDToPP *	getDatabase (const int side, const int region, const int sector, const int module) const
StatusCode	updateIndividualDatabase (const int side, const int sector, const std::string &blockname, std::shared_ptr< TGCDatabaseASDToPP > &database)

Private Attributes
ToolHandle< ITGCCablingDbTool >	m_tgcCablingDbTool
std::vector< std::string > *	m_ASD2PP_DIFF_12 {nullptr}
ForwardSectorDB	m_FWDdb {}
ForwardSectorDB	m_FSDdb {}
ForwardSectorDB	m_FWTdb {}
ForwardSectorDB	m_FSTdb {}
InnerSectorDB	m_FWIdb {}
InnerSectorDB	m_FSIdb {}
EndcapSectorDB	m_EWDdb {}
EndcapSectorDB	m_ESDdb {}
EndcapSectorDB	m_EWTdb {}
EndcapSectorDB	m_ESTdb {}
InnerSectorDB	m_EWIdb {}
InnerSectorDB	m_ESIdb {}
CommonDB	m_commonDb {{{nullptr}}}
CableType	m_type

Static Private Attributes
static const int	s_stripForward [] = {2,1,0,4,3,6,5,8,7}

Detailed Description

Definition at line 22 of file TGCCableASDToPP.h.

Member Typedef Documentation

◆ CommonDB

using MuonTGC_Cabling::TGCCableASDToPP::CommonDB = std::array<std::array<std::shared_ptr<TGCDatabaseASDToPP>, TGCId::MaxModuleType>, TGCId::MaxRegionType>

private

Pointers of common databases are recorded in this array.

Definition at line 83 of file TGCCableASDToPP.h.

◆ EndcapSectorDB

using MuonTGC_Cabling::TGCCableASDToPP::EndcapSectorDB = std::array<std::array<std::shared_ptr<TGCDatabaseASDToPP>, TGCId::NUM_ENDCAP_SECTOR>, TGCId::MaxSideType>

private

Definition at line 66 of file TGCCableASDToPP.h.

◆ ForwardSectorDB

using MuonTGC_Cabling::TGCCableASDToPP::ForwardSectorDB = std::array<std::array<std::shared_ptr<TGCDatabaseASDToPP>, TGCId::NUM_FORWARD_SECTOR>, TGCId::MaxSideType>

private

Definition at line 64 of file TGCCableASDToPP.h.

◆ InnerSectorDB

using MuonTGC_Cabling::TGCCableASDToPP::InnerSectorDB = std::array<std::array<std::shared_ptr<TGCDatabaseASDToPP>, TGCId::NUM_INNER_SECTOR>, TGCId::MaxSideType>

private

Definition at line 65 of file TGCCableASDToPP.h.

Member Enumeration Documentation

◆ CableType

enum MuonTGC_Cabling::TGCCable::CableType

inherited

Enumerator
NoCableType
InASD
ASDToPP
InPP
PPToSLB
InSLB
SLBToHPB
HPBToSL
SLBToSSW
SSWToROD
MaxCableType

Definition at line 18 of file TGCCable.h.

                 {NoCableType=-1,
          InASD, ASDToPP, InPP, PPToSLB, InSLB,
          SLBToHPB, HPBToSL, SLBToSSW, SSWToROD,
          MaxCableType};

Constructor & Destructor Documentation

◆ TGCCableASDToPP() [1/2]

MuonTGC_Cabling::TGCCableASDToPP::TGCCableASDToPP ( const std::string & filename )

Definition at line 17 of file TGCCableASDToPP.cxx.

                                                          :
  TGCCable(TGCCable::ASDToPP),
  m_tgcCablingDbTool("TGCCablingDbTool") {
    initialize(filename);
}

◆ ~TGCCableASDToPP()

MuonTGC_Cabling::TGCCableASDToPP::~TGCCableASDToPP ( )

virtual

Definition at line 23 of file TGCCableASDToPP.cxx.

                                  {
  delete m_ASD2PP_DIFF_12;
  m_ASD2PP_DIFF_12 = nullptr;
}

◆ TGCCableASDToPP() [2/2]

MuonTGC_Cabling::TGCCableASDToPP::TGCCableASDToPP ( )

inlineprivate

Definition at line 33 of file TGCCableASDToPP.h.

33{}

Member Function Documentation

◆ getCableType()

CableType MuonTGC_Cabling::TGCCable::getCableType ( void ) const

inlineinherited

Definition at line 30 of file TGCCable.h.

30{ return m_type; }

MuonTGC_Cabling::TGCCable::m_type

CableType m_type

Definition TGCCable.h:43

◆ getChannel()

TGCChannelId * MuonTGC_Cabling::TGCCableASDToPP::getChannel	(	const TGCChannelId *	channelId,
		bool	orChannel = false ) const

virtual

Definition at line 250 of file TGCCableASDToPP.cxx.

                                            {
  if(channelId) {
    if(channelId->getChannelIdType()==TGCChannelId::ChannelIdType::ASDOut)
      return getChannelOut(channelId,orChannel);
    if(channelId->getChannelIdType()==TGCChannelId::ChannelIdType::PPIn)
      return getChannelIn(channelId,orChannel);
  }
  return nullptr;
}

◆ getChannelIn()

TGCChannelId * MuonTGC_Cabling::TGCCableASDToPP::getChannelIn	(	const TGCChannelId *	ppin,
		bool	orChannel = false ) const

privatevirtual

Reimplemented from MuonTGC_Cabling::TGCCable.

Definition at line 261 of file TGCCableASDToPP.cxx.

                                             {
  if(orChannel) return nullptr;
  if(ppin->isValid()==false) return nullptr;
  
  TGCDatabaseASDToPP* databaseP = 
    getDatabase(ppin->getSideType(),
        ppin->getRegionType(),
        ppin->getSector(),
        ppin->getModuleType());
  
  if(databaseP==nullptr) return nullptr;
 
  int indexOut[TGCDatabaseASDToPP::NIndexOut] = 
    {ppin->getId(), ppin->getBlock(), ppin->getChannel()};
  int i = databaseP->getIndexDBOut(indexOut);
  if(i<0) return nullptr;
 
  // ASD2PP.db is Backward connection  
  int layer = databaseP->getEntry(i,0);
  if(ppin->isStrip()) {
    if(!(ppin->isBackward())) {
      layer = s_stripForward[layer];
    }
  }
  int offset = (ppin->isWire()) ? 4 : 0;
  int channel = databaseP->getEntry(i,2+offset);
 
  // Endcap Triplet chamberId start from 1 in ASDOut
  int chamber = databaseP->getEntry(i,1);
  if(ppin->isEndcap() && ppin->isTriplet()) {
    chamber = chamber+1;
  }
  TGCChannelASDOut *asdout = new TGCChannelASDOut(ppin->getSideType(),
                          ppin->getSignalType(),
                          ppin->getRegionType(),
                          ppin->getSector(),
                          layer,
                          chamber,
                          channel);
  
  return asdout;
}

◆ getChannelOut()

TGCChannelId * MuonTGC_Cabling::TGCCableASDToPP::getChannelOut	(	const TGCChannelId *	asdout,
		bool	orChannel = false ) const

privatevirtual

Reimplemented from MuonTGC_Cabling::TGCCable.

Definition at line 305 of file TGCCableASDToPP.cxx.

                                               {
  if(orChannel) return nullptr;
  if(asdout->isValid()==false) return nullptr;
 
  const bool asdoutisStrip = asdout->isStrip();
  const bool asdoutisBackward = asdout->isBackward();
  const bool asdoutisEndcap = asdout->isEndcap();
  const bool asdoutisTriplet = asdout->isTriplet();
  const int asdoutLayer = asdout->getLayer();
  const int asdoutChamber = asdout->getChamber();
  const int asdoutChannel = asdout->getChannel();
 
  TGCDatabaseASDToPP* databaseP =
    getDatabase(asdout->getSideType(),
        asdout->getRegionType(),
        asdout->getSector(),
        asdout->getModuleType());
 
  if(databaseP==nullptr) return nullptr;
  
  TGCChannelPPIn* ppin = nullptr;
  const int MaxEntry = databaseP->getMaxEntry();
  for(int i=0; i<MaxEntry; i++) {
    // ASD2PP.db is Backward connection
    int layer = asdoutLayer;
    if(asdoutisStrip) {
      if(!asdoutisBackward) {
    layer = s_stripForward[layer];
      }
    }
    
    int elecChannel = asdoutChannel;
 
    // Endcap Triplet chamberId start from 1 in ASDOut
    int chamber = asdoutChamber;
    if(asdoutisEndcap&&asdoutisTriplet)
      chamber = chamber-1;
    int offset = (asdout->isWire())? 4 : 0;  
    if(databaseP->getEntry(i,0)==layer&&
       databaseP->getEntry(i,1)==chamber&&
       databaseP->getEntry(i,2+offset)==elecChannel)
      {
    int id = databaseP->getEntry(i,3);
    int block = databaseP->getEntry(i,4);
    int channel = databaseP->getEntry(i,5);
    
    ppin = new TGCChannelPPIn(asdout->getSideType(),
                  asdout->getModuleType(),
                  asdout->getRegionType(),
                  asdout->getSector(),
                  id,
                  block,
                  channel);
    break;
      } 
  }
  return ppin;
}

◆ getDatabase()

TGCDatabaseASDToPP * MuonTGC_Cabling::TGCCableASDToPP::getDatabase	(	const int	side,
		const int	region,
		const int	sector,
		const int	module ) const

private

Definition at line 187 of file TGCCableASDToPP.cxx.

{
  if(side<0 || side>=TGCId::MaxSideType) return nullptr;
  if(sector<0) return nullptr;
 
  TGCDatabaseASDToPP* db=nullptr;
  if(region==TGCId::Endcap) {
    switch(module) {
    case TGCId::WD :
      if(sector<TGCId::NUM_ENDCAP_SECTOR) db = m_EWDdb[side][sector].get();
      break;
    case TGCId::SD :
      if(sector<TGCId::NUM_ENDCAP_SECTOR) db = m_ESDdb[side][sector].get();
      break;
    case TGCId::WT :
      if(sector<TGCId::NUM_ENDCAP_SECTOR) db = m_EWTdb[side][sector].get();
      break;
    case TGCId::ST :
      if(sector<TGCId::NUM_ENDCAP_SECTOR) db = m_ESTdb[side][sector].get();
      break;
    case TGCId::WI :
      if(sector<TGCId::NUM_INNER_SECTOR) db = m_EWIdb[side][sector].get();
      break;
    case TGCId::SI :
      if(sector<TGCId::NUM_INNER_SECTOR) db = m_ESIdb[side][sector].get();
      break;
    default:
      break;
    }
  } else if(region==TGCId::Forward) {
    switch(module) {
    case TGCId::WD :
      if(sector<TGCId::NUM_FORWARD_SECTOR) db = m_FWDdb[side][sector].get();
      break;
    case TGCId::SD :
      if(sector<TGCId::NUM_FORWARD_SECTOR) db = m_FSDdb[side][sector].get();
      break;
    case TGCId::WT :
      if(sector<TGCId::NUM_FORWARD_SECTOR) db = m_FWTdb[side][sector].get();
      break;
    case TGCId::ST :
      if(sector<TGCId::NUM_FORWARD_SECTOR) db = m_FSTdb[side][sector].get();
      break;
    case TGCId::WI :
      if(sector<TGCId::NUM_INNER_SECTOR) db = m_FWIdb[side][sector].get();
      break;
    case TGCId::SI :
      if(sector<TGCId::NUM_INNER_SECTOR) db = m_FSIdb[side][sector].get();
      break;
    default:
      break;
    }
  }
  return db;
}

◆ getModuleIn()

virtual TGCModuleMap * MuonTGC_Cabling::TGCCable::getModuleIn ( const TGCModuleId * ) const

inlineprotectedvirtualinherited

Reimplemented in MuonTGC_Cabling::TGCCableHPBToSL, MuonTGC_Cabling::TGCCablePPToSLB, MuonTGC_Cabling::TGCCableSLBToHPB, MuonTGC_Cabling::TGCCableSLBToSSW, and MuonTGC_Cabling::TGCCableSSWToROD.

Definition at line 39 of file TGCCable.h.

39{ return 0; }

◆ getModuleOut()

virtual TGCModuleMap * MuonTGC_Cabling::TGCCable::getModuleOut ( const TGCModuleId * ) const

inlineprotectedvirtualinherited

Reimplemented in MuonTGC_Cabling::TGCCableHPBToSL, MuonTGC_Cabling::TGCCablePPToSLB, MuonTGC_Cabling::TGCCableSLBToHPB, MuonTGC_Cabling::TGCCableSLBToSSW, and MuonTGC_Cabling::TGCCableSSWToROD.

Definition at line 40 of file TGCCable.h.

40{ return 0; }

◆ getUpdateInfo()

StatusCode MuonTGC_Cabling::TGCCableASDToPP::getUpdateInfo	(	const int	side,
		const int	sector,
		const std::string &	blockname,
		std::vector< std::vector< int > > &	info )

private

Definition at line 127 of file TGCCableASDToPP.cxx.

{
  // clear info
  info.clear();
  
  std::vector<std::string>::const_iterator it   = m_ASD2PP_DIFF_12->begin();
  std::vector<std::string>::const_iterator it_e = m_ASD2PP_DIFF_12->end();
  int size = 0;
 
  // search block name
  while(it!=it_e) {
    const std::string &buf = (*it);
    ++it;
    char firstl = buf.at(0);
    if(firstl=='/'||firstl=='*') continue;
    if(buf.compare(0,blockname.size(),blockname)==0) {
      std::istringstream line(buf);
      std::string temp;
      line >> temp >> size;
      break;
    }
  }
  
  // loop over entries of specified block
  while(it!=it_e) {
    const std::string &buf = (*it);
    ++it;
    char firstl = buf.at(0);
    if(firstl=='/'||firstl=='*') continue;
    if(firstl=='E'||firstl=='F') break;
    std::istringstream line(buf);
    std::vector<int> entry;
    int  t_side, t_sector;
    line >> t_side;
    line >> t_sector;
    bool isOK = false;
    if((t_side==side) && (t_sector==sector)) { 
      for(int i=2; i<8; i++) {
    int temp=-1;
    if(line >> temp) { 
      entry.push_back(temp);
    } else {
      break;
    }
    isOK = (i==7);
      }
      if(isOK) {
    info.push_back(std::move(entry));
      }
    }
  }
 
  return StatusCode::SUCCESS;
}

◆ initialize()

void MuonTGC_Cabling::TGCCableASDToPP::initialize ( const std::string & filename )

private

Definition at line 29 of file TGCCableASDToPP.cxx.

                                                          {
  m_commonDb[TGCId::Forward][TGCId::WD] = std::make_shared<TGCDatabaseASDToPP>(filename, "FWD");
  m_commonDb[TGCId::Forward][TGCId::SD] = std::make_shared<TGCDatabaseASDToPP>(filename, "FSD");
  m_commonDb[TGCId::Forward][TGCId::WT] = std::make_shared<TGCDatabaseASDToPP>(filename, "FWT");
  m_commonDb[TGCId::Forward][TGCId::ST] = std::make_shared<TGCDatabaseASDToPP>(filename, "FST");
 
  m_commonDb[TGCId::Endcap][TGCId::WD] = std::make_shared<TGCDatabaseASDToPP>(filename, "EWD");
  m_commonDb[TGCId::Endcap][TGCId::SD] = std::make_shared<TGCDatabaseASDToPP>(filename, "ESD");
  m_commonDb[TGCId::Endcap][TGCId::WT] = std::make_shared<TGCDatabaseASDToPP>(filename, "EWT");
  m_commonDb[TGCId::Endcap][TGCId::ST] = std::make_shared<TGCDatabaseASDToPP>(filename, "EST");
 
  m_commonDb[TGCId::Forward][TGCId::WI] = std::make_shared<TGCDatabaseASDToPP>(filename, "FWI");
  m_commonDb[TGCId::Forward][TGCId::SI] = std::make_shared<TGCDatabaseASDToPP>(filename, "FSI");
  m_commonDb[TGCId::Endcap][TGCId::WI] = std::make_shared<TGCDatabaseASDToPP>(filename, "EWI");
  m_commonDb[TGCId::Endcap][TGCId::SI] = std::make_shared<TGCDatabaseASDToPP>(filename, "ESI");
 
  for(int side=0; side < TGCId::MaxSideType; side++) {
    for(int sector=0; sector < TGCId::NUM_FORWARD_SECTOR; sector++) {
      m_FWDdb[side][sector] = m_commonDb[TGCId::Forward][TGCId::WD];
      m_FSDdb[side][sector] = m_commonDb[TGCId::Forward][TGCId::SD];
      m_FWTdb[side][sector] = m_commonDb[TGCId::Forward][TGCId::WT];
      m_FSTdb[side][sector] = m_commonDb[TGCId::Forward][TGCId::ST];
    }
    for(int sector=0; sector < TGCId::NUM_ENDCAP_SECTOR; sector++) {
      m_EWDdb[side][sector] = m_commonDb[TGCId::Endcap][TGCId::WD];
      m_ESDdb[side][sector] = m_commonDb[TGCId::Endcap][TGCId::SD];
      m_EWTdb[side][sector] = m_commonDb[TGCId::Endcap][TGCId::WT];
      m_ESTdb[side][sector] = m_commonDb[TGCId::Endcap][TGCId::ST];
    }
    for(int sector=0; sector < TGCId::NUM_INNER_SECTOR; sector++) {
      m_FWIdb[side][sector] = m_commonDb[TGCId::Forward][TGCId::WI];
      m_FSIdb[side][sector] = m_commonDb[TGCId::Forward][TGCId::SI];
      m_EWIdb[side][sector] = m_commonDb[TGCId::Endcap][TGCId::WI];
      m_ESIdb[side][sector] = m_commonDb[TGCId::Endcap][TGCId::SI];
    } 
  } 
}

◆ updateDatabase()

StatusCode MuonTGC_Cabling::TGCCableASDToPP::updateDatabase ( )

Definition at line 68 of file TGCCableASDToPP.cxx.

                                           {
  if(m_tgcCablingDbTool.retrieve().isFailure()) return StatusCode::FAILURE;
 
  StatusCode sc = m_tgcCablingDbTool->readASD2PP_DIFF_12FromText();
  if(!sc.isSuccess()) {
    return StatusCode::SUCCESS;
  }
 
  std::vector<std::string> *tmp_ASD2PP_DIFF_12 = m_tgcCablingDbTool->giveASD2PP_DIFF_12();
  if(!tmp_ASD2PP_DIFF_12) return StatusCode::FAILURE;
 
  delete m_ASD2PP_DIFF_12;
  m_ASD2PP_DIFF_12 = new std::vector<std::string>;
  // Truncation saves initialization CPU time of about 30 ms.
  for (const std::string& s : *tmp_ASD2PP_DIFF_12) {
    char letter = s.at(0);
    if(letter=='/'||letter=='*') continue; 
    m_ASD2PP_DIFF_12->push_back(s);
  }
  delete tmp_ASD2PP_DIFF_12;
  tmp_ASD2PP_DIFF_12 = nullptr;
 
  for(int side=0; side<TGCId::MaxSideType; side++) { 
    for(int sector=0; sector<TGCId::NUM_FORWARD_SECTOR; sector++) { 
      StatusCode sc = updateIndividualDatabase(side, sector, "FWD", m_FWDdb[side][sector]);
      if(!sc.isSuccess()) return sc; 
 
      sc = updateIndividualDatabase(side, sector, "FSD", m_FSDdb[side][sector]); 
      if(!sc.isSuccess()) return sc; 
      sc = updateIndividualDatabase(side, sector, "FWT", m_FWTdb[side][sector]); 
      if(!sc.isSuccess()) return sc; 
      sc = updateIndividualDatabase(side, sector, "FST", m_FSTdb[side][sector]); 
      if(!sc.isSuccess()) return sc; 
    } 
    for(int sector=0; sector<TGCId::NUM_ENDCAP_SECTOR; sector++) { 
      StatusCode sc = updateIndividualDatabase(side, sector, "EWD", m_EWDdb[side][sector]); 
      if(!sc.isSuccess()) return sc; 
      sc = updateIndividualDatabase(side, sector, "ESD", m_ESDdb[side][sector]); 
      if(!sc.isSuccess()) return sc; 
      sc = updateIndividualDatabase(side, sector, "EWT", m_EWTdb[side][sector]); 
      if(!sc.isSuccess()) return sc; 
      sc = updateIndividualDatabase(side, sector, "EST", m_ESTdb[side][sector]); 
      if(!sc.isSuccess()) return sc; 
    } 
    for(int sector=0; sector<TGCId::NUM_INNER_SECTOR; sector++) { 
      StatusCode sc = updateIndividualDatabase(side, sector, "EWI", m_EWIdb[side][sector]); 
      if(!sc.isSuccess()) return sc; 
      sc = updateIndividualDatabase(side, sector, "ESI", m_ESIdb[side][sector]); 
      if(!sc.isSuccess()) return sc; 
      sc = updateIndividualDatabase(side, sector, "FWI", m_FWIdb[side][sector]); 
      if(!sc.isSuccess()) return sc; 
      sc = updateIndividualDatabase(side, sector, "FSI", m_FSIdb[side][sector]); 
      if(!sc.isSuccess()) return sc; 
    } 
  } 
 
  return StatusCode::SUCCESS;
}

◆ updateIndividualDatabase()

StatusCode MuonTGC_Cabling::TGCCableASDToPP::updateIndividualDatabase	(	const int	side,
		const int	sector,
		const std::string &	blockname,
		std::shared_ptr< TGCDatabaseASDToPP > &	database )

private

Definition at line 365 of file TGCCableASDToPP.cxx.

                                                                          {
  if (!database) return StatusCode::FAILURE;
  std::vector<std::vector<int>> info;
  StatusCode sc = getUpdateInfo(side, sector, blockname, info);
  if(!sc.isSuccess()) return sc;
 
  size_t info_size = info.size(); 
  if(!info_size) return StatusCode::SUCCESS; 
 
  if(database->isCommon()) {
    database.reset(new TGCDatabaseASDToPP(*database, false));  // false means this database is not commonly used.
    if(!database) return StatusCode::FAILURE;
  }
 
  for(size_t i=0; i<info_size; i++) { 
    database->update(info[i]);
  } 
 
  return StatusCode::SUCCESS;
} 

Member Data Documentation

◆ m_ASD2PP_DIFF_12

std::vector<std::string>* MuonTGC_Cabling::TGCCableASDToPP::m_ASD2PP_DIFF_12 {nullptr}

private

Definition at line 61 of file TGCCableASDToPP.h.

61{nullptr};

◆ m_commonDb

CommonDB MuonTGC_Cabling::TGCCableASDToPP::m_commonDb {{{nullptr}}}

private

Definition at line 84 of file TGCCableASDToPP.h.

84{{{nullptr}}};

◆ m_ESDdb

EndcapSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_ESDdb {}

private

Definition at line 76 of file TGCCableASDToPP.h.

76{};

◆ m_ESIdb

InnerSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_ESIdb {}

private

Definition at line 80 of file TGCCableASDToPP.h.

80{};

◆ m_ESTdb

EndcapSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_ESTdb {}

private

Definition at line 78 of file TGCCableASDToPP.h.

78{};

◆ m_EWDdb

EndcapSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_EWDdb {}

private

Definition at line 75 of file TGCCableASDToPP.h.

75{};

◆ m_EWIdb

InnerSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_EWIdb {}

private

Definition at line 79 of file TGCCableASDToPP.h.

79{};

◆ m_EWTdb

EndcapSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_EWTdb {}

private

Definition at line 77 of file TGCCableASDToPP.h.

77{};

◆ m_FSDdb

ForwardSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_FSDdb {}

private

Definition at line 69 of file TGCCableASDToPP.h.

69{};

◆ m_FSIdb

InnerSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_FSIdb {}

private

Definition at line 73 of file TGCCableASDToPP.h.

73{};

◆ m_FSTdb

ForwardSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_FSTdb {}

private

Definition at line 71 of file TGCCableASDToPP.h.

71{};

◆ m_FWDdb

ForwardSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_FWDdb {}

private

Definition at line 68 of file TGCCableASDToPP.h.

68{};

◆ m_FWIdb

InnerSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_FWIdb {}

private

Definition at line 72 of file TGCCableASDToPP.h.

72{};

◆ m_FWTdb

ForwardSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_FWTdb {}

private

Definition at line 70 of file TGCCableASDToPP.h.

70{};

◆ m_tgcCablingDbTool

ToolHandle<ITGCCablingDbTool> MuonTGC_Cabling::TGCCableASDToPP::m_tgcCablingDbTool

private

Definition at line 60 of file TGCCableASDToPP.h.

◆ m_type

CableType MuonTGC_Cabling::TGCCable::m_type

privateinherited

Definition at line 43 of file TGCCable.h.

◆ s_stripForward

const int MuonTGC_Cabling::TGCCableASDToPP::s_stripForward = {2,1,0,4,3,6,5,8,7}

staticprivate

Definition at line 58 of file TGCCableASDToPP.h.

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

Public Types

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ CommonDB

◆ EndcapSectorDB

◆ ForwardSectorDB

◆ InnerSectorDB

Member Enumeration Documentation

◆ CableType

Constructor & Destructor Documentation

◆ TGCCableASDToPP() [1/2]

◆ ~TGCCableASDToPP()

◆ TGCCableASDToPP() [2/2]

Member Function Documentation

◆ getCableType()

◆ getChannel()

◆ getChannelIn()

◆ getChannelOut()

◆ getDatabase()

◆ getModuleIn()

◆ getModuleOut()

◆ getUpdateInfo()

◆ initialize()

◆ updateDatabase()

◆ updateIndividualDatabase()

Member Data Documentation

◆ m_ASD2PP_DIFF_12

◆ m_commonDb

◆ m_ESDdb

◆ m_ESIdb

◆ m_ESTdb

◆ m_EWDdb

◆ m_EWIdb

◆ m_EWTdb

◆ m_FSDdb

◆ m_FSIdb

◆ m_FSTdb

◆ m_FWDdb

◆ m_FWIdb

◆ m_FWTdb

◆ m_tgcCablingDbTool

◆ m_type

◆ s_stripForward