#include <TGCCableSLBToSSW.h>

Inheritance diagram for MuonTGC_Cabling::TGCCableSLBToSSW:

Collaboration diagram for MuonTGC_Cabling::TGCCableSLBToSSW:

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

Public Member Functions
	TGCCableSLBToSSW (const std::string &filename)
virtual	~TGCCableSLBToSSW ()=default
virtual TGCModuleMap *	getModule (const TGCModuleId *moduleId) const
CableType	getCableType (void) const

Protected Member Functions
virtual TGCChannelId *	getChannelIn (const TGCChannelId *, bool) const
virtual TGCChannelId *	getChannelOut (const TGCChannelId *, bool) const

Private Member Functions
	TGCCableSLBToSSW ()
virtual TGCModuleMap *	getModuleIn (const TGCModuleId *ssw) const
virtual TGCModuleMap *	getModuleOut (const TGCModuleId *slb) const

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

Detailed Description

Definition at line 18 of file TGCCableSLBToSSW.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

Enumerator
SL
MaxModuleType

Definition at line 20 of file TGCCableSLBToSSW.h.

       {
    SL            = TGCId::MaxModuleType, 
    MaxModuleType = TGCId::MaxModuleType + 1
  };

◆ 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

◆ TGCCableSLBToSSW() [1/2]

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

Definition at line 13 of file TGCCableSLBToSSW.cxx.

  : TGCCable(TGCCable::SLBToSSW)
{
  m_database[TGCId::Endcap][TGCId::WT] = std::make_unique<TGCDatabaseSLBToROD>(filename, "SLB EWT");
  m_database[TGCId::Endcap][TGCId::WD] = std::make_unique<TGCDatabaseSLBToROD>(filename, "SLB EWD");
  m_database[TGCId::Endcap][TGCId::ST] = std::make_unique<TGCDatabaseSLBToROD>(filename, "SLB EST");
  m_database[TGCId::Endcap][TGCId::SD] = std::make_unique<TGCDatabaseSLBToROD>(filename, "SLB ESD");
  m_database[TGCId::Endcap][TGCId::WI] = std::make_unique<TGCDatabaseSLBToROD>(filename, "SLB EWI");
  m_database[TGCId::Endcap][TGCId::SI] = std::make_unique<TGCDatabaseSLBToROD>(filename, "SLB ESI");
  m_database[TGCId::Endcap][SL] = std::make_unique<TGCDatabaseSLBToROD>(filename, "SLB ESL");
 
  m_database[TGCId::Forward][TGCId::WT] = std::make_unique<TGCDatabaseSLBToROD>(filename, "SLB FWT");
  m_database[TGCId::Forward][TGCId::WD] = std::make_unique<TGCDatabaseSLBToROD>(filename, "SLB FWD");
  m_database[TGCId::Forward][TGCId::ST] = std::make_unique<TGCDatabaseSLBToROD>(filename, "SLB FST");
  m_database[TGCId::Forward][TGCId::SD] = std::make_unique<TGCDatabaseSLBToROD>(filename, "SLB FSD");
  m_database[TGCId::Forward][TGCId::WI] = std::make_unique<TGCDatabaseSLBToROD>(filename, "SLB FWI");
  m_database[TGCId::Forward][TGCId::SI] = std::make_unique<TGCDatabaseSLBToROD>(filename, "SLB FSI");
  m_database[TGCId::Forward][SL] = std::make_unique<TGCDatabaseSLBToROD>(filename, "SLB FSL");
}

◆ ~TGCCableSLBToSSW()

virtual MuonTGC_Cabling::TGCCableSLBToSSW::~TGCCableSLBToSSW ( )

virtualdefault

◆ TGCCableSLBToSSW() [2/2]

MuonTGC_Cabling::TGCCableSLBToSSW::TGCCableSLBToSSW ( )

inlineprivate

Definition at line 31 of file TGCCableSLBToSSW.h.

31{}

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

◆ getChannelIn()

virtual TGCChannelId * MuonTGC_Cabling::TGCCable::getChannelIn	(	const TGCChannelId *	,
		bool	) const

inlineprotectedvirtualinherited

Reimplemented in MuonTGC_Cabling::TGCCableASDToPP, MuonTGC_Cabling::TGCCableInASD, MuonTGC_Cabling::TGCCableInPP, MuonTGC_Cabling::TGCCableInSLB, MuonTGC_Cabling::TGCCablePPToSLB, and MuonTGC_Cabling::TGCCableSLBToHPB.

Definition at line 34 of file TGCCable.h.

35 { return 0; }

◆ getChannelOut()

virtual TGCChannelId * MuonTGC_Cabling::TGCCable::getChannelOut	(	const TGCChannelId *	,
		bool	) const

inlineprotectedvirtualinherited

Reimplemented in MuonTGC_Cabling::TGCCableASDToPP, MuonTGC_Cabling::TGCCableInASD, MuonTGC_Cabling::TGCCableInPP, MuonTGC_Cabling::TGCCableInSLB, MuonTGC_Cabling::TGCCablePPToSLB, and MuonTGC_Cabling::TGCCableSLBToHPB.

Definition at line 36 of file TGCCable.h.

37 { return 0; }

◆ getModule()

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

virtual

Definition at line 33 of file TGCCableSLBToSSW.cxx.

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

◆ getModuleIn()

TGCModuleMap * MuonTGC_Cabling::TGCCableSLBToSSW::getModuleIn ( const TGCModuleId * ssw ) const

privatevirtual

Reimplemented from MuonTGC_Cabling::TGCCable.

Definition at line 43 of file TGCCableSLBToSSW.cxx.

                                                                        {
  if(ssw->isValid()==false) return nullptr;
 
  const int sswId = ssw->getId();
 
  TGCDatabase* databaseP[TGCId::MaxRegionType * MaxModuleType];
  TGCId::ModuleType module[TGCId::MaxRegionType * MaxModuleType];
  TGCId::RegionType region[TGCId::MaxRegionType * MaxModuleType];
  for(int i=0; i<TGCId::MaxRegionType; i++){
    for(int j=0; j< MaxModuleType; j++){
      databaseP[i*MaxModuleType + j] = m_database[i][j].get();
      region[i*MaxModuleType + j] = static_cast<TGCId::RegionType>(i);
      module[i*MaxModuleType + j] = static_cast<TGCId::ModuleType>(j);
    }
  }
 
  TGCModuleMap* mapId = nullptr;
  for(int type=0; type<TGCId::MaxRegionType* MaxModuleType; type++){
    const int MaxEntry = databaseP[type]->getMaxEntry();
    for(int i=0; i<MaxEntry; i++){
 
      if(databaseP[type]->getEntry(i,4) == sswId) {
    int sector = databaseP[type]->getEntry(i,0);
 
    // Inner
    if(module[type]==TGCId::WI) {
      // EI/FI 
          //  wire(TGCId::WI) and strip(TGCId::SI) of a chamber
          //  use the same SLB chip             
 
      int sswSector = ssw->getReadoutSector();
          // one ROD (rodId = 2,5,8,11) covers 6 Inner sectors
      if(sswSector %3 != 1) continue;
          sswSector -= 1;
 
      sector += sswSector*2;
      int id = databaseP[type]->getEntry(i,1);
      int block = databaseP[type]->getEntry(i,5);
      int sbLoc = databaseP[type]->getEntry(i,2);
          int slbAddr = databaseP[type]->getEntry(i,3);
      for(int ip= 0; ip<3 ; ip++){ 
        int psector  = sector  + ip*2;
        int pblock   = block   + ip*4;
        int psbLoc   = sbLoc   + ip*4;        
            int pslbAddr = slbAddr + ip*2;
        TGCModuleSLB* slb = new TGCModuleSLB(ssw->getSideType(),
                         module[type],
                         region[type],
                         psector,
                         id,
                         psbLoc,
                         pslbAddr);
      
        if(mapId==nullptr) mapId = new TGCModuleMap();
        mapId->insert(pblock,slb);
      }
 
    } else if(module[type]==TGCId::SI) {
      // EI/FI 
          //  wire(TGCId::WI) and strip(TGCId::SI) of a chamber
          //  use the same SLB chip             
 
      // do nothing
          
    } else {
      if(region[type]==TGCId::Endcap) {
        sector += ssw->getReadoutSector() * (TGCId::NUM_ENDCAP_SECTOR/TGCId::N_RODS);
      } else {
        sector += ssw->getReadoutSector() * (TGCId::NUM_FORWARD_SECTOR/TGCId::N_RODS);
      }
      int id = databaseP[type]->getEntry(i,1);
      int sbLoc = databaseP[type]->getEntry(i,2);
          int slbAddr = databaseP[type]->getEntry(i,3);
      int block = databaseP[type]->getEntry(i,5);
      TGCModuleSLB* slb = new TGCModuleSLB(ssw->getSideType(),
                           module[type],
                           region[type],
                           sector,
                           id,
                           sbLoc,
                           slbAddr);
      
      if(mapId==nullptr) mapId = new TGCModuleMap();
      mapId->insert(block,slb);
    } 
 
      }
    }
  }
 
  return mapId;
}

◆ getModuleOut()

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

privatevirtual

Reimplemented from MuonTGC_Cabling::TGCCable.

Definition at line 137 of file TGCCableSLBToSSW.cxx.

                                                                         {
  if(slb->isValid()==false) return nullptr;
 
  const int slbId = slb->getId();
  const int sector = slb->getSectorInReadout();
  int readoutSector = slb->getReadoutSector();
  
  TGCModuleMap* mapId = nullptr;
 
  TGCDatabase* databaseP =m_database[slb->getRegionType()][slb->getModuleType()].get();
  const int MaxEntry = databaseP->getMaxEntry();
  if(slb->getModuleType() == TGCId::WI ||
     slb->getModuleType() == TGCId::SI) {
    // inner 
    for(int i=0; i<MaxEntry; i++){
      if(databaseP->getEntry(i,0)==sector &&
     databaseP->getEntry(i,1)==slbId) {
    
        int sswSectorRO =   readoutSector - (readoutSector%3) + 1;
    int id = databaseP->getEntry(i,4);
    int block = databaseP->getEntry(i,5) + 4*(readoutSector%3);
        
    TGCModuleSSW* ssw = new TGCModuleSSW(slb->getSideType(),
                         sswSectorRO,
                         id);
        mapId = new TGCModuleMap();
        mapId->insert(block,ssw);
    break;
      } 
    }
    
  } else { 
    for(int i=0; i<MaxEntry; i++){
      if(databaseP->getEntry(i,0)==sector&&
     databaseP->getEntry(i,1)==slbId) {
    
    int id = databaseP->getEntry(i,4);
    int block = databaseP->getEntry(i,5);
    TGCModuleSSW* ssw = new TGCModuleSSW(slb->getSideType(),
                         readoutSector,
                         id);
        mapId = new TGCModuleMap();
        mapId->insert(block,ssw);
    break;
      } 
    }
 
  }
  return mapId;
}

Member Data Documentation

◆ m_database

std::array<std::array<std::unique_ptr<TGCDatabase>, MaxModuleType>, TGCId::MaxRegionType> MuonTGC_Cabling::TGCCableSLBToSSW::m_database {{{nullptr}}}

private

Definition at line 34 of file TGCCableSLBToSSW.h.

34{{{nullptr}}};

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

Public Types

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes