RegSelectorMapElement Class Reference

#include <RegSelectorMapElement.h>

Collaboration diagram for RegSelectorMapElement:

Public Member Functions
	RegSelectorMapElement ()
int	layerDiskPosition () const
int	layerDiskNumber () const
double	etaMin (const IdentifierHash hashId) const
double	etaMax (IdentifierHash hashId) const
double	phiMin (IdentifierHash hashId) const
double	phiMax (IdentifierHash hashId) const
const std::vector< IdentifierHash > &	hashId () const
double	etaminElem () const
double	etamaxElem () const
double	phiminElem () const
double	phimaxElem () const
double	phiminElem ()
	these phi*Elem() functions are some of the worst functions I have ever come accross: if the value it has is larger(smaller) than some threshold, it sets the value to some new value, which is also larger (and smaller) than the same threshold, so that every subsequent time it is called, it will be setting the value to this too-large (or too-small) value what it sthe point of it ? Why does it need to change this value at all ? If we want to find the value we should check all the elements in one place, and then set the value once and for all, and not mess about setting it to already out-of-range values in the accessor. More...
double	phimaxElem ()
void	findMaxMinElem (void)
void	additem (const IdentifierHash hashId, const double etaMin, const double etaMax, const double phiMin, const double phiMax, const int layerDiskNumber, const int layerDiskPosition, const uint32_t robId)
void	selection (double etaminIn, double etamaxIn, double phiminIn, double phimaxIn, std::set< IdentifierHash > &outset) const
void	selectionRobIdUint (double etaminIn, double etamaxIn, double phiminIn, double phimaxIn, std::set< uint32_t > &outset) const

Private Member Functions
void	insertElementInVector (double etaminIn, double etamaxIn, double phiminIn, double phimaxIn, IdentifierHash hashIdIn, uint32_t robIdIn)
void	insertNumberElement (int numberIn)
void	insertPositionElement (int position)
void	findHash (double etaminIn, double etamaxIn, double phiminIn, double phimaxIn, std::set< IdentifierHash > &outset) const
void	findRobId (double etaminIn, double etamaxIn, double phiminIn, double phimaxIn, std::set< uint32_t > &outset) const

Private Attributes
int	m_position
int	m_number
std::vector< double >	m_etamin
std::vector< double >	m_etamax
std::vector< double >	m_phimin
std::vector< double >	m_phimax
std::vector< IdentifierHash >	m_hashId
std::vector< uint32_t >	m_robId
double	m_etaminValue
double	m_etamaxValue
double	m_phiminValue
double	m_phimaxValue

Detailed Description

Definition at line 17 of file RegSelectorMapElement.h.

Constructor & Destructor Documentation

RegSelectorMapElement()

RegSelectorMapElement::RegSelectorMapElement

(

)

Definition at line 11 of file RegSelectorMapElement.cxx.

                                            {
  m_position = 0;
  m_number = 0;
}

Member Function Documentation

additem()

void RegSelectorMapElement::additem	(	const IdentifierHash	hashId,
		const double	etaMin,
		const double	etaMax,
		const double	phiMin,
		const double	phiMax,
		const int	layerDiskNumber,
		const int	layerDiskPosition,
		const uint32_t	robId
	)

Definition at line 189 of file RegSelectorMapElement.cxx.

                                             {
 
  insertElementInVector( etaMin, etaMax, phiMin, phiMax, hashId, robId);
  insertNumberElement( layerDiskNumber );
  insertPositionElement( layerDiskPosition );
}

etaMax()

double RegSelectorMapElement::etaMax

(

IdentifierHash

hashId

)

const

Definition at line 102 of file RegSelectorMapElement.cxx.

                                                                  {
  return m_etamax[ hashId ];
}

etamaxElem()

double RegSelectorMapElement::etamaxElem

(

)

const

Definition at line 118 of file RegSelectorMapElement.cxx.

                                               {
  return m_etamaxValue;
}

etaMin()

double RegSelectorMapElement::etaMin

(

const IdentifierHash

hashId

)

const

Definition at line 98 of file RegSelectorMapElement.cxx.

                                                                        {
  return m_etamin[ hashId ];
}

etaminElem()

double RegSelectorMapElement::etaminElem

(

)

const

Definition at line 114 of file RegSelectorMapElement.cxx.

                                               {
  return m_etaminValue;
}

findHash()

void RegSelectorMapElement::findHash ( double  etaminIn, double  etamaxIn, double  phiminIn, double  phimaxIn, std::set< IdentifierHash > &  outset  ) const

private

Definition at line 54 of file RegSelectorMapElement.cxx.

                                                             {
  int vecsize = m_etamin.size();
  double phiTmpMin = phiminElem();
  double phiTmpMax = phimaxElem();
 
  for(int i= 0; i < vecsize; i++){
    if( (etaminIn <= m_etamax[i]) && (etamaxIn >= m_etamin[i]) ){
      if( m_phimin[i] < m_phimax[i]){
    if( (phiminIn <= m_phimax[i]) && (phimaxIn >= m_phimin[i]) )
      outset.insert(m_hashId[i]);
      }
      else{
    if( ((phiminIn <= m_phimax[i]) && (phimaxIn >= phiTmpMin )) ||
        ((phiminIn <= phiTmpMax )  && (phimaxIn >= m_phimin[i])) )
      outset.insert(m_hashId[i]);
      }
    }
  }
}

findMaxMinElem()

void RegSelectorMapElement::findMaxMinElem

(

void

)

Definition at line 173 of file RegSelectorMapElement.cxx.

                                              {
  m_etaminValue = 1000; m_etamaxValue = -1000;
  m_phiminValue = 1000; m_phimaxValue = -1000;
  int vecsize = m_etamin.size();
  for(int i = 0; i < vecsize; i++){
    if( m_etamin[i] < m_etaminValue )
      m_etaminValue = m_etamin[i];
    if( m_etamax[i] > m_etamaxValue )
      m_etamaxValue = m_etamax[i];
    if( m_phimin[i] < m_phiminValue )
      m_phiminValue = m_phimin[i];
    if( m_phimax[i] > m_phimaxValue )
      m_phimaxValue = m_phimax[i];
  }
}

findRobId()

void RegSelectorMapElement::findRobId ( double  etaminIn, double  etamaxIn, double  phiminIn, double  phimaxIn, std::set< uint32_t > &  outset  ) const

private

Definition at line 76 of file RegSelectorMapElement.cxx.

                                                        {
  int      vecsize = m_etamin.size();
  double phiTmpMin = phiminElem();
  double phiTmpMax = phimaxElem();
  
  for(int i= 0; i < vecsize; i++){
    if( (etaminIn <= m_etamax[i]) && (etamaxIn >= m_etamin[i]) ){
      if( m_phimin[i] < m_phimax[i]){
    if( (phiminIn <= m_phimax[i]) && (phimaxIn >= m_phimin[i]) )
           outset.insert( m_robId[i]);
      }
      else{
    if( ((phiminIn <= m_phimax[i]) && (phimaxIn >= phiTmpMin )) ||
        ((phiminIn <= phiTmpMax )  && (phimaxIn >= m_phimin[i])) )
        outset.insert( m_robId[i]);
      }
    }
  }
}

hashId()

const std::vector< IdentifierHash > & RegSelectorMapElement::hashId

(

)

const

Definition at line 24 of file RegSelectorMapElement.cxx.

                                                                     {
  return m_hashId;
}

insertElementInVector()

void RegSelectorMapElement::insertElementInVector ( double  etaminIn, double  etamaxIn, double  phiminIn, double  phimaxIn, IdentifierHash  hashIdIn, uint32_t  robIdIn  )

private

Definition at line 28 of file RegSelectorMapElement.cxx.

                                           {
  if(etaminIn > etamaxIn){
      m_etamin.push_back(etamaxIn);
      m_etamax.push_back(etaminIn);
  }
  else{
    m_etamin.push_back(etaminIn);
    m_etamax.push_back(etamaxIn);
  }
 
  m_phimin.push_back(phiminIn);
  m_phimax.push_back(phimaxIn);
  m_hashId.push_back(hashIdIn);
  m_robId.push_back(robIdIn);
}

insertNumberElement()

void RegSelectorMapElement::insertNumberElement ( int  numberIn )

private

Definition at line 46 of file RegSelectorMapElement.cxx.

                                                           {
  m_number = numberIn;
}

insertPositionElement()

void RegSelectorMapElement::insertPositionElement ( int  position )

private

Definition at line 50 of file RegSelectorMapElement.cxx.

                                                               {
  m_position = positionIn;
}

layerDiskNumber()

int RegSelectorMapElement::layerDiskNumber

(

)

const

Definition at line 20 of file RegSelectorMapElement.cxx.

                                                    {
  return m_number;
}

layerDiskPosition()

int RegSelectorMapElement::layerDiskPosition

(

)

const

Definition at line 16 of file RegSelectorMapElement.cxx.

                                                      {
  return m_position;
}

phiMax()

double RegSelectorMapElement::phiMax

(

IdentifierHash

hashId

)

const

Definition at line 110 of file RegSelectorMapElement.cxx.

                                                                  {
  return m_phimax[ hashId ];
}

phimaxElem() [1/2]

double RegSelectorMapElement::phimaxElem

(

)

Definition at line 148 of file RegSelectorMapElement.cxx.

                                         {
  if(m_phimaxValue > (3*M_PI)/2)
    m_phimaxValue = 2*M_PI;
  else
    m_phimaxValue = M_PI;
  return m_phimaxValue;
}

phimaxElem() [2/2]

double RegSelectorMapElement::phimaxElem

(

)

const

Definition at line 164 of file RegSelectorMapElement.cxx.

                                               {
  if(m_phimaxValue > (3*M_PI)/2)
    return 2*M_PI;
  else
    return M_PI;
  return m_phimaxValue;
}

phiMin()

double RegSelectorMapElement::phiMin

(

IdentifierHash

hashId

)

const

Definition at line 106 of file RegSelectorMapElement.cxx.

                                                                  {
  return m_phimin[ hashId ];
}

phiminElem() [1/2]

double RegSelectorMapElement::phiminElem

(

)

these phi*Elem() functions are some of the worst functions I have ever come accross: if the value it has is larger(smaller) than some threshold, it sets the value to some new value, which is also larger (and smaller) than the same threshold, so that every subsequent time it is called, it will be setting the value to this too-large (or too-small) value what it sthe point of it ? Why does it need to change this value at all ? If we want to find the value we should check all the elements in one place, and then set the value once and for all, and not mess about setting it to already out-of-range values in the accessor.

So what this means is that when calling this function to to get the limit for the map, it might actually change that said limit, and give you some hardcoded limit instead. Why is the limit set to be the value that it is ? working out how to replace this function will be a complete pain, The sooner we get rid of this awful class the better

Definition at line 140 of file RegSelectorMapElement.cxx.

                                         {
  if(m_phiminValue < -M_PI/2)
    m_phiminValue = -M_PI;
  else
    m_phiminValue = 0;
  return m_phiminValue;
}

phiminElem() [2/2]

double RegSelectorMapElement::phiminElem

(

)

const

Definition at line 156 of file RegSelectorMapElement.cxx.

                                               {
  if(m_phiminValue < -M_PI/2)
    return -M_PI;
  else
    return 0;
  return m_phiminValue;
}

selection()

void RegSelectorMapElement::selection	(	double	etaminIn,
		double	etamaxIn,
		double	phiminIn,
		double	phimaxIn,
		std::set< IdentifierHash > &	outset
	)		const

Definition at line 199 of file RegSelectorMapElement.cxx.

                                                             {
  if(phiminIn > phimaxIn){
    double tmp = phimaxElem();
    findHash(etaminIn, etamaxIn, phiminIn, tmp, outset);
    tmp = phiminElem();
    findHash(etaminIn, etamaxIn, tmp, phimaxIn, outset);
  }
  else{
    findHash(etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
  }
}

selectionRobIdUint()

void RegSelectorMapElement::selectionRobIdUint	(	double	etaminIn,
		double	etamaxIn,
		double	phiminIn,
		double	phimaxIn,
		std::set< uint32_t > &	outset
	)		const

Definition at line 213 of file RegSelectorMapElement.cxx.

                                                         {
  if(phiminIn > phimaxIn){
    double tmp = phimaxElem();
    findRobId(etaminIn, etamaxIn, phiminIn, tmp, outset);
    tmp = phiminElem();
    findRobId(etaminIn, etamaxIn, tmp, phimaxIn, outset);
  }
  else{
    findRobId(etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
  }
}

Member Data Documentation

m_etamax

std::vector<double> RegSelectorMapElement::m_etamax

private

Definition at line 61 of file RegSelectorMapElement.h.

m_etamaxValue

double RegSelectorMapElement::m_etamaxValue

private

Definition at line 65 of file RegSelectorMapElement.h.

m_etamin

std::vector<double> RegSelectorMapElement::m_etamin

private

Definition at line 61 of file RegSelectorMapElement.h.

m_etaminValue

double RegSelectorMapElement::m_etaminValue

private

Definition at line 65 of file RegSelectorMapElement.h.

m_hashId

std::vector<IdentifierHash> RegSelectorMapElement::m_hashId

private

Definition at line 63 of file RegSelectorMapElement.h.

m_number

int RegSelectorMapElement::m_number

private

Definition at line 60 of file RegSelectorMapElement.h.

m_phimax

std::vector<double> RegSelectorMapElement::m_phimax

private

Definition at line 62 of file RegSelectorMapElement.h.

m_phimaxValue

double RegSelectorMapElement::m_phimaxValue

private

Definition at line 66 of file RegSelectorMapElement.h.

m_phimin

std::vector<double> RegSelectorMapElement::m_phimin

private

Definition at line 62 of file RegSelectorMapElement.h.

m_phiminValue

double RegSelectorMapElement::m_phiminValue

private

Definition at line 66 of file RegSelectorMapElement.h.

m_position

int RegSelectorMapElement::m_position

private

Definition at line 59 of file RegSelectorMapElement.h.

m_robId

std::vector<uint32_t> RegSelectorMapElement::m_robId

private

Definition at line 64 of file RegSelectorMapElement.h.

---

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

• RegSelectorMapElement.h
• RegSelectorMapElement.cxx