MuonTGC_Cabling::TGCCableSLBToHPB Class Reference

#include <TGCCableSLBToHPB.h>

Inheritance diagram for MuonTGC_Cabling::TGCCableSLBToHPB:

Collaboration diagram for MuonTGC_Cabling::TGCCableSLBToHPB:

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

Public Member Functions
	TGCCableSLBToHPB (const std::string &filename)
virtual	~TGCCableSLBToHPB ()
virtual TGCChannelId *	getChannel (const TGCChannelId *channelId, bool orChannel=false) const
virtual TGCModuleMap *	getModule (const TGCModuleId *moduleId) const
TGCChannelId *	getChannelInforHPB (const TGCChannelId *hpbin, TGCId::ModuleType moduleType, bool orChannel=false) const
CableType	getCableType (void) const

Private Member Functions
	TGCCableSLBToHPB (void)=delete
virtual TGCChannelId *	getChannelIn (const TGCChannelId *hpbin, bool orChannel=false) const
virtual TGCChannelId *	getChannelOut (const TGCChannelId *slbout, bool orChannel=false) const
virtual TGCModuleMap *	getModuleIn (const TGCModuleId *hpb) const
virtual TGCModuleMap *	getModuleInforHPB (const TGCModuleId *hpb, TGCId::ModuleType moduleType) const
virtual TGCModuleMap *	getModuleOut (const TGCModuleId *slb) const

Private Attributes
std::array< std::array< std::unique_ptr< TGCDatabase >, TGCId::MaxModuleType >, TGCId::MaxRegionType >	m_database
CableType	m_type

Detailed Description

Definition at line 18 of file TGCCableSLBToHPB.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

TGCCableSLBToHPB() [1/2]

MuonTGC_Cabling::TGCCableSLBToHPB::TGCCableSLBToHPB

(

const std::string &

filename

)

Definition at line 15 of file TGCCableSLBToHPB.cxx.

  : TGCCable(TGCCable::SLBToHPB),
    m_database{{{nullptr}}}
{
  m_database[TGCId::Endcap][TGCId::WT] = std::make_unique<TGCDatabasePPToSL>(filename,"SB EWT");
  m_database[TGCId::Endcap][TGCId::WD] = std::make_unique<TGCDatabasePPToSL>(filename,"SB EWD");
  m_database[TGCId::Endcap][TGCId::ST] = std::make_unique<TGCDatabasePPToSL>(filename,"SB EST");
  m_database[TGCId::Endcap][TGCId::SD] = std::make_unique<TGCDatabasePPToSL>(filename,"SB ESD");
  m_database[TGCId::Forward][TGCId::WT] = std::make_unique<TGCDatabasePPToSL>(filename,"SB FWT");
  m_database[TGCId::Forward][TGCId::WD] = std::make_unique<TGCDatabasePPToSL>(filename,"SB FWD");
  m_database[TGCId::Forward][TGCId::ST] = std::make_unique<TGCDatabasePPToSL>(filename,"SB FST");
  m_database[TGCId::Forward][TGCId::SD] = std::make_unique<TGCDatabasePPToSL>(filename,"SB FSD");
}

~TGCCableSLBToHPB()

MuonTGC_Cabling::TGCCableSLBToHPB::~TGCCableSLBToHPB ( )

virtualdefault

TGCCableSLBToHPB() [2/2]

MuonTGC_Cabling::TGCCableSLBToHPB::TGCCableSLBToHPB ( void )

privatedelete

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::TGCCableSLBToHPB::getChannel ( const TGCChannelId * channelId, bool orChannel = false ) const

virtual

Definition at line 31 of file TGCCableSLBToHPB.cxx.

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

getChannelIn()

TGCChannelId * MuonTGC_Cabling::TGCCableSLBToHPB::getChannelIn ( const TGCChannelId * hpbin, bool orChannel = false ) const

privatevirtual

Reimplemented from MuonTGC_Cabling::TGCCable.

Definition at line 52 of file TGCCableSLBToHPB.cxx.

                                               {
  if(orChannel) return nullptr;
  if(hpbin->isValid()==false) return nullptr;
  TGCChannelSLBOut* slbout = nullptr;
 
  // HPB module
  TGCModuleId* hpb = hpbin->getModule();
  if(!hpb) return nullptr;
  
  // HPB -> SLB module connection
  TGCModuleMap* mapId = getModule(hpb);
  delete hpb;
  if(!mapId) return nullptr;
  
  int numOfBlock = TGCChannelSLBOut::getNumberOfBlock(TGCId::WD);//SD
  if(numOfBlock==0) {
    delete mapId;
    mapId = nullptr;
    return nullptr;
  }
 
  int chInBlock = TGCChannelSLBOut::getChannelInBlock(TGCId::WD);//SD
  int slbInBlock = TGCChannelHPBIn::getSlbInBlock();
 
  // SLB module
  TGCModuleId* slb = nullptr;
  int blockInHPB = hpbin->getBlock();
  int nSlb       = hpbin->getChannel()/(numOfBlock*2); // half block
  int port       = blockInHPB*slbInBlock+nSlb;
  const int size = mapId->size();
  for(int i=0;i<size;i++){
    if(mapId->connector(i)==port){
      slb = mapId->popModuleId(i);
      break;
    }
  }
  
  delete mapId;
  if(!slb) return nullptr;
  
  // HPB ->SLB channel connection
  int nInSlb     = hpbin->getChannel()/(numOfBlock*2); // half block
  int blockInSlb = nInSlb/2;
  int nInBlock   = nInSlb%2;
  int channel    = (chInBlock/2)*nInBlock;
  
  slbout = new TGCChannelSLBOut(slb->getSideType(),
                slb->getModuleType(),
                slb->getRegionType(),
                slb->getSector(),
                slb->getId(),
                blockInSlb,
                channel);
  
  delete slb;
  return slbout;
}

getChannelInforHPB()

TGCChannelId * MuonTGC_Cabling::TGCCableSLBToHPB::getChannelInforHPB	(	const TGCChannelId *	hpbin,
		TGCId::ModuleType	moduleType,
		bool	orChannel = false ) const

Definition at line 111 of file TGCCableSLBToHPB.cxx.

{
  if(orChannel) return nullptr;
  if(hpbin->isValid()==false) return nullptr;
 
  TGCChannelSLBOut* slbout = nullptr;
 
  // HPB module
  TGCModuleId* hpb = hpbin->getModule();//This function is defined in TGCChannelHPBIn
                                        //set current SideType,SignalType... 
                                        //ChannelID(HPBIn) is set in HPBIn constructor
  if(!hpb) return nullptr;
 
  // HPB -> SLB module connection
  TGCModuleMap* mapId = getModuleInforHPB(hpb,moduleType);
  delete hpb;
  if(!mapId) return nullptr;
  
  // need to check
  int numOfBlock = TGCChannelSLBOut::getNumberOfBlock(moduleType);
  if(numOfBlock==0) {
    delete mapId;
    mapId = nullptr;
    return nullptr;
  }
 
  int chInBlock = TGCChannelSLBOut::getChannelInBlock(moduleType);
  int slbInBlock = 0;
    
  // SLB module
  TGCModuleId* slb = nullptr;
  int blockInHPB = 0;
  int nSlb = 0; // half block
  int port = 0; // input position for HPT
 
  // HPB ->SLB channel connection
  int blockInSlb = 0;
  int posInHpb = 0;
  int channel = 0;
  int size = 0;
  switch(moduleType){
 
  case TGCId::WD:
  case TGCId::SD:
    slbInBlock = 3;    
    blockInHPB = hpbin->getBlock();
    nSlb = hpbin->getChannel()/(numOfBlock*2);
    port = blockInHPB*slbInBlock+nSlb;
    size = mapId->size(); 
    for(int i=0;i<size;i++){
      if(mapId->connector(i)==port){
    slb = mapId->popModuleId(i);
    break;
      }
    }
    blockInSlb = (hpbin->getChannel() - nSlb*(numOfBlock*2))/2;
    posInHpb = (hpbin->getChannel() - (numOfBlock*2)*nSlb)%2;
    channel    = (chInBlock/2)*posInHpb;
    break;
  
  case TGCId::WT:
    slbInBlock = 2;
    blockInHPB = hpbin->getBlock();
    nSlb = hpbin->getChannel()/(numOfBlock*2);
    port = blockInHPB*slbInBlock+nSlb;
    size = mapId->size();
    for(int i=0;i<size;i++){
      if(mapId->connector(i)== -1*port){//triplet: - sign
    slb = mapId->popModuleId(i);
    break;
      }
    }
    blockInSlb = (hpbin->getChannel() - nSlb*(numOfBlock*2))/2;
    posInHpb = (hpbin->getChannel() - (numOfBlock*2)*nSlb)%2;
    channel    = (chInBlock/2)*posInHpb;
    break;
 
  case TGCId::ST:
    blockInHPB = hpbin->getBlock();
    if(blockInHPB==0 && hpbin->getChannel()<numOfBlock) port=1;
    else port=2;
    size = mapId->size();
    for(int i=0;i<size;i++){
      if(mapId->connector(i)== -1*port){//triplet: - sign
    slb = mapId->popModuleId(i);
    break;
      }
    }
    blockInSlb = (hpbin->getChannel())%numOfBlock;
    if(blockInHPB == 1 && hpbin->getChannel() >= numOfBlock) blockInSlb = blockInSlb + numOfBlock/2;
    channel = 0;
    break;
 
  default:
    break;
 
  }
 
  delete mapId; mapId = nullptr;
  if(!slb) return nullptr;
 
  const int offset =6; // offset to get center of block
  channel += offset;
 
  int SLBID = slb->getId();
  if((chInBlock*blockInSlb+channel)>chInBlock*numOfBlock){
    SLBID++;
    channel = channel%chInBlock;
    blockInSlb = 0;
  } else if( channel > chInBlock){
    channel = channel%chInBlock;
    blockInSlb++;
  }
 
  slbout = new TGCChannelSLBOut(slb->getSideType(),
                moduleType,
                slb->getRegionType(),
                slb->getSector(),
                SLBID,
                blockInSlb,
                channel );
 
  delete slb;
  return slbout;
}

getChannelOut()

TGCChannelId * MuonTGC_Cabling::TGCCableSLBToHPB::getChannelOut ( const TGCChannelId * slbout, bool orChannel = false ) const

privatevirtual

Reimplemented from MuonTGC_Cabling::TGCCable.

Definition at line 240 of file TGCCableSLBToHPB.cxx.

                                                {
  if(orChannel) return nullptr;
  if(slbout->isValid()==false) return nullptr;
  if(slbout->getMultipletType()==TGCId::Triplet) return nullptr;
  TGCChannelHPBIn* hpbin = nullptr;
  
  // SLB module
  TGCModuleId* slb = slbout->getModule();
  if(!slb) return nullptr;
  
  // SLB -> HPB module connection
  TGCModuleMap* mapId = getModule(slb);
  delete slb;
  if(!mapId) return nullptr;
  
  // HPB module
  int port = mapId->connector(0);
  TGCModuleId* hpb = mapId->popModuleId(0);
  delete mapId;
  if(!hpb) return nullptr;
 
  int chInBlock = TGCChannelSLBOut::getChannelInBlock(slbout->getModuleType());
  if(chInBlock<=1) {
    delete hpb;
    hpb = nullptr;
    return nullptr;
  }
  int slbInBlock = TGCChannelHPBIn::getSlbInBlock();
 
  // SLB ->HPB channel connection
  int block   = port/slbInBlock;
  int hitId   = (port%slbInBlock)*2+slbout->getBlock();
  int pos     = slbout->getChannel()/(chInBlock/2);
  int channel = hitId*2 + pos;
 
  hpbin = new TGCChannelHPBIn(hpb->getSideType(),
                              hpb->getSignalType(),
                              hpb->getRegionType(),
                              hpb->getSector(),
                              hpb->getId(),
                  block,
                              channel);
  delete hpb;
 
  return hpbin;
}

getModule()

TGCModuleMap * MuonTGC_Cabling::TGCCableSLBToHPB::getModule ( const TGCModuleId * moduleId ) const

virtual

Definition at line 42 of file TGCCableSLBToHPB.cxx.

                                                                           {
  if(moduleId){
    if(moduleId->getModuleIdType()==TGCModuleId::SLB)
      return getModuleOut(moduleId);
    if(moduleId->getModuleIdType()==TGCModuleId::HPB)
      return getModuleIn(moduleId);
  }
  return nullptr;
}

getModuleIn()

TGCModuleMap * MuonTGC_Cabling::TGCCableSLBToHPB::getModuleIn ( const TGCModuleId * hpb ) const

privatevirtual

Reimplemented from MuonTGC_Cabling::TGCCable.

Definition at line 288 of file TGCCableSLBToHPB.cxx.

                                                                        {
  if(hpb->isValid()==false) return nullptr;
  const int hpbId = hpb->getId();
 
  TGCId::ModuleType doublet=TGCId::NoModuleType;
  TGCId::ModuleType triplet=TGCId::NoModuleType;
  if(hpb->getSignalType()==TGCId::Wire){
    doublet = TGCId::WD;
    triplet = TGCId::WT;
  }
  if(hpb->getSignalType()==TGCId::Strip){
    doublet = TGCId::SD;
    triplet = TGCId::ST;
  }
 
  if(doublet==TGCId::NoModuleType || triplet==TGCId::NoModuleType) { 
    return nullptr;
  }
  
  TGCDatabase* doubletP = m_database[hpb->getRegionType()][doublet].get();
  TGCDatabase* tripletP = m_database[hpb->getRegionType()][triplet].get();
  
  TGCModuleMap* mapId = nullptr;
  const int doubletMaxEntry = doubletP->getMaxEntry();
  for(int i=0; i<doubletMaxEntry; i++){
    if(doubletP->getEntry(i,1)==hpbId)
      {
    int id = doubletP->getEntry(i,0);
    int block = doubletP->getEntry(i,2);
    TGCModuleSLB* slb = new TGCModuleSLB(hpb->getSideType(),
                         doublet,
                         hpb->getRegionType(),
                         hpb->getSector(),
                         id);
    if(mapId==nullptr) mapId = new TGCModuleMap();
    mapId->insert(block,slb);
      } 
  }
  const int tripletMaxEntry = tripletP->getMaxEntry();
  for(int i=0; i<tripletMaxEntry; i++){
    if(tripletP->getEntry(i,1)==hpbId)
      {
    int id = tripletP->getEntry(i,0);
    int block = -tripletP->getEntry(i,2);
    TGCModuleSLB* slb = new TGCModuleSLB(hpb->getSideType(),
                         triplet,
                         hpb->getRegionType(),
                         hpb->getSector(),
                         id);
    if(mapId==nullptr) mapId = new TGCModuleMap();
    mapId->insert(block,slb);
      } 
  }
  
  return mapId;
}

getModuleInforHPB()

TGCModuleMap * MuonTGC_Cabling::TGCCableSLBToHPB::getModuleInforHPB ( const TGCModuleId * hpb, TGCId::ModuleType moduleType ) const

privatevirtual

Definition at line 345 of file TGCCableSLBToHPB.cxx.

                                                            {
  if(hpb->isValid()==false) return nullptr;
 
  const int hpbId = hpb->getId();
 
  TGCDatabase* databaseP = m_database[hpb->getRegionType()][moduleType].get();
 
  TGCModuleMap* mapId = nullptr;
  const int MaxEntry = databaseP->getMaxEntry();
  for(int i=0; i<MaxEntry; i++){
    if(databaseP->getEntry(i,1)==hpbId)
      {
    int id = databaseP->getEntry(i,0);
    int block = -100;
    switch(moduleType){
    case TGCId::WD:
    case TGCId::SD:
    block = databaseP->getEntry(i,2);
    break;
 
    case TGCId::WT:
    case TGCId::ST:
    block = -1*databaseP->getEntry(i,2);// check - sign
    break;
 
    default:
    break;
    }
    TGCModuleSLB* slb = new TGCModuleSLB(hpb->getSideType(),
                         moduleType,
                         hpb->getRegionType(),
                         hpb->getSector(),
                         id);
    if(mapId==nullptr) mapId = new TGCModuleMap();
    mapId->insert(block,slb);
      } 
  }
  
  return mapId;
}

getModuleOut()

TGCModuleMap * MuonTGC_Cabling::TGCCableSLBToHPB::getModuleOut ( const TGCModuleId * slb ) const

privatevirtual

Reimplemented from MuonTGC_Cabling::TGCCable.

Definition at line 387 of file TGCCableSLBToHPB.cxx.

                                                                         {
  if(slb->isValid()==false) return nullptr;
 
  const int slbId = slb->getId();
 
  TGCDatabase* databaseP =m_database[slb->getRegionType()][slb->getModuleType()].get();
  
  TGCModuleMap* mapId = nullptr;
  const int MaxEntry = databaseP->getMaxEntry();
  for(int i=0; i<MaxEntry; i++){
    if(databaseP->getEntry(i,0)==slbId) {
    int id = databaseP->getEntry(i,1);
    int block = databaseP->getEntry(i,2);
    if(slb->getMultipletType()==TGCId::Triplet) 
      block *=-1;
 
    TGCModuleHPB* hpb = new TGCModuleHPB(slb->getSideType(),
                         slb->getSignalType(),
                         slb->getRegionType(),
                         slb->getSector(),
                         id);
 
      mapId = new TGCModuleMap();
      mapId->insert(block,hpb);
      break;
    } 
  }
 
  return mapId;
}

Member Data Documentation

m_database

std::array<std::array<std::unique_ptr<TGCDatabase>, TGCId::MaxModuleType>, TGCId::MaxRegionType> MuonTGC_Cabling::TGCCableSLBToHPB::m_database

private

Definition at line 41 of file TGCCableSLBToHPB.h.

m_type

CableType MuonTGC_Cabling::TGCCable::m_type

privateinherited

Definition at line 43 of file TGCCable.h.

---

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

• TGCCableSLBToHPB.h
• TGCCableSLBToHPB.cxx