TPC: fix the weight scaling of the mixed spline derivative in addCorrections

TPCFastSpaceChargeCorrectionHelper::addCorrections scaled the 4th parameter of each spline knot (the mixed derivative d2S/dudv)
with the square of the weight: secMainScale * secMainScale for the main correction, ls * ls * ... for the added ones (ls is the
weight times the z fade-out factor, 1 at the knots). A spline is linear in its parameters, so scaling the correction by w scales all
of them by w.

The correction was therefore right at the knots but wrong between them whenever a weight != 1 was used, e.g. the derivative map
added with weight lumiScale in TPCScalerSpec::buildMap. The error is proportional to w - w^2. Measured with a production map and
the derivative map of run 568041 (random points, vs the weighted point-by-point sum of getCorrectionLocal and of the inverse
getters), for map + 0.13 x derivative: rms ~20 um in dx and dz, ~10 um without the first 10 pad rows; deviations above 100 um are
rare (0.4 % of the points) and lie mostly in the first pad rows. At a weight of -0.5 the rms is ~150 um (~60 um without the first
10 pad rows). With the fix the sum is exact to float precision (< 0.1 um) for weights from -1 to 1.5, inverse corrections
included; w = 1 is unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: matthias-kleiner

Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx

@@ -1059,7 +1059,8 @@ void TPCFastSpaceChargeCorrectionHelper::addCorrections(
         constexpr int nKnotPar3d = nKnotPar1d * 3;
 
         { // scale the main correction
-          double parscale[4] = {secMainScale, secMainScale, secMainScale, secMainScale * secMainScale};
+          // a spline is linear in its parameters: scaling the function scales all of them, the mixed derivative included
+          double parscale[4] = {secMainScale, secMainScale, secMainScale, secMainScale};
           for (int iknot = 0, ind = 0; iknot < spline.getNumberOfKnots(); iknot++) {
             for (int ipar = 0; ipar < nKnotPar1d; ++ipar) {
               for (int idim = 0; idim < 3; idim++, ind++) {
@@ -1116,7 +1117,7 @@ void TPCFastSpaceChargeCorrectionHelper::addCorrections(
                 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};
+                double parscale[4] = {ls, ls * scaleU, ls * scaleV, ls * scaleU * scaleV};
                 const auto& spl = corr.getSplineForRow(row);
                 spl.interpolateParametersAtU(corr.getCorrectionData(sector, row), lu, lv, P);
                 for (int ipar = 0, ind = 0; ipar < nKnotPar1d; ++ipar) {
@@ -1132,7 +1133,7 @@ void TPCFastSpaceChargeCorrectionHelper::addCorrections(
               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};
+              double parscale[4] = {ls, ls * scaleRealU, ls * scaleRealV, ls * scaleRealU * scaleRealV};
 
               { // inverse X correction
                 corr.getSplineInvXforRow(row).interpolateParametersAtU(corr.getCorrectionDataInvX(sector, row), lu, lv, P);