MuonTGC_Cabling::TGCDatabaseASDToPP Class Reference

#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 (void)
	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 (void) const
virtual int	getEntry (int entry, int column) const
virtual int	getEntrySize (int entry) const
virtual int	getMaxEntry (void) const

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

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

Private Member Functions
virtual void	readDB (void) override
	TGCDatabaseASDToPP (void)
virtual void	makeIndexDBIn (void)
	Make the IndexDBIn table.
virtual int	convertIndexDBIn (int *indexIn) const
	Get the interal number, which is between 0 and NIndexDBIn-1.
virtual void	makeIndexDBOut (void)
	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 13 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 30 of file TGCDatabaseASDToPP.h.

{DATABASESIZE=8}; 

DatabaseType

enum MuonTGC_Cabling::TGCDatabase::DatabaseType

inherited

Enumerator
NoDatabaseType
ASDToPP
InPP
PPToSL
SLBToROD
MaxDatabaseType

Definition at line 17 of file TGCDatabase.h.

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

INDEXIN

enum MuonTGC_Cabling::TGCDatabaseASDToPP::INDEXIN

Enumerator
NIndexIn

Definition at line 31 of file TGCDatabaseASDToPP.h.

{NIndexIn=3};  

INDEXOUT

enum MuonTGC_Cabling::TGCDatabaseASDToPP::INDEXOUT

Enumerator
NIndexOut

Definition at line 34 of file TGCDatabaseASDToPP.h.

{NIndexOut=3}; 

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 18 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 37 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 ( void )

virtual

Destructor.

Definition at line 51 of file TGCDatabaseASDToPP.cxx.

{
}

TGCDatabaseASDToPP() [3/3]

MuonTGC_Cabling::TGCDatabaseASDToPP::TGCDatabaseASDToPP ( void )

inlineprivate

Definition at line 81 of file TGCDatabaseASDToPP.h.

{}

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 281 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 311 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 93 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 ( void ) const

inlineinherited

Definition at line 35 of file TGCDatabase.h.

{ return m_type; }

getEntry()

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

virtualinherited

Definition at line 28 of file TGCDatabase.cxx.

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

getEntrySize()

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

virtualinherited

Definition at line 32 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 108 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 142 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 118 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 152 of file TGCDatabaseASDToPP.cxx.

{
  tmpindexDBOut = m_indexDBOut;
}

getMaxEntry()

int MuonTGC_Cabling::TGCDatabase::getMaxEntry ( void ) const

virtualinherited

Definition at line 36 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 128 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 162 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 135 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 169 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 123 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 157 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 176 of file TGCDatabaseASDToPP.cxx.

{ 
  return m_isCommon; 
} 

makeIndexDBIn()

void MuonTGC_Cabling::TGCDatabaseASDToPP::makeIndexDBIn ( void )

privatevirtual

Make the IndexDBIn table.

Definition at line 261 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 ( void )

privatevirtual

Make the IndexDBOut table.

Definition at line 291 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 ( void )

overrideprivatevirtual

Reimplemented from MuonTGC_Cabling::TGCDatabase.

Definition at line 181 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;
      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 32 of file TGCDatabaseASDToPP.h.

IndexOut

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

static

Definition at line 35 of file TGCDatabaseASDToPP.h.

m_blockname

std::string MuonTGC_Cabling::TGCDatabase::m_blockname

protectedinherited

Definition at line 53 of file TGCDatabase.h.

m_database

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

protectedinherited

Definition at line 54 of file TGCDatabase.h.

m_filename

std::string MuonTGC_Cabling::TGCDatabase::m_filename

protectedinherited

Definition at line 52 of file TGCDatabase.h.

m_indexDBIn

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

private

Definition at line 88 of file TGCDatabaseASDToPP.h.

m_indexDBOut

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

private

Definition at line 98 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 104 of file TGCDatabaseASDToPP.h.

m_maxIndexIn

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

private

Definition at line 90 of file TGCDatabaseASDToPP.h.

{};

m_maxIndexOut

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

private

Definition at line 100 of file TGCDatabaseASDToPP.h.

{};

m_minIndexIn

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

private

Definition at line 91 of file TGCDatabaseASDToPP.h.

{};

m_minIndexOut

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

private

Definition at line 101 of file TGCDatabaseASDToPP.h.

{};

m_NIndexDBIn

int MuonTGC_Cabling::TGCDatabaseASDToPP::m_NIndexDBIn = 0

private

Definition at line 89 of file TGCDatabaseASDToPP.h.

m_NIndexDBOut

int MuonTGC_Cabling::TGCDatabaseASDToPP::m_NIndexDBOut = 0

private

Definition at line 99 of file TGCDatabaseASDToPP.h.

m_type

DatabaseType MuonTGC_Cabling::TGCDatabase::m_type

privateinherited

Definition at line 57 of file TGCDatabase.h.

ReverseIndexIn

const int MuonTGC_Cabling::TGCDatabaseASDToPP::ReverseIndexIn = {0, 1, -1, -1, -1, -1, 2, -1}

static

Definition at line 33 of file TGCDatabaseASDToPP.h.

ReverseIndexOut

const int MuonTGC_Cabling::TGCDatabaseASDToPP::ReverseIndexOut = {-1, -1, -1, 0, 1, 2, -1, -1}

static

Definition at line 36 of file TGCDatabaseASDToPP.h.

---

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

• TGCDatabaseASDToPP.h
• TGCDatabaseASDToPP.cxx