Merge 4b156fe into sapling-pr-archive-ktf

Author: ktf

Detectors/ITSMFT/common/base/include/ITSMFTBase/DPLAlpideParam.h

@@ -881,35 +881,35 @@ void TRKServices::createOTServicesPeacock(TGeoVolume* motherVolume)
     // TODO: add cables/connections at ends of OT barrels
     // Set rMin, rMax and dZ
 
-    double rMin = 45.0;
-    double rMax = rMinOuterServices;
-    double zCur = 145.0;
-    double dZ = siO2FiberAreaB / (4 * 3.14 * rMax);
-    TGeoTube* outerBarrelFiberSIO2 = new TGeoTube(Form("TRK_OUTERBARREL_FIBER_SIO2sh_%s", orLabel.c_str()), rMin, rMax, dZ);
+    double rMinOTbarrelServices = 45.0; // cm, radius of first OT layer
+    double rMaxOTbarrelServices = 80;   // cm, radius of last OT layer
+    double zCur = 135.0;                // cm, approximate position of OT services in z
+    double dZ = siO2FiberAreaB / (4 * 3.14 * rMaxOTbarrelServices);
+    TGeoTube* outerBarrelFiberSIO2 = new TGeoTube(Form("TRK_OUTERBARREL_FIBER_SIO2sh_%s", orLabel.c_str()), rMinOTbarrelServices, rMaxOTbarrelServices, dZ);
     TGeoVolume* outerBarrelFiberSIO2Volume = new TGeoVolume(Form("TRK_OUTERBARREL_FIBER_SIO2_%s", orLabel.c_str()), outerBarrelFiberSIO2, medSiO2);
     outerBarrelFiberSIO2Volume->SetLineColor(kGray);
     auto* combiTrans = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), nullptr);
     motherVolume->AddNode(outerBarrelFiberSIO2Volume, 1, combiTrans);
 
     zCur += 2 * dZ;
-    dZ = peFiberAreaB / (4 * 3.14 * rMax);
-    TGeoTube* outerBarrelFiberPE = new TGeoTube(Form("TRK_OUTERBARREL_FIBER_PEsh_%s", orLabel.c_str()), rMin, rMax, dZ);
+    dZ = peFiberAreaB / (4 * 3.14 * rMaxOTbarrelServices);
+    TGeoTube* outerBarrelFiberPE = new TGeoTube(Form("TRK_OUTERBARREL_FIBER_PEsh_%s", orLabel.c_str()), rMinOTbarrelServices, rMaxOTbarrelServices, dZ);
     TGeoVolume* outerBarrelFiberPEVolume = new TGeoVolume(Form("TRK_OUTERBARREL_FIBER_PE_%s", orLabel.c_str()), outerBarrelFiberPE, medPE);
     outerBarrelFiberPEVolume->SetLineColor(kGray);
     combiTrans = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), nullptr);
     motherVolume->AddNode(outerBarrelFiberPEVolume, 1, combiTrans);
 
     zCur += 2 * dZ;
-    dZ = cuPowerAreaB / (4 * 3.14 * rMax);
-    TGeoTube* outerBarrelPowerCu = new TGeoTube(Form("TRK_OUTERBARREL_POWER_CUsh_%s", orLabel.c_str()), rMin, rMax, dZ);
+    dZ = cuPowerAreaB / (4 * 3.14 * rMaxOTbarrelServices);
+    TGeoTube* outerBarrelPowerCu = new TGeoTube(Form("TRK_OUTERBARREL_POWER_CUsh_%s", orLabel.c_str()), rMinOTbarrelServices, rMaxOTbarrelServices, dZ);
     TGeoVolume* outerBarrelPowerCuVolume = new TGeoVolume(Form("TRK_OUTERBARREL_POWER_CU_%s", orLabel.c_str()), outerBarrelPowerCu, medCu);
-    outerBarrelFiberSIO2Volume->SetLineColor(kGray);
+    outerBarrelPowerCuVolume->SetLineColor(kGray);
     combiTrans = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), nullptr);
     motherVolume->AddNode(outerBarrelPowerCuVolume, 1, combiTrans);
 
     zCur += 2 * dZ;
-    dZ = pePowerAreaB / (4 * 3.14 * rMax);
-    TGeoTube* outerBarrelPowerPE = new TGeoTube(Form("TRK_OUTERBARREL_POWER_PEsh_%s", orLabel.c_str()), rMin, rMax, dZ);
+    dZ = pePowerAreaB / (4 * 3.14 * rMaxOTbarrelServices);
+    TGeoTube* outerBarrelPowerPE = new TGeoTube(Form("TRK_OUTERBARREL_POWER_PEsh_%s", orLabel.c_str()), rMinOTbarrelServices, rMaxOTbarrelServices, dZ);
     TGeoVolume* outerBarrelPowerPEVolume = new TGeoVolume(Form("TRK_OUTERBARREL_POWER_PE_%s", orLabel.c_str()), outerBarrelPowerPE, medPE);
     outerBarrelPowerPEVolume->SetLineColor(kGray);
     combiTrans = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), nullptr);

Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx

@@ -29,6 +29,7 @@
 #include "ReconstructionDataFormats/PrimaryVertex.h"
 #include "DetectorsVertexing/PVertexerHelpers.h"
 #include "DetectorsVertexing/PVertexerParams.h"
+#include "DetectorsBase/Propagator.h"
 #include "ReconstructionDataFormats/GlobalTrackID.h"
 #include "DataFormatsCalibration/MeanVertexObject.h"
 #include "DataFormatsITSMFT/DPLAlpideParam.h"
@@ -85,6 +86,7 @@ class PVertexer
   void setBunchFilling(const o2::BunchFilling& bf);
 
   void setBz(float bz) { mBz = bz; }
+  void setMatCorrType(o2::base::Propagator::MatCorrType type) { mMatCorr = type; }
   void setValidateWithIR(bool v) { mValidateWithIR = v; }
   bool getValidateWithIR() const { return mValidateWithIR; }
   void setTrackSources(GTrackID::mask_t s);
@@ -187,6 +189,7 @@ class PVertexer
   std::vector<TimeZCluster> mTimeZClusters; ///< set of time clusters
   float mITSROFrameLengthMUS = 0;           ///< ITS readout time span in \mus
   float mBz = 0.;                           ///< mag.field at beam line
+  o2::base::Propagator::MatCorrType mMatCorr = o2::base::Propagator::MatCorrType::USEMatCorrLUT; ///< material correction for propagation
   float mDBScanDeltaT = 0.;                 ///< deltaT cut for DBScan check
   float mDBSMaxZ2InvCorePoint = 0;          ///< inverse of max sigZ^2 of the track which can be core point in the DBScan
   bool mValidateWithIR = false;             ///< require vertex validation with InteractionCandidates (if available)

Detectors/Vertexing/include/DetectorsVertexing/PVertexer.h

@@ -1218,7 +1218,7 @@ bool PVertexer::relateTrackToMeanVertex(o2::track::TrackParCov& trc, float vtxEr
     z = mMeanVertex.getZ();
   }
   mMeanVertex.setMeanXYVertexAtZ(mMeanVertexSeed, z);
-  if (!o2::base::Propagator::Instance()->propagateToDCA(mMeanVertex, trc, mBz, 2.0f, o2::base::Propagator::MatCorrType::USEMatCorrLUT, &dca, nullptr, 0, mPVParams->dcaTolerance)) {
+  if (!o2::base::Propagator::Instance()->propagateToDCA(mMeanVertex, trc, mBz, 2.0f, mMatCorr, &dca, nullptr, 0, mPVParams->dcaTolerance)) {
     return false;
   }
   return dca.getY() * dca.getY() / (dca.getSigmaY2() + vtxErr2) < mPVParams->pullIniCut;
@@ -1227,7 +1227,7 @@ bool PVertexer::relateTrackToMeanVertex(o2::track::TrackParCov& trc, float vtxEr
 //______________________________________________
 bool PVertexer::relateTrackToVertex(o2::track::TrackParCov& trc, const o2d::VertexBase& vtxSeed) const
 {
-  return o2::base::Propagator::Instance()->propagateToDCA(vtxSeed, trc, mBz, 2.0f, o2::base::Propagator::MatCorrType::USEMatCorrLUT);
+  return o2::base::Propagator::Instance()->propagateToDCA(vtxSeed, trc, mBz, 2.0f, mMatCorr);
 }
 
 //______________________________________________

Detectors/Vertexing/src/PVertexer.cxx

@@ -768,6 +768,22 @@ o2::framework::ServiceSpec
                    .user<DecongestionContext>({.ref = services, .oldestPossibleOutput = oldestPossibleOutput}));
       }
 
+      // When consumeWhenPastOldestPossibleTimeframe is active, we always
+      // schedule the callback even when oldestPossibleOutput has not changed
+      // yet. Retry slots held by this policy will be consumed after this
+      // domainInfoUpdated call (once getReadyToProcess re-checks them), and
+      // the callback — running in the next iteration — will recompute
+      // oldestPossibleOutput and forward the updated value downstream.
+      if (decongestion.consumeWhenPastOldestPossibleTimeframeActive) {
+        auto& queue = services.get<AsyncQueue>();
+        AsyncQueueHelpers::post(
+          queue, AsyncTask{.timeslice = TimesliceId{oldestPossibleTimeslice},
+                           .id = decongestion.oldestPossibleTimesliceTask,
+                           .debounce = -1,
+                           .callback = decongestionCallbackPastOldest}
+                   .user<DecongestionContext>({.ref = services, .oldestPossibleOutput = oldestPossibleOutput}));
+      }
+
       if (oldestPossibleOutput.timeslice.value == decongestion.lastTimeslice) {
         O2_SIGNPOST_EVENT_EMIT(data_processor_context, cid, "oldest_possible_timeslice", "Synchronous: Not sending already sent value: %" PRIu64, (uint64_t)oldestPossibleOutput.timeslice.value);
         return;

Framework/Core/src/CommonServices.cxx

@@ -627,12 +627,15 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
     // Use the new dummy sink when the AOD reader is there
     O2_SIGNPOST_ID_GENERATE(sid, workflow_helpers);
     if (tfnsource != workflow.end()) {
-      O2_SIGNPOST_EVENT_EMIT(workflow_helpers, sid, "injectServiceDevices", "Injecting scheduled dummy sink");
-      // if there is a tfnsource, make sure the sink gets TFN/TFF
       DataSpecUtils::updateInputList(ignored, InputSpec{"tfn", "TFN", "TFNumber", 0, Lifetime::Sporadic});
       DataSpecUtils::updateInputList(ignored, InputSpec{"tff", "TFF", "TFFilename", 0, Lifetime::Sporadic});
+    }
+
+    if (tfnsource != workflow.end() && !tfnsource->name.starts_with("aod-producer-workflow")) { // any tfnsource except the aod-producer should use scheduled sink
+      O2_SIGNPOST_EVENT_EMIT(workflow_helpers, sid, "injectServiceDevices", "Injecting scheduled dummy sink");
+      // if there is a tfnsource, make sure the sink gets TFN/TFF
       extraSpecs.push_back(CommonDataProcessors::getScheduledDummySink(ignored));
-    } else {
+    } else { // if there is no tfn source or if that source is aod-producer-workflow, out-of-band channel is used to propagate the number of consumed timeframes
       O2_SIGNPOST_EVENT_EMIT(workflow_helpers, sid, "injectServiceDevices", "Injecting rate limited dummy sink");
       std::string rateLimitingChannelConfigOutput;
       if (rateLimitingIPCID != -1) {

Framework/Core/src/WorkflowHelpers.cxx

@@ -108,6 +108,7 @@ class GPUCommonMath
   GPUd() constexpr static float QuietNaN() { return GPUCA_CHOICE(std::numeric_limits<float>::quiet_NaN(), __builtin_nanf(""), nan(0u)); }
 #endif
   GPUd() constexpr static uint32_t Clz(uint32_t val);
+  GPUd() constexpr static uint32_t Ctz(uint32_t val);
   GPUd() constexpr static uint32_t Popcount(uint32_t val);
 
   GPUd() static void memcpy(void* dst, const void* src, size_t size);
@@ -332,6 +333,20 @@ GPUdi() constexpr uint32_t GPUCommonMath::Clz(uint32_t x)
 #endif
 }
 
+GPUdi() constexpr uint32_t GPUCommonMath::Ctz(uint32_t x)
+{
+#if (defined(__GNUC__) || defined(__clang__) || defined(__CUDACC__) || defined(__HIPCC__))
+  return x == 0 ? 32 : GPUCA_CHOICE(__builtin_ctz(x), __ffs(x) - 1, __builtin_ctz(x));
+#else
+  for (uint32_t i = 0; i < 32; ++i) {
+    if (x & (1u << i)) {
+      return i;
+    }
+  }
+  return 32;
+#endif
+}
+
 GPUdi() constexpr uint32_t GPUCommonMath::Popcount(uint32_t x)
 {
 #if (defined(__GNUC__) || defined(__clang__) || defined(__CUDACC__) || defined(__HIPCC__)) && !defined(__OPENCL__) // TODO: remove OPENCL when reported SPIR-V bug is fixed