Add pentafoil/hexafoil distortion (p11-p14), fix spline sign bug, restore

cardinal-angle resampling, and add calibration diagnostics.

Five major changes in this commit:

1. PENTAFOIL/HEXAFOIL DISTORTION (p11-p14)
   Fourier analysis of calibrant residuals showed k=5 (pentafoil) as the
   dominant unmodeled harmonic at 5.6 µε.  Added cos(5η)·R^5 (p11,p12)
   and cos(6η)·R^6 (p13,p14) to the distortion model.  nBase increases
   from 16 to 20 in the optimizer; all 19 downstream files updated.
   New --fit-p-models keywords: pentafoil5, hexafoil6.
   Fix: CalibrantIntegratorOMP eg0 initializer was missing .p7-.p10
   (evaluate-only mode used zeroed dipole/trefoil params).

2. SPLINE RESIDUAL CORRECTION SIGN FIX
   The spline stored deltaR = RadFit - IdealR and applied Rt += deltaR,
   amplifying errors instead of correcting them (correlation +0.53 with
   residuals).  Fixed by negating: delta_r_px = -delta_r / px.
   Result: Stage 2 analytical = 6.0 µε → Stage 4 with spline = 4.5 µε
   (25% improvement, previously regressed to 8.4 µε).

3. CARDINAL-ANGLE RADIAL RESAMPLING FOR CALIBRANT
   IntegrationCore.c used nearest-neighbor pixel lookup, ignoring the
   bilinear interpolation + radial gradient correction implemented in
   IntegratorZarrOMP.  Replaced with matching bilinear + optional
   GradientCorrection=1 radial resampling.  Reduces cardinal-angle
   aliasing at sub-pixel R-bin widths (0.25 px).
   New CLI flag: --gradient-correction (default 1).

4. INTEGRATOR VALIDATION FIXES
   - Panel parameters (NPanelsY/Z, PanelShiftsFile) were not passed to
     DetectorMapper in run_integrator_validation, losing all per-panel
     corrections.  Fixed.
   - Added DeltaR (µm) and DeltaA (Å) columns to both calibrant and
     integrator corr.csv output.

5. CALIBRATION DIAGNOSTICS
   - Stage 1/2/3/4 corr.csv files saved with stage suffixes.
   - Full-detector distortion map PNGs (200×200 vectorized numpy grid)
     generated at each stage, showing analytical + panel + spline ΔR.
   - Spline-only map PNG showing residual correction.
   - Panel corrections (dY, dZ, dTheta, dLsd, dP2) included in maps.
   - Mask-aware: gap pixels rendered as white.
   - Stage 4: evaluate-only (nIterations=0) with/without spline for
     diagnostic A/B comparison.
   - plot_calibrant_results.py viewer updated: DeltaR/DeltaA columns,
     dynamic column detection for backward compatibility.

Files changed: 21 (781 insertions, 139 deletions)
  C core:      DetectorGeometry, CalibrationCore, CalibrantIntegratorOMP,
               CalibrantEstep, MIDAS_ParamParser, MapperCore, DetectorMapper,
               IntegrationCore (previous commit)
  C fitting:   FitSetupParamsAllZarr, FitMultipleGrains, FitWedgeParallel,
               PeaksFittingOMPZarrRefactor, ForwardSimulationCompressed
  Python:      AutoCalibrateZarr, ffGenerateZipRefactor
  GUI:         plot_calibrant_results.py
  Tests:       test_calibration_integration.py

Tested on CeO2 Varex 2880×2880 (63keV, 900mm) and CeO2 Pilatus 1475×1679
(72keV, 650mm).  Varex: 6.0 µε analytical → 4.5 µε with spline.
Pilatus: 38 µε → panel corrections reduce integrator to 20 µε range.

Author: marinerhemant

FF_HEDM/Example/Calibration/runAllCalibrations.sh

@@ -1,16 +1,16 @@
 # Varex with bad distortion
-python ~/opt/MIDAS/utils/AutoCalibrateZarr.py --data CeO2_10s_1000mm_42keV_000718.tiff --n-iterations 5 --px 150.0 --wavelength 0.29519 --material ceo2 --im-trans 1 --cpus 8
+python ~/opt/MIDAS/utils/AutoCalibrateZarr.py --data CeO2_10s_1000mm_42keV_000718.tiff --n-iterations 5 --px 150.0 --wavelength 0.29519 --material ceo2 --im-trans 1 --cpus 8 --fit-p-models all
 
 # Varex with low distortion
-python ~/opt/MIDAS/utils/AutoCalibrateZarr.py --data Ceria_63keV_900mm_100x100_0p5s_aero_0_001137.tif --n-iterations 5 --px 150.0 --wavelength 0.196793 --material ceo2 --im-trans 2 --cpus 8
+python ~/opt/MIDAS/utils/AutoCalibrateZarr.py --data Ceria_63keV_900mm_100x100_0p5s_aero_0_001137.tif --n-iterations 5 --px 150.0 --wavelength 0.196793 --material ceo2 --im-trans 2 --cpus 8 --fit-p-models all
 
 # Pilatus with panel shifts and auto masking
 # Delete older panel shifts file and mask file to initialize from scratch
 rm *panel* *autocal_mask*
-python ~/opt/MIDAS/utils/AutoCalibrateZarr.py --data CeO2_Pil_100x100_att000_650mm_71p676keV_001956.tif --dark dark_CeO2_Pil_100x100_att000_650mm_71p676keV_001975.tif --px 172.0 --wavelength 0.172979 --material ceo2 --im-trans 2 --n-iterations 5 --cpus 8
+python ~/opt/MIDAS/utils/AutoCalibrateZarr.py --data CeO2_Pil_100x100_att000_650mm_71p676keV_001956.tif --dark dark_CeO2_Pil_100x100_att000_650mm_71p676keV_001975.tif --px 172.0 --wavelength 0.172979 --material ceo2 --im-trans 2 --n-iterations 5 --cpus 8 --fit-p-models all
 
 # offset GE
-python ~/opt/MIDAS/utils/AutoCalibrateZarr.py --data CeO2_1s_65pt351keV_1860mm_000007.edf.ge1 --dark dark_6s_000010.ge1 --px 200.0 --wavelength 0.189714 --material ceo2 --n-iterations 5 --cpus 8
+python ~/opt/MIDAS/utils/AutoCalibrateZarr.py --data CeO2_1s_65pt351keV_1860mm_000007.edf.ge1 --dark dark_6s_000010.ge1 --px 200.0 --wavelength 0.189714 --material ceo2 --n-iterations 5 --cpus 8 --fit-p-models all
 
 
 # cleanup at the end

FF_HEDM/src/CalibrantEstep.h

@@ -20,6 +20,7 @@
 typedef struct {
     double Lsd, ybc, zbc, tx, ty, tz;
     double p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10;
+    double p11, p12, p13, p14;
     double px, MaxRingRad, parallax;
     double EtaBinSize;
     int RBinWidth;

FF_HEDM/src/CalibrantIntegratorOMP.c

@@ -29,7 +29,7 @@ void calib_set_trace_file(const char *filename) {
   if (calib_trace_fp) {
     fprintf(calib_trace_fp,
             "Eval,Objective,MeanStrain_ue,Lsd,ybc,zbc,ty,tz,"
-            "p0,p1,p2,p3,p4,p5,p6\n");
+            "p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13,p14\n");
     fflush(calib_trace_fp);
   }
 }
@@ -377,9 +377,10 @@ double calib_problem_function(unsigned n, const double *x, double *grad,
   double p0 = x[5], p1 = x[6], p2 = x[7], p3 = x[8];
   double p4 = x[9], p5 = x[10], p6 = x[11];
   double p7 = x[12], p8 = x[13], p9 = x[14], p10 = x[15];
+  double p11 = x[16], p12 = x[17], p13 = x[18], p14 = x[19];
   double parallax = 0;
   if (f->fitParallax)
-    parallax = x[16];
+    parallax = x[20];
   double wavelength = 0;
   if (f->fitWavelength)
     wavelength = x[f->nBase - 1];
@@ -443,7 +444,7 @@ double calib_problem_function(unsigned n, const double *x, double *grad,
     // and it internally computes Y_phys = (-rawY + ybc) * px
     double R_px, Eta;
     dg_pixel_to_REta_corr(rawY, rawZ, ybc, zbc, TRs, Lsd, MaxRad,
-                     p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, px, dLsd, dP2, parallax,
+                     p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, px, dLsd, dP2, parallax,
                      f->residualCorr, &R_px, &Eta, NULL);
 
     // Ideal R in pixels: Lsd * tan(2θ) / px
@@ -500,10 +501,11 @@ double calib_problem_function(unsigned n, const double *x, double *grad,
         : 0.0;
     fprintf(calib_trace_fp,
             "%lld,%.10e,%.6f,%.6f,%.6f,%.6f,%.8f,%.8f,"
-            "%.8e,%.8e,%.8e,%.8e,%.8e,%.8e,%.8e,%.8e,%.8e,%.8e,%.8e\n",
+            "%.8e,%.8e,%.8e,%.8e,%.8e,%.8e,%.8e,%.8e,%.8e,%.8e,%.8e,"
+            "%.8e,%.8e,%.8e,%.8e\n",
             ctx->NrCalls, TotalDiff, meanStrain_ue,
             Lsd, ybc, zbc, ty, tz,
-            p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
+            p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14);
     fflush(calib_trace_fp);
   }
 
@@ -533,6 +535,10 @@ int calib_fit_tilt_bc_lsd(
     double p8in, double tolP8, double *p8Out,
     double p9in, double tolP9, double *p9Out,
     double p10in, double tolP10, double *p10Out,
+    double p11in, double tolP11, double *p11Out,
+    double p12in, double tolP12, double *p12Out,
+    double p13in, double tolP13, double *p13Out,
+    double p14in, double tolP14, double *p14Out,
     int verbose, int L2Objective, double *initParams,
     Panel *initPanels, int fitWavelength, double wavelengthIn,
     double tolWavelength, double *PointDSpacing,
@@ -544,7 +550,7 @@ int calib_fit_tilt_bc_lsd(
     const DGResidualCorr *residualCorr) {
 
   int fitParallax = (tolParallax > EPS) ? 1 : 0;
-  int nBase = 16; // Lsd, ybc, zbc, ty, tz, p0-p3, p4, p5, p6, p7, p8, p9, p10
+  int nBase = 20; // Lsd, ybc, zbc, ty, tz, p0-p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14
   if (fitParallax) nBase++;
   if (fitWavelength) nBase++;
   unsigned n = nBase;
@@ -600,6 +606,10 @@ int calib_fit_tilt_bc_lsd(
   double bp8   = (initParams ? initParams[13] : p8in);
   double bp9   = (initParams ? initParams[14] : p9in);
   double bp10  = (initParams ? initParams[15] : p10in);
+  double bp11  = (initParams ? initParams[16] : p11in);
+  double bp12  = (initParams ? initParams[17] : p12in);
+  double bp13  = (initParams ? initParams[18] : p13in);
+  double bp14  = (initParams ? initParams[19] : p14in);
 
   x[0]  = Lsd;   xl[0]  = bLsd  - tolLsd;   xu[0]  = bLsd  + tolLsd;
   x[1]  = ybc;   xl[1]  = bybc  - tolBC;    xu[1]  = bybc  + tolBC;
@@ -617,12 +627,16 @@ int calib_fit_tilt_bc_lsd(
   x[13] = p8in;  xl[13] = bp8   - tolP8;   xu[13] = bp8   + tolP8;
   x[14] = p9in;  xl[14] = bp9   - tolP9;   xu[14] = bp9   + tolP9;
   x[15] = p10in; xl[15] = bp10  - tolP10;  xu[15] = bp10  + tolP10;
+  x[16] = p11in; xl[16] = bp11  - tolP11;  xu[16] = bp11  + tolP11;
+  x[17] = p12in; xl[17] = bp12  - tolP12;  xu[17] = bp12  + tolP12;
+  x[18] = p13in; xl[18] = bp13  - tolP13;  xu[18] = bp13  + tolP13;
+  x[19] = p14in; xl[19] = bp14  - tolP14;  xu[19] = bp14  + tolP14;
 
   if (fitParallax) {
-    double bpar = (initParams ? initParams[16] : parallaxIn);
-    x[16]  = parallaxIn;
-    xl[16] = bpar - tolParallax;
-    xu[16] = bpar + tolParallax;
+    double bpar = (initParams ? initParams[20] : parallaxIn);
+    x[nBase]  = parallaxIn;
+    xl[nBase] = bpar - tolParallax;
+    xu[nBase] = bpar + tolParallax;
   }
   if (fitWavelength) {
     int wlIdx = nBase - 1;
@@ -752,7 +766,11 @@ int calib_fit_tilt_bc_lsd(
   if (p8Out) *p8Out = x[13];
   if (p9Out) *p9Out = x[14];
   if (p10Out) *p10Out = x[15];
-  if (fitParallax && parallaxOut) *parallaxOut = x[16];
+  if (p11Out) *p11Out = x[16];
+  if (p12Out) *p12Out = x[17];
+  if (p13Out) *p13Out = x[18];
+  if (p14Out) *p14Out = x[19];
+  if (fitParallax && parallaxOut) *parallaxOut = x[nBase];
   if (fitWavelength && wavelengthOut) *wavelengthOut = x[nBase - 1];
 
   // Update panel shifts
@@ -826,6 +844,8 @@ int calib_fit_tilt_bc_lsd(
                        (p6Out ? *p6Out : p6in),
                        (p7Out ? *p7Out : p7in), (p8Out ? *p8Out : p8in),
                        (p9Out ? *p9Out : p9in), (p10Out ? *p10Out : p10in),
+                       (p11Out ? *p11Out : p11in), (p12Out ? *p12Out : p12in),
+                       (p13Out ? *p13Out : p13in), (p14Out ? *p14Out : p14in),
                        px, dLsd, dP2,
                        (fitParallax && parallaxOut) ? *parallaxOut : 0,
                        residualCorr, &R_px, &Eta, NULL);
@@ -889,6 +909,7 @@ void calib_correct_tilt_distortion(
     double p3, double *Etas, double *Diffs, double *RadOuts,
     double *StdDiff, double outlierFactor, int *IsOutlier,
     double p4, double p5, double p6, double p7, double p8, double p9, double p10,
+    double p11, double p12, double p13, double p14,
     int OutlierIterations,
     int verbose, double *MeanDiffOut, double parallax,
     const int *skipBin,
@@ -934,7 +955,7 @@ void calib_correct_tilt_distortion(
     // Canonical geometry via dg_pixel_to_REta_corr
     double R_px, Eta;
     dg_pixel_to_REta_corr(rawY, rawZ, ybc, zbc, TRs, Lsd, MaxRad,
-                     p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, px, dLsd, dP2, parallax,
+                     p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, px, dLsd, dP2, parallax,
                      residualCorr, &R_px, &Eta, NULL);
 
     double RIdeal_px = (Lsd + dLsd) * tan(DG_DEG2RAD * IdealTtheta[i]) / px;

FF_HEDM/src/CalibrationCore.c

@@ -146,6 +146,10 @@ int calib_fit_tilt_bc_lsd(
     double p8in, double tolP8, double *p8Out,
     double p9in, double tolP9, double *p9Out,
     double p10in, double tolP10, double *p10Out,
+    double p11in, double tolP11, double *p11Out,
+    double p12in, double tolP12, double *p12Out,
+    double p13in, double tolP13, double *p13Out,
+    double p14in, double tolP14, double *p14Out,
     int verbose, int L2Objective, double *initParams,
     Panel *initPanels, int fitWavelength, double wavelengthIn,
     double tolWavelength, double *PointDSpacing,
@@ -166,6 +170,7 @@ void calib_correct_tilt_distortion(
     double p3, double *Etas, double *Diffs, double *RadOuts,
     double *StdDiff, double outlierFactor, int *IsOutlier,
     double p4, double p5, double p6, double p7, double p8, double p9, double p10,
+    double p11, double p12, double p13, double p14,
     int OutlierIterations,
     int verbose, double *MeanDiffOut, double parallax,
     const int *skipBin,

FF_HEDM/src/CalibrationCore.h

@@ -81,11 +81,13 @@ void dg_pixel_to_REta(double Y, double Z, double Ycen, double Zcen,
                       double TRs[3][3], double Lsd, double RhoD, double p0,
                       double p1, double p2, double p3, double p4, double p5,
                       double p6, double p7, double p8, double p9, double p10,
+                      double p11, double p12, double p13, double p14,
                       double px, double dLsd, double dP2, double parallax,
                       double *R_out, double *Eta_out,
                       double *Eta_untilted_out) {
   dg_pixel_to_REta_corr(Y, Z, Ycen, Zcen, TRs, Lsd, RhoD,
                          p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10,
+                         p11, p12, p13, p14,
                          px, dLsd, dP2, parallax, NULL,
                          R_out, Eta_out, Eta_untilted_out);
 }
@@ -94,6 +96,7 @@ void dg_pixel_to_REta_corr(double Y, double Z, double Ycen, double Zcen,
                       double TRs[3][3], double Lsd, double RhoD, double p0,
                       double p1, double p2, double p3, double p4, double p5,
                       double p6, double p7, double p8, double p9, double p10,
+                      double p11, double p12, double p13, double p14,
                       double px, double dLsd, double dP2, double parallax,
                       const DGResidualCorr *corr,
                       double *R_out, double *Eta_out,
@@ -125,6 +128,8 @@ void dg_pixel_to_REta_corr(double Y, double Z, double Ycen, double Zcen,
   DistortFunc += p5 * pow(RNorm, 4.0);
   DistortFunc += p7 * pow(RNorm, 4.0) * cos(DG_DEG2RAD * (EtaT + p8));
   DistortFunc += p9 * pow(RNorm, 3.0) * cos(DG_DEG2RAD * (3 * EtaT + p10));
+  DistortFunc += p11 * pow(RNorm, 5.0) * cos(DG_DEG2RAD * (5 * EtaT + p12));
+  DistortFunc += p13 * pow(RNorm, 6.0) * cos(DG_DEG2RAD * (6 * EtaT + p14));
   DistortFunc += 1;
   double Rt = Rad * DistortFunc / px; // in pixels
   Rt = Rt * (Lsd / panelLsd);         // re-project to global Lsd plane
@@ -157,10 +162,12 @@ void dg_invert_REta_to_pixel(
     double Lsd, double RhoD,
     double p0, double p1, double p2, double p3, double p4, double p5,
     double p6, double p7, double p8, double p9, double p10,
+                      double p11, double p12, double p13, double p14,
     double px, double dLsd, double dP2, double parallax,
     double *Y_out, double *Z_out) {
   dg_invert_REta_to_pixel_corr(R_target, Eta_target, Ycen, Zcen, TRs,
       Lsd, RhoD, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10,
+      p11, p12, p13, p14,
       px, dLsd, dP2, parallax, NULL, Y_out, Z_out);
 }
 
@@ -170,6 +177,7 @@ void dg_invert_REta_to_pixel_corr(
     double Lsd, double RhoD,
     double p0, double p1, double p2, double p3, double p4, double p5,
     double p6, double p7, double p8, double p9, double p10,
+                      double p11, double p12, double p13, double p14,
     double px, double dLsd, double dP2, double parallax,
     const DGResidualCorr *corr,
     double *Y_out, double *Z_out) {
@@ -187,7 +195,7 @@ void dg_invert_REta_to_pixel_corr(
     // Evaluate forward function at current (Y, Z)
     double R_eval, Eta_eval;
     dg_pixel_to_REta_corr(Y, Z, Ycen, Zcen, TRs, Lsd, RhoD,
-                     p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, px, dLsd, dP2, parallax,
+                     p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, px, dLsd, dP2, parallax,
                      corr, &R_eval, &Eta_eval, NULL);
 
     double dR = R_target - R_eval;
@@ -202,10 +210,10 @@ void dg_invert_REta_to_pixel_corr(
     // Numerical Jacobian: ∂(R,η)/∂(Y,Z)
     double R_dY, Eta_dY, R_dZ, Eta_dZ;
     dg_pixel_to_REta_corr(Y + h, Z, Ycen, Zcen, TRs, Lsd, RhoD,
-                     p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, px, dLsd, dP2, parallax,
+                     p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, px, dLsd, dP2, parallax,
                      corr, &R_dY, &Eta_dY, NULL);
     dg_pixel_to_REta_corr(Y, Z + h, Ycen, Zcen, TRs, Lsd, RhoD,
-                     p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, px, dLsd, dP2, parallax,
+                     p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, px, dLsd, dP2, parallax,
                      corr, &R_dZ, &Eta_dZ, NULL);
 
     double dRdY = (R_dY - R_eval) / h;
@@ -249,11 +257,13 @@ void dg_invert_REta_to_pixel_panel(
     double Lsd, double RhoD,
     double p0, double p1, double p2, double p3, double p4, double p5,
     double p6, double p7, double p8, double p9, double p10,
+                      double p11, double p12, double p13, double p14,
     double px, double parallax,
     const Panel *panel,
     double *Y_out, double *Z_out) {
   dg_invert_REta_to_pixel_panel_corr(R_target, Eta_target, Ycen, Zcen, TRs,
       Lsd, RhoD, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10,
+      p11, p12, p13, p14,
       px, parallax, NULL, panel, Y_out, Z_out);
 }
 
@@ -263,6 +273,7 @@ void dg_invert_REta_to_pixel_panel_corr(
     double Lsd, double RhoD,
     double p0, double p1, double p2, double p3, double p4, double p5,
     double p6, double p7, double p8, double p9, double p10,
+                      double p11, double p12, double p13, double p14,
     double px, double parallax,
     const DGResidualCorr *corr,
     const Panel *panel,
@@ -271,6 +282,7 @@ void dg_invert_REta_to_pixel_panel_corr(
   if (panel == NULL) {
     dg_invert_REta_to_pixel_corr(R_target, Eta_target, Ycen, Zcen, TRs,
                             Lsd, RhoD, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10,
+                            p11, p12, p13, p14,
                             px, 0, 0, parallax, corr, Y_out, Z_out);
     return;
   }
@@ -291,7 +303,7 @@ void dg_invert_REta_to_pixel_panel_corr(
     // Forward: panel-corrected pixel → (R, Eta) with panel dLsd/dP2
     double R_eval, Eta_eval;
     dg_pixel_to_REta_corr(Y, Z, Ycen, Zcen, TRs, Lsd, RhoD,
-                     p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, px, dLsd, dP2, parallax,
+                     p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, px, dLsd, dP2, parallax,
                      corr, &R_eval, &Eta_eval, NULL);
 
     double dR = R_target - R_eval;
@@ -305,10 +317,10 @@ void dg_invert_REta_to_pixel_panel_corr(
     // Numerical Jacobian
     double R_dY, Eta_dY, R_dZ, Eta_dZ;
     dg_pixel_to_REta_corr(Y + h, Z, Ycen, Zcen, TRs, Lsd, RhoD,
-                     p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, px, dLsd, dP2, parallax,
+                     p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, px, dLsd, dP2, parallax,
                      corr, &R_dY, &Eta_dY, NULL);
     dg_pixel_to_REta_corr(Y, Z + h, Ycen, Zcen, TRs, Lsd, RhoD,
-                     p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, px, dLsd, dP2, parallax,
+                     p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, px, dLsd, dP2, parallax,
                      corr, &R_dZ, &Eta_dZ, NULL);
 
     double dRdY = (R_dY - R_eval) / h;