FPGATrackSimLLPDoubletHoughTransformTool Class Reference

#include <FPGATrackSimLLPDoubletHoughTransformTool.h>

Inheritance diagram for FPGATrackSimLLPDoubletHoughTransformTool:

Collaboration diagram for FPGATrackSimLLPDoubletHoughTransformTool:

Public Member Functions
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
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 51 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

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 134 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 174 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 94 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 49 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 54 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;   
}

getSubRegion()

virtual int FPGATrackSimLLPDoubletHoughTransformTool::getSubRegion ( ) const

inlineoverridevirtual

Definition at line 36 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

{return -1;}

initialize()

StatusCode FPGATrackSimLLPDoubletHoughTransformTool::initialize ( )

overridevirtual

Definition at line 38 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 163 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 154 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 68 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

{ return x*m_step_x - m_d0_range; }

ytoqoverpt()

float FPGATrackSimLLPDoubletHoughTransformTool::ytoqoverpt ( int y ) const

inlineprivate

Definition at line 69 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

{ return y*m_step_y - m_qOverPt_range; }

Member Data Documentation

m_acceptedDistanceBetweenLayersMax

const double FPGATrackSimLLPDoubletHoughTransformTool::m_acceptedDistanceBetweenLayersMax = 600

private

Definition at line 55 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

m_acceptedDistanceBetweenLayersMin

const double FPGATrackSimLLPDoubletHoughTransformTool::m_acceptedDistanceBetweenLayersMin = 200

private

Definition at line 54 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 48 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

{ 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)"};

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 46 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

{ this, "d0_range", 120, "The d0 span: (-range, range) in mm"};

m_event

unsigned FPGATrackSimLLPDoubletHoughTransformTool::m_event = 0

private

Definition at line 65 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

m_eventsProcessed

int FPGATrackSimLLPDoubletHoughTransformTool::m_eventsProcessed = 0

private

Definition at line 70 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

m_imageSize_x

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

private

Definition at line 41 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

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

m_imageSize_y

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

private

Definition at line 42 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

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

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 47 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

{ this, "qOverPt_range", 0.002, "The q/pT span: (-range, range) in e/MeV"};

m_roads

std::vector<FPGATrackSimRoad> FPGATrackSimLLPDoubletHoughTransformTool::m_roads

private

Definition at line 52 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

m_roadsGenerated

int FPGATrackSimLLPDoubletHoughTransformTool::m_roadsGenerated = 0

private

Definition at line 71 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

m_step_x

double FPGATrackSimLLPDoubletHoughTransformTool::m_step_x = 0

private

Definition at line 57 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

m_step_y

double FPGATrackSimLLPDoubletHoughTransformTool::m_step_y = 0

private

Definition at line 58 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 43 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

{ this, "m_threshold", 8, "Threshold to be allied to bins of abs(d0) > 50 (mm)"};

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 44 of file FPGATrackSimLLPDoubletHoughTransformTool.h.

{ this, "m_threshold50", 8, "Threshold to be allied to bins of abs(d0) < (mm)"};

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 45 of file FPGATrackSimLLPDoubletHoughTransformTool.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."};

---

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

• FPGATrackSimLLPDoubletHoughTransformTool.h
• FPGATrackSimLLPDoubletHoughTransformTool.cxx