#include <TGCDatabaseASDToPP.h>

Inheritance diagram for MuonTGC_Cabling::TGCDatabaseASDToPP:

Collaboration diagram for MuonTGC_Cabling::TGCDatabaseASDToPP:

Public Types
enum	DATABASESIZE { DATABASESIZE = 8 }
enum	INDEXIN { NIndexIn = 3 }
enum	INDEXOUT { NIndexOut = 3 }
enum	DatabaseType { NoDatabaseType = -1 , ASDToPP , InPP , PPToSL , SLBToROD , MaxDatabaseType }

Public Member Functions
	TGCDatabaseASDToPP (const std::string &filename, const std::string &blockname, bool v_isCommon=true)
	Constructor.
	TGCDatabaseASDToPP (const TGCDatabaseASDToPP &, bool v_isCommon=true)
	Copy constructor.
virtual	~TGCDatabaseASDToPP ()
	Destructor.
virtual bool	update (const std::vector< int > &) override
virtual int	find (const std::vector< int > &) const override
virtual int	getIndexDBIn (int *indexIn) const override
	Get IndexDBIn (position in the databse between 0 and database.size()-1) from indexIn which is NIndexIn-dimension array.
virtual int	getIndexDBOut (int *indexOut) const override
	Get IndexDBOut (position in the databse between 0 and database.size()-1) from indexOut which is NIndexOut-dimension array.
virtual void	getindexDBVectorIn (std::vector< int > &tmpindexDBIn) const
	Get the IndexDBIn table.
virtual void	getNIndexDBIn (int &tmpNIndexDBIn) const
	Get the size of the IndexDBIn table.
virtual void	getmaxIndexIn (int *tmpmaxIndexIn) const
	Get the maximum values of indexIn with NIndexIn dimensions.
virtual void	getminIndexIn (int *tmpminIndexIn) const
	Get the minimum values of indexIn with NIndexIn dimensions.
virtual void	getindexDBVectorOut (std::vector< int > &tmpindexDBOut) const
	Get the IndexDBOut table.
virtual void	getNIndexDBOut (int &tmpNIndexDBOut) const
	Get the size of the IndexDBOut table.
virtual void	getmaxIndexOut (int *tmpmaxIndexOut) const
	Get the maximum values of indexOut with NIndexOut dimensions.
virtual void	getminIndexOut (int *tmpminIndexOut) const
	Get the minimum values of indexOut with NIndexOut dimensions.
bool	isCommon () const
	This method is used to know the database is common or sector specific.
DatabaseType	getDatabaseType () const
virtual int	getEntry (int entry, int column) const
virtual int	getEntrySize (int entry) const
virtual int	getMaxEntry () const

Static Public Attributes
static const int	IndexIn [NIndexIn] = {0, 1, 6}
static const int	ReverseIndexIn [DATABASESIZE]
static const int	IndexOut [NIndexOut] = {3, 4, 5}
static const int	ReverseIndexOut [DATABASESIZE]

Protected Attributes
std::string	m_filename
std::string	m_blockname
std::vector< std::vector< int > >	m_database

Private Member Functions
virtual void	readDB () override
	TGCDatabaseASDToPP ()
virtual void	makeIndexDBIn ()
	Make the IndexDBIn table.
virtual int	convertIndexDBIn (int *indexIn) const
	Get the interal number, which is between 0 and NIndexDBIn-1.
virtual void	makeIndexDBOut ()
	Make the IndexDBOut table.
virtual int	convertIndexDBOut (int *indexOut) const
	Get the interal number, which is between 0 and NIndexDBOut-1.
TGCDatabaseASDToPP &	operator= (const TGCDatabaseASDToPP &right)
	hidden assignment operator

Private Attributes
std::vector< int >	m_indexDBIn
int	m_NIndexDBIn = 0
int	m_maxIndexIn [NIndexIn] {}
int	m_minIndexIn [NIndexIn] {}
std::vector< int >	m_indexDBOut
int	m_NIndexDBOut = 0
int	m_maxIndexOut [NIndexOut] {}
int	m_minIndexOut [NIndexOut] {}
bool	m_isCommon
	This bool variable is used to know the database is common or sector specific.
DatabaseType	m_type

Detailed Description

Definition at line 12 of file TGCDatabaseASDToPP.h.

Member Enumeration Documentation

◆ DATABASESIZE

enum MuonTGC_Cabling::TGCDatabaseASDToPP::DATABASESIZE

share/MuonTGC_Cabling_ASD2PP.db
s t uuu x y zz
 
 s    = Layer ID
 t    = Chamber ID
 uuu  = Wire-group ID
 x    = PP ID
 y    = PP input-connector ID
 zz   = PP input-channel ID of a connector

(x, y, zz) is used as IndexOut in this class.

Enumerator
DATABASESIZE

Definition at line 28 of file TGCDatabaseASDToPP.h.

28{ DATABASESIZE = 8 };

MuonTGC_Cabling::TGCDatabaseASDToPP::DATABASESIZE

DATABASESIZE

Definition TGCDatabaseASDToPP.h:28

◆ DatabaseType

enum MuonTGC_Cabling::TGCDatabase::DatabaseType

inherited

Enumerator
NoDatabaseType
ASDToPP
InPP
PPToSL
SLBToROD
MaxDatabaseType

Definition at line 15 of file TGCDatabase.h.

                      {
        NoDatabaseType = -1,
        ASDToPP,
        InPP,
        PPToSL,
        SLBToROD,
        MaxDatabaseType
    };

◆ INDEXIN

enum MuonTGC_Cabling::TGCDatabaseASDToPP::INDEXIN

Enumerator
NIndexIn

Definition at line 29 of file TGCDatabaseASDToPP.h.

29{ NIndexIn = 3 };

MuonTGC_Cabling::TGCDatabaseASDToPP::NIndexIn

@ NIndexIn

Definition TGCDatabaseASDToPP.h:29

◆ INDEXOUT

enum MuonTGC_Cabling::TGCDatabaseASDToPP::INDEXOUT

Enumerator
NIndexOut

Definition at line 32 of file TGCDatabaseASDToPP.h.

32{ NIndexOut = 3 };

MuonTGC_Cabling::TGCDatabaseASDToPP::NIndexOut

@ NIndexOut

Definition TGCDatabaseASDToPP.h:32

Constructor & Destructor Documentation

◆ TGCDatabaseASDToPP() [1/3]

MuonTGC_Cabling::TGCDatabaseASDToPP::TGCDatabaseASDToPP	(	const std::string &	filename,
		const std::string &	blockname,
		bool	v_isCommon = true )

Constructor.

Definition at line 19 of file TGCDatabaseASDToPP.cxx.

    : TGCDatabase(TGCDatabase::ASDToPP, filename, blockname),
      m_NIndexDBIn(0),
      m_NIndexDBOut(0),
      m_isCommon(v_isCommon) {
    for (int iIndexIn = 0; iIndexIn < NIndexIn; iIndexIn++) {
        m_maxIndexIn[iIndexIn] = 0;
        m_minIndexIn[iIndexIn] = 9999;
    }
    for (int iIndexOut = 0; iIndexOut < NIndexOut; iIndexOut++) {
        m_maxIndexOut[iIndexOut] = 0;
        m_minIndexOut[iIndexOut] = 9999;
    }
 
    // read out ascii file and fill database
    TGCDatabaseASDToPP::readDB();
}

◆ TGCDatabaseASDToPP() [2/3]

MuonTGC_Cabling::TGCDatabaseASDToPP::TGCDatabaseASDToPP	(	const TGCDatabaseASDToPP &	right,
		bool	v_isCommon = true )

Copy constructor.

Definition at line 39 of file TGCDatabaseASDToPP.cxx.

    : TGCDatabase(right), m_isCommon(v_isCommon) {
    right.getindexDBVectorIn(m_indexDBIn);
    right.getNIndexDBIn(m_NIndexDBIn);
    right.getmaxIndexIn(m_maxIndexIn);
    right.getminIndexIn(m_minIndexIn);
 
    right.getindexDBVectorOut(m_indexDBOut);
    right.getNIndexDBOut(m_NIndexDBOut);
    right.getmaxIndexOut(m_maxIndexOut);
    right.getminIndexOut(m_minIndexOut);
}

◆ ~TGCDatabaseASDToPP()

MuonTGC_Cabling::TGCDatabaseASDToPP::~TGCDatabaseASDToPP ( )

virtual

Destructor.

Definition at line 53 of file TGCDatabaseASDToPP.cxx.

53{}

◆ TGCDatabaseASDToPP() [3/3]

MuonTGC_Cabling::TGCDatabaseASDToPP::TGCDatabaseASDToPP ( )

inlineprivate

Definition at line 78 of file TGCDatabaseASDToPP.h.

78{}

Member Function Documentation

◆ convertIndexDBIn()

int MuonTGC_Cabling::TGCDatabaseASDToPP::convertIndexDBIn ( int * indexIn ) const

privatevirtual

Get the interal number, which is between 0 and NIndexDBIn-1.

Definition at line 286 of file TGCDatabaseASDToPP.cxx.

                                                           {
    int converted = indexIn[0] - m_minIndexIn[0];
    for (int iIndexIn = 1; iIndexIn < NIndexIn; iIndexIn++) {
        converted *= (m_maxIndexIn[iIndexIn] - m_minIndexIn[iIndexIn] + 1);
        converted += indexIn[iIndexIn] - m_minIndexIn[iIndexIn];
    }
    return converted;
}

◆ convertIndexDBOut()

int MuonTGC_Cabling::TGCDatabaseASDToPP::convertIndexDBOut ( int * indexOut ) const

privatevirtual

Get the interal number, which is between 0 and NIndexDBOut-1.

Definition at line 316 of file TGCDatabaseASDToPP.cxx.

                                                             {
    int converted = indexOut[0] - m_minIndexOut[0];
    for (int iIndexOut = 1; iIndexOut < NIndexOut; iIndexOut++) {
        converted *= (m_maxIndexOut[iIndexOut] - m_minIndexOut[iIndexOut] + 1);
        converted += indexOut[iIndexOut] - m_minIndexOut[iIndexOut];
    }
    return converted;
}

◆ find()

int MuonTGC_Cabling::TGCDatabaseASDToPP::find ( const std::vector< int > & channel ) const

overridevirtual

Reimplemented from MuonTGC_Cabling::TGCDatabase.

Definition at line 96 of file TGCDatabaseASDToPP.cxx.

                                                                {
    int index = -1;
    const size_t size = m_database.size();
    for (size_t i = 0; i < size; i++) {
        if (m_database[i].at(2) == channel.at(2) &&
            m_database[i].at(1) == channel.at(1) &&
            m_database[i].at(0) == channel.at(0)) {
            index = i;
            break;
        }
    }
    return index;
}

◆ getDatabaseType()

DatabaseType MuonTGC_Cabling::TGCDatabase::getDatabaseType ( ) const

inlineinherited

Definition at line 37 of file TGCDatabase.h.

37{ return m_type; }

MuonTGC_Cabling::TGCDatabase::m_type

DatabaseType m_type

Definition TGCDatabase.h:59

◆ getEntry()

int MuonTGC_Cabling::TGCDatabase::getEntry	(	int	entry,
		int	column ) const

virtualinherited

Definition at line 17 of file TGCDatabase.cxx.

                                                     {
    return m_database[entry].at(column);
}

◆ getEntrySize()

int MuonTGC_Cabling::TGCDatabase::getEntrySize ( int entry ) const

virtualinherited

Definition at line 21 of file TGCDatabase.cxx.

                                             {
    return m_database[entry].size();
}

◆ getIndexDBIn()

int MuonTGC_Cabling::TGCDatabaseASDToPP::getIndexDBIn ( int * indexIn ) const

overridevirtual

Get IndexDBIn (position in the databse between 0 and database.size()-1) from indexIn which is NIndexIn-dimension array.

Reimplemented from MuonTGC_Cabling::TGCDatabase.

Definition at line 110 of file TGCDatabaseASDToPP.cxx.

                                                       {
    if (!indexIn) {
        return -1;
    }
 
    int converted = convertIndexDBIn(indexIn);
    if (converted < 0 || converted >= m_NIndexDBIn) {
        return -1;
    }
 
    return m_indexDBIn.at(converted);
}

◆ getIndexDBOut()

int MuonTGC_Cabling::TGCDatabaseASDToPP::getIndexDBOut ( int * indexOut ) const

overridevirtual

Get IndexDBOut (position in the databse between 0 and database.size()-1) from indexOut which is NIndexOut-dimension array.

Reimplemented from MuonTGC_Cabling::TGCDatabase.

Definition at line 144 of file TGCDatabaseASDToPP.cxx.

                                                         {
    if (!indexOut) {
        return -1;
    }
 
    int converted = convertIndexDBOut(indexOut);
    if (converted < 0 || converted >= m_NIndexDBOut) {
        return -1;
    }
 
    return m_indexDBOut.at(converted);
}

◆ getindexDBVectorIn()

void MuonTGC_Cabling::TGCDatabaseASDToPP::getindexDBVectorIn ( std::vector< int > & tmpindexDBIn ) const

virtual

Get the IndexDBIn table.

Definition at line 123 of file TGCDatabaseASDToPP.cxx.

                                        {
    tmpindexDBIn = m_indexDBIn;
}

◆ getindexDBVectorOut()

void MuonTGC_Cabling::TGCDatabaseASDToPP::getindexDBVectorOut ( std::vector< int > & tmpindexDBOut ) const

virtual

Get the IndexDBOut table.

Definition at line 157 of file TGCDatabaseASDToPP.cxx.

                                         {
    tmpindexDBOut = m_indexDBOut;
}

◆ getMaxEntry()

int MuonTGC_Cabling::TGCDatabase::getMaxEntry ( ) const

virtualinherited

Definition at line 25 of file TGCDatabase.cxx.

                                   {
    return m_database.size();
}

◆ getmaxIndexIn()

void MuonTGC_Cabling::TGCDatabaseASDToPP::getmaxIndexIn ( int * tmpmaxIndexIn ) const

virtual

Get the maximum values of indexIn with NIndexIn dimensions.

Definition at line 132 of file TGCDatabaseASDToPP.cxx.

                                                               {
    for (int iIndexIn = 0; iIndexIn < NIndexIn; iIndexIn++) {
        tmpmaxIndexIn[iIndexIn] = m_maxIndexIn[iIndexIn];
    }
}

◆ getmaxIndexOut()

void MuonTGC_Cabling::TGCDatabaseASDToPP::getmaxIndexOut ( int * tmpmaxIndexOut ) const

virtual

Get the maximum values of indexOut with NIndexOut dimensions.

Definition at line 166 of file TGCDatabaseASDToPP.cxx.

                                                                 {
    for (int iIndexOut = 0; iIndexOut < NIndexOut; iIndexOut++) {
        tmpmaxIndexOut[iIndexOut] = m_maxIndexOut[iIndexOut];
    }
}

◆ getminIndexIn()

void MuonTGC_Cabling::TGCDatabaseASDToPP::getminIndexIn ( int * tmpminIndexIn ) const

virtual

Get the minimum values of indexIn with NIndexIn dimensions.

Definition at line 138 of file TGCDatabaseASDToPP.cxx.

                                                               {
    for (int iIndexIn = 0; iIndexIn < NIndexIn; iIndexIn++) {
        tmpminIndexIn[iIndexIn] = m_minIndexIn[iIndexIn];
    }
}

◆ getminIndexOut()

void MuonTGC_Cabling::TGCDatabaseASDToPP::getminIndexOut ( int * tmpminIndexOut ) const

virtual

Get the minimum values of indexOut with NIndexOut dimensions.

Definition at line 172 of file TGCDatabaseASDToPP.cxx.

                                                                 {
    for (int iIndexOut = 0; iIndexOut < NIndexOut; iIndexOut++) {
        tmpminIndexOut[iIndexOut] = m_minIndexOut[iIndexOut];
    }
}

◆ getNIndexDBIn()

void MuonTGC_Cabling::TGCDatabaseASDToPP::getNIndexDBIn ( int & tmpNIndexDBIn ) const

virtual

Get the size of the IndexDBIn table.

Definition at line 128 of file TGCDatabaseASDToPP.cxx.

                                                               {
    tmpNIndexDBIn = m_NIndexDBIn;
}

◆ getNIndexDBOut()

void MuonTGC_Cabling::TGCDatabaseASDToPP::getNIndexDBOut ( int & tmpNIndexDBOut ) const

virtual

Get the size of the IndexDBOut table.

Definition at line 162 of file TGCDatabaseASDToPP.cxx.

                                                                 {
    tmpNIndexDBOut = m_NIndexDBOut;
}

◆ isCommon()

bool MuonTGC_Cabling::TGCDatabaseASDToPP::isCommon ( ) const

This method is used to know the database is common or sector specific.

Definition at line 178 of file TGCDatabaseASDToPP.cxx.

                                        {
    return m_isCommon;
}

◆ makeIndexDBIn()

void MuonTGC_Cabling::TGCDatabaseASDToPP::makeIndexDBIn ( )

privatevirtual

Make the IndexDBIn table.

Definition at line 267 of file TGCDatabaseASDToPP.cxx.

                                       {
    m_NIndexDBIn = 1;
    for (int iIndexIn = 0; iIndexIn < NIndexIn; iIndexIn++) {
        m_NIndexDBIn *= (m_maxIndexIn[iIndexIn] - m_minIndexIn[iIndexIn] + 1);
    }
    for (int iIndexDBIn = 0; iIndexDBIn < m_NIndexDBIn; iIndexDBIn++) {
        m_indexDBIn.push_back(-1);
    }
 
    const int size = m_database.size();
    for (int i = 0; i < size; i++) {
        int tmpValIndexIn[NIndexIn];
        for (int iIndexIn = 0; iIndexIn < NIndexIn; iIndexIn++) {
            tmpValIndexIn[iIndexIn] = m_database.at(i).at(IndexIn[iIndexIn]);
        }
        m_indexDBIn.at(convertIndexDBIn(tmpValIndexIn)) = i;
    }
}

◆ makeIndexDBOut()

void MuonTGC_Cabling::TGCDatabaseASDToPP::makeIndexDBOut ( )

privatevirtual

Make the IndexDBOut table.

Definition at line 295 of file TGCDatabaseASDToPP.cxx.

                                        {
    m_NIndexDBOut = 1;
    for (int iIndexOut = 0; iIndexOut < NIndexOut; iIndexOut++) {
        m_NIndexDBOut *=
            (m_maxIndexOut[iIndexOut] - m_minIndexOut[iIndexOut] + 1);
    }
    for (int iIndexDBOut = 0; iIndexDBOut < m_NIndexDBOut; iIndexDBOut++) {
        m_indexDBOut.push_back(-1);
    }
 
    const int size = m_database.size();
    for (int i = 0; i < size; i++) {
        int tmpValIndexOut[NIndexOut];
        for (int iIndexOut = 0; iIndexOut < NIndexOut; iIndexOut++) {
            tmpValIndexOut[iIndexOut] =
                m_database.at(i).at(IndexOut[iIndexOut]);
        }
        m_indexDBOut.at(convertIndexDBOut(tmpValIndexOut)) = i;
    }
}

◆ operator=()

TGCDatabaseASDToPP & MuonTGC_Cabling::TGCDatabaseASDToPP::operator= ( const TGCDatabaseASDToPP & right )

private

hidden assignment operator

◆ readDB()

void MuonTGC_Cabling::TGCDatabaseASDToPP::readDB ( )

overrideprivatevirtual

Reimplemented from MuonTGC_Cabling::TGCDatabase.

Definition at line 182 of file TGCDatabaseASDToPP.cxx.

                                {
    std::ifstream file(m_filename.c_str());
    std::string buf;
 
    for (int iIndexIn = 0; iIndexIn < NIndexIn; iIndexIn++) {
        m_maxIndexIn[iIndexIn] = 0;
        m_minIndexIn[iIndexIn] = 9999;
    }
    for (int iIndexOut = 0; iIndexOut < NIndexOut; iIndexOut++) {
        m_maxIndexOut[iIndexOut] = 0;
        m_minIndexOut[iIndexOut] = 9999;
    }
 
    while (getline(file, buf)) {
        if (buf.substr(0, m_blockname.size()) == m_blockname) {
            break;
        }
    }
 
    while (getline(file, buf)) {
        if (buf.substr(0, 1) == "E" || buf.substr(0, 1) == "F") {
            break;
        }
        std::istringstream line(buf);
        std::vector<int> entry;
        for (int i = 0; i < DATABASESIZE - 2; i++) {
            int temp = -1;
            line >> temp;
            entry.push_back(temp);
        }
        m_database.push_back(std::move(entry));
    }
 
    file.close();
 
    int nline = 0;
    const unsigned int database_size = m_database.size();
    for (unsigned int i = 0; i < database_size; i++) {
        // line is defined in whole sector. [0..n]
        if (i > 0 && m_database[i].at(0) != m_database[i - 1].at(0)) {
            nline = 0;
        }
        m_database[i].push_back(nline++);
 
        if (i == database_size - 1 ||
            m_database[i].at(0) != m_database[i + 1].at(0) ||
            m_database[i].at(1) != m_database[i + 1].at(1)) {
            // increase with R in chamber    [0..n]
            int totline = m_database[i].at(2) + 1;
            //coverity[TAINTED_SCALAR]
            for (int j = 0; j < totline; j++) {
                m_database[i - j].push_back(j);
            }
        }
    }
 
    for (unsigned int i = 0; i < database_size; i++) {
        for (int j = 0; j < DATABASESIZE; j++) {
            int temp = m_database[i].at(j);
            int k = ReverseIndexOut[j];
            if (k >= 0) {
                if (m_maxIndexOut[k] < temp) {
                    m_maxIndexOut[k] = temp;
                }
                if (m_minIndexOut[k] > temp) {
                    m_minIndexOut[k] = temp;
                }
            }
 
            k = ReverseIndexIn[j];
            if (k >= 0) {
                if (m_maxIndexIn[k] < temp) {
                    m_maxIndexIn[k] = temp;
                }
                if (m_minIndexIn[k] > temp) {
                    m_minIndexIn[k] = temp;
                }
            }
        }
    }
 
    makeIndexDBIn();
    makeIndexDBOut();
}

◆ update()

bool MuonTGC_Cabling::TGCDatabaseASDToPP::update ( const std::vector< int > & input )

overridevirtual

Reimplemented from MuonTGC_Cabling::TGCDatabase.

Definition at line 55 of file TGCDatabaseASDToPP.cxx.

                                                           {
    int ip = find(input);
    if (ip < 0) {
        return false;
    }
 
    int tmpValIndexOut[NIndexOut];
    for (int iIndexOut = 0; iIndexOut < NIndexOut; iIndexOut++) {
        tmpValIndexOut[iIndexOut] = input.at(IndexOut[iIndexOut]);
    }
 
    bool over_range = false;
    for (int iIndexOut = 0; iIndexOut < NIndexOut; iIndexOut++) {
        if (m_maxIndexOut[iIndexOut] < tmpValIndexOut[iIndexOut]) {
            m_maxIndexOut[iIndexOut] = tmpValIndexOut[iIndexOut];
            over_range = true;
        }
        if (m_minIndexOut[iIndexOut] > tmpValIndexOut[iIndexOut]) {
            m_minIndexOut[iIndexOut] = tmpValIndexOut[iIndexOut];
            over_range = true;
        }
    }
    if (over_range) {
        m_indexDBOut.clear();
        makeIndexDBOut();
    }
 
    int converted = convertIndexDBOut(tmpValIndexOut);
    if (converted < 0 || converted >= m_NIndexDBOut) {
        return false;
    }
 
    m_indexDBOut.at(converted) = ip;
 
    m_database[ip].at(3) = input.at(3);
    m_database[ip].at(4) = input.at(4);
    m_database[ip].at(5) = input.at(5);
 
    return true;
}

Member Data Documentation

◆ IndexIn

const int MuonTGC_Cabling::TGCDatabaseASDToPP::IndexIn = {0, 1, 6}

static

Definition at line 30 of file TGCDatabaseASDToPP.h.

◆ IndexOut

const int MuonTGC_Cabling::TGCDatabaseASDToPP::IndexOut = {3, 4, 5}

static

Definition at line 33 of file TGCDatabaseASDToPP.h.

◆ m_blockname

std::string MuonTGC_Cabling::TGCDatabase::m_blockname

protectedinherited

Definition at line 55 of file TGCDatabase.h.

◆ m_database

std::vector<std::vector<int> > MuonTGC_Cabling::TGCDatabase::m_database

protectedinherited

Definition at line 56 of file TGCDatabase.h.

◆ m_filename

std::string MuonTGC_Cabling::TGCDatabase::m_filename

protectedinherited

Definition at line 54 of file TGCDatabase.h.

◆ m_indexDBIn

std::vector<int> MuonTGC_Cabling::TGCDatabaseASDToPP::m_indexDBIn

private

Definition at line 85 of file TGCDatabaseASDToPP.h.

◆ m_indexDBOut

std::vector<int> MuonTGC_Cabling::TGCDatabaseASDToPP::m_indexDBOut

private

Definition at line 95 of file TGCDatabaseASDToPP.h.

◆ m_isCommon

bool MuonTGC_Cabling::TGCDatabaseASDToPP::m_isCommon

private

This bool variable is used to know the database is common or sector specific.

Definition at line 102 of file TGCDatabaseASDToPP.h.

◆ m_maxIndexIn

int MuonTGC_Cabling::TGCDatabaseASDToPP::m_maxIndexIn[NIndexIn] {}

private

Definition at line 87 of file TGCDatabaseASDToPP.h.

87{};

◆ m_maxIndexOut

int MuonTGC_Cabling::TGCDatabaseASDToPP::m_maxIndexOut[NIndexOut] {}

private

Definition at line 97 of file TGCDatabaseASDToPP.h.

97{};

◆ m_minIndexIn

int MuonTGC_Cabling::TGCDatabaseASDToPP::m_minIndexIn[NIndexIn] {}

private

Definition at line 88 of file TGCDatabaseASDToPP.h.

88{};

◆ m_minIndexOut

int MuonTGC_Cabling::TGCDatabaseASDToPP::m_minIndexOut[NIndexOut] {}

private

Definition at line 98 of file TGCDatabaseASDToPP.h.

98{};

◆ m_NIndexDBIn

int MuonTGC_Cabling::TGCDatabaseASDToPP::m_NIndexDBIn = 0

private

Definition at line 86 of file TGCDatabaseASDToPP.h.

◆ m_NIndexDBOut

int MuonTGC_Cabling::TGCDatabaseASDToPP::m_NIndexDBOut = 0

private

Definition at line 96 of file TGCDatabaseASDToPP.h.

◆ m_type

DatabaseType MuonTGC_Cabling::TGCDatabase::m_type

privateinherited

Definition at line 59 of file TGCDatabase.h.

◆ ReverseIndexIn

const int MuonTGC_Cabling::TGCDatabaseASDToPP::ReverseIndexIn

static

Initial value:

= {0, 1, -1, -1,

-1, -1, 2, -1}

Definition at line 31 of file TGCDatabaseASDToPP.h.

◆ ReverseIndexOut

const int MuonTGC_Cabling::TGCDatabaseASDToPP::ReverseIndexOut

static

Initial value:

= {-1, -1, -1, 0,

1, 2, -1, -1}

Definition at line 34 of file TGCDatabaseASDToPP.h.

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

Public Types

Public Member Functions

Static Public Attributes

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ DATABASESIZE

◆ DatabaseType

◆ INDEXIN

◆ INDEXOUT

Constructor & Destructor Documentation

◆ TGCDatabaseASDToPP() [1/3]

◆ TGCDatabaseASDToPP() [2/3]

◆ ~TGCDatabaseASDToPP()

◆ TGCDatabaseASDToPP() [3/3]

Member Function Documentation

◆ convertIndexDBIn()

◆ convertIndexDBOut()

◆ find()

◆ getDatabaseType()

◆ getEntry()

◆ getEntrySize()

◆ getIndexDBIn()

◆ getIndexDBOut()

◆ getindexDBVectorIn()

◆ getindexDBVectorOut()

◆ getMaxEntry()

◆ getmaxIndexIn()

◆ getmaxIndexOut()

◆ getminIndexIn()

◆ getminIndexOut()

◆ getNIndexDBIn()

◆ getNIndexDBOut()

◆ isCommon()

◆ makeIndexDBIn()

◆ makeIndexDBOut()

◆ operator=()

◆ readDB()

◆ update()

Member Data Documentation

◆ IndexIn

◆ IndexOut

◆ m_blockname

◆ m_database

◆ m_filename

◆ m_indexDBIn

◆ m_indexDBOut

◆ m_isCommon

◆ m_maxIndexIn

◆ m_maxIndexOut

◆ m_minIndexIn

◆ m_minIndexOut

◆ m_NIndexDBIn

◆ m_NIndexDBOut

◆ m_type

◆ ReverseIndexIn

◆ ReverseIndexOut