703 lines
33 KiB
C#
703 lines
33 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
|
|
namespace DatabaseExport
|
|
{
|
|
public class LinearizationFormula
|
|
{
|
|
private bool _bIsValid;
|
|
public bool IsValid() { return _bIsValid; }
|
|
public void MarkValid(bool bValid)
|
|
{
|
|
_bIsValid = bValid;
|
|
}
|
|
public enum Styles
|
|
{
|
|
IRTraccManual,
|
|
IRTraccDiagnosticsZero,
|
|
IRTraccZeroMMmV,
|
|
IRTraccAverageOverTime,
|
|
Polynomial,
|
|
IRTraccCalFactor
|
|
}
|
|
// public enum SLICEWareStyles
|
|
// {
|
|
// Manual,
|
|
// DiagnosticZeroMMmV,
|
|
// ZeroMMmV,
|
|
// AverageOverTime,
|
|
// Polynomial
|
|
// }
|
|
|
|
// // Translation
|
|
// public SLICEWareStyles SLICEWareStyle
|
|
// {
|
|
// get { return (SLICEWareStyles)_style; }
|
|
// set { _style = (Styles)value; }
|
|
// }
|
|
|
|
public Styles Style { get; set; } = Styles.IRTraccDiagnosticsZero;
|
|
|
|
public double PolynomialSensitivity { get; set; } = 1D;
|
|
|
|
public double LinearizationExponent { get; set; } = 1D;
|
|
|
|
// THIS IS MM/V, (UI has already been updated, we need to update the variable name)
|
|
public double MMPerV { get; set; }
|
|
|
|
public double MVAt0MM { get; set; }
|
|
|
|
public double Slope { get; set; }
|
|
|
|
public double Intercept { get; set; }
|
|
|
|
public double CalibrationFactor { get; set; }
|
|
|
|
public double ZeroPositionIntercept { get; set; }
|
|
|
|
public LinearizationFormula()
|
|
{
|
|
ZeroPositionIntercept = 0D;
|
|
CalibrationFactor = 0D;
|
|
Intercept = 0D;
|
|
_coefficients = new List<double>(new double[] { 0, 0, 0, 0 });
|
|
_exponents = new List<double>(new double[] { 0, 1, 2, 3 });
|
|
}
|
|
|
|
public LinearizationFormula(LinearizationFormula copy)
|
|
{
|
|
UsemVOverVForPolys = copy.UsemVOverVForPolys;
|
|
_bIsValid = copy._bIsValid;
|
|
_coefficients = new List<double>(copy._coefficients.ToArray());
|
|
_exponents = new List<double>(copy._exponents.ToArray());
|
|
Intercept = copy.Intercept;
|
|
LinearizationExponent = copy.LinearizationExponent;
|
|
MMPerV = copy.MMPerV;
|
|
MVAt0MM = copy.MVAt0MM;
|
|
Slope = copy.Slope;
|
|
Style = copy.Style;
|
|
_coefficients = new List<double>(copy._coefficients);
|
|
_exponents = new List<double>(copy._exponents);
|
|
PolynomialSensitivity = copy.PolynomialSensitivity;
|
|
ZeroPositionIntercept = copy.ZeroPositionIntercept;
|
|
CalibrationFactor = copy.CalibrationFactor;
|
|
}
|
|
// public double GetCoefficient(double exponent)
|
|
// {
|
|
// for (int i = 0; i < _exponents.Count && i < _coefficients.Count; i++)
|
|
// {
|
|
// if (_exponents[i] == exponent) { return _coefficients[i]; }
|
|
// }
|
|
// return 0;
|
|
// }
|
|
// public void SetCoefficient(double exponent, double coefficient)
|
|
// {
|
|
// for (int i = 0; i < _exponents.Count && i < _coefficients.Count; i++)
|
|
// {
|
|
// if (_exponents[i] == exponent) { _coefficients[i] = coefficient; return; }
|
|
// }
|
|
// }
|
|
// public double GetLinearizedValue(double input, double excitation)
|
|
// {
|
|
// if (Style != Styles.Polynomial && input <= 0)
|
|
// {
|
|
// //ir-tracc should never be < 0, however we may get readings less than zero due to
|
|
// //noise and other factors, treat these as positive near to zero
|
|
// input = .001;
|
|
// }
|
|
// //first linearize
|
|
// input /= 1000D;//assume input is in mV and we want it in Volts
|
|
// input = Math.Pow(input, LinearizationExponent);
|
|
|
|
// switch (Style)
|
|
// {
|
|
// case Styles.IRTraccDiagnosticsZero:
|
|
// return GetEUDiagnosticsZero(input);
|
|
// case Styles.IRTraccManual:
|
|
// return GetEUIRTraccManual(input);
|
|
// case Styles.IRTraccZeroMMmV:
|
|
// return GetEUZeroMMmV(input);
|
|
// case Styles.IRTraccAverageOverTime:
|
|
// return GetEUAverageOverTime(input);
|
|
// case Styles.Polynomial:
|
|
// return GetEUPolynomial(input, excitation);
|
|
// case Styles.IRTraccCalFactor:
|
|
// return GetEUIRTraccCalFactor(input);
|
|
// default:
|
|
// throw new NotSupportedException("unknown format: " + Style.ToString());
|
|
// }
|
|
// }
|
|
// private double GetEUIRTraccCalFactor(double volts)
|
|
// {
|
|
// return volts * CalibrationFactor + ZeroPositionIntercept;
|
|
// }
|
|
// private double GetEUIRTraccManual(double volts)
|
|
// {
|
|
// return (volts - Intercept) / Slope;
|
|
// }
|
|
public bool UsemVOverVForPolys { get; set; } = true;
|
|
// private double GetEUZeroMMmV(double volts)
|
|
// {
|
|
// double input = MVAt0MM / 1000D;
|
|
// input = Math.Pow(input, LinearizationExponent);
|
|
// if (double.IsNaN(input) || double.IsNegativeInfinity(input) || double.IsPositiveInfinity(input))
|
|
// {
|
|
// return volts * MMPerV;
|
|
// }
|
|
// else { return (volts * MMPerV - MMPerV * input); }
|
|
// }
|
|
private List<double> _coefficients = new List<double>();
|
|
private List<double> _exponents = new List<double>();
|
|
// private double GetEUPolynomial(double volts, double excitation)
|
|
// {
|
|
// //per J2517
|
|
// //3.4 Use of the Calibration Coefficients
|
|
// //The potentiometer assembly should be re-installed in the dummy without any mechanical adjustment of the
|
|
// //potentiometer. Prior to a crash test, the original zero offset level must be preserved by either not zeroing the
|
|
// //potentiometer (by signal conditioning or post-processing) or the amount that was zeroed must be added during postprocessing.
|
|
// //During the test the absolute voltage output time history should be recorded. This voltage signal is then
|
|
// //converted to engineering units by:
|
|
// //1. Convert voltage signal to mV/V at the sensor. This is the sensor reading S.
|
|
// //2. Convert the sensor reading S to displacement D by using the equation:
|
|
// //D = A*S^3 + B*S^2 + C*S + M (Eq. 2)
|
|
// //where:
|
|
// //D is the displacement relative to the thorax design position in mm
|
|
// //S is the sensor output reading in mV/V
|
|
// //A, B, C, and M are the calibration coefficients
|
|
// //NOTE: Make sure to use sufficient significant digits on all coefficients to assure accuracy of the conversion to
|
|
// //engineering units. It is recommended to use 5 significant digits (example 0.000012345).
|
|
|
|
// //double mV = volts * 1000D;
|
|
// //double gain = 1D;
|
|
// //mV = mV / (gain * excitation);
|
|
|
|
// //if (0 != PolynomialSensitivity && 1!= PolynomialSensitivity) { mV /= PolynomialSensitivity; }
|
|
// //double eu = 0D;
|
|
// //for (int i = 0; i < _coefficients.Count && i < _exponents.Count; i++)
|
|
// //{
|
|
// // eu += _coefficients[i] * Math.Pow(mV, _exponents[i]);
|
|
// //}
|
|
// //return eu;
|
|
|
|
// //CHANGED FOR GM TESTING
|
|
|
|
// if (0 != PolynomialSensitivity && 1 != PolynomialSensitivity)
|
|
// {
|
|
// volts /= PolynomialSensitivity;
|
|
// }
|
|
|
|
// double voltsOverV = 0D;
|
|
// if (UsemVOverVForPolys)
|
|
// {
|
|
// //convert to mV first
|
|
// voltsOverV = (volts * 1000D) / excitation;
|
|
// }
|
|
// else
|
|
// {
|
|
// //used by GM
|
|
// voltsOverV = volts / excitation;
|
|
// }
|
|
// double eu = 0;
|
|
|
|
// for (int i = 0; i < _coefficients.Count && i < _exponents.Count; i++)
|
|
// {
|
|
// if (_exponents[i] != 0)
|
|
// {
|
|
// eu += _coefficients[i] * Math.Pow(voltsOverV, _exponents[i]);
|
|
// }
|
|
// else
|
|
// {
|
|
// eu += _coefficients[i];
|
|
// }
|
|
// }
|
|
// return eu;
|
|
// }
|
|
// /// <summary>
|
|
// /// MvAt0MM set at diagnostics
|
|
// /// </summary>
|
|
// /// <param name="volts"></param>
|
|
// /// <returns></returns>
|
|
// private double GetEUDiagnosticsZero(double volts)
|
|
// {
|
|
// //double input = MVAt0MM/1000D;
|
|
// //input = System.Math.Pow(input,LinearizationExponent);
|
|
// double input = double.NaN;
|
|
// if (double.IsNaN(input) || double.IsPositiveInfinity(input) || double.IsNegativeInfinity(input))
|
|
// {
|
|
// return volts * MMPerV;
|
|
// }
|
|
// else
|
|
// {
|
|
// return volts * MMPerV - MMPerV * input;
|
|
// }
|
|
// }
|
|
// /// <summary>
|
|
// /// MVAt0MM set by diagnostics and then later on at
|
|
// /// Average Over Time
|
|
// /// </summary>
|
|
// /// <param name="volts"></param>
|
|
// /// <returns></returns>
|
|
// private double GetEUAverageOverTime(double volts)
|
|
// {
|
|
// //double input = MVAt0MM / 1000D;
|
|
// //input = System.Math.Pow(input, LinearizationExponent);
|
|
// double input = double.NaN;
|
|
// if (double.IsNaN(input) || double.IsNegativeInfinity(input) || double.IsPositiveInfinity(input))
|
|
// {
|
|
// return volts * MMPerV;
|
|
// }
|
|
// else
|
|
// {
|
|
// return volts * MMPerV - MMPerV * input;
|
|
// }
|
|
// }
|
|
|
|
|
|
// public string ToSLICEWareSerializeString()
|
|
// {
|
|
// if (!_bIsValid) { return ""; }
|
|
// StringBuilder sb = new StringBuilder();
|
|
// sb.AppendFormat("{0}_", Style.ToString());
|
|
|
|
// switch (Style)
|
|
// {
|
|
// case Styles.IRTraccDiagnosticsZero:
|
|
// sb.Append(ToIRTraccDiagnosticZeroString());
|
|
// break;
|
|
// case Styles.IRTraccManual:
|
|
// sb.Append(ToIRTraccManualString());
|
|
// break;
|
|
// case Styles.IRTraccZeroMMmV:
|
|
// sb.Append(ToIRTraccZeroMMmVString());
|
|
// break;
|
|
// case Styles.IRTraccAverageOverTime:
|
|
// sb.Append(ToIRTraccAverageOverTimeString());
|
|
// break;
|
|
// case Styles.Polynomial:
|
|
// sb.Append(ToSLICEWarePolynomialString());
|
|
// break;
|
|
// case Styles.IRTraccCalFactor:
|
|
// throw new NotSupportedException("CalFactor not supported in SLICEWare");
|
|
// default:
|
|
// throw new NotSupportedException("unknown type: " + Style.ToString());
|
|
// }
|
|
|
|
// return sb.ToString();
|
|
// }
|
|
|
|
/// <summary>
|
|
/// serializes to a string of the format "c0xe0 c1xe1...cnxen"
|
|
/// this will allow us arbitrary length polynomials and fractional exponents.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public string ToSerializeString()
|
|
{
|
|
if (!_bIsValid) { return ""; }
|
|
var sb = new StringBuilder();
|
|
sb.AppendFormat("{0}_", Style.ToString());
|
|
|
|
switch (Style)
|
|
{
|
|
case Styles.IRTraccDiagnosticsZero:
|
|
sb.Append(ToIRTraccDiagnosticZeroString());
|
|
break;
|
|
case Styles.IRTraccManual:
|
|
sb.Append(ToIRTraccManualString());
|
|
break;
|
|
case Styles.IRTraccZeroMMmV:
|
|
sb.Append(ToIRTraccZeroMMmVString());
|
|
break;
|
|
case Styles.IRTraccAverageOverTime:
|
|
sb.Append(ToIRTraccAverageOverTimeString());
|
|
break;
|
|
case Styles.Polynomial:
|
|
sb.Append(ToPolynomialString());
|
|
break;
|
|
case Styles.IRTraccCalFactor:
|
|
sb.Append(ToIRTraccCalFactorString());
|
|
break;
|
|
default:
|
|
throw new NotSupportedException("unknown type: " + Style.ToString());
|
|
}
|
|
|
|
return sb.ToString();
|
|
}
|
|
public string ToIRTraccDiagnosticZeroString()
|
|
{
|
|
return string.Format("{0}x{1}", MMPerV.ToString(System.Globalization.CultureInfo.InvariantCulture), LinearizationExponent
|
|
.ToString(System.Globalization.CultureInfo.InvariantCulture));
|
|
}
|
|
public string ToIRTraccCalFactorString()
|
|
{
|
|
return string.Format("{0}x{1}x{2}", CalibrationFactor.ToString(System.Globalization.CultureInfo.InvariantCulture), LinearizationExponent.ToString(System.Globalization.CultureInfo.InvariantCulture),
|
|
ZeroPositionIntercept.ToString(System.Globalization.CultureInfo.InvariantCulture));
|
|
}
|
|
public void FromIRTraccCalFactorString(string s, System.Globalization.CultureInfo culture)
|
|
{
|
|
var tokens = s.Split('x');
|
|
if (tokens.Length < 3) { throw new NotSupportedException("Invalid CalFactor format: " + s); }
|
|
|
|
CalibrationFactor = double.Parse(tokens[0], culture);
|
|
LinearizationExponent = double.Parse(tokens[1], culture);
|
|
ZeroPositionIntercept = double.Parse(tokens[2], culture);
|
|
}
|
|
public void FromIRTraccDiagnosticZeroString(string s, System.Globalization.CultureInfo culture)
|
|
{
|
|
var tokens = s.Split('x');
|
|
if (tokens.Length < 2) { throw new NotSupportedException("Invalid DiagnosticsZero format: " + s); }
|
|
MMPerV = double.Parse(tokens[0], culture);
|
|
LinearizationExponent = double.Parse(tokens[1], culture);
|
|
}
|
|
public string ToIRTraccManualString()
|
|
{
|
|
return string.Format("{0}x{1}x{2}", Slope.ToString(System.Globalization.CultureInfo.InvariantCulture), Intercept.ToString
|
|
(System.Globalization.CultureInfo.InvariantCulture), LinearizationExponent.ToString(
|
|
System.Globalization.CultureInfo.InvariantCulture));
|
|
}
|
|
public void FromIRTraccManualString(string s, System.Globalization.CultureInfo culture)
|
|
{
|
|
var tokens = s.Split('x');
|
|
if (tokens.Length < 3) { throw new NotSupportedException("Invalid IRTraccManual format: " + s); }
|
|
Slope = double.Parse(tokens[0], culture);
|
|
Intercept = double.Parse(tokens[1], culture);
|
|
LinearizationExponent = double.Parse(tokens[2], culture);
|
|
}
|
|
public string ToIRTraccZeroMMmVString()
|
|
{
|
|
return string.Format("{0}x{1}x{2}", MMPerV.ToString(System.Globalization.CultureInfo.InvariantCulture),
|
|
MVAt0MM.ToString(System.Globalization.CultureInfo.InvariantCulture),
|
|
LinearizationExponent.ToString(System.Globalization.CultureInfo.InvariantCulture));
|
|
}
|
|
// public string ToSLICEWarePolynomialString()
|
|
// {
|
|
// //SLICEWare is the reverse order of our DataPRO Database
|
|
// StringBuilder sb = new StringBuilder();
|
|
// for (int i = _exponents.Count - 1; i >= 0; i--)
|
|
// {
|
|
// if (i != _exponents.Count - 1) { sb.Append(","); }
|
|
// sb.AppendFormat("{0}x{1}", _coefficients[i].ToString(System.Globalization.CultureInfo.InvariantCulture),
|
|
// _exponents[i].ToString(System.Globalization.CultureInfo.InvariantCulture));
|
|
// }
|
|
|
|
// sb.AppendFormat(",S={0}", PolynomialSensitivity.ToString(System.Globalization.CultureInfo.InvariantCulture));
|
|
// return sb.ToString();
|
|
// }
|
|
public string ToPolynomialString()
|
|
{
|
|
var sb = new StringBuilder();
|
|
for (var i = 0; i < _coefficients.Count && i < _exponents.Count; i++)
|
|
{
|
|
if (i > 0) { sb.Append(","); }
|
|
sb.AppendFormat("{0}x{1}", _coefficients[i].ToString(System.Globalization.CultureInfo.InvariantCulture),
|
|
_exponents[i].ToString(System.Globalization.CultureInfo.InvariantCulture));
|
|
}
|
|
|
|
sb.AppendFormat(",S={0},mV={1}",
|
|
PolynomialSensitivity.ToString(System.Globalization.CultureInfo.InvariantCulture),
|
|
UsemVOverVForPolys.ToString(System.Globalization.CultureInfo.InvariantCulture));
|
|
|
|
return sb.ToString();
|
|
}
|
|
// public double[] PolynomialCoefficients
|
|
// {
|
|
// get { return _coefficients.ToArray(); }
|
|
// set { _coefficients = new List<double>(value); }
|
|
// }
|
|
// public double[] PolynomialExponents
|
|
// {
|
|
// get { return _exponents.ToArray(); }
|
|
// set { _exponents = new List<double>(value); }
|
|
// }
|
|
public string ToIRTraccAverageOverTimeString()
|
|
{
|
|
return string.Format("{0}x{1}", MMPerV.ToString(System.Globalization.CultureInfo.InvariantCulture),
|
|
LinearizationExponent.ToString(System.Globalization.CultureInfo.InvariantCulture));
|
|
}
|
|
public void FromIRTraccAverageOverTimeString(string s, System.Globalization.CultureInfo culture)
|
|
{
|
|
var tokens = s.Split('x');
|
|
if (tokens.Length < 2) { throw new NotSupportedException("Invalid IRTRaccAverageOverTime format: " + s); }
|
|
MMPerV = double.Parse(tokens[0], culture);
|
|
LinearizationExponent = double.Parse(tokens[1], culture);
|
|
}
|
|
public void FromIRTraccZeroMMmVString(string s, System.Globalization.CultureInfo culture)
|
|
{
|
|
var tokens = s.Split('x');
|
|
if (tokens.Length < 3) { throw new NotSupportedException("Invalid IRTraccZeroMMmV format: " + s); }
|
|
MMPerV = double.Parse(tokens[0], culture);
|
|
MVAt0MM = double.Parse(tokens[1], culture);
|
|
LinearizationExponent = double.Parse(tokens[2], culture);
|
|
}
|
|
public void FromPolynomialString(string s, System.Globalization.CultureInfo culture)
|
|
{
|
|
_coefficients.Clear();
|
|
_exponents.Clear();
|
|
|
|
var tokens = s.Split(',');
|
|
foreach (var t in tokens)
|
|
{
|
|
var subtokens = t.Split('x');
|
|
if (2 == subtokens.Length)
|
|
{
|
|
double d;
|
|
if (double.TryParse(subtokens[0], System.Globalization.NumberStyles.Float, culture, out d))
|
|
{
|
|
_coefficients.Add(d);
|
|
_exponents.Add(double.Parse(subtokens[1], culture));
|
|
}
|
|
else
|
|
{
|
|
PolynomialSensitivity = double.Parse(subtokens[1], culture);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
subtokens = t.Split('=');
|
|
if (subtokens.Length == 2)
|
|
{
|
|
switch (subtokens[0])
|
|
{
|
|
case "S":
|
|
PolynomialSensitivity = double.Parse(subtokens[1], culture);
|
|
break;
|
|
case "mV":
|
|
UsemVOverVForPolys = Convert.ToBoolean(subtokens[1], culture);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
public void FromSerializeString(string s, System.Globalization.CultureInfo culture)
|
|
{
|
|
if (string.IsNullOrEmpty(s)) { _bIsValid = false; return; }
|
|
if (s.Equals("1") || s.Equals("0") || s.Equals("1 ")) { _bIsValid = false; return; }
|
|
|
|
var tokens = s.Split('_');
|
|
if (tokens.Length < 2) { throw new NotSupportedException("unsupported Linearization Formula Format"); }
|
|
var style = (Styles)Enum.Parse(typeof(Styles), tokens[0], true);
|
|
Style = style;
|
|
switch (Style)
|
|
{
|
|
case Styles.IRTraccDiagnosticsZero:
|
|
FromIRTraccDiagnosticZeroString(tokens[1], culture);
|
|
_bIsValid = true;
|
|
break;
|
|
case Styles.IRTraccManual:
|
|
FromIRTraccManualString(tokens[1], culture);
|
|
_bIsValid = true;
|
|
break;
|
|
case Styles.IRTraccZeroMMmV:
|
|
FromIRTraccZeroMMmVString(tokens[1], culture);
|
|
_bIsValid = true;
|
|
break;
|
|
case Styles.Polynomial:
|
|
FromPolynomialString(tokens[1], culture);
|
|
_bIsValid = true;
|
|
break;
|
|
case Styles.IRTraccAverageOverTime:
|
|
FromIRTraccAverageOverTimeString(tokens[1], culture);
|
|
_bIsValid = true;
|
|
break;
|
|
case Styles.IRTraccCalFactor:
|
|
FromIRTraccCalFactorString(tokens[1], culture);
|
|
_bIsValid = true;
|
|
break;
|
|
default:
|
|
throw new NotSupportedException("Unknown format: " + Style.ToString());
|
|
}
|
|
}
|
|
public void FromSerializeString(string s)
|
|
{
|
|
FromSerializeString(s, System.Globalization.CultureInfo.InvariantCulture);
|
|
}
|
|
|
|
// public void FromTDCSerializeString()
|
|
// {
|
|
// _bIsValid = true;
|
|
// }
|
|
|
|
// /// <summary>
|
|
// /// Will return a display string for a nonlinear calibration based on N4 formating
|
|
// /// </summary>
|
|
// public string ToDisplayString()
|
|
// {
|
|
// return ToDisplayString("N4");
|
|
// }
|
|
// /// <summary>
|
|
// /// Will return a display string for a nonlinear calibration based on 1st paramater formating string
|
|
// /// </summary>
|
|
// /// <param name="nonlinearFormat"></param>
|
|
// /// <returns></returns>
|
|
// public string ToDisplayString(string nonlinearFormat)
|
|
// {
|
|
// if (string.IsNullOrEmpty(nonlinearFormat)) { nonlinearFormat = "N4"; }
|
|
// switch (Style)
|
|
// {
|
|
// case Styles.Polynomial:
|
|
// {
|
|
// return ToPolynomial(nonlinearFormat);
|
|
// }
|
|
// case Styles.IRTraccZeroMMmV:
|
|
// {
|
|
// return string.Format("mV = {0:n4}, {1:n4}*(V^{2})", MVAt0MM, MMPerV, ToSuperScript(LinearizationExponent.ToString(nonlinearFormat)));
|
|
// }
|
|
// case Styles.IRTraccManual:
|
|
// {
|
|
// return string.Format("((V^{0})-{1:n4})/{2:n4}", ToSuperScript(LinearizationExponent.ToString(nonlinearFormat)), Intercept, Slope);
|
|
// }
|
|
// case Styles.IRTraccDiagnosticsZero:
|
|
// {
|
|
// return string.Format("{0:n4}*(V^{1})", MMPerV, ToSuperScript(LinearizationExponent.ToString(nonlinearFormat)));
|
|
// }
|
|
// case Styles.IRTraccAverageOverTime:
|
|
// {
|
|
// return string.Format("{0:n4}*(V^{1})", MMPerV, ToSuperScript(LinearizationExponent.ToString(nonlinearFormat)));
|
|
// }
|
|
// case Styles.IRTraccCalFactor:
|
|
// {
|
|
// return string.Format("{2:n4}+{1:n4}*(V^{0})", ToSuperScript(LinearizationExponent.ToString(nonlinearFormat)), CalibrationFactor, ZeroPositionIntercept);
|
|
// }
|
|
// default:
|
|
// return string.Empty;
|
|
// }
|
|
// }
|
|
// private string ToPolynomial(string nonlinearFormat)
|
|
// {
|
|
// if (string.IsNullOrEmpty(nonlinearFormat)) { nonlinearFormat = "N4"; }
|
|
|
|
// StringBuilder sb = new StringBuilder();
|
|
|
|
// int termNumber = PolynomialCoefficients.Length - 1;
|
|
// foreach (var x in PolynomialCoefficients)
|
|
// {
|
|
// if (PolynomialCoefficients[termNumber] != 0)
|
|
// {
|
|
// double coeff = PolynomialCoefficients[termNumber];
|
|
|
|
// // Let the appended math symbol handle sign unless we're the first term.
|
|
// if (termNumber != PolynomialCoefficients.Length - 1)
|
|
// {
|
|
// coeff = Math.Abs(coeff);
|
|
// }
|
|
// sb.Append(coeff.ToString(nonlinearFormat));
|
|
// if (PolynomialExponents[termNumber] != 0)
|
|
// {
|
|
// sb.Append("x");
|
|
// if (PolynomialExponents[termNumber] != 1)
|
|
// {
|
|
// sb.Append(ToSuperScript(PolynomialExponents[termNumber].ToString("N0")));
|
|
// }
|
|
// }
|
|
// if (termNumber > 0)
|
|
// {
|
|
// // Coerricients are Displayed in absolute value. We need to combine the sign with the addition symbol
|
|
// sb.Append(PolynomialCoefficients[termNumber - 1] > 0 ? " + " : " - ");
|
|
// }
|
|
// }
|
|
// termNumber--;
|
|
// }
|
|
|
|
// return sb.ToString();
|
|
// }
|
|
// private string ToSuperScript(string source)
|
|
// {
|
|
// StringBuilder superScript = new StringBuilder();
|
|
|
|
// foreach (char c in source)
|
|
// {
|
|
// switch (c)
|
|
// {
|
|
// case '-':
|
|
// superScript.Append('\u207B');
|
|
// break;
|
|
// case '.':
|
|
// superScript.Append('\u00B7');
|
|
// break;
|
|
// case '1':
|
|
// superScript.Append('\u00B9');
|
|
// break;
|
|
// case '2':
|
|
// superScript.Append('\u00B2');
|
|
// break;
|
|
// case '3':
|
|
// superScript.Append('\u00B3');
|
|
// break;
|
|
// case '4':
|
|
// superScript.Append('\u2074');
|
|
// break;
|
|
// case '5':
|
|
// superScript.Append('\u2075');
|
|
// break;
|
|
// case '6':
|
|
// superScript.Append('\u2076');
|
|
// break;
|
|
// case '7':
|
|
// superScript.Append('\u2077');
|
|
// break;
|
|
// case '8':
|
|
// superScript.Append('\u2078');
|
|
// break;
|
|
// case '9':
|
|
// superScript.Append('\u2079');
|
|
// break;
|
|
// case '0':
|
|
// superScript.Append('\u2070');
|
|
// break;
|
|
// case '\'':
|
|
// superScript.Append('\u02C8');
|
|
// break;
|
|
// case ',':
|
|
// superScript.Append('\u22C5'); // there is no unicode superscript comma. this comes close
|
|
// break;
|
|
// case '\u00A0':
|
|
// superScript.Append('\u2009'); // unicode 'thin' space
|
|
// break;
|
|
// default:
|
|
// superScript.Append('\u207F');
|
|
// break;
|
|
// }
|
|
// }
|
|
|
|
// return superScript.ToString();
|
|
// }
|
|
// /*
|
|
// * we are given an equation in the form of y = ax^1 + b, except x and y are backwards for us (y=V where we'd prefer X was voltage, so we switch it)
|
|
// * y/a - b/a = x, and then switch y and x, (1/a)x^1 -(b/a)x^0 = y
|
|
// * now we want to get the coefficient of the first equation, which is "a", we get this by taking the inverse
|
|
// * we get b on the other hand by taking -1 * (b/a)*a. if we have the "coefficient", we have a
|
|
// */
|
|
// /*
|
|
// public double GetIRTraccCoefficient()
|
|
// {
|
|
// foreach (Factor f in Factors)
|
|
// {
|
|
// if (f.Exponent == 1D) { return System.Math.Pow(f.Coefficient, -1); }
|
|
// }
|
|
// return 1D; //0 doesn't make sense for ir
|
|
// }
|
|
// public double GetIRTraccConstant()
|
|
// {
|
|
// foreach (Factor f in Factors)
|
|
// {
|
|
// if (f.Exponent == 0D) { return -1D * GetIRTraccCoefficient() * f.Coefficient; }
|
|
// }
|
|
// return 0D;
|
|
// }
|
|
// public void SetIRTraccFactor(double coefficient, double constant)
|
|
// {
|
|
// if (0 == coefficient)
|
|
// {
|
|
// //well this doesn't make any sense ...
|
|
// coefficient = 1;
|
|
// }
|
|
// Factors = new Factor[]
|
|
// {
|
|
// new Factor(1/coefficient,1),
|
|
// new Factor(-constant/coefficient,0),
|
|
// };
|
|
// }*/
|
|
}
|
|
}
|