Merge branch 'AliceO2Group:dev' into fd3_digits

Author: pkurash

CCDB/src/CcdbApi.cxx

@@ -213,8 +213,7 @@ void CcdbApi::init(std::string const& host)
     snapshotReport += ')';
   }
 
-  mNeedAlienToken = (host.find("https://") != std::string::npos) || (host.find("alice-ccdb.cern.ch") != std::string::npos);
-
+  mNeedAlienToken = (host.find("https://") != std::string::npos) || (host.find("alice-ccdb.cern.ch") != std::string::npos) || (host.find("ccdb-test.cern.ch") != std::string::npos);
   // Set the curl timeout. It can be forced with an env var or it has different defaults based on the deployment mode.
   if (getenv("ALICEO2_CCDB_CURL_TIMEOUT_DOWNLOAD")) {
     auto timeout = atoi(getenv("ALICEO2_CCDB_CURL_TIMEOUT_DOWNLOAD"));

DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TrackITS.h

@@ -192,7 +192,12 @@ class TrackITSExt : public TrackITS
     getClusterRefs().setEntries(ncl);
   }
 
-  GPUhdi() const int& getClusterIndex(int lr) const { return mIndex[lr]; }
+  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)
   {

Detectors/GlobalTrackingWorkflow/study/src/CheckResidSpec.cxx

@@ -132,7 +132,7 @@ void CheckResidSpec::init(InitContext& ic)
   int maxLanes = ic.services().get<const o2::framework::DeviceSpec>().maxInputTimeslices;
   std::string nm = params.outname;
   if (maxLanes > 1) {
-    o2::conf::ConfigurableParam::updateFromString(fmt::format("checkresid.outname={}_{}", nm, lane));
+    o2::conf::ConfigurableParam::updateFromString(fmt::format("checkresid.outname={}_t{}", nm, lane));
   }
   if (mDraw) {
     mFillHistos = true;
@@ -173,8 +173,7 @@ void CheckResidSpec::init(InitContext& ic)
   mNThreads = 1;
 #endif
   if (mFillTree) {
-    nm += ".root";
-    mDBGOut = std::make_unique<o2::utils::TreeStreamRedirector>(nm.c_str(), "recreate");
+    mDBGOut = std::make_unique<o2::utils::TreeStreamRedirector>(fmt::format("{}.root", params.outname).c_str(), "recreate");
   }
 }
 

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

@@ -309,8 +309,7 @@ void TrackerTraitsGPU<NLayers>::findRoads(const int iteration)
     bounded_vector<TrackSeed<NLayers>> trackSeeds(this->getMemoryPool().get());
     for (int startCellTopologyId{0}; startCellTopologyId < hostTopology.nCells; ++startCellTopologyId) {
       const int startLayer = hostTopology.getCell(startCellTopologyId).hitLayerMask.last();
-      if ((this->mTrkParams[iteration].StartLayerMask & (1 << startLayer)) == 0 ||
-          mTimeFrameGPU->getNCells()[startCellTopologyId] == 0) {
+      if (!(this->mTrkParams[iteration].StartLayerMask.has(startLayer)) || mTimeFrameGPU->getNCells()[startCellTopologyId] == 0) {
         continue;
       }
       processNeighboursHandler<NLayers>(startLevel,
@@ -387,10 +386,10 @@ void TrackerTraitsGPU<NLayers>::findRoads(const int iteration)
     mTimeFrameGPU->downloadTrackITSExtDevice();
 
     auto& tracks = mTimeFrameGPU->getTrackITSExt();
-    this->acceptTracks(iteration, tracks, firstClusters, sharedFirstClusters);
+    this->acceptTracks(iteration, tracks, firstClusters);
     mTimeFrameGPU->loadUsedClustersDevice();
   }
-  this->markTracks(iteration, sharedFirstClusters);
+  this->markTracks(iteration);
   // wipe the artefact memory
   mTimeFrameGPU->popMemoryStack(iteration);
 };

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

@@ -26,6 +26,7 @@
 #include "CommonUtils/EnumFlags.h"
 #include "DetectorsBase/Propagator.h"
 #include "ITStracking/Constants.h"
+#include "ITStracking/LayerMask.h"
 
 namespace o2::its
 {
@@ -70,11 +71,9 @@ struct TrackingParameters {
   float DiamondCov[6] = {25.e-6f, 0.f, 0.f, 25.e-6f, 0.f, 36.f};
 
   /// General parameters
-  bool AllowSharingFirstCluster = false;
-  int ClusterSharing = 0;
   int MinTrackLength = 7;
   int MaxHoles = 0;
-  uint16_t HoleLayerMask = 0;
+  LayerMask HoleLayerMask = 0;
   float NSigmaCut = 5;
   float PVres = 1.e-2f;
   /// Trackleting cuts
@@ -87,7 +86,7 @@ struct TrackingParameters {
   float MaxChi2NDF = 30.f;
   int ReseedIfShorter = 6; // reseed for the final fit track with the length shorter than this
   std::vector<float> MinPt = {0.f, 0.f, 0.f, 0.f};
-  uint16_t StartLayerMask = 0x7F;
+  LayerMask StartLayerMask = 0x7F;
   bool RepeatRefitOut = false;   // repeat outward refit using inward refit as a seed
   bool ShiftRefToCluster = true; // TrackFit: after update shift the linearization reference to cluster
   bool PerPrimaryVertexProcessing = false;
@@ -98,6 +97,13 @@ struct TrackingParameters {
   bool PrintMemory = false; // print allocator usage in epilog report
   size_t MaxMemory = std::numeric_limits<size_t>::max();
   bool DropTFUponFailure = false;
+
+  // Selections on tracks sharing clusters
+  bool AllowSharingFirstCluster = false;
+  float SharedClusterMaxDeltaPhi = 0.05f; // For tracks sharing clusters, maximum allowed delta phi at the cluster position
+  float SharedClusterMaxDeltaEta = 0.03f; // For tracks sharing clusters, maximum allowed delta eta at the cluster position
+  bool SharedClusterOppositeSign = false; // For tracks sharing clusters, require opposite sign of the tracklets
+  int SharedMaxClusters = 0;              // Maximal allowed shared clusters (excluding first cluster)
 };
 
 struct VertexingParameters {

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

@@ -55,8 +55,8 @@ class TrackerTraits
   template <typename InputSeed>
   void processNeighbours(int iteration, int defaultCellTopologyId, int iLevel, const bounded_vector<InputSeed>& currentCellSeed, const bounded_vector<int>& currentCellId, const bounded_vector<int>& currentCellTopologyId, bounded_vector<TrackSeedN>& updatedCellSeed, bounded_vector<int>& updatedCellId, bounded_vector<int>& updatedCellTopologyId);
 
-  void acceptTracks(int iteration, bounded_vector<TrackITSExt>& tracks, bounded_vector<bounded_vector<int>>& firstClusters, bounded_vector<bounded_vector<int>>& sharedFirstClusters);
-  void markTracks(int iteration, bounded_vector<bounded_vector<int>>& sharedFirstClusters);
+  void acceptTracks(int iteration, bounded_vector<TrackITSExt>& tracks, bounded_vector<bounded_vector<int>>& firstClusters);
+  void markTracks(int iteration);
 
   void updateTrackingParameters(const std::vector<TrackingParameters>& trkPars)
   {

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

@@ -102,7 +102,12 @@ struct TrackerParamConfig : public o2::conf::ConfigurableParamHelper<TrackerPara
   size_t maxMemory = std::numeric_limits<size_t>::max();
   bool dropTFUponFailure = false;
   bool fataliseUponFailure = true;       // granular management of the fatalisation in async mode
+
+  // Selections on tracks sharing clusters
   bool allowSharingFirstCluster = false; // allow first cluster sharing among tracks
+  float sharedClusterMaxDeltaPhi = 0.05f; // Maximum allowed delta phi at the cluster position
+  float sharedClusterMaxDeltaEta = 0.03f; // Maximum allowed delta eta at the cluster position
+  bool sharedClusterOppositeSign = false; // Require opposite sign of the tracklets
 
   O2ParamDef(TrackerParamConfig, "ITSCATrackerParam");
 };

Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx

@@ -24,8 +24,9 @@ using namespace o2::its;
 
 std::string TrackingParameters::asString() const
 {
-  std::string str = std::format("NZb:{} NPhB:{} PerVtx:{} DropFail:{} ClSh:{} TtklMinPt:{:.2f} MinCl:{} MaxHoles:{} HoleMask:{:#x}",
-                                ZBins, PhiBins, PerPrimaryVertexProcessing, DropTFUponFailure, ClusterSharing, TrackletMinPt, MinTrackLength, MaxHoles, HoleLayerMask);
+  std::string str = std::format("NZb:{} NPhB:{} PerVtx:{} DropFail:{} TtklMinPt:{:.2f} MinCl:{}", ZBins, PhiBins, PerPrimaryVertexProcessing, DropTFUponFailure, TrackletMinPt, MinTrackLength);
+  auto isSet = [](auto e) { return e >= 0; };
+  auto isAnySet = [&isSet](auto v) { return !v.empty() && std::any_of(v.begin(), v.end(), isSet); };
   bool first = true;
   for (int il = NLayers; il >= MinTrackLength; il--) {
     int slot = NLayers - il;
@@ -37,18 +38,27 @@ std::string TrackingParameters::asString() const
       str += std::format("L{}:{:.2f} ", il, MinPt[slot]);
     }
   }
-  if (!SystErrorY2.empty() || !SystErrorZ2.empty()) {
+  if (isAnySet(SystErrorY2) || isAnySet(SystErrorZ2)) {
     str += " SystErrY/Z:";
     for (size_t i = 0; i < SystErrorY2.size(); i++) {
       str += std::format("{:.2e}/{:.2e} ", SystErrorY2[i], SystErrorZ2[i]);
     }
   }
-  if (!AddTimeError.empty()) {
+  if (isAnySet(AddTimeError)) {
     str += " AddTimeError:";
     for (unsigned int i : AddTimeError) {
       str += std::format("{} ", i);
     }
   }
+  if (SharedMaxClusters) {
+    str += std::format(" ShaMaxCls:{} ", SharedMaxClusters);
+  }
+  if (AllowSharingFirstCluster) {
+    str += std::format(" ShaClsDPhi:{} ShaClsDEta:{} ShaClsSign:{}", SharedClusterMaxDeltaPhi, SharedClusterMaxDeltaEta, SharedClusterOppositeSign);
+  }
+  if (MaxHoles) {
+    str += std::format(" MaxHoles:{} HoleMask:{}", MaxHoles, HoleLayerMask.asString());
+  }
   if (std::numeric_limits<size_t>::max() != MaxMemory) {
     str += std::format(" MemLimit {:.2f} GB", double(MaxMemory) / constants::GB);
   }
@@ -204,6 +214,9 @@ std::vector<TrackingParameters> TrackingMode::getTrackingParameters(TrackingMode
     p.SaveTimeBenchmarks = tc.saveTimeBenchmarks;
     p.FataliseUponFailure = tc.fataliseUponFailure;
     p.AllowSharingFirstCluster = tc.allowSharingFirstCluster;
+    p.SharedClusterMaxDeltaPhi = tc.sharedClusterMaxDeltaPhi;
+    p.SharedClusterMaxDeltaEta = tc.sharedClusterMaxDeltaEta;
+    p.SharedClusterOppositeSign = tc.sharedClusterOppositeSign;
     const auto iter = &p - trackParams.data();
     if (iter < constants::MaxIter) {
       p.MaxHoles = tc.maxHolesIter[iter];

Detectors/ITSMFT/ITS/tracking/src/FastMultEst.cxx

@@ -168,85 +168,41 @@ int FastMultEst::selectROFs(const std::array<gsl::span<const o2::itsmft::ROFReco
                             ROFMaskTableN& sel)
 {
   const auto& multEstConf = FastMultEstConfig::Instance(); // parameters for mult estimation and cuts
-  const int selectionLayer = overlapView.getClock();
-  int multLayer = std::clamp(multEstConf.cutMultClusLayer, 0, NLayers - 1);
-  if (doStaggering && rofs[multLayer].empty()) {
-    LOGP(info, "FastMultEst multiplicity layer {} has no ROFs, falling back to selection layer {}", multLayer, selectionLayer);
-    multLayer = selectionLayer;
-  }
-
-  const auto multCounts = buildMultiplicityCounts<NLayers>(rofs, clus, doStaggering, multLayer);
+  const int selectionLayer = multEstConf.isMultCutRequested() ? std::clamp(multEstConf.cutMultClusLayer, 0, NLayers - 1) : overlapView.getClock();
+  const auto multCounts = buildMultiplicityCounts<NLayers>(rofs, clus, doStaggering, selectionLayer);
   const int selectionRofCount = doStaggering ? static_cast<int>(rofs[selectionLayer].size()) : static_cast<int>(rofs[0].size());
 
   sel.resetMask();
   lastRandomSeed = gRandom->GetSeed();
   const o2::InteractionRecord tfStartIR{0, firstTForbit};
-
-  if (!trig.empty()) {
+  // mask ROFs which are not good from the multiplicity selection (if any) POV
+  struct ROFStatus {
+    int entry = 0, priority = 0;
+  };
+  std::vector<ROFStatus> selROFs;
+  selROFs.reserve(selectionRofCount);
+  bool selmult = multEstConf.isMultCutRequested();
+  for (int selectionRof = 0; selectionRof < selectionRofCount; ++selectionRof) {
+    selROFs.emplace_back(selectionRof, (selmult && !multEstConf.isPassingMultCut(process(multCounts[selectionRof]))) ? -1 : 0);
+  }
+  if (!trig.empty() && multEstConf.preferTriggered) {
     const auto& selectionLayerTiming = overlapView.getLayer(selectionLayer);
-    const auto& multLayerTiming = overlapView.getLayer(multLayer);
-
     for (const auto& trigger : trig) {
       const int selectionRof = findROFForIR(trigger.ir, tfStartIR, selectionLayerTiming);
-      if (selectionRof < 0) {
-        continue;
-      }
-      if (multEstConf.cutRandomFraction > 0.f && gRandom->Rndm() < multEstConf.cutRandomFraction) {
-        continue;
-      }
-      if (multEstConf.isMultCutRequested()) {
-        const int triggerMultRof = doStaggering ? findROFForIR(trigger.ir, tfStartIR, multLayerTiming) : selectionRof;
-        if (triggerMultRof < 0 || triggerMultRof >= static_cast<int>(multCounts.size())) {
-          continue;
-        }
-        if (!multEstConf.isPassingMultCut(process(multCounts[triggerMultRof]))) {
-          continue;
-        }
-      }
-      enableCompatibleROFs<NLayers>(selectionLayer, selectionRof, overlapView, sel);
-    }
-  } else {
-    LOGP(info, "FastMultEst received no physics/TRD triggers, falling back to ROF-driven filtering on layer {}", selectionLayer);
-    for (int selectionRof = 0; selectionRof < selectionRofCount; ++selectionRof) {
-      if (multEstConf.isMultCutRequested()) {
-        bool passes = false;
-        if (!doStaggering || selectionLayer == multLayer) {
-          if (selectionRof < static_cast<int>(multCounts.size())) {
-            passes = multEstConf.isPassingMultCut(process(multCounts[selectionRof]));
-          }
-        } else {
-          const auto& overlap = overlapView.getOverlap(selectionLayer, multLayer, selectionRof);
-          for (int rof = overlap.getFirstEntry(); rof < overlap.getEntriesBound(); ++rof) {
-            if (rof < static_cast<int>(multCounts.size())) {
-              if (multEstConf.isPassingMultCut(process(multCounts[rof]))) {
-                passes = true;
-                break;
-              }
-            }
-          }
-        }
-        if (!passes) {
-          continue;
-        }
-      }
-      if (multEstConf.cutRandomFraction > 0.f && gRandom->Rndm() < multEstConf.cutRandomFraction) {
+      if (selectionRof < 0 || selROFs[selectionRof].priority < 0) {
         continue;
       }
-      enableCompatibleROFs<NLayers>(selectionLayer, selectionRof, overlapView, sel);
+      selROFs[selectionRof].priority++; // increment trigger counter
     }
+    sort(selROFs.begin(), selROFs.end(), [](const ROFStatus& a, const ROFStatus& b) { return a.priority > b.priority; }); // order in number of triggers, masked will go to the end
   }
-
-  const auto selView = sel.getView();
   int nsel = 0;
-  for (int irof = 0; irof < selectionRofCount; ++irof) {
-    nsel += selView.isROFEnabled(selectionLayer, irof);
-  }
-
-  if (!trig.empty() && multEstConf.preferTriggered) {
-    LOGP(debug, "FastMultEst preferTriggered is ignored in trigger-driven mask mode");
+  for (auto& rof : selROFs) {
+    if (rof.priority >= 0 && (multEstConf.cutRandomFraction <= 0.f || (gRandom->Rndm() > multEstConf.cutRandomFraction))) {
+      enableCompatibleROFs<NLayers>(selectionLayer, rof.entry, overlapView, sel);
+      nsel++;
+    }
   }
-
   LOGP(debug, "NSel = {} of {} rofs on layer {} Seeds: before {} after {}", nsel, selectionRofCount, selectionLayer, lastRandomSeed, gRandom->GetSeed());
-
   return nsel;
 }