Merge branch 'AliceO2Group:dev' into new-detector4

Author: pkurash

DataFormats/simulation/include/SimulationDataFormat/TrackReference.h

@@ -171,7 +171,7 @@ class TrackReference
   float mTrackLength = 0; ///< track length from its origin in cm
   float mTof = 0;         ///< time of flight in cm
   Int_t mUserId = 0;      ///< optional Id defined by user
-  Int_t mDetectorId = 0;  ///< Detector Id
+  Int_t mDetectorId = -1; ///< sensitive Detector Id (-1 if unknown or in passive material)
   SimTrackStatus mStatus; ///< encoding the track status
 
   friend std::ostream& operator<<(std::ostream&, const TrackReference&);

Detectors/AOD/src/AODProducerWorkflowSpec.cxx

@@ -2717,7 +2717,7 @@ AODProducerWorkflowDPL::TrackQA AODProducerWorkflowDPL::processBarrelTrackQA(int
     if (auto itsContGID = data.getITSContributorGID(trackIndex); itsContGID.isIndexSet() && itsContGID.getSource() != GIndex::ITSAB) {
       const auto& itsOrig = data.getITSTrack(itsContGID);
       o2::track::TrackPar gloCopy = trackPar;
-      o2::track::TrackPar itsCopy = itsOrig;
+      o2::track::TrackPar itsCopy = itsOrig.getParamOut();
       o2::track::TrackPar tpcCopy = tpcOrig;
       if (prop->propagateToX(gloCopy, o2::aod::track::trackQARefRadius, prop->getNominalBz(), o2::base::Propagator::MAX_SIN_PHI, o2::base::Propagator::MAX_STEP, mMatCorr) &&
           prop->propagateToAlphaX(tpcCopy, gloCopy.getAlpha(), o2::aod::track::trackQARefRadius, false, o2::base::Propagator::MAX_SIN_PHI, o2::base::Propagator::MAX_STEP, 1, mMatCorr) &&

Detectors/ITSMFT/ITS/tracking/CMakeLists.txt

@@ -36,7 +36,9 @@ o2_add_library(ITStracking
                        O2::ITSReconstruction
                        O2::ITSMFTReconstruction
                        O2::DataFormatsITS
-               PRIVATE_LINK_LIBRARIES TBB::tbb)
+               PRIVATE_LINK_LIBRARIES
+                       O2::Steer
+                       TBB::tbb)
 
 o2_add_library(ITSTrackingInterface
                TARGETVARNAME targetName

Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx

@@ -246,7 +246,7 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
                                         this->mTrkParams[0].MaxChi2ClusterAttachment,
                                         this->mTrkParams[0].MaxChi2NDF,
                                         mTimeFrameGPU->getDevicePropagator(),
-                                        this->mCorrType,
+                                        this->mTrkParams[0].CorrType,
                                         conf.nBlocks,
                                         conf.nThreads);
     }
@@ -268,7 +268,7 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
                      this->mTrkParams[0].MaxChi2ClusterAttachment,     // float maxChi2ClusterAttachment
                      this->mTrkParams[0].MaxChi2NDF,                   // float maxChi2NDF
                      mTimeFrameGPU->getDevicePropagator(),             // const o2::base::Propagator* propagator
-                     this->mCorrType,                                  // o2::base::PropagatorImpl<float>::MatCorrType
+                     this->mTrkParams[0].CorrType,                     // o2::base::PropagatorImpl<float>::MatCorrType
                      conf.nBlocks,
                      conf.nThreads);
 

Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu

@@ -58,30 +58,43 @@ namespace gpu
 {
 
 template <typename T>
-class TypedAllocator : public thrust::device_allocator<T>
-{
- public:
+struct TypedAllocator {
   using value_type = T;
-  using pointer = T*;
+  using pointer = thrust::device_ptr<T>;
+  using const_pointer = thrust::device_ptr<const T>;
+  using size_type = std::size_t;
+  using difference_type = std::ptrdiff_t;
+
+  TypedAllocator() noexcept : mInternalAllocator(nullptr) {}
+  explicit TypedAllocator(ExternalAllocator* a) noexcept : mInternalAllocator(a) {}
 
   template <typename U>
-  struct rebind {
-    using other = TypedAllocator<U>;
-  };
+  TypedAllocator(const TypedAllocator<U>& o) noexcept : mInternalAllocator(o.mInternalAllocator)
+  {
+  }
 
-  explicit TypedAllocator(ExternalAllocator* allocPtr)
-    : mInternalAllocator(allocPtr) {}
+  pointer allocate(size_type n)
+  {
+    void* raw = mInternalAllocator->allocate(n * sizeof(T));
+    return thrust::device_pointer_cast(static_cast<T*>(raw));
+  }
 
-  T* allocate(size_t n)
+  void deallocate(pointer p, size_type n) noexcept
   {
-    return reinterpret_cast<T*>(mInternalAllocator->allocate(n * sizeof(T)));
+    if (!p) {
+      return;
+    }
+    void* raw = thrust::raw_pointer_cast(p);
+    mInternalAllocator->deallocate(static_cast<char*>(raw), n * sizeof(T));
   }
 
-  void deallocate(T* p, size_t n)
+  bool operator==(TypedAllocator const& o) const noexcept
+  {
+    return mInternalAllocator == o.mInternalAllocator;
+  }
+  bool operator!=(TypedAllocator const& o) const noexcept
   {
-    char* raw_ptr = reinterpret_cast<char*>(p);
-    size_t bytes = n * sizeof(T);
-    mInternalAllocator->deallocate(raw_ptr, bytes); // redundant as internal dealloc is no-op.
+    return !(*this == o);
   }
 
  private:

Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h

@@ -26,36 +26,8 @@
 #include "DetectorsBase/Propagator.h"
 #include "ITStracking/Constants.h"
 
-namespace o2
+namespace o2::its
 {
-namespace its
-{
-
-enum class TrackingMode {
-  Sync,
-  Async,
-  Cosmics,
-  Unset, // Special value to leave a default in case we want to override via Configurable Params
-};
-
-std::string asString(TrackingMode mode);
-std::ostream& operator<<(std::ostream& os, TrackingMode v);
-
-template <typename Param>
-class Configuration : public Param
-{
- public:
-  static Configuration<Param>& getInstance()
-  {
-    static Configuration<Param> instance;
-    return instance;
-  }
-  Configuration(const Configuration<Param>&) = delete;
-  const Configuration<Param>& operator=(const Configuration<Param>&) = delete;
-
- private:
-  Configuration() = default;
-};
 
 struct TrackingParameters {
   int CellMinimumLevel() const noexcept { return MinTrackLength - constants::ClustersPerCell + 1; }
@@ -140,6 +112,8 @@ struct VertexingParameters {
   int zSpan = -1;
   bool SaveTimeBenchmarks = false;
 
+  bool useTruthSeeding = false; // overwrite found vertices with MC events
+
   int nThreads = 1;
   bool PrintMemory = false; // print allocator usage in epilog report
   size_t MaxMemory = std::numeric_limits<size_t>::max();
@@ -166,7 +140,24 @@ struct TimeFrameGPUParameters {
   int maxGPUMemoryGB = -1;
 };
 
-} // namespace its
-} // namespace o2
+namespace TrackingMode
+{
+enum Type : int8_t {
+  Unset = -1, // Special value to leave a default in case we want to override via Configurable Params
+  Sync = 0,
+  Async = 1,
+  Cosmics = 2,
+  Off = 3,
+};
+
+Type fromString(std::string_view str);
+std::string toString(Type mode);
+
+std::vector<TrackingParameters> getTrackingParameters(Type mode);
+std::vector<VertexingParameters> getVertexingParameters(Type mode);
+
+}; // namespace TrackingMode
+
+} // namespace o2::its
 
 #endif /* TRACKINGITSU_INCLUDE_CONFIGURATION_H_ */

Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h

@@ -71,9 +71,7 @@ class Tracker
   void setParameters(const std::vector<TrackingParameters>& p) { mTrkParams = p; }
   void setMemoryPool(std::shared_ptr<BoundedMemoryResource>& pool) { mMemoryPool = pool; }
   std::vector<TrackingParameters>& getParameters() { return mTrkParams; }
-  void getGlobalConfiguration();
   void setBz(float bz) { mTraits->setBz(bz); }
-  void setCorrType(const o2::base::PropagatorImpl<float>::MatCorrType type) { mTraits->setCorrType(type); }
   bool isMatLUT() const { return mTraits->isMatLUT(); }
   void setNThreads(int n, std::shared_ptr<tbb::task_arena>& arena) { mTraits->setNThreads(n, arena); }
   void printSummary() const;

Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h

@@ -65,7 +65,6 @@ class TrackerTraits
 
   virtual void setBz(float bz);
   float getBz() const { return mBz; }
-  void setCorrType(const o2::base::PropagatorImpl<float>::MatCorrType type) { mCorrType = type; }
   bool isMatLUT() const;
   virtual const char* getName() const noexcept { return "CPU"; }
   virtual bool isGPU() const noexcept { return false; }
@@ -99,7 +98,6 @@ class TrackerTraits
   std::shared_ptr<tbb::task_arena> mTaskArena;
 
  protected:
-  o2::base::PropagatorImpl<float>::MatCorrType mCorrType = o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrNONE;
   o2::gpu::GPUChainITS* mChain = nullptr;
   TimeFrame<nLayers>* mTimeFrame;
   std::vector<TrackingParameters> mTrkParams;

Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h

@@ -48,6 +48,8 @@ struct VertexerParamConfig : public o2::conf::ConfigurableParamHelper<VertexerPa
   int ZBins = 1;     // z-phi index table configutation: number of z bins
   int PhiBins = 128; // z-phi index table configutation: number of phi bins
 
+  bool useTruthSeeding{false}; // overwrite seeding vertices with MC truth
+
   int nThreads = 1;
   bool printMemory = false;
   size_t maxMemory = std::numeric_limits<size_t>::max();

Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h

@@ -68,13 +68,7 @@ class ITSTrackingInterface
 
   // Custom
   void setTraitsFromProvider(VertexerTraits*, TrackerTraits7*, TimeFrame7*);
-  void setTrackingMode(TrackingMode mode = TrackingMode::Unset)
-  {
-    if (mode == TrackingMode::Unset) {
-      LOGP(fatal, "ITS Tracking mode Unset is meant to be a default. Specify the mode");
-    }
-    mMode = mode;
-  }
+  void setTrackingMode(TrackingMode::Type mode = TrackingMode::Unset) { mMode = mode; }
 
   auto getTracker() const { return mTracker.get(); }
   auto getVertexer() const { return mVertexer.get(); }
@@ -86,14 +80,13 @@ class ITSTrackingInterface
                        gsl::span<const itsmft::CompClusterExt> clusters,
                        gsl::span<const unsigned char>::iterator& pattIt,
                        const dataformats::MCTruthContainer<MCCompLabel>* mcLabels);
-  void getConfiguration(framework::ProcessingContext& pc);
 
  private:
   bool mIsMC = false;
   bool mRunVertexer = true;
   bool mCosmicsProcessing = false;
   int mUseTriggers = 0;
-  TrackingMode mMode = TrackingMode::Unset;
+  TrackingMode::Type mMode = TrackingMode::Unset;
   bool mOverrideBeamEstimation = false;
   const o2::itsmft::TopologyDictionary* mDict = nullptr;
   std::unique_ptr<Tracker> mTracker = nullptr;