#include <FPGATrackSimHoughTransform_d0phi0_Tool.h>

Inheritance diagram for FPGATrackSimHoughTransform_d0phi0_Tool:

Collaboration diagram for FPGATrackSimHoughTransform_d0phi0_Tool:

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

virtual StatusCode	initialize () override

virtual StatusCode	finalize () override

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

virtual int	getSubRegion () const override

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

Private Member Functions
Image	createLayerImage (std::vector< int > 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

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

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

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

void	matchIdealGeoSector (FPGATrackSimRoad &r) const

FPGATrackSimRoad	createRoad (const std::unordered_set< std::shared_ptr< const FPGATrackSimHit >> &hits, unsigned x, unsigned y) const

FPGATrackSimRoad	createRoad (std::vector< std::vector< std::shared_ptr< const FPGATrackSimHit >>> &&hits, layer_bitmask_t hitLayers, unsigned x, unsigned y) const

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< IFPGATrackSimBankSvc >	m_FPGATrackSimBankSvc {this, "FPGATrackSimBankSvc", "FPGATrackSimBankSvc"}

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

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", 1, "max phi"}

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

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

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

Gaudi::Property< unsigned int >	m_imageSize_x { this, "nBins_x", 1, ""}

Gaudi::Property< unsigned int >	m_imageSize_y { this, "nBins_y", 1, ""}

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

Gaudi::Property< std::vector< unsigned int > >	m_combineLayers { this, "combine_layers", {0,1,2,3,4,5,6,7}, ""}

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

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

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

Gaudi::Property< std::vector< unsigned int > >	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_stereo { this, "stereo", false, "Combine stereo layers"}

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_useSectors { this, "useSectors", false, "Will reverse calculate the sector for track-fitting purposes"}

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

FPGATrackSimTrackPars::pars_index	m_par_x = FPGATrackSimTrackPars::IPHI

FPGATrackSimTrackPars::pars_index	m_par_y = FPGATrackSimTrackPars::ID0

FPGATrackSimTrackPars	m_parMin

FPGATrackSimTrackPars	m_parMax

unsigned	m_nCombineLayers = 0U

std::vector< std::vector< int > >	m_combineLayer2D

unsigned	m_nLayers = 0U

double	m_step_x = 0

double	m_step_y = 0

std::vector< double >	m_bins_x

std::vector< double >	m_bins_y

std::unordered_map< int, std::vector< size_t > >	m_yBins_scaled

std::vector< FPGATrackSimRoad >	m_roads

int	m_event = 0

std::string	m_name

TFile	m_monitorFile

Detailed Description

Definition at line 37 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

Member Typedef Documentation

◆ Image

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

private

Definition at line 109 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

Constructor & Destructor Documentation

◆ FPGATrackSimHoughTransform_d0phi0_Tool()

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

Definition at line 37 of file FPGATrackSimHoughTransform_d0phi0_Tool.cxx.

                                                                                                                                                      :
   base_class(algname, name, ifc),
   m_name(instance_name(name)),
   m_monitorFile((m_name + ".root").c_str(), "RECREATE")
 {
 }

Member Function Documentation

◆ addRoad() [1/2]

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

private

Definition at line 453 of file FPGATrackSimHoughTransform_d0phi0_Tool.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
   m_roads.push_back(createRoad(std::move(sorted_hits), hitLayers, x, y));
 }

◆ addRoad() [2/2]

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

private

Definition at line 466 of file FPGATrackSimHoughTransform_d0phi0_Tool.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;
  
     // get bin scaling for the hit
     unsigned bin_scale = 0;
     for (unsigned i = 0; i < m_nCombineLayers; i++) {
       for (int const layer : m_combineLayer2D[i]) {
     if (hit->getLayer() == layer) {
       bin_scale = m_binScale[layer];
     }
       }
     }
     if (bin_scale == 0) bin_scale = 1; //avoid divide by zero,use 1:1 scale
     unsigned y_bin_min = floor(1.0 * y / bin_scale) * bin_scale;
     unsigned y_bin_max = ceil(1.0 * y / bin_scale) * bin_scale;
     if (y_bin_min == y_bin_max) y_bin_max++;
  
     // Find the min/max x bins
     auto xBins = yToXBins(y_bin_min, y_bin_max, hit);
     
     if (x >= xBins.first && x < xBins.second && y >= y_bin_min && y < y_bin_max) {
       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
  
   m_roads.push_back(createRoad(std::move(sorted_hits), hitLayers, x, y));
 }

◆ conv()

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

inlineprivate

Definition at line 147 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

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

◆ convolute()

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

private

Definition at line 246 of file FPGATrackSimHoughTransform_d0phi0_Tool.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
     int y = -static_cast<int>(m_convSize_y) / 2 + r + y0; // Indices of input
     for (unsigned c = 0; c < m_convSize_x; c++) {
       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()

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

private

Definition at line 226 of file FPGATrackSimHoughTransform_d0phi0_Tool.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]);
     if (i > 1 && i % 2 == 0 && m_stereo) ++i; // not sure how to deal with this for Combine Layer setting
     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()

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

private

Definition at line 178 of file FPGATrackSimHoughTransform_d0phi0_Tool.cxx.

 {
  
   Image image(m_imageSize_y, m_imageSize_x);
  
   for (auto const & hit : hits) {
  
     bool belong1 = false, belong2 = false;
     for (auto layer : combine_layers) {
       if (belong1 || belong2) break;
       if (hit->getLayer() == layer)
     belong1 = true;
       if (hit->getLayer() == layer + 1)
     belong2 = true;
     }
  
     if ((!belong1 && !m_stereo) ||
     (m_subRegion >= 0 && !m_FPGATrackSimMapping->SubRegionMap()->isInRegion(m_subRegion, *hit))) {
       continue;
     }
     else if (m_stereo && belong1) { /* Intentionally blank */ }
     else if (m_stereo && !(hit->getLayer() > 1 && (hit->getLayer() % 2 == 1 && belong2))) {
       continue;
     }
  
     // This scans over y (d0) 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_++) {
       int y_bin_min = m_yBins_scaled.at(scale)[y_];
       int y_bin_max = m_yBins_scaled.at(scale)[y_+1];
  
       // Find the min/max x bins
       auto xBins = yToXBins(y_bin_min, y_bin_max, hit);
       // Update the image
       for (int 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;
 }

◆ createRoad() [1/2]

FPGATrackSimRoad FPGATrackSimHoughTransform_d0phi0_Tool::createRoad	(	const std::unordered_set< std::shared_ptr< const FPGATrackSimHit >> &	hits,
		unsigned	x,
		unsigned	y
	)		const

private

Definition at line 410 of file FPGATrackSimHoughTransform_d0phi0_Tool.cxx.

                                                                                                                                                                     {
   // Get the road hits
   std::vector<std::shared_ptr<const FPGATrackSimHit>> road_hits;
   layer_bitmask_t hitLayers = 0;
   for (const auto &hit : hits) {
     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
  
   FPGATrackSimRoad r;
   r.setRoadID(m_roads.size());
   r.setPID(y * m_imageSize_y + x);
   if (m_idealGeoRoads) matchIdealGeoSector(r);
   r.setHitLayers(hitLayers);
   r.setHits(std::move(sorted_hits));
   r.setSubRegion(m_subRegion);
   r.setX(m_bins_x[x] + m_step_x/2);
   r.setY(m_bins_y[y] + m_step_y/2);
   return r;
 }

◆ createRoad() [2/2]

FPGATrackSimRoad FPGATrackSimHoughTransform_d0phi0_Tool::createRoad	(	std::vector< std::vector< std::shared_ptr< const FPGATrackSimHit >>> &&	hits,
		layer_bitmask_t	hitLayers,
		unsigned	x,
		unsigned	y
	)		const

private

Definition at line 435 of file FPGATrackSimHoughTransform_d0phi0_Tool.cxx.

 {
   FPGATrackSimRoad r;
   r.setRoadID(m_roads.size());
   r.setPID(y * m_imageSize_y + x);
   if (m_useSectors) r.setSector(m_FPGATrackSimBankSvc->SectorBank_1st()->findSector(hits));
   else if (m_idealGeoRoads) matchIdealGeoSector(r);
   r.setHitLayers(hitLayers);
   r.setHits(std::move(hits));
   r.setSubRegion(m_subRegion);
   r.setX(m_bins_x[x] + m_step_x/2);
   r.setY(m_bins_y[y] + m_step_y/2);
  
   return r;
 }

◆ drawImage()

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

private

Definition at line 505 of file FPGATrackSimHoughTransform_d0phi0_Tool.cxx.

 {
   m_monitorFile.cd();
  
   TH2I h(name.c_str(), "Hough Transform;phi;d0 (mm)",
      m_imageSize_x, m_parMin[m_par_x], m_parMax[m_par_x],
      m_imageSize_y, m_parMin[m_par_y], m_parMax[m_par_y]
      );
  
   for (unsigned y = 0; y < m_imageSize_y; y++)
     for (unsigned x = 0; x < m_imageSize_x; x++)
       h.SetBinContent(x+1, y+1, image(y, x).first); // +1 since root bins are 1-indexed
  
   h.Write();
 }

◆ finalize()

StatusCode FPGATrackSimHoughTransform_d0phi0_Tool::finalize ( )

overridevirtual

Definition at line 139 of file FPGATrackSimHoughTransform_d0phi0_Tool.cxx.

 {
   m_monitorFile.Write();
   return StatusCode::SUCCESS;
 }

◆ getRoads()

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

overridevirtual

Definition at line 149 of file FPGATrackSimHoughTransform_d0phi0_Tool.cxx.

 {
   ATH_MSG_DEBUG("Event: " << m_event << ", # hits: " << hits.size());
   roads.clear();
   m_roads.clear();
  
   Image image = createImage(hits);
   if (m_event < 5) drawImage(image, m_name + "_" + std::to_string(m_event));
   if (!m_conv.empty()) image = convolute(image);
  
   for (unsigned y = 0; y < m_imageSize_y; y++) {
     for (unsigned x = 0; x < m_imageSize_x; x++) {
       if (passThreshold(image, x, y)) {
     m_roads.push_back(createRoad(image(y,x).second, x, y));
       }
     }
   }
  
   roads.reserve(m_roads.size());
   for (FPGATrackSimRoad & r : m_roads) roads.emplace_back(std::make_shared<const FPGATrackSimRoad>(r));
  
   if (roads.empty() && m_event >= 5 && m_event < 200)
     drawImage(image, m_name + "_" + std::to_string(m_event));
  
   m_event++;
   return StatusCode::SUCCESS;
 }

◆ getSubRegion()

virtual int FPGATrackSimHoughTransform_d0phi0_Tool::getSubRegion ( ) const

inlineoverridevirtual

Definition at line 53 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

53 {return m_subRegion;}

◆ initialize()

StatusCode FPGATrackSimHoughTransform_d0phi0_Tool::initialize ( )

overridevirtual

Definition at line 45 of file FPGATrackSimHoughTransform_d0phi0_Tool.cxx.

 {
   // Move temp variables over from properties to struct
   m_parMin.phi = m_tempMin_phi;
   m_parMin.d0 = m_tempMin_d0;
   m_parMax.phi = m_tempMax_phi;
   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
   ATH_CHECK(m_FPGATrackSimBankSvc.retrieve());
   ATH_CHECK(m_FPGATrackSimMapping.retrieve());
   m_nLayers = m_FPGATrackSimMapping->PlaneMap_1st(0)->getNLogiLayers();
  
   // Error checking
   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.empty() && m_hitExtend_x.size() != m_nLayers)
     ATH_MSG_FATAL("initialize() Hit extentsion list must have size == nLayers");
   else if (m_threshold.size() % 2 != 1)
     ATH_MSG_FATAL("initialize() Threshold size must be odd");
   else
     ok = true;
   for (unsigned const scale : m_binScale) {
     if (m_imageSize_y % scale != 0) {
       ATH_MSG_FATAL("initialize() The imagesize is not divisible by scale");
       ok = false;
     }
   }
   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;
     }
   }
   
   
   // 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
   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);
   }
  
   // Initialize scaled binnings
   for (unsigned const scale : m_binScale) {
     auto iter = m_yBins_scaled.find(scale);
  
     // if scale not found in keys, then push the scaled binning
     if (iter == m_yBins_scaled.end()) {
       unsigned new_size_y  = m_imageSize_y / scale;
       std::vector<size_t> yBins_scaled;
       for (unsigned i = 0; i <= new_size_y; i++) {
     yBins_scaled.push_back(scale * i);
       }
       m_yBins_scaled[scale] = yBins_scaled;
     }
   }
  
   return StatusCode::SUCCESS;
 }

◆ matchIdealGeoSector()

void FPGATrackSimHoughTransform_d0phi0_Tool::matchIdealGeoSector ( FPGATrackSimRoad & r ) const

private

Definition at line 377 of file FPGATrackSimHoughTransform_d0phi0_Tool.cxx.

 {
   float pt = r.getY()*0.001; // convert to MeV
   auto bounds = std::equal_range(fpgatracksim::QOVERPT_BINS.begin(),fpgatracksim::QOVERPT_BINS.end(),pt);
   int sectorbin = bounds.first-fpgatracksim::QOVERPT_BINS.begin()-1;
  
   // those bins are for tracks between the values, can't be below first value or more than the last value
   if (sectorbin < 0) sectorbin = 0;
   if (sectorbin > static_cast<int>(fpgatracksim::QOVERPT_BINS.size()-2)) sectorbin =  fpgatracksim::QOVERPT_BINS.size()-2;
   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::unique_ptr<FPGATrackSimHit> wcHit = std::unique_ptr<FPGATrackSimHit>(new FPGATrackSimHit());
       wcHit->setHitType(HitType::wildcard);
       wcHit->setLayer(il);
       wcHit->setDetType(m_FPGATrackSimMapping->PlaneMap_1st(0)->getDetType(il));
       r.setHits(il,std::vector<std::shared_ptr<const FPGATrackSimHit>>({std::move(wcHit)}));
  
     }
     else
       modules.push_back(sectorbin);
   }
   const FPGATrackSimSectorBank* sectorbank = m_FPGATrackSimBankSvc->SectorBank_1st();
   r.setSector(sectorbank->findSector(modules));
 }

◆ passThreshold()

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

private

Definition at line 272 of file FPGATrackSimHoughTransform_d0phi0_Tool.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;
       }
     }
       }
   
   return true;
 }

◆ yToX()

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

private

Definition at line 335 of file FPGATrackSimHoughTransform_d0phi0_Tool.cxx.

 {
   double x = 0;
  
   if (m_par_x == FPGATrackSimTrackPars::IPHI && m_par_y == FPGATrackSimTrackPars::ID0) {
     double r = hit->getR(); // TODO check this, and units
     double phi_hit = hit->getGPhi(); // TODO check this, and units
     x = -y/r + phi_hit;
   }
   else {
     ATH_MSG_ERROR("yToX() not defined for the current m_par selection");
   }
   
   return x;
 }

◆ yToXBins()

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

private

Definition at line 353 of file FPGATrackSimHoughTransform_d0phi0_Tool.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
   if (!m_hitExtend_x.empty()) x_bin_min -= m_hitExtend_x[hit->getLayer()];
   if (!m_hitExtend_x.empty()) x_bin_max += m_hitExtend_x[hit->getLayer()];
  
   // 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> FPGATrackSimHoughTransform_d0phi0_Tool::m_bins_x

private

Definition at line 103 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_bins_y

std::vector<double> FPGATrackSimHoughTransform_d0phi0_Tool::m_bins_y

private

Definition at line 104 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_binScale

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

private

Definition at line 77 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_combineLayer2D

std::vector< std::vector<int> > FPGATrackSimHoughTransform_d0phi0_Tool::m_combineLayer2D

private

Definition at line 94 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_combineLayers

Gaudi::Property<std::vector<unsigned int> > FPGATrackSimHoughTransform_d0phi0_Tool::m_combineLayers { this, "combine_layers", {0,1,2,3,4,5,6,7}, ""}

private

Definition at line 76 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_conv

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

private

Definition at line 75 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_convSize_x

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

private

Definition at line 78 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_convSize_y

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

private

Definition at line 79 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_event

int FPGATrackSimHoughTransform_d0phi0_Tool::m_event = 0

private

Definition at line 124 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_FPGATrackSimBankSvc

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

private

Definition at line 60 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_FPGATrackSimMapping

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

private

Definition at line 61 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_hitExtend_x

Gaudi::Property<std::vector<unsigned int> > FPGATrackSimHoughTransform_d0phi0_Tool::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 80 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_idealGeoRoads

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

private

Definition at line 85 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_imageSize_x

Gaudi::Property<unsigned int> FPGATrackSimHoughTransform_d0phi0_Tool::m_imageSize_x { this, "nBins_x", 1, ""}

private

Definition at line 73 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_imageSize_y

Gaudi::Property<unsigned int> FPGATrackSimHoughTransform_d0phi0_Tool::m_imageSize_y { this, "nBins_y", 1, ""}

private

Definition at line 74 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_localMaxWindowSize

Gaudi::Property<bool> FPGATrackSimHoughTransform_d0phi0_Tool::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 83 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_monitorFile

TFile FPGATrackSimHoughTransform_d0phi0_Tool::m_monitorFile

private

Definition at line 126 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_name

std::string FPGATrackSimHoughTransform_d0phi0_Tool::m_name

private

Definition at line 125 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_nCombineLayers

unsigned FPGATrackSimHoughTransform_d0phi0_Tool::m_nCombineLayers = 0U

private

Definition at line 93 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_nLayers

unsigned FPGATrackSimHoughTransform_d0phi0_Tool::m_nLayers = 0U

private

Definition at line 99 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_par_x

FPGATrackSimTrackPars::pars_index FPGATrackSimHoughTransform_d0phi0_Tool::m_par_x = FPGATrackSimTrackPars::IPHI

private

Definition at line 87 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_par_y

FPGATrackSimTrackPars::pars_index FPGATrackSimHoughTransform_d0phi0_Tool::m_par_y = FPGATrackSimTrackPars::ID0

private

Definition at line 88 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_parMax

FPGATrackSimTrackPars FPGATrackSimHoughTransform_d0phi0_Tool::m_parMax

private

Definition at line 91 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_parMin

FPGATrackSimTrackPars FPGATrackSimHoughTransform_d0phi0_Tool::m_parMin

private

Definition at line 90 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_roads

std::vector<FPGATrackSimRoad> FPGATrackSimHoughTransform_d0phi0_Tool::m_roads

private

Definition at line 119 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_step_x

double FPGATrackSimHoughTransform_d0phi0_Tool::m_step_x = 0

private

Definition at line 101 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_step_y

double FPGATrackSimHoughTransform_d0phi0_Tool::m_step_y = 0

private

Definition at line 102 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_stereo

Gaudi::Property<bool> FPGATrackSimHoughTransform_d0phi0_Tool::m_stereo { this, "stereo", false, "Combine stereo layers"}

private

Definition at line 82 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_subRegion

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

private

Definition at line 67 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_tempMax_d0

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

private

Definition at line 71 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_tempMax_phi

Gaudi::Property<float> FPGATrackSimHoughTransform_d0phi0_Tool::m_tempMax_phi { this, "phi_max", 1, "max phi"}

private

Definition at line 69 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_tempMin_d0

Gaudi::Property<float> FPGATrackSimHoughTransform_d0phi0_Tool::m_tempMin_d0 { this, "d0_min", -1, "min q/pt"}

private

Definition at line 70 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_tempMin_phi

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

private

Definition at line 68 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_threshold

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

private

Definition at line 72 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_traceHits

Gaudi::Property<bool> FPGATrackSimHoughTransform_d0phi0_Tool::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 81 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_useSectors

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

private

Definition at line 84 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

◆ m_yBins_scaled

std::unordered_map<int, std::vector<size_t> > FPGATrackSimHoughTransform_d0phi0_Tool::m_yBins_scaled

private

Definition at line 107 of file FPGATrackSimHoughTransform_d0phi0_Tool.h.

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

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ Image

Constructor & Destructor Documentation

◆ FPGATrackSimHoughTransform_d0phi0_Tool()

Member Function Documentation

◆ addRoad() [1/2]

◆ addRoad() [2/2]

◆ conv()

◆ convolute()

◆ createImage()

◆ createLayerImage()

◆ createRoad() [1/2]

◆ createRoad() [2/2]

◆ drawImage()

◆ finalize()

◆ getRoads()

◆ getSubRegion()

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

◆ m_FPGATrackSimBankSvc

◆ m_FPGATrackSimMapping

◆ m_hitExtend_x

◆ m_idealGeoRoads

◆ m_imageSize_x

◆ m_imageSize_y

◆ m_localMaxWindowSize

◆ m_monitorFile

◆ m_name

◆ m_nCombineLayers

◆ m_nLayers

◆ m_par_x

◆ m_par_y

◆ m_parMax

◆ m_parMin

◆ m_roads

◆ m_step_x

◆ m_step_y

◆ m_stereo

◆ m_subRegion

◆ m_tempMax_d0

◆ m_tempMax_phi

◆ m_tempMin_d0

◆ m_tempMin_phi

◆ m_threshold

◆ m_traceHits

◆ m_useSectors

◆ m_yBins_scaled