RegSelEtaPhiLUT.h

Go to the documentation of this file.

// emacs: this is -*- c++ -*-
/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
//
//   @file    RegSelEtaPhiLUT.h        
//
//            a look up table for eta-phi space divided up into 
//            a set of elements Neta x Nphi.
//
//            "Modules" are added to the lookup table, and are 
//            stored in each element that they overlap with, so 
//            that all the modules overlapping an internal element 
//            for a tower of modules (actually stored as a set)
//            as the payload for the element.  
//
//            Because RoIs are defined in terms of a z range, 
//            without these z positions, eta coordinates are 
//            not well defined.
//            As a result, when passed an RoI, this class calculates
//            a virtual RoI, just in eta-phi space, where the eta
//            range corresponds to the maxuimum and minimum eta
//            possible from any z position with the RoI where the
//            object can be completely contained within a user 
//            specified radius. The default value is 600mm, chosen
//            to completely contain the outer radius of the SCT       
//  
//                
//
 
 
#ifndef REGSELETAPHILUT_H
#define REGSELETAPHILUT_H
 
#include <iostream>
#include <vector>
#include <set>
 
#include "RegSelLUT/RegSelRoI.h"
#include "RegSelLUT/RegSelEtaPhiModule.h"
#include "Identifier/IdentifierHash.h"
 
 
 
class RegSelEtaPhiLUT {
 
public:
 
  typedef TRegSelEtaPhiModule<IdentifierHash>  EtaPhiModule;
  
  typedef std::set<EtaPhiModule>               moduleset;
 
  typedef TRegSelEtaPhiModule<moduleset>       map_element;  
    
public:
 
  RegSelEtaPhiLUT(int Neta=3, int Nphi=32);
  
  virtual ~RegSelEtaPhiLUT();
 
 
  bool addModule( EtaPhiModule& m );
 
 
  void getModules( const RegSelRoI& roi, 
           std::vector<IdentifierHash>& hashids, 
           double r=600 ) const;
 
 
  const std::vector< std::vector< map_element > >& map() const { return m_grandmap.payload(); };
 
  
  const EtaPhiBase getElements( const RegSelRoI& roi, std::set<EtaPhiModule>& modules, double idradius=600 ) const;
 
private:
  
  void getRowElements( const EtaPhiBase& virtual_roi, 
               const std::vector< map_element >& row, 
               int first_phi, int last_phi, 
               std::set<EtaPhiModule>& modules ) const { 
    
    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;
      }      
    }
  }
 
 
private:
 
  double m_etamin;
  double m_etamax;
  
  int    m_Neta;
 
  double m_ideta;
  
  double m_phimin;
  double m_phimax;
  
  int    m_Nphi;
  
  double m_idphi;
 
  TRegSelEtaPhiModule< std::vector< std::vector< map_element > >  > m_grandmap;  
 
};
 
 
 
inline std::ostream& operator<<( std::ostream& s, const RegSelEtaPhiLUT& f ) { 
 
  for ( unsigned i=0 ; i<f.map().size() ; i++ ) { 
 
    const std::vector< RegSelEtaPhiLUT::map_element >& row = f.map()[i];
 
    s << "row " << i << std::endl;
    
    for ( unsigned j=0 ; j<row.size() ; j++ ) { 
      
      const RegSelEtaPhiLUT::map_element& tower = row[j];
      
      s << "\t" << j << "\t" << (EtaPhiBase)tower << " \t:";
 
      RegSelEtaPhiLUT::moduleset::const_iterator rpitr=tower.payload().begin();
      RegSelEtaPhiLUT::moduleset::const_iterator rpend=tower.payload().end();
 
      while ( rpitr!=rpend ) { 
        s << "\t" << (EtaPhiBase)(*rpitr);
        ++rpitr;
      }
      
      s << std::endl;
    }
 
    s << std::endl;
 
  }
 
  return s;
}
 
#endif  // __REGSELETAPHILUT_H