Skip to content

Commit 287d018

Browse files
davidrohrdavidrohr
committed
GPU TPC FastTransformation: Do not use std::array
1 parent d6ac2c7 commit 287d018

10 files changed

Lines changed: 178 additions & 174 deletions

‎Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx‎

Lines changed: 20 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -159,7 +159,8 @@ void TPCFastSpaceChargeCorrectionHelper::fillSpaceChargeCorrectionFromMap(TPCFas
159159
for (int i = 0; i < nDataPoints; ++i) {
160160
o2::gpu::TPCFastSpaceChargeCorrectionMap::CorrectionPoint p = data[i];
161161
// not corrected grid coordinates
162-
auto [gu, gv, scale] = correction.convLocalToGrid(sector, row, p.mY, p.mZ);
162+
float gu, gv, scale;
163+
correction.convLocalToGrid(sector, row, p.mY, p.mZ, gu, gv, scale);
163164
if (scale - 1.f > 1.e-6) { // point is outside the grid
164165
continue;
165166
}
@@ -300,7 +301,8 @@ std::unique_ptr<TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrectionHelper
300301
double dpad = info.maxPad / (6. * (nKnotsY - 1));
301302
for (double pad = 0; pad < info.maxPad + .5 * dpad; pad += dpad) {
302303
for (double l = 0.; l < mGeo.getTPCzLength() + .5 * dl; l += dl) {
303-
auto [y, z] = mGeo.convPadDriftLengthToLocal(iSector, iRow, pad, l);
304+
float y, z;
305+
mGeo.convPadDriftLengthToLocal(iSector, iRow, pad, l, y, z);
304306
double dx, dy, dz;
305307
correctionLocal(iSector, iRow, y, z, dx, dy, dz);
306308
mCorrectionMap.addCorrectionPoint(iSector, iRow,
@@ -360,7 +362,8 @@ void TPCFastSpaceChargeCorrectionHelper::testGeometry(const TPCFastTransformGeo&
360362
for (int pad = 0; pad < nPads; pad++) {
361363
const GlobalPadNumber p = mapper.globalPadNumber(PadPos(row, pad));
362364
const PadCentre& c = mapper.padCentre(p);
363-
auto [y, z] = geo.convPadDriftLengthToLocal(0, row, pad, 0.);
365+
float y, z;
366+
geo.convPadDriftLengthToLocal(0, row, pad, 0., y, z);
364367
const double dx = x - c.X();
365368
const double dy = y - (-c.Y()); // diferent sign convention for Y coordinate in the map
366369

@@ -974,18 +977,20 @@ void TPCFastSpaceChargeCorrectionHelper::initInverse(std::vector<o2::gpu::TPCFas
974977

975978
for (int iu = 0; iu < gridU.size(); iu++) {
976979
for (int iv = 0; iv < gridV.size(); iv++) {
977-
978-
auto [y, z] = correction.convGridToLocal(sector, row, gridU[iu], gridV[iv]);
980+
float y, z;
981+
correction.convGridToLocal(sector, row, gridU[iu], gridV[iv], y, z);
979982
double dx = 0, dy = 0, dz = 0;
980983

981984
// add corrections
982985
for (int i = 0; i < corrections.size(); ++i) {
983-
auto [dxTmp, dyTmp, dzTmp] = corrections[i]->getCorrectionLocal(sector, row, y, z);
986+
float dxTmp, dyTmp, dzTmp;
987+
corrections[i]->getCorrectionLocal(sector, row, y, z, dxTmp, dyTmp, dzTmp);
984988
dx += dxTmp * scaling[i];
985989
dy += dyTmp * scaling[i];
986990
dz += dzTmp * scaling[i];
987991
}
988-
auto [gridU, gridV, scale] = correction.convRealLocalToGrid(sector, row, y + dy, z + dz);
992+
float gridU, gridV, scale;
993+
correction.convRealLocalToGrid(sector, row, y + dy, z + dz, gridU, gridV, scale);
989994
dataPointGridU.push_back(gridU);
990995
dataPointGridV.push_back(gridV);
991996
dataPointF.push_back(scale * dx);
@@ -1111,9 +1116,11 @@ void TPCFastSpaceChargeCorrectionHelper::mergeCorrections(
11111116
float P[nKnotPar3d];
11121117

11131118
{ // direct correction
1114-
auto [y, z] = mainCorrection.convGridToLocal(sector, row, u, v);
1119+
float y, z;
1120+
mainCorrection.convGridToLocal(sector, row, u, v, y, z);
11151121
// return values: u, v, scaling factor
1116-
auto [lu, lv, ls] = corr.convLocalToGrid(sector, row, y, z);
1122+
float lu, lv, ls;
1123+
corr.convLocalToGrid(sector, row, y, z, lu, lv, ls);
11171124
ls *= scale;
11181125
double parscale[4] = {ls, ls * scaleU, ls * scaleV, ls * ls * scaleU * scaleV};
11191126
const auto& spl = corr.getSpline(sector, row);
@@ -1125,9 +1132,11 @@ void TPCFastSpaceChargeCorrectionHelper::mergeCorrections(
11251132
}
11261133
}
11271134

1128-
auto [y, z] = mainCorrection.convGridToRealLocal(sector, row, u, v);
1135+
float y, z;
1136+
mainCorrection.convGridToRealLocal(sector, row, u, v, y, z);
11291137
// return values: u, v, scaling factor
1130-
auto [lu, lv, ls] = corr.convRealLocalToGrid(sector, row, y, z);
1138+
float lu, lv, ls;
1139+
corr.convRealLocalToGrid(sector, row, y, z, lu, lv, ls);
11311140
ls *= scale;
11321141
double parscale[4] = {ls, ls * scaleRealU, ls * scaleRealV, ls * ls * scaleRealU * scaleRealV};
11331142

‎Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -203,7 +203,8 @@ void TPCFastTransformHelperO2::testGeometry(const TPCFastTransformGeo& geo) cons
203203
const GlobalPadNumber p = mapper.globalPadNumber(PadPos(row, pad));
204204
const PadCentre& c = mapper.padCentre(p);
205205

206-
auto [y, z] = geo.convPadDriftLengthToLocal(0, row, pad, 0.);
206+
float y, z;
207+
geo.convPadDriftLengthToLocal(0, row, pad, 0., y, z);
207208

208209
const double dx = x - c.X();
209210
const double dy = y - (-c.Y()); // diferent sign convention for Y coordinate in the map

‎GPU/TPCFastTransformation/Spline1DSpec.h‎

Lines changed: 17 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -314,11 +314,9 @@ class Spline1DSpec<DataT, YdimT, 0> : public Spline1DContainer<DataT>
314314
const auto nYdimTmp = SplineUtil::getNdim<YdimT>(inpYdim);
315315
const auto nYdim = nYdimTmp.get();
316316

317-
auto val = getSderivativesOverParsAtU<T>(knotL, u);
318-
const auto& dSdSl = val[0];
319-
const auto& dSdDl = val[1];
320-
const auto& dSdSr = val[2];
321-
const auto& dSdDr = val[3];
317+
T dSdSl, dSdDl, dSdSr, dSdDr;
318+
getSderivativesOverParsAtU<T>(knotL, u, dSdSl, dSdDl, dSdSr, dSdDr);
319+
322320
for (int32_t dim = 0; dim < nYdim; ++dim) {
323321
S[dim] = dSdSr * Sr[dim] + dSdSl * Sl[dim] + dSdDl * Dl[dim] + dSdDr * Dr[dim];
324322
}
@@ -346,7 +344,7 @@ class Spline1DSpec<DataT, YdimT, 0> : public Spline1DContainer<DataT>
346344
}
347345

348346
template <typename T>
349-
GPUd() std::array<T, 4> getSderivativesOverParsAtU(const Knot& knotL, DataT u) const
347+
GPUd() void getSderivativesOverParsAtU(const Knot& knotL, DataT u, T& dSdSl, T& dSdDl, T& dSdSr, T& dSdDr) const
350348
{
351349
/// Get derivatives of the interpolated value {S(u): 1D -> nYdim} at the segment [knotL, next knotR]
352350
/// 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>
363361
T vm1 = v - T(1.);
364362
T a = u * vm1;
365363
T v2 = v * v;
366-
T dSdSr = v2 * (T(3.) - v - v);
367-
T dSdSl = T(1.) - dSdSr;
368-
T dSdDl = vm1 * a;
369-
T dSdDr = v * a;
364+
dSdSr = v2 * (T(3.) - v - v);
365+
dSdSl = T(1.) - dSdSr;
366+
dSdDl = vm1 * a;
367+
dSdDr = v * a;
370368
// S(u) = dSdSl * Sl + dSdSr * Sr + dSdDl * Dl + dSdDr * Dr;
371-
return {dSdSl, dSdDl, dSdSr, dSdDr};
372369
}
373370

374371
template <typename T>
375-
GPUd() std::array<T, 8> getSDderivativesOverParsAtU(const Knot& knotL, DataT u) const
372+
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
376373
{
377374
/// Get derivatives of the interpolated value {S(u): 1D -> nYdim} at the segment [knotL, next knotR]
378375
/// over the spline values Sl, Sr and the slopes Dl, Dr
@@ -389,19 +386,18 @@ class Spline1DSpec<DataT, YdimT, 0> : public Spline1DContainer<DataT>
389386
T vm1 = v - T(1.);
390387
T a = u * vm1;
391388
T v2 = v * v;
392-
T dSdSr = v2 * (T(3.) - v - v);
393-
T dSdSl = T(1.) - dSdSr;
394-
T dSdDl = vm1 * a;
395-
T dSdDr = v * a;
389+
dSdSr = v2 * (T(3.) - v - v);
390+
dSdSl = T(1.) - dSdSr;
391+
dSdDl = vm1 * a;
392+
dSdDr = v * a;
396393

397394
T dv = T(knotL.Li);
398-
T dDdSr = 6. * v * (T(1.) - v) * dv;
399-
T dDdSl = -dDdSr;
400-
T dDdDl = vm1 * (v + v + vm1);
401-
T dDdDr = v * (v + vm1 + vm1);
395+
dDdSr = 6. * v * (T(1.) - v) * dv;
396+
dDdSl = -dDdSr;
397+
dDdDl = vm1 * (v + v + vm1);
398+
dDdDr = v * (v + vm1 + vm1);
402399
// S(u) = dSdSl * Sl + dSdSr * Sr + dSdDl * Dl + dSdDr * Dr;
403400
// D(u) = dS(u)/du = dDdSl * Sl + dDdSr * Sr + dDdDl * Dl + dDdDr * Dr;
404-
return {dSdSl, dSdDl, dSdSr, dSdDr, dDdSl, dDdDl, dDdSr, dDdDr};
405401
}
406402

407403
using TBase::convXtoU;

‎GPU/TPCFastTransformation/Spline2DSpec.h‎

Lines changed: 7 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -334,16 +334,9 @@ class Spline2DSpec<DataT, YdimT, 0>
334334
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}
335335
const DataT* B = A + nYdim4 * nu; // values { ... } at {u0, v1}
336336

337-
auto val1 = mGridX1.template getSderivativesOverParsAtU<DataT>(knotU, u);
338-
auto val2 = mGridX2.template getSderivativesOverParsAtU<DataT>(knotV, v);
339-
const auto& dSl = val1[0];
340-
const auto& dDl = val1[1];
341-
const auto& dSr = val1[2];
342-
const auto& dDr = val1[3];
343-
const auto& dSd = val2[0];
344-
const auto& dDd = val2[1];
345-
const auto& dSu = val2[2];
346-
const auto& dDu = val2[3];
337+
DataT dSl, dDl, dSr, dDr, dSd, dDd, dSu, dDu;
338+
mGridX1.template getSderivativesOverParsAtU<DataT>(knotU, u, dSl, dDl, dSr, dDr);
339+
mGridX2.template getSderivativesOverParsAtU<DataT>(knotV, v, dSd, dDd, dSu, dDu);
347340

348341
// when nYdim == 1:
349342
// S = dSl * (dSd * A[0] + dDd * A[1]) + dDl * (dSd * A[2] + dDd * A[3]) +
@@ -398,8 +391,10 @@ class Spline2DSpec<DataT, YdimT, 0>
398391
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}
399392
const DataT* B = A + nYdim4 * nu; // values { ... } at {u0, v1}
400393

401-
auto [dSdSl, dSdDl, dSdSr, dSdDr, dRdSl, dRdDl, dRdSr, dRdDr] = mGridX1.template getSDderivativesOverParsAtU<DataT>(knotU, u);
402-
auto [dSdSd, dSdDd, dSdSu, dSdDu, dQdSd, dQdDd, dQdSu, dQdDu] = mGridX2.template getSDderivativesOverParsAtU<DataT>(knotV, v);
394+
DataT dSdSl, dSdDl, dSdSr, dSdDr, dRdSl, dRdDl, dRdSr, dRdDr;
395+
mGridX1.template getSDderivativesOverParsAtU<DataT>(knotU, u, dSdSl, dSdDl, dSdSr, dSdDr, dRdSl, dRdDl, dRdSr, dRdDr);
396+
DataT dSdSd, dSdDd, dSdSu, dSdDu, dQdSd, dQdDd, dQdSu, dQdDu;
397+
mGridX2.template getSDderivativesOverParsAtU<DataT>(knotV, v, dSdSd, dSdDd, dSdSu, dSdDu, dQdSd, dQdDd, dQdSu, dQdDu);
403398

404399
// when nYdim == 1:
405400

‎GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx‎

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -731,7 +731,8 @@ double TPCFastSpaceChargeCorrection::testInverse(bool prn)
731731
MaxValue maxDrow[3];
732732
for (double y = y0; y < y1; y += stepY) {
733733
for (double z = z0; z < z1; z += stepZ) {
734-
auto [dx, dy, dz] = getCorrectionLocal(sector, row, y, z);
734+
float dx, dy, dz;
735+
getCorrectionLocal(sector, row, y, z, dx, dy, dz);
735736
double realX = x + dx;
736737
double realY = y + dy;
737738
double realZ = z + dz;
@@ -745,7 +746,8 @@ double TPCFastSpaceChargeCorrection::testInverse(bool prn)
745746
continue;
746747
}
747748
float dxr = getCorrectionXatRealYZ(sector, row, realY, realZ);
748-
auto [dyr, dzr] = getCorrectionYZatRealYZ(sector, row, realY, realZ);
749+
float dyr, dzr;
750+
getCorrectionYZatRealYZ(sector, row, realY, realZ, dyr, dzr);
749751
double d[3] = {dxr - dx, dyr - dy, dzr - dz};
750752
for (int32_t i = 0; i < 3; i++) {
751753
maxDrow[i].update(d[i], sector, row);

0 commit comments

Comments
 (0)