MuonTGC_Cabling::TGCCableInASD Class Reference

#include <TGCCableInASD.h>

Inheritance diagram for MuonTGC_Cabling::TGCCableInASD:

Collaboration diagram for MuonTGC_Cabling::TGCCableInASD:

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

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

Private Member Functions
std::unique_ptr< TGCChannelId >	getChannelIn (const TGCChannelId &asdout, bool orChannel=false) const
std::unique_ptr< TGCChannelId >	getChannelOut (const TGCChannelId &asdin, bool orChannel=false) const

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

Detailed Description

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

TGCCableInASD()

MuonTGC_Cabling::TGCCableInASD::TGCCableInASD

(

const std::string &

filename

)

Definition at line 14 of file TGCCableInASD.cxx.

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

~TGCCableInASD()

MuonTGC_Cabling::TGCCableInASD::~TGCCableInASD ( )

virtualdefault

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

Definition at line 44 of file TGCCableInASD.cxx.

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

getChannelIn()

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

private

Definition at line 56 of file TGCCableInASD.cxx.

                                                      {
    if (orChannel || !asdout.isValid()) {
        return nullptr;
    }
 
    TGCDatabase* databaseP =
        m_database[asdout.getRegionType()][asdout.getModuleType()].get();
 
    // sector ASDIn [1..48, 1..24], ASDOut [0..47, 0..23]
    int sector;
    if (asdout.isEndcap() && !asdout.isInner()) {
        sector = asdout.getSector() - 1;
        if (sector <= 0) {
            sector += TGCId::NUM_ENDCAP_SECTOR;
        }
    } else {
        sector = asdout.getSector();
        if (sector <= 0) {
            sector += TGCId::NUM_FORWARD_SECTOR;
        }
    }
 
    // chamber ASDIn [1(F),1,2,3,4,5(E)], ASDOut [0(F),4,3,2,1,0(E)]
    int chamber;
    if (asdout.isEndcap() && !asdout.isInner()) {
        chamber = 5 - asdout.getChamber();
    } else {
        chamber = asdout.getChamber() + 1;
    }
 
    int channel = -1;
    // channel ASDIn [1..32(S),1..n(W chamber)], ASDOut [0..31(S),n..0(W
    // sector)]
    if (asdout.isWire()) {
        // Endcap Triplet chamberId start from 1 in ASDOut
        int dbChamber = asdout.getChamber();
        if (asdout.isEndcap() && asdout.isTriplet()) {
            dbChamber = dbChamber - 1;
        }
        int indexIn[TGCDatabaseASDToPP::NIndexIn] = {
            asdout.getLayer(), dbChamber, asdout.getChannel()};
        int i = databaseP->getIndexDBIn(indexIn);
        if (i < 0) {
            return nullptr;
        }
        channel = databaseP->getEntry(i, 7) + 1;
    } else {
        if ((asdout.isBackward() && asdout.isAside()) ||
            (!asdout.isBackward() && asdout.isCside())) {
            channel = 32 - asdout.getChannel();
        } else {
            channel = asdout.getChannel() + 1;
        }
    }
    if (channel == -1) {
        return nullptr;
    }
 
    return std::make_unique<TGCChannelASDIn>(
        asdout.getSideType(), asdout.getSignalType(), asdout.getRegionType(),
        sector, asdout.getLayer(), chamber, channel);
}

getChannelOut()

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

private

Definition at line 120 of file TGCCableInASD.cxx.

                                                     {
    if (orChannel || asdin.isValid() == false) {
        return nullptr;
    }
 
    const bool asdinisEndcap = asdin.isEndcap();
    const bool asdinisTriplet = asdin.isTriplet();
    const int asdinLayer = asdin.getLayer();
    const int asdinChannel = asdin.getChannel();
 
    TGCDatabase* databaseP =
        m_database[asdin.getRegionType()][asdin.getModuleType()].get();
 
    if (!databaseP) {
        return nullptr;
    }
    // sector ASDIn [1..48, 1..24], ASDOut [2..47.0.1, 1..23.0]
    int sector{0};
    if (asdin.isEndcap()) {
        if (!asdin.isInner()) {
            // Endcap
            sector = (asdin.getSector() + 1) % TGCId::NUM_ENDCAP_SECTOR;
        } else {
            // EI
            sector = (asdin.getSector()) % TGCId::NUM_INNER_SECTOR;
        }
    } else {
        if (!asdin.isInner()) {
            // Forward
            sector = (asdin.getSector()) % TGCId::NUM_FORWARD_SECTOR;
        } else {
            // FI
            sector = (asdin.getSector()) % TGCId::NUM_INNER_SECTOR;
        }
    }
 
    // chamber ASDIn [1(F),1,2,3,4,5(E)], ASDOut [0(F),4,3,2,1,0(E)]
    int chamber{0};
    if (asdin.isEndcap() && !asdin.isInner()) {
        chamber = 5 - asdin.getChamber();
    } else {
        chamber = asdin.getChamber() - 1;
    }
 
    int channel = -1;
    // channel ASDIn [1..32(S),1..n(W chamber)], ASDOut [0..31(S),n..0(W
    // sector)]
    if (asdin.isWire()) {
        const int MaxEntry = databaseP->getMaxEntry();
        for (int i = 0; i < MaxEntry; i++) {
            // Endcap Triplet chamberId start from 1 in ASDOut
            int dbChamber = chamber;
            if (asdinisEndcap && asdinisTriplet) {
                dbChamber = dbChamber - 1;
            }
 
            int dbChannel = asdinChannel - 1;
            if (databaseP->getEntry(i, 7) == dbChannel &&
                databaseP->getEntry(i, 1) == dbChamber &&
                databaseP->getEntry(i, 0) == asdinLayer) {
                channel = databaseP->getEntry(i, 6);
                break;
            }
        }
    } else {
        // asdin.isBackward() can not be used because this method rely on
        // sector number for asdout
        bool is_Backward = false;
        if (asdin.isEndcap()) {
            if (!asdin.isInner()) {
                if (asdin.isAside()) {
                    is_Backward = (sector % 2 == 1);
                } else {
                    is_Backward = (sector % 2 == 0);
                }
            } else {
                // EI
                // Special case of EI11
                if (sector == 15) {
                    if (asdin.isAside()) {
                        is_Backward = false;
                    } else {
                        is_Backward = true;
                    }
                } else if (sector == 16) {
                    if (asdin.isAside()) {
                        is_Backward = true;
                    } else {
                        is_Backward = false;
                    }
                } else {
                    //  A-side phi0 F: phi1 F: phi2 B
                    //  C-side phi0 B: phi1 B: phi2 F
                    if (asdin.isAside()) {
                        is_Backward = (sector % 3 == 2);
                    } else {
                        is_Backward = (sector % 3 != 2);
                    }
                }
            }
        } else {
            if (asdin.isAside()) {
                is_Backward = true;  // All Backward for A-side
            }
        }
        if ((is_Backward && asdin.isAside()) ||
            (!is_Backward && asdin.isCside())) {
            channel = 32 - asdin.getChannel();
        } else {
            channel = asdin.getChannel() - 1;
        }
    }
    if (channel == -1) {
        return nullptr;
    }
 
    return std::make_unique<TGCChannelASDOut>(
        asdin.getSideType(), asdin.getSignalType(), asdin.getRegionType(),
        sector, asdin.getLayer(), chamber, channel);
}

Member Data Documentation

m_database

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

private

Definition at line 33 of file TGCCableInASD.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:

• TGCCableInASD.h
• TGCCableInASD.cxx