MatchTOF.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 ALICEO2_GLOBTRACKING_MATCHTOF_
#define ALICEO2_GLOBTRACKING_MATCHTOF_
 
#include <Rtypes.h>
#include <array>
#include <vector>
#include <string>
#include <gsl/span>
#include <TStopwatch.h>
#include "ReconstructionDataFormats/Track.h"
#include "ReconstructionDataFormats/TrackTPCITS.h"
#include "ReconstructionDataFormats/TrackTPCTOF.h"
#include "ReconstructionDataFormats/MatchInfoTOFReco.h"
#include "ReconstructionDataFormats/GlobalTrackID.h"
#include "DataFormatsTOF/CalibInfoTOF.h"
#include "CommonDataFormat/EvIndex.h"
#include "SimulationDataFormat/MCCompLabel.h"
#include "CommonUtils/TreeStreamRedirector.h"
#include "TOFBase/Geo.h"
#include "DataFormatsTOF/Cluster.h"
#include "GlobalTracking/MatchTPCITS.h"
#include "DataFormatsTPC/TrackTPC.h"
#include "DataFormatsTRD/TrackTRD.h"
#include "ReconstructionDataFormats/PID.h"
#include "TPCFastTransform.h"
#include "CommonDataFormat/InteractionRecord.h"
#include "CorrectionMapsHelper.h"
#include "GlobalTracking/MatchTOFParams.h"
 
// from FIT
#include "DataFormatsFT0/RecPoints.h"
 
namespace o2
{
namespace tpc
{
class VDriftCorrFact;
}
 
namespace globaltracking
{
class RecoContainer;
}
 
namespace dataformats
{
template <typename TruthElement>
class MCTruthContainer;
}
 
namespace globaltracking
{
 
struct TrackLocTPCITS : public o2::track::TrackParCov {
  o2::dataformats::EvIndex<int, int> source; 
  o2::math_utils::Bracket<float> timeBins;   
  float zMin = 0;                            // min possible Z of this track
  float zMax = 0;                            // max possible Z of this track
  int matchID = MinusOne;                    
  TrackLocTPCITS(const o2::track::TrackParCov& src, int tch, int tid) : o2::track::TrackParCov(src), source(tch, tid) {}
  TrackLocTPCITS() = default;
  ClassDefNV(TrackLocTPCITS, 1); // RS TODO: is this class needed?
};
 
class MatchTOF
{
  using Geo = o2::tof::Geo;
  using Cluster = o2::tof::Cluster;
  using evGIdx = o2::dataformats::EvIndex<int, o2::dataformats::GlobalTrackID>;
  using evIdx = o2::dataformats::EvIndex<int, int>;
  using timeEst = o2::dataformats::TimeStampWithError<float, float>;
  using matchTrack = std::pair<o2::track::TrackParCov, timeEst>;
  using trkType = o2::dataformats::MatchInfoTOFReco::TrackType;
 
 public:
  void run(const o2::globaltracking::RecoContainer& inp, unsigned long firstTForbit = 0);
 
  void setCosmics()
  {
    mIsCosmics = true;
    mSpaceTolerance = 150;
    mTimeTolerance = 50e3;
  }
 
  void setHighPurity(bool value = true) { mSetHighPurity = value; }
 
  void print() const;
  void printCandidatesTOF() const;
 
  void setTimeTolerance(float val) { mTimeTolerance = val; }
  float getTimeTolerance() const { return mTimeTolerance; }
  void setExtraTimeToleranceTRD(float val) { mExtraTimeToleranceTRD = val; }
  float getExtraTimeToleranceTRD() const { return mExtraTimeToleranceTRD; }
 
  void setSpaceTolerance(float val) { mSpaceTolerance = val; }
  float getSpaceTolerance() const { return mSpaceTolerance; }
 
  void setSigmaTimeCut(float val) { mSigmaTimeCut = val; }
  float getSigmaTimeCut() const { return mSigmaTimeCut; }
 
  enum DebugFlagTypes : UInt_t {
    MatchTreeAll = 0x1 << 1, 
  };
  bool isDebugFlag(UInt_t flags) const { return mDBGFlags & flags; }
 
  UInt_t getDebugFlags() const { return mDBGFlags; }
 
  void setDebugFlag(UInt_t flag, bool on = true);
 
  void setDebugTreeFileName(std::string name)
  {
    if (!name.empty()) {
      mDebugTreeFileName = name;
    }
  }
 
  std::vector<o2::dataformats::MatchInfoTOF>& getMatchedTrackVector(trkType index) { return mMatchedTracks[index]; }
  std::vector<o2::dataformats::CalibInfoTOF>& getCalibVector() { return mCalibInfoTOF; }
 
  std::vector<o2::dataformats::MatchInfoTOFReco>& getMatchedTracksPair(int sec) { return mMatchedTracksPairsSec[sec]; }
 
  std::vector<o2::MCCompLabel>& getMatchedTOFLabelsVector(trkType index) { return mOutTOFLabels[index]; } 
 
  void setTPCVDrift(const o2::tpc::VDriftCorrFact& v);
  void setTPCCorrMaps(o2::gpu::CorrectionMapsHelper* maph);
 
  void setFIT(bool value = true) { mIsFIT = value; }
  static int findFITIndex(int bc, const gsl::span<const o2::ft0::RecPoints>& FITRecPoints, unsigned long firstOrbit);
 
  void checkRefitter();
  bool makeConstrainedTPCTrack(int matchedID, o2::dataformats::TrackTPCTOF& trConstr);
 
  template <typename MtcInfo, typename MCInfo, typename CTrack>
  void makeConstrainedTPCTracks(MtcInfo& mtcCont, MCInfo& MCCont, CTrack& trcCont)
  {
    auto nmatch = getMatchedTrackVector(o2::dataformats::MatchInfoTOFReco::TrackType::TPC).size(); // preliminary matches
    mtcCont.reserve(nmatch);
    trcCont.reserve(nmatch);
    if (mMCTruthON) {
      MCCont.reserve(nmatch);
    }
    checkRefitter();
 
    auto& mclabs = getMatchedTOFLabelsVector(o2::dataformats::MatchInfoTOFReco::TrackType::TPC);
    auto& info = getMatchedTrackVector(o2::dataformats::MatchInfoTOFReco::TrackType::TPC);
    int nconstrained = 0;
    for (unsigned i = 0; i < nmatch; i++) {
      auto& ctr = trcCont.emplace_back();
      if (makeConstrainedTPCTrack(i, ctr)) {
        mtcCont.push_back(info[i]);
        if (mMCTruthON) {
          MCCont.push_back(mclabs[i]);
        }
        nconstrained++;
      } else {
        trcCont.pop_back();
      }
    }
  }
 
  void setTS(unsigned long creationTime) { mTimestamp = creationTime; }
  unsigned long getTS() const { return mTimestamp; }
 
  static void groupingMatch(const std::vector<o2::dataformats::MatchInfoTOFReco>& origin, std::vector<std::vector<o2::dataformats::MatchInfoTOFReco>>& grouped, std::vector<std::vector<int>>& firstEls, std::vector<std::vector<int>>& secondEls);
  static void printGrouping(const std::vector<o2::dataformats::MatchInfoTOFReco>& origin, const std::vector<std::vector<o2::dataformats::MatchInfoTOFReco>>& grouped);
 
  void storeMatchable(bool val = true) { mStoreMatchable = val; }
 
  void setNlanes(int lanes) { mNlanes = lanes; }
 
 private:
  bool prepareFITData();
  int prepareInteractionTimes();
  bool prepareTPCData();
  void propagateTPCTracks(int sec);
  void propagateConstrTracks(int sec);
  void addTPCSeed(const o2::tpc::TrackTPC& _tr, o2::dataformats::GlobalTrackID srcGID, float time0, float terr);
  void addITSTPCSeed(const o2::dataformats::TrackTPCITS& _tr, o2::dataformats::GlobalTrackID srcGID, float time0, float terr);
  void addTRDSeed(const o2::trd::TrackTRD& _tr, o2::dataformats::GlobalTrackID srcGID, float time0, float terr);
  void addConstrainedSeed(o2::track::TrackParCov& trc, o2::dataformats::GlobalTrackID srcGID, o2::track::TrackLTIntegral intLT0, timeEst timeMUS);
  //  void addTPCTRDSeed(const o2::track::TrackParCov& _tr, o2::dataformats::GlobalTrackID srcGID, int tpcID);
  //  void addITSTPCTRDSeed(const o2::track::TrackParCov& _tr, o2::dataformats::GlobalTrackID srcGID, int tpcID);
  bool prepareTOFClusters();
 
  void doMatching(int sec);
  void doMatchingForTPC(int sec);
  void selectBestMatches(int sec);
  void BestMatches(std::vector<o2::dataformats::MatchInfoTOFReco>& matchedTracksPairs, std::vector<o2::dataformats::MatchInfoTOF>* matchedTracks, std::vector<int>* matchedTracksIndex, int* matchedClustersIndex, const gsl::span<const o2::ft0::RecPoints>& FITRecPoints, const std::vector<Cluster>& TOFClusWork, const std::vector<matchTrack>* TracksWork, std::vector<o2::dataformats::CalibInfoTOF>& CalibInfoTOF, unsigned long Timestamp, bool MCTruthON, const o2::dataformats::MCTruthContainer<o2::MCCompLabel>* TOFClusLabels, const std::vector<o2::MCCompLabel>* TracksLblWork, std::vector<o2::MCCompLabel>* OutTOFLabels, float calibMaxChi2);
  void BestMatchesHP(std::vector<o2::dataformats::MatchInfoTOFReco>& matchedTracksPairs, std::vector<o2::dataformats::MatchInfoTOF>* matchedTracks, std::vector<int>* matchedTracksIndex, int* matchedClustersIndex, const gsl::span<const o2::ft0::RecPoints>& FITRecPoints, const std::vector<Cluster>& TOFClusWork, std::vector<o2::dataformats::CalibInfoTOF>& CalibInfoTOF, unsigned long Timestamp, bool MCTruthON, const o2::dataformats::MCTruthContainer<o2::MCCompLabel>* TOFClusLabels, const std::vector<o2::MCCompLabel>* TracksLblWork, std::vector<o2::MCCompLabel>* OutTOFLabels);
  bool propagateToRefX(o2::track::TrackParCov& trc, float xRef /*in cm*/, float stepInCm /*in cm*/, o2::track::TrackLTIntegral& intLT);
  bool propagateToRefXWithoutCov(const o2::track::TrackParCov& trc, float xRef /*in cm*/, float stepInCm /*in cm*/, float bz);
  bool propagateToRefXWithoutCov(const o2::track::TrackParCov& trc, float xRef /*in cm*/, float stepInCm /*in cm*/, float bz, float pos[3]);
  void updateTL(o2::track::TrackLTIntegral& intLT, float deltal);
 
  void updateTimeDependentParams();
 
  static bool mHasFillScheme;
  static bool mFillScheme[o2::constants::lhc::LHCMaxBunches];
 
  //================================================================
 
  // Data members
  const o2::globaltracking::RecoContainer* mRecoCont = nullptr;
  o2::InteractionRecord mStartIR{0, 0}; 
 
  int mNlanes = 3; 
 
  // TOF matching params (work in progress)
  const MatchTOFParams* mMatchParams = nullptr;
 
  // for derived class
  int mCurrTracksTreeEntry = 0; 
 
  float mXRef = Geo::RMIN; 
 
  bool mMCTruthON = false; 
 
  float mTPCVDriftRef = -1.; 
  float mTPCVDriftCorrFact = 1.; 
  float mTPCVDrift = -1.;    
  float mTPCDriftTimeOffset = 0; 
 
  float mBz = 0;          
  float mMaxInvPt = 999.; 
 
  // to be done later
  float mTPCTBinMUS = 0.;    
  float mTPCTBinMUSInv = 0.; 
  float mTPCBin2Z = 0.;      
 
  bool mIsCosmics = false;              
  float mTimeTolerance = 1e3;           
  float mExtraTimeToleranceTRD = 500E3; 
  float mSpaceTolerance = 10;           
  float mSigmaTimeCut = 3;              
 
  bool mIsFIT = false;
  bool mIsITSTPCused = false;
  bool mIsTPCused = false;
  bool mIsTPCTRDused = false;
  bool mIsITSTPCTRDused = false;
  bool mSetHighPurity = false;
  bool mStoreMatchable = false;
 
  unsigned long mTimestamp = 0; 
 
  unsigned long mFirstTForbit = 0; 
 
  // from ruben
  gsl::span<const o2::tpc::TrackTPC> mTPCTracksArray; 
 
  //           since this info is provided by external device
  //  std::vector<o2::dataformats::TrackTPCITS> mITSTPCTracksArrayInp;  ///< input tracks
  gsl::span<const Cluster> mTOFClustersArrayInp;     
 
  gsl::span<const o2::tpc::TPCClRefElem> mTPCTrackClusIdx;            
  gsl::span<const unsigned char> mTPCRefitterShMap;                   
  gsl::span<const unsigned int> mTPCRefitterOccMap;                   
  const o2::tpc::ClusterNativeAccess* mTPCClusterIdxStruct = nullptr; 
 
  o2::gpu::CorrectionMapsHelper* mTPCCorrMapsHelper = nullptr;        
  std::unique_ptr<o2::gpu::GPUO2InterfaceRefit> mTPCRefitter;         
 
  const o2::dataformats::MCTruthContainer<o2::MCCompLabel>* mTOFClusLabels; 
 
  int mNotPropagatedToTOF[trkType::SIZE]; 
 
  gsl::span<const o2::ft0::RecPoints> mFITRecPoints; 
 
 
  std::vector<matchTrack> mTracksWork[o2::constants::math::NSectors][trkType::SIZE];                   
  std::vector<o2::MCCompLabel> mTracksLblWork[o2::constants::math::NSectors][trkType::SIZE];           
  std::vector<o2::track::TrackLTIntegral> mLTinfos[o2::constants::math::NSectors][trkType::SIZE];      
  std::vector<o2::dataformats::GlobalTrackID> mTrackGid[o2::constants::math::NSectors][trkType::SIZE]; 
  std::array<std::vector<int>, o2::constants::math::NSectors> mTracksSectIndexCache[trkType::SIZE];
  std::array<std::vector<int>, o2::constants::math::NSectors> mTracksSeed[trkType::SIZE];
  std::vector<float> mVZtpcOnly[o2::constants::math::NSectors];
 
  std::vector<float> mExtraTPCFwdTime[o2::constants::math::NSectors]; 
  std::vector<Cluster> mTOFClusWork;                                  
  std::vector<int8_t> mSideTPC[o2::constants::math::NSectors];        
 
  std::array<std::vector<int>, o2::constants::math::NSectors> mTOFClusSectIndexCache;
 
  std::vector<o2::dataformats::MatchInfoTOFReco> mMatchedTracksPairsSec[o2::constants::math::NSectors];
 
  std::vector<o2::dataformats::CalibInfoTOF> mCalibInfoTOF;
 
  //std::vector<o2::dataformats::MatchInfoTOF> mMatchedTracks;
  std::vector<o2::dataformats::MatchInfoTOF> mMatchedTracks[trkType::SIZEALL]; // this is the output of the matching -> UNCONS, CONSTR
  std::vector<o2::MCCompLabel> mOutTOFLabels[trkType::SIZEALL];                
 
  std::vector<int> mMatchedTracksIndex[o2::constants::math::NSectors][trkType::SIZE]; // vector of indexes of the tracks to be matched
 
  int mNumOfClusters;                   // number of clusters to be matched
  int* mMatchedClustersIndex = nullptr; //[mNumOfClusters]
 
  std::unique_ptr<o2::utils::TreeStreamRedirector> mDBGOut;
  UInt_t mDBGFlags = 0;
  std::string mDebugTreeFileName = "dbg_matchTOF.root"; 
 
  std::array<float, 5> mCovDiagInner{}; 
  std::array<float, 5> mCovDiagOuter{}; 
 
  static constexpr float MAXSNP = 0.85; // max snp of ITS or TPC track at xRef to be matched
 
  TStopwatch mTimerTot;
  TStopwatch mTimerMatchITSTPC;
  TStopwatch mTimerMatchTPC;
  TStopwatch mTimerDBG;
  ClassDefNV(MatchTOF, 6);
};
} // namespace globaltracking
} // namespace o2
 
#endif