Merge a94a33b into sapling-pr-archive-ehellbar

ehellbar · web-flow · commit 99aad7a277dd · 2026-01-21T09:48:47.000+01:00
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
@@ -219,6 +219,7 @@ void trackSeedHandler(CellSeed<nLayers>* trackSeeds,
                       const float maxChi2ClusterAttachment,
                       const float maxChi2NDF,
                       const int reseedIfShorter,
+                      const bool repeatRefitOut,
                       const bool shiftRefToCluster,
                       const o2::base::Propagator* propagator,
                       const o2::base::PropagatorF::MatCorrType matCorrType,
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -336,6 +336,7 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
                      startLevel,                                       // const int startLevel,
                      this->mTrkParams[0].MaxChi2ClusterAttachment,     // float maxChi2ClusterAttachment
                      this->mTrkParams[0].MaxChi2NDF,                   // float maxChi2NDF
+                     this->mTrkParams[0].RepeatRefitOut,
                      this->mTrkParams[0].ReseedIfShorter,
                      this->mTrkParams[0].ShiftRefToCluster,
                      mTimeFrameGPU->getDevicePropagator(), // const o2::base::Propagator* propagator
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -291,6 +291,7 @@ GPUg() void __launch_bounds__(256, 1) fitTrackSeedsKernel(
   const float maxChi2ClusterAttachment,
   const float maxChi2NDF,
   const int reseedIfShorter,
+  const bool repeatRefitOut,
   const bool shifRefToCluster,
   const o2::base::Propagator* propagator,
   const o2::base::PropagatorF::MatCorrType matCorrType)
@@ -337,6 +338,34 @@ GPUg() void __launch_bounds__(256, 1) fitTrackSeedsKernel(
     if (!fitSuccess || temporaryTrack.getPt() < minPts[nLayers - temporaryTrack.getNClusters()]) {
       continue;
     }
+    if (repeatRefitOut) { // repeat outward refit seeding and linearizing with the stable inward fit result
+      o2::track::TrackParCov saveInw{temporaryTrack};
+      linRef = saveInw; // use refitted track as lin.reference
+      float saveChi2 = temporaryTrack.getChi2();
+      temporaryTrack.resetCovariance();
+      temporaryTrack.setCov(temporaryTrack.getQ2Pt() * temporaryTrack.getQ2Pt() * temporaryTrack.getCov()[o2::track::CovLabels::kSigQ2Pt2], o2::track::CovLabels::kSigQ2Pt2);
+      temporaryTrack.setChi2(0);
+      fitSuccess = fitTrack(temporaryTrack,               // TrackITSExt& track,
+                            0,                            // int lastLayer,
+                            nLayers,                      // int firstLayer,
+                            1,                            // int firstCluster,
+                            maxChi2ClusterAttachment,     // float maxChi2ClusterAttachment,
+                            maxChi2NDF,                   // float maxChi2NDF,
+                            o2::constants::math::VeryBig, // float maxQoverPt,
+                            0,                            // nCl,
+                            bz,                           // float bz,
+                            foundTrackingFrameInfo,       // TrackingFrameInfo** trackingFrameInfo,
+                            propagator,                   // const o2::base::Propagator* propagator,
+                            matCorrType,                  // o2::base::PropagatorF::MatCorrType matCorrType
+                            &linRef,
+                            shifRefToCluster);
+      if (!fitSuccess) {
+        continue;
+      }
+      temporaryTrack.getParamOut() = temporaryTrack.getParamIn();
+      temporaryTrack.getParamIn() = saveInw;
+      temporaryTrack.setChi2(saveChi2);
+    }
     tracks[iCurrentTrackSeedIndex] = temporaryTrack;
   }
 }
@@ -1174,6 +1203,7 @@ void trackSeedHandler(CellSeed<nLayers>* trackSeeds,
                       const float maxChi2ClusterAttachment,
                       const float maxChi2NDF,
                       const int reseedIfShorter,
+                      const bool repeatRefitOut,
                       const bool shiftRefToCluster,
                       const o2::base::Propagator* propagator,
                       const o2::base::PropagatorF::MatCorrType matCorrType,
@@ -1195,6 +1225,7 @@ void trackSeedHandler(CellSeed<nLayers>* trackSeeds,
     maxChi2ClusterAttachment,                 // float
     maxChi2NDF,                               // float
     reseedIfShorter,                          // int
+    repeatRefitOut,                           // bool
     shiftRefToCluster,                        // bool
     propagator,                               // const o2::base::Propagator*
     matCorrType);                             // o2::base::PropagatorF::MatCorrType
@@ -1375,6 +1406,7 @@ template void trackSeedHandler(CellSeed<7>* trackSeeds,
                                const float maxChi2ClusterAttachment,
                                const float maxChi2NDF,
                                const int reseedIfShorter,
+                               const bool repeatRefitOut,
                                const bool shiftRefToCluster,
                                const o2::base::Propagator* propagator,
                                const o2::base::PropagatorF::MatCorrType matCorrType,
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
@@ -69,6 +69,7 @@ struct TrackingParameters {
   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};
   unsigned char StartLayerMask = 0x7F;
+  bool RepeatRefitOut = true;    // repeat outward refit using inward refit as a seed
   bool ShiftRefToCluster = true; // TrackFit: after update shift the linearization reference to cluster
   bool FindShortTracks = false;
   bool PerPrimaryVertexProcessing = false;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
@@ -98,6 +98,7 @@ struct TrackerParamConfig : public o2::conf::ConfigurableParamHelper<TrackerPara
   int nIterations = MaxIter;               // overwrite the number of iterations
   int reseedIfShorter = 6;                 // for the final refit reseed the track with circle if they are shorter than this value
   bool shiftRefToCluster{true};            // TrackFit: after update shift the linearization reference to cluster
+  bool repeatRefitOut{false};              // repeat outward refit using inward refit as a seed
   bool createArtefactLabels{false}; // create on-the-fly labels for the artefacts
 
   int nThreads = 1;
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
@@ -187,6 +187,7 @@ std::vector<TrackingParameters> TrackingMode::getTrackingParameters(TrackingMode
       p.MinPt[lslot] *= bFactor;
     }
     p.ReseedIfShorter = tc.reseedIfShorter;
+    p.RepeatRefitOut = tc.repeatRefitOut;
     p.ShiftRefToCluster = tc.shiftRefToCluster;
     p.createArtefactLabels = tc.createArtefactLabels;
 
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -778,6 +778,22 @@ void TrackerTraits<nLayers>::findRoads(const int iteration)
         if (!fitSuccess || temporaryTrack.getPt() < mTrkParams[iteration].MinPt[mTrkParams[iteration].NLayers - temporaryTrack.getNClusters()]) {
           return 0;
         }
+        if (mTrkParams[0].RepeatRefitOut) { // repeat outward refit seeding and linearizing with the stable inward fit result
+          o2::track::TrackParCov saveInw{temporaryTrack};
+          linRef = saveInw; // use refitted track as lin.reference
+          float saveChi2 = temporaryTrack.getChi2();
+          temporaryTrack.resetCovariance();
+          temporaryTrack.setCov(temporaryTrack.getQ2Pt() * temporaryTrack.getQ2Pt() * temporaryTrack.getCov()[o2::track::CovLabels::kSigQ2Pt2], o2::track::CovLabels::kSigQ2Pt2);
+          temporaryTrack.setChi2(0);
+          fitSuccess = fitTrack(temporaryTrack, 0, mTrkParams[0].NLayers, 1, mTrkParams[0].MaxChi2ClusterAttachment, mTrkParams[0].MaxChi2NDF, o2::constants::math::VeryBig, 0, &linRef);
+          if (!fitSuccess) {
+            return 0;
+          }
+          temporaryTrack.getParamOut() = temporaryTrack.getParamIn();
+          temporaryTrack.getParamIn() = saveInw;
+          temporaryTrack.setChi2(saveChi2);
+        }
+
         if constexpr (decltype(Tag)::value == PassMode::OnePass::value) {
           tracks.push_back(temporaryTrack);
         } else if constexpr (decltype(Tag)::value == PassMode::TwoPassCount::value) {
diff --git a/Detectors/TRD/workflow/include/TRDWorkflow/TRDPulseHeightSpec.h b/Detectors/TRD/workflow/include/TRDWorkflow/TRDPulseHeightSpec.h
@@ -69,6 +69,7 @@ class PuseHeightDevice : public o2::framework::Task
     mPulseHeight->reset();
     mPulseHeight->process();
     pc.outputs().snapshot(Output{"TRD", "PULSEHEIGHT", 0}, mPulseHeight->getPHData());
+    pc.outputs().snapshot(Output{"TRD", "PULSEHEIGHTHD", 0}, mPulseHeight->getPHDataHD());
     if (pc.transitionState() == TransitionHandlingState::Requested) {
       LOG(info) << "Run stop requested, finalizing";
       mRunStopRequested = true;
@@ -103,6 +104,7 @@ DataProcessorSpec getTRDPulseHeightSpec(GID::mask_t src, bool digitsFromReader)
 
   std::vector<OutputSpec> outputs;
   outputs.emplace_back(o2::header::gDataOriginTRD, "PULSEHEIGHT", 0, Lifetime::Timeframe);
+  outputs.emplace_back(o2::header::gDataOriginTRD, "PULSEHEIGHTHD", 0, Lifetime::Timeframe);
 
   bool isTPCavailable = false;
   if (GID::includesSource(GID::Source::ITSTPC, src)) {
diff --git a/Framework/AnalysisSupport/src/AODWriterHelpers.cxx b/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
@@ -62,13 +62,13 @@ const static std::unordered_map<OutputObjHandlingPolicy, std::string> ROOTfileNa
 
 AlgorithmSpec AODWriterHelpers::getOutputTTreeWriter(ConfigContext const& ctx)
 {
-  auto& ac = ctx.services().get<DanglingEdgesContext>();
   auto dod = AnalysisSupportHelpers::getDataOutputDirector(ctx);
   int compressionLevel = 505;
   if (ctx.options().hasOption("aod-writer-compression")) {
     compressionLevel = ctx.options().get<int>("aod-writer-compression");
   }
-  return AlgorithmSpec{[dod, outputInputs = ac.outputsInputsAOD, compressionLevel](InitContext& ic) -> std::function<void(ProcessingContext&)> {
+  return AlgorithmSpec{[dod, compressionLevel](InitContext& ic) -> std::function<void(ProcessingContext&)> {
+    auto outputInputs = ic.services().get<DanglingEdgesContext>().outputsInputsAOD;
     LOGP(debug, "======== getGlobalAODSink::Init ==========");
 
     // find out if any table needs to be saved
@@ -241,14 +241,13 @@ AlgorithmSpec AODWriterHelpers::getOutputTTreeWriter(ConfigContext const& ctx)
   };
 }
 
-AlgorithmSpec AODWriterHelpers::getOutputObjHistWriter(ConfigContext const& ctx)
+AlgorithmSpec AODWriterHelpers::getOutputObjHistWriter(ConfigContext const& /*ctx*/)
 {
-  using namespace monitoring;
-  auto& ac = ctx.services().get<DanglingEdgesContext>();
-  auto tskmap = ac.outTskMap;
-  auto objmap = ac.outObjHistMap;
-
-  return AlgorithmSpec{[objmap, tskmap](InitContext& ic) -> std::function<void(ProcessingContext&)> {
+  return AlgorithmSpec{[](InitContext& ic) -> std::function<void(ProcessingContext&)> {
+    using namespace monitoring;
+    auto& dec = ic.services().get<DanglingEdgesContext>();
+    auto tskmap = dec.outTskMap;
+    auto objmap = dec.outObjHistMap;
     auto& callbacks = ic.services().get<CallbackService>();
     auto inputObjects = std::make_shared<std::vector<std::pair<InputObjectRoute, InputObject>>>();
 
@@ -278,7 +277,7 @@ AlgorithmSpec AODWriterHelpers::getOutputObjHistWriter(ConfigContext const& ctx)
 
     callbacks.set<CallbackService::Id::EndOfStream>(endofdatacb);
     return [inputObjects, objmap, tskmap](ProcessingContext& pc) mutable -> void {
-      auto mergePart = [&inputObjects, &objmap, &tskmap, &pc](DataRef const& ref) {
+      auto mergePart = [&inputObjects, &objmap, &tskmap](DataRef const& ref) {
         O2_SIGNPOST_ID_GENERATE(hid, histogram_registry);
         O2_SIGNPOST_START(histogram_registry, hid, "mergePart", "Merging histogram");
         if (!ref.header) {
@@ -474,7 +473,7 @@ AlgorithmSpec AODWriterHelpers::getOutputObjHistWriter(ConfigContext const& ctx)
       };
       O2_SIGNPOST_ID_GENERATE(rid, histogram_registry);
       O2_SIGNPOST_START(histogram_registry, rid, "processParts", "Start merging %zu parts received together.", pc.inputs().getNofParts(0));
-      for (int pi = 0; pi < pc.inputs().getNofParts(0); ++pi) {
+      for (auto pi = 0U; pi < pc.inputs().getNofParts(0); ++pi) {
         mergePart(pc.inputs().get("x", pi));
       }
       O2_SIGNPOST_END(histogram_registry, rid, "processParts", "Done histograms in multipart message.");
diff --git a/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx b/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx
@@ -67,38 +67,39 @@ void fillValidRoutes(CCDBFetcherHelper& helper, std::vector<o2::framework::Outpu
 }
 } // namespace
 
-AlgorithmSpec AnalysisCCDBHelpers::fetchFromCCDB(ConfigContext const& ctx)
+AlgorithmSpec AnalysisCCDBHelpers::fetchFromCCDB(ConfigContext const& /*ctx*/)
 {
-  auto& ac = ctx.services().get<DanglingEdgesContext>();
-  std::vector<std::shared_ptr<arrow::Schema>> schemas;
-  auto schemaMetadata = std::make_shared<arrow::KeyValueMetadata>();
+  return adaptStateful([](ConfigParamRegistry const& options, DeviceSpec const& spec, InitContext& ic) {
+    auto& dec = ic.services().get<DanglingEdgesContext>();
+    std::vector<std::shared_ptr<arrow::Schema>> schemas;
+    auto schemaMetadata = std::make_shared<arrow::KeyValueMetadata>();
 
-  for (auto& input : ac.analysisCCDBInputs) {
-    std::vector<std::shared_ptr<arrow::Field>> fields;
-    schemaMetadata->Append("outputRoute", DataSpecUtils::describe(input));
-    schemaMetadata->Append("outputBinding", input.binding);
+    for (auto& input : dec.analysisCCDBInputs) {
+      std::vector<std::shared_ptr<arrow::Field>> fields;
+      schemaMetadata->Append("outputRoute", DataSpecUtils::describe(input));
+      schemaMetadata->Append("outputBinding", input.binding);
 
-    for (auto& m : input.metadata) {
-      // Save the list of input tables
-      if (m.name.starts_with("input:")) {
-        auto name = m.name.substr(6);
-        schemaMetadata->Append("sourceTable", name);
-        schemaMetadata->Append("sourceMatcher", DataSpecUtils::describe(std::get<ConcreteDataMatcher>(DataSpecUtils::fromMetadataString(m.defaultValue.get<std::string>()).matcher)));
-        continue;
-      }
-      // Ignore the non ccdb: entries
-      if (!m.name.starts_with("ccdb:")) {
-        continue;
+      for (auto& m : input.metadata) {
+        // Save the list of input tables
+        if (m.name.starts_with("input:")) {
+          auto name = m.name.substr(6);
+          schemaMetadata->Append("sourceTable", name);
+          schemaMetadata->Append("sourceMatcher", DataSpecUtils::describe(std::get<ConcreteDataMatcher>(DataSpecUtils::fromMetadataString(m.defaultValue.get<std::string>()).matcher)));
+          continue;
+        }
+        // Ignore the non ccdb: entries
+        if (!m.name.starts_with("ccdb:")) {
+          continue;
+        }
+        // Create the schema of the output
+        auto metadata = std::make_shared<arrow::KeyValueMetadata>();
+        metadata->Append("url", m.defaultValue.asString());
+        auto columnName = m.name.substr(strlen("ccdb:"));
+        fields.emplace_back(std::make_shared<arrow::Field>(columnName, arrow::binary_view(), false, metadata));
       }
-      // Create the schema of the output
-      auto metadata = std::make_shared<arrow::KeyValueMetadata>();
-      metadata->Append("url", m.defaultValue.asString());
-      auto columnName = m.name.substr(strlen("ccdb:"));
-      fields.emplace_back(std::make_shared<arrow::Field>(columnName, arrow::binary_view(), false, metadata));
+      schemas.emplace_back(std::make_shared<arrow::Schema>(fields, schemaMetadata));
     }
-    schemas.emplace_back(std::make_shared<arrow::Schema>(fields, schemaMetadata));
-  }
-  return adaptStateful([schemas](CallbackService& callbacks, ConfigParamRegistry const& options, DeviceSpec const& spec) {
+
     std::shared_ptr<CCDBFetcherHelper> helper = std::make_shared<CCDBFetcherHelper>();
     CCDBFetcherHelper::initialiseHelper(*helper, options);
     std::unordered_map<std::string, int> bindings;
@@ -129,11 +130,11 @@ AlgorithmSpec AnalysisCCDBHelpers::fetchFromCCDB(ConfigContext const& ctx)
         int outputRouteIndex = bindings.at(outRouteDesc);
         auto& spec = helper->routes[outputRouteIndex].matcher;
         std::vector<std::shared_ptr<arrow::BinaryViewBuilder>> builders;
-        for (auto& _ : schema->fields()) {
+        for (auto const& _ : schema->fields()) {
           builders.emplace_back(std::make_shared<arrow::BinaryViewBuilder>());
         }
 
-        for (size_t ci = 0; ci < timestampColumn->num_chunks(); ++ci) {
+        for (auto ci = 0; ci < timestampColumn->num_chunks(); ++ci) {
           std::shared_ptr<arrow::Array> chunk = timestampColumn->chunk(ci);
           auto const* timestamps = chunk->data()->GetValuesSafe<size_t>(1);
 
diff --git a/Framework/CCDBSupport/src/AnalysisCCDBHelpers.h b/Framework/CCDBSupport/src/AnalysisCCDBHelpers.h
@@ -17,7 +17,7 @@ namespace o2::framework
 {
 
 struct AnalysisCCDBHelpers {
-  static AlgorithmSpec fetchFromCCDB(ConfigContext const& ctx);
+  static AlgorithmSpec fetchFromCCDB(ConfigContext const&);
 };
 
 } // namespace o2::framework
diff --git a/Framework/Core/include/Framework/AnalysisTask.h b/Framework/Core/include/Framework/AnalysisTask.h
@@ -521,7 +521,7 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
   std::vector<ExpressionInfo> expressionInfos;
 
   /// make sure options and configurables are set before expression infos are created
-  homogeneous_apply_refs([&options, &hash](auto& element) { return analysis_task_parsers::appendOption(options, element); }, *task.get());
+  homogeneous_apply_refs([&options](auto& element) { return analysis_task_parsers::appendOption(options, element); }, *task.get());
   /// extract conditions and append them as inputs
   homogeneous_apply_refs([&inputs](auto& element) { return analysis_task_parsers::appendCondition(inputs, element); }, *task.get());
 
@@ -620,7 +620,7 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
       }
       // reset pre-slice for the next dataframe
       auto slices = pc.services().get<ArrowTableSlicingCache>();
-      homogeneous_apply_refs([&pc, &slices](auto& element) {
+      homogeneous_apply_refs([&slices](auto& element) {
         return analysis_task_parsers::updateSliceInfo(element, slices);
       },
                              *(task.get()));
diff --git a/Framework/Core/include/Framework/DataProcessingContext.h b/Framework/Core/include/Framework/DataProcessingContext.h
@@ -23,6 +23,12 @@ struct ServiceRegistry;
 struct DataAllocator;
 struct DataProcessorSpec;
 
+enum struct ForwardPolicy {
+  AtInjection,
+  AtCompletionPolicySatisified,
+  AfterProcessing
+};
+
 struct DataProcessorContext {
   DataProcessorContext(DataProcessorContext const&) = delete;
   DataProcessorContext() = default;
@@ -122,7 +128,7 @@ struct DataProcessorContext {
   mutable std::vector<ServicePreLoopHandle> preLoopHandles;
 
   /// Wether or not the associated DataProcessor can forward things early
-  bool canForwardEarly = true;
+  ForwardPolicy forwardPolicy = ForwardPolicy::AtInjection;
   bool isSink = false;
   bool balancingInputs = true;
 
diff --git a/Framework/Core/src/AnalysisSupportHelpers.cxx b/Framework/Core/src/AnalysisSupportHelpers.cxx
@@ -98,7 +98,7 @@ std::shared_ptr<DataOutputDirector> AnalysisSupportHelpers::getDataOutputDirecto
     if (!keepString.empty()) {
       dod->reset();
       std::string d("dangling");
-      if (d.find(keepString) == 0) {
+      if (d.starts_with(keepString) == 0) {
         // use the dangling outputs
         std::vector<InputSpec> danglingOutputs;
         for (auto ii = 0u; ii < OutputsInputs.size(); ii++) {
@@ -144,7 +144,7 @@ void AnalysisSupportHelpers::addMissingOutputsToSpawner(std::vector<OutputSpec>
     sinks::append_to{publisher.outputs}; // append them to the publisher outputs
 
   std::vector<InputSpec> additionalInputs;
-  for (auto& input : requestedSpecials | views::filter_not_matching(providedSpecials)) {
+  for (auto const& input : requestedSpecials | views::filter_not_matching(providedSpecials)) {
     input.metadata |
       views::filter_string_params_with("input:") |
       views::params_to_input_specs() |
diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
diff --git a/Framework/Core/src/DataRelayer.cxx b/Framework/Core/src/DataRelayer.cxx
diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx

Original file line number	Diff line number	Diff line change
`@@ -187,6 +187,7 @@ std::vector<TrackingParameters> TrackingMode::getTrackingParameters(TrackingMode`
`187`	`187`	`p.MinPt[lslot] *= bFactor;`
`188`	`188`	`}`
`189`	`189`	`p.ReseedIfShorter = tc.reseedIfShorter;`
	`190`	`+ p.RepeatRefitOut = tc.repeatRefitOut;`
`190`	`191`	`p.ShiftRefToCluster = tc.shiftRefToCluster;`
`191`	`192`	`p.createArtefactLabels = tc.createArtefactLabels;`
`192`	`193`