AFPSiDLinRegTool Class Reference

Tool for reconstructing AFPTrack parameters from track candidates. More...

#include <AFPSiDLinRegTool.h>

Inheritance diagram for AFPSiDLinRegTool:

Collaboration diagram for AFPSiDLinRegTool:

Public Member Functions
	AFPSiDLinRegTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~AFPSiDLinRegTool () override
virtual StatusCode	initialize () override
	Read parameters from job options and print tool configuration.
StatusCode	reconstructTracks (std::unique_ptr< xAOD::AFPTrackContainer > &outputContainer, const EventContext &ctx) const override
	Reconstructs tracks properties from track candidates.
const std::string &	outputContainerName () const override

Private Member Functions
std::vector< const xAOD::AFPSiHitsCluster * >	findClusterAroundElement (std::list< const xAOD::AFPSiHitsCluster * > &toJoin, const xAOD::AFPSiHitsCluster *init) const
	Looks for cluster around init cluster.
bool	areNeighbours (const xAOD::AFPSiHitsCluster *a, const xAOD::AFPSiHitsCluster *b) const
	Checks if clusters are neighbours Compares distance between them to m_allowedDistanceBetweenClustersInTrack.
std::pair< double, double >	linearRegression (const std::vector< std::pair< double, double > > &YX) const
	Simple linear regression Used to calculate track postions and slopes.

Private Attributes
Gaudi::Property< std::string >	m_tracksContainerName {this, "tracksContainerName", "AFPTrackContainer", "Name of the container in which tracks are saved"}
	Name of the xAOD container to which tracks will be saved; actual saving is done in AFPSIDLocRecoTool.
Gaudi::Property< int >	m_stationID {this, "stationID", 0, "ID number of station for which tracks should be reconstructed"}
	AFP station ID for which tracks will be reconstructed.
Gaudi::Property< double >	m_allowedDistanceBetweenClustersInTrack {this, "allowedDistanceBetweenClustersInTrack", 0.5, "Maximum allowed distance between clusters to be considered coming from the same proton"}
	Maximum allowed distance between clusters to be considered coming from the same proton.
Gaudi::Property< std::string >	m_trackSelection {this, "trackSelection", "Medium", "Track selection, allowed values are \"Loose\" (accept all track candidates), \"Medium\" (accept only tracks with clusters in at least #m_minimalNumberOfPlanesInTrack planes), or \"Tight\" (reject all with more than a single cluster per plane and less than #m_minimalNumberOfPlanesInTrack planes)"}
	Track selection type:
Gaudi::Property< unsigned int >	m_minimalNumberOfPlanesInTrack {this, "minimalNumberOfPlanesInTrack", 2, "Minimal numer of planes required for track candidate"}
	Minimal numer of planes required for track candidate.
std::function< bool(const std::vector< const xAOD::AFPSiHitsCluster * > &)>	m_selectionFunction
SG::ReadHandleKey< xAOD::AFPSiHitsClusterContainer >	m_hitsClusterContainerKey {this, "AFPSiHitsClusterContainerKey", "AFPSiHitsClusterContainer", "Name of the container with clusters of hits from which tracks are to be reconstructed"}
	Name of the xAOD container with clusters to be used in track reconstruction.

Detailed Description

Tool for reconstructing AFPTrack parameters from track candidates.

Definition at line 40 of file AFPSiDLinRegTool.h.

Constructor & Destructor Documentation

AFPSiDLinRegTool()

AFPSiDLinRegTool::AFPSiDLinRegTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Definition at line 15 of file AFPSiDLinRegTool.cxx.

                                                               : 
  base_class( type, name, parent )
{
}

~AFPSiDLinRegTool()

virtual AFPSiDLinRegTool::~AFPSiDLinRegTool ( )

inlineoverridevirtual

Definition at line 47 of file AFPSiDLinRegTool.h.

{}

Member Function Documentation

areNeighbours()

bool AFPSiDLinRegTool::areNeighbours ( const xAOD::AFPSiHitsCluster * a, const xAOD::AFPSiHitsCluster * b ) const

private

Checks if clusters are neighbours Compares distance between them to m_allowedDistanceBetweenClustersInTrack.

Definition at line 76 of file AFPSiDLinRegTool.cxx.

{
    // All clusters should be in same station, so no need for checking
 
    const double xa = a->xLocal();
    const double ya = a->yLocal();
 
    const double xb = b->xLocal();
    const double yb = b->yLocal();
 
    const double dx = xa - xb;
    const double dy = ya - yb;
    const double maxDistanceSq = m_allowedDistanceBetweenClustersInTrack * m_allowedDistanceBetweenClustersInTrack;
    return dx * dx + dy * dy <= maxDistanceSq;
}

findClusterAroundElement()

std::vector< const xAOD::AFPSiHitsCluster * > AFPSiDLinRegTool::findClusterAroundElement ( std::list< const xAOD::AFPSiHitsCluster * > & toJoin, const xAOD::AFPSiHitsCluster * init ) const

private

Looks for cluster around init cluster.

• Loops over clusters in the list toJoin
• Checks if those clusters are neighbours of init cluster
• Adds neighbouring cluster to cluster vector and removes them from the list

Returns

Vector of clusters - track candiate

Definition at line 93 of file AFPSiDLinRegTool.cxx.

{
    // Push initial cluster
    std::vector<const xAOD::AFPSiHitsCluster*> track;
    track.push_back(init);
 
    std::vector<const xAOD::AFPSiHitsCluster*> newNeighbours;
 
    // Repeat while new neighbours are found
    do {
      newNeighbours.clear();
      for (auto&& b : toJoin) {
        bool isNew = false;
        for (auto&& a : track) {
          if (areNeighbours(a, b)) { isNew = true; }
        }
 
        if (isNew) {
          newNeighbours.push_back(b);
          track.push_back(b);
        }
      }
 
      // Clustered clusters are taken out from "clusters" container
      for (auto& t : newNeighbours) {
        toJoin.remove(t);
      }
 
    } while (!newNeighbours.empty());
 
    return track;
}

initialize()

StatusCode AFPSiDLinRegTool::initialize ( )

overridevirtual

Read parameters from job options and print tool configuration.

Definition at line 23 of file AFPSiDLinRegTool.cxx.

{
    if(m_trackSelection=="loose" || m_trackSelection=="Loose")
    {
        m_selectionFunction = [](const std::vector<const xAOD::AFPSiHitsCluster*>&) { return true; };
    }
    else if(m_trackSelection=="medium" || m_trackSelection=="Medium")
    {
        m_selectionFunction = [this](const std::vector<const xAOD::AFPSiHitsCluster*>& t) {
            std::vector<int> plane{0, 0, 0, 0};
 
            for (auto&& cluster : t) {
                const int p = cluster->pixelLayerID();
                plane[p]++;
            }
 
            auto HasAnyClusters = [](int n) { return n > 0; };
 
            return std::count_if(plane.begin(), plane.end(), HasAnyClusters) >= m_minimalNumberOfPlanesInTrack;
        };
    }
    else if(m_trackSelection=="tight" || m_trackSelection=="Tight")
    {
        m_selectionFunction = [this](const std::vector<const xAOD::AFPSiHitsCluster*>& t) {
            std::vector<int> plane{0, 0, 0, 0};
 
            for (auto&& cluster : t) {
                const int p = cluster->pixelLayerID();
                plane[p]++;
            }
 
            auto HasMultipleClusters = [](int n) { return n > 1; };
 
            if (std::any_of(plane.begin(), plane.end(), HasMultipleClusters)) { return false; }
 
            // Check number of planes (cluster/plane == 1)
            if (t.size() < m_minimalNumberOfPlanesInTrack) { return false; }
 
            return true;
        };
    }
    else
    {
        ATH_MSG_ERROR("unknown trackSelection "<<m_trackSelection<<", allowed values are \"Loose\", \"Medium\", or \"Tight\" ");
        return StatusCode::FAILURE;
    }
    
    CHECK( m_hitsClusterContainerKey.initialize() );
    
    return StatusCode::SUCCESS;
}

linearRegression()

std::pair< double, double > AFPSiDLinRegTool::linearRegression ( const std::vector< std::pair< double, double > > & YX ) const

private

Simple linear regression Used to calculate track postions and slopes.

Definition at line 127 of file AFPSiDLinRegTool.cxx.

{
    // here, "x" is Z axis and "y" is X or Y axis
    
    double meanx = 0, meany = 0;
    for (const auto& [y, x] : YX) {
        meany += y;
        meanx += x;
    }
    meanx /= YX.size();
    meany /= YX.size();
    
    double numerator = 0, denominator = 0;
    for (const auto& [y, x] : YX) {
        const double dy = y - meany;
        const double dx = x - meanx;
                
        numerator += dx * dy;
        denominator += dx * dx;
    }
    
    const double slope = numerator / denominator;
    const double position = meany - slope * meanx;
 
    return {position, slope};
}

outputContainerName()

const std::string & AFPSiDLinRegTool::outputContainerName ( ) const

inlineoverride

Definition at line 60 of file AFPSiDLinRegTool.h.

{return m_tracksContainerName;}

reconstructTracks()

StatusCode AFPSiDLinRegTool::reconstructTracks ( std::unique_ptr< xAOD::AFPTrackContainer > & outputContainer, const EventContext & ctx ) const

override

Reconstructs tracks properties from track candidates.

• Loops over all tracks candidates
• Calcutates and sets track properties

Definition at line 155 of file AFPSiDLinRegTool.cxx.

{
    SG::ReadHandle<xAOD::AFPSiHitsClusterContainer> clusters( m_hitsClusterContainerKey, ctx );
    if(!clusters.isValid())
    {
        // this is allowed, there might be no AFP data in the input
        return StatusCode::SUCCESS;
    }
    
    // Select clusters in given station
    std::list<const xAOD::AFPSiHitsCluster*> clustersInStation;
    std::copy_if(clusters->begin(), clusters->end(), std::back_inserter(clustersInStation),
                            [this](auto cluster) { return cluster->stationID() == m_stationID; });
 
    ATH_MSG_DEBUG("clusters in " << m_stationID << " size: " << clustersInStation.size());
 
 
    // Loop until all clusters are used
    while (!clustersInStation.empty())
    {
        // Take first element from the list...
        const auto *const initialCluster = clustersInStation.front();
        clustersInStation.pop_front();
 
        // ...and find other clusters around it
        const auto clusterOfClusters = findClusterAroundElement(clustersInStation, initialCluster);
 
        // If track candidate does not pass chosen selection, skip it
        if (!m_selectionFunction(clusterOfClusters)) {
            ATH_MSG_DEBUG("track candidate of size " << clusterOfClusters.size() << " did not pass selection.");
            continue;
        }
        
        auto *track = outputContainer->push_back(std::make_unique<xAOD::AFPTrack>());
 
        // Set stationID
        track->setStationID(m_stationID);
 
        // Add links to clusters
        for (const auto *const cluster : clusterOfClusters) {
            ElementLink<xAOD::AFPSiHitsClusterContainer> clusterLink;
            clusterLink.toContainedElement(*clusters, cluster);
            track->addCluster(clusterLink);
        }
 
        const int nClusters = track->clusters().size();
        
        if(nClusters>0)
        {
            track->setNClusters(nClusters);
        }
        else
        {
            ATH_MSG_DEBUG("track candidate has 0 clusters, erasing ");
            outputContainer->pop_back();
            continue;
        }
        
        // Fit the clusters with a line in X and Y direction along Z
        double x = 0.;
        double y = 0.;
        double xSlope = 0.;
        double ySlope = 0.;
        double chi2  = 0.;
 
        if (nClusters == 1) {
            x = (*(track->clusters().at(0)))->xLocal();
            y = (*(track->clusters().at(0)))->yLocal();
        } 
        else
        {           
            std::vector<std::pair<double, double>> XZ;
            std::vector<std::pair<double, double>> YZ;
 
            for (int i = 0; i < nClusters; i++) {
                const xAOD::AFPSiHitsCluster* cluster = *(track->clusters().at(i));
                                
                XZ.emplace_back(cluster->xLocal(), cluster->zLocal());
                YZ.emplace_back(cluster->yLocal(), cluster->zLocal());
            }
 
            auto linregx = linearRegression(XZ);
            auto linregy = linearRegression(YZ);
 
            std::tie(x, xSlope) = linregx;
            std::tie(y, ySlope) = linregy;
 
            for (int i = 0; i < nClusters; i++) {
                const xAOD::AFPSiHitsCluster* cluster = *(track->clusters().at(i));
 
                const double z = cluster->zLocal();
                const double ex = cluster->xLocalErr();
                const double ey = cluster->yLocalErr();
 
                const double dx = cluster->xLocal() - (x + xSlope * z);
                const double dy = cluster->yLocal() - (y + ySlope * z);
                                
                chi2 += dx * dx / (ex * ex);
                chi2 += dy * dy / (ey * ey);
            }
        }
 
        // Set track properties
        track->setChi2(chi2);
        track->setXLocal(x);
        track->setXSlope(xSlope);
        track->setYLocal(y);
        track->setYSlope(ySlope);
        track->setZLocal(0.); // because positions of x/y are calculated at z=0
        
        track->setAlgID(xAOD::AFPTrackRecoAlgID::linReg);
        
        std::vector<int> clustersPlane{0, 0, 0, 0};
        for (const auto& cl : track->clusters()) {
            ++clustersPlane[(*cl)->pixelLayerID()];
        }
        auto HasNoClusters = [](int n) { return n == 0; };
        track->setNHoles(std::count_if(clustersPlane.begin(), clustersPlane.end(), HasNoClusters));
        
 
        ATH_MSG_DEBUG("new track with " << track->clusters().size() << " clusters, x: " << track->xLocal()
                        << ", y: " << track->yLocal() << ", sx: " << track->xSlope()
                        << ", sy: " << track->ySlope() << ", chi2: " << track->chi2());
        for (auto&& cluster : track->clusters())
        {
            ATH_MSG_DEBUG('\t' << (*cluster)->xLocal() << " " << (*cluster)->yLocal() << " " << (*cluster)->zLocal());
        }
    }
    
    return StatusCode::SUCCESS;
}

Member Data Documentation

m_allowedDistanceBetweenClustersInTrack

Gaudi::Property<double> AFPSiDLinRegTool::m_allowedDistanceBetweenClustersInTrack {this, "allowedDistanceBetweenClustersInTrack", 0.5, "Maximum allowed distance between clusters to be considered coming from the same proton"}

private

Maximum allowed distance between clusters to be considered coming from the same proton.

Definition at line 70 of file AFPSiDLinRegTool.h.

{this, "allowedDistanceBetweenClustersInTrack", 0.5, "Maximum allowed distance between clusters to be considered coming from the same proton"};

m_hitsClusterContainerKey

SG::ReadHandleKey<xAOD::AFPSiHitsClusterContainer> AFPSiDLinRegTool::m_hitsClusterContainerKey {this, "AFPSiHitsClusterContainerKey", "AFPSiHitsClusterContainer", "Name of the container with clusters of hits from which tracks are to be reconstructed"}

private

Name of the xAOD container with clusters to be used in track reconstruction.

Definition at line 85 of file AFPSiDLinRegTool.h.

{this, "AFPSiHitsClusterContainerKey", "AFPSiHitsClusterContainer", "Name of the container with clusters of hits from which tracks are to be reconstructed"};

m_minimalNumberOfPlanesInTrack

Gaudi::Property<unsigned int> AFPSiDLinRegTool::m_minimalNumberOfPlanesInTrack {this, "minimalNumberOfPlanesInTrack", 2, "Minimal numer of planes required for track candidate"}

private

Minimal numer of planes required for track candidate.

Definition at line 79 of file AFPSiDLinRegTool.h.

{this, "minimalNumberOfPlanesInTrack", 2, "Minimal numer of planes required for track candidate"};

m_selectionFunction

std::function<bool(const std::vector<const xAOD::AFPSiHitsCluster*>&)> AFPSiDLinRegTool::m_selectionFunction

private

Definition at line 82 of file AFPSiDLinRegTool.h.

m_stationID

Gaudi::Property<int> AFPSiDLinRegTool::m_stationID {this, "stationID", 0, "ID number of station for which tracks should be reconstructed"}

private

AFP station ID for which tracks will be reconstructed.

Definition at line 67 of file AFPSiDLinRegTool.h.

{this, "stationID", 0, "ID number of station for which tracks should be reconstructed"};

m_tracksContainerName

Gaudi::Property<std::string> AFPSiDLinRegTool::m_tracksContainerName {this, "tracksContainerName", "AFPTrackContainer", "Name of the container in which tracks are saved"}

private

Name of the xAOD container to which tracks will be saved; actual saving is done in AFPSIDLocRecoTool.

Definition at line 64 of file AFPSiDLinRegTool.h.

{this, "tracksContainerName", "AFPTrackContainer", "Name of the container in which tracks are saved"};

m_trackSelection

Gaudi::Property<std::string> AFPSiDLinRegTool::m_trackSelection {this, "trackSelection", "Medium", "Track selection, allowed values are \"Loose\" (accept all track candidates), \"Medium\" (accept only tracks with clusters in at least #m_minimalNumberOfPlanesInTrack planes), or \"Tight\" (reject all with more than a single cluster per plane and less than #m_minimalNumberOfPlanesInTrack planes)"}

private

Track selection type:

• Loose: accept all track candidates
• Medium: accept only tracks with clusters in at least m_minimalNumberOfPlanesInTrack planes
• Tight: reject all with more than a single cluster per plane and less than m_minimalNumberOfPlanesInTrack planes

Definition at line 76 of file AFPSiDLinRegTool.h.

{this, "trackSelection", "Medium", "Track selection, allowed values are \"Loose\" (accept all track candidates), \"Medium\" (accept only tracks with clusters in at least #m_minimalNumberOfPlanesInTrack planes), or \"Tight\" (reject all with more than a single cluster per plane and less than #m_minimalNumberOfPlanesInTrack planes)"};

---

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

• AFPSiDLinRegTool.h
• AFPSiDLinRegTool.cxx