#include <FPGATrackSimLLPDoubletHoughTransformTool.h>

Inheritance diagram for FPGATrackSimLLPDoubletHoughTransformTool:

Collaboration diagram for FPGATrackSimLLPDoubletHoughTransformTool:

Public Member Functions
	FPGATrackSimLLPDoubletHoughTransformTool (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

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

Private Member Functions
StatusCode	fillImage (std::shared_ptr< const FPGATrackSimHit > &hit1, std::shared_ptr< const FPGATrackSimHit > &hit2, Image &image) const

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

bool	isLocalMaxima (Image const &image, int x, int y) const

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

void	drawImage (Image const &image) const

float	xtod0 (int x) const

float	ytoqoverpt (int y) const

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

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

Gaudi::Property< int >	m_threshold { this, "m_threshold", 8, "Threshold to be allied to bins of abs(d0) > 50 (mm)"}

Gaudi::Property< int >	m_threshold50 { this, "m_threshold50", 8, "Threshold to be allied to bins of abs(d0) < (mm)"}

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< float >	m_d0_range { this, "d0_range", 120, "The d0 span: (-range, range) in mm"}

Gaudi::Property< float >	m_qOverPt_range { this, "qOverPt_range", 0.002, "The q/pT span: (-range, range) in e/MeV"}

Gaudi::Property< bool >	m_continuous { this, "continuous", true, "assure that there is continuity of the line (i.e. middle bins in d0 are filled when one q/pT step would result in a hole)"}

std::vector< FPGATrackSimRoad >	m_roads

const double	m_acceptedDistanceBetweenLayersMin = 200

const double	m_acceptedDistanceBetweenLayersMax = 600

double	m_step_x = 0

double	m_step_y = 0

unsigned	m_event = 0

int	m_eventsProcessed = 0

int	m_roadsGenerated = 0

Detailed Description

Definition at line 25 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

Member Typedef Documentation

◆ Image

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

private

Definition at line 49 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

Constructor & Destructor Documentation

◆ FPGATrackSimLLPDoubletHoughTransformTool()

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

Definition at line 39 of file FPGATrackSimLLPDoubletHoughTransformTool.cxx.

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

Member Function Documentation

◆ createRoad()

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

private

Definition at line 142 of file FPGATrackSimLLPDoubletHoughTransformTool.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(8); // If no hits in last layer, return from sortByLayer will be too short
  
     FPGATrackSimRoad r;
     r.setHitLayers(hitLayers);
     r.setHits(std::move(sorted_hits));
     return r;
 }

◆ drawImage()

void FPGATrackSimLLPDoubletHoughTransformTool::drawImage ( Image const & image ) const

private

Definition at line 182 of file FPGATrackSimLLPDoubletHoughTransformTool.cxx.

                                                                                   { 
  
     TH2I h(("event"+std::to_string( m_event )).c_str(), "LLP Doublet Hough space;d_{0}[mm];q/pT [e/GeV]",
             m_imageSize_x, -m_d0_range, m_d0_range,
             m_imageSize_y, -m_qOverPt_range, m_qOverPt_range );
  
     for (unsigned x = 0; x < m_imageSize_x; x++)
         for (unsigned y = 0; y < m_imageSize_y; y++)
             h.SetBinContent(x+1, y+1, image(x, y).first); // +1 since root bins are 1-indexed
  
     h.SaveAs((name()+"_event_"+std::to_string( m_event )+".root").c_str(), "");
 }

◆ fillImage()

StatusCode FPGATrackSimLLPDoubletHoughTransformTool::fillImage	(	std::shared_ptr< const FPGATrackSimHit > &	hit1,
		std::shared_ptr< const FPGATrackSimHit > &	hit2,
		Image &	image
	)		const

private

Definition at line 102 of file FPGATrackSimLLPDoubletHoughTransformTool.cxx.

                                                                                                                                                                          { 
     const pvec p1 {{hit1->getX(), hit1->getY()}};
     const pvec p2 {{hit2->getX(), hit2->getY()}};
     const pvec halfDiff = (p2 - p1)*0.5;
     const fp_t halfLen = length(halfDiff);
  
     int xbefore = -1;
  
     for ( unsigned y = 0; y < m_imageSize_y; y++ ) {
         const fp_t qoverpt = (y * m_step_y) + m_step_y*0.5 - m_qOverPt_range; // use middle f the bin
         const fp_t radius = 1.0/(0.6*qoverpt); // magic transform constants
         const fp_t scale = std::copysign( std::sqrt( std::pow(radius/halfLen, 2) - 1), radius );
         const pvec rprime = rotate90(halfDiff) * scale;
         const pvec center = p1 + halfDiff + rprime;
         const fp_t d0 =  (std::signbit(radius) ? -1.0 : 1.0)*(length(center) - abs(radius));
  
         // find the bin x position in the image
         int x = (d0 + m_d0_range) / m_step_x;
  
         if ( 0 <= x && x < (int)m_imageSize_x) {
             if (xbefore == -1) xbefore = x;
             if ( m_continuous ) { // fill the bins along x starintg from the last one filled 
                 const int xmin =  (xbefore < x)? xbefore: x;
                 const int xmax =  (xbefore < x)? x: xbefore;
                 for ( int xinterpolated = xmin; xinterpolated <= xmax; ++xinterpolated) {
                     image(xinterpolated, y).first++;
                     image(xinterpolated, y).second.insert( hit1 );
                     image(xinterpolated, y).second.insert( hit2 );
                 }
             } else {
                 image(x, y).first++;
                 image(x, y).second.insert( hit1 );
                 image(x, y).second.insert( hit2 );
             }
             xbefore = x;
         }    
     }
     return StatusCode::SUCCESS;
 }

◆ finalize()

StatusCode FPGATrackSimLLPDoubletHoughTransformTool::finalize ( )

overridevirtual

Definition at line 57 of file FPGATrackSimLLPDoubletHoughTransformTool.cxx.

                                                               { 
     ATH_MSG_INFO("Number of events procesed by the FPGATrackSimLLPDoubletHoughTransformTool " << m_eventsProcessed <<  " roads " << m_roadsGenerated);
     return StatusCode::SUCCESS;
 }

◆ getRoads()

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

overridevirtual

Definition at line 62 of file FPGATrackSimLLPDoubletHoughTransformTool.cxx.

                                                                                                                                                                                     {
     roads.clear();
     m_roads.clear();
     m_eventsProcessed++;
     Image image(m_imageSize_x, m_imageSize_y); // not quite optimal to allocate this memory in evey event, but following nominal HT
     for (unsigned ihit1 = 0; ihit1 < hits.size(); ihit1++) {
       std::shared_ptr<const FPGATrackSimHit> hit1 = hits[ihit1];
       for (unsigned ihit2 = ihit1+1; ihit2 < hits.size(); ihit2++) {
     std::shared_ptr<const FPGATrackSimHit> hit2 = hits[ihit2];
             ATH_MSG_DEBUG("Hits pair R: " << hit1->getR() << " " << hit2->getR());
             //TODO: replace with qualification by layer IDs
             const double radiusDifference =  hit2->getR() - hit1->getR();
  
             if (  not (m_acceptedDistanceBetweenLayersMin < radiusDifference && radiusDifference < m_acceptedDistanceBetweenLayersMax) ) 
                 continue;
             if ( hit1->getLayer() == hit2->getLayer() )
                 continue;
             ATH_CHECK(fillImage( hit1, hit2, image ));
         }
     } 
     if ( m_event < 20 )
         drawImage(image);
  
     for (unsigned y = 0; y < m_imageSize_y; y++) {
         for (unsigned x = 0; x < m_imageSize_x; x++) {
             if (passThreshold(image, x, y) && isLocalMaxima( image, x, y ) ) {
                 ATH_MSG_DEBUG("Creating road with threshold " << image(x,y).first << " hits " << image(x,y).second.size() 
                                 << " at x: " << x  << " d0 " << xtod0(x) <<  " y: "<< y << " q/pt " << ytoqoverpt(y));
                 m_roadsGenerated++;
                 m_roads.push_back(createRoad(image(x, y).second, x, y));
             }
         }
     }
     roads.reserve(m_roads.size());
     for (FPGATrackSimRoad & r : m_roads) roads.emplace_back(std::make_shared<const FPGATrackSimRoad>(r));
     m_event++;
     return StatusCode::SUCCESS;   
 }

◆ initialize()

StatusCode FPGATrackSimLLPDoubletHoughTransformTool::initialize ( )

overridevirtual

Definition at line 46 of file FPGATrackSimLLPDoubletHoughTransformTool.cxx.

                                                                 { 
     if (m_imageSize_y %2 == 1) {
         ATH_MSG_ERROR("Can not have odd number  " <<  m_imageSize_y << " of bins in q/pT - will result in division by 0");
         return StatusCode::FAILURE;
     }
     m_step_x = (2*m_d0_range) / m_imageSize_x;
     m_step_y = (2*m_qOverPt_range) / m_imageSize_y;
  
     return StatusCode::SUCCESS;
  }

◆ isLocalMaxima()

bool FPGATrackSimLLPDoubletHoughTransformTool::isLocalMaxima	(	Image const &	image,
		int	x,
		int	y
	)		const

private

Definition at line 171 of file FPGATrackSimLLPDoubletHoughTransformTool.cxx.

                                                                                                     { 
     const auto centerValue =  image(x,y).first;
     for ( int xaround = std::min(x-1, 0); xaround <= std::max((int)m_imageSize_x-1, x+1); xaround++  ) {
       for ( int yaround = std::min(y-1, 0); yaround <= std::max((int)m_imageSize_y-1, y+1); yaround++  ) {
             if ( image(xaround,yaround).first > centerValue )
                 return false;
         }
     }
     return true; 
 }

◆ passThreshold()

bool FPGATrackSimLLPDoubletHoughTransformTool::passThreshold	(	Image const &	image,
		int	x,
		int	y
	)		const

private

Definition at line 162 of file FPGATrackSimLLPDoubletHoughTransformTool.cxx.

                                                                                                     {
     const int count = image(x,y).first;
     const float d0 = xtod0(x);
     if ( std::abs(d0) < 50.0 && count >= m_threshold50 ) return true;
     if ( std::abs(d0) >= 50.0 && count >= m_threshold ) return true;
     
     return false;
 }

◆ xtod0()

float FPGATrackSimLLPDoubletHoughTransformTool::xtod0 ( int x ) const

inlineprivate

Definition at line 66 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

66 { return x*m_step_x - m_d0_range; }

◆ ytoqoverpt()

float FPGATrackSimLLPDoubletHoughTransformTool::ytoqoverpt ( int y ) const

inlineprivate

Definition at line 67 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

67 { return y*m_step_y - m_qOverPt_range; }

Member Data Documentation

◆ m_acceptedDistanceBetweenLayersMax

const double FPGATrackSimLLPDoubletHoughTransformTool::m_acceptedDistanceBetweenLayersMax = 600

private

Definition at line 53 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

◆ m_acceptedDistanceBetweenLayersMin

const double FPGATrackSimLLPDoubletHoughTransformTool::m_acceptedDistanceBetweenLayersMin = 200

private

Definition at line 52 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

◆ m_continuous

Gaudi::Property<bool> FPGATrackSimLLPDoubletHoughTransformTool::m_continuous { this, "continuous", true, "assure that there is continuity of the line (i.e. middle bins in d0 are filled when one q/pT step would result in a hole)"}

private

Definition at line 46 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

◆ m_d0_range

Gaudi::Property<float> FPGATrackSimLLPDoubletHoughTransformTool::m_d0_range { this, "d0_range", 120, "The d0 span: (-range, range) in mm"}

private

Definition at line 44 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

◆ m_event

unsigned FPGATrackSimLLPDoubletHoughTransformTool::m_event = 0

private

Definition at line 63 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

◆ m_eventsProcessed

int FPGATrackSimLLPDoubletHoughTransformTool::m_eventsProcessed = 0

private

Definition at line 68 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

◆ m_imageSize_x

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

private

Definition at line 39 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

◆ m_imageSize_y

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

private

Definition at line 40 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

◆ m_qOverPt_range

Gaudi::Property<float> FPGATrackSimLLPDoubletHoughTransformTool::m_qOverPt_range { this, "qOverPt_range", 0.002, "The q/pT span: (-range, range) in e/MeV"}

private

Definition at line 45 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

◆ m_roads

std::vector<FPGATrackSimRoad> FPGATrackSimLLPDoubletHoughTransformTool::m_roads

private

Definition at line 50 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

◆ m_roadsGenerated

int FPGATrackSimLLPDoubletHoughTransformTool::m_roadsGenerated = 0

private

Definition at line 69 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

◆ m_step_x

double FPGATrackSimLLPDoubletHoughTransformTool::m_step_x = 0

private

Definition at line 55 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

◆ m_step_y

double FPGATrackSimLLPDoubletHoughTransformTool::m_step_y = 0

private

Definition at line 56 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

◆ m_threshold

Gaudi::Property<int> FPGATrackSimLLPDoubletHoughTransformTool::m_threshold { this, "m_threshold", 8, "Threshold to be allied to bins of abs(d0) > 50 (mm)"}

private

Definition at line 41 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

◆ m_threshold50

Gaudi::Property<int> FPGATrackSimLLPDoubletHoughTransformTool::m_threshold50 { this, "m_threshold50", 8, "Threshold to be allied to bins of abs(d0) < (mm)"}

private

Definition at line 42 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

◆ m_traceHits

Gaudi::Property<bool> FPGATrackSimLLPDoubletHoughTransformTool::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 43 of file FPGATrackSimLLPDoubletHoughTransformTool.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

◆ FPGATrackSimLLPDoubletHoughTransformTool()

Member Function Documentation

◆ createRoad()

◆ drawImage()

◆ fillImage()

◆ finalize()

◆ getRoads()

◆ initialize()

◆ isLocalMaxima()

◆ passThreshold()

◆ xtod0()

◆ ytoqoverpt()

Member Data Documentation

◆ m_acceptedDistanceBetweenLayersMax

◆ m_acceptedDistanceBetweenLayersMin

◆ m_continuous

◆ m_d0_range

◆ m_event

◆ m_eventsProcessed

◆ m_imageSize_x

◆ m_imageSize_y

◆ m_qOverPt_range

◆ m_roads

◆ m_roadsGenerated

◆ m_step_x

◆ m_step_y

◆ m_threshold

◆ m_threshold50

◆ m_traceHits