AFPFastReco.h

Go to the documentation of this file.

#ifndef AFP_MONITORING_AFPFASTRECO_H
#define AFP_MONITORING_AFPFASTRECO_H
 
#include <array>
#include <list>
#include <utility>
#include <vector>
 
#include "xAODForward/AFPSiHit.h"
#include "xAODForward/AFPSiHitContainer.h"
 
namespace AFPMon {
 
struct AFPCluster 
{
    AFPCluster(float x_, float y_, float z_, int s, int l, int sumToT_)
        : x {x_}, y {y_}, z {z_}, station {s}, layer {l}, sumToT{sumToT_} {}
 
    float x;
    float y;
    float z;
    int station;
    int layer;
    int sumToT;
 };
 
inline bool operator==(const AFPCluster& lhs, const AFPCluster& rhs) 
{
    if (lhs.x != rhs.x) return false;
    if (lhs.y != rhs.y) return false;
    if (lhs.z != rhs.z) return false;
    if (lhs.station != rhs.station) return false;
    if (lhs.layer != rhs.layer) return false;
    if (lhs.sumToT != rhs.sumToT) return false;
 
    return true;
}
 
struct AFPTrack 
{
    AFPTrack(float x_, float y_, int s, std::array<int, 4> a)
        : x {x_}, y {y_}, station {s}, layerClusters {std::move(a)} {}
 
    float x;
    float y;
    int station;
    std::array<int, 4> layerClusters;
};
 
class AFPFastReco 
{
    public:
    AFPFastReco(const xAOD::AFPSiHitContainer* hits) : m_hitContainer {hits} {}
 
    void reco();
 
    const std::vector<AFPCluster>& clusters() const { return m_clusters; }
 
    const std::vector<AFPTrack>& tracks() const { return m_tracks; }
 
    private:
    void recoClusters();
 
    void recoTracks();
 
    std::pair<double, double> linReg(const std::vector<std::pair<double, double>>& YX) const;
 
    template <class T>
    std::vector<T> findAround(T init, std::list<T>& toJoin) const;
 
    bool areNeighbours(const xAOD::AFPSiHit* lhs, const xAOD::AFPSiHit* rhs) const;
 
    bool areNeighbours(const AFPCluster& lhs, const AFPCluster& rhs) const;
 
    const xAOD::AFPSiHitContainer* m_hitContainer;
 
    std::vector<AFPCluster> m_clusters;
 
    std::vector<AFPTrack> m_tracks;
 
    static constexpr int s_afpStations = 4;
 
    static constexpr int s_afpLayers = 4;
 
    static constexpr int s_trackSize = 3;
 
    static constexpr float s_clusterDistance = 0.4;
 };
 
template <class T> std::vector<T> AFPFastReco::findAround(T init, std::list<T>& toJoin) const 
{
    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;
  }
 
}  // namespace AFPMon
 
#endif /* AFP_MONITORING_AFPFASTRECO_H */