MuonTGC_Cabling::TGCCablePPToSLB Class Reference

#include <TGCCablePPToSLB.h>

Inheritance diagram for MuonTGC_Cabling::TGCCablePPToSLB:

Collaboration diagram for MuonTGC_Cabling::TGCCablePPToSLB:

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

Public Member Functions
	TGCCablePPToSLB (const std::string &filename)
virtual	~TGCCablePPToSLB ()
std::unique_ptr< TGCChannelId >	getChannel (const TGCChannelId &channelId, bool orChannel=false) const
TGCModuleMap	getModule (const TGCModuleId &moduleId) const
CableType	getCableType () const

Private Member Functions
	TGCCablePPToSLB ()=delete
std::unique_ptr< TGCChannelId >	getChannelIn (const TGCChannelId &slbin, bool orChannel=false) const
std::unique_ptr< TGCChannelId >	getChannelOut (const TGCChannelId &ppout, bool orChannel=false) const
TGCModuleMap	getModuleIn (const TGCModuleId &slb) const
TGCModuleMap	getModuleOut (const TGCModuleId &pp) const

Private Attributes
std::array< std::array< std::unique_ptr< TGCDatabase >,+TGCId::ModuleType::MaxModuleType >,+TGCId::RegionType::MaxRegionType >	m_database
CableType	m_type {CableType::NoCableType}

Detailed Description

Definition at line 18 of file TGCCablePPToSLB.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 16 of file TGCCable.h.

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

Constructor & Destructor Documentation

TGCCablePPToSLB() [1/2]

MuonTGC_Cabling::TGCCablePPToSLB::TGCCablePPToSLB

(

const std::string &

filename

)

Definition at line 16 of file TGCCablePPToSLB.cxx.

    : TGCCable(TGCCable::PPToSLB), m_database{{{nullptr}}} {
    m_database.at(+TGCId::RegionType::Endcap).at(+TGCId::ModuleType::WT) =
        std::make_unique<TGCDatabasePPToSL>(filename, "PP EWT");
    m_database.at(+TGCId::RegionType::Endcap).at(+TGCId::ModuleType::WD) =
        std::make_unique<TGCDatabasePPToSL>(filename, "PP EWD");
    m_database.at(+TGCId::RegionType::Endcap).at(+TGCId::ModuleType::ST) =
        std::make_unique<TGCDatabasePPToSL>(filename, "PP EST");
    m_database.at(+TGCId::RegionType::Endcap).at(+TGCId::ModuleType::SD) =
        std::make_unique<TGCDatabasePPToSL>(filename, "PP ESD");
    m_database.at(+TGCId::RegionType::Endcap).at(+TGCId::ModuleType::WI) =
        std::make_unique<TGCDatabasePPToSL>(filename, "PP EWI");
    m_database.at(+TGCId::RegionType::Endcap).at(+TGCId::ModuleType::SI) =
        std::make_unique<TGCDatabasePPToSL>(filename, "PP ESI");
    m_database.at(+TGCId::RegionType::Forward).at(+TGCId::ModuleType::WT) =
        std::make_unique<TGCDatabasePPToSL>(filename, "PP FWT");
    m_database.at(+TGCId::RegionType::Forward).at(+TGCId::ModuleType::WD) =
        std::make_unique<TGCDatabasePPToSL>(filename, "PP FWD");
    m_database.at(+TGCId::RegionType::Forward).at(+TGCId::ModuleType::ST) =
        std::make_unique<TGCDatabasePPToSL>(filename, "PP FST");
    m_database.at(+TGCId::RegionType::Forward).at(+TGCId::ModuleType::SD) =
        std::make_unique<TGCDatabasePPToSL>(filename, "PP FSD");
    m_database.at(+TGCId::RegionType::Forward).at(+TGCId::ModuleType::WI) =
        std::make_unique<TGCDatabasePPToSL>(filename, "PP FWI");
    m_database.at(+TGCId::RegionType::Forward).at(+TGCId::ModuleType::SI) =
        std::make_unique<TGCDatabasePPToSL>(filename, "PP FSI");
}

~TGCCablePPToSLB()

MuonTGC_Cabling::TGCCablePPToSLB::~TGCCablePPToSLB ( )

virtualdefault

TGCCablePPToSLB() [2/2]

MuonTGC_Cabling::TGCCablePPToSLB::TGCCablePPToSLB ( )

privatedelete

Member Function Documentation

getCableType()

CableType MuonTGC_Cabling::TGCCable::getCableType ( ) const

inlineinherited

Definition at line 34 of file TGCCable.h.

{ return m_type; }

getChannel()

std::unique_ptr< TGCChannelId > MuonTGC_Cabling::TGCCablePPToSLB::getChannel	(	const TGCChannelId &	channelId,
		bool	orChannel = false ) const

Definition at line 46 of file TGCCablePPToSLB.cxx.

                                                         {
    if (channelId.getChannelIdType() == TGCChannelId::ChannelIdType::PPOut) {
        return getChannelOut(channelId, orChannel);
    }
    if (channelId.getChannelIdType() == TGCChannelId::ChannelIdType::SLBIn) {
        return getChannelIn(channelId, orChannel);
    }
 
    return nullptr;
}

getChannelIn()

std::unique_ptr< TGCChannelId > MuonTGC_Cabling::TGCCablePPToSLB::getChannelIn ( const TGCChannelId & slbin, bool orChannel = false ) const

private

Definition at line 68 of file TGCCablePPToSLB.cxx.

                                                     {
    if (orChannel || slbin.isValid() == false) {
        return nullptr;
    }
 
    // SLB channel
    const TGCChannelSLBIn* slbIn = nullptr;
    if (slbin.getChannelIdType() == TGCChannelId::ChannelIdType::SLBIn) {
        slbIn = dynamic_cast<const TGCChannelSLBIn*>(&slbin);
    }
    if (!slbIn) {
        return nullptr;
    }
 
    // SLB module
    std::unique_ptr<TGCModuleId> slb = slbIn->getModule();
    if (!slb) {
        return nullptr;
    }
 
    // SLB -> PP module connection
    TGCModuleMap mapId = getModule(*slb);
    if (!mapId.size()) {
        return nullptr;
    }
 
    // PP module
    int port = mapId.begin()->first;
    auto pp = mapId.popModule(port);
    if (!pp) {
        return nullptr;
    }
 
    // SLB ->PP channel connection
    int block = -1;
    int channel = -1;
    TGCChannelSLBIn::CellType cellType = slbIn->getCellType();
    if (cellType == TGCChannelSLBIn::NoCellType) {
        return nullptr;
    }
 
    if (cellType == TGCChannelSLBIn::CellA) {
        block = 1 + 2 * port;
        int lengthOfSLB = TGCChannelSLBIn::getLengthOfSLB(
            slbIn->getModuleType(), TGCChannelSLBIn::CellB);
        channel = lengthOfSLB + slbIn->getChannelInSLB();
    }
    if (cellType == TGCChannelSLBIn::CellB) {
        block = 1 + 2 * port;
        channel = slbIn->getChannelInSLB();
    }
    if (cellType == TGCChannelSLBIn::CellC) {
        block = 0 + 2 * port;
        int lengthOfSLB = TGCChannelSLBIn::getLengthOfSLB(
            slbIn->getModuleType(), TGCChannelSLBIn::CellD);
        channel = lengthOfSLB + slbIn->getChannelInSLB();
    }
    if (cellType == TGCChannelSLBIn::CellD) {
        block = 0 + 2 * port;
        channel = slbIn->getChannelInSLB();
    }
    return std::make_unique<TGCChannelPPOut>(
        pp->getSideType(), pp->getStation(),
        pp->getModuleType(), pp->getRegionType(),
        pp->getSector(), pp->getId(), block, channel);
}

getChannelOut()

std::unique_ptr< TGCChannelId > MuonTGC_Cabling::TGCCablePPToSLB::getChannelOut ( const TGCChannelId & ppout, bool orChannel = false ) const

private

Definition at line 136 of file TGCCablePPToSLB.cxx.

                                                     {
    if (orChannel || ppout.isValid() == false) {
        return nullptr;
    }
 
    const int ppoutBlock = ppout.getBlock();
 
    // PP module
    std::unique_ptr<TGCModuleId> pp{ppout.getModule()};
    if (!pp) {
        return nullptr;
    }
 
    // PP -> SLB module connection
    TGCModuleMap mapId = getModule(*pp);
    if (!mapId.size()) {
        return nullptr;
    }
 
    // SLB module
    auto slb = mapId.popModule(ppoutBlock / 2);
 
    if (!slb) {
        return nullptr;
    }
 
    // PP ->SLB channel connection
    TGCChannelSLBIn::CellType cellType = TGCChannelSLBIn::NoCellType;
    int channelInSLB = -1;
    if (ppoutBlock % 2 == 0) {  // D,C
        int lengthOfSLB = TGCChannelSLBIn::getLengthOfSLB(
            slb->getModuleType(), TGCChannelSLBIn::CellD);
        if (ppout.getChannel() < lengthOfSLB) {
            cellType = TGCChannelSLBIn::CellD;
            channelInSLB = ppout.getChannel();
        } else {
            cellType = TGCChannelSLBIn::CellC;
            channelInSLB = ppout.getChannel() - lengthOfSLB;
        }
    } else {  // B,A
        int lengthOfSLB = TGCChannelSLBIn::getLengthOfSLB(
            slb->getModuleType(), TGCChannelSLBIn::CellB);
        if (ppout.getChannel() < lengthOfSLB) {
            cellType = TGCChannelSLBIn::CellB;
            channelInSLB = ppout.getChannel();
        } else {
            cellType = TGCChannelSLBIn::CellA;
            channelInSLB = ppout.getChannel() - lengthOfSLB;
        }
    }
 
    int channel = TGCChannelSLBIn::convertChannel(slb->getModuleType(),
                                                  cellType, channelInSLB);
    return std::make_unique<TGCChannelSLBIn>(
        slb->getSideType(), slb->getModuleType(), slb->getRegionType(),
        slb->getSector(), slb->getId(), channel);
}

getModule()

TGCModuleMap MuonTGC_Cabling::TGCCablePPToSLB::getModule

(

const TGCModuleId &

moduleId

)

const

Definition at line 58 of file TGCCablePPToSLB.cxx.

                                                                         {
    if (moduleId.getModuleIdType() == TGCModuleId::PP) {
        return getModuleOut(moduleId);
    }
    if (moduleId.getModuleIdType() == TGCModuleId::SLB) {
        return getModuleIn(moduleId);
    }
    return TGCModuleMap{};
}

getModuleIn()

TGCModuleMap MuonTGC_Cabling::TGCCablePPToSLB::getModuleIn ( const TGCModuleId & slb ) const

private

Definition at line 195 of file TGCCablePPToSLB.cxx.

                                                                      {
    if (slb.isValid() == false) {
        return TGCModuleMap{};
    }
 
    const int slbId = slb.getId();
 
    TGCDatabase* databaseP =
        m_database.at(+slb.getRegionType()).at(+slb.getModuleType()).get();
    TGCModuleMap mapId{};
    const int MaxEntry = databaseP->getMaxEntry();
    for (int i = 0; i < MaxEntry; i++) {
        if (databaseP->getEntry(i, 1) == slbId) {
            int id = databaseP->getEntry(i, 0);
            auto pp = std::make_unique<TGCModulePP>(
                slb.getSideType(), slb.getStation(),
                slb.getModuleType(), slb.getRegionType(),
                slb.getSector(), id);
 
            mapId.insert(0, std::move(pp));
            break;
        }
        if (databaseP->getEntry(i, 2) == slbId) {
            int id = databaseP->getEntry(i, 0);
            auto pp = std::make_unique<TGCModulePP>(
                slb.getSideType(), slb.getStation(),
                slb.getModuleType(), slb.getRegionType(),
                slb.getSector(), id);
 
            mapId.insert(1, std::move(pp));
            break;
        }
    }
 
    return mapId;
}

getModuleOut()

TGCModuleMap MuonTGC_Cabling::TGCCablePPToSLB::getModuleOut ( const TGCModuleId & pp ) const

private

Definition at line 232 of file TGCCablePPToSLB.cxx.

                                                                      {
    if (pp.isValid() == false) {
        return TGCModuleMap{};
    }
 
    const int ppId = pp.getId();
 
    TGCDatabase* databaseP =
        m_database.at(+pp.getRegionType()).at(+pp.getModuleType()).get();
    TGCModuleMap mapId{};
    const int MaxEntry = databaseP->getMaxEntry();
    for (int i = 0; i < MaxEntry; i++) {
        if (databaseP->getEntry(i, 0) == ppId) {
            int id = -1;
 
            id = databaseP->getEntry(i, 1);
            if (id != -1) {
                auto slb = std::make_unique<TGCModuleSLB>(
                    pp.getSideType(), pp.getModuleType(), pp.getRegionType(),
                    pp.getSector(), id);
 
                mapId.insert(0, std::move(slb));
            }
 
            id = databaseP->getEntry(i, 2);
            if (id != -1) {
                auto slb = std::make_unique<TGCModuleSLB>(
                    pp.getSideType(), pp.getModuleType(), pp.getRegionType(),
                    pp.getSector(), id);
 
                mapId.insert(1, std::move(slb));
            }
            break;
        }
    }
 
    return mapId;
}

Member Data Documentation

m_database

std::array<std::array<std::unique_ptr<TGCDatabase>, +TGCId::ModuleType::MaxModuleType>, +TGCId::RegionType::MaxRegionType> MuonTGC_Cabling::TGCCablePPToSLB::m_database

private

Definition at line 38 of file TGCCablePPToSLB.h.

m_type

CableType MuonTGC_Cabling::TGCCable::m_type {CableType::NoCableType}

privateinherited

Definition at line 37 of file TGCCable.h.

{CableType::NoCableType};

---

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

• TGCCablePPToSLB.h
• TGCCablePPToSLB.cxx