FPGATrackSimHoughTransformTool Class Reference

#include <FPGATrackSimHoughTransformTool.h>

Inheritance diagram for FPGATrackSimHoughTransformTool:

Classes
struct	LUT
struct	pos

Public Types
typedef vector2D< std::pair< int, std::unordered_set< std::shared_ptr< const FPGATrackSimHit > > > >	Image

Public Member Functions
virtual StatusCode	initialize () override
virtual StatusCode	getRoads (const std::vector< std::shared_ptr< const FPGATrackSimHit > > &hits, std::vector< std::shared_ptr< const FPGATrackSimRoad > > &roads) override
double	getMinX () const
double	getMaxX () const
double	getMinY () const
double	getMaxY () const
unsigned	getThreshold () const
virtual int	getSubRegion () const override
double	yToX (double y, const std::shared_ptr< const FPGATrackSimHit > &hit) const
Image const &	getImage () const

Public Attributes
int	m_bitlength = 16

Private Member Functions
Image	createLayerImage (std::vector< unsigned > const &combine_layers, const std::vector< std::shared_ptr< const FPGATrackSimHit > > &hits, unsigned const scale) const
Image	createImage (const std::vector< std::shared_ptr< const FPGATrackSimHit > > &hits) const
std::vector< std::vector< int > >	lineGenLay (const std::shared_ptr< const FPGATrackSimHit > &hit) const
Image	convolute (Image const &image) const
std::pair< unsigned, unsigned >	yToXBins (size_t yBin_min, size_t yBin_max, const std::shared_ptr< const FPGATrackSimHit > &hit) const
unsigned	getExtension (unsigned y, unsigned layer) const
bool	passThreshold (Image const &image, unsigned x, unsigned y) const
void	addRoad (const std::vector< std::vector< std::shared_ptr< const FPGATrackSimHit > > > &hits, layer_bitmask_t hitLayers, unsigned x, unsigned y)
void	addRoad (const std::unordered_set< std::shared_ptr< const FPGATrackSimHit > > &hits, unsigned x, unsigned y)
void	addRoad (const std::vector< std::shared_ptr< const FPGATrackSimHit > > &hits, unsigned x, unsigned y)
int	conv (unsigned y, unsigned x)
void	drawImage (Image const &image, std::string const &name)
void	makeLUT (std::vector< std::vector< std::vector< LUT > > > &v_LUT, std::vector< TH1D * > &v_h, const std::string &tag="")

Private Attributes
ServiceHandle< IFPGATrackSimEventSelectionSvc >	m_EvtSel {this, "FPGATrackSimEventSelectionSvc", ""}
ServiceHandle< IFPGATrackSimBankSvc >	m_FPGATrackSimBankSvc {this, "FPGATrackSimBankSvc", "FPGATrackSimBankSvc"}
ServiceHandle< IFPGATrackSimMappingSvc >	m_FPGATrackSimMapping {this, "FPGATrackSimMappingSvc", "FPGATrackSimMappingSvc"}
FPGATrackSimTrackPars	m_parMin
FPGATrackSimTrackPars	m_parMax
FPGATrackSimTrackPars::pars_index	m_par_x = FPGATrackSimTrackPars::IPHI
FPGATrackSimTrackPars::pars_index	m_par_y = FPGATrackSimTrackPars::IHIP
Gaudi::Property< int >	m_subRegion { this, "subRegion", 0," -1 for entire region (no slicing)"}
Gaudi::Property< float >	m_tempMin_phi { this, "phi_min", 0, "min phi"}
Gaudi::Property< float >	m_tempMax_phi { this, "phi_max", 0, "max phi"}
Gaudi::Property< float >	m_tempMin_qOverPt { this, "qpT_min", 0, "min q/pt"}
Gaudi::Property< float >	m_tempMax_qOverPt { this, "qpT_max", 0, "max q/pt"}
Gaudi::Property< float >	m_tempMin_d0 { this, "d0_min", 0, "min q/pt"}
Gaudi::Property< float >	m_tempMax_d0 { this, "d0_max", 0, "max q/pt"}
Gaudi::Property< std::vector< int > >	m_threshold { this, "threshold", {},"Minimum number of hit layers to fire a road"}
Gaudi::Property< unsigned >	m_imageSize_x { this, "nBins_x", 0, ""}
Gaudi::Property< unsigned >	m_imageSize_y { this, "nBins_y", 0, ""}
Gaudi::Property< std::vector< int > >	m_conv { this, "convolution", {}, "Convolution filter, with size m_convSize_y * m_convSize_x"}
Gaudi::Property< std::vector< unsigned > >	m_combineLayers { this, "combine_layers", {}, ""}
Gaudi::Property< std::vector< unsigned > >	m_binScale { this, "scale", {}, "Vector containing the scales for each layers"}
Gaudi::Property< unsigned >	m_convSize_x { this, "convSize_x", 0, ""}
Gaudi::Property< unsigned >	m_convSize_y { this, "convSize_y", 0, ""}
Gaudi::Property< std::vector< unsigned > >	m_hitExtend_x { this, "hitExtend_x", {}, "Hit lines will fill extra bins in x by this amount on each side, size == nLayers"}
Gaudi::Property< bool >	m_traceHits { this, "traceHits", true, "Trace each hit that goes in a bin. Disabling this will save memory/time since each bin doesn't have to store all its hits but the roads created won't have hits from convolution, etc."}
Gaudi::Property< bool >	m_localMaxWindowSize { this, "localMaxWindowSize", 0, "Only create roads that are a local maximum within this window size. Set this to 0 to turn off local max filtering"}
Gaudi::Property< bool >	m_fieldCorrection { this, "fieldCorrection", true, "Apply corrections to hough equation due to field nonuniformity"}
Gaudi::Property< bool >	m_useSectors { this, "useSectors", false, "Will reverse calculate the sector for track-fitting purposes"}
Gaudi::Property< bool >	m_idealGeoRoads { this, "IdealGeoRoads", true, "Set sectors to use ideal geometry fit constants"}
Gaudi::Property< bool >	m_doRegionalMapping { this, "RegionalMapping", false, "Use the sub-region maps to define the sector"}
Gaudi::Property< bool >	m_doEtaPatternConsts { this, "doEtaPatternConsts", false, "Whether to use the eta pattern tool for constant generation"}
Gaudi::Property< bool >	m_useSpacePoints { this, "useSpacePoints", false, "Whether we are using spacepoints."}
Gaudi::Property< std::string >	m_houghType { this, "houghType", "Original", "Switch Hough strategy. Original: close to mathematical HT, LowResource: emulate pre calculated LUTs base FPGA performance, Flexible: emulate culculation on FPGA performance"}
Gaudi::Property< bool >	m_roadMerge { this, "roadMerge", false}
Gaudi::Property< std::string >	m_requirements { this, "requirements", "", "path of the requirements file"}
Gaudi::Property< int >	m_r_max { this, "r_max", 2047," - maximum -"}
Gaudi::Property< int >	m_phi_coord_max { this, "phi_coord_max", 65535," - maximum - phi"}
Gaudi::Property< double >	m_phi_range { this, "phi_range", 6.399609375,"range of phi in rad, customized ofr the algo"}
Gaudi::Property< double >	m_r_max_mm { this, "r_max_mm", 1137.5,"r value maximum used in the mm-to-bits conversion"}
Gaudi::Property< int >	m_bitwise_qApt_conv { this, "bitwise_qApt_conv", 16384, "exponential of 2 to multiply with qA/pt in case the latter in < 1"}
Gaudi::Property< int >	m_bitwise_phi0_conv { this, "bitwise_phi0_conv", 1, "exponential of 2 to multiply with phi0 in case the latter in < 1"}
Gaudi::Property< int >	m_phi0_sectors { this, "phi0_sectors", 1,"firmware method to draw monotonic lines. separation alongside phi0"}
Gaudi::Property< int >	m_qApt_sectors { this, "qApt_sectors", 7,"firmware method to draw monotonic lines. separation alongside qA/pt"}
Gaudi::Property< int >	m_pipes_qApt { this, "pipes_qApt", 8,"!!!!!!MAX 32 !!!!!!clock domains separation alongside qA/pt bins"}
Gaudi::Property< int >	m_pipes_phi0 { this, "pipes_phi0", 1," !!!!!!MAX 32 !!!!!!clock domains separation alongside phi0 bins"}
std::vector< std::vector< unsigned > >	m_combineLayer2D
unsigned	m_nLayers = 0U
unsigned	m_nCombineLayers = 0U
double	m_step_x = 0
double	m_step_y = 0
std::vector< double >	m_bins_x
std::vector< double >	m_bins_y
int	m_HT_sel = 0
long int	m_one_r_const_twoexp = 0
double	m_phi0_min_bit = 0
double	m_qApt_min_bit = 0
long int	m_DBinQApt_bit_int = 0
long int	m_DBinPhi0_bit_int = 0
long int	m_qAptBins_bit = 0
long int	m_phi0Bins_bit = 0
long int	m_phi0_bins_first_sector = 0
long int	m_qApt_bins_first_sector = 0
long int	m_tot_bitwise_conv = 0
long int	m_one_r_const_twoexp_post_conv = 0
long int	m_qApt_min_post_conv = 0
Image	m_image
std::vector< FPGATrackSimRoad >	m_roads
std::vector< std::vector< std::vector< LUT > > >	m_LUT
std::vector< TH1D * >	m_h_rfix

Detailed Description

Definition at line 90 of file FPGATrackSimHoughTransformTool.h.

Member Typedef Documentation

Image

typedef vector2D<std::pair<int, std::unordered_set<std::shared_ptr<const FPGATrackSimHit> > > > FPGATrackSimHoughTransformTool::Image

Definition at line 116 of file FPGATrackSimHoughTransformTool.h.

Member Function Documentation

addRoad() [1/3]

void FPGATrackSimHoughTransformTool::addRoad ( const std::unordered_set< std::shared_ptr< const FPGATrackSimHit > > & hits, unsigned x, unsigned y )

private

Definition at line 752 of file FPGATrackSimHoughTransformTool.cxx.

{
  layer_bitmask_t hitLayers = 0;
  for (auto const & hit : hits)
    hitLayers |= 1 << hit->getLayer();
 
  auto sorted_hits = ::sortByLayer(hits);
  sorted_hits.resize(m_nLayers); // If no hits in last layer, return from sortByLayer will be too short
 
  addRoad(sorted_hits, hitLayers, x, y);
}

addRoad() [2/3]

void FPGATrackSimHoughTransformTool::addRoad ( const std::vector< std::shared_ptr< const FPGATrackSimHit > > & hits, unsigned x, unsigned y )

private

Definition at line 765 of file FPGATrackSimHoughTransformTool.cxx.

{
  // Get the road hits
  std::vector<std::shared_ptr<const FPGATrackSimHit>> road_hits;
  layer_bitmask_t hitLayers = 0;
  for (const auto & hit : hits)
    {
      // Find the min/max y bins (after scaling)
      unsigned int y_bin_min = (y / m_binScale[hit->getLayer()]) * m_binScale[hit->getLayer()];
      unsigned int y_bin_max = y_bin_min + m_binScale[hit->getLayer()];
 
      // Find the min/max x bins
      auto xBins = yToXBins(y_bin_min, y_bin_max, hit);
      if (x >= xBins.first && x < xBins.second)
        {
      road_hits.push_back(hit);
      hitLayers |= 1 << hit->getLayer();
        }
    }
 
  auto sorted_hits = ::sortByLayer(road_hits);
  sorted_hits.resize(m_nLayers); // If no hits in last layer, return from sortByLayer will be too short
 
  addRoad(sorted_hits, hitLayers, x, y);
}

addRoad() [3/3]

void FPGATrackSimHoughTransformTool::addRoad ( const std::vector< std::vector< std::shared_ptr< const FPGATrackSimHit > > > & hits, layer_bitmask_t hitLayers, unsigned x, unsigned y )

private

Definition at line 729 of file FPGATrackSimHoughTransformTool.cxx.

{
  m_roads.emplace_back();
  FPGATrackSimRoad & r = m_roads.back();
 
  r.setRoadID(m_roads.size() - 1);
  r.setPID(y * m_imageSize_y + x);
  r.setHits( std::vector<std::vector<std::shared_ptr<const FPGATrackSimHit>>>(hits)); //copy hits
 
  // We use the y coordinate in matchIdealGeoSectors
  // and so it needs to be available before setting the sector.
 
  r.setSubRegion(m_subRegion);
  r.setX(m_bins_x[x] + m_step_x/2);
  r.setY(m_bins_y[y] + m_step_y/2);
  r.setXBin(x);
  r.setYBin(y);
  r.setHitLayers(hitLayers);
  r.setSubRegion(m_subRegion);
}

conv()

int FPGATrackSimHoughTransformTool::conv ( unsigned y, unsigned x )

inlineprivate

Definition at line 255 of file FPGATrackSimHoughTransformTool.h.

{ return m_conv[y * m_convSize_x + x]; } // NOTE: y index is first

convolute()

FPGATrackSimHoughTransformTool::Image FPGATrackSimHoughTransformTool::convolute ( Image const & image ) const

private

Definition at line 364 of file FPGATrackSimHoughTransformTool.cxx.

{
  Image out(m_imageSize_y, m_imageSize_x);
 
  for (unsigned y0 = 0; y0 < m_imageSize_y; y0++)     // Loop over out
    for (unsigned x0 = 0; x0 < m_imageSize_x; x0++) 
      for (unsigned r = 0; r < m_convSize_y; r++)     // Loop over conv
        for (unsigned c = 0; c < m_convSize_x; c++) {
            int y = -static_cast<int>(m_convSize_y) / 2 + r + y0; // Indices of input
            int x = -static_cast<int>(m_convSize_x) / 2 + c + x0; //
      
          if (y >= 0 && y < static_cast<int>(m_imageSize_y) && x >= 0 && x < static_cast<int>(m_imageSize_x)) {
              int val = m_conv[r * m_convSize_x + c] * image(y, x).first;
              if (val > 0) {
                out(y0, x0).first += val;
                out(y0, x0).second.insert(image(y, x).second.begin(), image(y, x).second.end());
              }
            }
          }  
  return out;
}

createImage()

FPGATrackSimHoughTransformTool::Image FPGATrackSimHoughTransformTool::createImage ( const std::vector< std::shared_ptr< const FPGATrackSimHit > > & hits ) const

private

Definition at line 346 of file FPGATrackSimHoughTransformTool.cxx.

{
  Image image(m_imageSize_y, m_imageSize_x);
 
  for (unsigned i = 0; i < m_nCombineLayers; i++)
    {
      Image layerImage = createLayerImage(m_combineLayer2D[i], hits, m_binScale[i]);
      for (unsigned x = 0; x < m_imageSize_x; ++x)
    for (unsigned y = 0; y < m_imageSize_y; ++y)
      if (layerImage(y, x).first > 0)
        {
          image(y, x).first++;
          image(y, x).second.insert(layerImage(y, x).second.begin(), layerImage(y, x).second.end());
        }
    }
  return image;
}

createLayerImage()

FPGATrackSimHoughTransformTool::Image FPGATrackSimHoughTransformTool::createLayerImage ( std::vector< unsigned > const & combine_layers, const std::vector< std::shared_ptr< const FPGATrackSimHit > > & hits, unsigned const scale ) const

private

Definition at line 249 of file FPGATrackSimHoughTransformTool.cxx.

{
  Image image(m_imageSize_y, m_imageSize_x);
 
  for (const auto& hit : hits) {
    if (std::find(layers.begin(), layers.end(), hit->getLayer()) == layers.end()) continue;
 
    if (m_houghType == "LowResource"){
      //FIXME at the moment, only the barrel is considered. And as the r is mostly the same for two strip layers, those two layers share the LUTs of acceptable input phi values. Here, LUT_layer is used to switch the list of LUTs 
      int LUT_layer = -1;
      switch (hit->getLayer()){
        case 0 :
          LUT_layer = 0;
          break;
        case 1 :
        case 2 :
          LUT_layer = 1;
          break;
        case 3 :
        case 4 :
          LUT_layer = 2;
          break;
        case 5 :
        case 6 :
          LUT_layer = 3;
          break;
        case 7 :
        case 8 :
          LUT_layer = 4;
          break;
        default :
          ATH_MSG_FATAL("Debug: something wrong! layer: " << hit->getLayer());
          break;
      }
      if (LUT_layer <0){
        ATH_MSG_ERROR("FPGATrackSimHoughTransformTool: array index is negative");
        return image;
      }
      int phi_L_bin = m_h_rfix.at(LUT_layer)->FindBin(hit->getGPhi());
      int MSB = (phi_L_bin >> (m_bitlength -6));
      if(MSB >= 64) MSB = 63;//for barrel, MSB should be up to 63, but this line force it to not crash
      for(const auto& LUT_i: m_LUT.at(LUT_layer).at(MSB)){//check LUTs only correspoinding MSB
    if(LUT_i.input_begin <= phi_L_bin && phi_L_bin <= LUT_i.input_end){//If in the range, then fire it
      for(const auto& pos: LUT_i.output){
        image(pos.y -1, pos.x -1).first++;//NOTE : pos is 1 start
        if (m_traceHits) image(pos.y -1, pos.x -1).second.insert(hit);
      }
    }
      }
    } else if (m_houghType == "Flexible") {
    double r = hit->getR();
    int r_bit = static_cast<int>(r * m_r_max / m_r_max_mm);   
    int input_bins_vector_size = 0;
    
    //Bologna Flexible HT uses qA/Pt=.... or Phi0=.... depending from the axis with more bins (qA/Pt axis #bin > Phi0 then Phi0=..... and viceversa)
    if (r_bit > m_HT_sel) { //formula for qA/Pt HT
      input_bins_vector_size = m_imageSize_x;
  } else { //formula for Phi0 HT
      input_bins_vector_size = m_imageSize_y;
  }
        
  std::vector<std::vector<int>> hitLineQAPtPhi0(input_bins_vector_size);
  hitLineQAPtPhi0 = lineGenLay(hit);
  
    for (const std::vector<int>& it_base : hitLineQAPtPhi0) {
        if (it_base[0] != -1 && it_base[1] != -1) {   
              image(it_base[0] , it_base[1]).first++;
              if (m_traceHits) {
                  image(it_base[0] , it_base[1]).second.insert(hit);
              }
        }
    }
    }else{
      // This scans over y (pT) because that is more efficient in memory, in C.
      // Unknown if firmware will want to scan over x instead.
      unsigned new_size_y  = m_imageSize_y / scale;
      for (unsigned y_ = 0; y_ < new_size_y; y_++) {
    unsigned y_bin_min = scale * y_;
    unsigned y_bin_max = scale * (y_ + 1);
 
    // Find the min/max x bins
    auto xBins = yToXBins(y_bin_min, y_bin_max, hit);
 
    // Update the image
    for (unsigned y = y_bin_min; y < y_bin_max; y++){
      for (unsigned x = xBins.first; x < xBins.second; x++) {
        image(y, x).first++;
        if (m_traceHits) image(y, x).second.insert(hit);
      }
    }
      }
    }
  }
 
  return image;
}

drawImage()

void FPGATrackSimHoughTransformTool::drawImage ( Image const & image, std::string const & name )

private

getExtension()

unsigned FPGATrackSimHoughTransformTool::getExtension ( unsigned y, unsigned layer ) const

private

Definition at line 715 of file FPGATrackSimHoughTransformTool.cxx.

{
  if (m_hitExtend_x.size() == m_nLayers) return m_hitExtend_x[layer];
  if (m_hitExtend_x.size() == m_nLayers * 2)
    {
      // different extension for low pt vs high pt, split in half but irrespective of sign
      // first nLayers entries of m_hitExtend_x is for low pt half, rest are for high pt half
      if (y < m_imageSize_y / 4 || y > 3 * m_imageSize_y / 4) return m_hitExtend_x[layer];
      return m_hitExtend_x[m_nLayers + layer];
    }
  return 0;
}

getImage()

Image const & FPGATrackSimHoughTransformTool::getImage ( ) const

inline

Definition at line 121 of file FPGATrackSimHoughTransformTool.h.

{ return m_image; } // Returns the image generated from the last call of getRoads

getMaxX()

double FPGATrackSimHoughTransformTool::getMaxX ( ) const

inline

Definition at line 107 of file FPGATrackSimHoughTransformTool.h.

{ return m_parMax[m_par_x]; }

getMaxY()

double FPGATrackSimHoughTransformTool::getMaxY ( ) const

inline

Definition at line 109 of file FPGATrackSimHoughTransformTool.h.

{ return m_parMax[m_par_y]; }

getMinX()

double FPGATrackSimHoughTransformTool::getMinX ( ) const

inline

Definition at line 106 of file FPGATrackSimHoughTransformTool.h.

{ return m_parMin[m_par_x]; }

getMinY()

double FPGATrackSimHoughTransformTool::getMinY ( ) const

inline

Definition at line 108 of file FPGATrackSimHoughTransformTool.h.

{ return m_parMin[m_par_y]; }

getRoads()

StatusCode FPGATrackSimHoughTransformTool::getRoads ( const std::vector< std::shared_ptr< const FPGATrackSimHit > > & hits, std::vector< std::shared_ptr< const FPGATrackSimRoad > > & roads )

overridevirtual

Definition at line 155 of file FPGATrackSimHoughTransformTool.cxx.

{
  roads.clear();
  m_roads.clear();
 
  m_image = createImage(hits);
 
  //objects for road merge, all roads go through them, except m_traceHits is disabled
  std::vector<std::pair<unsigned, unsigned>> roadListXY;
  std::unordered_set<std::shared_ptr<const FPGATrackSimHit>> merged_image;
 
  if (!m_conv.empty()) m_image = convolute(m_image);
 
  for (unsigned y = 0; y < m_imageSize_y; y++){
    for (unsigned x = 0; x < m_imageSize_x; x++){
      if (passThreshold(m_image, x, y)){
        if (m_traceHits){
      //first road is pushed to the roadList
      roadListXY.push_back({x, y});
    }else{
      addRoad(hits, x, y);
        }
      }
    }
  }
 
  for (const auto & roadXY : roadListXY){
    ATH_MSG_DEBUG("roadList x : " << roadXY.first << ", y : " << roadXY.second);
  }
 
  if(!m_traceHits){
    if(m_roadMerge)
      ATH_MSG_DEBUG("Trace hits is disabled. Road merge doesn't work with this state at the moment.");
  }
 
  if(!m_roadMerge){//in case road marge is disabled, add road as usual
    for (const auto & roadXY : roadListXY){
      unsigned x = roadXY.first;
      unsigned y = roadXY.second;
      addRoad(m_image(y, x).second, x, y);
    }
  }else{
    if(!roadListXY.empty()){
      std::vector<std::pair<unsigned, unsigned>> mergedRoadListXY;//merged road liste
      size_t roadCounter = 0; // the number of roads after road merge
      //Road marge works as follows
      //1. Take a road from the input list, add it to the merged road list, and remove it from the input list
      //2. If any road in the input list is neighbouring to the road in the merged road list, then add it to the merged road list and remove it from the input list
      //3. Once it reaches the end of the input list, select the second road in the merged road list, and repeat the check with the input list
      //4. Until it reaches the end of the merged road list, repeat 2.-3.
      //5. Once it reaches the end of the merged road list, all the hits associated with the road in the merged road list are re-associated with the first road in the merged road list
      //6. As a representative, only the first road is added as a road
      //7. Select the next road in the input list, then repeat 2.-6.
      //8. Repeat until all the roda in the input list are considered
      while(!roadListXY.empty()){
          mergedRoadListXY.push_back(roadListXY[0]);
          roadListXY.erase(roadListXY.begin());
        for(size_t i = 0; i < mergedRoadListXY.size(); i++){
          for(int j = 0; j < std::ssize(roadListXY); j++){
              if(std::abs(static_cast<int>(roadListXY[j].first) - static_cast<int>(mergedRoadListXY[i].first)) < 2 && 
                 std::abs(static_cast<int>(roadListXY[j].second) - static_cast<int>(mergedRoadListXY[i].second)) < 2){
                mergedRoadListXY.push_back(roadListXY[j]);
                roadListXY.erase(roadListXY.begin() + j);
                //note: on first iteration, j=0 so j-- will produce negative number
              j--;
            }
          }
        }
        if (!mergedRoadListXY.empty()){
          ATH_MSG_DEBUG( mergedRoadListXY.size() -1 <<" roads are merged to road(" << mergedRoadListXY[0].first << "," << mergedRoadListXY[0].second << ")");
        }
    for (const auto & roadXY : mergedRoadListXY){
      unsigned x = roadXY.first;
      unsigned y = roadXY.second;
          merged_image.insert(m_image(y, x).second.begin(), m_image(y, x).second.end());
    }
        addRoad(merged_image, mergedRoadListXY[0].first, mergedRoadListXY[0].second);
        mergedRoadListXY.clear();
        merged_image.clear();
        roadCounter++;
      }
      ATH_MSG_DEBUG("There is/are " << roadCounter << " roads after road merge");
    }
  }
 
  roads.reserve(m_roads.size());
  for (FPGATrackSimRoad & r : m_roads) roads.emplace_back(std::make_shared<const FPGATrackSimRoad>(r));
    
  return StatusCode::SUCCESS;
}

getSubRegion()

virtual int FPGATrackSimHoughTransformTool::getSubRegion ( ) const

inlineoverridevirtual

Definition at line 111 of file FPGATrackSimHoughTransformTool.h.

{return m_subRegion;}

getThreshold()

unsigned FPGATrackSimHoughTransformTool::getThreshold ( ) const

inline

Definition at line 110 of file FPGATrackSimHoughTransformTool.h.

{ return m_threshold[m_threshold.size() / 2]; }

initialize()

StatusCode FPGATrackSimHoughTransformTool::initialize ( )

overridevirtual

Definition at line 32 of file FPGATrackSimHoughTransformTool.cxx.

{
 
  // Move temp variables over from properties to struct
  m_parMin.phi = m_tempMin_phi;
  m_parMin.qOverPt = m_tempMin_qOverPt;
  m_parMin.d0 = m_tempMin_d0;
  m_parMax.phi = m_tempMax_phi;
  m_parMax.qOverPt = m_tempMax_qOverPt;
  m_parMax.d0 = m_tempMax_d0;
 
 
  // Debug
  ATH_MSG_INFO("Image size: " << m_imageSize_x << " x " << m_imageSize_y);
  ATH_MSG_INFO("Convolution size: " << m_convSize_x << " x " << m_convSize_y);
  ATH_MSG_INFO("Convolution: " << to_string(const_cast<std::vector<int>&>(m_conv.value())));
  ATH_MSG_INFO("Hit Extend: " << to_string(const_cast<std::vector<unsigned>&>(m_hitExtend_x.value())));
 
  // Retrieve info
  if (m_idealGeoRoads || m_useSectors) ATH_CHECK(m_FPGATrackSimBankSvc.retrieve());
  ATH_CHECK(m_FPGATrackSimMapping.retrieve());
  m_nLayers = m_FPGATrackSimMapping->PlaneMap_1st(0)->getNLogiLayers();
 
  // Error checking
  // TODO check bounds are set correctly
  bool ok = false;
  if (!m_imageSize_x || !m_imageSize_y)
    ATH_MSG_FATAL("initialize() Image size must be greater than 0");
  else if (m_conv.size() != m_convSize_x * m_convSize_y)
    ATH_MSG_FATAL("initialize() Convolution sizes don't match");
  else if (!m_conv.empty() && (m_convSize_x % 2 == 0 || m_convSize_y % 2 == 0))
    ATH_MSG_FATAL("initialize() Convolution sizes must be odd");
  else if (m_hitExtend_x.size() % m_nLayers)
    ATH_MSG_FATAL("initialize() Hit extentsion list must have size % nLayers");
  else if (!m_combineLayers.empty() && m_combineLayers.size() != m_nLayers)
    ATH_MSG_FATAL("initialize() Combine layers list must have size = nLayers");
  else if (m_threshold.size() % 2 != 1)
    ATH_MSG_FATAL("initialize() Threshold size must be odd");
  else if (!m_binScale.empty() && m_binScale.size() != m_nLayers)
    ATH_MSG_FATAL("initialize() Bin scale list must have size = nLayers");
  else if (std::any_of(m_binScale.begin(), m_binScale.end(), [&](unsigned i){ return m_imageSize_y % i != 0; }))
    ATH_MSG_FATAL("initialize() The imagesize is not divisible by scale");
  else
    ok = true;
  if (!ok) return StatusCode::FAILURE;
 
  // Warnings / corrections
  if (m_localMaxWindowSize && !m_traceHits)
    {
      ATH_MSG_WARNING("initialize() localMaxWindowSize requires tracing hits, turning on automatically");
      m_traceHits = true;
    }
  if (m_idealGeoRoads)
    {
      if (m_useSectors)
        {
      ATH_MSG_WARNING("initialize() idealGeoRoads conflicts with useSectors, switching off FPGATrackSim sector matching");
      m_useSectors = false;
        }
      if (!m_traceHits)
        {
      ATH_MSG_WARNING("initialize() idealGeoRoads requires tracing hits, turning on automatically");
      m_traceHits = true;
        }
    }
  if (m_binScale.empty()) m_binScale.value().resize(m_nLayers, 1);
         
  // Fill convenience variables
  m_step_x = (m_parMax[m_par_x] - m_parMin[m_par_x]) / m_imageSize_x;
  m_step_y = (m_parMax[m_par_y] - m_parMin[m_par_y]) / m_imageSize_y;
  for (unsigned i = 0; i <= m_imageSize_x; i++)
    m_bins_x.push_back(unquant(m_parMin[m_par_x], m_parMax[m_par_x], m_imageSize_x, i));
  for (unsigned i = 0; i <= m_imageSize_y; i++)
    m_bins_y.push_back(unquant(m_parMin[m_par_y], m_parMax[m_par_y], m_imageSize_y, i));
 
  // Initialize combine layers
  if (!m_combineLayers.empty())
    {
      m_nCombineLayers = *std::max_element(m_combineLayers.begin(), m_combineLayers.end()) + 1;
      m_combineLayer2D.resize(m_nCombineLayers);
      for (unsigned i = 0; i < m_combineLayers.size(); i++)
          m_combineLayer2D[m_combineLayers[i]].push_back(i);
    }
  else
    {
      m_nCombineLayers = m_nLayers;
      for (unsigned i = 0; i < m_nLayers; i++)
          m_combineLayer2D.push_back({ i });
    }
 
  if (m_houghType == "LowResource"){
    makeLUT(m_LUT, m_h_rfix, Form("%d-%d", m_imageSize_y.value(), m_imageSize_x.value()));
  } else if (m_houghType == "Flexible") {
    double phi0_max_bit_th = (m_parMax.phi * m_phi_coord_max * m_bitwise_phi0_conv) / (m_phi_range);
    double qApt_max_bit_th = (m_parMax.qOverPt * fpgatracksim::A * m_phi_coord_max * m_r_max_mm * m_bitwise_qApt_conv) / (m_r_max * m_phi_range);
 
    m_one_r_const_twoexp = std::pow(2, static_cast<int>(2 * std::log2(m_r_max + 1)));
    m_phi0_min_bit = (m_parMin.phi * m_phi_coord_max * m_bitwise_phi0_conv) / (m_phi_range);
    m_qApt_min_bit = (m_parMin.qOverPt * fpgatracksim::A * m_phi_coord_max * m_r_max_mm * m_bitwise_qApt_conv) / (m_r_max * m_phi_range);
    m_DBinQApt_bit_int = (qApt_max_bit_th - m_qApt_min_bit) / m_imageSize_y;
    m_DBinPhi0_bit_int = (phi0_max_bit_th - m_phi0_min_bit) / m_imageSize_x;
    double phi0_max_bit = m_phi0_min_bit + (m_imageSize_x * m_DBinPhi0_bit_int);
    double qApt_max_bit = m_qApt_min_bit + (m_imageSize_y * m_DBinQApt_bit_int);
    m_qAptBins_bit = (qApt_max_bit - m_qApt_min_bit) / m_DBinQApt_bit_int;
    m_phi0Bins_bit = (phi0_max_bit - m_phi0_min_bit) / m_DBinPhi0_bit_int;
    m_phi0_bins_first_sector = m_phi0Bins_bit / (m_phi0_sectors * m_pipes_phi0);
    m_qApt_bins_first_sector = m_qAptBins_bit / (m_pipes_qApt * m_qApt_sectors);    
    m_tot_bitwise_conv = m_bitwise_phi0_conv * m_bitwise_qApt_conv;
    m_one_r_const_twoexp_post_conv = m_bitwise_phi0_conv * m_one_r_const_twoexp;
    m_qApt_min_post_conv = (m_bitwise_phi0_conv * m_qApt_min_bit) / (m_bitwise_phi0_conv * m_DBinQApt_bit_int);
 
    double DBinQApt_clean = ((qApt_max_bit_th - m_qApt_min_bit) / m_imageSize_y) / m_bitwise_qApt_conv;
    double DBinPhi0_clean = ((phi0_max_bit_th - m_phi0_min_bit) / m_imageSize_x) / m_bitwise_phi0_conv;
    m_HT_sel = static_cast<int>(DBinPhi0_clean / DBinQApt_clean);
  }
  return StatusCode::SUCCESS;
}

lineGenLay()

std::vector< std::vector< int > > FPGATrackSimHoughTransformTool::lineGenLay ( const std::shared_ptr< const FPGATrackSimHit > & hit ) const

private

This condition is never true if (phi0_ht_sector < 0 && phi0_ht_pre >= 0 && (-1 + phi0_ht_sector >= m_bitwise_qApt_conv - m_imageSize_x)) { phi0_ht = phi0_ht_pre; }

Definition at line 466 of file FPGATrackSimHoughTransformTool.cxx.

{
    /*
    Chosen strategy: 
    The Bologna Flexible HT firmware does mathematical operations to implement the HT and utilizes only integer with variable bits range at the necessary minimum to do so.
    In the firmware some variables and flags are used to select 1)the scale factors the lead the float values to integer values and 2)the bits range of the internal variables.
    Because to lead the firmware to behave exactly as a "regular" software would have required to many work and resources on the FPGA, it has been chosen to:
        - make the firmware behave as a HT and adapt the software to the firmware to fully reproduce firmware performance;
        - change the HT software to properly behave as the firmware in some operations (as the fact that the bits range is not infinite and so on);
    Strategies to fill the accumulator:
        - 1 input bin to 1 output bin;
        - Assuming [Nx, Ny] binning accumulator is used, here the accumulator is separated into M "pipes," which each of them are[Nx/M, Ny] or [Nx, Ny/M]accumulator. In each pipe the line is drawn as described below:
        - only part of the "line" coming from a hit is drawn using the HT formula, the rest is done "shifting and replacing" the drawn line to the rest of the pipe
            - the lines drawn in the pipes start each one from a different point, following the monotonouse behavior of the line;
            - this reduce the amount of multiplication in the firmware but is not "exactly" as it would be in software, that is why it ahs been decided to keep it;
            - the accumulator in separated in "sectors" (not overlapped) alongside 1 axis. The first sector is filled with the line drawn with the HT formula, the others with the "shift and replace";
    */
 
    std::vector<int64_t> bins_x_new;
    std::vector<int64_t> bins_y_new;
    
    //Input values of the bins for the HT formula. The value is the center of the bin (in dev code the latter can be changed)  
    int64_t x_offset = m_phi0_min_bit + m_DBinPhi0_bit_int / 2;
    int64_t y_offset = m_qApt_min_bit + m_DBinQApt_bit_int / 2;
    for (unsigned i = 0; i < m_imageSize_x; i++) {
      bins_x_new.push_back(x_offset + m_DBinPhi0_bit_int * i);
    }
    for (unsigned i = 0; i < m_imageSize_y; i++) {
      bins_y_new.push_back(y_offset + m_DBinQApt_bit_int * i);
    }
 
      
    std::vector<int64_t> qApt_ht_array;
    std::vector<int64_t> phi0_ht_array;
    std::vector<int> zeros = {-1, -1};
       
    std::vector<std::vector<int>> hitLineQAPtPhi0;
    
    const unsigned bins_along_phi0_sector = m_phi0Bins_bit / m_phi0_sectors;
    const unsigned bins_along_qApt_sector = m_qAptBins_bit / m_qApt_sectors;
    
    for (unsigned i = 0; i < bins_along_phi0_sector; i++) {
        qApt_ht_array.push_back(0); 
    }
    for (unsigned i = 0; i < bins_along_qApt_sector; i++) {
        phi0_ht_array.push_back(0); 
    }
 
    int64_t phi_conv_offseted = 0;
    int64_t Delta_qApt_after_first_sector = 0;
    int64_t qApt_ht = -1;
    int64_t phi0_ht = -1;
    int64_t qApt_ht_pre = -1;
    int64_t phi0_ht_pre = -1;
    int64_t qApt_ht_sector = 0;
    int64_t phi0_ht_sector = 0;
    int64_t Delta_phi0_after_first_sector = 0;
 
    std::vector<double> d_qApt_ht_array;
    std::vector<double> d_phi0_ht_array;
 
    for (unsigned i = 0; i < bins_along_phi0_sector; i++) {
        d_qApt_ht_array.push_back(0.0); 
    }
    for (unsigned i = 0; i < bins_along_qApt_sector; i++) {
        d_phi0_ht_array.push_back(0.0); 
    }
 
   double d_phi_conv_offseted = 0.0;
   double d_qApt_ht_sector = 0.0;
   double d_phi0_ht_sector = 0.0;
   double d_one_over_r_by_const = 0.0;
   double d_phi_conv_over_DBinQApt = 0.0;
   double d_Delta_phi0_after_first_sector = 0.0;
 
    if (m_par_x == FPGATrackSimTrackPars::IPHI && m_par_y == FPGATrackSimTrackPars::IHIP) {
    double r = hit->getR();
        double phi_hit = hit->getGPhi(); // radians
        int r_bit = static_cast<int>(r * m_r_max / m_r_max_mm);
        int64_t phi_bit = phi_hit * m_phi_coord_max / m_phi_range;
        if (r_bit > m_HT_sel) { //Case for qA/Pt HT formula
            for (unsigned i = 0; i < m_imageSize_x; i++) {
                hitLineQAPtPhi0.push_back(zeros); 
            } 
            //formula first sector
                
            d_one_over_r_by_const = m_one_r_const_twoexp / r_bit;
            d_phi_conv_over_DBinQApt = phi_bit * m_tot_bitwise_conv / m_DBinQApt_bit_int;
 
        for (int pp = 0; pp < m_pipes_phi0; pp++) {//loop over pipes pipes alongside phi0 axis
                unsigned start_phi0_bins_first_sector = static_cast <unsigned>(pp * m_phi0Bins_bit / m_pipes_phi0);
                unsigned end_phi0_bins_first_sector = m_phi0_bins_first_sector + static_cast <unsigned>(pp * m_phi0Bins_bit / m_pipes_phi0);
 
                for (unsigned j = start_phi0_bins_first_sector; j < end_phi0_bins_first_sector; j++) {
                    double d_c1 = m_bitwise_qApt_conv * bins_x_new[j] / m_DBinQApt_bit_int;
                    int64_t c2 = (static_cast<int64_t>(d_c1) - static_cast<int64_t>(d_phi_conv_over_DBinQApt)) * static_cast<int64_t>(d_one_over_r_by_const) / m_one_r_const_twoexp_post_conv;
                    int64_t c3 = (static_cast<int64_t>(d_c1) - static_cast<int64_t>(d_phi_conv_over_DBinQApt)) * static_cast<int64_t>(d_one_over_r_by_const);
                    
                    double d_c2 = (d_c1 - d_phi_conv_over_DBinQApt) * d_one_over_r_by_const / m_one_r_const_twoexp_post_conv;
                    double d_c3 = (d_c1 - d_phi_conv_over_DBinQApt) * d_one_over_r_by_const;
                    double d_c4 = m_bitwise_phi0_conv * m_qApt_min_bit / (m_bitwise_phi0_conv * m_DBinQApt_bit_int);
 
                    if (static_cast<int64_t>(d_c1) <= static_cast<int64_t>(d_phi_conv_over_DBinQApt)) {
                      qApt_ht_pre = c2 - m_qApt_min_post_conv;
                    }else{
                      qApt_ht_pre = 1 + c2 - m_qApt_min_post_conv;
                    }
                    qApt_ht_sector = c3;
                    d_qApt_ht_sector = d_c3;
                    qApt_ht_array[j - start_phi0_bins_first_sector] = qApt_ht_sector;
                    d_qApt_ht_array[j - start_phi0_bins_first_sector] = d_qApt_ht_sector;
                    
                    if (static_cast<int64_t>(d_c1) <= static_cast<int64_t>(d_phi_conv_over_DBinQApt) && (d_c2 - m_qApt_min_post_conv - d_c4) >= 0) {
                        qApt_ht = qApt_ht_pre;
                    }
                    if (static_cast<int64_t>(d_c1) > static_cast<int64_t>(d_phi_conv_over_DBinQApt) && 1 + (d_c2 - m_qApt_min_post_conv - d_c4) >= 0) {
                        qApt_ht = qApt_ht_pre;
                    }
                    
                    if (qApt_ht >= 0 && qApt_ht <= m_imageSize_y -1) {
                        hitLineQAPtPhi0[j] = {static_cast<int>(qApt_ht), static_cast<int>(j)};
                    }
                    qApt_ht = -1;
                }
                if (m_phi0_sectors > 1) { //formula after first sector
                    for (int ps = 0; ps < m_phi0_sectors -1; ps++) {
                        //note: this is integer division, e.g. 3/2 = 1
                        int64_t d_c6 = (m_DBinPhi0_bit_int * ((ps + 1) * m_phi0_bins_first_sector) * m_bitwise_qApt_conv) / m_DBinQApt_bit_int;
 
                        Delta_phi0_after_first_sector = d_c6 * static_cast<int64_t>(d_one_over_r_by_const);
                        //want a double here
                        d_Delta_phi0_after_first_sector = static_cast<double>(d_c6) * d_one_over_r_by_const;
                        for (unsigned psi = start_phi0_bins_first_sector; psi < end_phi0_bins_first_sector; psi++) {
                            int64_t c7 = (qApt_ht_array[psi - start_phi0_bins_first_sector] + Delta_phi0_after_first_sector) / m_one_r_const_twoexp_post_conv;
                            
                            double d_c9 = m_bitwise_phi0_conv * m_qApt_min_bit / (m_bitwise_phi0_conv * m_DBinQApt_bit_int);
 
                            if (-qApt_ht_array[psi - start_phi0_bins_first_sector] < Delta_phi0_after_first_sector) {
                qApt_ht = 1 + c7 - m_qApt_min_post_conv;
                            }else{
                qApt_ht = 0 + c7 - m_qApt_min_post_conv;
                            }
                            
                            double d_c7 = (d_qApt_ht_array[psi - start_phi0_bins_first_sector] + d_Delta_phi0_after_first_sector) / m_one_r_const_twoexp_post_conv;
                            
                            if (qApt_ht >= 0 && qApt_ht <= m_imageSize_y -1 && (1 + d_c7 - d_c9) >= 0 && (0 + d_c7 - d_c9) >= 0 ) {
 
                hitLineQAPtPhi0[((ps + 1) * m_phi0_bins_first_sector) + psi] = {static_cast<int>(qApt_ht), static_cast<int>(((ps + 1) * m_phi0_bins_first_sector) + psi)};
                            }
                qApt_ht = -1;
                        }
                    }
                }
            }
        } else { //Case for Phi0 HT formula
            for (unsigned i = 0; i < m_imageSize_y; i++) {
                hitLineQAPtPhi0.push_back(zeros);
            }
            phi_conv_offseted = (m_bitwise_phi0_conv * phi_bit - static_cast<int64_t>(m_phi0_min_bit)) * m_bitwise_qApt_conv / m_DBinPhi0_bit_int;
            d_phi_conv_offseted = (m_bitwise_phi0_conv * phi_bit - m_phi0_min_bit) * m_bitwise_qApt_conv / m_DBinPhi0_bit_int;
 
            for (int pq = 0; pq < m_pipes_qApt; pq++) { //loop over pipes alongside qA/Pt axis 
 
                unsigned start_qApt_bins_first_sector = static_cast <unsigned>(pq * m_qAptBins_bit / m_pipes_qApt);
                unsigned end_qApt_bins_first_sector = m_qApt_bins_first_sector + static_cast <unsigned>(pq * m_qAptBins_bit / m_pipes_qApt);           
              
                for (unsigned n = start_qApt_bins_first_sector; n < end_qApt_bins_first_sector; n++) {
                  //formula for first sector
                  //note: this is integer division e.g. 3/2 = 1
                  int64_t d2 =m_bitwise_phi0_conv * bins_y_new[n] / m_DBinPhi0_bit_int;
 
                  phi0_ht_sector = phi_conv_offseted + r_bit * d2; 
                  phi0_ht_array[n - start_qApt_bins_first_sector] = phi0_ht_sector;
                  //want a double result here
                  d_phi0_ht_sector = d_phi_conv_offseted + r_bit * static_cast<double>(d2);
                  d_phi0_ht_array[n - start_qApt_bins_first_sector] = d_phi0_ht_sector;
 
                  if (phi0_ht_sector >= 0) {
                    phi0_ht_pre = phi0_ht_sector / m_bitwise_qApt_conv;
                  } else {
                    phi0_ht_pre = -1 + phi0_ht_sector / m_bitwise_qApt_conv;
                  }
                  
                  if (phi0_ht_sector >= 0 && phi0_ht_pre >= 0 && (phi0_ht_sector >= m_bitwise_qApt_conv - m_imageSize_x)) {
                      phi0_ht = phi0_ht_pre;
                  }
                  if (phi0_ht <= m_imageSize_x - 1 && phi0_ht >= 0){
                      hitLineQAPtPhi0[n] = {static_cast<int>(n), static_cast<int>(phi0_ht)};
                  }
                  phi0_ht = -1;
                }
                if (m_qApt_sectors > 1) { //formula after first sector
                    for (int ts = 0; ts < m_qApt_sectors - 1; ts++) {   
                        int64_t d3 = m_DBinQApt_bit_int * (ts + 1) * m_qApt_bins_first_sector * m_bitwise_phi0_conv / m_DBinPhi0_bit_int;
                        Delta_qApt_after_first_sector = r_bit * d3;
                        for (unsigned tsi =  start_qApt_bins_first_sector; tsi < end_qApt_bins_first_sector; tsi++) {   
                            phi0_ht = (phi0_ht_array[tsi - start_qApt_bins_first_sector] + Delta_qApt_after_first_sector) / m_bitwise_qApt_conv;
                            double d_phi0_ht = (d_phi0_ht_array[tsi - start_qApt_bins_first_sector] + Delta_qApt_after_first_sector) / m_bitwise_qApt_conv;
 
                            if (phi0_ht <= m_imageSize_x - 1 && phi0_ht >= 0 && d_phi0_ht >= 0 && phi0_ht >= m_bitwise_qApt_conv - m_imageSize_x) {
                                hitLineQAPtPhi0[((ts + 1) * m_qApt_bins_first_sector) + tsi] = {static_cast<int>((ts + 1) * m_qApt_bins_first_sector + tsi), static_cast<int>(phi0_ht)};  
                            }
                phi0_ht = -1;
                        }
                    }
                }
            } 
        }
    } else {
        ATH_MSG_ERROR("lineGenLay() not defined for the current m_par selection");
    }
 
    //return { HitLine, BinInPos };
    return  hitLineQAPtPhi0;
}

makeLUT()

void FPGATrackSimHoughTransformTool::makeLUT ( std::vector< std::vector< std::vector< LUT > > > & v_LUT, std::vector< TH1D * > & v_h, const std::string & tag = "" )

private

Definition at line 792 of file FPGATrackSimHoughTransformTool.cxx.

                                                                                                                                    {
  const std::string filepath = m_requirements.value() + "requirement-" + tag + ".root";
  TFile* fin = TFile::Open(filepath.c_str());
  ATH_MSG_INFO("open: " << tag);
  m_bitlength = 14;//FIXME length needed to represent input phi. Should be define from requirement file
  TTree* requirement = fin->Get<TTree>("requirement");
  v_LUT.resize(5);
  for(int i=0; i<5; i++){//FIXME as this target only for barrel so far, hardcoded
    v_LUT.at(i).resize(64);
    TH1D* h = (TH1D*)fin->Get(Form("in%d",i));//This is 1D hist to convert float phi to bitwise, depending on layer
    v_h.push_back(h);
  }
  int nrequirement = requirement->GetEntries();
  int in_min;
  int in_max;
  int xi;
  int yi;
  int ri;
  requirement->SetBranchAddress("input_begin", &in_min);
  requirement->SetBranchAddress("input_end", &in_max);
  requirement->SetBranchAddress("output_x", &xi);
  requirement->SetBranchAddress("output_y", &yi);
  requirement->SetBranchAddress("output_l", &ri);
  for(int i=0; i<nrequirement; i++){
    requirement->GetEntry(i);
    //process for min range
    int MSB = (in_min >> (m_bitlength -6));
    bool toBeFilled = true;
    if(!v_LUT.at(ri).at(MSB).empty()){
      for(auto& LUT_i : v_LUT.at(ri).at(MSB)){// For the sake of process speed and reproducibility of FPGA performance, LUTs are pushed to different vectors depending on their input MSB value.
        if(LUT_i.input_begin == in_min && LUT_i.input_end == in_max){
          LUT_i.output.push_back({xi, yi, ri});
          toBeFilled = false;
          break;
        }
      }
    }
    if(toBeFilled){
      LUT LUT_i;
      LUT_i.input_begin = in_min;
      LUT_i.input_end = in_max;
      LUT_i.layer = ri;
      LUT_i.output.push_back({xi, yi, ri});
      v_LUT.at(ri).at(MSB).push_back(std::move(LUT_i));
    }
    //process for max range
    int MSB2 = (in_max >> (m_bitlength -6));
    if(MSB != MSB2){
      MSB = MSB2;
      toBeFilled = true;
      if(!v_LUT.at(ri).at(MSB).empty()){
        for(auto& LUT_i : v_LUT.at(ri).at(MSB)){
          if(LUT_i.input_begin == in_min && LUT_i.input_end == in_max){
            LUT_i.output.push_back({xi, yi, ri});
            toBeFilled = false;
            break;
          }
        }
      }
      if(toBeFilled){
        LUT LUT_i;
        LUT_i.input_begin = in_min;
        LUT_i.input_end = in_max;
        LUT_i.layer = ri;
        LUT_i.output.push_back({xi, yi, ri});
        v_LUT.at(ri).at(MSB).push_back(std::move(LUT_i));
      }
    }
  }
  int LUTsize = v_LUT.size();
  for(int layer = 0; layer < LUTsize; layer++){
    for(int msb = 0; msb < 64; msb++){
      ATH_MSG_DEBUG("LUT size L(" << layer << ") msb(" << msb << "): " << v_LUT.at(layer).at(msb).size());
    }
  }
}

passThreshold()

bool FPGATrackSimHoughTransformTool::passThreshold ( Image const & image, unsigned x, unsigned y ) const

private

Definition at line 386 of file FPGATrackSimHoughTransformTool.cxx.

{
  // Pass window threshold
  unsigned width = m_threshold.size() / 2;
  if (x < width || (image.size(1) - x) < width) return false;
  for (unsigned i = 0; i < m_threshold.size(); i++) {
    if (image(y, x - width + i).first < m_threshold[i]) return false;
  }
  
  // Pass local-maximum check
  if (m_localMaxWindowSize) {
    for (int j = -m_localMaxWindowSize; j <= m_localMaxWindowSize; j++) {
      for (int i = -m_localMaxWindowSize; i <= m_localMaxWindowSize; i++) {
        if (i == 0 && j == 0) continue;
          if (y + j < image.size(0) && x + i < image.size(1)) {
            if (image(y+j, x+i).first > image(y, x).first) return false;
            if (image(y+j, x+i).first == image(y, x).first) {
              if (image(y+j, x+i).second.size() > image(y, x).second.size()) return false;
              if (image(y+j, x+i).second.size() == image(y, x).second.size() && j <= 0 && i <= 0) return false; // favor bottom-left (low phi, low neg q/pt)
            }
          }
      }
    }
  }
  return true;
}

yToX()

double FPGATrackSimHoughTransformTool::yToX	(	double	y,
		const std::shared_ptr< const FPGATrackSimHit > &	hit ) const

Definition at line 443 of file FPGATrackSimHoughTransformTool.cxx.

{
  double x = 0;
 
  if (m_par_x == FPGATrackSimTrackPars::IPHI && m_par_y == FPGATrackSimTrackPars::IHIP)
    {
      double r = hit->getR(); // mm
      double phi_hit = hit->getGPhi(); // radians
      double d0 = std::isnan(m_parMin.d0) ? 0 : m_parMin.d0; // mm, assume min = max
      x = asin(r * fpgatracksim::A * y - d0 / r) + phi_hit;
 
      if (m_fieldCorrection) x += fieldCorrection(m_EvtSel->getRegionID(), y, r);
    }
  else
    {
      ATH_MSG_ERROR("yToX() not defined for the current m_par selection");
    }
 
  return x;
}

yToXBins()

std::pair< unsigned, unsigned > FPGATrackSimHoughTransformTool::yToXBins ( size_t yBin_min, size_t yBin_max, const std::shared_ptr< const FPGATrackSimHit > & hit ) const

private

Definition at line 689 of file FPGATrackSimHoughTransformTool.cxx.

{
  // Get float values
  double x_min = yToX(m_bins_y[yBin_min], hit);
  double x_max = yToX(m_bins_y[yBin_max], hit);
  if (x_min > x_max) std::swap(x_min, x_max);
  if (x_max < m_parMin[m_par_x] || x_min > m_parMax[m_par_x])
    return { 0, 0 }; // out of bounds
 
  // Get bins
  int x_bin_min = quant(m_parMin[m_par_x], m_parMax[m_par_x], m_imageSize_x, x_min);
  int x_bin_max = quant(m_parMin[m_par_x], m_parMax[m_par_x], m_imageSize_x, x_max) + 1; // exclusive
 
  // Extend bins
  unsigned extend = getExtension(yBin_min, hit->getLayer());
  x_bin_min -= extend;
  x_bin_max += extend;
 
  // Clamp bins
  if (x_bin_min < 0) x_bin_min = 0;
  if (x_bin_max > static_cast<int>(m_imageSize_x)) x_bin_max = m_imageSize_x;
 
  return { x_bin_min, x_bin_max };
}

Member Data Documentation

m_bins_x

std::vector<double> FPGATrackSimHoughTransformTool::m_bins_x

private

Definition at line 209 of file FPGATrackSimHoughTransformTool.h.

m_bins_y

std::vector<double> FPGATrackSimHoughTransformTool::m_bins_y

private

Definition at line 210 of file FPGATrackSimHoughTransformTool.h.

m_binScale

Gaudi::Property<std::vector<unsigned> > FPGATrackSimHoughTransformTool::m_binScale { this, "scale", {}, "Vector containing the scales for each layers"}

private

Definition at line 171 of file FPGATrackSimHoughTransformTool.h.

{ this, "scale", {}, "Vector containing the scales for each layers"};

m_bitlength

int FPGATrackSimHoughTransformTool::m_bitlength = 16

Definition at line 138 of file FPGATrackSimHoughTransformTool.h.

m_bitwise_phi0_conv

Gaudi::Property<int> FPGATrackSimHoughTransformTool::m_bitwise_phi0_conv { this, "bitwise_phi0_conv", 1, "exponential of 2 to multiply with phi0 in case the latter in < 1"}

private

Definition at line 193 of file FPGATrackSimHoughTransformTool.h.

{ this, "bitwise_phi0_conv", 1, "exponential of 2 to multiply with phi0 in case the latter in < 1"};    

m_bitwise_qApt_conv

Gaudi::Property<int> FPGATrackSimHoughTransformTool::m_bitwise_qApt_conv { this, "bitwise_qApt_conv", 16384, "exponential of 2 to multiply with qA/pt in case the latter in < 1"}

private

Definition at line 192 of file FPGATrackSimHoughTransformTool.h.

{ this, "bitwise_qApt_conv", 16384, "exponential of 2 to multiply with qA/pt in case the latter in < 1"};

m_combineLayer2D

std::vector<std::vector<unsigned> > FPGATrackSimHoughTransformTool::m_combineLayer2D

private

Definition at line 199 of file FPGATrackSimHoughTransformTool.h.

m_combineLayers

Gaudi::Property<std::vector<unsigned> > FPGATrackSimHoughTransformTool::m_combineLayers { this, "combine_layers", {}, ""}

private

Definition at line 170 of file FPGATrackSimHoughTransformTool.h.

{ this, "combine_layers", {}, ""};

m_conv

Gaudi::Property<std::vector<int> > FPGATrackSimHoughTransformTool::m_conv { this, "convolution", {}, "Convolution filter, with size m_convSize_y * m_convSize_x"}

private

Definition at line 169 of file FPGATrackSimHoughTransformTool.h.

{ this, "convolution", {}, "Convolution filter, with size m_convSize_y * m_convSize_x"};

m_convSize_x

Gaudi::Property<unsigned> FPGATrackSimHoughTransformTool::m_convSize_x { this, "convSize_x", 0, ""}

private

Definition at line 172 of file FPGATrackSimHoughTransformTool.h.

{ this, "convSize_x", 0, ""};

m_convSize_y

Gaudi::Property<unsigned> FPGATrackSimHoughTransformTool::m_convSize_y { this, "convSize_y", 0, ""}

private

Definition at line 173 of file FPGATrackSimHoughTransformTool.h.

{ this, "convSize_y", 0, ""};

m_DBinPhi0_bit_int

long int FPGATrackSimHoughTransformTool::m_DBinPhi0_bit_int = 0

private

Definition at line 221 of file FPGATrackSimHoughTransformTool.h.

m_DBinQApt_bit_int

long int FPGATrackSimHoughTransformTool::m_DBinQApt_bit_int = 0

private

Definition at line 220 of file FPGATrackSimHoughTransformTool.h.

m_doEtaPatternConsts

Gaudi::Property<bool> FPGATrackSimHoughTransformTool::m_doEtaPatternConsts { this, "doEtaPatternConsts", false, "Whether to use the eta pattern tool for constant generation"}

private

Definition at line 181 of file FPGATrackSimHoughTransformTool.h.

{ this, "doEtaPatternConsts", false, "Whether to use the eta pattern tool for constant generation"};

m_doRegionalMapping

Gaudi::Property<bool> FPGATrackSimHoughTransformTool::m_doRegionalMapping { this, "RegionalMapping", false, "Use the sub-region maps to define the sector"}

private

Definition at line 180 of file FPGATrackSimHoughTransformTool.h.

{ this, "RegionalMapping", false,  "Use the sub-region maps to define the sector"};

m_EvtSel

ServiceHandle<IFPGATrackSimEventSelectionSvc> FPGATrackSimHoughTransformTool::m_EvtSel {this, "FPGATrackSimEventSelectionSvc", ""}

private

Definition at line 145 of file FPGATrackSimHoughTransformTool.h.

{this, "FPGATrackSimEventSelectionSvc", ""};

m_fieldCorrection

Gaudi::Property<bool> FPGATrackSimHoughTransformTool::m_fieldCorrection { this, "fieldCorrection", true, "Apply corrections to hough equation due to field nonuniformity"}

private

Definition at line 177 of file FPGATrackSimHoughTransformTool.h.

{ this, "fieldCorrection", true, "Apply corrections to hough equation due to field nonuniformity"};

m_FPGATrackSimBankSvc

ServiceHandle<IFPGATrackSimBankSvc> FPGATrackSimHoughTransformTool::m_FPGATrackSimBankSvc {this, "FPGATrackSimBankSvc", "FPGATrackSimBankSvc"}

private

Definition at line 146 of file FPGATrackSimHoughTransformTool.h.

{this, "FPGATrackSimBankSvc", "FPGATrackSimBankSvc"};

m_FPGATrackSimMapping

ServiceHandle<IFPGATrackSimMappingSvc> FPGATrackSimHoughTransformTool::m_FPGATrackSimMapping {this, "FPGATrackSimMappingSvc", "FPGATrackSimMappingSvc"}

private

Definition at line 147 of file FPGATrackSimHoughTransformTool.h.

{this, "FPGATrackSimMappingSvc", "FPGATrackSimMappingSvc"};

m_h_rfix

std::vector<TH1D*> FPGATrackSimHoughTransformTool::m_h_rfix

private

Definition at line 260 of file FPGATrackSimHoughTransformTool.h.

m_hitExtend_x

Gaudi::Property<std::vector<unsigned> > FPGATrackSimHoughTransformTool::m_hitExtend_x { this, "hitExtend_x", {}, "Hit lines will fill extra bins in x by this amount on each side, size == nLayers"}

private

Definition at line 174 of file FPGATrackSimHoughTransformTool.h.

{ this, "hitExtend_x", {}, "Hit lines will fill extra bins in x by this amount on each side, size == nLayers"};

m_houghType

Gaudi::Property<std::string> FPGATrackSimHoughTransformTool::m_houghType { this, "houghType", "Original", "Switch Hough strategy. Original: close to mathematical HT, LowResource: emulate pre calculated LUTs base FPGA performance, Flexible: emulate culculation on FPGA performance"}

private

Definition at line 183 of file FPGATrackSimHoughTransformTool.h.

{ this, "houghType", "Original", "Switch Hough strategy. Original: close to mathematical HT, LowResource: emulate pre calculated LUTs base FPGA performance, Flexible: emulate culculation on FPGA performance"};

m_HT_sel

int FPGATrackSimHoughTransformTool::m_HT_sel = 0

private

Definition at line 216 of file FPGATrackSimHoughTransformTool.h.

m_idealGeoRoads

Gaudi::Property<bool> FPGATrackSimHoughTransformTool::m_idealGeoRoads { this, "IdealGeoRoads", true, "Set sectors to use ideal geometry fit constants"}

private

Definition at line 179 of file FPGATrackSimHoughTransformTool.h.

{ this, "IdealGeoRoads", true, "Set sectors to use ideal geometry fit constants"};

m_image

Image FPGATrackSimHoughTransformTool::m_image

private

Definition at line 233 of file FPGATrackSimHoughTransformTool.h.

m_imageSize_x

Gaudi::Property<unsigned> FPGATrackSimHoughTransformTool::m_imageSize_x { this, "nBins_x", 0, ""}

private

Definition at line 167 of file FPGATrackSimHoughTransformTool.h.

{ this, "nBins_x", 0, ""};

m_imageSize_y

Gaudi::Property<unsigned> FPGATrackSimHoughTransformTool::m_imageSize_y { this, "nBins_y", 0, ""}

private

Definition at line 168 of file FPGATrackSimHoughTransformTool.h.

{ this, "nBins_y", 0, ""};

m_localMaxWindowSize

Gaudi::Property<bool> FPGATrackSimHoughTransformTool::m_localMaxWindowSize { this, "localMaxWindowSize", 0, "Only create roads that are a local maximum within this window size. Set this to 0 to turn off local max filtering"}

private

Definition at line 176 of file FPGATrackSimHoughTransformTool.h.

{ this, "localMaxWindowSize", 0, "Only create roads that are a local maximum within this window size. Set this to 0 to turn off local max filtering"};

m_LUT

std::vector<std::vector<std::vector<LUT> > > FPGATrackSimHoughTransformTool::m_LUT

private

Definition at line 259 of file FPGATrackSimHoughTransformTool.h.

m_nCombineLayers

unsigned FPGATrackSimHoughTransformTool::m_nCombineLayers = 0U

private

Definition at line 205 of file FPGATrackSimHoughTransformTool.h.

m_nLayers

unsigned FPGATrackSimHoughTransformTool::m_nLayers = 0U

private

Definition at line 204 of file FPGATrackSimHoughTransformTool.h.

m_one_r_const_twoexp

long int FPGATrackSimHoughTransformTool::m_one_r_const_twoexp = 0

private

Definition at line 217 of file FPGATrackSimHoughTransformTool.h.

m_one_r_const_twoexp_post_conv

long int FPGATrackSimHoughTransformTool::m_one_r_const_twoexp_post_conv = 0

private

Definition at line 227 of file FPGATrackSimHoughTransformTool.h.

m_par_x

FPGATrackSimTrackPars::pars_index FPGATrackSimHoughTransformTool::m_par_x = FPGATrackSimTrackPars::IPHI

private

Definition at line 156 of file FPGATrackSimHoughTransformTool.h.

m_par_y

FPGATrackSimTrackPars::pars_index FPGATrackSimHoughTransformTool::m_par_y = FPGATrackSimTrackPars::IHIP

private

Definition at line 157 of file FPGATrackSimHoughTransformTool.h.

m_parMax

FPGATrackSimTrackPars FPGATrackSimHoughTransformTool::m_parMax

private

Definition at line 154 of file FPGATrackSimHoughTransformTool.h.

m_parMin

FPGATrackSimTrackPars FPGATrackSimHoughTransformTool::m_parMin

private

Definition at line 153 of file FPGATrackSimHoughTransformTool.h.

m_phi0_bins_first_sector

long int FPGATrackSimHoughTransformTool::m_phi0_bins_first_sector = 0

private

Definition at line 224 of file FPGATrackSimHoughTransformTool.h.

m_phi0_min_bit

double FPGATrackSimHoughTransformTool::m_phi0_min_bit = 0

private

Definition at line 218 of file FPGATrackSimHoughTransformTool.h.

m_phi0_sectors

Gaudi::Property<int> FPGATrackSimHoughTransformTool::m_phi0_sectors { this, "phi0_sectors", 1,"firmware method to draw monotonic lines. separation alongside phi0"}

private

Definition at line 194 of file FPGATrackSimHoughTransformTool.h.

{ this, "phi0_sectors", 1,"firmware method to draw monotonic lines. separation alongside phi0"};

m_phi0Bins_bit

long int FPGATrackSimHoughTransformTool::m_phi0Bins_bit = 0

private

Definition at line 223 of file FPGATrackSimHoughTransformTool.h.

m_phi_coord_max

Gaudi::Property<int> FPGATrackSimHoughTransformTool::m_phi_coord_max { this, "phi_coord_max", 65535," - maximum - phi"}

private

Definition at line 189 of file FPGATrackSimHoughTransformTool.h.

{ this, "phi_coord_max", 65535," - maximum - phi"};

m_phi_range

Gaudi::Property<double> FPGATrackSimHoughTransformTool::m_phi_range { this, "phi_range", 6.399609375,"range of phi in rad, customized ofr the algo"}

private

Definition at line 190 of file FPGATrackSimHoughTransformTool.h.

{ this, "phi_range", 6.399609375,"range of phi in rad, customized ofr the algo"}; 

m_pipes_phi0

Gaudi::Property<int> FPGATrackSimHoughTransformTool::m_pipes_phi0 { this, "pipes_phi0", 1," !!!!!!MAX 32 !!!!!!clock domains separation alongside phi0 bins"}

private

Definition at line 197 of file FPGATrackSimHoughTransformTool.h.

{ this, "pipes_phi0", 1," !!!!!!MAX 32 !!!!!!clock domains separation alongside phi0  bins"};    

m_pipes_qApt

Gaudi::Property<int> FPGATrackSimHoughTransformTool::m_pipes_qApt { this, "pipes_qApt", 8,"!!!!!!MAX 32 !!!!!!clock domains separation alongside qA/pt bins"}

private

Definition at line 196 of file FPGATrackSimHoughTransformTool.h.

{ this, "pipes_qApt", 8,"!!!!!!MAX 32 !!!!!!clock domains separation alongside qA/pt bins"};

m_qApt_bins_first_sector

long int FPGATrackSimHoughTransformTool::m_qApt_bins_first_sector = 0

private

Definition at line 225 of file FPGATrackSimHoughTransformTool.h.

m_qApt_min_bit

double FPGATrackSimHoughTransformTool::m_qApt_min_bit = 0

private

Definition at line 219 of file FPGATrackSimHoughTransformTool.h.

m_qApt_min_post_conv

long int FPGATrackSimHoughTransformTool::m_qApt_min_post_conv = 0

private

Definition at line 228 of file FPGATrackSimHoughTransformTool.h.

m_qApt_sectors

Gaudi::Property<int> FPGATrackSimHoughTransformTool::m_qApt_sectors { this, "qApt_sectors", 7,"firmware method to draw monotonic lines. separation alongside qA/pt"}

private

Definition at line 195 of file FPGATrackSimHoughTransformTool.h.

{ this, "qApt_sectors", 7,"firmware method to draw monotonic lines. separation alongside qA/pt"};

m_qAptBins_bit

long int FPGATrackSimHoughTransformTool::m_qAptBins_bit = 0

private

Definition at line 222 of file FPGATrackSimHoughTransformTool.h.

m_r_max

Gaudi::Property<int> FPGATrackSimHoughTransformTool::m_r_max { this, "r_max", 2047," - maximum -"}

private

Definition at line 188 of file FPGATrackSimHoughTransformTool.h.

{ this, "r_max", 2047," - maximum -"};   

m_r_max_mm

Gaudi::Property<double> FPGATrackSimHoughTransformTool::m_r_max_mm { this, "r_max_mm", 1137.5,"r value maximum used in the mm-to-bits conversion"}

private

Definition at line 191 of file FPGATrackSimHoughTransformTool.h.

{ this, "r_max_mm", 1137.5,"r value maximum used in the mm-to-bits conversion"};        

m_requirements

Gaudi::Property<std::string> FPGATrackSimHoughTransformTool::m_requirements { this, "requirements", "", "path of the requirements file"}

private

Definition at line 185 of file FPGATrackSimHoughTransformTool.h.

{ this, "requirements", "", "path of the requirements file"};

m_roadMerge

Gaudi::Property<bool> FPGATrackSimHoughTransformTool::m_roadMerge { this, "roadMerge", false}

private

Definition at line 184 of file FPGATrackSimHoughTransformTool.h.

{ this, "roadMerge", false};

m_roads

std::vector<FPGATrackSimRoad> FPGATrackSimHoughTransformTool::m_roads

private

Definition at line 234 of file FPGATrackSimHoughTransformTool.h.

m_step_x

double FPGATrackSimHoughTransformTool::m_step_x = 0

private

Definition at line 207 of file FPGATrackSimHoughTransformTool.h.

m_step_y

double FPGATrackSimHoughTransformTool::m_step_y = 0

private

Definition at line 208 of file FPGATrackSimHoughTransformTool.h.

m_subRegion

Gaudi::Property<int> FPGATrackSimHoughTransformTool::m_subRegion { this, "subRegion", 0," -1 for entire region (no slicing)"}

private

Definition at line 159 of file FPGATrackSimHoughTransformTool.h.

{ this, "subRegion", 0," -1 for entire region (no slicing)"};

m_tempMax_d0

Gaudi::Property<float> FPGATrackSimHoughTransformTool::m_tempMax_d0 { this, "d0_max", 0, "max q/pt"}

private

Definition at line 165 of file FPGATrackSimHoughTransformTool.h.

{ this, "d0_max", 0, "max q/pt"};

m_tempMax_phi

Gaudi::Property<float> FPGATrackSimHoughTransformTool::m_tempMax_phi { this, "phi_max", 0, "max phi"}

private

Definition at line 161 of file FPGATrackSimHoughTransformTool.h.

{ this, "phi_max", 0, "max phi"};

m_tempMax_qOverPt

Gaudi::Property<float> FPGATrackSimHoughTransformTool::m_tempMax_qOverPt { this, "qpT_max", 0, "max q/pt"}

private

Definition at line 163 of file FPGATrackSimHoughTransformTool.h.

{ this, "qpT_max", 0, "max q/pt"};

m_tempMin_d0

Gaudi::Property<float> FPGATrackSimHoughTransformTool::m_tempMin_d0 { this, "d0_min", 0, "min q/pt"}

private

Definition at line 164 of file FPGATrackSimHoughTransformTool.h.

{ this, "d0_min", 0, "min q/pt"};

m_tempMin_phi

Gaudi::Property<float> FPGATrackSimHoughTransformTool::m_tempMin_phi { this, "phi_min", 0, "min phi"}

private

Definition at line 160 of file FPGATrackSimHoughTransformTool.h.

{ this, "phi_min", 0, "min phi"};

m_tempMin_qOverPt

Gaudi::Property<float> FPGATrackSimHoughTransformTool::m_tempMin_qOverPt { this, "qpT_min", 0, "min q/pt"}

private

Definition at line 162 of file FPGATrackSimHoughTransformTool.h.

{ this, "qpT_min", 0, "min q/pt"};

m_threshold

Gaudi::Property<std::vector<int> > FPGATrackSimHoughTransformTool::m_threshold { this, "threshold", {},"Minimum number of hit layers to fire a road"}

private

Definition at line 166 of file FPGATrackSimHoughTransformTool.h.

{ this, "threshold", {},"Minimum number of hit layers to fire a road"};

m_tot_bitwise_conv

long int FPGATrackSimHoughTransformTool::m_tot_bitwise_conv = 0

private

Definition at line 226 of file FPGATrackSimHoughTransformTool.h.

m_traceHits

Gaudi::Property<bool> FPGATrackSimHoughTransformTool::m_traceHits { this, "traceHits", true, "Trace each hit that goes in a bin. Disabling this will save memory/time since each bin doesn't have to store all its hits but the roads created won't have hits from convolution, etc."}

private

Definition at line 175 of file FPGATrackSimHoughTransformTool.h.

{ this, "traceHits", true, "Trace each hit that goes in a bin. Disabling this will save memory/time since each bin doesn't have to store all its hits but the roads created won't have hits from convolution, etc."};

m_useSectors

Gaudi::Property<bool> FPGATrackSimHoughTransformTool::m_useSectors { this, "useSectors", false, "Will reverse calculate the sector for track-fitting purposes"}

private

Definition at line 178 of file FPGATrackSimHoughTransformTool.h.

{ this, "useSectors", false, "Will reverse calculate the sector for track-fitting purposes"};

m_useSpacePoints

Gaudi::Property<bool> FPGATrackSimHoughTransformTool::m_useSpacePoints { this, "useSpacePoints", false, "Whether we are using spacepoints."}

private

Definition at line 182 of file FPGATrackSimHoughTransformTool.h.

{ this, "useSpacePoints", false, "Whether we are using spacepoints."};

---

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

• FPGATrackSimHoughTransformTool.h
• FPGATrackSimHoughTransformTool.cxx