GPUTRDTrack.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 GPUTRDTRACK_H
#define GPUTRDTRACK_H
 
#include "GPUTRDDef.h"
#include "GPUCommonDef.h"
#include "GPUCommonRtypes.h"
 
struct GPUTRDTrackDataRecord;
class AliHLTExternalTrackParam;
 
namespace o2::tpc
{
class TrackTPC;
} // namespace o2::tpc
namespace o2::dataformats
{
class TrackTPCITS;
class GlobalTrackID;
} // namespace o2::dataformats
 
//_____________________________________________________________________________
#include "GPUTRDInterfaceO2Track.h"
 
namespace o2::gpu
{
 
template <typename T>
class GPUTRDTrack_t : public T
{
 public:
  enum EGPUTRDTrack {
    kNLayers = 6,
    kAmbiguousFlag = 6,
    kStopFlag = 7
  };
 
  GPUd() GPUTRDTrack_t();
  GPUTRDTrack_t(const typename T::baseClass& t) = delete;
  GPUd() GPUTRDTrack_t(const GPUTRDTrack_t& t);
  GPUd() GPUTRDTrack_t(const AliHLTExternalTrackParam& t);
  GPUd() GPUTRDTrack_t(const o2::dataformats::TrackTPCITS& t);
  GPUd() GPUTRDTrack_t(const o2::tpc::TrackTPC& t);
  GPUd() GPUTRDTrack_t(const T& t);
  GPUd() GPUTRDTrack_t& operator=(const GPUTRDTrack_t& t);
 
  // attach a tracklet to this track; this overwrites the mFlags flag to true for this layer
  GPUd() void addTracklet(int32_t iLayer, int32_t idx) { mAttachedTracklets[iLayer] = idx; }
 
  // getters
  GPUd() int32_t getNlayersFindable() const;
  GPUd() int32_t getTrackletIndex(int32_t iLayer) const { return mAttachedTracklets[iLayer]; }
  GPUd() uint32_t getRefGlobalTrackIdRaw() const { return mRefGlobalTrackId; }
  // This method is only defined in TrackTRD.h and is intended to be used only with that TRD track type
  GPUd() o2::dataformats::GlobalTrackID getRefGlobalTrackId() const;
  GPUd() int16_t getCollisionId() const { return mCollisionId; }
  GPUd() int32_t getNtracklets() const
  {
    // returns number of tracklets attached to this track
    int32_t retVal = 0;
    for (int32_t iLy = 0; iLy < kNLayers; ++iLy) {
      if (mAttachedTracklets[iLy] >= 0) {
        ++retVal;
      }
    }
    return retVal;
  }
 
  GPUd() float getChi2() const { return mChi2; }
  GPUd() float getSignal() const { return mSignal; }
  GPUd() uint8_t getIsCrossingNeighbor() const { return mIsCrossingNeighbor; }
  GPUd() bool getIsCrossingNeighbor(int32_t iLayer) const { return mIsCrossingNeighbor & (1 << iLayer); }
  GPUd() bool getHasNeighbor() const { return mIsCrossingNeighbor & (1 << 6); }
  GPUd() bool getHasPadrowCrossing() const { return mIsCrossingNeighbor & (1 << 7); }
  GPUd() float getReducedChi2() const { return getNlayersFindable() == 0 ? mChi2 : mChi2 / getNlayersFindable(); }
  GPUd() bool getIsStopped() const { return (mFlags >> kStopFlag) & 0x1; }
  GPUd() bool getIsAmbiguous() const { return (mFlags >> kAmbiguousFlag) & 0x1; }
  GPUd() bool getIsFindable(int32_t iLayer) const { return (mFlags >> iLayer) & 0x1; }
  GPUd() int32_t getNmissingConsecLayers(int32_t iLayer) const;
  GPUd() int32_t getIsPenaltyAdded(int32_t iLayer) const { return getIsFindable(iLayer) && getTrackletIndex(iLayer) < 0; }
 
  // setters
  GPUd() void setRefGlobalTrackIdRaw(uint32_t id) { mRefGlobalTrackId = id; }
  // This method is only defined in TrackTRD.h and is intended to be used only with that TRD track type
  GPUd() void setRefGlobalTrackId(o2::dataformats::GlobalTrackID id);
  GPUd() void setCollisionId(int16_t id) { mCollisionId = id; }
  GPUd() void setIsFindable(int32_t iLayer) { mFlags |= (1U << iLayer); }
  GPUd() void setIsStopped() { mFlags |= (1U << kStopFlag); }
  GPUd() void setIsAmbiguous() { mFlags |= (1U << kAmbiguousFlag); }
  GPUd() void setChi2(float chi2) { mChi2 = chi2; }
  GPUd() void setSignal(float signal) { mSignal = signal; }
  GPUd() void setIsCrossingNeighbor(int32_t iLayer) { mIsCrossingNeighbor |= (1U << iLayer); }
  GPUd() void setHasNeighbor() { mIsCrossingNeighbor |= (1U << 6); }
  GPUd() void setHasPadrowCrossing() { mIsCrossingNeighbor |= (1U << 7); }
 
 protected:
  float mChi2;                          // total chi2.
  float mSignal{-1.f};                  // electron Likelihood for track
  uint32_t mRefGlobalTrackId;           // raw GlobalTrackID of the seeding track (either ITS-TPC or TPC)
  int32_t mAttachedTracklets[kNLayers]; // indices of the tracklets attached to this track; -1 means no tracklet in that layer
  int16_t mCollisionId;                 // the collision ID of the tracklets attached to this track; is used to retrieve the BC information for this track after the tracking is done
  uint8_t mFlags;                       // bits 0 to 5 indicate whether track is findable in layer 0 to 5, bit 6 indicates an ambiguous track and bit 7 flags if the track is stopped in the TRD
  uint8_t mIsCrossingNeighbor;          // bits 0 to 5 indicate if a tracklet was either a neighboring tracklet (e.g. a potential split tracklet) or crossed a padrow, bit 6 indicates that a neighbor in any layer has been found and bit 7 if a padrow was crossed
 
 private:
  GPUd() void initialize();
#if !defined(GPUCA_STANDALONE)
  ClassDefNV(GPUTRDTrack_t, 4);
#endif
};
 
} // namespace o2::gpu
 
#endif // GPUTRDTRACK_H