ATLAS Offline Software
Public Member Functions | Protected Types | Protected Member Functions | Static Protected Member Functions | Private Member Functions | Private Attributes | List of all members
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 More...
 
virtual void HashIDList (long layer, const IRoiDescriptor &roi, std::vector< IdentifierHash > &idlist) const override
 HashIDList interface declaration. return list of non-repeated IdentifierHash. More...
 
virtual void ROBIDList (const IRoiDescriptor &roi, std::vector< uint32_t > &roblist) const override
 Rob identifier methods. More...
 
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. More...
 
virtual ~RegSelectorMap () override=default
 
double etaminValue (void) const
 the rest of the class starts here More...
 
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 ... More...
 
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. More...
 
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 ... More...
 

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.

83 { addLut(&detLut); }

◆ addLut() [2/2]

void RegSelectorMap::addLut ( const RegionSelectorLUT *  detLut)

Definition at line 203 of file RegSelectorMap.cxx.

203  {
204 
205 
206  for( size_t i=0; i< detLut->maxHash(); ++i) {
207  writeLine(detLut->layerDiskPosition(i),
208  detLut->layerDiskNumber(i),
209  detLut->hashId(i),
210  detLut->robId(i),
211  detLut->etaMin(i),
212  detLut->etaMax(i),
213  detLut->phiMin(i),
214  detLut->phiMax(i));
215  // std::cout << "RSDEBUG i=" << i << " hashid=" << detLut.hashId(i) << std::endl;
216  }
217 
218 }

◆ barORendOut()

const std::vector< int > & RegSelectorMap::barORendOut ( void  ) const

Definition at line 89 of file RegSelectorMap.cxx.

89  {
90  return m_barORend;
91 }

◆ 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.

705  {
706  RegSelectorMapElement newElement;
707 
708  newElement.additem( hashIdIn,
709  etaminIn, etamaxIn,
710  phiminIn, phimaxIn,
711  numberIn, positionIn, robIdIn );
712 
713  return newElement;
714 }

◆ etaMaxOut()

const std::vector< double > & RegSelectorMap::etaMaxOut ( void  ) const

Definition at line 101 of file RegSelectorMap.cxx.

101  {
102  return m_etamax;
103 }

◆ etamaxValue()

double RegSelectorMap::etamaxValue ( void  ) const

Definition at line 69 of file RegSelectorMap.cxx.

69  {
70  return m_etamaxDet;
71 }

◆ etaMinOut()

const std::vector< double > & RegSelectorMap::etaMinOut ( void  ) const

Definition at line 97 of file RegSelectorMap.cxx.

97  {
98  return m_etamin;
99 }

◆ etaminValue()

double RegSelectorMap::etaminValue ( void  ) const

the rest of the class starts here

Definition at line 65 of file RegSelectorMap.cxx.

65  {
66  return m_etaminDet;
67 }

◆ findMaxMinValues()

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

Definition at line 685 of file RegSelectorMap.cxx.

685  {
686 
687  std::list<RegSelectorMapElement>::iterator it;
688 
689  for(it = dataList.begin(); it != dataList.end(); ++it){ // runs through entire list
690  if( (*it).etaminElem() < m_etaminDet )
691  m_etaminDet = (*it).etaminElem();
692  if( (*it).etamaxElem() > m_etamaxDet )
693  m_etamaxDet = (*it).etamaxElem();
694  if( (*it).phiminElem() < m_phiminDet )
695  m_phiminDet = (*it).phiminElem();
696  if( (*it).phimaxElem() > m_phimaxDet )
697  m_phimaxDet = (*it).phimaxElem();
698  }
699 
700 }

◆ 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.

661  {
662 
663  std::list<RegSelectorMapElement>::const_iterator itPos, itNeg, itEnd;
664 
665  itPos = m_posdataList.begin(); // positioning iterator at the begining of POSITIVE eta value list
666  itNeg = m_negdataList.begin(); // NEGATIVE eta value list
667 
668  if(posORneg == false){ // it's positive
669  it = itPos;
670  itEnd = m_posdataList.end();
671  }
672  else{
673  it = itNeg;
674  itEnd = m_negdataList.end();
675  }
676 
677  while(it != itEnd) {
678  if( (*it).layerDiskNumber() == layNumber )
679  break;
680  ++it;
681  }
682 
683 }

◆ 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.

630  {
631 
632  std::list<RegSelectorMapElement>::const_iterator itPos, itNeg, itEnd;
633 
634  itPos = m_posdataList.begin(); // positioning iterator at the begining of POSITIVE eta value list
635  // each element of this list is a EtaPhiMap of a MDT chamber
636  itNeg = m_negdataList.begin(); // NEGATIVE eta value list of MDT chambers
637 
638  if(posORneg == false){ // it's positive
639  it = itPos;
640  itEnd = m_posdataList.end();
641  }
642  else{
643  it = itNeg;
644  itEnd = m_negdataList.end();
645  }
646 
651 
652  while(it != itEnd) {
653  if( (*it).layerDiskNumber() == typeinID )
654  break;
655  ++it;
656  }
657 
658 }

◆ getEtaPhi()

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

Definition at line 806 of file RegSelectorMap.cxx.

808  {
809 
810  (*etaMin) = m_etamin[hashId];
811  (*etaMax) = m_etamax[hashId];
812  (*phiMin) = m_phimin[hashId];
813  (*phiMax) = m_phimax[hashId];
814 }

◆ HashIDList() [1/2]

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

implementation of the IRegSelUT interface - intentionally inlined

implementation of the IRegSelUT interface - intentionally inlined

hash id methods

hash id methods

Implements IRegSelLUT.

Definition at line 18 of file RegSelectorMap.cxx.

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

◆ 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
longlayer, long int to decide which layer within the detector.
IRoiDescriptorroi, 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.

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

◆ 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.

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

◆ 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.

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

◆ hashIdOut()

const std::vector< IdentifierHash > & RegSelectorMap::hashIdOut ( void  ) const

Definition at line 81 of file RegSelectorMap.cxx.

81  {
82  return m_hashId;
83 }

◆ 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.

88  {
89 
90  if ( roi.composite() ) {
91  idlist.clear();
92  for ( unsigned iroi=roi.size() ; iroi-- ; ) IDList<C>( *(roi.at(iroi)), idlist, lister );
93  if ( roi.size()>1 ) IRegSelLUT::removeDuplicates( idlist );
94  return;
95  }
96 
97  (dynamic_cast<const C*>(this)->*lister)( roi, idlist );
98 
99  }

◆ 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.

106  {
107 
108  if ( roi.composite() ) {
109  idlist.clear();
110  for ( unsigned iroi=roi.size() ; iroi-- ; ) IDList_layer<C>( layer, *(roi.at(iroi)), idlist, lister );
111  if ( roi.size()>1 ) IRegSelLUT::removeDuplicates( idlist );
112  return;
113  }
114 
115  (dynamic_cast<const C*>(this)->*lister)( layer, roi, idlist );
116 
117  }

◆ 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.

749  {
750  if(positionIn > 0 ){ // list of positive values
751  insertList(m_posdataList, positionIn, numberIn,
752  etaminIn, etamaxIn, phiminIn, phimaxIn, hashIdIn, robIdIn);
753  }
754  else if(positionIn < 0){ // list of negative values
755  insertList(m_negdataList, positionIn, numberIn,
756  etaminIn, etamaxIn, phiminIn, phimaxIn, hashIdIn, robIdIn);
757  }
758  else if(positionIn == 0){
759  insertList(m_barreldataList, positionIn, numberIn,
760  etaminIn, etamaxIn, phiminIn, phimaxIn, hashIdIn, robIdIn);
761  }
762 }

◆ 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.

719  {
720  bool flag = false;
721  RegSelectorMapElement newElement;
722  std::list<RegSelectorMapElement>::iterator it;
723 
724  for(it = dataList.begin(); it != dataList.end(); ++it){ // runs through entire positive list
725  if( positionIn == (*it).layerDiskPosition() ){ // position already exist
726  flag = false;
727  if( numberIn == (*it).layerDiskNumber() ) {// number already exist
728  (*it).additem( hashIdIn, etaminIn, etamaxIn,
729  phiminIn, phimaxIn, numberIn, positionIn, robIdIn );
730  break;
731  }
732  else
733  flag = true;
734  }
735  else // position & number doesn't exist
736  flag = true;
737  } // end for
738 
739  if(flag == true || dataList.size() == 0){ // inserting new element
740  newElement = creatingElement(positionIn, numberIn,
741  etaminIn,etamaxIn,
742  phiminIn, phimaxIn,
743  hashIdIn, robIdIn);
744  dataList.push_back( std::move(newElement) );
745  }
746 }

◆ layORdskOut()

const std::vector< int > & RegSelectorMap::layORdskOut ( void  ) const

Definition at line 93 of file RegSelectorMap.cxx.

93  {
94  return m_layORdsk;
95 }

◆ mountDataStruct()

void RegSelectorMap::mountDataStruct ( void  )

Definition at line 113 of file RegSelectorMap.cxx.

113  {
114  int nLines = m_barORend.size();
115  int i;
116 
117  for( i = 0; i < nLines; ++i){ // creating list of RegSelectElementUint
118  insertDataElement(m_barORend[i], m_layORdsk[i],
119  m_etamin[i], m_etamax[i],
120  m_phimin[i], m_phimax[i],
121  m_hashId[i], m_robId[i] );
122  }
123  std::list<RegSelectorMapElement>::iterator it;
124  // find max and min values of each barrel layer and endcap disk
125  for(it = m_barreldataList.begin();it != m_barreldataList.end(); ++it)
126  (*it).findMaxMinElem();
127  for(it = m_posdataList.begin();it != m_posdataList.end(); ++it)
128  (*it).findMaxMinElem();
129  for(it = m_negdataList.begin();it != m_negdataList.end(); ++it)
130  (*it).findMaxMinElem();
131  // find max and min values of a subdetector
132  m_etaminDet = 1000; m_etamaxDet = -1000;
133  m_phiminDet = 1000; m_phimaxDet = -1000;
134  findMaxMinValues(m_barreldataList);
135  findMaxMinValues(m_posdataList);
136  findMaxMinValues(m_negdataList);
137 }

◆ phiMaxOut()

const std::vector< double > & RegSelectorMap::phiMaxOut ( void  ) const

Definition at line 109 of file RegSelectorMap.cxx.

109  {
110  return m_phimax;
111 }

◆ phimaxValue()

double RegSelectorMap::phimaxValue ( void  ) const

Definition at line 77 of file RegSelectorMap.cxx.

77  {
78  return m_phimaxDet;
79 }

◆ phiMinOut()

const std::vector< double > & RegSelectorMap::phiMinOut ( void  ) const

Definition at line 105 of file RegSelectorMap.cxx.

105  {
106  return m_phimin;
107 }

◆ phiminValue()

double RegSelectorMap::phiminValue ( void  ) const

Definition at line 73 of file RegSelectorMap.cxx.

73  {
74  return m_phiminDet;
75 }

◆ 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.

365  {
366 
367  StatusCode sc = StatusCode::SUCCESS;
368 
369  // use path resolver to find full path to file
370  std::string unresolvedFileName(filename);
371  std::string fullFileName = PathResolver::find_file (unresolvedFileName, "DATAPATH");
372  //log << MSG::DEBUG << "PathResolver found " << fullFileName << endmsg;
373  if (fullFileName == "") {
374  //log << MSG::FATAL << "Could not find input file in DATAPATH" << unresolvedFileName<< endmsg;
375  std::cerr << "RegSelectorMap: FATAL: Could not find input file in DATAPATH" << unresolvedFileName<< std::endl;
376  return StatusCode::FAILURE;
377  }
378  //std::cout << "RegSelectDataIdentifierHash::read fullFileName=" << fullFileName << std::endl;
379 
380  switch(type){
381  case TILE:
382  sc = readTILE(fullFileName.c_str());
383  break;
384  default:
387  // ATH_MSG_ERROR( "Don't EVER use this code for anything except the Tile Calorimeter" );
388  sc = StatusCode::FAILURE;
389  }
390  return sc;
391 }

◆ readTILE()

StatusCode RegSelectorMap::readTILE ( const char *  filename)
private

Definition at line 778 of file RegSelectorMap.cxx.

778  {
779  StatusCode sc = StatusCode::SUCCESS;
780  char buffer_[256];
781  char *buffer = buffer_;
782  int barORend =0, layORwhe =0;
783  IdentifierHash hashId;
784  double emin, emax, pmin, pmax;
785  uint32_t robid, collid;
786 
787  std::ifstream fin(filename);
788  if(fin.bad()){ //Test if the file failed:
789  sc = StatusCode::FAILURE;
790  return sc;
791  }
792  fin.getline(buffer,128,'\n');
793  while (fin.getline(buffer, 128, '\n')){
794  if (strncmp(buffer,"#",1)!=0){
795  sscanf(buffer, "%x %x %x %lf %lf %lf %lf", &robid, &collid, (unsigned int*)&hashId, &emin, &emax, &pmin, &pmax);
796  writeLine(barORend, layORwhe, hashId, robid, emin, emax, pmin, pmax);
797  }
798  }
799  fin.close();
800 
801  return sc;
802 }

◆ 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.

223  {
224 
225  verifyInputsInternal( etaminIn, etamaxIn, phiminIn, phimaxIn );
226 
227  std::list<RegSelectorMapElement>::const_iterator it;
228  std::set<IdentifierHash> outset;
229  std::set<IdentifierHash>::const_iterator itset, negbarrelbeg,negbarrelend;
230  bool divideEta = false;
231 
232  for(it = m_barreldataList.begin(); //barrel list
233  it != m_barreldataList.end(); ++it){ // runs trought all RegSelectElementUints
234  (*it).selection(etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
235  }
236 
237  switch(TYPE){
238  case TILE: divideEta = true; break;
239  default: break;
240  }
241 
242  if( divideEta ){
243  if(etaminIn < 0 || etamaxIn < 0){ // negative data list
244  for(it = m_negdataList.begin();it != m_negdataList.end(); ++it){ // runs trought all RegSelectElementUints
245  (*it).selection(etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
246  }
247  }
248 
249  if( etaminIn >= 0 || etamaxIn >= 0 ){ // positive data list
250  for(it = m_posdataList.begin();it != m_posdataList.end(); ++it){ // runs trought all RegSelectElementUints
251  (*it).selection(etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
252  }
253  }
254  }
255  else{
256  for(it = m_negdataList.begin();it != m_negdataList.end(); ++it){ // runs trought all RegSelectElementUints
257  (*it).selection(etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
258  }
259  for(it = m_posdataList.begin();it != m_posdataList.end(); ++it){ // runs trought all RegSelectElementUints
260  (*it).selection(etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
261  }
262  }
263 
264  if (TYPE==TILE){
265  negbarrelbeg = outset.upper_bound(0x3f);
266  negbarrelend = outset.lower_bound(0x80);
267  for(itset = negbarrelbeg; itset != negbarrelend; ++itset){
268  outList.push_back(*itset);
269  }
270  for(itset = outset.begin(); itset != negbarrelbeg; ++itset){
271  outList.push_back(*itset);
272  }
273  for(itset = negbarrelend; itset != outset.end(); ++itset){
274  outList.push_back(*itset);
275  }
276  } else{
277  for(itset = outset.begin(); itset != outset.end(); ++itset){
278  outList.push_back(*itset);
279  }
280  }
281 
282 }

◆ 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.

326  {
327 
328  verifyInputsInternal( etaminIn, etamaxIn, phiminIn, phimaxIn );
329 
330  std::list<RegSelectorMapElement>::const_iterator it, itEnd;
331  std::set<IdentifierHash> outset;
332  std::set<IdentifierHash>::const_iterator itset;
333  bool posORneg;
334 
335 
336  if( etaminIn > 0 && etamaxIn > 0 ){ //search positive list to find layNumber
337  posORneg = false; // it's POSITIVE
338  findPosition(layNumber,posORneg, it);
339  (*it).selection( etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
340  }
341  else if( etaminIn < 0 && etamaxIn < 0 ){ //search negative list to find layNumber
342  posORneg = true; // it's NEGATIVE
343  findPosition(layNumber,posORneg, it);
344  (*it).selection( etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
345  }
346 
347  // barrel
348  it = m_barreldataList.begin();
349  itEnd = m_barreldataList.end();
350 
351  while(it != itEnd) {
352  if( (*it).layerDiskNumber() == layNumber ) {
353  (*it).selection( etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
354  break;
355  }
356  ++it;
357  }
358 
359  for(itset = outset.begin(); itset != outset.end(); ++itset){
360  outList.push_back(*itset);
361  }
362 
363 }

◆ 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.

287  {
288 
289  verifyInputsInternal( etaminIn, etamaxIn, phiminIn, phimaxIn );
290 
291  std::list<RegSelectorMapElement>::const_iterator it;
292  std::set<IdentifierHash> outset;
293  std::set<IdentifierHash>::const_iterator itset;
294  bool posORneg;
295 
296 
297  if( etaminIn > 0 && etamaxIn > 0 ){ //search positive list to find TYPEID
298  posORneg = false; // it's POSITIVE
299  findPosition(typeinID,posORneg, it);
300  (*it).selection( etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
301  }
302  else if( etaminIn < 0 && etamaxIn < 0 ){ //search negative list to find TYPEID
303  posORneg = true; // it's NEGATIVE
304  findPosition(typeinID,posORneg, it);
305  (*it).selection( etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
306  }
307  else { //search both list to find TYPEID
308  posORneg = false;
309  findPosition(typeinID,posORneg, it);
310  (*it).selection( etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
311  posORneg = true;
312  findPosition(typeinID,posORneg, it);
313  (*it).selection( etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
314  }
315 
316  for(itset = outset.begin(); itset != outset.end(); ++itset){
317  outList.push_back(*itset);
318  }
319 }

◆ 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.

142  {
143 
144  verifyInputsInternal( etaminIn, etamaxIn, phiminIn, phimaxIn );
145 
146  std::list<RegSelectorMapElement>::const_iterator it;
147  std::set<uint32_t> outset;
148  std::set<uint32_t>::const_iterator itset, negbarrelbeg, negbarrelend;
149  bool divideEta = false;
150 
151  for( it = m_barreldataList.begin(); //barrel list
152  it != m_barreldataList.end(); ++it){ // runs trought all RegSelectElementUints
153  (*it).selectionRobIdUint( etaminIn, etamaxIn, phiminIn, phimaxIn, outset );
154  }
155 
156  switch(TYPE){
157  case TILE: divideEta = true; break;
158  default: break;
159  }
160 
161  if( divideEta ){
162  if(etaminIn < 0 || etamaxIn < 0){ // negative data list
163  for(it = m_negdataList.begin();it != m_negdataList.end(); ++it){ // runs trought all RegSelectElementUints
164  (*it).selectionRobIdUint(etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
165  }
166  }
167 
168  if( etaminIn >= 0 || etamaxIn >= 0 ){ // positive data list
169  for(it = m_posdataList.begin();it != m_posdataList.end(); ++it){ // runs trought all RegSelectElementUints
170  (*it).selectionRobIdUint(etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
171  }
172  }
173  }
174  else{
175  for(it = m_negdataList.begin();it != m_negdataList.end(); ++it){ // runs trought all RegSelectElementUints
176  (*it).selectionRobIdUint(etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
177  }
178  for(it = m_posdataList.begin();it != m_posdataList.end(); ++it){ // runs trought all RegSelectElementUints
179  (*it).selectionRobIdUint(etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
180  }
181  }
182 
183  if (TYPE==TILE){
184  negbarrelbeg = outset.upper_bound(0x51000f);
185  negbarrelend = outset.lower_bound(0x530000);
186  for(itset = negbarrelbeg; itset != negbarrelend; ++itset){
187  outList.push_back(*itset);
188  }
189  for(itset = outset.begin(); itset != negbarrelbeg; ++itset){
190  outList.push_back(*itset);
191  }
192  for(itset = negbarrelend; itset != outset.end(); ++itset){
193  outList.push_back(*itset);
194  }
195  }else{
196  for(itset = outset.begin(); itset != outset.end(); ++itset){
197  outList.push_back(*itset);
198  }
199  }
200 
201 }

◆ 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.

524  {
525 
526  verifyInputsInternal( etaminIn, etamaxIn, phiminIn, phimaxIn );
527 
528  std::set<uint32_t> outset;
529  int i;
530  unsigned int j;
531  double etamin, etamax, phimin, phimax;
532  std::vector<uint32_t> outvec;
533 
534  int vecsize = m_etamin.size();
535  for( i= 0; i < vecsize; ++i){
536  if(m_etamin[i] > m_etamax[i]){
537  etamin = m_etamax[i]; etamax = m_etamin[i];
538  }
539  else{
540  etamin = m_etamin[i]; etamax = m_etamax[i];
541  }
542  if(m_phimin[i] > m_phimax[i]){
543  phimin = m_phimin[i];
544  phimax = phimaxValue();
545  if( (etaminIn <= etamax) && (etamaxIn >= etamin) ){
546  if( (phiminIn <= phimax) && (phimaxIn >= phimin) ){
547  outset.insert(m_robId[i]);
548  }
549  }
550  phimin = phiminValue();
551  phimax = m_phimax[i];
552  if( (etaminIn <= etamax) && (etamaxIn >= etamin) ){
553  if( (phiminIn <= phimax) && (phimaxIn >= phimin) ){
554  outset.insert(m_robId[i]);
555  }
556  }
557  }
558  else{
559  phimin = m_phimin[i]; phimax = m_phimax[i];
560  if( (etaminIn <= etamax) && (etamaxIn >= etamin) ){
561  if( (phiminIn <= phimax) && (phimaxIn >= phimin) ){
562  outset.insert(m_robId[i]);
563  }
564  }
565  }
566  }
567 
568  std::set<uint32_t>::iterator it;
569  for(it = outset.begin(); it != outset.end(); ++it)
570  outvec.push_back(*it);
571 
572  if(outvec == outList)
573  std::cout << "equal vectors " << std::endl;
574  std::cout << "desired output ";
575  for( j=0; j < outvec.size(); ++j)
576  std::cout << std::dec << outvec[j] << " ";
577  std::cout << std::endl;
578  std::cout << "obtained output ";
579  for( j=0; j < outList.size(); ++j)
580  std::cout << std::dec << outList[j] << " ";
581  std::cout << std::endl;
582 }

◆ 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.

590  {
591 
592  verifyInputsInternal( etaminIn, etamaxIn, phiminIn, phimaxIn );
593 
594  std::set<uint32_t> outset;
595  std::list<RegSelectorMapElement>::const_iterator it, itEnd;
596  std::set<uint32_t>::const_iterator itset;
597  bool posORneg;
598 
599 
600  if( etaminIn > 0 && etamaxIn > 0 ){ //search positive list to find layNumber
601  posORneg = false; // it's POSITIVE
602  findPosition(layNumber,posORneg, it);
603  (*it).selectionRobIdUint( etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
604  }
605  else if( etaminIn < 0 && etamaxIn < 0 ){ //search negative list to find layNumber
606  posORneg = true; // it's NEGATIVE
607  findPosition(layNumber,posORneg, it);
608  (*it).selectionRobIdUint( etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
609  }
610 
611  // barrel
612  it = m_barreldataList.begin();
613  itEnd = m_barreldataList.end();
614 
615  while(it != itEnd) {
616  if( (*it).layerDiskNumber() == layNumber ) {
617  (*it).selectionRobIdUint( etaminIn, etamaxIn, phiminIn, phimaxIn, outset);
618  break;
619  }
620  ++it;
621  }
622 
623  for(itset = outset.begin(); itset != outset.end(); ++itset){
624  outList.push_back(*itset);
625  }
626 
627 }

◆ removeDuplicates()

template<typename T >
static void IRegSelLUT::removeDuplicates ( std::vector< T > &  vec)
inlinestaticprotectedinherited

useful for removing duplicates if required ...

Definition at line 78 of file IRegSelLUT.h.

78  {
79  std::sort(vec.begin(), vec.end());
80  vec.erase(std::unique(vec.begin(), vec.end()), vec.end());
81  }

◆ ROBIDList() [1/2]

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

Rob identifier methods.

Rob identifier methods

Implements IRegSelLUT.

Definition at line 28 of file RegSelectorMap.cxx.

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

◆ 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
longlayer, long int to decide which layer within the detector.
IRoiDescriptorthe 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.

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

◆ 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.

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

◆ 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.

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

◆ robIdOut()

const std::vector< uint32_t > & RegSelectorMap::robIdOut ( void  ) const

Definition at line 85 of file RegSelectorMap.cxx.

85  {
86  return m_robId;
87 }

◆ summaryDataFile()

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

Definition at line 393 of file RegSelectorMap.cxx.

393  {
394  std::list<RegSelectorMapElement>::iterator it;
395 
396  for(it = dataList.begin(); it != dataList.end(); ++it){ // runs through entire list
397  std::cout << "position: " << (*it).layerDiskPosition() << " number: " << (*it).layerDiskNumber() << std::endl;
398  std::cout << "etamin: " << m_etaminDet << " etamax: " << m_etamaxDet << std::endl;
399  std::cout << "phimin: " << m_phiminDet << " phimax: " << m_phimaxDet << std::endl;
400  std::cout << "hashId: ";
401  std::vector<IdentifierHash> aux = (*it).hashId();
402  for(std::vector<IdentifierHash>::iterator i = aux.begin(); i != aux.end(); ++i)
403  std::cout << (*i) << " ";
404  std::cout << std::endl;
405  std::cin.get();
406  }
407 }

◆ verifyInputs()

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

Definition at line 434 of file RegSelectorMap.cxx.

435  {
436  verifyInputsInternal( etaminIn, etamaxIn, phiminIn, phimaxIn );
437  return StatusCode::SUCCESS;
438 }

◆ verifyInputsInternal()

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

Definition at line 411 of file RegSelectorMap.cxx.

412  {
413 
414  while (phiminIn > 2*M_PI) phiminIn -= 2*M_PI;
415  while (phiminIn < 0 ) phiminIn += 2*M_PI;
416  while (phimaxIn > 2*M_PI) phimaxIn -= 2*M_PI;
417  while (phimaxIn < 0 ) phimaxIn += 2*M_PI;
418 
419  if( ( (etaminIn < m_etaminDet) && (etamaxIn < m_etaminDet) ) ||
420  ( (etaminIn > m_etamaxDet) && (etamaxIn > m_etamaxDet) ) ){
421  }
422  else{
423  if( (etaminIn < m_etaminDet) && (etamaxIn > m_etaminDet) ){
424  etaminIn = m_etaminDet;
425  }
426  if( (etamaxIn > m_etamaxDet) && (etaminIn < m_etamaxDet) ){
427  etamaxIn = m_etamaxDet;
428  }
429  }
430 
431 }

◆ verifyInputsMinusPi()

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

Definition at line 442 of file RegSelectorMap.cxx.

443  {
444 
445  StatusCode sc = StatusCode::SUCCESS;
446 
447  while (phiminIn > M_PI) phiminIn -= 2*M_PI;
448  while (phiminIn < -M_PI) phiminIn += 2*M_PI;
449  while (phimaxIn > M_PI) phimaxIn -= 2*M_PI;
450  while (phimaxIn < -M_PI) phimaxIn += 2*M_PI;
451 
452  if( ( (etaminIn < m_etaminDet) && (etamaxIn < m_etaminDet) ) ||
453  ( (etaminIn > m_etamaxDet) && (etamaxIn > m_etamaxDet) ) ){
454  //sc = StatusCode::FAILURE;
455  }
456  else{
457  if( (etaminIn < m_etaminDet) && (etamaxIn > m_etaminDet) ){
458  etaminIn = m_etaminDet;
459  }
460  if( (etamaxIn > m_etamaxDet) && (etaminIn < m_etamaxDet) ){
461  etamaxIn = m_etamaxDet;
462  }
463  }
464 
465  return sc;
466 }

◆ 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.

470  {
471 
472  std::vector<IdentifierHash> outset;
473  int i;
474  unsigned int j;
475  double etamin, etamax, phimin, phimax;
476  int vecsize = m_etamin.size();
477  for( i= 0; i < vecsize; ++i){
478  if(m_etamin[i] > m_etamax[i]){
479  etamin = m_etamax[i]; etamax = m_etamin[i];
480  }
481  else{
482  etamin = m_etamin[i]; etamax = m_etamax[i];
483  }
484  if(m_phimin[i] > m_phimax[i]){
485  phimin = m_phimin[i];
486  phimax = phimaxValue();
487  if( (etaminIn <= etamax) && (etamaxIn >= etamin) ){
488  if( (phiminIn <= phimax) && (phimaxIn >= phimin) ){
489  outset.push_back(m_hashId[i]);
490  }
491  }
492  phimin = phiminValue();
493  phimax = m_phimax[i];
494  if( (etaminIn <= etamax) && (etamaxIn >= etamin) ){
495  if( (phiminIn <= phimax) && (phimaxIn >= phimin) ){
496  outset.push_back(m_hashId[i]);
497  }
498  }
499  }
500  else{
501  phimin = m_phimin[i]; phimax = m_phimax[i];
502  if( (etaminIn <= etamax) && (etamaxIn >= etamin) ){
503  if( (phiminIn <= phimax) && (phimaxIn >= phimin) ){
504  outset.push_back(m_hashId[i]);
505  }
506  }
507  }
508  }
509  if(outset == outputIdlist)
510  std::cout << "equal vectors " << std::endl;
511  std::cout << "desired output ";
512  for( j=0; j < outset.size(); ++j)
513  std::cout << std::dec << outset[j] << " ";
514  std::cout << std::endl;
515  std::cout << "obtained output ";
516  for( j=0; j < outputIdlist.size(); ++j)
517  std::cout << std::dec << outputIdlist[j] << " ";
518  std::cout << std::endl;
519 }

◆ 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.

766  {
767 
768  m_barORend.push_back(barORend);
769  m_layORdsk.push_back(layORdsk);
770  m_hashId.push_back(hashId);
771  m_robId.push_back(robId);
772  m_etamin.push_back(emin);
773  m_etamax.push_back(emax);
774  m_phimin.push_back(pmin);
775  m_phimax.push_back(pmax);
776 }

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:
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
RegSelectorMap::phimaxValue
double phimaxValue(void) const
Definition: RegSelectorMap.cxx:77
RegSelectorMap::phiminValue
double phiminValue(void) const
Definition: RegSelectorMap.cxx:73
RegSelectorMap::writeLine
void writeLine(int barORend, int layORdsk, IdentifierHash hashId, uint32_t robId, double emin, double emax, double pmin, double pmax)
Definition: RegSelectorMap.cxx:764
RegionSelectorLUT::layerDiskPosition
int layerDiskPosition(int hashId) const
Definition: RegionSelectorLUT.cxx:32
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
IRoiDescriptor::etaMinus
virtual double etaMinus() const =0
RegSelectorMap::insertList
void insertList(std::list< RegSelectorMapElement > &dataList, int positionIn, int numberIn, double etaminIn, double etamaxIn, double phiminIn, double phimaxIn, IdentifierHash hashIdIn, uint32_t &robIdIn)
Definition: RegSelectorMap.cxx:716
RegSelectorMapElement
Definition: RegSelectorMapElement.h:17
DMTest::C
C_v1 C
Definition: C.h:26
RegSelectorMap::m_barORend
std::vector< int > m_barORend
Definition: RegSelectorMap.h:152
skel.it
it
Definition: skel.GENtoEVGEN.py:407
IRoiDescriptor::size
virtual unsigned size() const =0
number of constituents
M_PI
#define M_PI
Definition: ActiveFraction.h:11
vec
std::vector< size_t > vec
Definition: CombinationsGeneratorTest.cxx:9
RegionSelectorLUT::maxHash
unsigned int maxHash(void) const
Definition: RegionSelectorLUT.cxx:68
IRoiDescriptor::etaPlus
virtual double etaPlus() const =0
RegionSelectorLUT::etaMin
double etaMin(int hashId) const
Definition: RegionSelectorLUT.cxx:40
RegSelectorMap::m_phimaxDet
double m_phimaxDet
Definition: RegSelectorMap.h:164
RegSelectorMap::m_posdataList
std::list< RegSelectorMapElement > m_posdataList
Definition: RegSelectorMap.h:150
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
RegSelectorMapElement::additem
void additem(const IdentifierHash hashId, const double etaMin, const double etaMax, const double phiMin, const double phiMax, const int layerDiskNumber, const int layerDiskPosition, const uint32_t robId)
Definition: RegSelectorMapElement.cxx:191
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
RegSelectorMap::m_layORdsk
std::vector< int > m_layORdsk
Definition: RegSelectorMap.h:152
RegionSelectorLUT::phiMax
double phiMax(int hashId) const
Definition: RegionSelectorLUT.cxx:52
RegSelectorMap::addLut
void addLut(const RegionSelectorLUT *detLut)
Definition: RegSelectorMap.cxx:203
RegSelectorMap::HashIDList_internal
virtual void HashIDList_internal(const IRoiDescriptor &roi, std::vector< IdentifierHash > &idlist) const
internal lookup table access for full interface ...
Definition: RegSelectorMap.cxx:40
createCoolChannelIdFile.buffer
buffer
Definition: createCoolChannelIdFile.py:11
lumiFormat.i
int i
Definition: lumiFormat.py:85
RegSelectorMap::creatingElement
RegSelectorMapElement creatingElement(int &positionIn, int &numberIn, double &etaminIn, double &etamaxIn, double &phiminIn, double &phimaxIn, IdentifierHash &hashIdIn, uint32_t &robId)
Definition: RegSelectorMap.cxx:702
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
master.flag
bool flag
Definition: master.py:29
RegSelectorMap::ROBIDList_internal
virtual void ROBIDList_internal(const IRoiDescriptor &roi, std::vector< uint32_t > &roblist) const
Rob identifier methods.
Definition: RegSelectorMap.cxx:52
IRoiDescriptor::phiMinus
virtual double phiMinus() const =0
IRoiDescriptor::phiPlus
virtual double phiPlus() const =0
extreme phi values
TYPE
#define TYPE(CODE, TYP, IOTYP)
RegSelectorMap::regionSelector
void regionSelector(DETID TYPE, double etaminIn, double etamaxIn, double phiminIn, double phimaxIn, std::vector< IdentifierHash > &outList) const
Definition: RegSelectorMap.cxx:220
RegSelectorMap::m_etamin
std::vector< double > m_etamin
Definition: RegSelectorMap.h:158
RegionSelectorLUT::robId
int robId(int hashId) const
Definition: RegionSelectorLUT.cxx:60
RegSelectorMap::m_etamaxDet
double m_etamaxDet
Definition: RegSelectorMap.h:162
RegSelectorMap::verifyInputsInternal
void verifyInputsInternal(double &etaminIn, double &etamaxIn, double &phiminIn, double &phimaxIn) const
Definition: RegSelectorMap.cxx:411
RegionSelectorLUT::layerDiskNumber
int layerDiskNumber(int hashId) const
Definition: RegionSelectorLUT.cxx:36
RegSelectorMap::insertDataElement
void insertDataElement(int &positionIn, int &numberIn, double &etaminIn, double &etamaxIn, double &phiminIn, double &phimaxIn, IdentifierHash &hashIdIn, uint32_t &robIdIn)
Definition: RegSelectorMap.cxx:748
TILE
@ TILE
Definition: RegSelEnums.h:30
RegSelectorMap::m_etaminDet
double m_etaminDet
Definition: RegSelectorMap.h:162
RegSelectorMap::m_barreldataList
std::list< RegSelectorMapElement > m_barreldataList
Definition: RegSelectorMap.h:150
RegSelectorMap::m_etamax
std::vector< double > m_etamax
Definition: RegSelectorMap.h:158
RegSelectorMap::m_phimin
std::vector< double > m_phimin
Definition: RegSelectorMap.h:160
RegionSelectorLUT::etaMax
double etaMax(int hashId) const
Definition: RegionSelectorLUT.cxx:44
RegSelectorMap::m_phiminDet
double m_phiminDet
Definition: RegSelectorMap.h:164
std::sort
void sort(typename std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, typename std::reverse_iterator< DataModel_detail::iterator< DVL > > end, const Compare &comp)
Specialization of sort for DataVector/List.
Definition: DVL_algorithms.h:623
PathResolver::find_file
static std::string find_file(const std::string &logical_file_name, const std::string &search_path)
Definition: PathResolver.cxx:221
RegSelectorMap::findPosition
void findPosition(TYPEID typeinID, bool posORneg, std::list< RegSelectorMapElement >::const_iterator &it) const
Definition: RegSelectorMap.cxx:629
zebraShift.outList
list outList
Definition: zebraShift.py:103
RegSelectorMap::m_robId
std::vector< uint32_t > m_robId
Definition: RegSelectorMap.h:156
IRoiDescriptor::isFullscan
virtual bool isFullscan() const =0
is this a full detector RoI?
CaloCellTimeCorrFiller.filename
filename
Definition: CaloCellTimeCorrFiller.py:23
compute_lumi.fin
fin
Definition: compute_lumi.py:19
RegSelectorMap::findMaxMinValues
void findMaxMinValues(std::list< RegSelectorMapElement > &dataList)
Definition: RegSelectorMap.cxx:685
RegSelectorMap::m_negdataList
std::list< RegSelectorMapElement > m_negdataList
Definition: RegSelectorMap.h:150
IdentifierHash
This is a "hash" representation of an Identifier. This encodes a 32 bit index which can be used to lo...
Definition: IdentifierHash.h:25
IRoiDescriptor::at
virtual const IRoiDescriptor * at(int i) const =0
find an RoiDescriptor constituent
RegSelectorMap::readTILE
StatusCode readTILE(const char *filename)
Definition: RegSelectorMap.cxx:778
LArCellBinning.etamin
etamin
Definition: LArCellBinning.py:137
RegSelectorMap::regionSelectorRobIdUint
void regionSelectorRobIdUint(DETID TYPE, double etaminIn, double etamaxIn, double phiminIn, double phimaxIn, std::vector< uint32_t > &outList) const
Definition: RegSelectorMap.cxx:139
IRegSelLUT::removeDuplicates
static void removeDuplicates(std::vector< T > &vec)
useful for removing duplicates if required ...
Definition: IRegSelLUT.h:78
RegionSelectorLUT::hashId
int hashId(int value) const
Definition: RegionSelectorLUT.cxx:64
RegSelectorMap::m_hashId
std::vector< IdentifierHash > m_hashId
Definition: RegSelectorMap.h:154
RegSelectorMap::m_phimax
std::vector< double > m_phimax
Definition: RegSelectorMap.h:160
IRoiDescriptor::composite
virtual bool composite() const =0
Super RoI access methods.
RegionSelectorLUT::phiMin
double phiMin(int hashId) const
Definition: RegionSelectorLUT.cxx:48
Generated on Mon Nov 24 2025 21:44:27 for ATLAS Offline Software by   doxygen 1.8.18