init

Common/DTS.CommonCore/.svn/pristine/84/842f974461cce14d14039c9d4668d8a4c8bacc9e.svn-base

@@ -0,0 +1,52 @@
+using System.ComponentModel;
+using DTS.Common.Converters;
+
+namespace DTS.Common.Enums
+{
+    /// <summary>
+    /// FB15313 Configure S6A udp streaming
+    /// </summary>
+    [TypeConverter(typeof(EnumDescriptionTypeConverter))]
+    public enum UDPStreamProfile : byte
+    {
+        [Description("UDPStreamProfiles_RTCStreaming")]
+        RTCStreaming = 0,
+        [Description("UDPStreamProfiles_DTS_UDP")]
+        DTS_UDP = 1,    // DTS with UDP timestamped using IRIG106 spec.
+        //    /! profile with time format 1 RTC. /
+        [Description("UDPStreamProfiles_CH10_MANUAL_CONFIG")]
+        CH10_MANUAL_CONFIG = 2,    // chapter 10 with manual configuration
+        [Description("UDPStreamProfiles_CH10_PCM128_MM")]
+        CH10_PCM128_MM = 3,    // PCM format with TDP format 1 and 128bit minor frame/major frame. No supercom.
+        [Description("UDPStreamProfiles_CH10_ANALOG")]
+        CH10_ANALOG = 4,    // analog format with time format 1.
+        [Description("UDPStreamProfiles_CH10_PCM_STANDARD")]
+        CH10_PCM_STANDARD = 5,    // PCM with standard format similar to one used for TmNS payload.
+        [Description("UDPStreamProfiles_CH10_PCM_SUPERCOM")]
+        CH10_PCM_SUPERCOM = 6,    // PCM with supercom format similar to one used for TmNS payload.
+
+        /*! profile with time format 2 + 2hdr option */
+        [Description("UDPStreamProfiles_CH10_PCM_128BIT_2HDR")]
+        CH10_PCM_128BIT_2HDR = 7,    // current PCM with 12-bit. 32-bit sync + 96 bit ADC (16x6)
+        [Description("UDPStreamProfiles_CH10_ANALOG_2HDR")]
+        CH10_ANALOG_2HDR = 8,    // Ch10 with analog + time format 1
+        [Description("UDPStreamProfiles_CH10_PCM_STANDARD_2HDR")]
+        CH10_PCM_STANDARD_2HDR = 9,    // PCM with standard format similar to one used for TmNS payload.
+        [Description("UDPStreamProfiles_CH10_PCM_SUPERCOM_2HDR")]
+        CH10_PCM_SUPERCOM_2HDR = 10,   // PCM with supercom format similar to one used for TmNS payload.
+
+        /*! TmNS PCM payload format */
+        [Description("UDPStreamProfiles_TMNS_PCM_STANDARD")]
+        TMNS_PCM_STANDARD = 11,   // TmNS with standard PCM format.
+        [Description("UDPStreamProfiles_TMNS_PCM_SUPERCOM")]
+        TMNS_PCM_SUPERCOM = 12,   // TmNS with supercom PCM format.
+        [Description("UDPStreamProfiles_IENAPTYPESTREAM")]
+        IENA_PTYPE_STREAM = 13,     // message format for Positional parameter only.
+        [Description("UDPStreamProfiles_UART_STREAM")]
+        UART_STREAM = 14,     // ADC-to-UART stream. no actual UDP messages sent
+        /*! reserved */
+        /*
+        [Description("UDPStreamProfiles_RSV15")]
+        RSV15 = 15*/
+    }
+}

Common/DTS.CommonCore/.svn/pristine/84/843f24fb793e5d51bed71b678bcf7c418a49d406.svn-base

@@ -0,0 +1,14 @@
+
+
+namespace DTS.Common.Enums.GroupTemplates
+{
+    public enum GroupTemplateFields
+    {
+        Name,
+        Description,
+        Channels,
+        LastModifiedBy,
+        LastModified,
+        AssociatedGroups
+    }
+}

Common/DTS.CommonCore/.svn/pristine/84/843f738d7fd3035285df6547d7fda5ebcf16a034.svn-base

@@ -0,0 +1,18 @@
+using Microsoft.Practices.Prism.Events;
+
+namespace DTS.Common.Events
+{
+    /// <summary>
+    /// Event to inform app that com status has changed
+    /// </summary>
+    /// <remarks>
+    ///  
+    /// </remarks>
+    public class CommActiveEvent : CompositePresentationEvent<ComStatusArg> { }
+
+    public enum ComStatusArg
+    {
+        CommandStart,
+        ResponseStart
+    }
+}

Common/DTS.CommonCore/.svn/pristine/84/84501d6774b2a12163132fe2fa587a4023865cc1.svn-base

@@ -0,0 +1,7 @@
+namespace DTS.Common.Enums.Sensors
+{
+    public enum SensorChangeTypes
+    {
+        OffsetTolerance
+    }
+}

Common/DTS.CommonCore/.svn/pristine/84/846fd517a426d2aa7f24475533e5d9d737b2a628.svn-base

@@ -0,0 +1,304 @@
+using System;
+using System.Text;
+using System.Xml.Linq;
+using System.ComponentModel;
+using DTS.Common.Utilities.Logging;
+using DTS.Common.Enums.Sensors;
+using DTS.Common.Interface.Sensors;
+using System.Collections.Generic;
+
+namespace DTS.Common.Classes.Sensors
+{
+    public class ZeroMethod : INotifyPropertyChanged
+    {
+        public event PropertyChangedEventHandler PropertyChanged;
+
+        protected bool SetProperty<T>(ref T storage, T value, String propertyName = null)
+        {
+            if (Equals(storage, value)) return false;
+
+            storage = value;
+            OnPropertyChanged(propertyName);
+            return true;
+        }
+        protected void OnPropertyChanged(string propertyName = null)
+        {
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+        }
+        public override int GetHashCode()
+        {
+            return Method.GetHashCode() + Start.GetHashCode() + End.GetHashCode();
+        }
+
+        public ZeroMethodType Method { get; set; } = SensorConstants.DefaultZeroMethodType; // FB12764: Belt-and-suspenders, fetch default from SensorConstants
+
+        public double Start { get; set; } = SensorConstants.DefaultZeroMethodStart; // FB12764: Belt-and-suspenders, fetch default from SensorConstants
+
+        public double End { get; set; } = SensorConstants.DefaultZeroMethodEnd; // FB12764: Belt-and-suspenders, fetch default from SensorConstants
+
+        #region Tags
+
+        internal const string ZERO_METHOD_TAG = "ZeroMethod";
+        internal const string METHOD_TAG = "Method";
+        internal const string START_TAG = "Start";
+        internal const string END_TAG = "End";
+
+        #endregion
+
+        public ZeroMethod(ZeroMethodType zm, double start, double end)
+        {
+            Method = zm;
+            Start = start;
+            End = end;
+        }
+
+        public ZeroMethod(string zm, System.Globalization.CultureInfo culture)
+        {
+            Initialize(zm, culture);
+        }
+        public ZeroMethod(string zm)
+        {
+            Initialize(zm, System.Globalization.CultureInfo.InvariantCulture);
+        }
+        /// <summary>
+        /// do a deep copy
+        /// </summary>
+        /// <param name="copy"></param>
+        public ZeroMethod(ZeroMethod copy)
+        {
+            Method = copy.Method;
+            Start = copy.Start;
+            End = copy.End;
+        }
+        private void Initialize(string zm, System.Globalization.CultureInfo culture)
+        {
+            var tokens = zm.Split(',');
+            if (tokens.Length < 3) { return; }
+            Start = Convert.ToDouble(tokens[1], culture);
+            End = Convert.ToDouble(tokens[2], culture);
+            if( tokens[0].Contains("PreCalZero") )
+            {
+                Method = ZeroMethodType.UsePreEventDiagnosticsZero;
+            }
+            else
+            { 
+                Method = (ZeroMethodType)
+                Enum.Parse(typeof(ZeroMethodType), tokens[0]);
+            }
+        }
+        public string ToDbString()
+        {
+            return $"{Method.ToString()},{Start},{End}";
+        }
+        private readonly string _tableName;
+        public ZeroMethod(XElement elem, string prefix, string tblName, string id)
+        {
+            _tableName = tblName;
+            XElement inner;
+            try
+            {
+                inner = elem.Element(mkTag(prefix));
+            }
+            catch (ArgumentNullException)
+            {
+                if (!string.IsNullOrEmpty(id))
+                {
+                    throw new Exception($"{_tableName}: Can't find tag {prefix + "-" + ZERO_METHOD_TAG} for entry {id}");
+                }
+                throw new Exception($"{_tableName}: Can't find tag {prefix + "-" + ZERO_METHOD_TAG} in file");
+            }
+            try
+            {
+                // this is a special case to remain compatible with older TDM
+                // I moved this to avoid the exception
+                // 6/8/2010 - dtm
+                if (inner.Value == "UsePreCalZero")
+                {
+                    Method = ZeroMethodType.UsePreEventDiagnosticsZero;
+                }
+                else if (inner.Value == ZeroMethodType.UsePreEventDiagnosticsZero.ToString())
+                {
+                    inner.Value = "UsePreCalZero";
+                    Method = ZeroMethodType.UsePreEventDiagnosticsZero;
+                }
+                else
+                {
+                    Method = (ZeroMethodType) Enum.Parse(typeof(ZeroMethodType), inner.Value);
+                }
+            }
+            catch (ArgumentException ex)
+            {
+                APILogger.Log(ex);
+                throw;
+            }
+            Start = double.Parse(inner.Attribute(START_TAG).Value, System.Globalization.CultureInfo.InvariantCulture);
+            End = double.Parse(inner.Attribute(END_TAG).Value, System.Globalization.CultureInfo.InvariantCulture);
+        }
+        
+        internal XElement ToXElement(string prefix)
+        {
+            string value;
+            switch (Method)
+            {
+                case ZeroMethodType.UsePreEventDiagnosticsZero:
+                    value = "UsePreCalZero";
+                    break;
+                default:
+                    value = Method.ToString();
+                    break;
+            }
+
+            var element = new XElement(mkTag(prefix), value);
+            element.SetAttributeValue(START_TAG, Start);
+            element.SetAttributeValue(END_TAG, End);
+            return element;
+        }
+        
+        internal void Update(XElement elem, string prefix)
+        {
+            elem.SetElementValue(mkTag(prefix), Method.ToString());
+            var element = elem.Element(mkTag(prefix));
+            element.SetAttributeValue(START_TAG, Start);
+            element.SetAttributeValue(END_TAG, End);
+        }
+        
+        internal static string mkTag(string prefix)
+        {
+            return prefix + "-" + ZERO_METHOD_TAG;
+        }
+
+        public string ToSerializeString()
+        {
+            return $"{Method.ToString()},{Start.ToString(System.Globalization.CultureInfo.InvariantCulture)},{End.ToString(System.Globalization.CultureInfo.InvariantCulture)}";
+        }
+
+
+        public string ToDisplayString(string averageOverTimeFormatString, string diagnosticLevelFormatString, string absoluteZeroFormatString)
+        {
+            var sb = new StringBuilder();
+            switch (Method)
+            {
+                case ZeroMethodType.AverageOverTime:
+                    sb.AppendFormat("{0} from {1} to {2}", averageOverTimeFormatString, Start, End);
+                    break;
+                case ZeroMethodType.UsePreEventDiagnosticsZero:
+                    sb.AppendFormat("{0}", diagnosticLevelFormatString);
+                    break;
+                case ZeroMethodType.None:
+                    sb.AppendFormat("{0}", absoluteZeroFormatString);
+                    break;
+            }
+            return sb.ToString();
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj is ZeroMethod zm)
+            {
+                return zm.Method == Method && zm.Start == Start && zm.End == End;
+            }
+            return base.Equals(obj);
+        }
+    }
+
+    public class ZeroMethods : IZeroMethods
+    {
+        public ZeroMethod[] Methods { get; set; } = new ZeroMethod[] { };
+
+        public ZeroMethods(ZeroMethods copy) : this(copy.Methods)
+        {
+        }
+
+        public ZeroMethods(ZeroMethod[] copyMethods)
+        {
+            ZeroMethod[] methods = new ZeroMethod[copyMethods.Length];
+            for (int i = 0; i < copyMethods.Length; i++)
+            {
+                methods[i] = new ZeroMethod(copyMethods[i]);
+            }
+            Methods = methods;
+        }
+
+        public ZeroMethods()
+        {
+            Methods = new ZeroMethod[] {  };
+        }
+        public ZeroMethods(string methods)
+        {
+            FromSerializedString(methods);
+        }
+
+        public ZeroMethods(ZeroMethod startingMethod)
+        {
+            Methods = new ZeroMethod[] { startingMethod };
+        }
+        public override bool Equals(object obj)
+        {
+            if (obj is ZeroMethods r)
+            {
+                if (r.Methods.Length != Methods.Length) { return false; }
+                for (int i = 0; i < r.Methods.Length; i++)
+                {
+                    if (!r.Methods[i].Equals(Methods[i])) { return false; }
+                }
+                return true;
+            }
+            return base.Equals(obj);
+        }
+        public void FromSerializedString(string s)
+        {
+            string[] tokens = s.Split(new string[] { MySeparator }, StringSplitOptions.None);
+            for (int i = 0; i < tokens.Length; i++) { tokens[i] = tokens[i].Replace(MySeparatorBackup, MySeparator); }
+
+            List<ZeroMethod> methods = new List<ZeroMethod>();
+            foreach (string token in tokens)
+            {
+                methods.Add(new ZeroMethod(token));
+            }
+            Methods = methods.ToArray();
+        }
+        private const string MySeparator = "__x__";
+        private const string MySeparatorBackup = "___xx___";
+        public string ToSerializedString()
+        {
+            List<string> methods = new List<string>();
+
+            foreach (var r in Methods) { methods.Add(r.ToSerializeString()); }
+
+            for (int i = 0; i < methods.Count; i++)
+            {
+                System.Diagnostics.Trace.Assert(!methods[i].Contains(MySeparatorBackup));
+                methods[i] = methods[i].Replace(MySeparator, MySeparatorBackup);
+            }
+            return string.Join(MySeparator, methods.ToArray());
+        }
+
+        public string ToDisplayString(string averageOverTimeFormatString, string diagnosticLevelFormatString, string absoluteZeroFormatString)
+        {
+            StringBuilder sb = new StringBuilder();
+
+            /*foreach (var r in Methods)
+            {
+                if (currentMethod > 1) { sb.AppendLine(); }
+                sb.AppendFormat("{0}: {1}", currentMethod++, r.ToDisplayString(sc));
+            }*/
+            for (int i = 0; i < Methods.Length; i++)
+            {
+                if (i > 0) { sb.AppendLine(); }
+
+                string s = Methods[i].ToDisplayString(averageOverTimeFormatString, diagnosticLevelFormatString, absoluteZeroFormatString);
+                if (!string.IsNullOrEmpty(s))
+                {
+                    sb.Append(s);
+                }
+
+            }
+            return sb.ToString();
+        }
+        public override string ToString()
+        {
+            return ToDisplayString(Strings.Strings.SensorFields_InitialOffset_AverageOverTimeFormat, Strings.Strings.SensorFields_InitialOffset_DiagnosticLevelFormat,
+                Strings.Strings.SensorFields_InitialOffset_AbsoluteZeroFormat);
+        }
+    }
+}

Common/DTS.CommonCore/.svn/pristine/84/8475800b4c8e95443c7dc7577ef38c9e3abf3e48.svn-base

@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace DTS.Common.Classes.Hardware
+{
+    public class SerializableAAF
+    {
+        public enum DAS_TYPE { TDAS = 0, SLICE = 1 };
+
+        /*private DAS_TYPE _type = DAS_TYPE.TDAS;
+        public DAS_TYPE DasType { get { return _type; }  }
+
+        private UInt64 _sampleRate = 0;
+        public UInt64 SampleRate { get { return _sampleRate; }  }
+
+        private float _aaf = 0F;
+        public float AAF { get { return _aaf; }  }
+        
+        public SerializableAAF(DAS_TYPE type, ulong sps, float aaf)
+        {
+            _type = type;
+            _sampleRate = sps;
+            _aaf = aaf;
+        }
+        private const string SEPARATOR = "_x_";
+        public string GetSerializedKey()
+        {
+            return string.Format("{0}{1}{2}", (int)DasType, SEPARATOR, SampleRate);                
+        }
+        public string GetSerializedValue()
+        {
+            return AAF.ToString(System.Globalization.CultureInfo.InvariantCulture);
+        }
+        public void FromSerializedStrings(string key, string value)
+        {
+            string[] tokens = key.Split(new string[] { SEPARATOR }, StringSplitOptions.None);
+            if (2 != tokens.Length) { throw new NotSupportedException("Invalid Format AAF key: " + key.ToArray()); }
+            _type = (DAS_TYPE)Convert.ToInt32(tokens[0]);
+            _sampleRate = Convert.ToUInt64(tokens[1]);
+            _aaf = Convert.ToSingle(value);
+        }*/
+    }
+}

Common/DTS.CommonCore/.svn/pristine/84/848541dff2b50c9c8a1f33897119c8efc79c55df.svn-base

@@ -0,0 +1,12 @@
+using DTS.Common.Base;
+
+namespace DTS.Common.Interface
+{
+    public interface IDockPanelHorizontalViewModel : IBaseViewModel
+    {
+        /// <summary>
+        /// Gets the Tab View.
+        /// </summary>
+        IDockPanelHorizontalView View { get; }
+    }
+}

Common/DTS.CommonCore/.svn/pristine/84/849c8095ab7b4fba3eb88d55dfc8d9ee66758615.svn-base

@@ -0,0 +1,195 @@
+using System;
+using System.ComponentModel;
+using System.Windows.Media;
+using DTS.Common.Base;
+// ReSharper disable CheckNamespace
+
+namespace DTS.Common.Interface
+{
+    public interface ITestChannel : INotifyPropertyChanged
+    {
+        string Group { get; set; }
+        string SubGroup { get; set; }
+        bool IsGraphChannel { get; set; }
+        string  GraphName { get; set; }
+        string TestId { get; set; }
+
+        string TestSetupName { get; set; }
+        string ModuleSerialNumber { get; set; }
+        string SerialNumber { get; set; }
+        string ChannelId { get; set; }
+        string ChannelDisplayName { get; set; }
+        string Description { get; set; }
+        string IsoCode { get; set; }
+        string IsoChannelName { get; set; }
+        string UserCode { get; set; }
+        string UserChannelName { get; set; }
+        string ChannelGroupName { get; set; }
+        string ChannelType { get; set; }
+        bool IsCalculatedChannel { get; set; }
+        int Number { get; set; }
+        string DigitalMultiplier { get; set; }
+        string DigitalMode { get; set; }
+        DateTime Start { get; set; }
+        string Bridge { get; set; }
+        double BridgeResistanceOhms { get; set; }
+        double ZeroPoint { get; set; }
+        string ChannelDescriptionString { get; set; }
+        void SetChannelDescriptionAndDisplayName(string channelDescriptionString);
+        string ChannelName2 { get; set; }
+        string HardwareChannelName { get; set; }
+        double DesiredRange { get; set; }
+        double ActualMaxRangeEu { get; set; }
+        double ActualMinRangeEu { get; set; }
+        double ActualMaxRangeAdc { get; }
+        double ActualMinRangeAdc { get; }
+        double ActualMaxRangeMv { get; set; }
+        double ActualMinRangeMv { get; set; }
+        double Sensitivity { get; set; }
+        string SoftwareFilter { get; set; }
+        bool ProportionalToExcitation { get; set; }
+        bool IsInverted { get; set; }
+        string LinearizationFormula { get; set; }
+        bool IsSubsampled { get; set; }
+        int AbsoluteDisplayOrder { get; set; }
+        DateTime LastCalibrationDate { get; set; }
+        string SensorId { get; set; }
+        int OffsetToleranceLowMv { get; set; }
+        int OffsetToleranceHighMv { get; set; }
+        int DataFlag { get; set; }
+        string ExcitationVoltage { get; set; }
+        string Eu { get; set; }
+        bool CalSignalEnabled { get; set; }
+        bool ShuntEnabled { get; set; }
+        bool VoltageInsertionCheckEnabled { get; set; }
+        bool RemoveOffset { get; set; }
+        string ZeroMethod { get; set; }
+        double ZeroAverageWindowBegin { get; set; }
+        double ZeroAverageWindowEnd { get; set; }
+        int InitialEu { get; set; }
+        string InitialOffset { get; set; }
+        int UnsubsampledSampleRateHz { get; set; }
+        double MeasuredShuntDeflectionMv { get; set; }
+        double TargetShuntDeflectionMv { get; set; }
+        double MeasuredExcitationVoltage { get; set; }
+        double FactoryExcitationVoltage { get; set; }
+        double TimeOfFirstSample { get; set; }
+        double Multiplier { get; set; }
+        double UserOffsetEu { get; set; }
+        int UnitConversion { get; set; }
+        bool AtCapacity { get; set; }
+        int CapacityOutputIsBasedOn { get; set; }
+        string SourceChannelNumber { get; set; }
+        string SourceModuleNumber { get; set; }
+        string SourceModuleSerialNumber { get; set; }
+        string Calculation { get; set; }
+        int SampleRateHz { get; set; }
+        string SensitivityUnits { get; set; }
+        int SensorCapacity { get; set; }
+        string SensorPolarity { get; set; }
+        int ChannelNumber { get; set; }
+        string BinaryFileName { get; set; }
+        string BinaryFilePath { get; set; }
+        double Xmax { get; set; }
+        double Xmin { get; set; }
+        int SequentialNumbers { get; set; }
+        ITestSetupMetadata ParentTestSetup { get; set; }
+        ITestModule ParentModule { get; set; }
+        IBaseViewModel Parent { get; set; }
+        Color ChannelColor { get; set; }
+        string ErrorMessage { get; set; }
+        bool IsError { get; set; }
+        Color? ErrorColor { get; set; }
+        bool IsSelected { get; set; }
+        bool CanSelectChannel { get; set; }
+        bool IsLocked { get; set; }
+        bool CanLock { get; set; }
+        ITestChannel Copy();
+        ulong T1Sample { get; set; }
+        ulong T2Sample { get; set; }
+        double HIC { get; set; }
+        bool UseEUScaler { get; set; }
+        double ScaleFactorEU { get; set; }
+
+        /// <summary>
+        /// Min value of ADC for entire dataset
+        /// </summary>
+        double MinADC { get; set; }
+        /// <summary>
+        /// Max value in ADC for entire dataset
+        /// </summary>
+        double MaxADC { get; set; }
+        /// <summary>
+        /// Average value in ADC for entire dataset
+        /// </summary>
+        double AveADC { get; set; }
+        /// <summary>
+        /// STD DEV in ADC for entire dataset
+        /// </summary>
+        double StdDevADC { get; set; }
+        /// <summary>
+        /// Value @ T0 in ADC
+        /// </summary>
+        double T0ADC { get; set; }
+        /// <summary>
+        /// Minimum value in mV for entire dataset
+        /// </summary>
+        double MinMV { get; set; }
+        /// <summary>
+        /// Maximum value in mV for entire dataset
+        /// </summary>
+        double MaxMV { get; set; }
+        /// <summary>
+        /// average value in mV for entire dataset
+        /// </summary>
+        double AveMV { get; set; }
+        /// <summary>
+        /// std dev in mV for entire dataset
+        /// </summary>
+        double StdDevMV { get; set; }
+        /// <summary>
+        /// value in mV at T0
+        /// </summary>
+        double T0MV { get; set; }
+        /// <summary>
+        /// minimum value in EU for entire dataset
+        /// </summary>
+        double MinEU { get; set; }
+        /// <summary>
+        /// maximum value in EU for entire dataset
+        /// </summary>
+        double MaxEU { get; set; }
+        /// <summary>
+        /// average value in EU for entire dataset
+        /// </summary>
+        double AveEU { get; set; }
+        /// <summary>
+        /// std dev in EU
+        /// </summary>
+        double StdDevEU { get; set; }
+        /// <summary>
+        /// value at T0 in EU
+        /// </summary>
+        double T0EU { get; set; }
+        /// <summary>
+        /// minimum value for whatever current units are for entire dataset
+        /// </summary>
+        double MinY { get; set; }
+        /// <summary>
+        /// maximum value for whatever current units are for entire dataset
+        /// </summary>
+        double MaxY { get; set; }
+        /// <summary>
+        /// average value for whatever current units are for entire dataset
+        /// </summary>
+        double AveY { get; set; }
+        /// <summary>
+        /// std deviation for whatever current units are
+        /// </summary>
+        double StdDevY { get; set; }
+        /// <summary>
+        /// Value at T0 in whatever current units are
+        /// </summary>
+        double T0Value { get; set; }
+    }
+}