MuonTGC_Cabling::TGCCableInPP Class Reference

#include <TGCCableInPP.h>

Inheritance diagram for MuonTGC_Cabling::TGCCableInPP:

Collaboration diagram for MuonTGC_Cabling::TGCCableInPP:

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

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

Private Member Functions
	TGCCableInPP ()=delete
std::unique_ptr< TGCChannelId >	getChannelIn (const TGCChannelId &ppout, const bool orChannel=false) const
std::unique_ptr< TGCChannelId >	getChannelOut (const TGCChannelId &ppin, const 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 19 of file TGCCableInPP.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

TGCCableInPP() [1/2]

MuonTGC_Cabling::TGCCableInPP::TGCCableInPP

(

const std::string &

filename

)

Definition at line 15 of file TGCCableInPP.cxx.

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

~TGCCableInPP()

MuonTGC_Cabling::TGCCableInPP::~TGCCableInPP ( )

virtualdefault

TGCCableInPP() [2/2]

MuonTGC_Cabling::TGCCableInPP::TGCCableInPP ( )

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

Definition at line 45 of file TGCCableInPP.cxx.

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

getChannelIn()

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

private

Definition at line 56 of file TGCCableInPP.cxx.

                                                           {
    if (ppout.isValid() == false) {
        return nullptr;
    }
 
    TGCId::ModuleType moduleType = ppout.getModuleType();
 
    int ndatabaseP = 1;
    TGCDatabase* databaseP[2];
    databaseP[0] = m_database[ppout.getRegionType()][moduleType].get();
    // EI/FI
    //  wire(TGCId::WI) and strip(TGCId::SI) of a chamber
    //  use the same SLB chip
    //  The SLB chip is treated as TGCId::WI in TGCCableSLBToSSW.cxx
    if (moduleType == TGCId::WI) {
        databaseP[1] = m_database[ppout.getRegionType()][TGCId::SI].get();
        ndatabaseP = 2;
    }
 
    int id = -1, block = -1, channel = -1;
    bool found = false;
 
    for (int idatabaseP = 0; idatabaseP < ndatabaseP; idatabaseP++) {
        // EI/FI
        //  wire(TGCId::WI) and strip(TGCId::SI) of a chamber
        //  use the same SLB chip
        //  The SLB chip is treated as TGCId::WI in TGCCableSLBToSSW.cxx
        if (idatabaseP == 1) {
            moduleType = TGCId::SI;
        }
 
        int indexIn[TGCDatabaseInPP::NIndexIn] = {
            ppout.getId(), ppout.getBlock(), ppout.getChannel()};
        int i = databaseP[idatabaseP]->getIndexDBIn(indexIn);
        if (i < 0) {
            continue;
        }
 
        if (orChannel == false) {
            // first channel
            id = databaseP[idatabaseP]->getEntry(i, 3);
            block = databaseP[idatabaseP]->getEntry(i, 4);
            channel = databaseP[idatabaseP]->getEntry(i, 5);
            if (id == -1 && block == -1 && channel == -1) {
                continue;
            }
            found = true;
            break;
        } else {
            // ored channel
            if (databaseP[idatabaseP]->getEntrySize(i) == 9) {
                id = databaseP[idatabaseP]->getEntry(i, 6);
                block = databaseP[idatabaseP]->getEntry(i, 7);
                channel = databaseP[idatabaseP]->getEntry(i, 8);
                found = true;
            }
        }
    }
 
    if (!found) {
        return nullptr;
    }
 
    return std::make_unique<TGCChannelPPIn>(
        ppout.getSideType(), moduleType, ppout.getRegionType(),
        ppout.getSector(), id, block, channel);
}

getChannelOut()

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

private

Definition at line 125 of file TGCCableInPP.cxx.

                                                          {
    if (ppin.isValid() == false) {
        return nullptr;
    }
 
    const int ppinChannel = ppin.getChannel();
    const int ppinBlock = ppin.getBlock();
    const int ppinId = ppin.getId();
 
    TGCDatabase* databaseP =
        m_database[ppin.getRegionType()][ppin.getModuleType()].get();
 
    const int MaxEntry = databaseP->getMaxEntry();
    for (int i = 0; i < MaxEntry; i++) {
        bool cond1 = (databaseP->getEntry(i, 5) == ppinChannel) &&
                     (databaseP->getEntry(i, 4) == ppinBlock) &&
                     (databaseP->getEntry(i, 3) == ppinId);
 
        bool cond2 = (databaseP->getEntrySize(i) == 9) &&
                     (databaseP->getEntry(i, 8) == ppinChannel) &&
                     (databaseP->getEntry(i, 7) == ppinBlock) &&
                     (databaseP->getEntry(i, 6) == ppinId);
 
        if (cond1 || cond2) {
            int id = databaseP->getEntry(i, 0);
            int block = databaseP->getEntry(i, 1);
            int channel = databaseP->getEntry(i, 2);
 
            // TGCChannelSLBIn::CellType cellType = TGCChannelSLBIn::NoCellType;
            int channelInSLB = -1;
            bool adjacent = false;
            TGCId::ModuleType moduleType = ppin.getModuleType();
            if (block == 0 || block == 2) {  // C,D
                int lengthOfC = TGCChannelSLBIn::getLengthOfSLB(
                    moduleType, TGCChannelSLBIn::CellC);
                int lengthOfD = TGCChannelSLBIn::getLengthOfSLB(
                    moduleType, TGCChannelSLBIn::CellD);
                if (channel < lengthOfD) {
                    int adjacentOfD = TGCChannelSLBIn::getAdjacentOfSLB(
                        moduleType, TGCChannelSLBIn::CellD);
                    // cellType = TGCChannelSLBIn::CellD;
                    channelInSLB = channel;
                    if (channelInSLB < adjacentOfD ||
                        channelInSLB >= lengthOfD - adjacentOfD) {
                        adjacent = true;
                    }
                } else {
                    int adjacentOfC = TGCChannelSLBIn::getAdjacentOfSLB(
                        moduleType, TGCChannelSLBIn::CellC);
                    // cellType = TGCChannelSLBIn::CellC;
                    channelInSLB = channel - lengthOfD;
                    if (channelInSLB < adjacentOfC ||
                        channelInSLB >= lengthOfC - adjacentOfC) {
                        adjacent = true;
                    }
                }
            }
            if (block == 1 || block == 3) {  // A,B
                int lengthOfA = TGCChannelSLBIn::getLengthOfSLB(
                    moduleType, TGCChannelSLBIn::CellA);
                int lengthOfB = TGCChannelSLBIn::getLengthOfSLB(
                    moduleType, TGCChannelSLBIn::CellB);
                if (channel < lengthOfB) {
                    int adjacentOfB = TGCChannelSLBIn::getAdjacentOfSLB(
                        moduleType, TGCChannelSLBIn::CellB);
                    // cellType = TGCChannelSLBIn::CellB;
                    channelInSLB = channel;
                    if (channelInSLB < adjacentOfB ||
                        channelInSLB >= lengthOfB - adjacentOfB) {
                        adjacent = true;
                    }
                } else {
                    int adjacentOfA = TGCChannelSLBIn::getAdjacentOfSLB(
                        moduleType, TGCChannelSLBIn::CellA);
                    // cellType = TGCChannelSLBIn::CellA;
                    channelInSLB = channel - lengthOfB;
                    if (channelInSLB < adjacentOfA ||
                        channelInSLB >= lengthOfA - adjacentOfA) {
                        adjacent = true;
                    }
                }
            }
 
            if ((moduleType == TGCId::SD) &&
                (ppin.getRegionType() == TGCId::Endcap)) {
                // Strips of Middle doublets are ORed to the adjacent chamber
                adjacent = cond2;
            }
 
            if (adjacent == orChannel) {
                return std::make_unique<TGCChannelPPOut>(
                    ppin.getSideType(), ppin.getModuleType(),
                    ppin.getRegionType(), ppin.getSector(), id, block, channel);
                break;
            }
        }
    }
 
    return nullptr;
}

Member Data Documentation

m_database

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

private

Definition at line 36 of file TGCCableInPP.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:

• TGCCableInPP.h
• TGCCableInPP.cxx