GPU TPC FastTransformation: Do not use std::array

Author: davidrohr

Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx

@@ -159,7 +159,8 @@ void TPCFastSpaceChargeCorrectionHelper::fillSpaceChargeCorrectionFromMap(TPCFas
           for (int i = 0; i < nDataPoints; ++i) {
             o2::gpu::TPCFastSpaceChargeCorrectionMap::CorrectionPoint p = data[i];
             // not corrected grid coordinates
-            auto [gu, gv, scale] = correction.convLocalToGrid(sector, row, p.mY, p.mZ);
+            float gu, gv, scale;
+            correction.convLocalToGrid(sector, row, p.mY, p.mZ, gu, gv, scale);
             if (scale - 1.f > 1.e-6) { // point is outside the grid
               continue;
             }
@@ -300,7 +301,8 @@ std::unique_ptr<TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrectionHelper
           double dpad = info.maxPad / (6. * (nKnotsY - 1));
           for (double pad = 0; pad < info.maxPad + .5 * dpad; pad += dpad) {
             for (double l = 0.; l < mGeo.getTPCzLength() + .5 * dl; l += dl) {
-              auto [y, z] = mGeo.convPadDriftLengthToLocal(iSector, iRow, pad, l);
+              float y, z;
+              mGeo.convPadDriftLengthToLocal(iSector, iRow, pad, l, y, z);
               double dx, dy, dz;
               correctionLocal(iSector, iRow, y, z, dx, dy, dz);
               mCorrectionMap.addCorrectionPoint(iSector, iRow,
@@ -360,7 +362,8 @@ void TPCFastSpaceChargeCorrectionHelper::testGeometry(const TPCFastTransformGeo&
     for (int pad = 0; pad < nPads; pad++) {
       const GlobalPadNumber p = mapper.globalPadNumber(PadPos(row, pad));
       const PadCentre& c = mapper.padCentre(p);
-      auto [y, z] = geo.convPadDriftLengthToLocal(0, row, pad, 0.);
+      float y, z;
+      geo.convPadDriftLengthToLocal(0, row, pad, 0., y, z);
       const double dx = x - c.X();
       const double dy = y - (-c.Y()); // diferent sign convention for Y coordinate in the map
 
@@ -974,18 +977,20 @@ void TPCFastSpaceChargeCorrectionHelper::initInverse(std::vector<o2::gpu::TPCFas
 
         for (int iu = 0; iu < gridU.size(); iu++) {
           for (int iv = 0; iv < gridV.size(); iv++) {
-
-            auto [y, z] = correction.convGridToLocal(sector, row, gridU[iu], gridV[iv]);
+            float y, z;
+            correction.convGridToLocal(sector, row, gridU[iu], gridV[iv], y, z);
             double dx = 0, dy = 0, dz = 0;
 
             // add corrections
             for (int i = 0; i < corrections.size(); ++i) {
-              auto [dxTmp, dyTmp, dzTmp] = corrections[i]->getCorrectionLocal(sector, row, y, z);
+              float dxTmp, dyTmp, dzTmp;
+              corrections[i]->getCorrectionLocal(sector, row, y, z, dxTmp, dyTmp, dzTmp);
               dx += dxTmp * scaling[i];
               dy += dyTmp * scaling[i];
               dz += dzTmp * scaling[i];
             }
-            auto [gridU, gridV, scale] = correction.convRealLocalToGrid(sector, row, y + dy, z + dz);
+            float gridU, gridV, scale;
+            correction.convRealLocalToGrid(sector, row, y + dy, z + dz, gridU, gridV, scale);
             dataPointGridU.push_back(gridU);
             dataPointGridV.push_back(gridV);
             dataPointF.push_back(scale * dx);
@@ -1111,9 +1116,11 @@ void TPCFastSpaceChargeCorrectionHelper::mergeCorrections(
               float P[nKnotPar3d];
 
               { // direct correction
-                auto [y, z] = mainCorrection.convGridToLocal(sector, row, u, v);
+                float y, z;
+                mainCorrection.convGridToLocal(sector, row, u, v, y, z);
                 // return values: u, v, scaling factor
-                auto [lu, lv, ls] = corr.convLocalToGrid(sector, row, y, z);
+                float lu, lv, ls;
+                corr.convLocalToGrid(sector, row, y, z, lu, lv, ls);
                 ls *= scale;
                 double parscale[4] = {ls, ls * scaleU, ls * scaleV, ls * ls * scaleU * scaleV};
                 const auto& spl = corr.getSpline(sector, row);
@@ -1125,9 +1132,11 @@ void TPCFastSpaceChargeCorrectionHelper::mergeCorrections(
                 }
               }
 
-              auto [y, z] = mainCorrection.convGridToRealLocal(sector, row, u, v);
+              float y, z;
+              mainCorrection.convGridToRealLocal(sector, row, u, v, y, z);
               // return values: u, v, scaling factor
-              auto [lu, lv, ls] = corr.convRealLocalToGrid(sector, row, y, z);
+              float lu, lv, ls;
+              corr.convRealLocalToGrid(sector, row, y, z, lu, lv, ls);
               ls *= scale;
               double parscale[4] = {ls, ls * scaleRealU, ls * scaleRealV, ls * ls * scaleRealU * scaleRealV};
 

Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx

@@ -203,7 +203,8 @@ void TPCFastTransformHelperO2::testGeometry(const TPCFastTransformGeo& geo) cons
       const GlobalPadNumber p = mapper.globalPadNumber(PadPos(row, pad));
       const PadCentre& c = mapper.padCentre(p);
 
-      auto [y, z] = geo.convPadDriftLengthToLocal(0, row, pad, 0.);
+      float y, z;
+      geo.convPadDriftLengthToLocal(0, row, pad, 0., y, z);
 
       const double dx = x - c.X();
       const double dy = y - (-c.Y()); // diferent sign convention for Y coordinate in the map

GPU/TPCFastTransformation/Spline1DSpec.h

@@ -314,11 +314,9 @@ class Spline1DSpec<DataT, YdimT, 0> : public Spline1DContainer<DataT>
     const auto nYdimTmp = SplineUtil::getNdim<YdimT>(inpYdim);
     const auto nYdim = nYdimTmp.get();
 
-    auto val = getSderivativesOverParsAtU<T>(knotL, u);
-    const auto& dSdSl = val[0];
-    const auto& dSdDl = val[1];
-    const auto& dSdSr = val[2];
-    const auto& dSdDr = val[3];
+    T dSdSl, dSdDl, dSdSr, dSdDr;
+    getSderivativesOverParsAtU<T>(knotL, u, dSdSl, dSdDl, dSdSr, dSdDr);
+
     for (int32_t dim = 0; dim < nYdim; ++dim) {
       S[dim] = dSdSr * Sr[dim] + dSdSl * Sl[dim] + dSdDl * Dl[dim] + dSdDr * Dr[dim];
     }
@@ -346,7 +344,7 @@ class Spline1DSpec<DataT, YdimT, 0> : public Spline1DContainer<DataT>
   }
 
   template <typename T>
-  GPUd() std::array<T, 4> getSderivativesOverParsAtU(const Knot& knotL, DataT u) const
+  GPUd() void getSderivativesOverParsAtU(const Knot& knotL, DataT u, T& dSdSl, T& dSdDl, T& dSdSr, T& dSdDr) const
   {
     /// Get derivatives of the interpolated value {S(u): 1D -> nYdim} at the segment [knotL, next knotR]
     /// over the spline parameters Sl(eft), Sr(ight) and the slopes Dl, Dr
@@ -363,16 +361,15 @@ class Spline1DSpec<DataT, YdimT, 0> : public Spline1DContainer<DataT>
     T vm1 = v - T(1.);
     T a = u * vm1;
     T v2 = v * v;
-    T dSdSr = v2 * (T(3.) - v - v);
-    T dSdSl = T(1.) - dSdSr;
-    T dSdDl = vm1 * a;
-    T dSdDr = v * a;
+    dSdSr = v2 * (T(3.) - v - v);
+    dSdSl = T(1.) - dSdSr;
+    dSdDl = vm1 * a;
+    dSdDr = v * a;
     // S(u) = dSdSl * Sl + dSdSr * Sr + dSdDl * Dl + dSdDr * Dr;
-    return {dSdSl, dSdDl, dSdSr, dSdDr};
   }
 
   template <typename T>
-  GPUd() std::array<T, 8> getSDderivativesOverParsAtU(const Knot& knotL, DataT u) const
+  GPUd() void getSDderivativesOverParsAtU(const Knot& knotL, DataT u, T& dSdSl, T& dSdDl, T& dSdSr, T& dSdDr, T& dDdSl, T& dDdDl, T& dDdSr, T& dDdDr) const
   {
     /// Get derivatives of the interpolated value {S(u): 1D -> nYdim} at the segment [knotL, next knotR]
     /// over the spline values Sl, Sr and the slopes Dl, Dr
@@ -389,19 +386,18 @@ class Spline1DSpec<DataT, YdimT, 0> : public Spline1DContainer<DataT>
     T vm1 = v - T(1.);
     T a = u * vm1;
     T v2 = v * v;
-    T dSdSr = v2 * (T(3.) - v - v);
-    T dSdSl = T(1.) - dSdSr;
-    T dSdDl = vm1 * a;
-    T dSdDr = v * a;
+    dSdSr = v2 * (T(3.) - v - v);
+    dSdSl = T(1.) - dSdSr;
+    dSdDl = vm1 * a;
+    dSdDr = v * a;
 
     T dv = T(knotL.Li);
-    T dDdSr = 6. * v * (T(1.) - v) * dv;
-    T dDdSl = -dDdSr;
-    T dDdDl = vm1 * (v + v + vm1);
-    T dDdDr = v * (v + vm1 + vm1);
+    dDdSr = 6. * v * (T(1.) - v) * dv;
+    dDdSl = -dDdSr;
+    dDdDl = vm1 * (v + v + vm1);
+    dDdDr = v * (v + vm1 + vm1);
     // S(u) = dSdSl * Sl + dSdSr * Sr + dSdDl * Dl + dSdDr * Dr;
     // D(u) = dS(u)/du = dDdSl * Sl + dDdSr * Sr + dDdDl * Dl + dDdDr * Dr;
-    return {dSdSl, dSdDl, dSdSr, dSdDr, dDdSl, dDdDl, dDdSr, dDdDr};
   }
 
   using TBase::convXtoU;

GPU/TPCFastTransformation/Spline2DSpec.h

@@ -334,16 +334,9 @@ class Spline2DSpec<DataT, YdimT, 0>
     const DataT* A = Parameters + (nu * iv + iu) * nYdim4; // values { {Y1,Y2,Y3}, {Y1,Y2,Y3}'v, {Y1,Y2,Y3}'u, {Y1,Y2,Y3}''vu } at {u0, v0}
     const DataT* B = A + nYdim4 * nu;                      // values { ... } at {u0, v1}
 
-    auto val1 = mGridX1.template getSderivativesOverParsAtU<DataT>(knotU, u);
-    auto val2 = mGridX2.template getSderivativesOverParsAtU<DataT>(knotV, v);
-    const auto& dSl = val1[0];
-    const auto& dDl = val1[1];
-    const auto& dSr = val1[2];
-    const auto& dDr = val1[3];
-    const auto& dSd = val2[0];
-    const auto& dDd = val2[1];
-    const auto& dSu = val2[2];
-    const auto& dDu = val2[3];
+    DataT dSl, dDl, dSr, dDr, dSd, dDd, dSu, dDu;
+    mGridX1.template getSderivativesOverParsAtU<DataT>(knotU, u, dSl, dDl, dSr, dDr);
+    mGridX2.template getSderivativesOverParsAtU<DataT>(knotV, v, dSd, dDd, dSu, dDu);
 
     // when nYdim == 1:
     // S = dSl * (dSd * A[0] + dDd * A[1]) + dDl * (dSd * A[2] + dDd * A[3]) +
@@ -398,8 +391,10 @@ class Spline2DSpec<DataT, YdimT, 0>
     const DataT* A = Parameters + (nu * iv + iu) * nYdim4; // values { {Y1,Y2,Y3}, {Y1,Y2,Y3}'v, {Y1,Y2,Y3}'u, {Y1,Y2,Y3}''vu } at {u0, v0}
     const DataT* B = A + nYdim4 * nu;                      // values { ... } at {u0, v1}
 
-    auto [dSdSl, dSdDl, dSdSr, dSdDr, dRdSl, dRdDl, dRdSr, dRdDr] = mGridX1.template getSDderivativesOverParsAtU<DataT>(knotU, u);
-    auto [dSdSd, dSdDd, dSdSu, dSdDu, dQdSd, dQdDd, dQdSu, dQdDu] = mGridX2.template getSDderivativesOverParsAtU<DataT>(knotV, v);
+    DataT dSdSl, dSdDl, dSdSr, dSdDr, dRdSl, dRdDl, dRdSr, dRdDr;
+    mGridX1.template getSDderivativesOverParsAtU<DataT>(knotU, u, dSdSl, dSdDl, dSdSr, dSdDr, dRdSl, dRdDl, dRdSr, dRdDr);
+    DataT dSdSd, dSdDd, dSdSu, dSdDu, dQdSd, dQdDd, dQdSu, dQdDu;
+    mGridX2.template getSDderivativesOverParsAtU<DataT>(knotV, v, dSdSd, dSdDd, dSdSu, dSdDu, dQdSd, dQdDd, dQdSu, dQdDu);
 
     // when nYdim == 1:
 

GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx

@@ -731,7 +731,8 @@ double TPCFastSpaceChargeCorrection::testInverse(bool prn)
       MaxValue maxDrow[3];
       for (double y = y0; y < y1; y += stepY) {
         for (double z = z0; z < z1; z += stepZ) {
-          auto [dx, dy, dz] = getCorrectionLocal(sector, row, y, z);
+          float dx, dy, dz;
+          getCorrectionLocal(sector, row, y, z, dx, dy, dz);
           double realX = x + dx;
           double realY = y + dy;
           double realZ = z + dz;
@@ -745,7 +746,8 @@ double TPCFastSpaceChargeCorrection::testInverse(bool prn)
             continue;
           }
           float dxr = getCorrectionXatRealYZ(sector, row, realY, realZ);
-          auto [dyr, dzr] = getCorrectionYZatRealYZ(sector, row, realY, realZ);
+          float dyr, dzr;
+          getCorrectionYZatRealYZ(sector, row, realY, realZ, dyr, dzr);
           double d[3] = {dxr - dx, dyr - dy, dzr - dz};
           for (int32_t i = 0; i < 3; i++) {
             maxDrow[i].update(d[i], sector, row);