MuonTGC_Cabling::TGCCableASDToPP Class Reference

#include <TGCCableASDToPP.h>

Inheritance diagram for MuonTGC_Cabling::TGCCableASDToPP:

Collaboration diagram for MuonTGC_Cabling::TGCCableASDToPP:

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

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

Private Types
using	ForwardSectorDB
using	InnerSectorDB
using	EndcapSectorDB
using	CommonDB
	Pointers of common databases are recorded in this array.

Private Member Functions
void	initialize (const std::string &filename, const std::string &diffFile)
void	updateDatabase (const std::string &diffFile)
std::unique_ptr< TGCChannelId >	getChannelIn (const TGCChannelId &ppin, bool orChannel=false) const
std::unique_ptr< TGCChannelId >	getChannelOut (const TGCChannelId &asdout, bool orChannel=false) const
std::vector< std::vector< int > >	getUpdateInfo (const int side, const int sector, const std::vector< std::string > &diffFile, const std::string &blockname)
TGCDatabaseASDToPP *	getDatabase (const int side, const int region, const int sector, const int module) const
void	updateIndividualDatabase (const int side, const int sector, const std::vector< std::string > &diffFile, const std::string &blockname, std::shared_ptr< TGCDatabaseASDToPP > &database)

Private Attributes
ForwardSectorDB	m_FWDdb {}
ForwardSectorDB	m_FSDdb {}
ForwardSectorDB	m_FWTdb {}
ForwardSectorDB	m_FSTdb {}
InnerSectorDB	m_FWIdb {}
InnerSectorDB	m_FSIdb {}
EndcapSectorDB	m_EWDdb {}
EndcapSectorDB	m_ESDdb {}
EndcapSectorDB	m_EWTdb {}
EndcapSectorDB	m_ESTdb {}
InnerSectorDB	m_EWIdb {}
InnerSectorDB	m_ESIdb {}
CommonDB	m_commonDb {{{nullptr}}}
CableType	m_type {CableType::NoCableType}

Static Private Attributes
static constexpr std::array< int, 9 >	s_stripForward

Detailed Description

Definition at line 18 of file TGCCableASDToPP.h.

Member Typedef Documentation

CommonDB

using MuonTGC_Cabling::TGCCableASDToPP::CommonDB

private

Initial value:

 std::array<
        std::array<std::shared_ptr<TGCDatabaseASDToPP>, TGCId::MaxModuleType>,
        TGCId::MaxRegionType>

Pointers of common databases are recorded in this array.

Definition at line 83 of file TGCCableASDToPP.h.

EndcapSectorDB

using MuonTGC_Cabling::TGCCableASDToPP::EndcapSectorDB

private

Initial value:

 
        std::array<std::array<std::shared_ptr<TGCDatabaseASDToPP>,
                              TGCId::NUM_ENDCAP_SECTOR>,
                   TGCId::MaxSideType>

Definition at line 63 of file TGCCableASDToPP.h.

ForwardSectorDB

using MuonTGC_Cabling::TGCCableASDToPP::ForwardSectorDB

private

Initial value:

 
        std::array<std::array<std::shared_ptr<TGCDatabaseASDToPP>,
                              TGCId::NUM_FORWARD_SECTOR>,
                   TGCId::MaxSideType>

Definition at line 55 of file TGCCableASDToPP.h.

InnerSectorDB

using MuonTGC_Cabling::TGCCableASDToPP::InnerSectorDB

private

Initial value:

 
        std::array<std::array<std::shared_ptr<TGCDatabaseASDToPP>,
                              TGCId::NUM_INNER_SECTOR>,
                   TGCId::MaxSideType>

Definition at line 59 of file TGCCableASDToPP.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

TGCCableASDToPP()

MuonTGC_Cabling::TGCCableASDToPP::TGCCableASDToPP	(	const std::string &	fileName,
		const std::string &	diffFile )

Definition at line 17 of file TGCCableASDToPP.cxx.

    : TGCCable{TGCCable::ASDToPP} {
    initialize(filename, diffFile);
}

~TGCCableASDToPP()

MuonTGC_Cabling::TGCCableASDToPP::~TGCCableASDToPP ( )

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

Definition at line 281 of file TGCCableASDToPP.cxx.

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

getChannelIn()

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

private

Definition at line 293 of file TGCCableASDToPP.cxx.

                                                    {
    if (orChannel || !ppin.isValid()) {
        return nullptr;
    }
 
    TGCDatabaseASDToPP* databaseP =
        getDatabase(ppin.getSideType(), ppin.getRegionType(), ppin.getSector(),
                    ppin.getModuleType());
 
    if (databaseP == nullptr) {
        return nullptr;
    }
 
    int indexOut[TGCDatabaseASDToPP::NIndexOut] = {
        ppin.getId(), ppin.getBlock(), ppin.getChannel()};
    int i = databaseP->getIndexDBOut(indexOut);
    if (i < 0) {
        return nullptr;
    }
 
    // ASD2PP.db is Backward connection
    int layer = databaseP->getEntry(i, 0);
    if (ppin.isStrip()) {
        if (!ppin.isBackward()) {
            layer = s_stripForward[layer];
        }
    }
    int offset = (ppin.isWire()) ? 4 : 0;
    int channel = databaseP->getEntry(i, 2 + offset);
 
    // Endcap Triplet chamberId start from 1 in ASDOut
    int chamber = databaseP->getEntry(i, 1);
    if (ppin.isEndcap() && ppin.isTriplet()) {
        chamber = chamber + 1;
    }
    return std::make_unique<TGCChannelASDOut>(
        ppin.getSideType(), ppin.getSignalType(), ppin.getRegionType(),
        ppin.getSector(), layer, chamber, channel);
}

getChannelOut()

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

private

Definition at line 334 of file TGCCableASDToPP.cxx.

                                                      {
    if (orChannel || !asdout.isValid()) {
        return nullptr;
    }
 
    const bool asdoutisStrip = asdout.isStrip();
    const bool asdoutisBackward = asdout.isBackward();
    const bool asdoutisEndcap = asdout.isEndcap();
    const bool asdoutisTriplet = asdout.isTriplet();
    const int asdoutLayer = asdout.getLayer();
    const int asdoutChamber = asdout.getChamber();
    const int asdoutChannel = asdout.getChannel();
 
    TGCDatabaseASDToPP* databaseP =
        getDatabase(asdout.getSideType(), asdout.getRegionType(),
                    asdout.getSector(), asdout.getModuleType());
 
    if (databaseP == nullptr) {
        return nullptr;
    }
 
    const int MaxEntry = databaseP->getMaxEntry();
    for (int i = 0; i < MaxEntry; i++) {
        // ASD2PP.db is Backward connection
        int layer = asdoutLayer;
        if (asdoutisStrip && !asdoutisBackward) {
            layer = s_stripForward[layer];
        }
 
        int elecChannel = asdoutChannel;
 
        // Endcap Triplet chamberId start from 1 in ASDOut
        int chamber = asdoutChamber;
        if (asdoutisEndcap && asdoutisTriplet) {
            chamber = chamber - 1;
        }
        int offset = (asdout.isWire()) ? 4 : 0;
        if (databaseP->getEntry(i, 0) == layer &&
            databaseP->getEntry(i, 1) == chamber &&
            databaseP->getEntry(i, 2 + offset) == elecChannel) {
            int id = databaseP->getEntry(i, 3);
            int block = databaseP->getEntry(i, 4);
            int channel = databaseP->getEntry(i, 5);
 
            return std::make_unique<TGCChannelPPIn>(
                asdout.getSideType(), asdout.getModuleType(),
                asdout.getRegionType(), asdout.getSector(), id, block, channel);
        }
    }
    return nullptr;
}

getDatabase()

TGCDatabaseASDToPP * MuonTGC_Cabling::TGCCableASDToPP::getDatabase ( const int side, const int region, const int sector, const int module ) const

private

Definition at line 195 of file TGCCableASDToPP.cxx.

                                                                         {
    if (side < 0 || side >= TGCId::MaxSideType) {
        return nullptr;
    }
    if (sector < 0) {
        return nullptr;
    }
 
    TGCDatabaseASDToPP* db = nullptr;
    if (region == TGCId::Endcap) {
        switch (module) {
            case TGCId::WD:
                if (sector < TGCId::NUM_ENDCAP_SECTOR) {
                    db = m_EWDdb[side][sector].get();
                }
                break;
            case TGCId::SD:
                if (sector < TGCId::NUM_ENDCAP_SECTOR) {
                    db = m_ESDdb[side][sector].get();
                }
                break;
            case TGCId::WT:
                if (sector < TGCId::NUM_ENDCAP_SECTOR) {
                    db = m_EWTdb[side][sector].get();
                }
                break;
            case TGCId::ST:
                if (sector < TGCId::NUM_ENDCAP_SECTOR) {
                    db = m_ESTdb[side][sector].get();
                }
                break;
            case TGCId::WI:
                if (sector < TGCId::NUM_INNER_SECTOR) {
                    db = m_EWIdb[side][sector].get();
                }
                break;
            case TGCId::SI:
                if (sector < TGCId::NUM_INNER_SECTOR) {
                    db = m_ESIdb[side][sector].get();
                }
                break;
            default:
                break;
        }
    } else if (region == TGCId::Forward) {
        switch (module) {
            case TGCId::WD:
                if (sector < TGCId::NUM_FORWARD_SECTOR) {
                    db = m_FWDdb[side][sector].get();
                }
                break;
            case TGCId::SD:
                if (sector < TGCId::NUM_FORWARD_SECTOR) {
                    db = m_FSDdb[side][sector].get();
                }
                break;
            case TGCId::WT:
                if (sector < TGCId::NUM_FORWARD_SECTOR) {
                    db = m_FWTdb[side][sector].get();
                }
                break;
            case TGCId::ST:
                if (sector < TGCId::NUM_FORWARD_SECTOR) {
                    db = m_FSTdb[side][sector].get();
                }
                break;
            case TGCId::WI:
                if (sector < TGCId::NUM_INNER_SECTOR) {
                    db = m_FWIdb[side][sector].get();
                }
                break;
            case TGCId::SI:
                if (sector < TGCId::NUM_INNER_SECTOR) {
                    db = m_FSIdb[side][sector].get();
                }
                break;
            default:
                break;
        }
    }
    return db;
}

getUpdateInfo()

std::vector< std::vector< int > > MuonTGC_Cabling::TGCCableASDToPP::getUpdateInfo ( const int side, const int sector, const std::vector< std::string > & diffFile, const std::string & blockname )

private

Definition at line 133 of file TGCCableASDToPP.cxx.

                                {
    // clear info
    std::vector<std::vector<int>> info{};
 
    std::vector<std::string>::const_iterator it = diffFile.begin();
    std::vector<std::string>::const_iterator it_e = diffFile.end();
    int size = 0;
 
    // search block name
    while (it != it_e) {
        const std::string& buf = (*it);
        ++it;
        char firstl = buf.at(0);
        if (firstl == '/' || firstl == '*') {
            continue;
        }
        if (buf.compare(0, blockname.size(), blockname) == 0) {
            std::istringstream line(buf);
            std::string temp;
            line >> temp >> size;
            break;
        }
    }
 
    // loop over entries of specified block
    while (it != it_e) {
        const std::string& buf = (*it);
        ++it;
        char firstl = buf.at(0);
        if (firstl == '/' || firstl == '*') {
            continue;
        }
        if (firstl == 'E' || firstl == 'F') {
            break;
        }
        std::istringstream line(buf);
        std::vector<int> entry;
        int t_side, t_sector;
        line >> t_side;
        line >> t_sector;
        bool isOK = false;
        if ((t_side == side) && (t_sector == sector)) {
            for (int i = 2; i < 8; i++) {
                int temp = -1;
                if (line >> temp) {
                    entry.push_back(temp);
                } else {
                    break;
                }
                isOK = (i == 7);
            }
            if (isOK) {
                info.push_back(std::move(entry));
            }
        }
    }
    return info;
}

initialize()

void MuonTGC_Cabling::TGCCableASDToPP::initialize ( const std::string & filename, const std::string & diffFile )

private

Definition at line 25 of file TGCCableASDToPP.cxx.

                                                            {
    m_commonDb[TGCId::Forward][TGCId::WD] =
        std::make_shared<TGCDatabaseASDToPP>(filename, "FWD");
    m_commonDb[TGCId::Forward][TGCId::SD] =
        std::make_shared<TGCDatabaseASDToPP>(filename, "FSD");
    m_commonDb[TGCId::Forward][TGCId::WT] =
        std::make_shared<TGCDatabaseASDToPP>(filename, "FWT");
    m_commonDb[TGCId::Forward][TGCId::ST] =
        std::make_shared<TGCDatabaseASDToPP>(filename, "FST");
 
    m_commonDb[TGCId::Endcap][TGCId::WD] =
        std::make_shared<TGCDatabaseASDToPP>(filename, "EWD");
    m_commonDb[TGCId::Endcap][TGCId::SD] =
        std::make_shared<TGCDatabaseASDToPP>(filename, "ESD");
    m_commonDb[TGCId::Endcap][TGCId::WT] =
        std::make_shared<TGCDatabaseASDToPP>(filename, "EWT");
    m_commonDb[TGCId::Endcap][TGCId::ST] =
        std::make_shared<TGCDatabaseASDToPP>(filename, "EST");
 
    m_commonDb[TGCId::Forward][TGCId::WI] =
        std::make_shared<TGCDatabaseASDToPP>(filename, "FWI");
    m_commonDb[TGCId::Forward][TGCId::SI] =
        std::make_shared<TGCDatabaseASDToPP>(filename, "FSI");
    m_commonDb[TGCId::Endcap][TGCId::WI] =
        std::make_shared<TGCDatabaseASDToPP>(filename, "EWI");
    m_commonDb[TGCId::Endcap][TGCId::SI] =
        std::make_shared<TGCDatabaseASDToPP>(filename, "ESI");
 
    for (int side = 0; side < TGCId::MaxSideType; side++) {
        for (int sector = 0; sector < TGCId::NUM_FORWARD_SECTOR; sector++) {
            m_FWDdb[side][sector] = m_commonDb[TGCId::Forward][TGCId::WD];
            m_FSDdb[side][sector] = m_commonDb[TGCId::Forward][TGCId::SD];
            m_FWTdb[side][sector] = m_commonDb[TGCId::Forward][TGCId::WT];
            m_FSTdb[side][sector] = m_commonDb[TGCId::Forward][TGCId::ST];
        }
        for (int sector = 0; sector < TGCId::NUM_ENDCAP_SECTOR; sector++) {
            m_EWDdb[side][sector] = m_commonDb[TGCId::Endcap][TGCId::WD];
            m_ESDdb[side][sector] = m_commonDb[TGCId::Endcap][TGCId::SD];
            m_EWTdb[side][sector] = m_commonDb[TGCId::Endcap][TGCId::WT];
            m_ESTdb[side][sector] = m_commonDb[TGCId::Endcap][TGCId::ST];
        }
        for (int sector = 0; sector < TGCId::NUM_INNER_SECTOR; sector++) {
            m_FWIdb[side][sector] = m_commonDb[TGCId::Forward][TGCId::WI];
            m_FSIdb[side][sector] = m_commonDb[TGCId::Forward][TGCId::SI];
            m_EWIdb[side][sector] = m_commonDb[TGCId::Endcap][TGCId::WI];
            m_ESIdb[side][sector] = m_commonDb[TGCId::Endcap][TGCId::SI];
        }
    }
    updateDatabase(diffFile);
}

updateDatabase()

void MuonTGC_Cabling::TGCCableASDToPP::updateDatabase ( const std::string & diffFile )

private

Definition at line 77 of file TGCCableASDToPP.cxx.

                                                              {
 
    std::vector<std::string> fileContent{};
    std::ifstream inASDToPP;
    inASDToPP.open(diffFile);
    if (inASDToPP.bad()) {
        throw std::runtime_error("Failed to open " + diffFile);
        return;
    }
 
    std::string buf{};
    // Copy database into m_ASD2PP_DIFF_12
    while (getline(inASDToPP, buf)) {
        char letter = buf.at(0);
        // Truncation saves initialization CPU time of about 30 ms.
        if (letter == '/' || letter == '*') {
            continue;
        }
 
        fileContent.push_back(buf);
    }
 
    for (int side = 0; side < TGCId::MaxSideType; side++) {
        for (int sector = 0; sector < TGCId::NUM_FORWARD_SECTOR; sector++) {
            updateIndividualDatabase(side, sector, fileContent, "FWD",
                                     m_FWDdb[side][sector]);
            updateIndividualDatabase(side, sector, fileContent, "FSD",
                                     m_FSDdb[side][sector]);
            updateIndividualDatabase(side, sector, fileContent, "FWT",
                                     m_FWTdb[side][sector]);
            updateIndividualDatabase(side, sector, fileContent, "FST",
                                     m_FSTdb[side][sector]);
        }
        for (int sector = 0; sector < TGCId::NUM_ENDCAP_SECTOR; sector++) {
            updateIndividualDatabase(side, sector, fileContent, "EWD",
                                     m_EWDdb[side][sector]);
            updateIndividualDatabase(side, sector, fileContent, "ESD",
                                     m_ESDdb[side][sector]);
            updateIndividualDatabase(side, sector, fileContent, "EWT",
                                     m_EWTdb[side][sector]);
            updateIndividualDatabase(side, sector, fileContent, "EST",
                                     m_ESTdb[side][sector]);
        }
        for (int sector = 0; sector < TGCId::NUM_INNER_SECTOR; sector++) {
            updateIndividualDatabase(side, sector, fileContent, "EWI",
                                     m_EWIdb[side][sector]);
            updateIndividualDatabase(side, sector, fileContent, "ESI",
                                     m_ESIdb[side][sector]);
            updateIndividualDatabase(side, sector, fileContent, "FWI",
                                     m_FWIdb[side][sector]);
            updateIndividualDatabase(side, sector, fileContent, "FSI",
                                     m_FSIdb[side][sector]);
        }
    }
}

updateIndividualDatabase()

void MuonTGC_Cabling::TGCCableASDToPP::updateIndividualDatabase ( const int side, const int sector, const std::vector< std::string > & diffFile, const std::string & blockname, std::shared_ptr< TGCDatabaseASDToPP > & database )

private

Definition at line 387 of file TGCCableASDToPP.cxx.

                                                 {
    if (!database) {
        return;
    }
    std::vector<std::vector<int>> info =
        getUpdateInfo(side, sector, diffFile, blockname);
 
    if (info.empty()) {
        return;
    }
 
    if (database->isCommon()) {
        database = std::make_unique<TGCDatabaseASDToPP>(
            *database,
            false);  // false means this database is not commonly used.
    }
 
    for (auto& i : info) {
        database->update(i);
    }
}

Member Data Documentation

m_commonDb

CommonDB MuonTGC_Cabling::TGCCableASDToPP::m_commonDb {{{nullptr}}}

private

Definition at line 86 of file TGCCableASDToPP.h.

{{{nullptr}}};

m_ESDdb

EndcapSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_ESDdb {}

private

Definition at line 76 of file TGCCableASDToPP.h.

{};

m_ESIdb

InnerSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_ESIdb {}

private

Definition at line 80 of file TGCCableASDToPP.h.

{};

m_ESTdb

EndcapSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_ESTdb {}

private

Definition at line 78 of file TGCCableASDToPP.h.

{};

m_EWDdb

EndcapSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_EWDdb {}

private

Definition at line 75 of file TGCCableASDToPP.h.

{};

m_EWIdb

InnerSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_EWIdb {}

private

Definition at line 79 of file TGCCableASDToPP.h.

{};

m_EWTdb

EndcapSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_EWTdb {}

private

Definition at line 77 of file TGCCableASDToPP.h.

{};

m_FSDdb

ForwardSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_FSDdb {}

private

Definition at line 69 of file TGCCableASDToPP.h.

{};

m_FSIdb

InnerSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_FSIdb {}

private

Definition at line 73 of file TGCCableASDToPP.h.

{};

m_FSTdb

ForwardSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_FSTdb {}

private

Definition at line 71 of file TGCCableASDToPP.h.

{};

m_FWDdb

ForwardSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_FWDdb {}

private

Definition at line 68 of file TGCCableASDToPP.h.

{};

m_FWIdb

InnerSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_FWIdb {}

private

Definition at line 72 of file TGCCableASDToPP.h.

{};

m_FWTdb

ForwardSectorDB MuonTGC_Cabling::TGCCableASDToPP::m_FWTdb {}

private

Definition at line 70 of file TGCCableASDToPP.h.

{};

m_type

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

privateinherited

Definition at line 37 of file TGCCable.h.

{CableType::NoCableType};

s_stripForward

std::array<int, 9> MuonTGC_Cabling::TGCCableASDToPP::s_stripForward

staticconstexprprivate

Initial value:

{2, 1, 0, 4, 3,
                                                       6, 5, 8, 7}

Definition at line 51 of file TGCCableASDToPP.h.

                                                    {2, 1, 0, 4, 3,
                                                       6, 5, 8, 7};

---

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

• TGCCableASDToPP.h
• TGCCableASDToPP.cxx