#include <FPGATrackSimHoughTransformTool.h>

Inheritance diagram for FPGATrackSimHoughTransformTool:

Collaboration diagram for FPGATrackSimHoughTransformTool:

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

Public Member Functions
	FPGATrackSimHoughTransformTool (const std::string &, const std::string &, const IInterface *)

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

int	getSubRegion () const

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

Image const &	getImage () const

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

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	matchIdealGeoSector (FPGATrackSimRoad &r) 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)

Private Attributes
ServiceHandle< IFPGATrackSimEventSelectionSvc >	m_EvtSel {this, "FPGATrackSimEventSelectionSvc", "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."}

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

Image	m_image

std::vector< FPGATrackSimRoad >	m_roads

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 119 of file FPGATrackSimHoughTransformTool.h.

Constructor & Destructor Documentation

◆ FPGATrackSimHoughTransformTool()

FPGATrackSimHoughTransformTool::FPGATrackSimHoughTransformTool	(	const std::string &	algname,
		const std::string &	name,
		const IInterface *	ifc
	)

Definition at line 34 of file FPGATrackSimHoughTransformTool.cxx.

                                                                                                                                      :
   base_class(algname, name, ifc)
 {
   declareInterface<IFPGATrackSimRoadFinderTool>(this);
 }

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 455 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 468 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)
     {
       if (m_subRegion >= 0 && !m_FPGATrackSimMapping->SubRegionMap()->isInRegion(m_subRegion, *hit)) continue;
  
       // 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 429 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);
  
   if (m_useSectors) r.setSector(m_FPGATrackSimBankSvc->SectorBank_1st()->findSector(hits));
   else if (m_idealGeoRoads) matchIdealGeoSector(r);
 }

◆ conv()

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

inlineprivate

Definition at line 210 of file FPGATrackSimHoughTransformTool.h.

210 { 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 221 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 202 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 162 of file FPGATrackSimHoughTransformTool.cxx.

 {
   Image image(m_imageSize_y, m_imageSize_x);
  
   for (auto const & hit : hits)
     {
       if (std::find(layers.begin(), layers.end(), hit->getLayer()) == layers.end()) continue;
  
       if (m_subRegion >= 0) {
         // NOTE: uncomment middle piece if we port over 2nd stage functionality.
         auto* subrmap = /*(m_2ndStage) ? m_FPGATrackSimMapping->SubRegionMap_2nd() :*/ m_FPGATrackSimMapping->SubRegionMap();
         if (!(subrmap->isInRegion(m_subRegion, *hit))) {
           continue;
         }
       }
  
       // 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 349 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 124 of file FPGATrackSimHoughTransformTool.h.

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

◆ getMaxX()

double FPGATrackSimHoughTransformTool::getMaxX ( ) const

inline

Definition at line 110 of file FPGATrackSimHoughTransformTool.h.

110 { return m_parMax[m_par_x]; }

◆ getMaxY()

double FPGATrackSimHoughTransformTool::getMaxY ( ) const

inline

Definition at line 112 of file FPGATrackSimHoughTransformTool.h.

112 { return m_parMax[m_par_y]; }

◆ getMinX()

double FPGATrackSimHoughTransformTool::getMinX ( ) const

inline

Definition at line 109 of file FPGATrackSimHoughTransformTool.h.

109 { return m_parMin[m_par_x]; }

◆ getMinY()

double FPGATrackSimHoughTransformTool::getMinY ( ) const

inline

Definition at line 111 of file FPGATrackSimHoughTransformTool.h.

111 { 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 139 of file FPGATrackSimHoughTransformTool.cxx.

 {
   roads.clear();
   m_roads.clear();
  
   m_image = createImage(hits);
   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)
             addRoad(m_image(y, x).second, x, y);
           else
             addRoad(hits, x, y);
         }
     
   roads.reserve(m_roads.size());
   for (FPGATrackSimRoad & r : m_roads) roads.emplace_back(std::make_shared<const FPGATrackSimRoad>(r));
     
   return StatusCode::SUCCESS;
 }

◆ getSubRegion()

int FPGATrackSimHoughTransformTool::getSubRegion ( ) const

inline

Definition at line 114 of file FPGATrackSimHoughTransformTool.h.

114 { return m_subRegion; }

◆ getThreshold()

unsigned FPGATrackSimHoughTransformTool::getThreshold ( ) const

inline

Definition at line 113 of file FPGATrackSimHoughTransformTool.h.

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

◆ initialize()

StatusCode FPGATrackSimHoughTransformTool::initialize ( )

overridevirtual

Definition at line 41 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()->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 });
     }
     
   return StatusCode::SUCCESS;
 }

◆ matchIdealGeoSector()

void FPGATrackSimHoughTransformTool::matchIdealGeoSector ( FPGATrackSimRoad & r ) const

private

Definition at line 362 of file FPGATrackSimHoughTransformTool.cxx.

 {
  
   // This logic is now identical between the 1D and 2D Hough tools. Perhaps it should
   // be moved into the sector bank class?
  
   // We now look up the binning information in the sector bank.
   const FPGATrackSimSectorBank* sectorbank = m_FPGATrackSimBankSvc->SectorBank_1st();
  
   // Look up q/pt (or |q/pt|) from the Hough road, convert to MeV.
   double qoverpt = r.getY()*0.001;
   if (sectorbank->isAbsQOverPtBinning()) {
       qoverpt = abs(qoverpt);
   }
  
   int sectorbin = 0;
  
   // Retrieve the bin boundaries from the sector bank; map this onto them.
   std::vector<double> qoverpt_bins = sectorbank->getQOverPtBins();
   auto bounds = std::equal_range(qoverpt_bins.begin(), qoverpt_bins.end(), qoverpt);
  
   sectorbin = fpgatracksim::QPT_SECTOR_OFFSET*(bounds.first - qoverpt_bins.begin() - 1);
  
   if (sectorbin < 0) sectorbin = 0;
   if ((sectorbin / 10) > static_cast<int>(qoverpt_bins.size() - 2))sectorbin = 10*(qoverpt_bins.size() - 2);
  
   if (m_doRegionalMapping){
     int subregion = r.getSubRegion();
     sectorbin += subregion*fpgatracksim::SUBREGION_SECTOR_OFFSET;
   }
   std::vector<module_t> modules;
   for (unsigned int il = 0; il < r.getNLayers(); il++) {
     if (r.getNHits_layer()[il] == 0) {
       modules.push_back(-1);
  
       layer_bitmask_t wc_layers = r.getWCLayers();
       wc_layers |= (0x1 << il);
       r.setWCLayers(wc_layers);
  
       std::shared_ptr<FPGATrackSimHit> wcHit = std::make_shared<FPGATrackSimHit>();
       wcHit->setHitType(HitType::wildcard);
       wcHit->setLayer(il);
       wcHit->setDetType(m_FPGATrackSimMapping->PlaneMap_1st()->getDetType(il));
       std::vector<std::shared_ptr<const FPGATrackSimHit>> wcHits;
       wcHits.emplace_back(std::move(wcHit));
       r.setHits(il,std::move(wcHits));
     }
     else {
       modules.push_back(sectorbin);
     }
   }
  
   // If we are using eta patterns. We need to first run the roads through the road filter.
   // Then the filter will be responsible for setting the actual sector.
   // As a hack, we can store the sector bin ID in the road for now.
   // This is fragile! If we want to store a different ID for each layer, it will break.
  
   // Similarly, we do the same thing for spacepoints. this probably means we can't combine the two.
   // maybe better to store the module array instead of just a number?
  
   r.setSectorBin(sectorbin);
   if (!m_doEtaPatternConsts && !m_useSpacePoints) {
       r.setSector(sectorbank->findSector(modules));
   }
 }

◆ passThreshold()

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

private

Definition at line 243 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 300 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 323 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 180 of file FPGATrackSimHoughTransformTool.h.

◆ m_bins_y

std::vector<double> FPGATrackSimHoughTransformTool::m_bins_y

private

Definition at line 181 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 157 of file FPGATrackSimHoughTransformTool.h.

◆ m_combineLayer2D

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

private

Definition at line 170 of file FPGATrackSimHoughTransformTool.h.

◆ m_combineLayers

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

private

Definition at line 156 of file FPGATrackSimHoughTransformTool.h.

◆ 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 155 of file FPGATrackSimHoughTransformTool.h.

◆ m_convSize_x

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

private

Definition at line 158 of file FPGATrackSimHoughTransformTool.h.

◆ m_convSize_y

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

private

Definition at line 159 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 167 of file FPGATrackSimHoughTransformTool.h.

◆ m_doRegionalMapping

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

private

Definition at line 166 of file FPGATrackSimHoughTransformTool.h.

◆ m_EvtSel

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

private

Definition at line 131 of file FPGATrackSimHoughTransformTool.h.

◆ m_fieldCorrection

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

private

Definition at line 163 of file FPGATrackSimHoughTransformTool.h.

◆ m_FPGATrackSimBankSvc

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

private

Definition at line 132 of file FPGATrackSimHoughTransformTool.h.

◆ m_FPGATrackSimMapping

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

private

Definition at line 133 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 160 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 165 of file FPGATrackSimHoughTransformTool.h.

◆ m_image

Image FPGATrackSimHoughTransformTool::m_image

private

Definition at line 188 of file FPGATrackSimHoughTransformTool.h.

◆ m_imageSize_x

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

private

Definition at line 153 of file FPGATrackSimHoughTransformTool.h.

◆ m_imageSize_y

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

private

Definition at line 154 of file FPGATrackSimHoughTransformTool.h.

◆ 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 162 of file FPGATrackSimHoughTransformTool.h.

◆ m_nCombineLayers

unsigned FPGATrackSimHoughTransformTool::m_nCombineLayers = 0U

private

Definition at line 176 of file FPGATrackSimHoughTransformTool.h.

◆ m_nLayers

unsigned FPGATrackSimHoughTransformTool::m_nLayers = 0U

private

Definition at line 175 of file FPGATrackSimHoughTransformTool.h.

◆ m_par_x

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

private

Definition at line 142 of file FPGATrackSimHoughTransformTool.h.

◆ m_par_y

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

private

Definition at line 143 of file FPGATrackSimHoughTransformTool.h.

◆ m_parMax

FPGATrackSimTrackPars FPGATrackSimHoughTransformTool::m_parMax

private

Definition at line 140 of file FPGATrackSimHoughTransformTool.h.

◆ m_parMin

FPGATrackSimTrackPars FPGATrackSimHoughTransformTool::m_parMin

private

Definition at line 139 of file FPGATrackSimHoughTransformTool.h.

◆ m_roads

std::vector<FPGATrackSimRoad> FPGATrackSimHoughTransformTool::m_roads

private

Definition at line 189 of file FPGATrackSimHoughTransformTool.h.

◆ m_step_x

double FPGATrackSimHoughTransformTool::m_step_x = 0

private

Definition at line 178 of file FPGATrackSimHoughTransformTool.h.

◆ m_step_y

double FPGATrackSimHoughTransformTool::m_step_y = 0

private

Definition at line 179 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 145 of file FPGATrackSimHoughTransformTool.h.

◆ m_tempMax_d0

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

private

Definition at line 151 of file FPGATrackSimHoughTransformTool.h.

◆ m_tempMax_phi

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

private

Definition at line 147 of file FPGATrackSimHoughTransformTool.h.

◆ m_tempMax_qOverPt

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

private

Definition at line 149 of file FPGATrackSimHoughTransformTool.h.

◆ m_tempMin_d0

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

private

Definition at line 150 of file FPGATrackSimHoughTransformTool.h.

◆ m_tempMin_phi

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

private

Definition at line 146 of file FPGATrackSimHoughTransformTool.h.

◆ m_tempMin_qOverPt

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

private

Definition at line 148 of file FPGATrackSimHoughTransformTool.h.

◆ 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 152 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 161 of file FPGATrackSimHoughTransformTool.h.

◆ m_useSectors

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

private

Definition at line 164 of file FPGATrackSimHoughTransformTool.h.

◆ m_useSpacePoints

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

private

Definition at line 168 of file FPGATrackSimHoughTransformTool.h.

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

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ Image

Constructor & Destructor Documentation

◆ FPGATrackSimHoughTransformTool()

Member Function Documentation

◆ addRoad() [1/3]

◆ addRoad() [2/3]

◆ addRoad() [3/3]

◆ conv()

◆ convolute()

◆ createImage()

◆ createLayerImage()

◆ drawImage()

◆ getExtension()

◆ getImage()

◆ getMaxX()

◆ getMaxY()

◆ getMinX()

◆ getMinY()

◆ getRoads()

◆ getSubRegion()

◆ getThreshold()

◆ initialize()

◆ matchIdealGeoSector()

◆ passThreshold()

◆ yToX()

◆ yToXBins()

Member Data Documentation

◆ m_bins_x

◆ m_bins_y

◆ m_binScale

◆ m_combineLayer2D

◆ m_combineLayers

◆ m_conv

◆ m_convSize_x

◆ m_convSize_y

◆ m_doEtaPatternConsts

◆ m_doRegionalMapping

◆ m_EvtSel

◆ m_fieldCorrection

◆ m_FPGATrackSimBankSvc

◆ m_FPGATrackSimMapping

◆ m_hitExtend_x

◆ m_idealGeoRoads

◆ m_image

◆ m_imageSize_x

◆ m_imageSize_y

◆ m_localMaxWindowSize

◆ m_nCombineLayers

◆ m_nLayers

◆ m_par_x

◆ m_par_y

◆ m_parMax

◆ m_parMin

◆ m_roads

◆ m_step_x

◆ m_step_y

◆ m_subRegion

◆ m_tempMax_d0

◆ m_tempMax_phi

◆ m_tempMax_qOverPt

◆ m_tempMin_d0

◆ m_tempMin_phi

◆ m_tempMin_qOverPt

◆ m_threshold

◆ m_traceHits

◆ m_useSectors

◆ m_useSpacePoints