TrackITS.h

Go to the documentation of this file.

// Copyright 2019-2026 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_ITS_TRACKITS_H
#define ALICEO2_ITS_TRACKITS_H
 
#include <cstdint>
 
#include "GPUCommonDef.h"
#include "ReconstructionDataFormats/Track.h"
#include "CommonDataFormat/RangeReference.h"
#include "DataFormatsITS/TimeEstBC.h"
 
namespace o2
{
namespace itsmft
{
class Cluster;
}
 
namespace its
{
 
class TrackITS : public o2::track::TrackParCov
{
  enum UserBits {
    kSharedClusters = 1 << 28
  };
 
  using Cluster = o2::itsmft::Cluster;
  using ClusRefs = o2::dataformats::RangeRefComp<4>;
 
 public:
  using o2::track::TrackParCov::TrackParCov; // inherit base constructors
  static constexpr int MaxClusters = 16;
 
  GPUhdDefault() TrackITS() = default;
  GPUhdDefault() TrackITS(const TrackITS& t) = default;
  GPUhd() TrackITS(const o2::track::TrackParCov& parcov) : o2::track::TrackParCov{parcov} {}
  GPUhd() TrackITS(const o2::track::TrackParCov& parCov, float chi2, const o2::track::TrackParCov& outer)
    : o2::track::TrackParCov{parCov}, mParamOut{outer}, mChi2{chi2} {}
  GPUhdDefault() TrackITS& operator=(const TrackITS& tr) = default;
  GPUhdDefault() TrackITS& operator=(TrackITS&& tr) = default;
  GPUhdDefault() ~TrackITS() = default;
 
  // These functions must be provided
  bool propagate(float alpha, float x, float bz);
  bool update(const Cluster& c, float chi2);
 
  // Other functions
  GPUhdi() float getChi2() const { return mChi2; }
  GPUhdi() int getNClusters() const { return mClusRef.getEntries(); }
  GPUhdi() int getNumberOfClusters() const { return getNClusters(); }
  int getFirstClusterEntry() const { return mClusRef.getFirstEntry(); }
  int getClusterEntry(int i) const { return getFirstClusterEntry() + i; }
  void shiftFirstClusterEntry(int bias)
  {
    mClusRef.setFirstEntry(mClusRef.getFirstEntry() + bias);
  }
  void setFirstClusterEntry(int offs)
  {
    mClusRef.setFirstEntry(offs);
  }
  void setNumberOfClusters(int n)
  {
    mClusRef.setEntries(n);
  }
  bool operator<(const TrackITS& o) const;
  void getImpactParams(float x, float y, float z, float bz, float ip[2]) const;
  // bool getPhiZat(float r,float &phi,float &z) const;
 
  void setClusterRefs(int firstEntry, int n)
  {
    mClusRef.set(firstEntry, n);
  }
 
  const ClusRefs& getClusterRefs() const { return mClusRef; }
  GPUhdi() ClusRefs& getClusterRefs() { return mClusRef; }
 
  GPUhdi() void setChi2(float chi2) { mChi2 = chi2; }
 
  bool isBetter(const TrackITS& best, float maxChi2) const;
 
  GPUhdi() auto& getTimeStamp() { return mTime; }
  GPUhdi() const auto& getTimeStamp() const { return mTime; }
 
  GPUhdi() o2::track::TrackParCov& getParamIn() { return *this; }
  GPUhdi() const o2::track::TrackParCov& getParamIn() const { return *this; }
 
  GPUhdi() o2::track::TrackParCov& getParamOut() { return mParamOut; }
  GPUhdi() const o2::track::TrackParCov& getParamOut() const { return mParamOut; }
 
  GPUhdi() void setPattern(uint32_t p) { mPattern = p; }
  GPUhdi() uint32_t getPattern() const { return mPattern; }
  bool hasHitOnLayer(uint32_t i) const { return mPattern & (0x1 << i); }
  bool isFakeOnLayer(uint32_t i) const { return !(mPattern & (0x1 << (16 + i))); }
  bool isExtendedOnLayer(uint32_t i) const { return (mPattern & (0x1 << (24 + i))); } // only correct if getNClusters <= 8 on layers <= 8
  uint32_t getLastClusterLayer() const
  {
    uint32_t r{0}, v{mPattern & ((1 << 16) - 1)};
    while (v >>= 1) {
      r++;
    }
    return r;
  }
  uint32_t getFirstClusterLayer() const
  {
    int s{0};
    while (!(mPattern & (1 << s))) {
      s++;
    }
    return s;
  }
  int getNFakeClusters() const;
 
  void setSharedClusters(bool toggle = true) { mClusterSizes = toggle ? (mClusterSizes | kSharedClusters) : (mClusterSizes & ~kSharedClusters); }
  bool hasSharedClusters() const { return mClusterSizes & kSharedClusters; }
 
  void setClusterSize(int l, int size)
  {
    if (l >= 8) {
      return;
    }
    if (size > 15) {
      size = 15;
    }
    mClusterSizes &= ~(0xf << (l * 4));
    mClusterSizes |= (size << (l * 4));
  }
 
  int getClusterSize(int l)
  {
    if (l >= 7) {
      return 0;
    }
    return (mClusterSizes >> (l * 4)) & 0xf;
  }
 
  int getClusterSizes() const
  {
    return mClusterSizes;
  }
 
 private:
  o2::track::TrackParCov mParamOut; 
  ClusRefs mClusRef;                
  float mChi2 = 0.;                 
  uint32_t mPattern = 0;            
  uint32_t mClusterSizes = 0u;      
  TimeStamp mTime;                  
 
  ClassDefNV(TrackITS, 7);
};
 
class TrackITSExt : public TrackITS
{
 public:
  static constexpr int MaxClusters = 16; 
  using TrackITS::TrackITS;              // inherit base constructors
 
  GPUh() TrackITSExt(o2::track::TrackParCov&& parCov, short ncl, float chi2, o2::track::TrackParCov&& outer, std::array<int, MaxClusters> cls)
    : TrackITS(parCov, chi2, outer), mIndex{cls}
  {
    setNumberOfClusters(ncl);
  }
 
  GPUh() TrackITSExt(o2::track::TrackParCov& parCov, short ncl, float chi2, std::uint32_t rof, o2::track::TrackParCov& outer, std::array<int, MaxClusters> cls)
    : TrackITS(parCov, chi2, outer), mIndex{cls}
  {
    setNumberOfClusters(ncl);
  }
 
  GPUhdDefault() TrackITSExt(const TrackITSExt& t) = default;
 
  void setClusterIndex(int l, int i)
  {
    int ncl = getNumberOfClusters();
    mIndex[ncl++] = (l << 28) + i;
    getClusterRefs().setEntries(ncl);
  }
 
  GPUhdi() int getClusterIndex(int lr) const { return mIndex[lr]; }
 
  GPUh() int getFirstLayerClusterIndex() const
  {
    return getClusterIndex(getFirstClusterLayer());
  }
 
  GPUhdi() void setExternalClusterIndex(int layer, int idx, bool newCluster = false)
  {
    if (newCluster) {
      getClusterRefs().setEntries(getNumberOfClusters() + 1);
      uint32_t pattern = getPattern();
      pattern |= 0x1 << layer;
      setPattern(pattern);
    }
    mIndex[layer] = idx;
  }
 
  GPUh() std::array<int, MaxClusters>& getClusterIndexes()
  {
    return mIndex;
  }
 
#ifndef GPUCA_GPUCODE
  // build order-independent hash via the external cluster idx (unique within a TF) for the selected layers
  // cluster indices are either sorted inward or outward
  size_t hash(uint16_t layerMask = 0xFFFF, bool inward = true) const noexcept
  {
    size_t h1 = 0, h2 = 0;
    int from = (int)getLastClusterLayer(), to = -1, step = -1;
    if (inward) {
      from = (int)getFirstClusterLayer();
      to = MaxClusters;
      step = 1;
    }
    // clusters are stored continously but they do not necesarrily correspond to the layers
    for (int layer = from, slot{0}; layer != to; layer += step) {
      if (hasHitOnLayer(layer)) {
        int idx = mIndex[slot++];
        if (layerMask & (uint16_t(1) << layer)) {
          size_t v = std::hash<int>{}(idx);
          h1 ^= v;
          h2 += v * 0x9e3779b97f4a7c15ULL; // boost's hash_combine
        }
      }
    }
    return h1 ^ (h2 << 1);
  }
#endif
 
 private:
  std::array<int, MaxClusters> mIndex = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; 
  ClassDefNV(TrackITSExt, 3);
};
} // namespace its
} // namespace o2
#endif /* ALICEO2_ITS_TRACKITS_H */