RegSelectorHashMap Class Reference

#include <RegSelectorHashMap.h>

Inheritance diagram for RegSelectorHashMap:

Collaboration diagram for RegSelectorHashMap:

Public Member Functions
virtual void	HashIDList (const IRoiDescriptor &roi, std::vector< IdentifierHash > &idlist) const override
	implementation of the IRegSelUT interface
virtual void	HashIDList (long layer, const IRoiDescriptor &roi, std::vector< IdentifierHash > &idlist) const override
	HashIDList interface declaration. return list of non-repeated IdentifierHash.
virtual void	ROBIDList (const IRoiDescriptor &roi, std::vector< uint32_t > &roblist) const override
	rob methods
virtual void	ROBIDList (long layer, const IRoiDescriptor &roi, std::vector< uint32_t > &roblist) const override
	ROBIDList interface declaration. This interface can be used by the ID subdetectors. A list of non-repeated ROBIDs (uint_32_t) is returned by a reference.
virtual	~RegSelectorHashMap () override=default
double	etaminValue () const
	rest of the class implementation
double	etamaxValue () const
double	phiminValue () const
double	phimaxValue () const
const std::vector< double > &	etaMinOut (void) const
const std::vector< double > &	etaMaxOut (void) const
const std::vector< double > &	phiMinOut (void) const
const std::vector< double > &	phiMaxOut (void) const
void	mountDataStruct (void)
const std::vector< IdentifierHash > &	hashIdOut (void) const
const std::vector< std::vector< uint32_t > > &	robIdOut (void) const
const std::vector< int > &	sampleOut (void) const
const std::vector< int > &	layerOut (void) const
void	regionSelectorRobIdUint (double etaminIn, double etamaxIn, double phiminIn, double phimaxIn, std::vector< uint32_t > &outRobIDList) const
void	regionSelectorRobIdUint (int sampling, double etaminIn, double etamaxIn, double phiminIn, double phimaxIn, std::vector< uint32_t > &outRobIDList) const
void	regionSelector (double etaminIn, double etamaxIn, double phiminIn, double phimaxIn, std::vector< IdentifierHash > &outList) const
void	regionSelector (int sampling, double etaminIn, double etamaxIn, double phiminIn, double phimaxIn, std::vector< IdentifierHash > &outList) const
void	initvar (void)
StatusCode	read (const char *filename)
void	addLut (const RegionSelectorLUT *detLut)
void	summaryDataFile (std::list< RegSelectorMapElement > &dataList)
void	verifyInputs (double &etaminIn, double &etamaxIn, double &phiminIn, double &phimaxIn) const
void	verifyROBIDOutput (double etaminIn, double etamaxIn, double phiminIn, double phimaxIn, std::vector< uint32_t > &outputIdlist) const
void	verifyROBIDOutput (int sampling, double etaminIn, double etamaxIn, double phiminIn, double phimaxIn, std::vector< uint32_t > &outputIdlist) const
void	verifyOutput (double etaminIn, double etamaxIn, double phiminIn, double phimaxIn, std::vector< IdentifierHash > *outputIdlist) const
void	verifyOutput (int sampling, double etaminIn, double etamaxIn, double phiminIn, double phimaxIn, std::vector< IdentifierHash > *outputIdlist) const
void	getEtaPhi (IdentifierHash hashId, double *etaMin, double *etaMax, double *phiMin, double *phiMax) const
void	DisableMissingROBs (const std::vector< uint32_t > &vec)

Protected Types
template<typename C, typename T>
using	handler = void (C::*)(const IRoiDescriptor& , std::vector<T>& ) const
template<typename C, typename T>
using	handler_layer = void (C::*)(long layer, const IRoiDescriptor& , std::vector<T>& ) const

Protected Member Functions
virtual void	HashIDList_internal (const IRoiDescriptor &roi, std::vector< IdentifierHash > &idlist) const
	internal implementation of the IRegSelUT interface
virtual void	HashIDList_internal (long layer, const IRoiDescriptor &roi, std::vector< IdentifierHash > &idlist) const
virtual void	ROBIDList_internal (const IRoiDescriptor &roi, std::vector< uint32_t > &roblist) const
	rob methods
virtual void	ROBIDList_internal (long layer, const IRoiDescriptor &roi, std::vector< uint32_t > &roblist) const
template<typename C, typename T>
void	IDList (const IRoiDescriptor &roi, std::vector< T > &idlist, handler< C, T > lister) const
template<typename C, typename T>
void	IDList_layer (long layer, const IRoiDescriptor &roi, std::vector< T > &idlist, handler_layer< C, T > lister) const

Static Protected Member Functions
template<typename T>
static void	removeDuplicates (std::vector< T > &vec)
	useful for removing duplicates if required ...

Private Member Functions
void	populateMatrix (int iPage, IdentifierHash value)
void	populateMatrixRobId (int iPage, uint32_t value)
void	initMatrix (void)
void	writeLine (const int &layer, const IdentifierHash &hashId, const std::vector< uint32_t > &robId, const double &emin, const double &emax, const double &pmin, const double &pmax, const int &samp)
int	MyRound (double pdValue)
void	regionSelectorIN (const int &sampling, const double &etaminIn, const double &etamaxIn, const double &phiminIn, const double &phimaxIn, std::vector< IdentifierHash > *outListIH) const
void	regionSelectorINROB (const int &sampling, const double &etaminIn, const double &etamaxIn, const double &phiminIn, const double &phimaxIn, std::vector< uint32_t > *outList) const
void	phiCondition (const std::vector< IdentifierHash > &identifier, int i, double etaminIn, double etamaxIn, double phiminIn, double phimaxIn, double etamin, double etamax, std::set< IdentifierHash > *outset) const
void	phiConditionRobId (const std::vector< std::vector< uint32_t > > &identifier, int i, double etaminIn, double etamaxIn, double phiminIn, double phimaxIn, double etamin, double etamax, std::set< uint32_t > *outset) const
void	findIdentifier (std::vector< IdentifierHash > &auxsetIH, const int iXBeg, const int iXEnd, const int iYBeg, const int iYEnd, const int iPage) const
void	findIdentifierROB (std::vector< uint32_t > &auxset, const int iXBeg, const int iXEnd, const int iYBeg, const int iYEnd, const int iPage) const

Private Attributes
double	m_stepMinPhi {}
double	m_stepMinEta {}
std::list< RegSelectorMapElement >	m_dataList
std::vector< int >	m_sample
std::vector< int >	m_layer
std::vector< IdentifierHash >	m_hashId
std::vector< double >	m_etamin
std::vector< double >	m_etamax
std::vector< double >	m_phimin
std::vector< double >	m_phimax
std::vector< std::vector< uint32_t > >	m_robId
double	m_etaminDet {}
double	m_etamaxDet {}
double	m_phiminDet {}
double	m_phimaxDet {}
int	m_NumSamples {}
int	m_iColumns {}
int	m_iLines {}
bool	m_readFromFile {}
std::vector< std::vector< uint32_t > >	m_robIDMap
std::vector< IdentifierHash >	m_hashIDMap

Detailed Description

Definition at line 40 of file RegSelectorHashMap.h.

Member Typedef Documentation

handler

template<typename C, typename T>

using IRegSelLUT::handler = void (C::*)(const IRoiDescriptor& , std::vector<T>& ) const

protectedinherited

Definition at line 85 of file IRegSelLUT.h.

handler_layer

template<typename C, typename T>

using IRegSelLUT::handler_layer = void (C::*)(long layer, const IRoiDescriptor& , std::vector<T>& ) const

protectedinherited

Definition at line 103 of file IRegSelLUT.h.

Constructor & Destructor Documentation

~RegSelectorHashMap()

virtual RegSelectorHashMap::~RegSelectorHashMap ( )

overridevirtualdefault

Member Function Documentation

addLut()

void RegSelectorHashMap::addLut

(

const RegionSelectorLUT *

detLut

)

Definition at line 611 of file RegSelectorHashMap.cxx.

                                                              {
  // unsigned int j;
 
  initvar();
  std::vector<uint32_t> robId_cpy;
 
  // If not readFromFile detLut->maxHash() != 0
  m_readFromFile = (detLut->maxHash() == 0);
  // Assuming that we can have up to 2 ROBs for a given TT
  double etamin(-999.0), etamax(-999.0), phimin(-999.0), phimax(-999.0); 
  int samp(999), layer(999);
  int hash(999);
  int tablesize = detLut->maxHash();
  m_hashId.reserve(tablesize);
  m_robId.reserve(tablesize);
  m_etamin.reserve(tablesize);
  m_etamax.reserve(tablesize);
  m_phimin.reserve(tablesize);
  m_phimax.reserve(tablesize);
  m_layer.reserve(tablesize);
  m_sample.reserve(tablesize);
  
  for( int j=0; j<tablesize; ++j){
    if ( detLut->hashId(j)==hash && detLut->sampling(j)==samp &&
      detLut->etaMin(j)==etamin && detLut->etaMax(j) == etamax &&
          detLut->phiMin(j)==phimin && detLut->phiMax(j) == phimax &&
      detLut->layerDiskNumber(j) == layer ){
        robId_cpy.push_back(detLut->robId(j));
    writeLine(detLut->layerDiskNumber(j),
              detLut->hashId(j),
          robId_cpy,
              detLut->etaMin(j),
              detLut->etaMax(j),
              detLut->phiMin(j),
              detLut->phiMax(j),
              detLut->sampling(j));
          ++j;
     } else { // Write previous line
    if ( j!= 0 )
    writeLine(layer,hash,robId_cpy,etamin,etamax,phimin,phimax,samp);
     }
     robId_cpy.clear();
     robId_cpy.push_back(detLut->robId(j));
     hash=detLut->hashId(j); samp=detLut->sampling(j);
     etamin=detLut->etaMin(j); etamax=detLut->etaMax(j);
     phimin=detLut->phiMin(j); phimax=detLut->phiMax(j);
     layer=detLut->layerDiskNumber(j);
     // After prossessing need to update global vars
     double stepPhi = std::fabs(phimax-phimin);// initial value for phi and eta step
     double stepEta = std::fabs(etamin-etamax);
     m_stepMinPhi = std::min(m_stepMinPhi,stepPhi);
     m_stepMinEta = std::min(m_stepMinEta,stepEta);
     m_etaminDet = std::min(std::min(m_etaminDet,etamin),etamax);
     m_phiminDet = std::min(std::min(m_phiminDet,phimin),phimax);
     m_etamaxDet = std::max(std::max(m_etamaxDet,etamax),etamin);
     m_phimaxDet = std::max(std::max(m_phimaxDet,phimax),phimin);
     m_NumSamples = std::max(m_NumSamples,samp);
  }
  // Shall not forget to save last one
  // Assuming last line is NOT a 2 ROB/TT case
  writeLine(layer,hash,robId_cpy,etamin,etamax,phimin,phimax,samp);
 
}

DisableMissingROBs()

void RegSelectorHashMap::DisableMissingROBs

(

const std::vector< uint32_t > &

vec

)

Definition at line 1029 of file RegSelectorHashMap.cxx.

                                                                         {
    for(size_t i=0;i<vec.size();++i){
        for(size_t j=0;j<m_robIDMap.size();++j){
            for(size_t k=0;k<m_robIDMap[j].size();++k){
               if ( vec[i] == m_robIDMap[j][k] )
                m_robIDMap[j][k] = INITHASH;
            }
        }
    }
}

etaMaxOut()

const std::vector< double > & RegSelectorHashMap::etaMaxOut

(

void

)

const

Definition at line 106 of file RegSelectorHashMap.cxx.

                                                                 {
  return m_etamax;
}

etamaxValue()

double RegSelectorHashMap::etamaxValue

(

)

const

Definition at line 74 of file RegSelectorHashMap.cxx.

                                             {
  return m_etamaxDet;
}

etaMinOut()

const std::vector< double > & RegSelectorHashMap::etaMinOut

(

void

)

const

Definition at line 102 of file RegSelectorHashMap.cxx.

                                                                 {
  return m_etamin;
}

etaminValue()

double RegSelectorHashMap::etaminValue

(

)

const

rest of the class implementation

Definition at line 70 of file RegSelectorHashMap.cxx.

                                             {
  return m_etaminDet;
}

findIdentifier()

void RegSelectorHashMap::findIdentifier ( std::vector< IdentifierHash > & auxsetIH, const int iXBeg, const int iXEnd, const int iYBeg, const int iYEnd, const int iPage ) const

private

Definition at line 971 of file RegSelectorHashMap.cxx.

                                            {
 int xEta, yPhi, iPosition;
 
  for(xEta= iXBeg; xEta < iXEnd; ++xEta){
    for(yPhi=iYBeg; yPhi < iYEnd; ++yPhi){
      iPosition = iPage + (yPhi* m_iColumns + xEta);
      if(m_hashIDMap[iPosition] != INITHASH){
          auxsetIH.push_back(m_hashIDMap[iPosition]);
      }
    }
  }
  
  if(auxsetIH.size()!=0){
    sort(auxsetIH.begin(),auxsetIH.end());
    auxsetIH.erase(unique(auxsetIH.begin(),auxsetIH.end()),auxsetIH.end());
  }
  
}

findIdentifierROB()

void RegSelectorHashMap::findIdentifierROB ( std::vector< uint32_t > & auxset, const int iXBeg, const int iXEnd, const int iYBeg, const int iYEnd, const int iPage ) const

private

Definition at line 993 of file RegSelectorHashMap.cxx.

                                                {
  int xEta, yPhi, iPosition;
  unsigned int i,size_rod;
  
  for(xEta= iXBeg; xEta < iXEnd; ++xEta){
    for(yPhi=iYBeg; yPhi < iYEnd; ++yPhi){
      iPosition = iPage + (yPhi* m_iColumns + xEta);
          size_rod=m_robIDMap[iPosition].size();
          for(i=0; i < size_rod; ++i)
             if ( m_robIDMap[iPosition][i] != INITHASH )
             auxset.push_back(m_robIDMap[iPosition][i]);
      }
    }
 
  if(auxset.size()!=0){
    sort(auxset.begin(),auxset.end());
    auxset.erase(unique(auxset.begin(),auxset.end()),auxset.end());
  }
  
}

getEtaPhi()

void RegSelectorHashMap::getEtaPhi	(	IdentifierHash	hashId,
		double *	etaMin,
		double *	etaMax,
		double *	phiMin,
		double *	phiMax ) const

Definition at line 1019 of file RegSelectorHashMap.cxx.

                                                         {
  
  (*etaMin) = m_etamin[hashId];
  (*etaMax) = m_etamax[hashId];
  (*phiMin) = m_phimin[hashId];
  (*phiMax) = m_phimax[hashId];
}

HashIDList() [1/2]

void RegSelectorHashMap::HashIDList ( const IRoiDescriptor & roi, std::vector< IdentifierHash > & idlist ) const

overridevirtual

implementation of the IRegSelUT interface

implementation of the IRegSelUT interface
hash id methods

hash id methods

Implements IRegSelLUT.

Definition at line 20 of file RegSelectorHashMap.cxx.

                                                                                                        {
  IRegSelLUT::IDList<RegSelectorHashMap>( roi, idlist, &RegSelectorHashMap::HashIDList_internal );
}

HashIDList() [2/2]

void RegSelectorHashMap::HashIDList ( long layer, const IRoiDescriptor & roi, std::vector< IdentifierHash > & idlist ) const

overridevirtual

HashIDList interface declaration. return list of non-repeated IdentifierHash.

Parameters

long	layer, long int to decide which layer within the detector.
IRoiDescriptor	roi, the IRoiDescriptor for the roi, all enabled elements in the roi are found.

Returns

std::vector<IdentifierHash> which is a list of non-repeated Offline Identifier Hash numbers.

Implements IRegSelLUT.

Definition at line 24 of file RegSelectorHashMap.cxx.

                                                                                                                    {;
  IRegSelLUT::IDList_layer<RegSelectorHashMap>( layer, roi, idlist, &RegSelectorHashMap::HashIDList_internal );
}

HashIDList_internal() [1/2]

void RegSelectorHashMap::HashIDList_internal ( const IRoiDescriptor & roi, std::vector< IdentifierHash > & idlist ) const

protectedvirtual

internal implementation of the IRegSelUT interface

implementation of the IRegSelUT interface

hash id methods

Definition at line 44 of file RegSelectorHashMap.cxx.

                                                                                                                 {
  if ( roi.isFullscan() ) regionSelector( -4.8, 4.8, -M_PI, M_PI, idlist );
  regionSelector( roi.etaMinus(), roi.etaPlus(), roi.phiMinus(), roi.phiPlus(), idlist);
}

HashIDList_internal() [2/2]

void RegSelectorHashMap::HashIDList_internal ( long layer, const IRoiDescriptor & roi, std::vector< IdentifierHash > & idlist ) const

protectedvirtual

Definition at line 49 of file RegSelectorHashMap.cxx.

                                                                                                                             {
  if ( roi.isFullscan() ) regionSelector( layer, -4.8, 4.8, -M_PI, M_PI, idlist );
  regionSelector( layer, roi.etaMinus(), roi.etaPlus(), roi.phiMinus(), roi.phiPlus(), idlist);
}

hashIdOut()

const std::vector< IdentifierHash > & RegSelectorHashMap::hashIdOut

(

void

)

const

Definition at line 86 of file RegSelectorHashMap.cxx.

                                                                         {
  return m_hashId;
}

IDList()

template<typename C, typename T>

void IRegSelLUT::IDList ( const IRoiDescriptor & roi, std::vector< T > & idlist, handler< C, T > lister ) const

inlineprotectedinherited

Definition at line 88 of file IRegSelLUT.h.

                                                                                             {
        
    if ( roi.composite() ) {
      idlist.clear();
      for ( unsigned iroi=roi.size() ; iroi-- ;  )  IDList<C>( *(roi.at(iroi)), idlist, lister );
      if ( roi.size()>1 ) IRegSelLUT::removeDuplicates( idlist );
      return;
    }
    
    (dynamic_cast<const C*>(this)->*lister)( roi, idlist ); 
    
  }

IDList_layer()

template<typename C, typename T>

void IRegSelLUT::IDList_layer ( long layer, const IRoiDescriptor & roi, std::vector< T > & idlist, handler_layer< C, T > lister ) const

inlineprotectedinherited

Definition at line 106 of file IRegSelLUT.h.

                                                                                                                     {
    
    if ( roi.composite() ) {
      idlist.clear();
      for ( unsigned iroi=roi.size() ; iroi-- ;  )  IDList_layer<C>( layer, *(roi.at(iroi)), idlist, lister );
      if ( roi.size()>1 ) IRegSelLUT::removeDuplicates( idlist );
      return;
    }
    
    (dynamic_cast<const C*>(this)->*lister)( layer, roi, idlist ); 
    
  }

initMatrix()

void RegSelectorHashMap::initMatrix ( void )

private

Definition at line 263 of file RegSelectorHashMap.cxx.

                                       {
  int k, iPage, iNumRanges;
 
  iNumRanges =  m_NumSamples;
 
  for(k=0;k<=iNumRanges;++k){
    iPage = k * (m_iColumns * m_iLines);
      populateMatrix(iPage, INITHASH);
  }
 
}

initvar()

void RegSelectorHashMap::initvar

(

void

)

Definition at line 546 of file RegSelectorHashMap.cxx.

                                    {
  m_NumSamples = -1;
  m_stepMinPhi = 99;
  m_stepMinEta = 99;
  m_etaminDet = m_phiminDet = 99;
  m_etamaxDet = m_phimaxDet = -99;
}

layerOut()

const std::vector< int > & RegSelectorHashMap::layerOut

(

void

)

const

Definition at line 98 of file RegSelectorHashMap.cxx.

                                                             {
  return m_layer;
}

mountDataStruct()

void RegSelectorHashMap::mountDataStruct

(

void

)

Definition at line 118 of file RegSelectorHashMap.cxx.

                                            {
  int iNumRanges, iRepeatOverX, iRepeatOverY, xEta, yPhi, k;
  int iPage, iPosition, iXeta, iYphi; // , iNumSamples;
  double dEtaMin=-999, dEtaMax=-999, dPhiMin= -999, dPhiMax = -999;
 
  m_iLines = std::floor((m_phimaxDet-m_phiminDet)/m_stepMinPhi);
  m_iColumns = std::floor((m_etamaxDet-m_etaminDet)/m_stepMinEta);
 
  //Number of elements from the vectors (number of different ranges)
  iNumRanges = m_sample.size();
 
  //Creates the m_NumSamples matrix"es"
  // m_NumSamples*iColumns*iLines ->defines the matrix M page
  // Yphi*iColumns+Xeta -> define the element M[X,Y]
 
  // initialize matrix
  initMatrix();
 
  //Populates the matrix
  for(k=0;k<iNumRanges;++k){
    //Get the range values
    dEtaMin = std::min(m_etamin[k],m_etamax[k]);
    dEtaMax = std::max(m_etamin[k],m_etamax[k]);
    dPhiMin = std::min(m_phimin[k],m_phimax[k]);
    dPhiMax = std::max(m_phimin[k],m_phimax[k]);
    //Guess how many times the hashID must be repeated on the X axis
    iRepeatOverX = MyRound((dEtaMax-dEtaMin)/m_stepMinEta);
    iRepeatOverX = std::abs(iRepeatOverX);
    //Guess how many times the hashID must be repeated on the Y axis
    iRepeatOverY = MyRound((dPhiMax-dPhiMin)/m_stepMinPhi);
    iRepeatOverY = std::abs(iRepeatOverY);
 
    iPage = m_sample[k] * (m_iColumns * m_iLines);
 
    // initial position
    iYphi = std::floor((dPhiMin - m_phiminDet+2e-6)/m_stepMinPhi);
    for(yPhi=0;yPhi<iRepeatOverY;++yPhi){
     iXeta = std::floor((dEtaMin - m_etaminDet)/m_stepMinEta);
     for(xEta=0;xEta<iRepeatOverX;++xEta){
        iPosition = iPage + (iYphi* m_iColumns +iXeta);
        m_hashIDMap[iPosition] = m_hashId[k];
        m_robIDMap[iPosition][0]=m_robId[k][0];
    for(unsigned int i=1; i< m_robId[k].size();++i )
           m_robIDMap[iPosition].push_back(m_robId[k][i]);
        ++iXeta;
      }
      ++iYphi;
    }
  }
#ifdef REGSELDEBUG   
   for(k=0;k<iNumRanges;++k){      
         std::cout << "REGSELECTOR HASH TABLE " <<   
         m_phimin[k] << " " << m_phimax[k] << " " <<   
         m_etamin[k] << " " << m_etamax[k] << " " <<   
         m_sample[k] << " " << m_layer[k]  << " " <<    
         m_hashId[k] << " 0x";      
     std::cout << std::hex;
         for(unsigned int i=0;i<m_robId[k].size();++i)     
                 std::cout << m_robId[k][i]  << " ";      
     std::cout << std::dec;
         std::cout << std::endl;     
   }     
   //Populates the matrix    
   for(k=0;k<iNumRanges;++k){      
     //Get the range values      
     dEtaMin = std::min(m_etamin[k],m_etamax[k]);    
     dEtaMax = std::max(m_etamin[k],m_etamax[k]);    
     dPhiMin = std::min(m_phimin[k],m_phimax[k]);    
     dPhiMax = std::max(m_phimin[k],m_phimax[k]);    
     iRepeatOverX = MyRound((dEtaMax-dEtaMin)/m_stepMinEta);      
     iRepeatOverX = std::abs(iRepeatOverX);      
     iRepeatOverY = MyRound((dPhiMax-dPhiMin)/m_stepMinPhi);      
     iRepeatOverY = std::abs(iRepeatOverY);      
     iPage = m_sample[k] * (m_iColumns * m_iLines);   
     // initial position     
     iYphi = std::floor((dPhiMin - m_phiminDet+2e-6)/m_stepMinPhi);   
     for(yPhi=0;yPhi<iRepeatOverY;++yPhi){   
      iXeta = std::floor((dEtaMin - m_etaminDet)/m_stepMinEta);   
      for(xEta=0;xEta<iRepeatOverX;++xEta){      
         iPosition = iPage + (iYphi* m_iColumns +iXeta);   
         std::cout << "REGSELECTOR MAPS " <<     
         iXeta << " " << iYphi << " " << iPosition << " " <<     
         m_hashIDMap[iPosition] << " ";   
     std::cout << std::hex;
         for(unsigned int i=0; i<m_robIDMap[iPosition].size();++i)   
                 std::cout << "0x" << m_robIDMap[iPosition][i]  << " ";    
     std::cout << std::dec;
         std::cout << std::endl;     
         ++iXeta;    
       }     
       ++iYphi;      
     }   
    }    
#endif
 
}

MyRound()

int RegSelectorHashMap::MyRound ( double pdValue )

private

Definition at line 291 of file RegSelectorHashMap.cxx.

                                             {
  double dFloor, dAux;
  int iReturn;
 
  dFloor = std::floor(pdValue);
  dAux = std::fabs(pdValue-dFloor);
  if(dAux >= 0.5f)
    iReturn = (int) (dFloor + 1);
  else
    iReturn = (int) dFloor;
 
  return iReturn;
}

phiCondition()

void RegSelectorHashMap::phiCondition ( const std::vector< IdentifierHash > & identifier, int i, double etaminIn, double etamaxIn, double phiminIn, double phimaxIn, double etamin, double etamax, std::set< IdentifierHash > * outset ) const

private

Definition at line 462 of file RegSelectorHashMap.cxx.

                                                            {
  double phimin, phimax;
  if(m_phimin[i] > m_phimax[i]){
    phimin = m_phimin[i];
    phimax = m_phimaxDet;
 
    if( (etaminIn <= etamax) && (etamaxIn >= etamin) ){
      if( (phiminIn <= phimax) && (phimaxIn >= phimin) ){
        (*outset).insert(identifier[i]);
      }
    }
    phimin = m_phiminDet;
    phimax = m_phimax[i];
    if( (etaminIn <= etamax) && (etamaxIn >= etamin) ){
      if( (phiminIn <= phimax) && (phimaxIn >= phimin) ){
        (*outset).insert(identifier[i]);
      }
    }
  }
  else{
    phimin = m_phimin[i]; phimax = m_phimax[i];
    if( (etaminIn <= etamax) && (etamaxIn >= etamin) ){
      if( (phiminIn <= phimax) && (phimaxIn >= phimin) ){
        (*outset).insert(identifier[i]);
      }
    }
  }
  
}

phiConditionRobId()

void RegSelectorHashMap::phiConditionRobId ( const std::vector< std::vector< uint32_t > > & identifier, int i, double etaminIn, double etamaxIn, double phiminIn, double phimaxIn, double etamin, double etamax, std::set< uint32_t > * outset ) const

private

Definition at line 496 of file RegSelectorHashMap.cxx.

                                                       {
  double phimin, phimax;
  if(m_phimin[i] > m_phimax[i]){
    phimin = m_phimin[i];
    phimax = m_phimaxDet;
 
    if( (etaminIn <= etamax) && (etamaxIn >= etamin) ){
      if( (phiminIn <= phimax) && (phimaxIn >= phimin) ){
        (*outset).insert(identifier[i][0]);
      }
    }
    phimin = m_phiminDet;
    phimax = m_phimax[i];
    if( (etaminIn <= etamax) && (etamaxIn >= etamin) ){
      if( (phiminIn <= phimax) && (phimaxIn >= phimin) ){
        (*outset).insert(identifier[i][0]);
      }
    }
  }
  else{
    phimin = m_phimin[i]; phimax = m_phimax[i];
    if( (etaminIn <= etamax) && (etamaxIn >= etamin) ){
      if( (phiminIn <= phimax) && (phimaxIn >= phimin) ){
        (*outset).insert(identifier[i][0]);
      }
    }
  }
  
}

phiMaxOut()

const std::vector< double > & RegSelectorHashMap::phiMaxOut

(

void

)

const

Definition at line 114 of file RegSelectorHashMap.cxx.

                                                                 {
  return m_phimax;
}

phimaxValue()

double RegSelectorHashMap::phimaxValue

(

)

const

Definition at line 82 of file RegSelectorHashMap.cxx.

                                             {
  return m_phimaxDet;
}

phiMinOut()

const std::vector< double > & RegSelectorHashMap::phiMinOut

(

void

)

const

Definition at line 110 of file RegSelectorHashMap.cxx.

                                                                 {
  return m_phimin;
}

phiminValue()

double RegSelectorHashMap::phiminValue

(

)

const

Definition at line 78 of file RegSelectorHashMap.cxx.

                                             {
  return m_phiminDet;
}

populateMatrix()

void RegSelectorHashMap::populateMatrix ( int iPage, IdentifierHash value )

private

Definition at line 227 of file RegSelectorHashMap.cxx.

                                                                      {
  int xEta,yPhi, iPosition;
  int max_iPosition(0);
  std::vector<uint32_t> tocreate(1);
  IdentifierHash tocreateIH(value);
 
  for(xEta= 0; xEta < m_iColumns; ++xEta){
    for(yPhi= 0; yPhi < m_iLines; ++yPhi){
      iPosition = iPage + (yPhi* m_iColumns + xEta);
      if(iPosition>max_iPosition) max_iPosition=iPosition;
    }
  }
  m_hashIDMap.resize(max_iPosition+1,tocreateIH);
  m_robIDMap.resize(max_iPosition+1,tocreate);
  for(xEta= 0; xEta < m_iColumns; ++xEta){
    for(yPhi= 0; yPhi < m_iLines; ++yPhi){
      iPosition = iPage + (yPhi* m_iColumns + xEta);
      m_robIDMap[iPosition].clear();
      m_robIDMap[iPosition].push_back(value);
    }
  }
 
}

populateMatrixRobId()

void RegSelectorHashMap::populateMatrixRobId ( int iPage, uint32_t value )

private

Definition at line 251 of file RegSelectorHashMap.cxx.

                                                                      {
  int xEta,yPhi, iPosition;
 
  for(xEta= 0; xEta < m_iColumns; ++xEta){
    for(yPhi= 0; yPhi < m_iLines; ++yPhi){
      iPosition = iPage + (yPhi* m_iColumns + xEta);
      m_robIDMap[iPosition].push_back(value);
    }
  }
 
}

read()

StatusCode RegSelectorHashMap::read

(

const char *

filename

)

Definition at line 554 of file RegSelectorHashMap.cxx.

                                                       {
  StatusCode sc = StatusCode::SUCCESS;
  char  buffer_[256]; // only needs to be 128 long, but safety first!
  char* buffer = buffer_;
  int samp, layer;
  unsigned int hashId;
  double emin, emax, pmin, pmax;
  double stepPhi, stepEta;
  char robIdStr[12], robIdStr2[12];
  char *pch; 
  std::vector<uint32_t> robId;
  robId.push_back(0);
 
// use path resolver to find full path to file
  std::string unresolvedFileName(filename);
  std::string fullFileName = PathResolver::find_file (unresolvedFileName, "DATAPATH");
  if (fullFileName == "") {
    std::cerr << "LArTTRegionSelectorIdentifierHash: FATAL: Could not find input file in DATAPATH" <<  unresolvedFileName<< std::endl;
    return StatusCode::FAILURE;
  }
 
  std::ifstream fin(fullFileName.c_str());
  fin.getline(buffer,128,'\n');
   if(fin.bad()){  //Test if the file failed:
     sc = StatusCode::FAILURE;
     return sc;
   }
  if (strncmp(buffer," TT-ID",6)==0){
    fin.getline(buffer, 128, '\n');
    do{
      robId.clear();
      pch = strchr(buffer,' ');
      int test = sscanf(pch, " %u %d %d %lf %lf %lf %lf %11s %11s",  // max 11 chars + null-byte
                        &hashId, &layer, &samp, &emin, &emax, &pmin, &pmax, robIdStr, robIdStr2);
      robId.push_back(strtol(robIdStr,nullptr,16));
      if ( test == 9 ) // this means that there are 2 ROBs in 1 TT
        robId.push_back(strtol(robIdStr2,nullptr,16));
      pch=strchr(buffer,' ');
      stepPhi = std::fabs(pmax-pmin);// initial value for phi and eta step
      stepEta = std::fabs(emin-emax);
      m_stepMinPhi = std::min(m_stepMinPhi,stepPhi);
      m_stepMinEta = std::min(m_stepMinEta,stepEta);
      m_etaminDet = std::min(std::min(m_etaminDet,emin),emax);
      m_phiminDet = std::min(std::min(m_phiminDet,pmin),pmax);
      m_etamaxDet = std::max(std::max(m_etamaxDet,emax),emin);
      m_phimaxDet = std::max(std::max(m_phimaxDet,pmax),pmin);
      m_NumSamples = std::max(m_NumSamples,samp);
      writeLine(layer, (IdentifierHash) hashId, robId, emin, emax, pmin, pmax, samp);
      // ++nlines;
    }while((fin.getline(buffer, 128, '\n')));
  }
  // m_readFromFile = !( nlines == 0 );
  fin.close();
 
  return sc;
}

regionSelector() [1/2]

void RegSelectorHashMap::regionSelector	(	double	etaminIn,
		double	etamaxIn,
		double	phiminIn,
		double	phimaxIn,
		std::vector< IdentifierHash > &	outList ) const

Definition at line 530 of file RegSelectorHashMap.cxx.

                                                                                               {
  verifyInputs(etaminIn, etamaxIn, phiminIn, phimaxIn);
  regionSelectorIN((int)-1, (double)etaminIn, (double)etamaxIn,
           (double)phiminIn, (double)phimaxIn,&outList);
  
}

regionSelector() [2/2]

void RegSelectorHashMap::regionSelector	(	int	sampling,
		double	etaminIn,
		double	etamaxIn,
		double	phiminIn,
		double	phimaxIn,
		std::vector< IdentifierHash > &	outList ) const

Definition at line 538 of file RegSelectorHashMap.cxx.

                                                                                                {
  verifyInputs(etaminIn, etamaxIn, phiminIn, phimaxIn);
  regionSelectorIN((int)sampling, (double)etaminIn, (double)etamaxIn,
           (double)phiminIn, (double)phimaxIn,&outList);
  
}

regionSelectorIN()

void RegSelectorHashMap::regionSelectorIN ( const int & sampling, const double & etaminIn, const double & etamaxIn, const double & phiminIn, const double & phimaxIn, std::vector< IdentifierHash > * outListIH ) const

private

why are we making this

need to check whether spans the pi boundary - using iYBeg > iYEnd isn't good enough since it it is very nearly 2pi, then iYBeg and iYEnd will be equal

wrap phi

why reduce the RoI size?

This is WRONG!! this forces all rois to increase as the radius increases - oh dear

Definition at line 305 of file RegSelectorHashMap.cxx.

                                                                  {
  int iYBeg, iYEnd, iXBeg, iXEnd, k, iPage;
  int iXTemp;
  std::vector<IdentifierHash>& auxsetIH=(*outListIH);

  iYBeg = std::floor((phiminIn - m_phiminDet+7e-3)/m_stepMinPhi);
  iYEnd = std::ceil((phimaxIn - m_phiminDet-7e-3)/m_stepMinPhi);
 

  bool pi_boundary = false;
  if ( phiminIn>phimaxIn ) pi_boundary = true;

   if(iYBeg < 0)        iYBeg += m_iLines;
   if(iYBeg > m_iLines) iYBeg -= m_iLines;   
   if(iYEnd < 0)        iYEnd += m_iLines ;      
   if(iYEnd > m_iLines) iYEnd -= m_iLines;
 

   iXBeg = std::floor((etaminIn - m_etaminDet+2e-5)/m_stepMinEta);
   iXEnd = std::ceil((etamaxIn - m_etaminDet-2e-5)/m_stepMinEta);
 
    if(iXBeg < 0) iXBeg = 0;
    if(iXBeg > m_iColumns) iXBeg = m_iColumns;
    if(iXEnd < 0) iXEnd = 0;
    if(iXEnd > m_iColumns) iXEnd = m_iColumns;
 

    if(iXBeg > iXEnd){
      iXTemp = iXBeg;
      iXBeg = iXEnd;
      iXEnd = iXTemp;
    }
    if(sampling == -1){ // Consider all samplings (0...3)
      if( pi_boundary ){
        for(k=0; k<=m_NumSamples; ++k){
          iPage = k * (m_iColumns * m_iLines);
          findIdentifier(auxsetIH, iXBeg, iXEnd, iYBeg, m_iLines, iPage);
        }
        for(k=0; k<=m_NumSamples; ++k){
          iPage = k * (m_iColumns * m_iLines);
          findIdentifier(auxsetIH, iXBeg, iXEnd, 0, iYEnd, iPage);
        }
      }
      else{
        for(k=0; k<=m_NumSamples; ++k){
          iPage = k * (m_iColumns * m_iLines);
          findIdentifier(auxsetIH,iXBeg, iXEnd, iYBeg, iYEnd, iPage);
        }
      }
    }
    else{ // Consider only the input sampling value
      k= sampling;
      iPage = k * (m_iColumns * m_iLines);
      if( pi_boundary ){
        findIdentifier(auxsetIH,iXBeg, iXEnd, iYBeg, m_iLines, iPage);
        findIdentifier(auxsetIH,iXBeg, iXEnd, 0, iYEnd, iPage);
      }
      else{
        findIdentifier(auxsetIH,iXBeg, iXEnd, iYBeg, iYEnd, iPage);
      }
    }
}

regionSelectorINROB()

void RegSelectorHashMap::regionSelectorINROB ( const int & sampling, const double & etaminIn, const double & etamaxIn, const double & phiminIn, const double & phimaxIn, std::vector< uint32_t > * outList ) const

private

why do we reduce the size of the RoI here? if we must mess with it, shouldn't we make it larger?

need to check whether spans the pi boundary - using (iYBeg > iYEnd) isn't good enough since it it is very nearly 2pi, then iYBeg and iYEnd will be equal.

wrap phi

why reduce the size of the RoI?

This is WRONG!! this forces all rois to increase as the radius increases - oh dear

Definition at line 382 of file RegSelectorHashMap.cxx.

                                                             {
  int iYBeg{}, iYEnd{}, iXBeg{}, iXEnd{}, k{}, iPage{};
  int iXTemp{};
  std::vector<uint32_t>& auxset=(*outList);

  if (m_stepMinPhi !=0){
    //
    iYBeg = std::floor((phiminIn - m_phiminDet+7e-3)/m_stepMinPhi);
    iYEnd = std::ceil((phimaxIn - m_phiminDet-7e-3)/m_stepMinPhi);
  }

  bool pi_boundary = false;
  if ( phiminIn>phimaxIn ) pi_boundary = true;

   if(iYBeg < 0)        iYBeg += m_iLines;
   if(iYBeg > m_iLines) iYBeg -= m_iLines;   
   if(iYEnd < 0)        iYEnd += m_iLines ;      
   if(iYEnd > m_iLines) iYEnd -= m_iLines;
   if (m_stepMinEta!=0) {
     iXBeg = std::floor((etaminIn - m_etaminDet+2e-5)/m_stepMinEta);
     iXEnd = std::ceil((etamaxIn - m_etaminDet-2e-5)/m_stepMinEta);
   }
    if(iXBeg < 0) iXBeg = 0;
    if(iXBeg > m_iColumns) iXBeg = m_iColumns;
    if(iXEnd < 0) iXEnd = 0;
    if(iXEnd > m_iColumns) iXEnd = m_iColumns;
  

    if(iXBeg > iXEnd){
      iXTemp = iXBeg;
      iXBeg = iXEnd;
      iXEnd = iXTemp;
    }
 
    if(sampling == -1){ // Consider all samplings (0...3)
 
      if( pi_boundary ){
        for(k=0; k<=m_NumSamples; ++k){
          iPage = k * (m_iColumns * m_iLines);
          findIdentifierROB(auxset, iXBeg, iXEnd, iYBeg, m_iLines,
        iPage);
        }
        for(k=0; k<=m_NumSamples; ++k){
          iPage = k * (m_iColumns * m_iLines);
          findIdentifierROB(auxset, iXBeg, iXEnd, 0, iYEnd, iPage);
        }
      }
      else{
        for(k=0; k<=m_NumSamples; ++k){
          iPage = k * (m_iColumns * m_iLines);
          findIdentifierROB(auxset,iXBeg, iXEnd, iYBeg, iYEnd, iPage);
        }
      }
    }
    else{ // Consider only the input sampling value
 
      k= sampling;
      iPage = k * (m_iColumns * m_iLines);
      if( pi_boundary ){
        findIdentifierROB(auxset,iXBeg, iXEnd, iYBeg, m_iLines, iPage);
        findIdentifierROB(auxset,iXBeg, iXEnd, 0, iYEnd, iPage);
      }
      else{
        findIdentifierROB(auxset,iXBeg, iXEnd, iYBeg, iYEnd, iPage);
      }
    }
}

regionSelectorRobIdUint() [1/2]

void RegSelectorHashMap::regionSelectorRobIdUint	(	double	etaminIn,
		double	etamaxIn,
		double	phiminIn,
		double	phimaxIn,
		std::vector< uint32_t > &	outRobIDList ) const

Definition at line 215 of file RegSelectorHashMap.cxx.

                                                               {
  regionSelectorINROB(-1, etaminIn, etamaxIn, phiminIn, phimaxIn,&outList);
}

regionSelectorRobIdUint() [2/2]

void RegSelectorHashMap::regionSelectorRobIdUint	(	int	sampling,
		double	etaminIn,
		double	etamaxIn,
		double	phiminIn,
		double	phimaxIn,
		std::vector< uint32_t > &	outRobIDList ) const

Definition at line 221 of file RegSelectorHashMap.cxx.

                                                               {
  regionSelectorINROB(sampling, etaminIn, etamaxIn, phiminIn, phimaxIn, &outList);
}

removeDuplicates()

template<typename T>

void IRegSelLUT::removeDuplicates ( std::vector< T > & vec )

inlinestaticprotectedinherited

useful for removing duplicates if required ...

Definition at line 78 of file IRegSelLUT.h.

                                                  {
    std::sort(vec.begin(), vec.end());
    vec.erase(std::unique(vec.begin(), vec.end()), vec.end());
  }

ROBIDList() [1/2]

void RegSelectorHashMap::ROBIDList ( const IRoiDescriptor & roi, std::vector< uint32_t > & roblist ) const

overridevirtual

rob methods

Rob identifier methods.

Implements IRegSelLUT.

Definition at line 30 of file RegSelectorHashMap.cxx.

                                                                                                  {
  IRegSelLUT::IDList<RegSelectorHashMap>( roi, roblist, &RegSelectorHashMap::ROBIDList_internal );
}

ROBIDList() [2/2]

void RegSelectorHashMap::ROBIDList ( long layer, const IRoiDescriptor & roi, std::vector< uint32_t > & roblist ) const

overridevirtual

ROBIDList interface declaration. This interface can be used by the ID subdetectors. A list of non-repeated ROBIDs (uint_32_t) is returned by a reference.

Parameters

long	layer, long int to decide which layer within the detector.
IRoiDescriptor	the IRoiDescriptor for the roi, all enabled elements in the roi are found.

Returns

std::vector<uint32_t> which is a list of non-repeated ROBID numbers.

Implements IRegSelLUT.

Definition at line 34 of file RegSelectorHashMap.cxx.

                                                                                                              {
  IRegSelLUT::IDList_layer<RegSelectorHashMap>( layer, roi, roblist, &RegSelectorHashMap::ROBIDList_internal );
}

ROBIDList_internal() [1/2]

void RegSelectorHashMap::ROBIDList_internal ( const IRoiDescriptor & roi, std::vector< uint32_t > & roblist ) const

protectedvirtual

rob methods

Definition at line 56 of file RegSelectorHashMap.cxx.

                                                                                                           {
  if ( roi.isFullscan() ) regionSelectorRobIdUint( -4.8, 4.8, -M_PI, M_PI, roblist );
  regionSelectorRobIdUint( roi.etaMinus(), roi.etaPlus(), roi.phiMinus(), roi.phiPlus(), roblist);
}

ROBIDList_internal() [2/2]

void RegSelectorHashMap::ROBIDList_internal ( long layer, const IRoiDescriptor & roi, std::vector< uint32_t > & roblist ) const

protectedvirtual

Definition at line 61 of file RegSelectorHashMap.cxx.

                                                                                                                       {
  if ( roi.isFullscan() ) regionSelectorRobIdUint( layer, -4.8, 4.8, -M_PI, M_PI, roblist );
  regionSelectorRobIdUint( layer, roi.etaMinus(), roi.etaPlus(), roi.phiMinus(), roi.phiPlus(), roblist);
}

robIdOut()

const std::vector< std::vector< uint32_t > > & RegSelectorHashMap::robIdOut

(

void

)

const

Definition at line 90 of file RegSelectorHashMap.cxx.

                                                                              {
  return m_robId;
}

sampleOut()

const std::vector< int > & RegSelectorHashMap::sampleOut

(

void

)

const

Definition at line 94 of file RegSelectorHashMap.cxx.

                                                              {
  return m_sample;
}

summaryDataFile()

void RegSelectorHashMap::summaryDataFile

(

std::list< RegSelectorMapElement > &

dataList

)

Definition at line 675 of file RegSelectorHashMap.cxx.

                                                                                {
  for(std::list<RegSelectorMapElement>::iterator it = dataList.begin();
      it != dataList.end(); ++it){ // runs through entire list
    std::cout << "position: " << (*it).layerDiskPosition() << " number: " << (*it).layerDiskNumber() << std::endl;
    std::cout << "etamin: " << m_etaminDet << "  etamax: " << m_etamaxDet << std::endl;
    std::cout << "phimin: " << m_phiminDet << "  phimax: " << m_phimaxDet << std::endl;
    std::cout << "hashId: ";
    std::vector<IdentifierHash> aux = (*it).hashId();
    for(std::vector<IdentifierHash>::iterator i = aux.begin(); i != aux.end(); ++i)
      std::cout << (*i) << " ";
    std::cout << std::endl;
    std::cin.get();
  }
}

verifyInputs()

void RegSelectorHashMap::verifyInputs	(	double &	etaminIn,
		double &	etamaxIn,
		double &	phiminIn,
		double &	phimaxIn ) const

Definition at line 690 of file RegSelectorHashMap.cxx.

                                                                {
  
  if ( m_readFromFile ) { // Files still 0 <-> 2pi
    while (phiminIn > 2*M_PI ) phiminIn -= 2*M_PI;
    while (phiminIn < 0      ) phiminIn += 2*M_PI;
    while (phimaxIn > 2*M_PI ) phimaxIn -= 2*M_PI;
    while (phimaxIn < 0      ) phimaxIn += 2*M_PI;
  } else { // SG maps -pi <-> pi
    while (phiminIn > M_PI  ) phiminIn -= 2*M_PI;
    while (phiminIn < -M_PI ) phiminIn += 2*M_PI;
    while (phimaxIn > M_PI  ) phimaxIn -= 2*M_PI;
    while (phimaxIn < -M_PI ) phimaxIn += 2*M_PI;
  }
  
  if( ( (etaminIn < m_etaminDet) && (etamaxIn < m_etaminDet) ) ||
      ( (etaminIn > m_etamaxDet) && (etamaxIn > m_etamaxDet) ) ){
    //sc = StatusCode::FAILURE;
  }
  else{
    if( (etaminIn < m_etaminDet) && (etamaxIn > m_etaminDet) ){
      etaminIn = m_etaminDet;
    }
    if( (etamaxIn > m_etamaxDet) && (etaminIn < m_etamaxDet) ){
      etamaxIn = m_etamaxDet;
    }
  }
}

verifyOutput() [1/2]

void RegSelectorHashMap::verifyOutput	(	double	etaminIn,
		double	etamaxIn,
		double	phiminIn,
		double	phimaxIn,
		std::vector< IdentifierHash > *	outputIdlist ) const

Definition at line 850 of file RegSelectorHashMap.cxx.

                                                                     {
  int i;
  std::set<IdentifierHash> myset;
  std::vector<IdentifierHash> outset;
  double etamin, etamax, etatmp, phimintmp, phimaxtmp;
  int vecsize = m_sample.size();
 
  if(etaminIn > etamaxIn){
    etatmp = etamaxIn;
    etamaxIn = etaminIn;
    etaminIn = etatmp;
  }
 
  phimintmp = phiminIn;
  phimaxtmp = phimaxIn;
 
  for(i= 0; i < vecsize; ++i){
    if(m_etamin[i] > m_etamax[i]){
      etamin = m_etamax[i]; etamax = m_etamin[i];
    }
    else{
      etamin = m_etamin[i]; etamax = m_etamax[i];
    }
    if(phiminIn > phimaxIn ){
      phimaxIn = m_phimaxDet;                                                            
      phiCondition(m_hashId, i, etaminIn, etamaxIn, phiminIn, phimaxIn, etamin, etamax,&myset);
      phiminIn = m_phiminDet;
      phimaxIn = phimaxtmp;
      phiCondition(m_hashId, i, etaminIn, etamaxIn, phiminIn, phimaxIn, etamin, etamax, &myset);
    }
    else{
      phiCondition(m_hashId, i, etaminIn, etamaxIn, phiminIn, phimaxIn, etamin, etamax, &myset);
    }
    phiminIn = phimintmp; phimaxIn = phimaxtmp;
  }
 
  std::set<IdentifierHash>::iterator it;
  for(it = myset.begin(); it!= myset.end(); ++it){
    outset.push_back(*it);
  }
 
  if(outset == (*outputIdlist) ){
    std::cout << "equal vectors " << std::endl;
  }
  else {
    std::cout << "eta(" << etaminIn << "," << etamaxIn << ")   phi(" << phiminIn << "," << phimaxIn << ")" << std::endl;
    std::cout << "desired output ";
    for(unsigned int i=0; i < outset.size(); ++i)
      std::cout << std::dec << outset[i] << " ";
    std::cout << std::endl;
    std::cout << "obtained output ";
    for(unsigned int i=0; i < (*outputIdlist).size(); ++i)
      std::cout << std::dec << (*outputIdlist)[i] << " ";
    std::cout << std::endl;
  }
}

verifyOutput() [2/2]

void RegSelectorHashMap::verifyOutput	(	int	sampling,
		double	etaminIn,
		double	etamaxIn,
		double	phiminIn,
		double	phimaxIn,
		std::vector< IdentifierHash > *	outputIdlist ) const

Definition at line 909 of file RegSelectorHashMap.cxx.

                                                                     {
  int i;
  std::set<IdentifierHash> myset;
  std::vector<IdentifierHash> outset;
  double etamin, etamax, etatmp, phimintmp, phimaxtmp;
  int vecsize = m_sample.size();
 
  if(etaminIn > etamaxIn){
    etatmp = etamaxIn;
    etamaxIn = etaminIn;
    etaminIn = etatmp;
  }
 
  phimintmp = phiminIn;
  phimaxtmp = phimaxIn;
 
  for(i= 0; i < vecsize; ++i){
    if( sampling == m_sample[i]){
      if(m_etamin[i] > m_etamax[i]){
        etamin = m_etamax[i]; etamax = m_etamin[i];
      }
      else{
        etamin = m_etamin[i]; etamax = m_etamax[i];
      }
      if(phiminIn > phimaxIn ){
        phimaxIn = m_phimaxDet;
        phiCondition(m_hashId, i, etaminIn, etamaxIn, phiminIn, phimaxIn, etamin, etamax,&myset);
        phiminIn = m_phiminDet;
        phimaxIn = phimaxtmp;
        phiCondition(m_hashId, i, etaminIn, etamaxIn, phiminIn, phimaxIn, etamin, etamax, &myset);
      }
      else{
        phiCondition(m_hashId, i, etaminIn, etamaxIn, phiminIn, phimaxIn, etamin, etamax,&myset);
      }
    }
    phiminIn = phimintmp; phimaxIn = phimaxtmp;
  }
 
  std::set<IdentifierHash>::iterator it;
  for(it = myset.begin(); it!= myset.end(); ++it){
    outset.push_back(*it);
  }
 
  if(outset == (*outputIdlist) ){
    std::cout << "equal vectors " << std::endl;
  }
  else {
    std::cout << "sampling " << sampling << "eta(" << etaminIn << "," << etamaxIn << ")   phi(" << phiminIn << "," << phimaxIn << ")" << std::endl;
    std::cout << "desired output ";
    for(unsigned int i=0; i < outset.size(); ++i)
      std::cout << std::dec << outset[i] << " ";
    std::cout << std::endl;
    std::cout << "obtained output ";
    for(unsigned int i=0; i < (*outputIdlist).size(); ++i)
      std::cout << std::dec << (*outputIdlist)[i] << " ";
    std::cout << std::endl;
    std::cin.get();
  }
}

verifyROBIDOutput() [1/2]

void RegSelectorHashMap::verifyROBIDOutput	(	double	etaminIn,
		double	etamaxIn,
		double	phiminIn,
		double	phimaxIn,
		std::vector< uint32_t > &	outputIdlist ) const

Definition at line 719 of file RegSelectorHashMap.cxx.

                                                          {
  int i;
  std::set<uint32_t> myset;
  std::vector<uint32_t> outset;
  std::vector<std::vector<uint32_t> > identifier;
  double etamin, etamax, etatmp, phimintmp, phimaxtmp;
  int vecsize = m_sample.size();
 
  identifier = m_robId;
 
  if(etaminIn > etamaxIn){
    etatmp = etamaxIn;
    etamaxIn = etaminIn;
    etaminIn = etatmp;
  }
 
  phimintmp = phiminIn;
  phimaxtmp = phimaxIn;
 
  for(i= 0; i < vecsize; ++i){
    if(m_etamin[i] > m_etamax[i]){
      etamin = m_etamax[i]; etamax = m_etamin[i];
    }
    else{
      etamin = m_etamin[i]; etamax = m_etamax[i];
    }
    if(phiminIn > phimaxIn ){
      phimaxIn = m_phimaxDet;        
      phiConditionRobId(identifier, i, etaminIn, etamaxIn, phiminIn, phimaxIn, etamin, etamax,&myset);
      phiminIn = m_phiminDet;
      phimaxIn = phimaxtmp;
      phiConditionRobId(identifier, i, etaminIn, etamaxIn, phiminIn, phimaxIn, etamin, etamax, &myset);
    }
    else{
      phiConditionRobId(identifier, i, etaminIn, etamaxIn, phiminIn, phimaxIn, etamin, etamax, &myset);
    }
    phiminIn = phimintmp; phimaxIn = phimaxtmp;
  }
 
  std::set<uint32_t>::iterator it;
  for(it = myset.begin(); it!= myset.end(); ++it){
    outset.push_back(*it);
  }
 
  if( (outset == outputIdlist) || (outputIdlist.size() >= outset.size()) ){
    std::cout << "equal vectors " << std::endl;
  }
  else {
    std::cout << "nonequal vectors " << std::endl;
    std::cout << "eta(" << etaminIn << "," << etamaxIn << ")   phi(" << phiminIn << "," << phimaxIn << ")" << std::endl;
    std::cout << "desired output ";
    for(unsigned int i=0; i < outset.size(); ++i)
      std::cout << std::dec << outset[i] << " ";
    std::cout << std::endl;
    std::cout << "obtained output ";
    for(unsigned int i=0; i < outputIdlist.size(); ++i)
      std::cout << std::dec << outputIdlist[i] << " ";
    std::cout << std::endl;
    std::cin.get();
  }
}

verifyROBIDOutput() [2/2]

void RegSelectorHashMap::verifyROBIDOutput	(	int	sampling,
		double	etaminIn,
		double	etamaxIn,
		double	phiminIn,
		double	phimaxIn,
		std::vector< uint32_t > &	outputIdlist ) const

Definition at line 783 of file RegSelectorHashMap.cxx.

                                                                 {
 
  int i;
  std::set<uint32_t> myset;
  std::vector<std::vector<uint32_t> > identifier;
  std::vector<uint32_t> outset;
  double etamin, etamax, etatmp, phimintmp, phimaxtmp;
  int vecsize = m_sample.size();
 
  identifier = m_robId;
 
  if(etaminIn > etamaxIn){
    etatmp = etamaxIn;
    etamaxIn = etaminIn;
    etaminIn = etatmp;
  }
 
  phimintmp = phiminIn;
  phimaxtmp = phimaxIn;
 
  for(i= 0; i < vecsize; ++i){
    if( sampling == m_sample[i]){
      if(m_etamin[i] > m_etamax[i]){
        etamin = m_etamax[i]; etamax = m_etamin[i];
      }
      else{
        etamin = m_etamin[i]; etamax = m_etamax[i];
      }
      if(phiminIn > phimaxIn ){
        phimaxIn = m_phimaxDet;
        phiConditionRobId(identifier, i, etaminIn, etamaxIn, phiminIn, phimaxIn, etamin, etamax,&myset);
        phiminIn = m_phiminDet;
        phimaxIn = phimaxtmp;
        phiConditionRobId(identifier, i, etaminIn, etamaxIn, phiminIn, phimaxIn, etamin, etamax, &myset);
      }
      else{
        phiConditionRobId(identifier, i, etaminIn, etamaxIn, phiminIn, phimaxIn, etamin, etamax,&myset);
      }
    }
    phiminIn = phimintmp; phimaxIn = phimaxtmp;
  }
 
  std::set<uint32_t>::iterator it;
  for(it = myset.begin(); it!= myset.end(); ++it){
    outset.push_back(*it);
  }
 
  if(outset == outputIdlist){
    std::cout << "equal vectors " << std::endl;
  }
  else {
    std::cout << "sampling " << sampling << "eta(" << etaminIn << "," << etamaxIn << ")   phi(" << phiminIn << "," << phimaxIn << ")" << std::endl;
    std::cout << "desired output ";
    for(unsigned int i=0; i < outset.size(); ++i)
      std::cout << std::dec << outset[i] << " ";
    std::cout << std::endl;
    std::cout << "obtained output ";
    for(unsigned int i=0; i < outputIdlist.size(); ++i)
      std::cout << std::dec << outputIdlist[i] << " ";
    std::cout << std::endl;
    std::cin.get();
  }
}

writeLine()

void RegSelectorHashMap::writeLine ( const int & layer, const IdentifierHash & hashId, const std::vector< uint32_t > & robId, const double & emin, const double & emax, const double & pmin, const double & pmax, const int & samp )

private

Definition at line 275 of file RegSelectorHashMap.cxx.

                                                {
 
  m_hashId.push_back(hashId);
  m_robId.push_back(robId);
  m_etamin.push_back(emin);
  m_etamax.push_back(emax);
  m_phimin.push_back(pmin);
  m_phimax.push_back(pmax);
  m_layer.push_back(layer);
  m_sample.push_back(samp);
 
}

Member Data Documentation

m_dataList

std::list<RegSelectorMapElement> RegSelectorHashMap::m_dataList

private

Definition at line 131 of file RegSelectorHashMap.h.

m_etamax

std::vector<double> RegSelectorHashMap::m_etamax

private

Definition at line 134 of file RegSelectorHashMap.h.

m_etamaxDet

double RegSelectorHashMap::m_etamaxDet {}

private

Definition at line 137 of file RegSelectorHashMap.h.

{}, m_etamaxDet{};

m_etamin

std::vector<double> RegSelectorHashMap::m_etamin

private

Definition at line 134 of file RegSelectorHashMap.h.

m_etaminDet

double RegSelectorHashMap::m_etaminDet {}

private

Definition at line 137 of file RegSelectorHashMap.h.

{}, m_etamaxDet{};

m_hashId

std::vector<IdentifierHash> RegSelectorHashMap::m_hashId

private

Definition at line 133 of file RegSelectorHashMap.h.

m_hashIDMap

std::vector<IdentifierHash> RegSelectorHashMap::m_hashIDMap

private

Definition at line 143 of file RegSelectorHashMap.h.

m_iColumns

int RegSelectorHashMap::m_iColumns {}

private

Definition at line 140 of file RegSelectorHashMap.h.

{}, m_iLines{};

m_iLines

int RegSelectorHashMap::m_iLines {}

private

Definition at line 140 of file RegSelectorHashMap.h.

{}, m_iLines{};

m_layer

std::vector<int> RegSelectorHashMap::m_layer

private

Definition at line 132 of file RegSelectorHashMap.h.

m_NumSamples

int RegSelectorHashMap::m_NumSamples {}

private

Definition at line 139 of file RegSelectorHashMap.h.

{};

m_phimax

std::vector<double> RegSelectorHashMap::m_phimax

private

Definition at line 135 of file RegSelectorHashMap.h.

m_phimaxDet

double RegSelectorHashMap::m_phimaxDet {}

private

Definition at line 138 of file RegSelectorHashMap.h.

{}, m_phimaxDet{};

m_phimin

std::vector<double> RegSelectorHashMap::m_phimin

private

Definition at line 135 of file RegSelectorHashMap.h.

m_phiminDet

double RegSelectorHashMap::m_phiminDet {}

private

Definition at line 138 of file RegSelectorHashMap.h.

{}, m_phimaxDet{};

m_readFromFile

bool RegSelectorHashMap::m_readFromFile {}

private

Definition at line 141 of file RegSelectorHashMap.h.

{};

m_robId

std::vector<std::vector<uint32_t> > RegSelectorHashMap::m_robId

private

Definition at line 136 of file RegSelectorHashMap.h.

m_robIDMap

std::vector<std::vector<uint32_t> > RegSelectorHashMap::m_robIDMap

private

Definition at line 142 of file RegSelectorHashMap.h.

m_sample

std::vector<int> RegSelectorHashMap::m_sample

private

Definition at line 132 of file RegSelectorHashMap.h.

m_stepMinEta

double RegSelectorHashMap::m_stepMinEta {}

private

Definition at line 129 of file RegSelectorHashMap.h.

{}, m_stepMinEta{};

m_stepMinPhi

double RegSelectorHashMap::m_stepMinPhi {}

private

Definition at line 129 of file RegSelectorHashMap.h.

{}, m_stepMinEta{};

---

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

• RegSelectorHashMap.h
• RegSelectorHashMap.cxx