Skip to content

Commit 5d802af

Browse files
sgorbunodavidrohr
sgorbuno
authored and
davidrohr
committed
TPC Splines: cleanup
1 parent 56b9a7b commit 5d802af

File tree

7 files changed

+66
-62
lines changed

7 files changed

+66
-62
lines changed

‎GPU/TPCFastTransformation/Spline1D.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -77,7 +77,7 @@ namespace gpu
7777
/// One can store all F-dependent spline parameters outside of the spline object
7878
/// and provide them at each interpolation call.
7979
/// To do so, create a spline with nYdimensions=0; create spline parameters for F via Spline1DHelper class;
80-
/// then use special interpolateU(..) methods for the interpolation.
80+
/// then use special interpolateAtU(..) methods for the interpolation.
8181
///
8282
/// This feature allows one to use the same spline object for the approximation of different functions
8383
/// on the same grid of knots.

‎GPU/TPCFastTransformation/Spline1DSpec.h‎

Lines changed: 32 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -287,33 +287,38 @@ class Spline1DSpec<DataT, YdimT, 0> : public Spline1DContainer<DataT>
287287
/// Get interpolated value S(x)
288288
GPUd() void interpolate(DataT x, GPUgeneric() DataT S[/*mYdim*/]) const
289289
{
290-
interpolateU<SafetyLevel::kSafe>(mYdim, mParameters, convXtoU(x), S);
290+
interpolateAtU<SafetyLevel::kSafe>(mYdim, mParameters, convXtoU(x), S);
291291
}
292292

293293
/// Get interpolated value for an nYdim-dimensional S(u) using spline parameters Parameters.
294294
template <SafetyLevel SafeT = SafetyLevel::kSafe>
295-
GPUd() void interpolateU(int32_t inpYdim, GPUgeneric() const DataT Parameters[],
296-
DataT u, GPUgeneric() DataT S[/*nYdim*/]) const
295+
GPUd() void interpolateAtU(int32_t inpYdim, GPUgeneric() const DataT Parameters[],
296+
DataT u, GPUgeneric() DataT S[/*nYdim*/]) const
297297
{
298298
const auto nYdimTmp = SplineUtil::getNdim<YdimT>(inpYdim);
299299
const auto nYdim = nYdimTmp.get();
300300
int32_t iknot = TBase::template getLeftKnotIndexForU<SafeT>(u);
301301
const DataT* d = Parameters + (2 * nYdim) * iknot;
302-
interpolateU(nYdim, getKnots()[iknot], &(d[0]), &(d[nYdim]), &(d[2 * nYdim]), &(d[3 * nYdim]), u, S);
302+
interpolateAtU(nYdim, getKnots()[iknot], &(d[0]), &(d[nYdim]), &(d[2 * nYdim]), &(d[3 * nYdim]), u, S);
303303
}
304304

305305
/// The main mathematical utility.
306306
/// Get interpolated value {S(u): 1D -> nYdim} at the segment [knotL, next knotR]
307307
/// using the spline values Sl, Sr and the slopes Dl, Dr
308308
template <typename T>
309-
GPUd() void interpolateU(int32_t inpYdim, const Knot& knotL,
310-
GPUgeneric() const T Sl[/*mYdim*/], GPUgeneric() const T Dl[/*mYdim*/],
311-
GPUgeneric() const T Sr[/*mYdim*/], GPUgeneric() const T Dr[/*mYdim*/],
312-
DataT u, GPUgeneric() T S[/*mYdim*/]) const
309+
GPUd() void interpolateAtU(int32_t inpYdim, const Knot& knotL,
310+
GPUgeneric() const T Sl[/*mYdim*/], GPUgeneric() const T Dl[/*mYdim*/],
311+
GPUgeneric() const T Sr[/*mYdim*/], GPUgeneric() const T Dr[/*mYdim*/],
312+
DataT u, GPUgeneric() T S[/*mYdim*/]) const
313313
{
314314
const auto nYdimTmp = SplineUtil::getNdim<YdimT>(inpYdim);
315315
const auto nYdim = nYdimTmp.get();
316316

317+
auto [dSdSl, dSdDl, dSdSr, dSdDr] = getSderivativesOverParsAtU<T>(knotL, u);
318+
for (int32_t dim = 0; dim < nYdim; ++dim) {
319+
S[dim] = dSdSr * Sr[dim] + dSdSl * Sl[dim] + dSdDl * Dl[dim] + dSdDr * Dr[dim];
320+
}
321+
/*
317322
if (u < (DataT)0) {
318323
u = (DataT)0;
319324
}
@@ -330,6 +335,7 @@ class Spline1DSpec<DataT, YdimT, 0> : public Spline1DContainer<DataT>
330335
T b = df - Dl[dim] - a;
331336
S[dim] = ((a * v + b) * v + Dl[dim]) * uu + Sl[dim];
332337
}
338+
*/
333339
/*
334340
another way to calculate f(u):
335341
T uu = T(u - knotL.u);
@@ -345,11 +351,10 @@ class Spline1DSpec<DataT, YdimT, 0> : public Spline1DContainer<DataT>
345351
}
346352

347353
template <typename T>
348-
GPUd() void getUderivatives(const Knot& knotL, DataT u,
349-
T& dSl, T& dDl, T& dSr, T& dDr) const
354+
GPUd() std::tuple<T, T, T, T> getSderivativesOverParsAtU(const Knot& knotL, DataT u) const
350355
{
351356
/// Get derivatives of the interpolated value {S(u): 1D -> nYdim} at the segment [knotL, next knotR]
352-
/// over the spline values Sl, Sr and the slopes Dl, Dr
357+
/// over the spline parameters Sl(eft), Sr(ight) and the slopes Dl, Dr
353358

354359
if (u < (DataT)0) {
355360
u = (DataT)0;
@@ -363,11 +368,12 @@ class Spline1DSpec<DataT, YdimT, 0> : public Spline1DContainer<DataT>
363368
T vm1 = v - 1.;
364369
T a = u * vm1;
365370
T v2 = v * v;
366-
dSr = v2 * (3. - 2 * v);
367-
dSl = 1. - dSr;
368-
dDl = vm1 * a;
369-
dDr = v * a;
370-
// F(u) = dSl * Sl + dSr * Sr + dDl * Dl + dDr * Dr;
371+
T dSdSr = v2 * (3. - 2 * v);
372+
T dSdSl = 1. - dSdSr;
373+
T dSdDl = vm1 * a;
374+
T dSdDr = v * a;
375+
// S(u) = dSdSl * Sl + dSdSr * Sr + dSdDl * Dl + dSdDr * Dr;
376+
return std::make_tuple(dSdSl, dSdDl, dSdSr, dSdDr);
371377
}
372378
/*
373379
template <typename T>
@@ -480,21 +486,21 @@ class Spline1DSpec<DataT, YdimT, 1>
480486

481487
/// Get interpolated value for an YdimT-dimensional S(u) using spline parameters Parameters.
482488
template <SafetyLevel SafeT = SafetyLevel::kSafe>
483-
GPUd() void interpolateU(GPUgeneric() const DataT Parameters[],
484-
DataT u, GPUgeneric() DataT S[/*nYdim*/]) const
489+
GPUd() void interpolateAtU(GPUgeneric() const DataT Parameters[],
490+
DataT u, GPUgeneric() DataT S[/*nYdim*/]) const
485491
{
486-
TBase::template interpolateU<SafeT>(YdimT, Parameters, u, S);
492+
TBase::template interpolateAtU<SafeT>(YdimT, Parameters, u, S);
487493
}
488494

489495
/// Get interpolated value for an YdimT-dimensional S(u) at the segment [knotL, next knotR]
490496
/// using the spline values Sl, Sr and the slopes Dl, Dr
491497
template <typename T>
492-
GPUd() void interpolateU(const typename TBase::Knot& knotL,
493-
GPUgeneric() const T Sl[/*mYdim*/], GPUgeneric() const T Dl[/*mYdim*/],
494-
GPUgeneric() const T Sr[/*mYdim*/], GPUgeneric() const T Dr[/*mYdim*/],
495-
DataT u, GPUgeneric() T S[/*mYdim*/]) const
498+
GPUd() void interpolateAtU(const typename TBase::Knot& knotL,
499+
GPUgeneric() const T Sl[/*mYdim*/], GPUgeneric() const T Dl[/*mYdim*/],
500+
GPUgeneric() const T Sr[/*mYdim*/], GPUgeneric() const T Dr[/*mYdim*/],
501+
DataT u, GPUgeneric() T S[/*mYdim*/]) const
496502
{
497-
TBase::interpolateU(YdimT, knotL, Sl, Dl, Sr, Dr, u, S);
503+
TBase::interpolateAtU(YdimT, knotL, Sl, Dl, Sr, Dr, u, S);
498504
}
499505

500506
using TBase::getNumberOfKnots;
@@ -504,7 +510,7 @@ class Spline1DSpec<DataT, YdimT, 1>
504510
#if !defined(GPUCA_GPUCODE)
505511
using TBase::recreate;
506512
#endif
507-
using TBase::interpolateU;
513+
using TBase::interpolateAtU;
508514
};
509515

510516
/// ==================================================================================================
@@ -552,7 +558,7 @@ class Spline1DSpec<DataT, YdimT, 2>
552558

553559
/// _______ Expert tools: interpolation with given nYdim and external Parameters _______
554560

555-
using TBase::interpolateU;
561+
using TBase::interpolateAtU;
556562
ClassDefNV(Spline1DSpec, 0);
557563
};
558564

‎GPU/TPCFastTransformation/Spline2DHelper.cxx‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -194,7 +194,7 @@ void Spline2DHelper<DataT>::approximateFunction(
194194
for (int32_t ipu = 0; ipu < nDataPointsU; ipu++) {
195195
double splineF[Ndim];
196196
double u = mHelperU1.getDataPoint(ipu).u;
197-
mHelperU1.getSpline().interpolateU(Ndim, parUdbl.get(), u, splineF);
197+
mHelperU1.getSpline().interpolateAtU(Ndim, parUdbl.get(), u, splineF);
198198
for (int32_t dim = 0; dim < Ndim; dim++) {
199199
rotDataPointF[(ipu * nDataPointsV + ipv) * Ndim + dim] = splineF[dim];
200200
}

‎GPU/TPCFastTransformation/Spline2DSpec.h‎

Lines changed: 17 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -239,13 +239,13 @@ class Spline2DSpec<DataT, YdimT, 0>
239239
/// Get interpolated value S(x)
240240
GPUd() void interpolate(DataT x1, DataT x2, GPUgeneric() DataT S[/*mYdim*/]) const
241241
{
242-
interpolateU<SafetyLevel::kSafe>(mYdim, mParameters, mGridX1.convXtoU(x1), mGridX2.convXtoU(x2), S);
242+
interpolateAtU<SafetyLevel::kSafe>(mYdim, mParameters, mGridX1.convXtoU(x1), mGridX2.convXtoU(x2), S);
243243
}
244244

245245
/// Get interpolated value for an inpYdim-dimensional S(u1,u2) using spline parameters Parameters.
246246
template <SafetyLevel SafeT = SafetyLevel::kSafe>
247-
GPUd() void interpolateUold(int32_t inpYdim, GPUgeneric() const DataT Parameters[],
248-
DataT u1, DataT u2, GPUgeneric() DataT S[/*inpYdim*/]) const
247+
GPUd() void interpolateAtUold(int32_t inpYdim, GPUgeneric() const DataT Parameters[],
248+
DataT u1, DataT u2, GPUgeneric() DataT S[/*inpYdim*/]) const
249249
{
250250

251251
const auto nYdimTmp = SplineUtil::getNdim<YdimT>(inpYdim);
@@ -295,7 +295,7 @@ class Spline2DSpec<DataT, YdimT, 0>
295295
typedef Spline1DSpec<DataT, 4 * YdimT, 0> TGridX1;
296296
const TGridX1& gridX1 = reinterpret_cast<const TGridX1&>(mGridX1);
297297

298-
gridX1.interpolateU(nYdim4, knotU, Su0, Du0, Su1, Du1, u, parU);
298+
gridX1.interpolateAtU(nYdim4, knotU, Su0, Du0, Su1, Du1, u, parU);
299299

300300
const DataT* Sv0 = parU + 0;
301301
const DataT* Dv0 = parU + nYdim;
@@ -304,13 +304,13 @@ class Spline2DSpec<DataT, YdimT, 0>
304304

305305
typedef Spline1DSpec<DataT, YdimT, 0> TGridX2;
306306
const TGridX2& gridX2 = reinterpret_cast<const TGridX2&>(mGridX2);
307-
gridX2.interpolateU(nYdim, knotV, Sv0, Dv0, Sv1, Dv1, v, S);
307+
gridX2.interpolateAtU(nYdim, knotV, Sv0, Dv0, Sv1, Dv1, v, S);
308308
}
309309

310310
/// Get interpolated value for an inpYdim-dimensional S(u1,u2) using spline parameters Parameters.
311311
template <SafetyLevel SafeT = SafetyLevel::kSafe>
312-
GPUd() void interpolateU(int32_t inpYdim, GPUgeneric() const DataT Parameters[],
313-
DataT u1, DataT u2, GPUgeneric() DataT S[/*inpYdim*/]) const
312+
GPUd() void interpolateAtU(int32_t inpYdim, GPUgeneric() const DataT Parameters[],
313+
DataT u1, DataT u2, GPUgeneric() DataT S[/*inpYdim*/]) const
314314
{
315315

316316
const auto nYdimTmp = SplineUtil::getNdim<YdimT>(inpYdim);
@@ -334,10 +334,8 @@ 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-
DataT dSl, dDl, dSr, dDr;
338-
mGridX1.getUderivatives(knotU, u, dSl, dDl, dSr, dDr);
339-
DataT dSd, dDd, dSu, dDu;
340-
mGridX2.getUderivatives(knotV, v, dSd, dDd, dSu, dDu);
337+
auto [dSl, dDl, dSr, dDr] = mGridX1.template getSderivativesOverParsAtU<DataT>(knotU, u);
338+
auto [dSd, dDd, dSu, dDu] = mGridX2.template getSderivativesOverParsAtU<DataT>(knotV, v);
341339

342340
// when nYdim == 1:
343341
// S = dSl * (dSd * A[0] + dDd * A[1]) + dDl * (dSd * A[2] + dDd * A[3]) +
@@ -430,18 +428,18 @@ class Spline2DSpec<DataT, YdimT, 1>
430428

431429
/// Get interpolated value for an YdimT-dimensional S(u1,u2) using spline parameters Parameters.
432430
template <SafetyLevel SafeT = SafetyLevel::kSafe>
433-
GPUd() void interpolateU(GPUgeneric() const DataT Parameters[],
434-
DataT u1, DataT u2, GPUgeneric() DataT S[/*nYdim*/]) const
431+
GPUd() void interpolateAtU(GPUgeneric() const DataT Parameters[],
432+
DataT u1, DataT u2, GPUgeneric() DataT S[/*nYdim*/]) const
435433
{
436-
TBase::template interpolateU<SafeT>(YdimT, Parameters, u1, u2, S);
434+
TBase::template interpolateAtU<SafeT>(YdimT, Parameters, u1, u2, S);
437435
}
438436

439437
/// Get interpolated value for an YdimT-dimensional S(u1,u2) using spline parameters Parameters.
440438
template <SafetyLevel SafeT = SafetyLevel::kSafe>
441-
GPUd() void interpolateUold(GPUgeneric() const DataT Parameters[],
442-
DataT u1, DataT u2, GPUgeneric() DataT S[/*nYdim*/]) const
439+
GPUd() void interpolateAtUold(GPUgeneric() const DataT Parameters[],
440+
DataT u1, DataT u2, GPUgeneric() DataT S[/*nYdim*/]) const
443441
{
444-
TBase::template interpolateUold<SafeT>(YdimT, Parameters, u1, u2, S);
442+
TBase::template interpolateAtUold<SafeT>(YdimT, Parameters, u1, u2, S);
445443
}
446444

447445
using TBase::getNumberOfKnots;
@@ -451,7 +449,7 @@ class Spline2DSpec<DataT, YdimT, 1>
451449
#if !defined(GPUCA_GPUCODE)
452450
using TBase::recreate;
453451
#endif
454-
using TBase::interpolateU;
452+
using TBase::interpolateAtU;
455453
};
456454

457455
/// ==================================================================================================
@@ -507,7 +505,7 @@ class Spline2DSpec<DataT, YdimT, 2>
507505

508506
/// _______ Expert tools: interpolation with given nYdim and external Parameters _______
509507

510-
using TBase::interpolateU;
508+
using TBase::interpolateAtU;
511509
};
512510

513511
/// ==================================================================================================

‎GPU/TPCFastTransformation/SplineHelper.cxx‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -410,8 +410,8 @@ void SplineHelper<DataT>::approximateFunction(
410410
}
411411
double splineF[mFdimensions];
412412
double u = mHelpers[dimension].getDataPoint(i).u;
413-
mHelpers[dimension].getSpline().interpolateU(mFdimensions, parD[dimension].get(), u, splineF); // recalculate at all datapoints of dimension
414-
for (int32_t dim = 0; dim < mFdimensions; dim++) { // writing it in allParameters
413+
mHelpers[dimension].getSpline().interpolateAtU(mFdimensions, parD[dimension].get(), u, splineF); // recalculate at all datapoints of dimension
414+
for (int32_t dim = 0; dim < mFdimensions; dim++) { // writing it in allParameters
415415
// LOG(info)<<allParameters [p-(int32_t)(pow(2.0, dimension))] [(int32_t)(startdatapoint*mFdimensions + i*distance + dim)]<<", ";
416416
allParameters[p - (int32_t)(pow(2.0, dimension))][(int32_t)(startdatapoint * mFdimensions + i * distance + dim)] = splineF[dim]; // write it in the array.
417417
// LOG(info)<<allParameters [p-(int32_t)(pow(2.0, dimension))] [(int32_t)(startdatapoint*mFdimensions + i*distance + dim)]<<", ";

‎GPU/TPCFastTransformation/SplineSpec.h‎

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -276,13 +276,13 @@ class SplineSpec<DataT, XdimT, YdimT, 0> : public SplineContainer<DataT>
276276
for (int32_t i = 0; i < nXdim; i++) {
277277
u[i] = mGrid[i].convXtoU(x[i]);
278278
}
279-
interpolateU<SafetyLevel::kSafe>(mXdim, mYdim, mParameters, u, S);
279+
interpolateAtU<SafetyLevel::kSafe>(mXdim, mYdim, mParameters, u, S);
280280
}
281281

282282
/// Get interpolated value for S(u):inpXdim->inpYdim using spline parameters Parameters
283283
template <SafetyLevel SafeT = SafetyLevel::kSafe>
284-
GPUd() void interpolateU(int32_t inpXdim, int32_t inpYdim, GPUgeneric() const DataT Parameters[],
285-
const DataT u[/*inpXdim*/], GPUgeneric() DataT S[/*inpYdim*/]) const
284+
GPUd() void interpolateAtU(int32_t inpXdim, int32_t inpYdim, GPUgeneric() const DataT Parameters[],
285+
const DataT u[/*inpXdim*/], GPUgeneric() DataT S[/*inpYdim*/]) const
286286
{
287287
const auto nXdimTmp = SplineUtil::getNdim<XdimT>(mXdim);
288288
const auto nXdim = nXdimTmp.get();
@@ -345,7 +345,7 @@ class SplineSpec<DataT, XdimT, YdimT, 0> : public SplineContainer<DataT>
345345
DataT coordinate = u[d];
346346
typedef Spline1DSpec<DataT, 0, 0> TGridX;
347347
const TGridX& gridX = *((const TGridX*)&(mGrid[d]));
348-
gridX.interpolateU(nInterpolations, knotL, S0, D0, S1, D1, coordinate, iParameters);
348+
gridX.interpolateAtU(nInterpolations, knotL, S0, D0, S1, D1, coordinate, iParameters);
349349
nInterpolations /= 4;
350350
nKnots /= 2;
351351
} // end d (every dimension)
@@ -354,7 +354,7 @@ class SplineSpec<DataT, XdimT, YdimT, 0> : public SplineContainer<DataT>
354354
S[i] = iParameters[i]; // write into result-array
355355
// LOG(info)<<iParameters[i] <<", ";
356356
}
357-
} // end interpolateU
357+
} // end interpolateAtU
358358

359359
protected:
360360
using TBase::mGrid;
@@ -421,18 +421,18 @@ class SplineSpec<DataT, XdimT, YdimT, 1>
421421

422422
/// Get interpolated value for an YdimT-dimensional S(u1,u2) using spline parameters Parameters.
423423
template <SafetyLevel SafeT = SafetyLevel::kSafe>
424-
GPUd() void interpolateU(GPUgeneric() const DataT Parameters[],
425-
const DataT u[/*XdimT*/], GPUgeneric() DataT S[/*YdimT*/]) const
424+
GPUd() void interpolateAtU(GPUgeneric() const DataT Parameters[],
425+
const DataT u[/*XdimT*/], GPUgeneric() DataT S[/*YdimT*/]) const
426426
{
427-
TBase::template interpolateU<SafeT>(XdimT, YdimT, Parameters, u, S);
427+
TBase::template interpolateAtU<SafeT>(XdimT, YdimT, Parameters, u, S);
428428
}
429429

430430
/// _______________ Suppress some parent class methods ________________________
431431
private:
432432
#if !defined(GPUCA_GPUCODE)
433433
using TBase::recreate;
434434
#endif
435-
using TBase::interpolateU;
435+
using TBase::interpolateAtU;
436436
};
437437

438438
/// ==================================================================================================
@@ -490,7 +490,7 @@ class SplineSpec<DataT, XdimT, YdimT, 2>
490490

491491
/// _______ Expert tools: interpolation with given nYdim and external Parameters _______
492492

493-
using TBase::interpolateU;
493+
using TBase::interpolateAtU;
494494

495495
/// Check dimensions
496496
void checkDimensions(int32_t& nXdim, int32_t& nYdim)

‎GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -410,7 +410,7 @@ GPUdi() std::tuple<float, float, float> TPCFastSpaceChargeCorrection::getCorrect
410410
auto [gridU, gridV, scale] = convLocalToGrid(sector, row, y, z);
411411

412412
float dxyz[3];
413-
spline.interpolateU(splineData, gridU, gridV, dxyz);
413+
spline.interpolateAtU(splineData, gridU, gridV, dxyz);
414414

415415
float dx = scale * GPUCommonMath::Clamp(dxyz[0], info.minCorr[0], info.maxCorr[0]);
416416
float dy = scale * GPUCommonMath::Clamp(dxyz[1], info.minCorr[1], info.maxCorr[1]);
@@ -427,7 +427,7 @@ GPUdi() float TPCFastSpaceChargeCorrection::getCorrectionXatRealYZ(int32_t secto
427427
auto [gridU, gridV, scale] = convCorrectedLocalToGrid(sector, row, realY, realZ);
428428

429429
float dx = 0;
430-
spline.interpolateU(splineData, gridU, gridV, &dx);
430+
spline.interpolateAtU(splineData, gridU, gridV, &dx);
431431

432432
dx = scale * GPUCommonMath::Clamp(dx, info.minCorr[0], info.maxCorr[0]);
433433
return dx;
@@ -443,7 +443,7 @@ GPUdi() std::tuple<float, float> TPCFastSpaceChargeCorrection::getCorrectionYZat
443443
const float* splineData = getSplineData(sector, row, 2);
444444

445445
float dyz[2];
446-
spline.interpolateU(splineData, gridU, gridV, dyz);
446+
spline.interpolateAtU(splineData, gridU, gridV, dyz);
447447

448448
dyz[0] = scale * GPUCommonMath::Clamp(dyz[0], info.minCorr[1], info.maxCorr[1]);
449449
dyz[1] = scale * GPUCommonMath::Clamp(dyz[1], info.minCorr[2], info.maxCorr[2]);

0 commit comments

Comments
 (0)