Tracker.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
 
#ifndef O2_MID_TRACKER_H
#define O2_MID_TRACKER_H
 
#include <vector>
#include <unordered_set>
#include <gsl/gsl>
#include "DataFormatsMID/Cluster.h"
#include "DataFormatsMID/ROFRecord.h"
#include "DataFormatsMID/Track.h"
#include "MIDBase/GeometryTransformer.h"
 
namespace o2
{
namespace mid
{
class Tracker
{
 public:
  Tracker(const GeometryTransformer& geoTrans);
 
  inline float getImpactParamCut() const { return mImpactParamCut; }
  inline float getSigmaCut() const { return mSigmaCut; }
 
  void process(gsl::span<const Cluster> clusters, bool accumulate = false);
  void process(gsl::span<const Cluster> clusters, gsl::span<const ROFRecord> rofRecords);
  bool init(bool keepAll = false);
 
  const std::vector<Track>& getTracks() { return mTracks; }
 
  const std::vector<Cluster>& getClusters() { return mClusters; }
 
  const std::vector<ROFRecord>& getTrackROFRecords() { return mTrackROFRecords; }
 
  const std::vector<ROFRecord>& getClusterROFRecords() { return mClusterROFRecords; }
 
 private:
  void processSide(bool isRight, bool isInward);
  void tryAddTrack(const Track& track);
  void followTrackKeepAll(Track& track, bool isRight, bool isInward);
  bool findAllClusters(const Track& track, bool isRight, int chamber, int firstRPC, int lastRPC, int nextChamber,
                       std::unordered_set<int>& excludedClusters, bool excludeClusters);
  void followTrackKeepBest(Track& track, bool isRight, bool isInward);
  void findNextCluster(const Track& track, bool isRight, bool isInward, int chamber, int firstRPC, int lastRPC, Track& bestTrack) const;
  int getFirstNeighbourRPC(int rpc) const;
  int getLastNeighbourRPC(int rpc) const;
  bool loadClusters(gsl::span<const Cluster>& clusters);
  bool makeTrackSeed(Track& track, const Cluster& cl1, const Cluster& cl2) const;
  void runKalmanFilter(Track& track, const Cluster& cluster) const;
  bool tryOneCluster(const Track& track, int chamber, int clIdx, Track& newTrack) const;
  void excludeUsedClusters(const Track& track, int ch1, int ch2, std::unordered_set<int>& excludedClusters) const;
  bool skipOneChamber(Track& track) const;
 
  static constexpr float SMT11Z = -1603.5; 
 
  float mImpactParamCut = 210.; 
  float mSigmaCut = 5.;         
  float mMaxChi2 = 50.;         
 
  std::vector<int> mClusterIndexes[72]; 
  std::vector<Cluster> mClusters{};     
 
  std::vector<Track> mTracks{};                
  std::vector<ROFRecord> mTrackROFRecords{};   
  std::vector<ROFRecord> mClusterROFRecords{}; 
  size_t mFirstTrackOffset{0};                 
  size_t mTrackOffset{0};                      
  int mNTracksStep1{0};                        
 
  GeometryTransformer mTransformer{}; 
 
  typedef void (Tracker::*TrackerMemFn)(Track&, bool, bool);
  TrackerMemFn mFollowTrack{&Tracker::followTrackKeepAll}; 
};
} // namespace mid
} // namespace o2
 
#endif /* O2_MID_TRACKER_H */