RegSelectorMap Class Reference

#include <RegSelectorMap.h>

Inheritance diagram for RegSelectorMap:

Collaboration diagram for RegSelectorMap:

Public Member Functions
virtual void	HashIDList (const IRoiDescriptor &roi, std::vector< IdentifierHash > &idlist) const override
	implementation of the IRegSelUT interface - intentionally inlined
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 identifier 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	~RegSelectorMap () override=default
double	etaminValue (void) const
	the rest of the class starts here
double	etamaxValue (void) const
double	phiminValue (void) const
double	phimaxValue (void) const
const std::vector< IdentifierHash > &	hashIdOut (void) const
const std::vector< uint32_t > &	robIdOut (void) const
const std::vector< int > &	barORendOut (void) const
const std::vector< int > &	layORdskOut (void) 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)
void	regionSelectorRobIdUint (DETID TYPE, double etaminIn, double etamaxIn, double phiminIn, double phimaxIn, std::vector< uint32_t > &outList) const
void	regionSelectorRobIdUint (double etaminIn, double etamaxIn, double phiminIn, double phimaxIn, std::vector< uint32_t > &outList) const
void	regionSelectorRobIdUint (long layNumber, double etaminIn, double etamaxIn, double phiminIn, double phimaxIn, std::vector< uint32_t > &outList) const
void	addLut (const RegionSelectorLUT *detLut)
void	addLut (const RegionSelectorLUT &detLut)
void	regionSelector (DETID TYPE, double etaminIn, double etamaxIn, double phiminIn, double phimaxIn, std::vector< IdentifierHash > &outList) const
void	regionSelector (TYPEID typeinID, double etaminIn, double etamaxIn, double phiminIn, double phimaxIn, std::vector< IdentifierHash > &outList) const
void	regionSelector (long layNumber, double etaminIn, double etamaxIn, double phiminIn, double phimaxIn, std::vector< IdentifierHash > &outList) const
StatusCode	read (const char *filename, DETID type)
void	summaryDataFile (std::list< RegSelectorMapElement > &dataList)
void	verifyInputsInternal (double &etaminIn, double &etamaxIn, double &phiminIn, double &phimaxIn) const
StatusCode	verifyInputs (double &etaminIn, double &etamaxIn, double &phiminIn, double &phimaxIn) const
StatusCode	verifyInputsMinusPi (double &etaminIn, double &etamaxIn, double &phiminIn, double &phimaxIn) const
void	verifyOutput (double etaminIn, double etamaxIn, double phiminIn, double phimaxIn, const std::vector< IdentifierHash > &outputIdlist) const
void	getEtaPhi (IdentifierHash hashId, double *etaMin, double *etaMax, double *phiMin, double *phiMax) const

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 lookup table access for full 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 identifier 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	findPosition (TYPEID typeinID, bool posORneg, std::list< RegSelectorMapElement >::const_iterator &it) const
void	findPosition (long layNumber, bool posORneg, std::list< RegSelectorMapElement >::const_iterator &it) const
void	findMaxMinValues (std::list< RegSelectorMapElement > &dataList)
RegSelectorMapElement	creatingElement (int &positionIn, int &numberIn, double &etaminIn, double &etamaxIn, double &phiminIn, double &phimaxIn, IdentifierHash &hashIdIn, uint32_t &robId)
void	insertList (std::list< RegSelectorMapElement > &dataList, int positionIn, int numberIn, double etaminIn, double etamaxIn, double phiminIn, double phimaxIn, IdentifierHash hashIdIn, uint32_t &robIdIn)
void	insertDataElement (int &positionIn, int &numberIn, double &etaminIn, double &etamaxIn, double &phiminIn, double &phimaxIn, IdentifierHash &hashIdIn, uint32_t &robIdIn)
void	writeLine (int barORend, int layORdsk, IdentifierHash hashId, uint32_t robId, double emin, double emax, double pmin, double pmax)
StatusCode	readTILE (const char *filename)

Private Attributes
std::list< RegSelectorMapElement >	m_barreldataList
std::list< RegSelectorMapElement >	m_posdataList
std::list< RegSelectorMapElement >	m_negdataList
std::vector< int >	m_barORend
std::vector< int >	m_layORdsk
std::vector< IdentifierHash >	m_hashId
std::vector< uint32_t >	m_robId
std::vector< double >	m_etamin
std::vector< double >	m_etamax
std::vector< double >	m_phimin
std::vector< double >	m_phimax
double	m_etaminDet =0
double	m_etamaxDet =0
double	m_phiminDet =0
double	m_phimaxDet =0

Detailed Description

Definition at line 28 of file RegSelectorMap.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

~RegSelectorMap()

virtual RegSelectorMap::~RegSelectorMap ( )

overridevirtualdefault

Member Function Documentation

addLut() [1/2]

void RegSelectorMap::addLut ( const RegionSelectorLUT & detLut )

inline

Definition at line 83 of file RegSelectorMap.h.

{ addLut(&detLut); } 

addLut() [2/2]

void RegSelectorMap::addLut

(

const RegionSelectorLUT *

detLut

)

Definition at line 203 of file RegSelectorMap.cxx.

                                                            {
 
 
  for( size_t i=0; i< detLut->maxHash(); ++i) {
    writeLine(detLut->layerDiskPosition(i),
              detLut->layerDiskNumber(i),
          detLut->hashId(i),
          detLut->robId(i),
              detLut->etaMin(i),
              detLut->etaMax(i),
              detLut->phiMin(i),
              detLut->phiMax(i));
    //    std::cout << "RSDEBUG i=" << i << " hashid=" << detLut.hashId(i) << std::endl;
  }
 
}

barORendOut()

const std::vector< int > & RegSelectorMap::barORendOut

(

void

)

const

Definition at line 89 of file RegSelectorMap.cxx.

                                                            {
  return m_barORend;
}

creatingElement()

RegSelectorMapElement RegSelectorMap::creatingElement ( int & positionIn, int & numberIn, double & etaminIn, double & etamaxIn, double & phiminIn, double & phimaxIn, IdentifierHash & hashIdIn, uint32_t & robId )

private

Definition at line 702 of file RegSelectorMap.cxx.

                                                                             {
  RegSelectorMapElement newElement;
 
  newElement.additem( hashIdIn, 
              etaminIn, etamaxIn,
                  phiminIn, phimaxIn, 
              numberIn, positionIn, robIdIn );
 
  return newElement;
}

etaMaxOut()

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

(

void

)

const

Definition at line 101 of file RegSelectorMap.cxx.

                                                             {
  return m_etamax;
}

etamaxValue()

double RegSelectorMap::etamaxValue

(

void

)

const

Definition at line 69 of file RegSelectorMap.cxx.

                                             {
  return m_etamaxDet;
}

etaMinOut()

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

(

void

)

const

Definition at line 97 of file RegSelectorMap.cxx.

                                                             {
  return m_etamin;
}

etaminValue()

double RegSelectorMap::etaminValue

(

void

)

const

the rest of the class starts here

Definition at line 65 of file RegSelectorMap.cxx.

                                             {
  return m_etaminDet;
}

findMaxMinValues()

void RegSelectorMap::findMaxMinValues ( std::list< RegSelectorMapElement > & dataList )

private

Definition at line 685 of file RegSelectorMap.cxx.

                                                                              {
 
  std::list<RegSelectorMapElement>::iterator it;
 
  for(it = dataList.begin(); it != dataList.end(); ++it){ // runs through entire list
    if( (*it).etaminElem() < m_etaminDet )
      m_etaminDet = (*it).etaminElem();
    if( (*it).etamaxElem() > m_etamaxDet )
      m_etamaxDet = (*it).etamaxElem();
    if( (*it).phiminElem() < m_phiminDet )
      m_phiminDet = (*it).phiminElem();
    if( (*it).phimaxElem() > m_phimaxDet )
      m_phimaxDet = (*it).phimaxElem();
  }
 
}

findPosition() [1/2]

void RegSelectorMap::findPosition ( long layNumber, bool posORneg, std::list< RegSelectorMapElement >::const_iterator & it ) const

private

Definition at line 660 of file RegSelectorMap.cxx.

                                                                           {
  
  std::list<RegSelectorMapElement>::const_iterator itPos, itNeg, itEnd;
 
  itPos = m_posdataList.begin(); // positioning iterator at the begining of POSITIVE eta value list
  itNeg = m_negdataList.begin(); // NEGATIVE eta value list 
 
   if(posORneg == false){ // it's positive
     it = itPos;
     itEnd = m_posdataList.end();
   }
   else{
     it = itNeg;
     itEnd = m_negdataList.end();
   }
 
   while(it != itEnd) {
     if( (*it).layerDiskNumber() == layNumber )
       break;
     ++it;
   }
 
}

findPosition() [2/2]

void RegSelectorMap::findPosition ( TYPEID typeinID, bool posORneg, std::list< RegSelectorMapElement >::const_iterator & it ) const

private

what does this even do ? just loops over the oiterators and then exits with the value of the iterator set ?? this is quite dangerous - in principle it can return itEnd but will any calling function test for this properly ??

Definition at line 629 of file RegSelectorMap.cxx.

                                                                            {
  
  std::list<RegSelectorMapElement>::const_iterator itPos, itNeg, itEnd;
 
  itPos = m_posdataList.begin(); // positioning iterator at the begining of POSITIVE eta value list
                 // each element of this list is a EtaPhiMap of a MDT chamber
  itNeg = m_negdataList.begin(); // NEGATIVE eta value list of MDT chambers
 
   if(posORneg == false){ // it's positive
     it = itPos;
     itEnd = m_posdataList.end();
   }
   else{
     it = itNeg;
     itEnd = m_negdataList.end();
   }

 
   while(it != itEnd) {
     if( (*it).layerDiskNumber() == typeinID )
       break;
     ++it;
   }
 
}

getEtaPhi()

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

Definition at line 806 of file RegSelectorMap.cxx.

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

HashIDList() [1/2]

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

overridevirtual

implementation of the IRegSelUT interface - intentionally inlined

hash id methods

Implements IRegSelLUT.

Definition at line 18 of file RegSelectorMap.cxx.

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

HashIDList() [2/2]

void RegSelectorMap::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 22 of file RegSelectorMap.cxx.

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

HashIDList_internal() [1/2]

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

protectedvirtual

internal lookup table access for full interface ...

internal hash id methods

Definition at line 40 of file RegSelectorMap.cxx.

                                                                                                             {
  if ( roi.isFullscan() ) regionSelector( TILE, -4.9, 4.9, 0, 2*M_PI, idlist );
  regionSelector( TILE, roi.etaMinus(), roi.etaPlus(), roi.phiMinus(), roi.phiPlus(), idlist );
}

HashIDList_internal() [2/2]

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

protectedvirtual

Definition at line 45 of file RegSelectorMap.cxx.

                                                                                                                         {;
  if ( roi.isFullscan() ) regionSelector( layer, -4.9, 4.9, 0, 2*M_PI, idlist );
  regionSelector( layer, roi.etaMinus(), roi.etaPlus(), roi.phiMinus(), roi.phiPlus(), idlist );
}

hashIdOut()

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

(

void

)

const

Definition at line 81 of file RegSelectorMap.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 ); 
    
  }

insertDataElement()

void RegSelectorMap::insertDataElement ( int & positionIn, int & numberIn, double & etaminIn, double & etamaxIn, double & phiminIn, double & phimaxIn, IdentifierHash & hashIdIn, uint32_t & robIdIn )

private

Definition at line 748 of file RegSelectorMap.cxx.

                                                                                                       {
  if(positionIn > 0 ){ // list of positive values
    insertList(m_posdataList, positionIn, numberIn,
           etaminIn, etamaxIn, phiminIn, phimaxIn, hashIdIn, robIdIn);
  }
  else if(positionIn < 0){ // list of negative values
    insertList(m_negdataList, positionIn, numberIn,
           etaminIn, etamaxIn, phiminIn, phimaxIn, hashIdIn, robIdIn);
  }
  else if(positionIn == 0){
    insertList(m_barreldataList, positionIn, numberIn,
           etaminIn, etamaxIn, phiminIn, phimaxIn, hashIdIn, robIdIn);
  }
}

insertList()

void RegSelectorMap::insertList ( std::list< RegSelectorMapElement > & dataList, int positionIn, int numberIn, double etaminIn, double etamaxIn, double phiminIn, double phimaxIn, IdentifierHash hashIdIn, uint32_t & robIdIn )

private

Definition at line 716 of file RegSelectorMap.cxx.

                                                           {
  bool flag = false;
  RegSelectorMapElement newElement;
  std::list<RegSelectorMapElement>::iterator it;
 
  for(it = dataList.begin(); it != dataList.end(); ++it){ // runs through entire positive list
    if( positionIn == (*it).layerDiskPosition() ){ // position already exist
      flag = false;
      if( numberIn == (*it).layerDiskNumber() ) {// number already exist
    (*it).additem( hashIdIn, etaminIn, etamaxIn,
                   phiminIn, phimaxIn, numberIn, positionIn, robIdIn );
        break;
      }
      else
    flag = true;
    }
    else // position & number doesn't exist
      flag = true;
  } // end for
 
  if(flag == true || dataList.size() == 0){ // inserting new element
    newElement = creatingElement(positionIn, numberIn,
                 etaminIn,etamaxIn,
                 phiminIn, phimaxIn,
                 hashIdIn, robIdIn);
    dataList.push_back( std::move(newElement) );
  }
}

layORdskOut()

const std::vector< int > & RegSelectorMap::layORdskOut

(

void

)

const

Definition at line 93 of file RegSelectorMap.cxx.

                                                            {
  return m_layORdsk;
}

mountDataStruct()

void RegSelectorMap::mountDataStruct

(

void

)

Definition at line 113 of file RegSelectorMap.cxx.

                                        {
  int nLines = m_barORend.size();
  int i;
 
  for( i = 0; i < nLines; ++i){ // creating list of RegSelectElementUint
    insertDataElement(m_barORend[i], m_layORdsk[i],
              m_etamin[i], m_etamax[i],
              m_phimin[i], m_phimax[i],
              m_hashId[i], m_robId[i] );
  }
  std::list<RegSelectorMapElement>::iterator it;
  // find max and min values of each barrel layer and endcap disk
  for(it = m_barreldataList.begin();it != m_barreldataList.end(); ++it)
    (*it).findMaxMinElem();
  for(it = m_posdataList.begin();it != m_posdataList.end(); ++it)
    (*it).findMaxMinElem();
  for(it = m_negdataList.begin();it != m_negdataList.end(); ++it)
    (*it).findMaxMinElem();
  // find max and min values of a subdetector
  m_etaminDet = 1000; m_etamaxDet = -1000;
  m_phiminDet = 1000; m_phimaxDet = -1000;
  findMaxMinValues(m_barreldataList);
  findMaxMinValues(m_posdataList);
  findMaxMinValues(m_negdataList);
}

phiMaxOut()

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

(

void

)

const

Definition at line 109 of file RegSelectorMap.cxx.

                                                             {
  return m_phimax;
}

phimaxValue()

double RegSelectorMap::phimaxValue

(

void

)

const

Definition at line 77 of file RegSelectorMap.cxx.

                                             {
  return m_phimaxDet;
}

phiMinOut()

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

(

void

)

const

Definition at line 105 of file RegSelectorMap.cxx.

                                                             {
  return m_phimin;
}

phiminValue()

double RegSelectorMap::phiminValue

(

void

)

const

Definition at line 73 of file RegSelectorMap.cxx.

                                             {
  return m_phiminDet;
}

read()

StatusCode RegSelectorMap::read	(	const char *	filename,
		DETID	type )

can't call the msg stream in this class - oh dear leave the code in place for the time being until we sort out a solution

Definition at line 365 of file RegSelectorMap.cxx.

                                                                {
 
  StatusCode sc = StatusCode::SUCCESS;
 
  // use path resolver to find full path to file
  std::string unresolvedFileName(filename);
  std::string fullFileName = PathResolver::find_file (unresolvedFileName, "DATAPATH");
  //log << MSG::DEBUG << "PathResolver found " << fullFileName << endmsg;
  if (fullFileName == "") {
    //log << MSG::FATAL << "Could not find input file in DATAPATH" <<  unresolvedFileName<< endmsg;
    std::cerr << "RegSelectorMap: FATAL: Could not find input file in DATAPATH" <<  unresolvedFileName<< std::endl;
    return StatusCode::FAILURE;
  }
  //std::cout << "RegSelectDataIdentifierHash::read fullFileName=" << fullFileName << std::endl;
 
  switch(type){
  case TILE:
    sc = readTILE(fullFileName.c_str());
    break;
  default:
    //    ATH_MSG_ERROR( "Don't EVER use this code for anything except the Tile Calorimeter" );
    sc = StatusCode::FAILURE;
  }
  return sc;
}

readTILE()

StatusCode RegSelectorMap::readTILE ( const char * filename )

private

Definition at line 778 of file RegSelectorMap.cxx.

                                                       {
  StatusCode sc = StatusCode::SUCCESS;
  char  buffer_[256];
  char *buffer = buffer_;
  int barORend =0, layORwhe =0;
  IdentifierHash  hashId;
  double emin, emax, pmin, pmax;
  uint32_t robid, collid;
 
  std::ifstream fin(filename);
  if(fin.bad()){  //Test if the file failed:
    sc = StatusCode::FAILURE;
    return sc;
  }
  fin.getline(buffer,128,'\n');
  while (fin.getline(buffer, 128, '\n')){
    if (strncmp(buffer,"#",1)!=0){
      sscanf(buffer, "%x %x %x %lf %lf %lf %lf", &robid, &collid, (unsigned int*)&hashId, &emin, &emax, &pmin, &pmax);
      writeLine(barORend, layORwhe, hashId, robid, emin, emax, pmin, pmax);
    }
  }
  fin.close();
  
  return sc;
}

regionSelector() [1/3]

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

Definition at line 220 of file RegSelectorMap.cxx.

                                                               {
  
  verifyInputsInternal( etaminIn, etamaxIn, phiminIn, phimaxIn );
 
  std::list<RegSelectorMapElement>::const_iterator it;
  std::set<IdentifierHash> outset;
  std::set<IdentifierHash>::const_iterator itset, negbarrelbeg,negbarrelend;
  bool divideEta = false;
 
  for(it = m_barreldataList.begin(); //barrel list
      it != m_barreldataList.end(); ++it){ // runs trought all RegSelectElementUints
       (*it).selection(etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
  }
 
  switch(TYPE){
  case TILE: divideEta = true; break;
  default: break;
  }
 
  if( divideEta ){
    if(etaminIn < 0 || etamaxIn < 0){ // negative data list
      for(it = m_negdataList.begin();it != m_negdataList.end(); ++it){ // runs trought all RegSelectElementUints
        (*it).selection(etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
      }
    }
 
    if( etaminIn >= 0 || etamaxIn >= 0 ){ // positive data list
      for(it = m_posdataList.begin();it != m_posdataList.end(); ++it){ // runs trought all RegSelectElementUints
        (*it).selection(etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
      }
    }
  }
  else{
    for(it = m_negdataList.begin();it != m_negdataList.end(); ++it){ // runs trought all RegSelectElementUints
      (*it).selection(etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
    }
    for(it = m_posdataList.begin();it != m_posdataList.end(); ++it){ // runs trought all RegSelectElementUints
      (*it).selection(etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
    }
  }
 
  if (TYPE==TILE){
    negbarrelbeg = outset.upper_bound(0x3f);
    negbarrelend = outset.lower_bound(0x80);
    for(itset = negbarrelbeg; itset != negbarrelend; ++itset){
      outList.push_back(*itset);
    }
    for(itset = outset.begin(); itset != negbarrelbeg; ++itset){
      outList.push_back(*itset);
    }
    for(itset = negbarrelend; itset != outset.end(); ++itset){
      outList.push_back(*itset);
    }
  } else{
  for(itset = outset.begin(); itset != outset.end(); ++itset){
    outList.push_back(*itset);
  }
  }
 
}

regionSelector() [2/3]

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

Definition at line 323 of file RegSelectorMap.cxx.

                                                               {
 
  verifyInputsInternal( etaminIn, etamaxIn, phiminIn, phimaxIn );
 
  std::list<RegSelectorMapElement>::const_iterator it, itEnd;
  std::set<IdentifierHash> outset;
  std::set<IdentifierHash>::const_iterator itset;
  bool posORneg;
 
 
 if( etaminIn > 0 && etamaxIn > 0 ){ //search positive list to find layNumber
   posORneg = false; // it's POSITIVE
   findPosition(layNumber,posORneg, it);
   (*it).selection( etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
 }
 else if( etaminIn < 0 && etamaxIn < 0 ){ //search negative list to find layNumber
   posORneg = true; // it's NEGATIVE
   findPosition(layNumber,posORneg, it);
   (*it).selection( etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
 }
 
  // barrel
  it = m_barreldataList.begin(); 
  itEnd = m_barreldataList.end();
 
   while(it != itEnd) {
     if( (*it).layerDiskNumber() == layNumber ) {
       (*it).selection( etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
       break;
     }
     ++it;
   }
    
  for(itset = outset.begin(); itset != outset.end(); ++itset){
    outList.push_back(*itset);
  }
  
}

regionSelector() [3/3]

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

Definition at line 284 of file RegSelectorMap.cxx.

                                                                {
 
  verifyInputsInternal( etaminIn, etamaxIn, phiminIn, phimaxIn );
 
  std::list<RegSelectorMapElement>::const_iterator it;
  std::set<IdentifierHash> outset;
  std::set<IdentifierHash>::const_iterator itset;
  bool posORneg;
 
 
 if( etaminIn > 0 && etamaxIn > 0 ){ //search positive list to find TYPEID
   posORneg = false; // it's POSITIVE
   findPosition(typeinID,posORneg, it);
   (*it).selection( etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
 }
 else if( etaminIn < 0 && etamaxIn < 0 ){ //search negative list to find TYPEID
   posORneg = true; // it's NEGATIVE
   findPosition(typeinID,posORneg, it);
   (*it).selection( etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
 }
 else { //search both list to find TYPEID
   posORneg = false;
   findPosition(typeinID,posORneg, it);
   (*it).selection( etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
   posORneg = true;
   findPosition(typeinID,posORneg, it);
   (*it).selection( etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
 }
 
  for(itset = outset.begin(); itset != outset.end(); ++itset){
    outList.push_back(*itset);
  }
}

regionSelectorRobIdUint() [1/3]

void RegSelectorMap::regionSelectorRobIdUint	(	DETID	TYPE,
		double	etaminIn,
		double	etamaxIn,
		double	phiminIn,
		double	phimaxIn,
		std::vector< uint32_t > &	outList ) const

Definition at line 139 of file RegSelectorMap.cxx.

                                                               {
  
  verifyInputsInternal( etaminIn, etamaxIn, phiminIn, phimaxIn );
 
  std::list<RegSelectorMapElement>::const_iterator it;
  std::set<uint32_t> outset;
  std::set<uint32_t>::const_iterator itset, negbarrelbeg, negbarrelend;
  bool divideEta = false;
 
  for( it = m_barreldataList.begin(); //barrel list
       it != m_barreldataList.end(); ++it){ // runs trought all RegSelectElementUints
       (*it).selectionRobIdUint( etaminIn, etamaxIn, phiminIn, phimaxIn, outset );
  }
 
  switch(TYPE){
  case TILE: divideEta = true; break;
  default: break;
  }
 
  if( divideEta ){
    if(etaminIn < 0 || etamaxIn < 0){ // negative data list
      for(it = m_negdataList.begin();it != m_negdataList.end(); ++it){ // runs trought all RegSelectElementUints
        (*it).selectionRobIdUint(etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
      }
    }
 
    if( etaminIn >= 0 || etamaxIn >= 0 ){ // positive data list
      for(it = m_posdataList.begin();it != m_posdataList.end(); ++it){ // runs trought all RegSelectElementUints
        (*it).selectionRobIdUint(etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
      }
    }
  }
  else{
    for(it = m_negdataList.begin();it != m_negdataList.end(); ++it){ // runs trought all RegSelectElementUints
      (*it).selectionRobIdUint(etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
    }
    for(it = m_posdataList.begin();it != m_posdataList.end(); ++it){ // runs trought all RegSelectElementUints
      (*it).selectionRobIdUint(etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
    }
  }
 
  if (TYPE==TILE){
    negbarrelbeg = outset.upper_bound(0x51000f);
    negbarrelend = outset.lower_bound(0x530000);
    for(itset = negbarrelbeg; itset != negbarrelend; ++itset){
      outList.push_back(*itset);
    }
    for(itset = outset.begin(); itset != negbarrelbeg; ++itset){
      outList.push_back(*itset);
    }
    for(itset = negbarrelend; itset != outset.end(); ++itset){
      outList.push_back(*itset);
    }
  }else{
  for(itset = outset.begin(); itset != outset.end(); ++itset){
    outList.push_back(*itset);
  }
  }
 
}

regionSelectorRobIdUint() [2/3]

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

Definition at line 522 of file RegSelectorMap.cxx.

                                                              {
  
  verifyInputsInternal( etaminIn, etamaxIn, phiminIn, phimaxIn );
 
  std::set<uint32_t> outset;
  int i;
  unsigned int j;
  double etamin, etamax, phimin, phimax;
  std::vector<uint32_t> outvec;
 
  int vecsize = m_etamin.size();
  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(m_phimin[i] > m_phimax[i]){
      phimin = m_phimin[i];
      phimax = phimaxValue();
      if( (etaminIn <= etamax) && (etamaxIn >= etamin) ){
    if( (phiminIn <= phimax) && (phimaxIn >= phimin) ){
      outset.insert(m_robId[i]);
    }
      }
      phimin = phiminValue();
      phimax = m_phimax[i];
      if( (etaminIn <= etamax) && (etamaxIn >= etamin) ){
    if( (phiminIn <= phimax) && (phimaxIn >= phimin) ){
      outset.insert(m_robId[i]);
    }
      }
    }
    else{
      phimin = m_phimin[i]; phimax = m_phimax[i];
      if( (etaminIn <= etamax) && (etamaxIn >= etamin) ){
    if( (phiminIn <= phimax) && (phimaxIn >= phimin) ){
      outset.insert(m_robId[i]);
    }
      }
    }
  }
 
  std::set<uint32_t>::iterator it;
  for(it = outset.begin(); it != outset.end(); ++it)
    outvec.push_back(*it);
 
  if(outvec == outList)
    std::cout << "equal vectors " << std::endl;
  std::cout << "desired output ";
  for( j=0; j < outvec.size(); ++j)
    std::cout << std::dec << outvec[j] << " ";
  std::cout << std::endl;
  std::cout << "obtained output ";
  for( j=0; j < outList.size(); ++j)
    std::cout << std::dec << outList[j] << " ";
  std::cout << std::endl;
}

regionSelectorRobIdUint() [3/3]

void RegSelectorMap::regionSelectorRobIdUint	(	long	layNumber,
		double	etaminIn,
		double	etamaxIn,
		double	phiminIn,
		double	phimaxIn,
		std::vector< uint32_t > &	outList ) const

Definition at line 587 of file RegSelectorMap.cxx.

                                                              {
  
  verifyInputsInternal( etaminIn, etamaxIn, phiminIn, phimaxIn );
 
  std::set<uint32_t> outset;
  std::list<RegSelectorMapElement>::const_iterator it, itEnd;
  std::set<uint32_t>::const_iterator itset;
  bool posORneg;
 
 
 if( etaminIn > 0 && etamaxIn > 0 ){ //search positive list to find layNumber
   posORneg = false; // it's POSITIVE
   findPosition(layNumber,posORneg, it);
   (*it).selectionRobIdUint( etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
 }
 else if( etaminIn < 0 && etamaxIn < 0 ){ //search negative list to find layNumber
   posORneg = true; // it's NEGATIVE
   findPosition(layNumber,posORneg, it);
   (*it).selectionRobIdUint( etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
 }
 
  // barrel
  it = m_barreldataList.begin(); 
  itEnd = m_barreldataList.end();
 
   while(it != itEnd) {
     if( (*it).layerDiskNumber() == layNumber ) {
       (*it).selectionRobIdUint( etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
       break;
     }
     ++it;
   }
    
  for(itset = outset.begin(); itset != outset.end(); ++itset){
    outList.push_back(*itset);
  }
  
}

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 RegSelectorMap::ROBIDList ( const IRoiDescriptor & roi, std::vector< uint32_t > & roblist ) const

overridevirtual

Rob identifier methods.

Implements IRegSelLUT.

Definition at line 28 of file RegSelectorMap.cxx.

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

ROBIDList() [2/2]

void RegSelectorMap::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 32 of file RegSelectorMap.cxx.

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

ROBIDList_internal() [1/2]

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

protectedvirtual

Rob identifier methods.

internal Rob identifier methods

Definition at line 52 of file RegSelectorMap.cxx.

                                                                                                       {
  if ( roi.isFullscan() ) regionSelectorRobIdUint( TILE, -4.9, 4.9, 0, 2*M_PI, roblist );
  regionSelectorRobIdUint( TILE, roi.etaMinus(), roi.etaPlus(), roi.phiMinus(), roi.phiPlus(), roblist );
}

ROBIDList_internal() [2/2]

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

protectedvirtual

Definition at line 57 of file RegSelectorMap.cxx.

                                                                                                                   {
  if ( roi.isFullscan() ) regionSelectorRobIdUint( layer, -4.9, 4.9, 0, 2*M_PI, roblist );
  regionSelectorRobIdUint( layer, roi.etaMinus(), roi.etaPlus(), roi.phiMinus(), roi.phiPlus(), roblist );
}

robIdOut()

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

(

void

)

const

Definition at line 85 of file RegSelectorMap.cxx.

                                                              {
  return m_robId;
}

summaryDataFile()

void RegSelectorMap::summaryDataFile

(

std::list< RegSelectorMapElement > &

dataList

)

Definition at line 393 of file RegSelectorMap.cxx.

                                                                            {
  std::list<RegSelectorMapElement>::iterator it;
 
  for(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()

StatusCode RegSelectorMap::verifyInputs	(	double &	etaminIn,
		double &	etamaxIn,
		double &	phiminIn,
		double &	phimaxIn ) const

Definition at line 434 of file RegSelectorMap.cxx.

                                                                {
  verifyInputsInternal( etaminIn, etamaxIn, phiminIn, phimaxIn );
  return StatusCode::SUCCESS;
}

verifyInputsInternal()

void RegSelectorMap::verifyInputsInternal	(	double &	etaminIn,
		double &	etamaxIn,
		double &	phiminIn,
		double &	phimaxIn ) const

Definition at line 411 of file RegSelectorMap.cxx.

                                                                  {
 
  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;
 
  if( ( (etaminIn < m_etaminDet) && (etamaxIn < m_etaminDet) ) ||
      ( (etaminIn > m_etamaxDet) && (etamaxIn > m_etamaxDet) ) ){
  }
  else{
    if( (etaminIn < m_etaminDet) && (etamaxIn > m_etaminDet) ){
        etaminIn = m_etaminDet;
    }
    if( (etamaxIn > m_etamaxDet) && (etaminIn < m_etamaxDet) ){
        etamaxIn = m_etamaxDet;
    }
  }
 
}

verifyInputsMinusPi()

StatusCode RegSelectorMap::verifyInputsMinusPi	(	double &	etaminIn,
		double &	etamaxIn,
		double &	phiminIn,
		double &	phimaxIn ) const

Definition at line 442 of file RegSelectorMap.cxx.

                                                                  {
 
  StatusCode sc = StatusCode::SUCCESS;
 
  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;
    }
  }
 
  return sc;
}

verifyOutput()

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

Definition at line 468 of file RegSelectorMap.cxx.

                                                                        {
 
  std::vector<IdentifierHash> outset;
  int i;
  unsigned int j;
  double etamin, etamax, phimin, phimax;
  int vecsize = m_etamin.size();
  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(m_phimin[i] > m_phimax[i]){
      phimin = m_phimin[i];
      phimax = phimaxValue();
      if( (etaminIn <= etamax) && (etamaxIn >= etamin) ){
    if( (phiminIn <= phimax) && (phimaxIn >= phimin) ){
      outset.push_back(m_hashId[i]);
    }
      }
      phimin = phiminValue();
      phimax = m_phimax[i];
      if( (etaminIn <= etamax) && (etamaxIn >= etamin) ){
    if( (phiminIn <= phimax) && (phimaxIn >= phimin) ){
      outset.push_back(m_hashId[i]);
    }
      }
    }
    else{
      phimin = m_phimin[i]; phimax = m_phimax[i];
      if( (etaminIn <= etamax) && (etamaxIn >= etamin) ){
    if( (phiminIn <= phimax) && (phimaxIn >= phimin) ){
      outset.push_back(m_hashId[i]);
    }
      }
    }
  }
  if(outset == outputIdlist)
    std::cout << "equal vectors " << std::endl;
  std::cout << "desired output ";
  for( j=0; j < outset.size(); ++j)
    std::cout << std::dec << outset[j] << " ";
  std::cout << std::endl;
  std::cout << "obtained output ";
  for( j=0; j < outputIdlist.size(); ++j)
    std::cout << std::dec << outputIdlist[j] << " ";
  std::cout << std::endl;
}

writeLine()

void RegSelectorMap::writeLine ( int barORend, int layORdsk, IdentifierHash hashId, uint32_t robId, double emin, double emax, double pmin, double pmax )

private

Definition at line 764 of file RegSelectorMap.cxx.

                                            {
 
  m_barORend.push_back(barORend);
  m_layORdsk.push_back(layORdsk);
  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);
}

Member Data Documentation

m_barORend

std::vector<int> RegSelectorMap::m_barORend

private

Definition at line 152 of file RegSelectorMap.h.

m_barreldataList

std::list<RegSelectorMapElement> RegSelectorMap::m_barreldataList

private

Definition at line 150 of file RegSelectorMap.h.

m_etamax

std::vector<double> RegSelectorMap::m_etamax

private

Definition at line 158 of file RegSelectorMap.h.

m_etamaxDet

double RegSelectorMap::m_etamaxDet =0

private

Definition at line 162 of file RegSelectorMap.h.

m_etamin

std::vector<double> RegSelectorMap::m_etamin

private

Definition at line 158 of file RegSelectorMap.h.

m_etaminDet

double RegSelectorMap::m_etaminDet =0

private

Definition at line 162 of file RegSelectorMap.h.

m_hashId

std::vector<IdentifierHash> RegSelectorMap::m_hashId

private

Definition at line 154 of file RegSelectorMap.h.

m_layORdsk

std::vector<int> RegSelectorMap::m_layORdsk

private

Definition at line 152 of file RegSelectorMap.h.

m_negdataList

std::list<RegSelectorMapElement> RegSelectorMap::m_negdataList

private

Definition at line 150 of file RegSelectorMap.h.

m_phimax

std::vector<double> RegSelectorMap::m_phimax

private

Definition at line 160 of file RegSelectorMap.h.

m_phimaxDet

double RegSelectorMap::m_phimaxDet =0

private

Definition at line 164 of file RegSelectorMap.h.

m_phimin

std::vector<double> RegSelectorMap::m_phimin

private

Definition at line 160 of file RegSelectorMap.h.

m_phiminDet

double RegSelectorMap::m_phiminDet =0

private

Definition at line 164 of file RegSelectorMap.h.

m_posdataList

std::list<RegSelectorMapElement> RegSelectorMap::m_posdataList

private

Definition at line 150 of file RegSelectorMap.h.

m_robId

std::vector<uint32_t> RegSelectorMap::m_robId

private

Definition at line 156 of file RegSelectorMap.h.

---

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

• RegSelectorMap.h
• RegSelectorMap.cxx