AFPSiDBasicKalmanTool Class Reference

Class reconstructing tracks using basic Kalman filter. More...

#include <AFPSiDBasicKalmanTool.h>

Inheritance diagram for AFPSiDBasicKalmanTool:

Collaboration diagram for AFPSiDBasicKalmanTool:

Public Member Functions
	AFPSiDBasicKalmanTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~AFPSiDBasicKalmanTool () override
virtual StatusCode	initialize () override
	Read parameters from job options and print tool configuration.
virtual StatusCode	finalize () override
	Does nothing.
StatusCode	reconstructTracks (std::unique_ptr< xAOD::AFPTrackContainer > &outputContainer, const EventContext &ctx) const override
	Does actual tracks reconstruction.
const std::string &	outputContainerName () const override
void	filterTrkCollection (std::list< AFPSiDBasicKalmanToolTrack > &reconstructedTracks) const
	Filters duplicate tracks from the list.
unsigned int	countSharedClusters (const AFPSiDBasicKalmanToolTrack &firstTrack, const AFPSiDBasicKalmanToolTrack &secondTrack) const
	Returns number of the same clusters used to reconstruct two tracks.
void	clearAllLayers (AFPLocRecoStationBasicObj &my_stationClusters) const
	clear all layers from clusters saved in #m_stationsClusters;

Private Member Functions
void	fillLayersWithClusters (AFPLocRecoStationBasicObj &my_stationClusters, SG::ReadHandle< xAOD::AFPSiHitsClusterContainer > &hitsClusterContainer) const
	Fills layers with clusters of hits, dividing them into stations and layers.
void	initMatrixFromVector (CLHEP::HepMatrix &matrix, const std::vector< float > &vec1D) const
	Method that initialises 2D matrix using values from the vector.
bool	checkMatrixAndVectorSize (const CLHEP::HepMatrix &matrix, const std::vector< float > &vec1D) const
	Returns true if vector size equals matrix rows times columns.
bool	areNeighbours (const xAOD::AFPSiHitsCluster *a, const xAOD::AFPSiHitsCluster *b, const double dist) const
	Checks if clusters are neighbours Compares distance between them to m_allowedDistanceBetweenClustersInSeed.
void	saveToXAOD (const AFPSiDBasicKalmanToolTrack &recoTrack, std::unique_ptr< xAOD::AFPTrackContainer > &containerToFill, SG::ReadHandle< xAOD::AFPSiHitsClusterContainer > &hitsClusterContainer) const
	Save reconstructed track to the xAOD container.

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.
CLHEP::HepMatrix	m_observationModel
	The observation model which maps the true state space into the observed space ( \(H_{k}\))
Gaudi::Property< std::vector< float > >	m_observationModelInit {this, "observationModel", {}, "vector used to initialise observation model matrix (2x4), the first four numbers correspond to the first row of the matrix"}
	A vector used to initialise m_observationModel matrix.
CLHEP::HepMatrix	m_observationNoise
	The observation noise matrix.
Gaudi::Property< std::vector< float > >	m_observationNoiseInit {this, "observationNoise", {}, "vector used to initialise observation noise matrix (2x2), the first two numbers correspond to the first row of the matrix"}
	A vector used to initialise m_observationNoise matrix.
CLHEP::HepMatrix	m_processNoiseCov
	The covariance matrix of process noise.
Gaudi::Property< std::vector< float > >	m_processNoiseCovInit {this, "processNoiseCov", {}, "A vector used to initialise process noise covariance matrix (4x4).The first 4 numbers correspond to the first row of the matrix."}
	A vector used to initialise m_processNoiseCov matrix.
CLHEP::HepMatrix	m_aposterioriCov
	A posteriori error covariance matrix (a measure of the estimated accuracy of the state estimate) ( \(P_{k|k}\))
Gaudi::Property< std::vector< float > >	m_aposterioriCovInit {this, "aposterioriCov", {}, "A vector used to initialise a posteriori covariance matrix (4x4). The first 4 numbers correspond to the first row of the matrix."}
	A vector used to initialise m_aposterioriCov matrix.
Gaudi::Property< int >	m_numberOfLayersInStation {this, "numberOfLayersInStations", 4, "The size of the vector sets number of stations. Each element defines number of pixel layers in the station."}
	Number of layers used for reconstruction in station If not set in job options 4 stations, each with 4 layers are created.
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.
Gaudi::Property< double >	m_maxAllowedDistance {this, "maxAllowedDistance", 10, "Maximal distance at which cluster can be joined to the track"}
	Maximal distance at which cluster can be joined to the track (Default = 100 - all clusters)
Gaudi::Property< unsigned int >	m_minClustersNumber {this, "minClustersNumber", 3, "Minimal number of clusters in track. If there are less clusters track is rejected"}
	Minimal number of clusters in track. If there are less clusters track is rejected (Default = 3)
Gaudi::Property< unsigned int >	m_maxSharedClusters {this, "maxSharedClusters", 2, "Maximal number of hits that two tracks can share. If they share more one is deleted."}
	Maximal number of hits that two tracks can share. If they share more one is deleted.
Gaudi::Property< float >	m_clusterMaxChi2 {this, "clusterMaxChi2", 3, "Maximal value of chi2 for which a cluster is added."}
	Maximal value of chi2 for which a cluster is added.
Gaudi::Property< float >	m_trackMaxChi2 {this, "trackMaxChi2", 3, "Maximal value of chi2 for the track."}
	Maximal value of chi2 for the track.
Gaudi::Property< double >	m_allowedDistanceBetweenClustersInSeed {this, "allowedDistanceBetweenClustersInSeed", 0.5, "Maximum allowed distance between clusters in a seed to be considered coming from the same proton; if the difference between clusters is 2 layers (3 layers), this distance is multiplied by 2 (3)"}
	Maximum allowed distance between clusters to be considered coming from the same proton.
Gaudi::Property< std::vector< std::pair< int, int > > >	m_layersForSeeds {this, "layersForSeeds", {{0,1}}, "Pairs of layers that are used to create seeds."}
	Vector of pairs of layers. These pairs will be used to make seeds.
ToolHandle< GenericMonitoringTool >	m_monTool {this, "MonTool", "", "Monitoring tool"}
	Monitoring.

Detailed Description

Class reconstructing tracks using basic Kalman filter.

The idea of the reconstruction is presented in the talk https://indico.cern.ch/event/275484/contributions/1618277/attachments/499062/689421/mdyndal_2013-10-15_AFP_Gen.pdf

Definition at line 49 of file AFPSiDBasicKalmanTool.h.

Constructor & Destructor Documentation

AFPSiDBasicKalmanTool()

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

Definition at line 29 of file AFPSiDBasicKalmanTool.cxx.

                                                                         : 
  base_class( type, name, parent )
{
}

~AFPSiDBasicKalmanTool()

virtual AFPSiDBasicKalmanTool::~AFPSiDBasicKalmanTool ( )

inlineoverridevirtual

Definition at line 57 of file AFPSiDBasicKalmanTool.h.

{}

Member Function Documentation

areNeighbours()

bool AFPSiDBasicKalmanTool::areNeighbours ( const xAOD::AFPSiHitsCluster * a, const xAOD::AFPSiHitsCluster * b, const double dist ) const

private

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

Definition at line 215 of file AFPSiDBasicKalmanTool.cxx.

{
  const double dx = a->xLocal() - b->xLocal();
  const double dy = a->yLocal() - b->yLocal();
  const double maxDistanceSq = allowedDistanceBetweenClustersInSeed * allowedDistanceBetweenClustersInSeed;
  
  return dx * dx + dy * dy <= maxDistanceSq;
}

checkMatrixAndVectorSize()

bool AFPSiDBasicKalmanTool::checkMatrixAndVectorSize ( const CLHEP::HepMatrix & matrix, const std::vector< float > & vec1D ) const

inlineprivate

Returns true if vector size equals matrix rows times columns.

Definition at line 204 of file AFPSiDBasicKalmanTool.h.

  {return ((int)vec1D.size()) == matrix.num_row()*matrix.num_col();}

clearAllLayers()

void AFPSiDBasicKalmanTool::clearAllLayers ( AFPLocRecoStationBasicObj & my_stationClusters ) const

inline

clear all layers from clusters saved in #m_stationsClusters;

Definition at line 92 of file AFPSiDBasicKalmanTool.h.

  {my_stationClusters.clear();}

countSharedClusters()

unsigned int AFPSiDBasicKalmanTool::countSharedClusters	(	const AFPSiDBasicKalmanToolTrack &	firstTrack,
		const AFPSiDBasicKalmanToolTrack &	secondTrack ) const

Returns number of the same clusters used to reconstruct two tracks.

Definition at line 410 of file AFPSiDBasicKalmanTool.cxx.

{
  unsigned int sharedClustersN = 0;
 
  for (const xAOD::AFPSiHitsCluster* firstCluster : firstTrack.clustersInTrack())
    for (const xAOD::AFPSiHitsCluster* secondCluster : secondTrack.clustersInTrack())
      if (firstCluster == secondCluster) {
        ++sharedClustersN;
        break;
      }
        
  return sharedClustersN;
}

fillLayersWithClusters()

void AFPSiDBasicKalmanTool::fillLayersWithClusters ( AFPLocRecoStationBasicObj & my_stationClusters, SG::ReadHandle< xAOD::AFPSiHitsClusterContainer > & hitsClusterContainer ) const

private

Fills layers with clusters of hits, dividing them into stations and layers.

Definition at line 199 of file AFPSiDBasicKalmanTool.cxx.

{
  // retrieve clusters
  try {
    // fill layers with clusters
    for (const xAOD::AFPSiHitsCluster* theCluster : *hitsClusterContainer)
      if (theCluster->stationID() == m_stationID) // check if cluster is from the correct station
        my_stationClusters.clustersInLayer(theCluster->pixelLayerID()).push_back(theCluster);
  }
  catch (const std::out_of_range& outOfRange) {
    ATH_MSG_WARNING("Cluster with station or pixel ID outside expected range. Aborting track reconstruction.");
    clearAllLayers(my_stationClusters);
  }
 
  }

filterTrkCollection()

void AFPSiDBasicKalmanTool::filterTrkCollection

(

std::list< AFPSiDBasicKalmanToolTrack > &

reconstructedTracks

)

const

Filters duplicate tracks from the list.

The tracks are considered duplicates if more than m_maxSharedClusters clusters are the same in both tracks. In such situation track quality is calculated according to the formula \(q = N_{clusters} + ((\chi^2_{trk, max} - \chi^2{trk})/(\chi^2_{trk, max} + 1))\). The track with smaller value of \(q\) is deleted.

Definition at line 350 of file AFPSiDBasicKalmanTool.cxx.

{
  //filtering tracking collection using shared hits + quality requirement
  std::list<AFPSiDBasicKalmanToolTrack>::iterator mainIterator = tracksList.begin();
  while (mainIterator != tracksList.end()) {
 
    bool deletedMain = false;
    // start comparing from the next object to the one currently testing
    std::list<AFPSiDBasicKalmanToolTrack>::iterator compareIterator = mainIterator;
    ++compareIterator;
    while (compareIterator != tracksList.end())
    {
      const unsigned int sharedClusters = countSharedClusters(*mainIterator, *compareIterator);
      bool removeMain = false;
      bool removeCompare = false;
      
      if(sharedClusters > m_maxSharedClusters)
      {
        // calculate quality of the tracks preferring tracks with more clusters
        const AFPSiDBasicKalmanToolTrack& mainTrk = (*mainIterator);
        const double mainTrkQuality = mainTrk.chi2Smooth().size() + ((m_trackMaxChi2 - mainTrk.trkChi2NDFSmooth()) / (m_trackMaxChi2 + 1.));
        AFPSiDBasicKalmanToolTrack& compareTrk = (*compareIterator);
        const double compareTrkQuality = compareTrk.chi2Smooth().size() + ((m_trackMaxChi2 - compareTrk.trkChi2NDFSmooth()) / (m_trackMaxChi2 + 1.));
 
        if(mainTrkQuality >= compareTrkQuality)
        {
          removeCompare = true;
        }
        else
        {
          removeMain = true;
        }
      }
      else if(sharedClusters == mainIterator->clustersInTrack().size() && sharedClusters == compareIterator->clustersInTrack().size())
      {
        // these are the same tracks
        removeCompare = true;
      }
      
      if (removeCompare)
      {
        tracksList.erase(compareIterator++);
        continue;
      }
      else if(removeMain)
      {
        tracksList.erase(mainIterator++);
        deletedMain = true;
        break;
      }
 
      ++compareIterator;
    } // end while (compareIterator)
 
    // go to the next object only if the main was not deleted, because iterator was already moved when deleting
    if (!deletedMain) ++mainIterator;
    
  } // end mainIterator
}

finalize()

StatusCode AFPSiDBasicKalmanTool::finalize ( )

overridevirtual

Does nothing.

Definition at line 194 of file AFPSiDBasicKalmanTool.cxx.

{
  return StatusCode::SUCCESS;
}

initialize()

StatusCode AFPSiDBasicKalmanTool::initialize ( )

overridevirtual

Read parameters from job options and print tool configuration.

Definition at line 36 of file AFPSiDBasicKalmanTool.cxx.

{
  CHECK( m_hitsClusterContainerKey.initialize() );
  
  // monitoring
  if (!(m_monTool.name().empty())) {
    CHECK( m_monTool.retrieve() );
    ATH_MSG_DEBUG("m_monTool name: " << m_monTool);
  }
  
  // === Kalman matrices initialization ===
 
  // --- initialise observation model matrix ---
  m_observationModel = CLHEP::HepMatrix(2, 4, 0);
  // if proper m_observationModelInit is available use it
  if (checkMatrixAndVectorSize(m_observationModel, m_observationModelInit)) {
    initMatrixFromVector (m_observationModel, m_observationModelInit);
  }
  else {
    // otherwise use default unit transformation
    m_observationModel[0][0] = 1.;
    m_observationModel[1][2] = 1.;
  }
  ATH_MSG_DEBUG("Observation model matrix (Hk) is initialised to: "<<m_observationModel);
 
  // --- set observation noise matrix ---
  m_observationNoise = CLHEP::HepMatrix(2, 2, 0);
  if (checkMatrixAndVectorSize(m_observationNoise, m_observationNoiseInit)) { 
    // use matrix from job options if set
    initMatrixFromVector(m_observationNoise, m_observationNoiseInit);
  }
  else {
    // if matrix is not initialised from the job options use pixel sizes
    const double pixelSizeX = 0.05;
    const double pixelSizeY = 0.25;
    m_observationNoise[0][0] = pixelSizeX*pixelSizeX;
    m_observationNoise[1][1] = pixelSizeY*pixelSizeY;
  }
  ATH_MSG_DEBUG("Observation noise  matrix (Vk) is initialised to: "<<m_observationNoise);
 
  // --- set covariance matrix of the process noise
  m_processNoiseCov = CLHEP::HepMatrix(4, 4, 0); // initialise with default values
  if (checkMatrixAndVectorSize(m_processNoiseCov, m_processNoiseCovInit)) {
    // use matrix from job options if set
    initMatrixFromVector(m_processNoiseCov, m_processNoiseCovInit);
  }
  ATH_MSG_DEBUG("Process noise covariance matrix (Qk) is initialised to: "<<m_processNoiseCov);
 
 
  // --- set initial value of the a posteriori error covariance matrix ---
  m_aposterioriCov = CLHEP::HepMatrix(4, 4, 0);
  if (checkMatrixAndVectorSize(m_aposterioriCov, m_aposterioriCovInit)) {
    // use matrix from job options if set
    initMatrixFromVector(m_aposterioriCov, m_aposterioriCovInit);
  }
  else {
    // set default matrix if not defined in job options
    const float planesZDist = 9.;
 
    const float pixelSizeX = 0.05;
    m_aposterioriCov[0][0] = pixelSizeX * pixelSizeX / 3.;
    m_aposterioriCov[1][1] = pixelSizeX * pixelSizeX / (planesZDist*planesZDist*3.);
 
    const float pixelSizeY = 0.25;
    m_aposterioriCov[2][2] = pixelSizeY * pixelSizeY / 3.;
    m_aposterioriCov[3][3] = pixelSizeY * pixelSizeY / (planesZDist*planesZDist*3.);
  }
  ATH_MSG_DEBUG("A posteriori error covariance matrix (Pkk) is initialised to: "<<m_aposterioriCov);
 
 
  // print information about initialised layers and stations
  if (m_numberOfLayersInStation >= 2)
  {
    ATH_MSG_DEBUG("Station with ID="<<m_stationID <<" will have "<<m_numberOfLayersInStation<<" layers.");
  }
  else
  {
    ATH_MSG_ERROR("Impossible to reconstruct tracks with less than 2 layers in station, but configured to run with "<<m_numberOfLayersInStation<<".");
    return StatusCode::FAILURE;
  }
  
  
  if(m_layersForSeeds.size()==0)
  {
    ATH_MSG_ERROR("Impossible to make seeds when length of m_layersForSeeds is 0 ");
    return StatusCode::FAILURE;
  }
  
  for(auto lfs = m_layersForSeeds.begin(); lfs != m_layersForSeeds.end(); ) 
  {
    if(lfs->first == lfs->second)
    {
      ATH_MSG_WARNING("Both layer IDs in m_layersForSeeds are equal to "<<lfs->first<<", removing this pair of layer IDs");
      lfs=m_layersForSeeds.erase(lfs);
    }
    else if(lfs->first >= m_numberOfLayersInStation || lfs->second >= m_numberOfLayersInStation || lfs->first < 0 || lfs->second < 0)
    {
      ATH_MSG_WARNING("First layer ID is "<<lfs->first<<", second layer ID is "<<lfs->second<<", while number of layers is "<<m_numberOfLayersInStation<<", removing this pair");
      lfs=m_layersForSeeds.erase(lfs);
    }
    else
    {
      if(lfs->first > lfs->second)
      {
        ATH_MSG_INFO("The first layer ID for seeds ("<<lfs->first<<") is higher than the second layer ID ("<<lfs->second<<"), swapping");
        int tmp=lfs->first;
        lfs->first=lfs->second;
        lfs->second=tmp;
      }
      
      ++lfs;
    }
  }
  
  if(m_layersForSeeds.size()>=2)
  {
    std::sort( m_layersForSeeds.begin(), m_layersForSeeds.end() );
    auto lfs1 = m_layersForSeeds.begin();
    auto lfs2 = m_layersForSeeds.begin()+1;
    for(;lfs2!=m_layersForSeeds.end();)
    {
      if(*lfs1==*lfs2)
      {
        ATH_MSG_WARNING("Found duplicity for {"<<lfs2->first<<","<<lfs2->second<<"}, removing the duplicity");
        lfs2=m_layersForSeeds.erase(lfs2);
      }
      else
      {
        ++lfs1;
        ++lfs2;
      }
    }
  }
  
  if(m_layersForSeeds.size()==0)
  {
    ATH_MSG_ERROR("Nothing is left in m_layersForSeeds after cleaning, please fix the setup");
    return StatusCode::FAILURE;
  }
  
  std::string stringLayersForSeeds="{";
  for(auto lfs = m_layersForSeeds.begin(); lfs != m_layersForSeeds.end(); ++lfs)
  {
    stringLayersForSeeds+="{"+std::to_string(lfs->first)+","+std::to_string(lfs->second)+"},";
  }
  stringLayersForSeeds.pop_back();
  ATH_MSG_DEBUG("Pairs of layer IDs that will make track seeds = "<<stringLayersForSeeds<<"}");
  
  
  // print information about remaining parameters
  ATH_MSG_DEBUG("Maximal distance at which cluster can be joined to the track m_maxAllowedDistance = "<<m_maxAllowedDistance);
  ATH_MSG_DEBUG("Minimal number of clusters in track. If there are less clusters track is rejected m_minClustersNumber = "<<m_minClustersNumber);
  ATH_MSG_DEBUG("Maximal chi2 of cluster to be added to track = "<<m_clusterMaxChi2);
  ATH_MSG_DEBUG("Maximal chi2 of the track = "<<m_trackMaxChi2);
 
  return StatusCode::SUCCESS;
}

initMatrixFromVector()

void AFPSiDBasicKalmanTool::initMatrixFromVector ( CLHEP::HepMatrix & matrix, const std::vector< float > & vec1D ) const

private

Method that initialises 2D matrix using values from the vector.

The method checks if the matrix size agrees with the vector size (N_columns*N_rows = N_vector). If the sizes are incompatible the matrix is unchanged.

Parameters

[out]	the	matrix to be initialised
[in]	the	vector with values to be copied to the matrix

Definition at line 424 of file AFPSiDBasicKalmanTool.cxx.

{
  const int rowsN = matrix.num_row();
  const int columnsN = matrix.num_col();
 
  // check if size of matrix and vector are compatible
  if ( ((int)vec1D.size()) == rowsN*columnsN) { 
    // if sizes are compatible initialise matrix
    for (int rowID = 0; rowID < rowsN; rowID++)
      for (int columnID = 0; columnID < columnsN; columnID++)
        matrix[rowID][columnID] = vec1D[rowID*columnsN + columnID];
  }
  else {
    // if sizes are incompatible print warning message and do nothing
    std::stringstream warningMessage;
    warningMessage<<"Matrix size ("<<rowsN<<"x"<<columnsN
                  <<" = "<<rowsN*columnsN<<") is not compatible with vector size: "
                  <<vec1D.size()<<".";
    warningMessage<<"Matrix will not be initialised. The vector contains following numbers: ";
    for (const float number : vec1D)
      warningMessage<<number<<" ";
 
    ATH_MSG_WARNING (warningMessage.str());
  }
}

outputContainerName()

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

inlineoverride

Definition at line 76 of file AFPSiDBasicKalmanTool.h.

{return m_tracksContainerName;}

reconstructTracks()

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

override

Does actual tracks reconstruction.

1. Reads clusters from the xAOD container.
2. Creates seeds by making all combinations of clusters in the first and second planes.
3. For each seed all remaining layers are checked for clusters that fit the track. If the cluster is found it is added to the track if not a number of holes (xAOD::AFPTrack::m_holes) is incremented.
4. If the track has more clusters than m_minClustersNumber a smoothing algorithm is run on it and added to the output list.
5. The output list of tracks if filtered for duplicates using AFPSiDBasicKalmanTool::filterTrkCollection().
6. The output list is saved to xAOD containers and objects.

Definition at line 224 of file AFPSiDBasicKalmanTool.cxx.

{
  SG::ReadHandle<xAOD::AFPSiHitsClusterContainer> hitsClusterContainer( m_hitsClusterContainerKey, ctx );
  if(!hitsClusterContainer.isValid())
  {
      // this is allowed, there might be no AFP data in the input
      return StatusCode::SUCCESS;
  }
  
  
  using LayersIter_t = std::vector<std::vector<const xAOD::AFPSiHitsCluster *>>::const_iterator;
 
  // prepare list for storing temporary reconstructed tracks
  std::list<AFPSiDBasicKalmanToolTrack> reconstructedTracks;
 
  AFPLocRecoStationBasicObj my_stationClusters;
  
  // the track reconstruction will seg fault if there are less than 2 layers (seed cannot be created)
  my_stationClusters.setNumberOfLayers(m_numberOfLayersInStation);
 
 
  clearAllLayers(my_stationClusters);
  fillLayersWithClusters(my_stationClusters, hitsClusterContainer);
 
  // ===== do tracks reconstruction =====
  // start with making seeds by combining all hits from the first and second layer IDs
  
  for(auto layersForSeeds = m_layersForSeeds.begin(); layersForSeeds != m_layersForSeeds.end(); ++layersForSeeds)
  {
    const LayersIter_t layersEnd = my_stationClusters.layers().end();
    const LayersIter_t layersBegin = my_stationClusters.layers().begin();
    
    // make all combinations between first and second layer ID
    LayersIter_t firstLayer = layersBegin+layersForSeeds->first;
    LayersIter_t secondLayer = layersBegin+layersForSeeds->second;
 
    for (const xAOD::AFPSiHitsCluster* firstCluster : *firstLayer)
    {
      for (const xAOD::AFPSiHitsCluster* secondCluster : *secondLayer)
      {
        // skip if clusters are too far, one "m_allowedDistanceBetweenClustersInSeed" per 1 layer difference
        if(!areNeighbours(firstCluster, secondCluster, m_allowedDistanceBetweenClustersInSeed*(layersForSeeds->second-layersForSeeds->first)))
        {
          continue;
        }
        
        // make the seed
        reconstructedTracks.emplace_back(firstCluster, secondCluster, m_observationModel, m_observationNoise, m_aposterioriCov);
        AFPSiDBasicKalmanToolTrack& theTrack = reconstructedTracks.back();
 
        // loop over remaining layers
        for (LayersIter_t remainingLayersIT = layersBegin; remainingLayersIT != layersEnd; ++remainingLayersIT)
        {
          if(remainingLayersIT==firstLayer || remainingLayersIT==secondLayer) continue;
        
          const xAOD::AFPSiHitsCluster* closestCluster = theTrack.findNearestCluster(*remainingLayersIT, m_maxAllowedDistance);
          if (closestCluster != nullptr) // if there is a cluster near the track add it to the track
            theTrack.addCluster(closestCluster, m_clusterMaxChi2);
          else                        // if there is no cluster add a hole (missing cluster in the layer)
            theTrack.addHole();
        }
 
        // process the track only if there are enough clusters, remove the ones with less tracks 
        if (theTrack.clustersInTrack().size() >= m_minClustersNumber)
          theTrack.smooth();
        else 
          reconstructedTracks.pop_back();
        
      } // end of loop over seeds (all combinations between the first and second layer
    }
  }
  
  filterTrkCollection(reconstructedTracks);
 
  // === Save result to xAOD container ===
  for (const AFPSiDBasicKalmanToolTrack& track : reconstructedTracks)
  {
    saveToXAOD(track, outputContainer, hitsClusterContainer);
  }
  
  // monitoring
  auto trkStationID = Monitored::Collection("TrkStationID",*outputContainer, &xAOD::AFPTrack::stationID);
  auto trkXLocal    = Monitored::Collection("TrkXLocal",   *outputContainer, &xAOD::AFPTrack::xLocal);
  auto trkYLocal    = Monitored::Collection("TrkYLocal",   *outputContainer, &xAOD::AFPTrack::yLocal);
  auto trkZLocal    = Monitored::Collection("TrkZLocal",   *outputContainer, &xAOD::AFPTrack::zLocal);
  auto trkXSlope    = Monitored::Collection("TrkXSlope",   *outputContainer, &xAOD::AFPTrack::xSlope);
  auto trkYSlope    = Monitored::Collection("TrkYSlope",   *outputContainer, &xAOD::AFPTrack::ySlope);
  auto trkNClusters = Monitored::Collection("TrkNClusters",*outputContainer, &xAOD::AFPTrack::nClusters);
  auto trkNHoles    = Monitored::Collection("TrkNHoles",   *outputContainer, &xAOD::AFPTrack::nHoles);
  auto trkChi2      = Monitored::Collection("TrkChi2",     *outputContainer, &xAOD::AFPTrack::chi2);
  int statID = m_stationID;
  auto trkMask    = Monitored::Collection("TrkMask",*outputContainer, [statID](const xAOD::AFPTrack* t){return t->stationID()==statID;});
  Monitored::Group(m_monTool, trkStationID, trkXLocal, trkYLocal, trkZLocal, trkXSlope, trkYSlope, trkNClusters, trkNHoles, trkChi2, trkMask);
  
  return StatusCode::SUCCESS;
}

saveToXAOD()

void AFPSiDBasicKalmanTool::saveToXAOD ( const AFPSiDBasicKalmanToolTrack & recoTrack, std::unique_ptr< xAOD::AFPTrackContainer > & containerToFill, SG::ReadHandle< xAOD::AFPSiHitsClusterContainer > & hitsClusterContainer ) const

private

Save reconstructed track to the xAOD container.

Definition at line 321 of file AFPSiDBasicKalmanTool.cxx.

{
  auto *track = containerToFill->push_back(std::make_unique<xAOD::AFPTrack>());
  
  const xAOD::AFPSiHitsCluster* firstCluster = recoTrack.clustersInTrack().front();
  const CLHEP::HepVector& firstPoint = recoTrack.positionAndSlopeSmooth().back(); // reading from smoothed collection which is done in reversed order
  
  track->setStationID(firstCluster->stationID());
  track->setXLocal(firstPoint[0]);
  track->setYLocal(firstPoint[2]);
  track->setZLocal(firstCluster->zLocal());
  track->setXSlope(firstPoint[1]);
  track->setYSlope(firstPoint[3]);
  track->setNClusters(recoTrack.clustersInTrack().size());
  track->setNHoles(recoTrack.holes());
  track->setChi2(recoTrack.trkChi2NDFSmooth());
  track->setAlgID(xAOD::AFPTrackRecoAlgID::basicKalman);
 
  // add links to clusters
  ATH_MSG_DEBUG("Track position: (x="<<track->xLocal()<<", y="<<track->yLocal()<<", z="<<track->zLocal()<<")   slope: (dx="<<track->xSlope()<<", dy="<<track->ySlope()<<")   chi2="<<track->chi2()<<", nHoles="<<track->nHoles()<<", nClusters="<<track->nClusters());
  for (const xAOD::AFPSiHitsCluster* theCluster : recoTrack.clustersInTrack()) {
    ElementLink< xAOD::AFPSiHitsClusterContainer > clusterLink;
    clusterLink.toContainedElement(*hitsClusterContainer, theCluster);
    track->addCluster(clusterLink);
 
    ATH_MSG_DEBUG("cluster position: (x="<<theCluster->xLocal()<<", y="<<theCluster->yLocal()<<", z="<<theCluster->zLocal()<<")");
  }
}

Member Data Documentation

m_allowedDistanceBetweenClustersInSeed

Gaudi::Property<double> AFPSiDBasicKalmanTool::m_allowedDistanceBetweenClustersInSeed {this, "allowedDistanceBetweenClustersInSeed", 0.5, "Maximum allowed distance between clusters in a seed to be considered coming from the same proton; if the difference between clusters is 2 layers (3 layers), this distance is multiplied by 2 (3)"}

private

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

Definition at line 185 of file AFPSiDBasicKalmanTool.h.

{this, "allowedDistanceBetweenClustersInSeed", 0.5, "Maximum allowed distance between clusters in a seed to be considered coming from the same proton; if the difference between clusters is 2 layers (3 layers), this distance is multiplied by 2 (3)"};

m_aposterioriCov

CLHEP::HepMatrix AFPSiDBasicKalmanTool::m_aposterioriCov

private

A posteriori error covariance matrix (a measure of the estimated accuracy of the state estimate) ( \(P_{k|k}\))

This is 4x4 matrix. If the matrix is not defined in job options it set to 0.

Definition at line 154 of file AFPSiDBasicKalmanTool.h.

m_aposterioriCovInit

Gaudi::Property<std::vector<float> > AFPSiDBasicKalmanTool::m_aposterioriCovInit {this, "aposterioriCov", {}, "A vector used to initialise a posteriori covariance matrix (4x4). The first 4 numbers correspond to the first row of the matrix."}

private

A vector used to initialise m_aposterioriCov matrix.

The first 4 numbers correspond to the first row of the matrix.

Definition at line 159 of file AFPSiDBasicKalmanTool.h.

{this, "aposterioriCov", {}, "A vector used to initialise a posteriori covariance matrix (4x4). The first 4 numbers correspond to the first row of the matrix."};

m_clusterMaxChi2

Gaudi::Property<float> AFPSiDBasicKalmanTool::m_clusterMaxChi2 {this, "clusterMaxChi2", 3, "Maximal value of chi2 for which a cluster is added."}

private

Maximal value of chi2 for which a cluster is added.

Definition at line 179 of file AFPSiDBasicKalmanTool.h.

{this, "clusterMaxChi2", 3, "Maximal value of chi2 for which a cluster is added."};

m_hitsClusterContainerKey

SG::ReadHandleKey<xAOD::AFPSiHitsClusterContainer> AFPSiDBasicKalmanTool::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 167 of file AFPSiDBasicKalmanTool.h.

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

m_layersForSeeds

Gaudi::Property<std::vector<std::pair<int,int> > > AFPSiDBasicKalmanTool::m_layersForSeeds {this, "layersForSeeds", {{0,1}}, "Pairs of layers that are used to create seeds."}

private

Vector of pairs of layers. These pairs will be used to make seeds.

Definition at line 188 of file AFPSiDBasicKalmanTool.h.

{this, "layersForSeeds", {{0,1}}, "Pairs of layers that are used to create seeds."};

m_maxAllowedDistance

Gaudi::Property<double> AFPSiDBasicKalmanTool::m_maxAllowedDistance {this, "maxAllowedDistance", 10, "Maximal distance at which cluster can be joined to the track"}

private

Maximal distance at which cluster can be joined to the track (Default = 100 - all clusters)

Definition at line 170 of file AFPSiDBasicKalmanTool.h.

{this, "maxAllowedDistance", 10, "Maximal distance at which cluster can be joined to the track"};

m_maxSharedClusters

Gaudi::Property<unsigned int> AFPSiDBasicKalmanTool::m_maxSharedClusters {this, "maxSharedClusters", 2, "Maximal number of hits that two tracks can share. If they share more one is deleted."}

private

Maximal number of hits that two tracks can share. If they share more one is deleted.

Definition at line 176 of file AFPSiDBasicKalmanTool.h.

{this, "maxSharedClusters", 2, "Maximal number of hits that two tracks can share. If they share more one is deleted."};

m_minClustersNumber

Gaudi::Property<unsigned int> AFPSiDBasicKalmanTool::m_minClustersNumber {this, "minClustersNumber", 3, "Minimal number of clusters in track. If there are less clusters track is rejected"}

private

Minimal number of clusters in track. If there are less clusters track is rejected (Default = 3)

Definition at line 173 of file AFPSiDBasicKalmanTool.h.

{this, "minClustersNumber", 3, "Minimal number of clusters in track. If there are less clusters track is rejected"};

m_monTool

ToolHandle<GenericMonitoringTool> AFPSiDBasicKalmanTool::m_monTool {this, "MonTool", "", "Monitoring tool"}

private

Monitoring.

Definition at line 215 of file AFPSiDBasicKalmanTool.h.

{this, "MonTool", "", "Monitoring tool"};

m_numberOfLayersInStation

Gaudi::Property<int> AFPSiDBasicKalmanTool::m_numberOfLayersInStation {this, "numberOfLayersInStations", 4, "The size of the vector sets number of stations. Each element defines number of pixel layers in the station."}

private

Number of layers used for reconstruction in station If not set in job options 4 stations, each with 4 layers are created.

Definition at line 164 of file AFPSiDBasicKalmanTool.h.

{this, "numberOfLayersInStations", 4, "The size of the vector sets number of stations. Each element defines number of pixel layers in the station."};

m_observationModel

CLHEP::HepMatrix AFPSiDBasicKalmanTool::m_observationModel

private

The observation model which maps the true state space into the observed space ( \(H_{k}\))

This is 2x4 matrix, where dimension 2 comes from two position variables (x, y) and dimension 4 comes from position and slope in each of the two directions. \(z_{k} = H_{k} x_{k} + v_{k}\)

If no proper observationModel array is defined in python configuration the default unit transformation is used - X and Y position are simply copied.

Definition at line 114 of file AFPSiDBasicKalmanTool.h.

m_observationModelInit

Gaudi::Property<std::vector<float> > AFPSiDBasicKalmanTool::m_observationModelInit {this, "observationModel", {}, "vector used to initialise observation model matrix (2x4), the first four numbers correspond to the first row of the matrix"}

private

A vector used to initialise m_observationModel matrix.

The first four numbers correspond to the first row of the matrix.

Definition at line 119 of file AFPSiDBasicKalmanTool.h.

{this, "observationModel", {}, "vector used to initialise observation model matrix (2x4), the first four numbers correspond to the first row of the matrix"};

m_observationNoise

CLHEP::HepMatrix AFPSiDBasicKalmanTool::m_observationNoise

private

The observation noise matrix.

( \(v_{k}\))

This is 2x2 matrix In standard Kalman it is assumed to be zero mean Gaussian white noise with covariance specified by the matrix. \(z_{k} = H_{k} x_{k} + v_{k}\)

If the matrix is not defined in job options it set to be diagonal matrix with squared sizes of pixel.

Definition at line 130 of file AFPSiDBasicKalmanTool.h.

m_observationNoiseInit

Gaudi::Property<std::vector<float> > AFPSiDBasicKalmanTool::m_observationNoiseInit {this, "observationNoise", {}, "vector used to initialise observation noise matrix (2x2), the first two numbers correspond to the first row of the matrix"}

private

A vector used to initialise m_observationNoise matrix.

The first two numbers correspond to the first row of the matrix.

Definition at line 135 of file AFPSiDBasicKalmanTool.h.

{this, "observationNoise", {}, "vector used to initialise observation noise matrix (2x2), the first two numbers correspond to the first row of the matrix"};

m_processNoiseCov

CLHEP::HepMatrix AFPSiDBasicKalmanTool::m_processNoiseCov

private

The covariance matrix of process noise.

( \(Q_{k}\))

This is 4x4 matrix. If the matrix is not defined in job options it set to 0.

Definition at line 142 of file AFPSiDBasicKalmanTool.h.

m_processNoiseCovInit

Gaudi::Property<std::vector<float> > AFPSiDBasicKalmanTool::m_processNoiseCovInit {this, "processNoiseCov", {}, "A vector used to initialise process noise covariance matrix (4x4).The first 4 numbers correspond to the first row of the matrix."}

private

A vector used to initialise m_processNoiseCov matrix.

The first 4 numbers correspond to the first row of the matrix.

Definition at line 147 of file AFPSiDBasicKalmanTool.h.

{this, "processNoiseCov", {}, "A vector used to initialise process noise covariance matrix (4x4).The first 4 numbers correspond to the first row of the matrix."};

m_stationID

Gaudi::Property<int> AFPSiDBasicKalmanTool::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 102 of file AFPSiDBasicKalmanTool.h.

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

m_trackMaxChi2

Gaudi::Property<float> AFPSiDBasicKalmanTool::m_trackMaxChi2 {this, "trackMaxChi2", 3, "Maximal value of chi2 for the track."}

private

Maximal value of chi2 for the track.

Definition at line 182 of file AFPSiDBasicKalmanTool.h.

{this, "trackMaxChi2", 3, "Maximal value of chi2 for the track."};

m_tracksContainerName

Gaudi::Property<std::string> AFPSiDBasicKalmanTool::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 99 of file AFPSiDBasicKalmanTool.h.

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

---

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

• AFPSiDBasicKalmanTool.h
• AFPSiDBasicKalmanTool.cxx