MuonTGC_Cabling::TGCCableASDToPP Class Reference

#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. More...

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.

{}

Member Function Documentation

getCableType()

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

inlineinherited

Definition at line 30 of file TGCCable.h.

{ return m_type; }

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::TGCCableSLBToSSW, MuonTGC_Cabling::TGCCablePPToSLB, MuonTGC_Cabling::TGCCableHPBToSL, MuonTGC_Cabling::TGCCableSSWToROD, and MuonTGC_Cabling::TGCCableSLBToHPB.

Definition at line 39 of file TGCCable.h.

{ return 0; }

getModuleOut()

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

inlineprotectedvirtualinherited

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

Definition at line 40 of file TGCCable.h.

{ 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(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.

m_commonDb

CommonDB MuonTGC_Cabling::TGCCableASDToPP::m_commonDb {nullptr}

private

Definition at line 84 of file TGCCableASDToPP.h.

m_ESDdb

EndcapSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_ESDdb {}

private

Definition at line 76 of file TGCCableASDToPP.h.

m_ESIdb

InnerSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_ESIdb {}

private

Definition at line 80 of file TGCCableASDToPP.h.

m_ESTdb

EndcapSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_ESTdb {}

private

Definition at line 78 of file TGCCableASDToPP.h.

m_EWDdb

EndcapSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_EWDdb {}

private

Definition at line 75 of file TGCCableASDToPP.h.

m_EWIdb

InnerSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_EWIdb {}

private

Definition at line 79 of file TGCCableASDToPP.h.

m_EWTdb

EndcapSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_EWTdb {}

private

Definition at line 77 of file TGCCableASDToPP.h.

m_FSDdb

ForwardSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_FSDdb {}

private

Definition at line 69 of file TGCCableASDToPP.h.

m_FSIdb

InnerSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_FSIdb {}

private

Definition at line 73 of file TGCCableASDToPP.h.

m_FSTdb

ForwardSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_FSTdb {}

private

Definition at line 71 of file TGCCableASDToPP.h.

m_FWDdb

ForwardSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_FWDdb {}

private

Definition at line 68 of file TGCCableASDToPP.h.

m_FWIdb

InnerSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_FWIdb {}

private

Definition at line 72 of file TGCCableASDToPP.h.

m_FWTdb

ForwardSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_FWTdb {}

private

Definition at line 70 of file TGCCableASDToPP.h.

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:

• TGCCableASDToPP.h
• TGCCableASDToPP.cxx