RegSelEtaPhiLUT Class Reference

#include <RegSelEtaPhiLUT.h>

Collaboration diagram for RegSelEtaPhiLUT:

Public Types
typedef TRegSelEtaPhiModule< IdentifierHash >	EtaPhiModule
	Concrete data type.
typedef std::set< EtaPhiModule >	moduleset
	tower of the actual modules assigned to each element of the lookup table
typedef TRegSelEtaPhiModule< moduleset >	map_element
	element type from which the look up table is built

Public Member Functions
	RegSelEtaPhiLUT (int Neta=3, int Nphi=32)
	defines the number of elements in the internal eta-phi element storage NB: these numbers of internal elements, 3, 32, have been optimised for 0.2 x 0.2 rois with 32 x 32 modules
virtual	~RegSelEtaPhiLUT ()
	destructor
bool	addModule (EtaPhiModule &m)
	add an element, returns true if element added.
void	getModules (const RegSelRoI &roi, std::vector< IdentifierHash > &hashids, double r=600) const
	get back a vector of the payload for each of the eta-phi segments that overlap with this roi
const std::vector< std::vector< map_element > > &	map () const
	access the actual complete map - shouldn't be public really, is only so for the ostream streamer
const EtaPhiBase	getElements (const RegSelRoI &roi, std::set< EtaPhiModule > &modules, double idradius=600) const
	get the modules from the elements, returns the virtual eta-phi roi corresponding to the virtual eta - phi region of the roi NB: Could return the number of eta-phi modules found rather than the virtual roi

Private Member Functions
void	getRowElements (const EtaPhiBase &virtual_roi, const std::vector< map_element > &row, int first_phi, int last_phi, std::set< EtaPhiModule > &modules) const
	get the modules from the elements in the phi direction, called for each eta slice processed

Private Attributes
double	m_etamin
	eta and phi ranges and number of internal book keeping elements in eta and phi directions
double	m_etamax
int	m_Neta
double	m_ideta
	inverse eta element size
double	m_phimin
double	m_phimax
int	m_Nphi
double	m_idphi
	inverse phi element size
TRegSelEtaPhiModule< std::vector< std::vector< map_element > > >	m_grandmap
	overall map, can get the limits from the object, can have different numbers and different ranges for different phi ranges - should swap eta and phi round probably

Detailed Description

Definition at line 45 of file RegSelEtaPhiLUT.h.

Member Typedef Documentation

EtaPhiModule

typedef TRegSelEtaPhiModule<IdentifierHash> RegSelEtaPhiLUT::EtaPhiModule

Concrete data type.

Definition at line 50 of file RegSelEtaPhiLUT.h.

map_element

typedef TRegSelEtaPhiModule<moduleset> RegSelEtaPhiLUT::map_element

element type from which the look up table is built

Definition at line 57 of file RegSelEtaPhiLUT.h.

moduleset

typedef std::set<EtaPhiModule> RegSelEtaPhiLUT::moduleset

tower of the actual modules assigned to each element of the lookup table

Definition at line 54 of file RegSelEtaPhiLUT.h.

Constructor & Destructor Documentation

RegSelEtaPhiLUT()

RegSelEtaPhiLUT::RegSelEtaPhiLUT	(	int	Neta = 3,
		int	Nphi = 32 )

defines the number of elements in the internal eta-phi element storage NB: these numbers of internal elements, 3, 32, have been optimised for 0.2 x 0.2 rois with 32 x 32 modules

constructor the number of elements in the internal eta-phi element storage

inverse element sizes

Definition at line 38 of file RegSelEtaPhiLUT.cxx.

                                                   : 
  m_etamin(-3), m_etamax(3),      m_Neta(Neta),  
  m_phimin(0),  m_phimax(2*M_PI), m_Nphi(Nphi), 
  m_grandmap( m_etamin, m_etamax, m_phimin, m_phimax,  
          std::vector< std::vector< map_element > >() )
{
  m_ideta = m_Neta/(m_etamax-m_etamin);    
  m_idphi = m_Nphi/(m_phimax-m_phimin);
    
  std::vector< std::vector< map_element > >& tmap = m_grandmap.payload();
  
  //  std::cout << "RegSelEtaPhiUT::RegSelEtaPhiLUT() Neta " << Neta << "\tNphi " << Nphi << std::endl;
 
  moduleset empty_set;
  
  for ( int i=0 ; i<m_Neta ; i++ ) { 
    
    double tetamin = m_etamin+i/m_ideta;
    double tetamax = m_etamin+(i+1)/m_ideta;
    
      std::vector< map_element > row;
      
      for ( int j=0 ; j<m_Nphi ; j++ ) { 
    double tphimin = m_phimin+j/m_idphi;
    double tphimax = m_phimin+(j+1)/m_idphi;
    
    map_element m( tetamin, tetamax, tphimin, tphimax, empty_set );
    
    row.push_back( m ); 
    
      }
      
      tmap.push_back( std::move(row) ); 
      
  }
    
}

~RegSelEtaPhiLUT()

RegSelEtaPhiLUT::~RegSelEtaPhiLUT ( )

virtual

destructor

Definition at line 80 of file RegSelEtaPhiLUT.cxx.

{ } 

Member Function Documentation

addModule()

bool RegSelEtaPhiLUT::addModule

(

EtaPhiModule &

m

)

add an element, returns true if element added.

Could return the number of eta-phi regions element was added to

first check if it overlaps with look up table at all

only do overlapping bits in eta

wrap in phi

does it overlap phi boundary?

Definition at line 87 of file RegSelEtaPhiLUT.cxx.

                                                 { 
 
  //    std::cout << "adding... " << m << std::endl;
 
  std::vector< std::vector< map_element > >& tmap = m_grandmap.payload();
  
  int first_eta = (m.etamin()-m_etamin)*m_ideta;
  int last_eta  = (m.etamax()-m_etamin)*m_ideta;
  
  int first_phi = (m.phimin()-m_phimin)*m_idphi;
  int last_phi  = (m.phimax()-m_phimin)*m_idphi;
  
  if ( !m_grandmap.overlap( m ) ) return false;
  
  if ( first_eta<0 )      first_eta = 0;
  if ( last_eta>=m_Neta ) last_eta  = m_Neta-1;
  
  if ( first_phi<0 )       first_phi += m_Nphi;
  if ( first_phi>=m_Nphi ) first_phi -= m_Nphi;
  
  if ( last_phi<0 )       last_phi += m_Nphi;
  if ( last_phi>=m_Nphi ) last_phi -= m_Nphi;
  
  
  if ( first_phi<last_phi ) { 
    for ( int i=int(first_eta) ; i<=last_eta ; i++ ) { 
      for ( int j=int(first_phi) ; j<=last_phi ; j++ ) tmap[i][j].payload().insert( m );
    }
  }
  else { 
    for ( int i=int(first_eta) ; i<=last_eta ; i++ ) { 
      for ( int j=0 ; j<=int(last_phi) ; j++ ) tmap[i][j].payload().insert( m );
      for ( int j=first_phi ; j<m_Nphi ; j++ ) tmap[i][j].payload().insert( m );
    }
  }
  
  //    std::cout << "added" << std::endl;
  
  return true;
}

getElements()

const EtaPhiBase RegSelEtaPhiLUT::getElements	(	const RegSelRoI &	roi,
		std::set< EtaPhiModule > &	modules,
		double	idradius = 600 ) const

get the modules from the elements, returns the virtual eta-phi roi corresponding to the virtual eta - phi region of the roi NB: Could return the number of eta-phi modules found rather than the virtual roi

add an element, returns the virtual eta-phi roi corresponding to the eta phi region of the roi NB: Could return the number of eta-phi modules found rather than the virtual roi

create a virtual roi for the input roi

check roi overlaps with the lookup table

don't have to cover the first_eta>=m_Neta case, etc as that is dealt with by the overlap test earlier

wrap in phi

does the roi overlap the phi boundary?

Definition at line 167 of file RegSelEtaPhiLUT.cxx.

                                                   { 
 
    modules.clear();
 
    //   struct timeval timer = simpletimer_start();

    const EtaPhiBase virtual_roi( roi.etaMinLimit(idradius), roi.etaMaxLimit(idradius), 
                  roi.getphiMin(),           roi.getphiMax() ); 
 
    //    double time = simpletimer_stop( timer );

    bool inmap = m_grandmap.overlap( virtual_roi );
 
    if ( !inmap ) return virtual_roi;
 
    int first_phi = (virtual_roi.phimin()-m_phimin)*m_idphi;
    int last_phi  = (virtual_roi.phimax()-m_phimin)*m_idphi;
 
    int first_eta = (virtual_roi.etamin()-m_etamin)*m_ideta;
    int last_eta  = (virtual_roi.etamax()-m_etamin)*m_ideta;

    if ( first_eta<0 )      first_eta = 0;
    if ( last_eta>=m_Neta ) last_eta = m_Neta-1;

    if ( first_phi<0 )       first_phi += m_Nphi;
    if ( first_phi>=m_Nphi ) first_phi -= m_Nphi;
 
    if ( last_phi<0 )       last_phi += m_Nphi;
    if ( last_phi>=m_Nphi ) last_phi -= m_Nphi;
 
    const std::vector< std::vector< map_element > >& tmap = map();

    if ( first_phi<last_phi ) { 
      for ( int i=first_eta ; i<=last_eta ; i++ ) { 
    getRowElements( virtual_roi, tmap[i], first_phi, last_phi, modules );
      }
    }
    else { 
      for ( int i=first_eta ; i<=last_eta ; i++ ) { 
    getRowElements( virtual_roi, tmap[i], 0,        last_phi, modules );
    getRowElements( virtual_roi, tmap[i], first_phi, m_Nphi-1,  modules );
      }
    }
    
    return virtual_roi;
}

getModules()

void RegSelEtaPhiLUT::getModules	(	const RegSelRoI &	roi,
		std::vector< IdentifierHash > &	hashids,
		double	r = 600 ) const

get back a vector of the payload for each of the eta-phi segments that overlap with this roi

Definition at line 137 of file RegSelEtaPhiLUT.cxx.

                                   {
    
  hashids.clear();
  
  std::set<EtaPhiModule> modules;
  
  getElements( roi, modules, r );
  
  hashids.reserve( modules.size() );
  
  std::set<EtaPhiModule>::iterator rpitr=modules.begin();
  std::set<EtaPhiModule>::iterator rpend=modules.end();
  
  while ( rpitr!=rpend ) { 
    hashids.push_back( rpitr->payload() );
    ++rpitr;
  }
  
} 

getRowElements()

void RegSelEtaPhiLUT::getRowElements ( const EtaPhiBase & virtual_roi, const std::vector< map_element > & row, int first_phi, int last_phi, std::set< EtaPhiModule > & modules ) const

inlineprivate

get the modules from the elements in the phi direction, called for each eta slice processed

here, need to iterate over all the modules in the region and test whether they overlap with the roi

Definition at line 97 of file RegSelEtaPhiLUT.h.

                                                     { 
    
    for ( int j=first_phi ; j<=last_phi ; j++ ) { 
      
      const map_element& tower = row[j];
      
      moduleset::const_iterator rpitr=tower.payload().begin();
      moduleset::const_iterator rpend=tower.payload().end();
 
      while ( rpitr!=rpend ) { 
        if ( virtual_roi.overlap( *rpitr ) ) modules.insert( *rpitr );
        ++rpitr;
      }      
    }
  }

map()

const std::vector< std::vector< map_element > > & RegSelEtaPhiLUT::map ( ) const

inline

access the actual complete map - shouldn't be public really, is only so for the ostream streamer

Definition at line 85 of file RegSelEtaPhiLUT.h.

{ return m_grandmap.payload(); };

Member Data Documentation

m_etamax

double RegSelEtaPhiLUT::m_etamax

private

Definition at line 123 of file RegSelEtaPhiLUT.h.

m_etamin

double RegSelEtaPhiLUT::m_etamin

private

eta and phi ranges and number of internal book keeping elements in eta and phi directions

Definition at line 122 of file RegSelEtaPhiLUT.h.

m_grandmap

TRegSelEtaPhiModule< std::vector< std::vector< map_element > > > RegSelEtaPhiLUT::m_grandmap

private

overall map, can get the limits from the object, can have different numbers and different ranges for different phi ranges - should swap eta and phi round probably

Definition at line 140 of file RegSelEtaPhiLUT.h.

m_ideta

double RegSelEtaPhiLUT::m_ideta

private

inverse eta element size

Definition at line 128 of file RegSelEtaPhiLUT.h.

m_idphi

double RegSelEtaPhiLUT::m_idphi

private

inverse phi element size

Definition at line 136 of file RegSelEtaPhiLUT.h.

m_Neta

int RegSelEtaPhiLUT::m_Neta

private

Definition at line 125 of file RegSelEtaPhiLUT.h.

m_Nphi

int RegSelEtaPhiLUT::m_Nphi

private

Definition at line 133 of file RegSelEtaPhiLUT.h.

m_phimax

double RegSelEtaPhiLUT::m_phimax

private

Definition at line 131 of file RegSelEtaPhiLUT.h.

m_phimin

double RegSelEtaPhiLUT::m_phimin

private

Definition at line 130 of file RegSelEtaPhiLUT.h.

---

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

• RegSelEtaPhiLUT.h
• RegSelEtaPhiLUT.cxx