} //Calculates ratio between Z data from Calibration and Z data from Data points
static public double[] CalibrationAbsoluteArrayCalculation(double[] DataX, double[] DataY, double[] DataZ,
double[] XBkpt, double[] YBkpt, double[,] ZTab)
{
if (DataX.Length == DataY.Length && DataY.Length == DataZ.Length) //Check Data size plausibility
{
double[] ZArray = new double[DataX.Length];
for (int i = 0; i < DataX.Length; i++)
{
if (TabManagementMethods.BilinearInterpolation(DataX[i], DataY[i], XBkpt, YBkpt, ZTab) != 0)
{
ZArray[i] = TabManagementMethods.BilinearInterpolation(DataX[i], DataY[i], XBkpt, YBkpt, ZTab);
}
else
{
ZArray[i] = 0;
}
}
return(ZArray);
}
else
{
throw new System.ArgumentException("The X, Y and Z data arrays are not the same size", "original");
}
} //Calculates resulting Z calibrated value for each provided X, Y data point
static public double[] CalibrationRatioArrayCalculation(double[] DataX, double[] DataY, double[] DataZ,
double[] XBkpt, double[] YBkpt, double[,] ZTab)
{
if (DataX.Length == DataY.Length && DataY.Length == DataZ.Length) //Check Data size plausibility
{
double[] ZRatioArray = new double[DataX.Length];
for (int i = 0; i < DataX.Length; i++)
{
if (TabManagementMethods.BilinearInterpolation(DataX[i], DataY[i], XBkpt, YBkpt, ZTab) != 0)
{
DataZ[i] = DataZ[i] == 0 ? 0.00000001 : DataZ[i];
ZRatioArray[i] = DataZ[i] / TabManagementMethods.BilinearInterpolation(DataX[i], DataY[i], XBkpt, YBkpt, ZTab);
}
else if (TabManagementMethods.BilinearInterpolation(DataX[i], DataY[i], XBkpt, YBkpt, ZTab) == 0 && DataZ[i] == 0)
{
ZRatioArray[i] = 0;
}
else
{
DataZ[i] = DataZ[i] == 0 ? 0.00000001 : DataZ[i];
ZRatioArray[i] = DataZ[i] / 0.00000001;
}
}
return(ZRatioArray);
}
else
{
throw new System.ArgumentException("The X, Y and Z data arrays are not the same size", "original");
}
} //Calculates ratio between Z data from Calibration and Z data from Data points
} //Calculates resulting Z calibrated value for each provided X, Y data point
static public double[,] CalibrationTabOptimizationWiPB(double MeanTar, int PrecisionTar,
int WeightBox, int FineTuneIterBox, int FineTuneSubIterBox, bool FitType,
double[] DataX, double[] DataY, double[] DataZ,
double[] XBkpt, double[] YBkpt, double[,] ZTab,
ref ProgressBoxInvokation ProgressBox, ref double[] ErrStep, ref double[] StdDStep) // WiPB = With Progress Box
{
double X_A, X_B, Y_A, Y_B, ZMeanInterval;
double[,] ZWorkTab = new double[1 + ZTab.GetUpperBound(0), 1 + ZTab.GetUpperBound(1)];
double[] ZRatio = new double[DataZ.Length];
byte[,] ZTabStatus = new byte[1 + ZTab.GetUpperBound(0), 1 + ZTab.GetUpperBound(1)];
//0. Populate the iteration converging error vector (first position) to be plotted afterwards
if (FitType == false)
{
ErrStep[ErrStep.GetLowerBound(0)] = VectorStatBasicMethods.ErrorsAvg(DataZ,
CalibrationMethods.CalibrationAbsoluteArrayCalculation(DataX, DataY, DataZ, XBkpt, YBkpt, ZTab));
StdDStep[ErrStep.GetLowerBound(0)] = VectorStatBasicMethods.ErrorsStdDev(DataZ,
CalibrationMethods.CalibrationAbsoluteArrayCalculation(DataX, DataY, DataZ, XBkpt, YBkpt, ZTab));
}
else
{
ErrStep[ErrStep.GetLowerBound(0)] = VectorStatBasicMethods.Mean(
CalibrationMethods.CalibrationAbsoluteArrayCalculation(DataX, DataY, DataZ, XBkpt, YBkpt, ZTab));
StdDStep[ErrStep.GetLowerBound(0)] = VectorStatBasicMethods.StdDev(
CalibrationMethods.CalibrationAbsoluteArrayCalculation(DataX, DataY, DataZ, XBkpt, YBkpt, ZTab));
}
//1. Sweep each table point and get average value from delivered data
for (int i = 0; i < 1 + ZWorkTab.GetUpperBound(0); i++) //i sweeps Y
{
for (int j = 0; j < 1 + ZWorkTab.GetUpperBound(1); j++) //j sweeps X
{
//1.1 Select interval around table current point - X Values
if (j == 0)
{
X_A = XBkpt[j] - ((XBkpt[j + 1] - XBkpt[j]) / 2);
X_B = (XBkpt[j + 1] + XBkpt[j]) / 2;
}
else if (j == ZWorkTab.GetUpperBound(1))
{
X_A = (XBkpt[j] + XBkpt[j - 1]) / 2;
X_B = XBkpt[j] + ((XBkpt[j] - XBkpt[j - 1]) / 2);
}
else
{
X_A = (XBkpt[j] + XBkpt[j - 1]) / 2;
X_B = (XBkpt[j + 1] + XBkpt[j]) / 2;
}
//1.2 Select interval around table current point - Y Values
if (i == 0)
{
Y_A = YBkpt[i] - ((YBkpt[i + 1] - YBkpt[i]) / 2);
Y_B = (YBkpt[i + 1] + YBkpt[i]) / 2;
}
else if (i == ZWorkTab.GetUpperBound(0))
{
Y_A = (YBkpt[i] + YBkpt[i - 1]) / 2;
Y_B = YBkpt[i] + ((YBkpt[i] - YBkpt[i - 1]) / 2);
}
else
{
Y_A = (YBkpt[i] + YBkpt[i - 1]) / 2;
Y_B = (YBkpt[i + 1] + YBkpt[i]) / 2;
}
//1.3 Collect data corresponding to the targeted interval
int m_A = 0, m_B = 0, m_C = 0, m_D = 0;
//1.3.1 Num. of positions needed for each array
for (int k = 0; k < DataX.Length; k++)
{
m_A += (DataX[k] >= X_A && DataX[k] < XBkpt[j] && DataY[k] >= Y_A && DataY[k] < YBkpt[i]) ? 1 : 0;
m_B += (DataX[k] >= XBkpt[j] && DataX[k] < X_B && DataY[k] >= Y_A && DataY[k] < YBkpt[i]) ? 1 : 0;
m_C += (DataX[k] >= X_A && DataX[k] < XBkpt[j] && DataY[k] >= YBkpt[i] && DataY[k] < Y_B) ? 1 : 0;
m_D += (DataX[k] >= XBkpt[j] && DataX[k] < X_B && DataY[k] >= YBkpt[i] && DataY[k] < Y_B) ? 1 : 0;
}
double[] DataZSel_A = new double[m_A];
double[] DataZWei_A = new double[m_A];
double[] DataZSel_B = new double[m_B];
double[] DataZWei_B = new double[m_B];
double[] DataZSel_C = new double[m_C];
double[] DataZWei_C = new double[m_C];
double[] DataZSel_D = new double[m_D];
double[] DataZWei_D = new double[m_D];
m_A = 0;
m_B = 0;
m_C = 0;
m_D = 0;
//1.3.2 - Z values and weight calculation for each interval
for (int k = 0; k < DataX.Length; k++)
{
if (DataX[k] >= X_A && DataX[k] < XBkpt[j] && DataY[k] >= Y_A && DataY[k] < YBkpt[i])
{
DataZSel_A[m_A] = DataZ[k];
DataZWei_A[m_A] = TabManagementMethods.PointsDist2D((DataX[k] - X_A) / (XBkpt[j] - X_A),
(DataY[k] - Y_A) / (YBkpt[i] - Y_A),
0, 0);
m_A++;
}
else if (DataX[k] >= XBkpt[j] && DataX[k] < X_B && DataY[k] >= Y_A && DataY[k] < YBkpt[i])
{
DataZSel_B[m_B] = DataZ[k];
DataZWei_B[m_B] = TabManagementMethods.PointsDist2D((DataX[k] - X_B) / (XBkpt[j] - X_B),
(DataY[k] - Y_A) / (YBkpt[i] - Y_A),
0, 0);
m_B++;
}
else if (DataX[k] >= X_A && DataX[k] < XBkpt[j] && DataY[k] >= YBkpt[i] && DataY[k] < Y_B)
{
DataZSel_C[m_C] = DataZ[k];
DataZWei_C[m_C] = TabManagementMethods.PointsDist2D((DataX[k] - X_A) / (XBkpt[j] - X_A),
(DataY[k] - Y_B) / (YBkpt[i] - Y_B),
0, 0);
m_C++;
}
else if (DataX[k] >= XBkpt[j] && DataX[k] < X_B && DataY[k] >= YBkpt[i] && DataY[k] < Y_B)
{
DataZSel_D[m_D] = DataZ[k];
DataZWei_D[m_D] = TabManagementMethods.PointsDist2D((DataX[k] - X_B) / (XBkpt[j] - X_B),
(DataY[k] - Y_B) / (YBkpt[i] - Y_B),
0, 0);
m_D++;
}
}
//1.4 Calculate ZMean, within selected interval
byte b_A = 1, b_B = 1, b_C = 1, b_D = 1;
b_A = DataZSel_A.Length == 0 ? (byte)0 : (byte)1;
b_B = DataZSel_B.Length == 0 ? (byte)0 : (byte)1;
b_C = DataZSel_C.Length == 0 ? (byte)0 : (byte)1;
b_D = DataZSel_D.Length == 0 ? (byte)0 : (byte)1;
ZMeanInterval = (b_A * VectorStatBasicMethods.MeanWeighted(DataZSel_A, DataZWei_A, WeightBox) +
b_B * VectorStatBasicMethods.MeanWeighted(DataZSel_B, DataZWei_B, WeightBox) +
b_C * VectorStatBasicMethods.MeanWeighted(DataZSel_C, DataZWei_C, WeightBox) +
b_D * VectorStatBasicMethods.MeanWeighted(DataZSel_D, DataZWei_D, WeightBox)) / (b_A + b_B + b_C + b_D);
//1.5 Input mean optimized value (based on data) in ZWorkTab
ZWorkTab[i, j] = ZMeanInterval;
//1.6 Track/Flag the table values which didn't have associated data to be calculated
ZTabStatus[i, j] = (b_A + b_B + b_C + b_D == 0) ? (byte)0 : (byte)1;
ZWorkTab[i, j] = (b_A + b_B + b_C + b_D == 0) ? Math.Pow(10, -1 * (PrecisionTar + 1)) : ZWorkTab[i, j];
}
}
//2. Sweep empty table points (due to lack of data) and estimate value by neighbors
for (int i = 0; i < 1 + ZWorkTab.GetUpperBound(0); i++) //i sweeps Y
{
for (int j = 0; j < 1 + ZWorkTab.GetUpperBound(1); j++) //j sweeps X
{
ZWorkTab[i, j] += (ZWorkTab[i, j] == 0) ? Math.Pow(10, -1 * (PrecisionTar + 1)) : 0;
if (ZTabStatus[i, j] == 0)// Empty position gotten
{
double Z_Ya = 0, Z_Yb = 0, Z_Xa = 0, Z_Xb = 0;
byte b_Ya = 0, b_Yb = 0, b_Xa = 0, b_Xb = 0;
Z_Ya = (i == 0) ? 0 : ZWorkTab[i - 1, j];
Z_Yb = (i == ZWorkTab.GetUpperBound(0)) ? 0 : ZWorkTab[i + 1, j];
Z_Xa = (j == 0) ? 0 : ZWorkTab[i, j - 1];
Z_Xb = (j == ZWorkTab.GetUpperBound(1)) ? 0 : ZWorkTab[i, j + 1];
b_Ya = (byte)((i == 0) ? 0 : ZTabStatus[i - 1, j]);
b_Yb = (byte)((i == ZWorkTab.GetUpperBound(0)) ? 0 : ZTabStatus[i + 1, j]);
b_Xa = (byte)((j == 0) ? 0 : ZTabStatus[i, j - 1]);
b_Xb = (byte)((j == ZWorkTab.GetUpperBound(1)) ? 0 : ZTabStatus[i, j + 1]);
ZWorkTab[i, j] = (b_Ya + b_Yb + b_Xa + b_Xb) != 0 ?
(b_Ya * Z_Ya + b_Yb * Z_Yb + b_Xa * Z_Xa + b_Xb * Z_Xb) / (b_Ya + b_Yb + b_Xa + b_Xb) :
Math.Pow(10, -1 * (PrecisionTar + 1));
ZWorkTab[i, j] += Math.Pow(10, -1 * (PrecisionTar + 1));
}
}
}
//3. Sweep each table point and adjust to dimish Z Ratio average deviation
double MFactor = 1.25;
double[] ZRatioArray = CalibrationMethods.CalibrationRatioArrayCalculation(DataX, DataY, DataZ, XBkpt, YBkpt, ZWorkTab);
double ZErr = VectorStatBasicMethods.ErrorsStdDev(DataZ,
CalibrationMethods.CalibrationAbsoluteArrayCalculation(DataX, DataY, DataZ, XBkpt, YBkpt, ZWorkTab)), ZErrOld;
if (ProgressBox != null)
{
ProgressBox.ProgressBoxStart(); //If delivered, ProgressBox is desired, thus start ProgressBox
}
if (ProgressBox != null)
{
ProgressBox.ProgressBoxUpdate(0); //If delivered, ProgressBox is desired, thus set ProgressBox=0
}
for (int P2A = 0; P2A < FineTuneIterBox; P2A++)
{
for (int i = 0; i < 1 + ZWorkTab.GetUpperBound(0); i++) //i sweeps Y
{
for (int j = 0; j < 1 + ZWorkTab.GetUpperBound(1); j++) //j sweeps X
{
int LoopSkip = 0;
if (FitType == false) //Absolute Error optimization
{
ZErr = VectorStatBasicMethods.ErrorsStdDev(DataZ,
CalibrationMethods.CalibrationAbsoluteArrayCalculation(DataX, DataY, DataZ, XBkpt, YBkpt, ZWorkTab));
}
else //Relative Error optimization
{
ZErr = VectorStatBasicMethods.StdDev(
CalibrationMethods.CalibrationRatioArrayCalculation(DataX, DataY, DataZ, XBkpt, YBkpt, ZWorkTab));
}
for (int P2B = 0; P2B < FineTuneSubIterBox; P2B++)
{
// Increment or Decrement a Table value by a specific percent
ZWorkTab[i, j] *= MFactor;
// Evaluate the results of the value increment/decrement in terms of summed squared errors
ZErrOld = ZErr;
if (FitType == false) //Absolute Error optimization
{
ZErr = VectorStatBasicMethods.ErrorsStdDev(DataZ,
CalibrationMethods.CalibrationAbsoluteArrayCalculation(DataX, DataY, DataZ, XBkpt, YBkpt, ZWorkTab));
}
else //Relative Error optimization
{
ZErr = VectorStatBasicMethods.StdDev(
CalibrationMethods.CalibrationRatioArrayCalculation(DataX, DataY, DataZ, XBkpt, YBkpt, ZWorkTab));
}
// If the result didn't optimize the StdDev, undo operation and change direction and retrieve old error
MFactor = (ZErr >= ZErrOld) ? 1 / MFactor : MFactor;
ZWorkTab[i, j] *= (ZErr >= ZErrOld) ? MFactor : 1;
ZErr = (ZErr >= ZErrOld) ? ZErrOld : ZErr;
// When a second direction change is required (optm reached), break loop and goto next Table position
LoopSkip = (P2B == 1 && LoopSkip == 0) ? 1 : LoopSkip;
LoopSkip += (ZErr >= ZErrOld) ? 1 : 0;
if (LoopSkip == 2)
{
break;
}
}
if (ProgressBox != null)
{
ProgressBox.ProgressBoxUpdate(100 * P2A / FineTuneIterBox); //If delivered, ProgressBox is desired, thus set ProgressBox update
}
}
}
MFactor = MFactor < 1 ? 1 / MFactor : MFactor;
MFactor = ((MFactor - 1) / 2) + 1;
//Populate the iteration converging error vector to be plotted afterwards
if (FitType == false)
{
ErrStep[P2A + 1] = VectorStatBasicMethods.ErrorsAvg(DataZ,
CalibrationMethods.CalibrationAbsoluteArrayCalculation(DataX, DataY, DataZ, XBkpt, YBkpt, ZWorkTab));
StdDStep[P2A + 1] = VectorStatBasicMethods.ErrorsStdDev(DataZ,
CalibrationMethods.CalibrationAbsoluteArrayCalculation(DataX, DataY, DataZ, XBkpt, YBkpt, ZWorkTab));
}
else
{
ErrStep[P2A + 1] = VectorStatBasicMethods.Mean(
CalibrationMethods.CalibrationAbsoluteArrayCalculation(DataX, DataY, DataZ, XBkpt, YBkpt, ZWorkTab));
StdDStep[P2A + 1] = VectorStatBasicMethods.StdDev(
CalibrationMethods.CalibrationAbsoluteArrayCalculation(DataX, DataY, DataZ, XBkpt, YBkpt, ZWorkTab));
}
}
if (ProgressBox != null)
{
ProgressBox.ProgressBoxFinish(); //If delivered, ProgressBox is desired, thus finish ProgressBox
}
//4 Adjust Calibration Table values - MeanTar, Decimal Places, Round Values
double ZMean = VectorStatBasicMethods.Mean(ZRatioArray);
for (int i = 0; i < 1 + ZWorkTab.GetUpperBound(0); i++) //i sweeps Y
{
for (int j = 0; j < 1 + ZWorkTab.GetUpperBound(1); j++) //j sweeps X
{
if (FitType == false)
{
ZWorkTab[i, j] += ErrStep[ErrStep.GetUpperBound(0) - 1];
ZWorkTab[i, j] *= MeanTar;
}
else
{
ZWorkTab[i, j] *= MeanTar * VectorStatBasicMethods.Mean(
CalibrationMethods.CalibrationRatioArrayCalculation(DataX, DataY, DataZ, XBkpt, YBkpt, ZWorkTab));;
}
ZWorkTab[i, j] = Math.Round(ZWorkTab[i, j], PrecisionTar);
}
}
//5. Populate the iteration converging error vector (last position) to be plotted afterwards
if (FitType == false)
{
ErrStep[ErrStep.GetUpperBound(0)] = VectorStatBasicMethods.ErrorsAvg(DataZ,
CalibrationMethods.CalibrationAbsoluteArrayCalculation(DataX, DataY, DataZ, XBkpt, YBkpt, ZWorkTab));
StdDStep[ErrStep.GetUpperBound(0)] = VectorStatBasicMethods.ErrorsStdDev(DataZ,
CalibrationMethods.CalibrationAbsoluteArrayCalculation(DataX, DataY, DataZ, XBkpt, YBkpt, ZWorkTab));
}
else
{
ErrStep[ErrStep.GetUpperBound(0)] = VectorStatBasicMethods.Mean(
CalibrationMethods.CalibrationAbsoluteArrayCalculation(DataX, DataY, DataZ, XBkpt, YBkpt, ZWorkTab));
StdDStep[ErrStep.GetUpperBound(0)] = VectorStatBasicMethods.StdDev(
CalibrationMethods.CalibrationAbsoluteArrayCalculation(DataX, DataY, DataZ, XBkpt, YBkpt, ZWorkTab));
}
return(ZWorkTab);
}
