Merge 92d07e4 into sapling-pr-archive-ktf

Author: ktf

.github/workflows/code-transformations.yml

@@ -140,6 +140,9 @@ void OrtModel::initEnvironment()
 
 void OrtModel::initSessionFromBuffer(const char* buffer, size_t bufferSize)
 {
+  if (mAllocateDeviceMemory) {
+    memoryOnDevice(mDeviceId);
+  }
   mPImplOrt->sessionOptions.AddConfigEntry("session.load_model_format", "ONNX");
   mPImplOrt->sessionOptions.AddConfigEntry("session.use_ort_model_bytes_directly", "1");
 

Common/ML/src/OrtInterface.cxx

@@ -110,6 +110,7 @@ class MeanVertexObject : public VertexBase
 
   void setMeanXYVertexAtZ(VertexBase& v, float z) const
   {
+    v = *this;
     v.setX(getXAtZ(z));
     v.setY(getYAtZ(z));
     v.setZ(z);

DataFormats/Calibration/include/DataFormatsCalibration/MeanVertexObject.h

@@ -73,28 +73,21 @@ struct ClusterNative {
   uint8_t sigmaTimePacked;  //< Sigma of the time in packed format
   uint8_t sigmaPadPacked;   //< Sigma of the pad in packed format
   uint16_t qMax;            //< QMax of the cluster
-  uint16_t qTot;            //< Total charge of the cluster
+  uint16_t qTotPacked;      //< Total charge of the cluster
 
   GPUd() static uint16_t packPad(float pad) { return (uint16_t)(pad * scalePadPacked + 0.5); }
   GPUd() static uint32_t packTime(float time) { return (uint32_t)(time * scaleTimePacked + 0.5); }
   GPUd() static float unpackPad(uint16_t pad) { return float(pad) * (1.f / scalePadPacked); }
   GPUd() static float unpackTime(uint32_t time) { return float(time) * (1.f / scaleTimePacked); }
 
   GPUdDefault() ClusterNative() = default;
-  GPUd() ClusterNative(uint32_t time, uint8_t flags, uint16_t pad, uint8_t sigmaTime, uint8_t sigmaPad, uint16_t qmax, uint16_t qtot) : padPacked(pad), sigmaTimePacked(sigmaTime), sigmaPadPacked(sigmaPad), qMax(qmax), qTot(qtot)
+  GPUd() ClusterNative(uint32_t time, uint8_t flags, uint16_t pad, uint8_t sigmaTime, uint8_t sigmaPad, uint16_t qmax, uint16_t qtotPacked) : padPacked(pad), sigmaTimePacked(sigmaTime), sigmaPadPacked(sigmaPad), qMax(qmax), qTotPacked(qtotPacked)
   {
     setTimePackedFlags(time, flags);
   }
 
   GPUd() uint16_t getQmax() const { return qMax; }
-  GPUd() uint16_t getQtot() const
-  {
-    if (isSaturated()) [[unlikely]] {
-      auto sQtot = getSaturatedQtot();
-      return sQtot < USHRT_MAX ? sQtot : USHRT_MAX;
-    }
-    return qTot;
-  }
+  GPUd() uint32_t getQtot() const { return isSaturated() ? getSaturatedQtot() : (uint32_t)qTotPacked; }
   GPUd() uint8_t getFlags() const { return timeFlagsPacked >> 24; }
   GPUd() uint32_t getTimePacked() const { return timeFlagsPacked & 0xFFFFFF; }
   GPUd() void setTimePackedFlags(uint32_t timePacked, uint8_t flags)
@@ -155,19 +148,19 @@ struct ClusterNative {
     sigmaPadPacked = tmp;
   }
 
-  GPUd() bool isSaturated() const { return qTot > maxRegularQtot; }
+  GPUd() bool isSaturated() const { return qTotPacked > maxRegularQtot; }
 
   GPUd() void setSaturatedQtot(uint32_t qtot)
   {
-    this->qTot = USHRT_MAX;
+    this->qTotPacked = USHRT_MAX;
     if (qtot < maxSaturatedQtot) {
-      this->qTot = ((qtot + scaleSaturatedQtot / 2) / scaleSaturatedQtot) + maxRegularQtot;
+      this->qTotPacked = ((qtot + scaleSaturatedQtot / 2) / scaleSaturatedQtot) + maxRegularQtot;
     }
   }
 
   GPUd() uint32_t getSaturatedQtot() const
   {
-    return uint32_t(qTot - maxRegularQtot) * scaleSaturatedQtot;
+    return uint32_t(qTotPacked - maxRegularQtot) * scaleSaturatedQtot;
   }
 
   GPUd() void setSaturatedTailLength(uint32_t tail)
@@ -192,8 +185,8 @@ struct ClusterNative {
       return (this->sigmaPadPacked < rhs.sigmaPadPacked);
     } else if (this->qMax != rhs.qMax) {
       return (this->qMax < rhs.qMax);
-    } else if (this->qTot != rhs.qTot) {
-      return (this->qTot < rhs.qTot);
+    } else if (this->qTotPacked != rhs.qTotPacked) {
+      return (this->getQtot() < rhs.getQtot());
     } else {
       return (this->getFlags() < rhs.getFlags());
     }
@@ -206,7 +199,7 @@ struct ClusterNative {
            this->sigmaTimePacked == rhs.sigmaTimePacked &&
            this->sigmaPadPacked == rhs.sigmaPadPacked &&
            this->qMax == rhs.qMax &&
-           this->qTot == rhs.qTot &&
+           this->qTotPacked == rhs.qTotPacked &&
            this->getFlags() == rhs.getFlags();
   }
 

DataFormats/Detectors/TPC/include/DataFormatsTPC/ClusterNative.h

@@ -312,7 +312,7 @@ class ClusterNativeHelper
         sigmaTime = rhs.getSigmaTime();
         sigmaPad = rhs.getSigmaPad();
         qMax = rhs.qMax;
-        qTot = rhs.qTot;
+        qTot = rhs.qTotPacked;
         flags = rhs.getFlags();
         return *this;
       }

DataFormats/Detectors/TPC/include/DataFormatsTPC/ClusterNativeHelper.h

@@ -166,18 +166,18 @@ int AlignableDetectorTPC::processPoints(GIndex gid, int npntCut, bool inv)
           // mController->getTPCCorrMaps()->Transform(sector, row, cl->getPad(), cl->getTime(), x, y, z, tOffset);
           currentRow = row;
           currentSector = sector;
-          charge = cl->qTot;
+          charge = cl->getQtot();
           clusterState = nextState;
           combRow = row;
           LOGP(debug, "starting a supercluster at row {} of sector {} -> {},{},{}", currentRow, currentSector, x, y, z);
         } else {
           // float xx, yy, zz;
           // mController->getTPCCorrMaps()->Transform(sector, row, cl->getPad(), cl->getTime(), xx, yy, zz, tOffset);
-          x += xTmp * cl->qTot;
-          y += yTmp * cl->qTot;
-          z += zTmp * cl->qTot;
-          combRow += row * cl->qTot;
-          charge += cl->qTot;
+          x += xTmp * cl->getQtot();
+          y += yTmp * cl->getQtot();
+          z += zTmp * cl->getQtot();
+          combRow += row * cl->getQtot();
+          charge += cl->getQtot();
           clusterState |= nextState;
           npntCut--;
           LOGP(debug, "merging cluster #{} at row {} to a supercluster starting at row {} ", clusters + 1, row, currentRow);

Detectors/Align/src/AlignableDetectorTPC.cxx

@@ -389,13 +389,12 @@ void Clusterer::ClustererThread::updateChip(const ChipPixelData* curChipData, ui
     }
   } else {
     // row above should be always checked
-    int nnb = 0, lowestIndex = curr[row - 1], lowestNb = 0, *nbrCol[4], nbrRow[4];
+    int nnb = 0, lowestIndex = curr[row - 1], *nbrCol[4], nbrRow[4];
     if (lowestIndex >= 0) {
       nbrCol[nnb] = curr;
       nbrRow[nnb++] = row - 1;
     } else {
       lowestIndex = 0x7ffff;
-      lowestNb = -1;
     }
 #ifdef _ALLOW_DIAGONAL_ALPIDE_CLUSTERS_
     for (int i : {-1, 0, 1}) {
@@ -405,7 +404,6 @@ void Clusterer::ClustererThread::updateChip(const ChipPixelData* curChipData, ui
         nbrRow[nnb] = row + i;
         if (v < lowestIndex) {
           lowestIndex = v;
-          lowestNb = nnb;
         }
         nnb++;
       }
@@ -415,8 +413,7 @@ void Clusterer::ClustererThread::updateChip(const ChipPixelData* curChipData, ui
       nbrCol[nnb] = prev;
       nbrRow[nnb] = row;
       if (prev[row] < lowestIndex) {
-        lowestIndex = v;
-        lowestNb = nnb;
+        lowestIndex = prev[row];
       }
       nnb++;
     }

Detectors/ITSMFT/common/reconstruction/src/Clusterer.cxx

@@ -520,7 +520,7 @@ void TrackInterpolation::interpolateTrack(int iSeed)
     mCache[row].clY = clTPCYZ[0];
     mCache[row].clZ = clTPCYZ[1];
     mCache[row].clAngle = o2::math_utils::sector2Angle(sector);
-    mCacheDEDX[row].first = clTPC.getQtot();
+    mCacheDEDX[row].first = std::min<uint16_t>(clTPC.getQtot(), UINT16_MAX);
     mCacheDEDX[row].second = clTPC.getQmax();
     int imb = int(clTPC.getTime() * mNTPCOccBinLengthInv);
     if (imb < mTPCParam->occupancyMapSize) {

Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx

@@ -44,11 +44,11 @@ class TrackDump
     float gx{};
     float gy{};
     uint16_t qMax; //< QMax of the cluster
-    uint16_t qTot; //< Total charge of the cluster
+    uint32_t qTot; //< Total charge of the cluster
     uint8_t sector = 0;
     uint8_t padrow = 0;
 
-    ClassDefNV(ClusterGlobal, 1);
+    ClassDefNV(ClusterGlobal, 2);
   };
 
   struct ClusterNativeAdd : public ClusterNative {

Detectors/TPC/calibration/include/TPCCalibration/TrackDump.h

@@ -245,7 +245,7 @@ void CalculatedEdx::calculatedEdx(o2::tpc::TrackTPC& track, dEdxInfo& output, fl
     }
 
     // get charge values
-    float chargeTot = cl.qTot;
+    float chargeTot = cl.getQtot();
     float chargeMax = cl.qMax;
 
     // get threshold