#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 phiElem() 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;
   m_etaminValue = 1000;
   m_etamaxValue = -1000;
   m_phiminValue = 1000;
   m_phimaxValue = -1000;
 }

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 193 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 106 of file RegSelectorMapElement.cxx.

                                                                   {
   return m_etamax[ hashId ];
 }

◆ etamaxElem()

double RegSelectorMapElement::etamaxElem ( ) const

Definition at line 122 of file RegSelectorMapElement.cxx.

                                                {
   return m_etamaxValue;
 }

◆ etaMin()

double RegSelectorMapElement::etaMin ( const IdentifierHash hashId ) const

Definition at line 102 of file RegSelectorMapElement.cxx.

                                                                         {
   return m_etamin[ hashId ];
 }

◆ etaminElem()

double RegSelectorMapElement::etaminElem ( ) const

Definition at line 118 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 58 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 177 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 80 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 28 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 32 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 50 of file RegSelectorMapElement.cxx.

                                                            {
   m_number = numberIn;
 }

◆ insertPositionElement()

void RegSelectorMapElement::insertPositionElement ( int position )

private

Definition at line 54 of file RegSelectorMapElement.cxx.

                                                                {
   m_position = positionIn;
 }

◆ layerDiskNumber()

int RegSelectorMapElement::layerDiskNumber ( ) const

Definition at line 24 of file RegSelectorMapElement.cxx.

                                                     {
   return m_number;
 }

◆ layerDiskPosition()

int RegSelectorMapElement::layerDiskPosition ( ) const

Definition at line 20 of file RegSelectorMapElement.cxx.

                                                       {
   return m_position;
 }

◆ phiMax()

double RegSelectorMapElement::phiMax ( IdentifierHash hashId ) const

Definition at line 114 of file RegSelectorMapElement.cxx.

                                                                   {
   return m_phimax[ hashId ];
 }

◆ phimaxElem() [1/2]

double RegSelectorMapElement::phimaxElem ( )

Definition at line 152 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 168 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 110 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 144 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 160 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 203 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 217 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:

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ RegSelectorMapElement()

Member Function Documentation

◆ additem()

◆ etaMax()

◆ etamaxElem()

◆ etaMin()

◆ etaminElem()

◆ findHash()

◆ findMaxMinElem()

◆ findRobId()

◆ hashId()

◆ insertElementInVector()

◆ insertNumberElement()

◆ insertPositionElement()

◆ layerDiskNumber()

◆ layerDiskPosition()

◆ phiMax()

◆ phimaxElem() [1/2]

◆ phimaxElem() [2/2]

◆ phiMin()

◆ phiminElem() [1/2]

◆ phiminElem() [2/2]

◆ selection()

◆ selectionRobIdUint()

Member Data Documentation

◆ m_etamax

◆ m_etamaxValue

◆ m_etamin

◆ m_etaminValue

◆ m_hashId

◆ m_number

◆ m_phimax

◆ m_phimaxValue

◆ m_phimin

◆ m_phiminValue

◆ m_position

◆ m_robId