MatchTPCITS.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_MATCHTPCITS_
#define ALICEO2_GLOBTRACKING_MATCHTPCITS_
 
#define _ALLOW_DEBUG_TREES_ // to allow debug and control tree output
 
#define _ALLOW_DEBUG_AB_ // fill extra debug info for AB
 
#include <Rtypes.h>
#include <array>
#include <deque>
#include <vector>
#include <string>
#include <gsl/span>
#include <TStopwatch.h>
#include "DataFormatsTPC/TrackTPC.h"
#include "DetectorsBase/Propagator.h"
#include "ReconstructionDataFormats/Track.h"
#include "ReconstructionDataFormats/TrackTPCITS.h"
#include "ReconstructionDataFormats/GlobalTrackID.h"
#include "MathUtils/Primitive2D.h"
#include "CommonDataFormat/EvIndex.h"
#include <DetectorsCommonDataFormats/DetID.h>
#include "CommonDataFormat/InteractionRecord.h"
#include "CommonDataFormat/RangeReference.h"
#include "CommonDataFormat/BunchFilling.h"
#include "CommonDataFormat/Triplet.h"
#include "SimulationDataFormat/MCCompLabel.h"
#include "CommonUtils/TreeStreamRedirector.h"
#include "DataFormatsITSMFT/Cluster.h"
#include "DataFormatsITSMFT/ROFRecord.h"
#include "DataFormatsITSMFT/DPLAlpideParam.h"
#include "DataFormatsITS/TrackITS.h"
#include "DataFormatsFT0/RecPoints.h"
#include "FT0Reconstruction/InteractionTag.h"
#include "DataFormatsTPC/ClusterNativeHelper.h"
#include "DataFormatsTPC/VDriftCorrFact.h"
#include "ITSReconstruction/RecoGeomHelper.h"
#include "GPUO2InterfaceRefit.h"
#include "GPUTPCGeometry.h"
#include "GlobalTracking/MatchTPCITSParams.h"
#include "DataFormatsITSMFT/TopologyDictionary.h"
#include "DataFormatsITSMFT/TrkClusRef.h"
#include "DataFormatsITSMFT/ClusterID.h"
#include "ITSMFTReconstruction/ChipMappingITS.h"
#include "TPCFastTransformPOD.h"
#if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__ROOTCLING__) && !defined(__CLING__)
#include "MemoryResources/MemoryResources.h"
#endif
#ifdef ENABLE_UPGRADES
#include "ITS3Reconstruction/TopologyDictionary.h"
#endif
 
class TTree;
 
namespace o2
{
 
namespace globaltracking
{
class RecoContainer;
}
 
namespace dataformats
{
template <typename TruthElement>
class MCTruthContainer;
}
 
namespace its
{
class TrackITS;
}
 
namespace itsmft
{
class Cluster;
}
 
namespace tpc
{
class TrackTPC;
class VDriftCorrFact;
} // namespace tpc
 
namespace gpu
{
struct GPUParam;
}
 
namespace globaltracking
{
 
constexpr int Zero = 0;
constexpr int MinusOne = -1;
constexpr int MinusTen = -10;
constexpr int Validated = -2;
 
using ITSClusStatus = std::array<std::vector<int>, o2::its::RecoGeomHelper::getNLayers()>;
 
enum TrackRejFlag : int {
  Accept = 0,
  RejectOnY, // rejected comparing DY difference of tracks
  RejectOnZ,
  RejectOnSnp,
  RejectOnTgl,
  RejectOnQ2Pt,
  RejectOnChi2,
  NSigmaShift = 10,
  RejectoOnPIDCorr = 20
};
 
struct TrackLocTPC : public o2::track::TrackParCov {
  enum Constraint_t : uint8_t { Constrained,
                                ASide,
                                CSide };
  o2::math_utils::Bracketf_t tBracket;  
  float time0 = 0.f;                    
  float timeErr = 0.f;                  
  int sourceID = 0;                     
  o2::dataformats::GlobalTrackID gid{}; // global track source ID (TPC track may be part of it)
  int matchID = MinusOne;               
  uint8_t lowestRow = -1;
  uint8_t padFromEdge = -1;
  Constraint_t constraint{Constrained};
 
  float getCorrectedTime(float dt) const // return time0 corrected for extra drift (to match certain Z)
  {
    return constraint == Constrained ? time0 : (constraint == ASide ? time0 + dt : time0 - dt);
  }
  float getSignedDT(float dt) const // account for TPC side in time difference for dt=external_time - tpc.time0
  {
    return constraint == Constrained ? 0.f : (constraint == ASide ? dt : -dt);
  }
 
  ClassDefNV(TrackLocTPC, 3);
};
 
struct TrackLocITS : public o2::track::TrackParCov {
  enum : uint16_t { CloneBefore = 0x1,
                    CloneAfter = 0x2 };
  o2::math_utils::Bracketf_t tBracket; 
  int sourceID = 0;                    
  int roFrame = MinusOne;              
  int matchID = MinusOne;              
  float xrho = 0;                      
  float dL = 0;                        
  bool hasCloneBefore() const { return getUserField() & CloneBefore; }
  bool hasCloneAfter() const { return getUserField() & CloneAfter; }
  int getCloneShift() const { return hasCloneBefore() ? -1 : (hasCloneAfter() ? 1 : 0); }
  void setCloneBefore() { setUserField(getUserField() | CloneBefore); }
  void setCloneAfter() { setUserField(getUserField() | CloneAfter); }
 
  ClassDefNV(TrackLocITS, 1);
};
 
struct MatchRecord {
  float chi2 = -1.f;        
  int partnerID = MinusOne; 
  int nextRecID = MinusOne; 
  int matchedIC = MinusOne; 
  MatchRecord(int partID, float chi2match, int nxt = MinusOne, int candIC = MinusOne) : partnerID(partID), chi2(chi2match), nextRecID(nxt), matchedIC(candIC) {}
  MatchRecord() = default;
 
  bool isBetter(float otherChi2, int otherIC = MinusOne) const
  { // prefer record with matched IC candidate, otherwise, better chi2
    if (otherIC == MinusOne) {
      return matchedIC == MinusOne ? chi2 < otherChi2 : true;
    } else {
      return matchedIC == MinusOne ? false : chi2 < otherChi2;
    }
  }
 
  bool isBetter(const MatchRecord& other) const
  {
    return isBetter(other.chi2, other.matchedIC);
  }
};
 
struct ABTrackLink : public o2::track::TrackParCov {
  static constexpr int Disabled = -2;
  int clID = MinusOne;     
  int parentID = MinusOne; 
  int nextOnLr = MinusOne; 
  uint8_t nDaughters = 0;  
  int8_t layerID = -1;     
  int8_t nContLayers = 0;  
  uint8_t ladderID = 0xff; 
  float chi2 = 0.f;        
 
  ABTrackLink() = default;
  ~ABTrackLink() = default;
  ABTrackLink(const o2::track::TrackParCov& tr, int cl, int parID, int nextID, int lr, int nc, int ld, float _chi2)
    : o2::track::TrackParCov(tr), clID(cl), parentID(parID), nextOnLr(nextID), layerID(int8_t(lr)), nContLayers(int8_t(nc)), ladderID(uint8_t(ld)), chi2(_chi2) {}
 
  bool isDisabled() const { return clID == Disabled; }
  void disable() { clID = Disabled; }
  bool isDummyTop() const { return clID == MinusTen; }
  float chi2Norm() const { return layerID < o2::its::RecoGeomHelper::getNLayers() ? chi2 / (o2::its::RecoGeomHelper::getNLayers() - layerID) : 999.; }
  float chi2NormPredict(float chi2cl) const { return (chi2 + chi2cl) / (1 + o2::its::RecoGeomHelper::getNLayers() - layerID); }
};
 
struct LinksPoolMT {
  std::vector<std::deque<ABTrackLink>> threadPool;
};
 
// AB primary seed: TPC track propagated to outermost ITS layer under specific InteractionCandidate hypothesis
struct TPCABSeed {
  static constexpr int8_t NeedAlternative = -3;
  int tpcWID = MinusOne;                                            
  int ICCanID = MinusOne;                                           
  int winLinkID = MinusOne;                                         
  uint32_t linksEntry = 0;                                          
  int nLinks = 0;                                                   
  int8_t lowestLayer = o2::its::RecoGeomHelper::getNLayers();       
  int8_t status = MinusOne;                                         
  uint8_t threadID = 0;                                             
  o2::track::TrackParCov track{};                                   
  std::array<int, o2::its::RecoGeomHelper::getNLayers()> firstInLr; 
  static LinksPoolMT* gLinksPool;                                   
 
  TPCABSeed(int id, int ic, const o2::track::TrackParCov& trc) : tpcWID(id), ICCanID(ic), track(trc)
  {
    firstInLr.fill(MinusOne);
  }
  bool isDisabled() const { return status == MinusTen; }
  void disable() { status = MinusTen; }
  bool isValidated() const { return status == Validated; }
  void validate(int lID)
  {
    winLinkID = lID;
    status = Validated;
  }
  int8_t getNLayers() const { return o2::its::RecoGeomHelper::getNLayers() - lowestLayer; }
  bool needAlteranative() const { return status == NeedAlternative; }
  void setNeedAlternative() { status = NeedAlternative; }
  ABTrackLink& getLink(int i) { return gLinksPool->threadPool[threadID][i + linksEntry]; }
  const ABTrackLink& getLink(int i) const { return gLinksPool->threadPool[threadID][i + linksEntry]; }
  void addLink(const o2::track::TrackParCov& trc, int clID, int parentID, int nextID, int lr, int nc, int laddID, float chi2)
  {
    gLinksPool->threadPool[threadID].push_back({trc, clID, parentID, nextID, lr, nc, laddID, chi2});
    nLinks++;
  }
  int getNLinks() const { return nLinks; }
  auto getBestLinkID() const
  {
    return lowestLayer < o2::its::RecoGeomHelper::getNLayers() ? firstInLr[lowestLayer] : -1;
  }
  bool checkLinkHasUsedClusters(int linkID, const ITSClusStatus& clStatus) const
  {
    // check if some clusters used by the link or its parents are forbidden (already used by validatet track)
    while (linkID > MinusOne) {
      const auto& link = getLink(linkID);
      if (link.clID > MinusOne && clStatus[o2::itsmft::clusID2Layer(link.clID)][o2::itsmft::clusID2Index(link.clID)] != MinusOne) {
        return true;
      }
      linkID = link.parentID;
    }
    return false;
  }
  void flagLinkUsedClusters(int linkID, ITSClusStatus& clStatus) const
  {
    // check if some clusters used by the link or its parents are forbidden (already used by validated track)
    while (linkID > MinusOne) {
      const auto& link = getLink(linkID);
      if (link.clID > MinusOne) {
        clStatus[o2::itsmft::clusID2Layer(link.clID)][o2::itsmft::clusID2Index(link.clID)] = MinusTen;
      }
      linkID = link.parentID;
    }
  }
  size_t sizeInternal() const { return sizeof(ABTrackLink) * getNLinks(); }
  size_t capInternal() const { return sizeof(ABTrackLink) * getNLinks(); }
};
 
struct InteractionCandidate : public o2::InteractionRecord {
  o2::math_utils::Bracketf_t tBracket;                // interaction time
  int rofITS;                                         // corresponding ITS clock-layer cluster ROF entry (in the ROFRecord vectors)
  uint32_t flag;                                      // origin, etc.
  o2::dataformats::RangeReference<int, int> seedsRef; // references to AB seeds
  std::array<int, o2::its::RecoGeomHelper::getNLayers()> rofLr; // per ITS layer: cluster ROF entry compatible with the candidate time, -1: none
  uint8_t rofNextLr = 0;                                        // bit lr set: the candidate time is compatible also with the ROF rofLr[lr]+1 of the layer
  InteractionCandidate(const o2::InteractionRecord& ir, float t, float dt, int rof, uint32_t f = 0) : o2::InteractionRecord(ir), tBracket(t - dt, t + dt), rofITS(rof), flag(f)
  {
    rofLr.fill(MinusOne);
  }
};
 
struct ABClusterInfo {
  float y = 0.f, z = 0.f; 
  int id = MinusOne;      
  int chip = -1;          
};
 
struct ABLayerClusters {
  using ClusRange = o2::dataformats::RangeReference<int, int>;
  std::vector<o2::math_utils::Bracketf_t> rofTimes; 
  std::vector<ClusRange> rofRefs;                   
  std::vector<ABClusterInfo> clus;                  
  std::vector<uint8_t> needROF;                     
  void clear()
  {
    rofTimes.clear();
    rofRefs.clear();
    clus.clear();
    needROF.clear();
  }
  size_t sizeInternal() const { return sizeof(ABClusterInfo) * clus.size() + sizeof(o2::math_utils::Bracketf_t) * rofTimes.size() + sizeof(ClusRange) * rofRefs.size() + needROF.size(); }
  size_t capInternal() const { return sizeof(ABClusterInfo) * clus.capacity() + sizeof(o2::math_utils::Bracketf_t) * rofTimes.capacity() + sizeof(ClusRange) * rofRefs.capacity() + needROF.capacity(); }
};
 
struct ABLayerView {
  using ClusRange = o2::dataformats::RangeReference<int, int>;
  int rofKey = -2;                     
  int nROFsKey = 0;                    
  int chipOffs = 0;                    
  int nData = 0;                       
  const ABClusterInfo* data = nullptr; 
  std::vector<ClusRange> chipRefs;     
  std::vector<int> touchedChips;       
  std::vector<ABClusterInfo> merged;   
};
 
struct ABThreadClusterViews {
  std::array<ABLayerView, o2::its::RecoGeomHelper::getNLayers()> layers;
};
 
class MatchTPCITS
{
 public:
  using ITSCluster = o2::BaseCluster<float>;
  using ClusRange = o2::dataformats::RangeReference<int, int>;
  using TPCTransform = o2::gpu::TPCFastTransform;
  using BracketF = o2::math_utils::Bracket<float>;
  using BracketIR = o2::math_utils::Bracket<o2::InteractionRecord>;
  using Params = o2::globaltracking::MatchTPCITSParams;
  using MatCorrType = o2::base::Propagator::MatCorrType;
  using VDTriplet = o2::dataformats::Triplet<float, float, float>;
  using AlpParamITS = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>;
 
  MatchTPCITS(); // std::unique_ptr to forward declared type needs constructor / destructor in .cxx
  ~MatchTPCITS();
 
  static constexpr int MaxUpDnLadders = 3;                     // max N ladders to check up and down from selected one
  static constexpr int MaxLadderCand = 2 * MaxUpDnLadders + 1; // max ladders to check for matching clusters
  static constexpr int MaxSeedsPerLayer = 50;                  // TODO
  static constexpr int NITSLayers = o2::its::RecoGeomHelper::getNLayers();
  static_assert(NITSLayers == AlpParamITS::getNLayers(), "ITS layers count mismatch between geometry helper and DPLAlpideParam");
  static_assert(NITSLayers == o2::itsmft::MaxITSClusLayers, "ITS layers count mismatch between geometry helper and the composed cluster ID encoding");
#if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__ROOTCLING__) && !defined(__CLING__)
  void run(const o2::globaltracking::RecoContainer& inp,
           pmr::vector<o2::dataformats::TrackTPCITS>& matchedTracks,
           pmr::vector<o2::itsmft::TrkClusRef>& ABTrackletRefs,
           pmr::vector<int>& ABTrackletClusterIDs,
           pmr::vector<o2::MCCompLabel>& matchLabels,
           pmr::vector<o2::MCCompLabel>& ABTrackletLabels,
           pmr::vector<o2::dataformats::Triplet<float, float, float>>& calib);
  void refitWinners(pmr::vector<o2::dataformats::TrackTPCITS>& matchedTracks, pmr::vector<o2::MCCompLabel>& matchLabels, pmr::vector<o2::dataformats::Triplet<float, float, float>>& calib);
  bool refitTrackTPCITS(int slot, int iTPC, int& iITS, pmr::vector<o2::dataformats::TrackTPCITS>& matchedTracks, pmr::vector<o2::MCCompLabel>& matchLabels, pmr::vector<o2::dataformats::Triplet<float, float, float>>& calib);
  void fillCalibDebug(int ifit, int iTPC, const o2::dataformats::TrackTPCITS& match, pmr::vector<o2::dataformats::Triplet<float, float, float>>& calib);
  void reportSizes(pmr::vector<o2::dataformats::TrackTPCITS>& matchedTracks,
                   pmr::vector<o2::itsmft::TrkClusRef>& ABTrackletRefs,
                   pmr::vector<int>& ABTrackletClusterIDs,
                   pmr::vector<o2::MCCompLabel>& matchLabels,
                   pmr::vector<o2::MCCompLabel>& ABTrackletLabels,
                   pmr::vector<o2::dataformats::Triplet<float, float, float>>& calib);
  bool runAfterBurner(pmr::vector<o2::dataformats::TrackTPCITS>& matchedTracks, pmr::vector<o2::MCCompLabel>& matchLabels, pmr::vector<o2::MCCompLabel>& ABTrackletLabels, pmr::vector<int>& ABTrackletClusterIDs,
                      pmr::vector<o2::itsmft::TrkClusRef>& ABTrackletRefs, pmr::vector<o2::dataformats::Triplet<float, float, float>>& calib);
  void refitABWinners(pmr::vector<o2::dataformats::TrackTPCITS>& matchedTracks, pmr::vector<o2::MCCompLabel>& matchLabels, pmr::vector<o2::MCCompLabel>& ABTrackletLabels, pmr::vector<int>& ABTrackletClusterIDs,
                      pmr::vector<o2::itsmft::TrkClusRef>& ABTrackletRefs, pmr::vector<o2::dataformats::Triplet<float, float, float>>& calib);
  bool refitABTrack(int iITSAB, const TPCABSeed& seed, pmr::vector<o2::dataformats::TrackTPCITS>& matchedTracks, pmr::vector<int>& ABTrackletClusterIDs, pmr::vector<o2::itsmft::TrkClusRef>& ABTrackletRefs);
#endif // CLING
  void setSkipTPCOnly(bool v)
  {
    mSkipTPCOnly = v;
  }
  void setCosmics(bool v) { mCosmics = v; }
  bool isCosmics() const { return mCosmics; }
  void setNThreads(int n);
 
  void init();
  void end();
  void reportTiming();
 
  void clear();
 
  void setBunchFilling(const o2::BunchFilling& bf);
 
  void setNHBPerTF(int n) { mNHBPerTF = n; }
 
  void setITSTriggered(bool v)
  {
    mITSTriggered = v;
    if (mAlpParams) { // the ROF length depends on the readout mode
      setAlpideParam(mAlpParams);
    }
  }
  bool isITSTriggered() const { return mITSTriggered; }
 
  void setUseFT0(bool v) { mUseFT0 = v; }
  bool getUseFT0() const { return mUseFT0; }
 
  void setUseBCFilling(bool v) { mUseBCFilling = v; }
  bool getUseBCFilling() const { return mUseBCFilling; }
 
  void setAlpideParam(const AlpParamITS* p);
  const AlpParamITS* getAlpideParam() const { return mAlpParams; }
 
  int getITSClockLayer() const { return mITSClockLayer; }
 
  int getITSROFrameLengthInBC(int lr) const { return mITSROFrameLengthInBC[lr]; }
  float getITSROFrameLengthMUS(int lr) const { return mITSROFrameLengthMUS[lr]; }
  float getITSROFrameLengthMUSInv(int lr) const { return mITSROFrameLengthMUSInv[lr]; }
  float getITSTimeResMUS(int lr) const { return mITSTimeResMUS[lr]; }
  int getITSTimeBiasInBC(int lr) const { return mITSTimeBiasInBC[lr]; }
  float getITSTimeBiasMUS(int lr) const { return mITSTimeBiasMUS[lr]; }
 
  BracketF getITSROFTimeBracket(long nBC, int lr) const
  {
    float tMin = (nBC + mITSTimeBiasInBC[lr]) * o2::constants::lhc::LHCBunchSpacingMUS;
    return {tMin, tMin + mITSROFrameLengthMUS[lr]};
  }
 
  // ==================== >> DPL-driven input >> =======================
  void setITSDictionary(const o2::itsmft::TopologyDictionary* d) { mITSDict = d; }
#ifdef ENABLE_UPGRADES
  void setIT3Dictionary(const o2::its3::TopologyDictionary* d)
  {
    mIT3Dict = d;
  }
#endif
 
  void setMCTruthOn(bool v)
  {
    mMCTruthON = v;
  }
 
  void setVDriftCalib(bool v)
  {
    mVDriftCalibOn = v;
  }
  void setTPCVDrift(const o2::tpc::VDriftCorrFact& v);
  void setTPCCorrMaps(const o2::gpu::TPCFastTransformPOD* maph, float lumi);
 
  void print() const;
  void printCandidatesTPC() const;
  void printCandidatesITS() const;
 
  //>>> ====================== options =============================>>>
  void setUseMatCorrFlag(MatCorrType f) { mUseMatCorrFlag = f; }
  auto getUseMatCorrFlag() const { return mUseMatCorrFlag; }
 
  //<<< ====================== options =============================<<<
 
#ifdef _ALLOW_DEBUG_TREES_
  enum DebugFlagTypes : UInt_t {
    MatchTreeAll = 0x1 << 1,      
    MatchTreeAccOnly = 0x1 << 2,  
    WinnerMatchesTree = 0x1 << 3, 
    TPCOrigTree = 0x1 << 4        
  };
  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;
    }
  }
 
  const std::string& getDebugTreeFileName() const { return mDebugTreeFileName; }
 
  void fillTPCITSmatchTree(int itsID, int tpcID, int rejFlag, float chi2 = -1., float tCorr = 0.);
  void dumpWinnerMatches();
  void dumpTPCOrig(bool acc, int tpcIndex);
#endif
 
 private:
  void updateTimeDependentParams();
 
  int findLaddersToCheckBOn(int ilr, int lad0, const o2::math_utils::CircleXYf_t& circle, float errYFrac,
                            std::array<int, MaxLadderCand>& lad2Check) const;
  int findLaddersToCheckBOff(int ilr, int lad0, const o2::math_utils::IntervalXYf_t& trcLinPar, float errYFrac,
                             std::array<int, MatchTPCITS::MaxLadderCand>& lad2Check) const;
  bool prepareTPCData();
  bool prepareITSData();
  bool prepareFITData();
  int prepareInteractionTimes();
  int prepareTPCTracksAfterBurner();
  int addTPCSeed(const o2::track::TrackParCov& _tr, float t0, float terr, o2::dataformats::GlobalTrackID srcGID, int tpcID);
 
  int preselectChipClusters(std::vector<int>& clVecOut, const ClusRange& clRange, const ABLayerView& clView,
                            float trackY, float trackZ, float tolerY, float tolerZ) const;
  void flagUsedITSClusters(const o2::its::TrackITS& track);
 
  void doMatching(int sec);
 
  bool refitTPCInward(o2::track::TrackParCov& trcIn, float& chi2, float xTgt, int trcID, float timeTB) const;
 
  void selectBestMatches();
  bool validateTPCMatch(int iTPC);
  void removeITSfromTPC(int itsID, int tpcID);
  void removeTPCfromITS(int tpcID, int itsID);
  bool isValidatedTPC(const TrackLocTPC& t) const;
  bool isValidatedITS(const TrackLocITS& t) const;
  bool isDisabledTPC(const TrackLocTPC& t) const;
  bool isDisabledITS(const TrackLocITS& t) const;
 
  int compareTPCITSTracks(const TrackLocITS& tITS, const TrackLocTPC& tTPC, float& chi2) const;
  float getPredictedChi2NoZ(const o2::track::TrackParCov& trITS, const o2::track::TrackParCov& trTPC) const;
  bool propagateToRefX(o2::track::TrackParCov& trc, o2::track::TrackLTIntegral* lti = nullptr);
  void addLastTrackCloneForNeighbourSector(int sector, o2::track::TrackLTIntegral* trackLTInt = nullptr);
 
  bool registerMatchRecordTPC(int iITS, int iTPC, float chi2, int candIC = MinusOne);
  void registerMatchRecordITS(int iITS, int iTPC, float chi2, int candIC = MinusOne);
  void suppressMatchRecordITS(int iITS, int iTPC);
 
  int getNMatchRecordsTPC(const TrackLocTPC& tTPC) const;
 
  int getNMatchRecordsITS(const TrackLocITS& tITS) const;
 
  BracketIR tBracket2IRBracket(const BracketF tbrange);
 
  int time2ITSROFrameCont(float t) const
  {
    int rof = (t - mITSTimeBiasMUS[mITSClockLayer]) * mITSROFrameLengthMUSInv[mITSClockLayer];
    if (rof < 0) {
      rof = 0;
    }
    // the rof is estimated continuous counter but the actual bins might have gaps (e.g. HB rejects etc)-> use mapping
    return rof < int(mITSTrackROFContMapping.size()) ? mITSTrackROFContMapping[rof] : mITSTrackROFContMapping.back();
  }
 
  int time2ITSROFrameTrig(float t, int start) const
  {
    t -= mITSTimeBiasMUS[mITSClockLayer];
    while (start < int(mITSROFTimes.size())) {
      if (mITSROFTimes[start].getMax() > t) {
        return start;
      }
      start++;
    }
    return --start;
  }
 
  float tpcTimeBin2Z(float tbn) const { return tbn * mTPCBin2Z; }
 
  float tpcTimeBin2MUS(float tbn) const { return tbn * mTPCTBinMUS; }
 
  float tpcTimeBin2NS(float tbn) const { return tbn * mTPCTBinNS; }
 
  float z2TPCBin(float z) const { return z * mZ2TPCBin; }
 
  float tpcBin2Z(float t) const { return t * mTPCBin2Z; }
 
  int roughCheckDif(float delta, float toler, int rejFlag) const
  {
    return delta > toler ? rejFlag : (delta < -toler ? -rejFlag : Accept);
  }
 
  const ITSCluster& getITSCluster(int composedID) const
  {
    return mITSClustersArray[o2::itsmft::clusID2Layer(composedID)][o2::itsmft::clusID2Index(composedID)];
  }
 
  // ========================= AFTERBURNER =========================
  int prepareABSeeds();
  void prepareABClusters();
  void updateABLayerView(ABLayerView& view, int lr, int rof, int nROFs) const;
  void processABSeed(int sid, const ABThreadClusterViews& itsClViews, uint8_t tID);
  int followABSeed(const o2::track::TrackParCov& seed, const ABLayerView& clView, int seedID, int lrID, TPCABSeed& ABSeed);
  int registerABTrackLink(TPCABSeed& ABSeed, const o2::track::TrackParCov& trc, int clID, int parentID, int lr, int laddID, float chi2Cl);
  bool isBetter(float chi2A, float chi2B) { return chi2A < chi2B; } // RS FIMXE TODO
  void accountForOverlapsAB(int lrSeed);
  float correctTPCTrack(o2::track::TrackParCov& trc, const TrackLocTPC& tTPC, const InteractionCandidate& cand) const; // RS FIXME will be needed for refit
  //================================================================
 
  bool mInitDone = false;  
  bool mFieldON = true;    
  bool mCosmics = false;   
  bool mMCTruthON = false; 
  float mBz = 0;           
  int mTFCount = 0;        
  int mNThreads = 1;       
  int mNHBPerTF = 0;
  int mNTPCOccBinLength = 0; 
  float mNTPCOccBinLengthInv;
  o2::InteractionRecord mStartIR{0, 0}; 
 
  const Params* mParams = nullptr;
  const o2::ft0::InteractionTag* mFT0Params = nullptr;
  const AlpParamITS* mAlpParams = nullptr; 
 
  MatCorrType mUseMatCorrFlag = MatCorrType::USEMatCorrTGeo;
  bool mUseBCFilling = false; 
  bool mSkipTPCOnly = false;  
  bool mITSTriggered = false; 
  bool mUseFT0 = false;       
 
  bool mCompareTracksDZ = false;
 
  float YMaxAtXMatchingRef = 999.; 
 
  float mSectEdgeMargin = 0.; 
 
  float mTPCTimeEdgeTSafeMargin = 0.f;
  float mTPCExtConstrainedNSigmaInv = 0.f; // inverse for NSigmas for TPC time-interval from external constraint time sigma
  int mITSClockLayer = 0;                                  
  std::array<int, NITSLayers> mITSROFrameLengthInBC{};     
  std::array<float, NITSLayers> mITSROFrameLengthMUS{};    
  std::array<float, NITSLayers> mITSROFrameLengthMUSInv{}; 
  std::array<float, NITSLayers> mITSTimeResMUS{};          
  std::array<int, NITSLayers> mITSTimeBiasInBC{};          
  std::array<float, NITSLayers> mITSTimeBiasMUS{};         
  float mTPCVDrift = -1.;                  
  float mTPCVDriftInv = -1.;               
  float mTPCDriftTimeOffset = 0;           
  float mTPCTBinMUS = 0.;                  
  float mTPCTBinNS = 0.;                   
  float mTPCTBinMUSInv = 0.;               
  float mZ2TPCBin = 0.;                    
  float mTPCBin2Z = 0.;                    
  float mNTPCBinsFullDrift = 0.;           
  float mTPCZMax = 0.;                     
  float mTPCmeanX0Inv = 1. / 31850.;       
 
  float mMinTPCTrackPtInv = 999.; 
  float mMinITSTrackPtInv = 999.; 
  bool mVDriftCalibOn = false;    
  o2::tpc::VDriftCorrFact mTPCDrift{};
  const o2::gpu::TPCFastTransformPOD* mTPCCorrMaps = nullptr;
  float mLumiCTP{-1};
 
  std::unique_ptr<o2::gpu::GPUO2InterfaceRefit> mTPCRefitter; 
 
  o2::BunchFilling mBunchFilling;
  std::array<int16_t, o2::constants::lhc::LHCMaxBunches> mClosestBunchAbove; // closest filled bunch from above
  std::array<int16_t, o2::constants::lhc::LHCMaxBunches> mClosestBunchBelow; // closest filled bunch from below
 
  std::array<float, 5> mCovDiagInner{}; 
  std::array<float, 5> mCovDiagOuter{}; 
 
  const o2::itsmft::ChipMappingITS ITSChMap{};
 
  const o2::globaltracking::RecoContainer* mRecoCont = nullptr;
  //           since this info is provided by external device
  gsl::span<const o2::tpc::TrackTPC> mTPCTracksArray;      
  gsl::span<const o2::tpc::TPCClRefElem> mTPCTrackClusIdx; 
  gsl::span<const o2::itsmft::ROFRecord> mITSTrackROFRec;  
  gsl::span<const o2::its::TrackITS> mITSTracksArray;      
  gsl::span<const int> mITSTrackClusIdx;                   
  std::array<std::vector<ITSCluster>, NITSLayers> mITSClustersArray{};              
  std::array<std::vector<uint8_t>, NITSLayers> mITSClusterSizes{};                  
  std::array<gsl::span<const o2::itsmft::ROFRecord>, NITSLayers> mITSClusterROFRec; 
  int mNITSClusters = 0;
  gsl::span<const o2::ft0::RecPoints> mFITInfo;             
 
  gsl::span<const unsigned char> mTPCRefitterShMap; 
  gsl::span<const unsigned int> mTPCRefitterOccMap; 
  const o2::itsmft::TopologyDictionary* mITSDict{nullptr}; // cluster patterns dictionary
#ifdef ENABLE_UPGRADES
  const o2::its3::TopologyDictionary* mIT3Dict{nullptr}; // cluster patterns dictionary
#endif
 
  const o2::tpc::ClusterNativeAccess* mTPCClusterIdxStruct = nullptr; 
 
  std::array<const o2::dataformats::MCTruthContainer<o2::MCCompLabel>*, NITSLayers> mITSClsLabels{}; 
  gsl::span<const o2::MCCompLabel> mITSTrkLabels;                                    
  gsl::span<const o2::MCCompLabel> mTPCTrkLabels;                                    
 
  size_t mNMatches = 0;
  size_t mNCalibPrelim = 0;
  size_t mNMatchesControl = 0;
 
  size_t mNABRefsClus = 0;
  float mAB2MatchGuess = 0.2;                      // heuristic guess about fraction of AB matches in total matches
  std::vector<InteractionCandidate> mInteractions; 
  std::vector<int> mInteractionMUSLUT;             
 
  std::vector<MatchRecord> mMatchRecordsTPC; // RSS DEQ
  std::vector<MatchRecord> mMatchRecordsITS; // RSS DEQ
 
  std::vector<BracketF> mITSROFTimes;       
  std::vector<TrackLocTPC> mTPCWork;        
  std::vector<TrackLocITS> mITSWork;        
  std::vector<o2::MCCompLabel> mTPCLblWork; 
  std::vector<o2::MCCompLabel> mITSLblWork; 
  std::vector<float> mWinnerChi2Refit;      
  std::vector<float> mTBinClOcc;            
 
  // ------------------------------
  std::vector<TPCABSeed> mTPCABSeeds; 
  std::vector<int> mTPCABIndexCache;
  std::vector<int> mABWinnersIDs;
  ITSClusStatus mABClusterStatus;
  std::array<ABLayerClusters, NITSLayers> mABLayerClusters; 
  std::array<int, NITSLayers + 1> mABChipsBounds{};         
  float mABROFMarginMUS = 0.f;                              
  float mITSMaxROFOverhangMUS = 0.f;                        
  LinksPoolMT mABLinksPool;
 
  std::array<std::vector<int>, o2::constants::math::NSectors> mTPCSectIndexCache;
  std::array<std::vector<int>, o2::constants::math::NSectors> mITSSectIndexCache;
 
  std::array<std::vector<int>, o2::constants::math::NSectors> mTPCTimeStart;
  std::array<std::vector<int>, o2::constants::math::NSectors> mITSTimeStart;
 
  std::vector<int> mITSTrackROFContMapping;
 
  o2::its::RecoGeomHelper mRGHelper; 
 
#ifdef _ALLOW_DEBUG_TREES_
  std::unique_ptr<o2::utils::TreeStreamRedirector> mDBGOut;
  UInt_t mDBGFlags = 0;
  std::string mDebugTreeFileName = "dbg_TPCITSmatch.root"; 
#endif
 
  static constexpr float Tan70 = 2.74747771e+00;       // tg(70 degree): std::tan(70.*o2::constants::math::PI/180.);
  static constexpr float Cos70I2 = 1. + Tan70 * Tan70; // 1/cos^2(70) = 1 + tan^2(70)
  static constexpr float MaxSnp = 0.9;                 // max snp of ITS or TPC track at xRef to be matched
  static constexpr float MaxTgp = 2.064;               // max tg corresponting to MaxSnp = MaxSnp/std::sqrt(1.-MaxSnp^2)
  static constexpr float MinTBToCleanCache = 600.;     // keep in AB ITS cluster refs cache at most this number of TPC bins
  static const o2::gpu::GPUTPCGeometry TPCGeometry;
 
  enum TimerIDs { SWTot,
                  SWPrepITS,
                  SWPrepTPC,
                  SWDoMatching,
                  SWSelectBest,
                  SWRefit,
                  SWABSeeds,
                  SWABMatch,
                  SWABWinners,
                  SWABRefit,
                  SWIO,
                  SWDBG,
                  NStopWatches };
  static constexpr std::string_view TimerName[] = {"Total", "PrepareITS", "PrepareTPC", "DoMatching", "SelectBest", "Refit",
                                                   "ABSeeds", "ABMatching", "ABWinners", "ABRefit", "IO", "Debug"};
  TStopwatch mTimer[NStopWatches];
};
 
//______________________________________________
inline bool MatchTPCITS::isValidatedTPC(const TrackLocTPC& t) const
{
  return t.matchID > MinusOne && mMatchRecordsTPC[t.matchID].nextRecID == Validated;
}
 
//______________________________________________
inline bool MatchTPCITS::isValidatedITS(const TrackLocITS& t) const
{
  return t.matchID > MinusOne && mMatchRecordsITS[t.matchID].nextRecID == Validated;
}
 
//______________________________________________
inline bool MatchTPCITS::isDisabledITS(const TrackLocITS& t) const { return t.matchID < 0; }
 
//______________________________________________
inline bool MatchTPCITS::isDisabledTPC(const TrackLocTPC& t) const { return t.matchID < 0; }
 
} // namespace globaltracking
} // namespace o2
 
#endif