Merge 51b4524 into sapling-pr-archive-ehellbar

Author: ehellbar

Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h

@@ -209,13 +209,17 @@ void processNeighboursHandler(const int startLayer,
 template <int nLayers = 7>
 void trackSeedHandler(CellSeed<nLayers>* trackSeeds,
                       const TrackingFrameInfo** foundTrackingFrameInfo,
+                      const Cluster** unsortedClusters,
                       o2::its::TrackITSExt* tracks,
-                      std::vector<float>& minPtsHost,
+                      const std::vector<float>& layerRadiiHost,
+                      const std::vector<float>& minPtsHost,
                       const unsigned int nSeeds,
                       const float Bz,
                       const int startLevel,
-                      float maxChi2ClusterAttachment,
-                      float maxChi2NDF,
+                      const float maxChi2ClusterAttachment,
+                      const float maxChi2NDF,
+                      const int reseedIfShorter,
+                      const bool shiftRefToCluster,
                       const o2::base::Propagator* propagator,
                       const o2::base::PropagatorF::MatCorrType matCorrType,
                       const int nBlocks,

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

@@ -325,17 +325,21 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
     mTimeFrameGPU->createTrackITSExtDevice(trackSeeds);
     mTimeFrameGPU->loadTrackSeedsDevice(trackSeeds);
 
-    trackSeedHandler(mTimeFrameGPU->getDeviceTrackSeeds(),             // CellSeed* trackSeeds
-                     mTimeFrameGPU->getDeviceArrayTrackingFrameInfo(), // TrackingFrameInfo** foundTrackingFrameInfo
-                     mTimeFrameGPU->getDeviceTrackITSExt(),            // o2::its::TrackITSExt* tracks
-                     this->mTrkParams[iteration].MinPt,                // std::vector<float>& minPtsHost,
+    trackSeedHandler(mTimeFrameGPU->getDeviceTrackSeeds(),             // CellSeed*
+                     mTimeFrameGPU->getDeviceArrayTrackingFrameInfo(), // TrackingFrameInfo**
+                     mTimeFrameGPU->getDeviceArrayUnsortedClusters(),  // Cluster**
+                     mTimeFrameGPU->getDeviceTrackITSExt(),            // o2::its::TrackITSExt*
+                     this->mTrkParams[iteration].LayerRadii,           // const std::vector<float>&
+                     this->mTrkParams[iteration].MinPt,                // const std::vector<float>&
                      trackSeeds.size(),                                // const size_t nSeeds
                      this->mBz,                                        // const float Bz
                      startLevel,                                       // const int startLevel,
                      this->mTrkParams[0].MaxChi2ClusterAttachment,     // float maxChi2ClusterAttachment
                      this->mTrkParams[0].MaxChi2NDF,                   // float maxChi2NDF
-                     mTimeFrameGPU->getDevicePropagator(),             // const o2::base::Propagator* propagator
-                     this->mTrkParams[0].CorrType,                     // o2::base::PropagatorImpl<float>::MatCorrType
+                     this->mTrkParams[0].ReseedIfShorter,
+                     this->mTrkParams[0].ShiftRefToCluster,
+                     mTimeFrameGPU->getDevicePropagator(), // const o2::base::Propagator* propagator
+                     this->mTrkParams[0].CorrType,         // o2::base::PropagatorImpl<float>::MatCorrType
                      conf.nBlocksTracksSeeds[iteration],
                      conf.nThreadsTracksSeeds[iteration]);
 

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

@@ -66,10 +66,10 @@ struct TrackingParameters {
   o2::base::PropagatorImpl<float>::MatCorrType CorrType = o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrNONE;
   float MaxChi2ClusterAttachment = 60.f;
   float MaxChi2NDF = 30.f;
-  int reseedIfShorter = 6; // reseed for the final fit track with the length shorter than this
+  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 shiftRefToCluster = true; // TrackFit: after update shift the linearization reference to cluster
+  bool ShiftRefToCluster = true; // TrackFit: after update shift the linearization reference to cluster
   bool FindShortTracks = false;
   bool PerPrimaryVertexProcessing = false;
   bool SaveTimeBenchmarks = false;

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

@@ -92,7 +92,7 @@ class TrackerTraits
   virtual int getTFNumberOfCells() const { return mTimeFrame->getNumberOfCells(); }
 
  private:
-  track::TrackParCov buildTrackSeed(const Cluster& cluster1, const Cluster& cluster2, const TrackingFrameInfo& tf3);
+  track::TrackParCov buildTrackSeed(const Cluster& cluster1, const Cluster& cluster2, const TrackingFrameInfo& tf3, bool reverse = false);
   TrackITSExt seedTrackForRefit(const CellSeedN& seed);
   bool fitTrack(TrackITSExt& track, int start, int end, int step, float chi2clcut = o2::constants::math::VeryBig, float chi2ndfcut = o2::constants::math::VeryBig, float maxQoverPt = o2::constants::math::VeryBig, int nCl = 0, o2::track::TrackPar* refLin = nullptr);
 

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

@@ -186,8 +186,8 @@ std::vector<TrackingParameters> TrackingMode::getTrackingParameters(TrackingMode
       int lslot = tc.MaxTrackLength - ilg;
       p.MinPt[lslot] *= bFactor;
     }
-    p.reseedIfShorter = tc.reseedIfShorter;
-    p.shiftRefToCluster = tc.shiftRefToCluster;
+    p.ReseedIfShorter = tc.reseedIfShorter;
+    p.ShiftRefToCluster = tc.shiftRefToCluster;
     p.createArtefactLabels = tc.createArtefactLabels;
 
     p.PrintMemory = tc.printMemory;

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

@@ -765,15 +765,14 @@ void TrackerTraits<nLayers>::findRoads(const int iteration)
       auto forSeed = [&](auto Tag, int iSeed, int offset = 0) {
         TrackITSExt temporaryTrack = seedTrackForRefit(trackSeeds[iSeed]);
         o2::track::TrackPar linRef{temporaryTrack};
-        o2::track::TrackParCov savTr = temporaryTrack; // REMOVE
         bool 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();
         linRef = temporaryTrack.getParamOut(); // use refitted track as lin.reference
         temporaryTrack.resetCovariance();
-        temporaryTrack.setCov(temporaryTrack.getQ2Pt() * temporaryTrack.getQ2Pt() * temporaryTrack.getCov()[14], 14);
+        temporaryTrack.setCov(temporaryTrack.getQ2Pt() * temporaryTrack.getQ2Pt() * temporaryTrack.getCov()[o2::track::CovLabels::kSigQ2Pt2], o2::track::CovLabels::kSigQ2Pt2);
         temporaryTrack.setChi2(0);
         fitSuccess = fitTrack(temporaryTrack, mTrkParams[0].NLayers - 1, -1, -1, mTrkParams[0].MaxChi2ClusterAttachment, mTrkParams[0].MaxChi2NDF, 50.f, 0, &linRef);
         if (!fitSuccess || temporaryTrack.getPt() < mTrkParams[iteration].MinPt[mTrkParams[iteration].NLayers - temporaryTrack.getNClusters()]) {
@@ -1082,7 +1081,7 @@ bool TrackerTraits<nLayers>::fitTrack(TrackITSExt& track, int start, int end, in
     if (!track.o2::track::TrackParCov::update(trackingHit.positionTrackingFrame, trackingHit.covarianceTrackingFrame)) {
       return false;
     }
-    if (linRef && mTrkParams[0].shiftRefToCluster) { // displace the reference to the last updated cluster
+    if (linRef && mTrkParams[0].ShiftRefToCluster) { // displace the reference to the last updated cluster
       linRef->setY(trackingHit.positionTrackingFrame[0]);
       linRef->setZ(trackingHit.positionTrackingFrame[1]);
     }
@@ -1208,27 +1207,22 @@ template <int nLayers>
 TrackITSExt TrackerTraits<nLayers>::seedTrackForRefit(const CellSeedN& seed)
 {
   TrackITSExt temporaryTrack(seed);
+  int lrMin = nLayers, lrMax = 0, lrMid = 0;
   for (int iL = 0; iL < nLayers; ++iL) {
-    temporaryTrack.setExternalClusterIndex(iL, seed.getCluster(iL), seed.getCluster(iL) != constants::UnusedIndex);
+    const int idx = seed.getCluster(iL);
+    temporaryTrack.setExternalClusterIndex(iL, idx, idx != constants::UnusedIndex);
+    if (idx != constants::UnusedIndex) {
+      lrMin = o2::gpu::CAMath::Min(lrMin, iL);
+      lrMax = o2::gpu::CAMath::Max(lrMax, iL);
+    }
   }
   int ncl = temporaryTrack.getNClusters();
-  if (ncl < mTrkParams[0].reseedIfShorter) { // reseed with circle passing via edges and the midpoint
-    int lrMin = 999, lrMax = 0, lrMid = 0;
+  if (ncl < mTrkParams[0].ReseedIfShorter) { // reseed with circle passing via edges and the midpoint
     if (ncl == mTrkParams[0].NLayers) {
       lrMin = 0;
       lrMax = mTrkParams[0].NLayers - 1;
       lrMid = (lrMin + lrMax) / 2;
     } else {
-      for (int iL = 0; iL < nLayers; ++iL) {
-        if (seed.getCluster(iL) != constants::UnusedIndex) {
-          if (iL < lrMin) {
-            lrMin = iL;
-          }
-          if (iL > lrMax) {
-            lrMax = iL;
-          }
-        }
-      }
       lrMid = lrMin + 1;
       float midR = 0.5 * (mTrkParams[0].LayerRadii[lrMax] + mTrkParams[0].LayerRadii[lrMin]), dstMidR = o2::gpu::GPUCommonMath::Abs(midR - mTrkParams[0].LayerRadii[lrMid]);
       for (int iL = lrMid + 1; iL < lrMax; ++iL) { // find the midpoint as closest to the midR
@@ -1242,45 +1236,48 @@ TrackITSExt TrackerTraits<nLayers>::seedTrackForRefit(const CellSeedN& seed)
     const auto& cluster0_tf = mTimeFrame->getTrackingFrameInfoOnLayer(lrMin)[seed.getCluster(lrMin)]; // if the sensor frame!
     const auto& cluster1_gl = mTimeFrame->getUnsortedClusters()[lrMid][seed.getCluster(lrMid)];       // global frame
     const auto& cluster2_gl = mTimeFrame->getUnsortedClusters()[lrMax][seed.getCluster(lrMax)];       // global frame
-    temporaryTrack.getParamIn() = buildTrackSeed(cluster2_gl, cluster1_gl, cluster0_tf);
-    temporaryTrack.setQ2Pt(-temporaryTrack.getQ2Pt()); // we are calling buildTrackSeed with the clusters order opposite to what it expects
-    temporaryTrack.setSnp(-temporaryTrack.getSnp());   // we are calling buildTrackSeed with the clusters order opposite to what it expects
+    temporaryTrack.getParamIn() = buildTrackSeed(cluster2_gl, cluster1_gl, cluster0_tf, true);
   }
   temporaryTrack.resetCovariance();
-  temporaryTrack.setCov(temporaryTrack.getQ2Pt() * temporaryTrack.getQ2Pt() * temporaryTrack.getCov()[14], 14);
+  temporaryTrack.setCov(temporaryTrack.getQ2Pt() * temporaryTrack.getQ2Pt() * temporaryTrack.getCov()[o2::track::CovLabels::kSigQ2Pt2], o2::track::CovLabels::kSigQ2Pt2);
   return temporaryTrack;
 }
 
 /// Clusters are given from inside outward (cluster3 is the outermost). The outermost cluster is given in the tracking
 /// frame coordinates whereas the others are referred to the global frame.
 template <int nLayers>
-track::TrackParCov TrackerTraits<nLayers>::buildTrackSeed(const Cluster& cluster1, const Cluster& cluster2, const TrackingFrameInfo& tf3)
+track::TrackParCov TrackerTraits<nLayers>::buildTrackSeed(const Cluster& cluster1, const Cluster& cluster2, const TrackingFrameInfo& tf3, bool reverse)
 {
-  float ca{-999.f}, sa{-999.f};
+  const float sign = reverse ? -1.f : 1.f;
+
+  float ca, sa;
   o2::gpu::CAMath::SinCos(tf3.alphaTrackingFrame, sa, ca);
+
   const float x1 = cluster1.xCoordinate * ca + cluster1.yCoordinate * sa;
   const float y1 = -cluster1.xCoordinate * sa + cluster1.yCoordinate * ca;
-  const float z1 = cluster1.zCoordinate;
   const float x2 = cluster2.xCoordinate * ca + cluster2.yCoordinate * sa;
   const float y2 = -cluster2.xCoordinate * sa + cluster2.yCoordinate * ca;
-  const float z2 = cluster2.zCoordinate;
   const float x3 = tf3.xTrackingFrame;
   const float y3 = tf3.positionTrackingFrame[0];
-  const float z3 = tf3.positionTrackingFrame[1];
-  float tgp{1.f}, crv{1.f}, snp{-999.f}, tgl12{-999.f}, tgl23{-999.f}, q2pt{1.f / track::kMostProbablePt}, q2pt2{1.f}, sg2q2pt{-999.f};
+
+  float snp, q2pt, q2pt2;
   if (mIsZeroField) {
-    tgp = o2::gpu::CAMath::ATan2(y3 - y1, x3 - x1);
-    snp = tgp / o2::gpu::CAMath::Sqrt(1.f + tgp * tgp);
+    const float tgp = o2::gpu::CAMath::ATan2(y3 - y1, x3 - x1);
+    snp = sign * tgp / o2::gpu::CAMath::Sqrt(1.f + tgp * tgp);
+    q2pt = sign / track::kMostProbablePt;
+    q2pt2 = 1.f;
   } else {
-    crv = math_utils::computeCurvature(x3, y3, x2, y2, x1, y1);
-    snp = crv * (x3 - math_utils::computeCurvatureCentreX(x3, y3, x2, y2, x1, y1));
-    q2pt = crv / (mBz * o2::constants::math::B2C);
+    const float crv = math_utils::computeCurvature(x3, y3, x2, y2, x1, y1);
+    snp = sign * crv * (x3 - math_utils::computeCurvatureCentreX(x3, y3, x2, y2, x1, y1));
+    q2pt = sign * crv / (mBz * o2::constants::math::B2C);
     q2pt2 = crv * crv;
   }
-  tgl12 = math_utils::computeTanDipAngle(x1, y1, x2, y2, z1, z2);
-  tgl23 = math_utils::computeTanDipAngle(x2, y2, x3, y3, z2, z3);
-  sg2q2pt = track::kC1Pt2max * (q2pt2 > 0.0005f ? (q2pt2 < 1.f ? q2pt2 : 1.f) : 0.0005f);
-  return {tf3.xTrackingFrame, tf3.alphaTrackingFrame, {y3, z3, snp, 0.5f * (tgl12 + tgl23), q2pt}, {tf3.covarianceTrackingFrame[0], tf3.covarianceTrackingFrame[1], tf3.covarianceTrackingFrame[2], 0.f, 0.f, track::kCSnp2max, 0.f, 0.f, 0.f, track::kCTgl2max, 0.f, 0.f, 0.f, 0.f, sg2q2pt}};
+
+  const float tgl = 0.5f * (math_utils::computeTanDipAngle(x1, y1, x2, y2, cluster1.zCoordinate, cluster2.zCoordinate) +
+                            math_utils::computeTanDipAngle(x2, y2, x3, y3, cluster2.zCoordinate, tf3.positionTrackingFrame[1]));
+  const float sg2q2pt = track::kC1Pt2max * (q2pt2 > 0.0005f ? (q2pt2 < 1.f ? q2pt2 : 1.f) : 0.0005f);
+
+  return {x3, tf3.alphaTrackingFrame, {y3, tf3.positionTrackingFrame[1], snp, tgl, q2pt}, {tf3.covarianceTrackingFrame[0], tf3.covarianceTrackingFrame[1], tf3.covarianceTrackingFrame[2], 0.f, 0.f, track::kCSnp2max, 0.f, 0.f, 0.f, track::kCTgl2max, 0.f, 0.f, 0.f, 0.f, sg2q2pt}};
 }
 
 template <int nLayers>

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

@@ -351,6 +351,7 @@ BOOST_AUTO_TEST_CASE(CalDetStreamerTest)
   o2::tpc::DeadChannelMapCreator creator{};
   creator.init("https://alice-ccdb.cern.ch");
   creator.loadIDCPadFlags(1731274461770);
+  creator.loadFEEConfig(1731274461770);
 }
 
 } // namespace o2::tpc

Detectors/TPC/base/test/testTPCCalDet.cxx

@@ -38,7 +38,9 @@ class FairMQDeviceProxy
   FairMQDeviceProxy() = default;
   FairMQDeviceProxy(FairMQDeviceProxy const&) = delete;
   void bind(std::vector<OutputRoute> const& outputs, std::vector<InputRoute> const& inputs,
-            std::vector<ForwardRoute> const& forwards, fair::mq::Device& device);
+            std::vector<ForwardRoute> const& forwards,
+            std::function<fair::mq::Channel&(std::string const&)> bindChannelByName,
+            std::function<bool(void)> newStateRequestedCallback);
 
   /// Retrieve the transport associated to a given route.
   [[nodiscard]] OutputRoute const& getOutputRoute(RouteIndex routeIndex) const { return mOutputs.at(routeIndex.value); }

Framework/Core/include/Framework/FairMQDeviceProxy.h

@@ -57,7 +57,18 @@ o2::framework::ServiceSpec CommonMessageBackends::fairMQDeviceProxy()
       /// some of the channels are added only later on to the party,
       /// (e.g. by ECS) and Init might not be late enough to
       /// account for them.
-      proxy->bind(outputs, inputs, forwards, *device); },
+      std::function<fair::mq::Channel&(std::string const&)> bindByName = [device](std::string const& channelName) -> fair::mq::Channel& {
+        auto channel = device->GetChannels().find(channelName);
+        if (channel == device->GetChannels().end()) {
+          LOGP(fatal, "Expected channel {} not configured.", channelName);
+        }
+         return channel->second.at(0);
+      };
+
+      std::function<bool()> newStateCallback = [device]() -> bool {
+        return device->NewStatePending();
+      };
+      proxy->bind(outputs, inputs, forwards, bindByName, newStateCallback); },
   };
 }