AFPMon::AFPFastReco Class Reference

#include <AFPFastReco.h>

Collaboration diagram for AFPMon::AFPFastReco:

Public Member Functions
	AFPFastReco (const xAOD::AFPSiHitContainer *hits)
	Constructor. Sets input hit container. More...
void	reco ()
	Performs fast reconstruction of clusters and tracks. More...
std::vector< AFPCluster >	clusters () const
	Returns vector of clusters. More...
std::vector< AFPTrack >	tracks () const
	Returns vector of tracks. More...

Private Member Functions
void	recoClusters ()
	Performs fast cluster reconstruction. More...
void	recoTracks ()
	Performs fast track reconstruction. More...
std::pair< double, double >	linReg (const std::vector< std::pair< double, double >> &YX) const
	Returns parameters of fitted line. More...
template<class T >
std::vector< T >	findAround (T init, std::list< T > &toJoin) const
	Finds hits/clusters around given init element. More...
bool	areNeighbours (const xAOD::AFPSiHit *lhs, const xAOD::AFPSiHit *rhs) const
	Checks if given hits are neighbours. More...
bool	areNeighbours (const AFPCluster &lhs, const AFPCluster &rhs) const
	Checks if given clusters are neighbours. More...

Private Attributes
const xAOD::AFPSiHitContainer *	m_hitContainer
	Pointer to hit container. More...
std::vector< AFPCluster >	m_clusters
	Vector of clusters. More...
std::vector< AFPTrack >	m_tracks
	Vector of tracks. More...

Static Private Attributes
static constexpr int	s_afpStations = 4
	Number of AFP stations. More...
static constexpr int	s_afpLayers = 4
	Number of layers in each station. More...
static constexpr int	s_trackSize = 3
	Minimum number of clusters in track. More...
static constexpr float	s_clusterDistance = 0.4
	Maximum distance between cluster. More...

Detailed Description

Definition at line 50 of file AFPFastReco.h.

Constructor & Destructor Documentation

AFPFastReco()

AFPMon::AFPFastReco::AFPFastReco ( const xAOD::AFPSiHitContainer *  hits )

inline

Constructor. Sets input hit container.

Definition at line 54 of file AFPFastReco.h.

: m_hitContainer {hits} {}

Member Function Documentation

areNeighbours() [1/2]

bool AFPMon::AFPFastReco::areNeighbours ( const AFPCluster &  lhs, const AFPCluster &  rhs  ) const

private

Checks if given clusters are neighbours.

Definition at line 139 of file AFPFastReco.cxx.

{
    if (lhs.station != rhs.station) return false;
 
    const float dx = lhs.x - rhs.x;
    const float dy = lhs.y - rhs.y;
    return dx * dx + dy * dy <= s_clusterDistance;
}

areNeighbours() [2/2]

bool AFPMon::AFPFastReco::areNeighbours ( const xAOD::AFPSiHit *  lhs, const xAOD::AFPSiHit *  rhs  ) const

private

Checks if given hits are neighbours.

Definition at line 129 of file AFPFastReco.cxx.

{
    if (lhs->stationID() != rhs->stationID()) return false;
    if (lhs->pixelLayerID() != rhs->pixelLayerID()) return false;
    if (lhs->pixelColIDChip() != rhs->pixelColIDChip()) return false;
    if (abs(lhs->pixelRowIDChip() - rhs->pixelRowIDChip()) != 1) return false;
 
    return true;
}

clusters()

std::vector<AFPCluster> AFPMon::AFPFastReco::clusters ( ) const

inline

Returns vector of clusters.

Definition at line 60 of file AFPFastReco.h.

{ return m_clusters; }

findAround()

template<class T >

std::vector< T > AFPMon::AFPFastReco::findAround ( T  init, std::list< T > &  toJoin  ) const

private

Finds hits/clusters around given init element.

Definition at line 107 of file AFPFastReco.h.

{
    std::vector<T> element;
    element.push_back(init);
 
    std::vector<T> newNeighbours;
    do 
    {
        newNeighbours.clear();
        for (auto& b : toJoin) 
        {
            bool isNew = false;
            for (auto& a : element)
            if (areNeighbours(a, b)) 
            {
                isNew = true;
                break;
            }
 
            if (isNew) 
            {
                newNeighbours.push_back(b);
                element.push_back(b);
            }
        }
 
        for (auto& t : newNeighbours)
            toJoin.remove(t);
 
    } while (newNeighbours.size() > 0);
 
    return element;
  }

linReg()

std::pair< double, double > AFPMon::AFPFastReco::linReg ( const std::vector< std::pair< double, double >> &  YX ) const

private

Returns parameters of fitted line.

Definition at line 99 of file AFPFastReco.cxx.

{
    double meanx = 0;
    double meany = 0;
    for (const auto& yx : YX) 
    {
        meany += yx.first;
        meanx += yx.second;
    }
 
    meanx /= YX.size();
    meany /= YX.size();
 
    double numerator   = 0;
    double denumerator = 0;
    for (const auto& yx : YX) 
    {
        const double dy = yx.first - meany;
        const double dx = yx.second - meanx;
        numerator += dx * dy;
        denumerator += dx * dx;
    }
 
    if(denumerator==0.0) denumerator=1e-6;
    const double slope    = numerator / denumerator;
    const double position = meany - slope * meanx;
 
    return {position, slope};
}

reco()

void AFPMon::AFPFastReco::reco

(

)

Performs fast reconstruction of clusters and tracks.

Definition at line 16 of file AFPFastReco.cxx.

{
    recoClusters();
    recoTracks();
}

recoClusters()

void AFPMon::AFPFastReco::recoClusters ( )

private

Performs fast cluster reconstruction.

Definition at line 22 of file AFPFastReco.cxx.

{
    constexpr float dx   = 0.25;  // [mm]
    constexpr float dy   = 0.05;  // [mm]
    constexpr float dz   = 9.00;  // [mm]
    constexpr float tilt = 14. / 180. * M_PI;
 
    std::list toCluster(m_hitContainer->begin(), m_hitContainer->end());
 
    while (!toCluster.empty()) 
    {
        const auto *init = *(toCluster.begin());
        toCluster.pop_front();
        auto clusteredHits = findAround(init, toCluster);
 
        float sumX        = 0;
        float sumY        = 0;
        float sumCharge   = 0;
        int   sumToT_temp = 0;
        for (const xAOD::AFPSiHit* h : clusteredHits) 
        {
            const float charge = h->depositedCharge();
            const float pixX   = dx * h->pixelColIDChip();
            const float pixY   = dy * h->pixelRowIDChip();
            sumX += charge * pixX;
            sumY += charge * pixY;
            sumCharge += charge;
            sumToT_temp += h->timeOverThreshold();
        }
 
        const float xPlane = sumX / sumCharge;
        const float yPlane = sumY / sumCharge;
 
        const int stationID = init->stationID();
        const int layerID   = init->pixelLayerID();
 
        const float x = xPlane;
        const float y = yPlane * std::cos(tilt);
        const float z = yPlane * std::sin(tilt) + dz * layerID;
 
        m_clusters.emplace_back(x, y, z, stationID, layerID, sumToT_temp);
    }
}

recoTracks()

void AFPMon::AFPFastReco::recoTracks ( )

private

Performs fast track reconstruction.

Definition at line 66 of file AFPFastReco.cxx.

{
    std::list toTrack(m_clusters.begin(), m_clusters.end());
 
    while (!toTrack.empty()) 
    {
        auto init = *(toTrack.begin());
        toTrack.pop_front();
        auto trackCandidate = findAround(init, toTrack);
 
        if (trackCandidate.size() < s_trackSize) continue;
 
        std::array<int, 4> clusters {};
 
        std::vector<std::pair<double, double>> XZ;
        std::vector<std::pair<double, double>> YZ;
 
        for (const auto& cluster : trackCandidate) 
        {
            clusters[cluster.layer]++;
 
            XZ.emplace_back(cluster.x, cluster.z);
            YZ.emplace_back(cluster.y, cluster.z);
        }
 
        const auto [x, xSlope] = linReg(XZ);
        const auto [y, ySlope] = linReg(YZ);
        const int station      = trackCandidate[0].station;
 
        m_tracks.emplace_back(x, y, station, clusters);
    }
}

tracks()

std::vector<AFPTrack> AFPMon::AFPFastReco::tracks ( ) const

inline

Returns vector of tracks.

Definition at line 63 of file AFPFastReco.h.

{ return m_tracks; }

Member Data Documentation

m_clusters

std::vector<AFPCluster> AFPMon::AFPFastReco::m_clusters

private

Vector of clusters.

Definition at line 89 of file AFPFastReco.h.

m_hitContainer

const xAOD::AFPSiHitContainer* AFPMon::AFPFastReco::m_hitContainer

private

Pointer to hit container.

Definition at line 86 of file AFPFastReco.h.

m_tracks

std::vector<AFPTrack> AFPMon::AFPFastReco::m_tracks

private

Vector of tracks.

Definition at line 92 of file AFPFastReco.h.

s_afpLayers

constexpr int AFPMon::AFPFastReco::s_afpLayers = 4

staticconstexprprivate

Number of layers in each station.

Definition at line 98 of file AFPFastReco.h.

s_afpStations

constexpr int AFPMon::AFPFastReco::s_afpStations = 4

staticconstexprprivate

Number of AFP stations.

Definition at line 95 of file AFPFastReco.h.

s_clusterDistance

constexpr float AFPMon::AFPFastReco::s_clusterDistance = 0.4

staticconstexprprivate

Maximum distance between cluster.

Definition at line 104 of file AFPFastReco.h.

s_trackSize

constexpr int AFPMon::AFPFastReco::s_trackSize = 3

staticconstexprprivate

Minimum number of clusters in track.

Definition at line 101 of file AFPFastReco.h.

---

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

• AFPFastReco.h
• AFPFastReco.cxx