init

Common/DTS.Common.Serialization/Control/Event/Module/AnalogInputChannel/ReviewableCfcAttribute.cs

@@ -0,0 +1,59 @@
+/*
+ * DTS.Slice.Control.Event.Module.AnalogInputChannel.ReviewableCfcAttribute.cs
+ * 
+ * Copyright © 2009
+ * Diversified Technical Systems, Inc.
+ * All Rights Reserved
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using DTS.Utilities;
+
+namespace DTS.Slice.Control
+{
+    // *** see DTS.Slice.Control.Event.cs ***
+    public partial class Event
+    {
+
+        // *** see DTS.Slice.Control.Event.Module.cs ***
+        public partial class Module
+        {
+
+            // *** see DTS.Slice.Control.Event.Module.AnalogInputChannel.cs ***
+            public partial class AnalogInputChannel
+            {
+
+                /// <summary>
+                /// A reviewable CFC attribute attached to a specific channel.
+                /// </summary>
+                public class ReviewableCfcAttribute
+                    : Slice.Control.Event.Module.Channel.ReviewableAttribute
+                {
+                    /// <summary>
+                    /// Initialize an instance of this class.
+                    /// </summary>
+                    /// 
+                    /// <param name="channel">
+                    /// The <see cref="Event.Module.Channel"/> to which this attribute is attached.
+                    /// </param>
+                    /// 
+                    public ReviewableCfcAttribute(Event.Module.Channel channel)
+                        : base("CFC",
+                        delegate
+                        {
+                            //return ( new CfcValueAttributeCoder( ).DecodeAttributeValue( ( channel.CurrentFilter as SaeJ211Filter ).Type ) ).ToString( ); 
+                            if (channel.CurrentFilter.Type == ChannelFilter.AdHoc) { return "N/A"; }
+                            else { return (new CfcValueAttributeCoder().DecodeAttributeValue((channel.CurrentFilter as SaeJ211Filter).Type)).ToString(); }
+                        }
+                    )
+                    {
+                    }
+                }
+            }   // *** end Channel ***
+        }   // *** end Module ***
+    }   // *** end Event ***
+}
+

Common/DTS.Common.Serialization/Control/Event/Module/AnalogInputChannel/ReviewableDescriptionAttribute.cs

@@ -0,0 +1,52 @@
+/*
+ * DTS.Slice.Control.Event.Module.AnalogInputChannel.ReviewableCfcAttribute.cs
+ * 
+ * Copyright © 2009
+ * Diversified Technical Systems, Inc.
+ * All Rights Reserved
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using DTS.Utilities;
+
+namespace DTS.Slice.Control
+{
+    // *** see DTS.Slice.Control.Event.cs ***
+    public partial class Event
+    {
+
+        // *** see DTS.Slice.Control.Event.Module.cs ***
+        public partial class Module
+        {
+
+            // *** see DTS.Slice.Control.Event.Module.AnalogInputChannel.cs ***
+            public partial class AnalogInputChannel
+            {
+
+                /// <summary>
+                /// A reviewable CFC attribute attached to a specific channel.
+                /// </summary>
+                public class ReviewableDescriptionAttribute
+                    : Slice.Control.Event.Module.Channel.ReviewableAttribute
+                {
+                    /// <summary>
+                    /// Initialize an instance of this class.
+                    /// </summary>
+                    /// 
+                    /// <param name="channel">
+                    /// The <see cref="Event.Module.Channel"/> to which this attribute is attached.
+                    /// </param>
+                    /// 
+                    public ReviewableDescriptionAttribute(Event.Module.Channel channel)
+                        : base("Description", delegate { return channel.ChannelDescriptionString; })
+                    {
+                    }
+                }
+            }   // *** end Channel ***
+        }   // *** end Module ***
+    }   // *** end Event ***
+}
+

Common/DTS.Common.Serialization/Control/Event/Module/AnalogInputChannel/ReviewableFilterFrequencyAttribute.cs

@@ -0,0 +1,49 @@
+/*
+ * DTS.Slice.Control.Event.Module.AnalogInputChannel.ReviewableFilterFrequencyAttribute.cs
+ * 
+ * Copyright © 2009
+ * Diversified Technical Systems, Inc.
+ * All Rights Reserved
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using DTS.Utilities;
+
+namespace DTS.Slice.Control
+{
+    // *** see DTS.Slice.Control.Event.cs ***
+    public partial class Event              {
+        
+    // *** see DTS.Slice.Control.Event.Module.cs ***
+    public partial class Module             {
+            
+    // *** see DTS.Slice.Control.Event.Module.AnalogInputChannel.cs ***
+    public partial class AnalogInputChannel {
+                
+        /// <summary>
+        /// A reviewable filter frequency attribute attached to a specific channel.
+        /// </summary>
+        public class ReviewableFilterFrequencyAttribute
+            : Slice.Control.Event.Module.Channel.ReviewableAttribute
+        {
+            /// <summary>
+            /// Initialize an instance of this class.
+            /// </summary>
+            /// 
+            /// <param name="channel">
+            /// The <see cref="Event.Module.Channel"/> to which this attribute is attached.
+            /// </param>
+            /// 
+            public ReviewableFilterFrequencyAttribute( Event.Module.Channel channel )
+                : base( "Filter Frequency", delegate { return ( ( int )( channel.CurrentFilter as SaeJ211Filter ).CutoffFrequencyHz ).ToString("N"); } ) 
+            {
+            }
+        }
+    }   // *** end Channel ***
+    }   // *** end Module ***
+    }   // *** end Event ***
+}
+

Common/DTS.Common.Serialization/Control/Event/Module/AnalogInputChannel/ReviewableIsoCodeAttribute.cs

@@ -0,0 +1,50 @@
+/*
+ * DTS.Slice.Control.Event.Module.AnalogInputChannel.ReviewableIsoCodeAttribute.cs
+ * 
+ * Copyright © 2009
+ * Diversified Technical Systems, Inc.
+ * All Rights Reserved
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace DTS.Slice.Control
+{
+    // *** see DTS.Slice.Control.Event.cs ***
+    public partial class Event
+    {
+
+        // *** see DTS.Slice.Control.Event.Module.cs ***
+        public partial class Module
+        {
+
+            // *** see DTS.Slice.Control.Event.Module.AnalogInputChannel.cs ***
+            public partial class AnalogInputChannel
+            {
+
+                /// <summary>
+                /// A reviewable serial number attribute attached to a specific channel.
+                /// </summary>
+                public class ReviewableIsoCodeAttribute
+                    : Slice.Control.Event.Module.Channel.ReviewableAttribute
+                {
+                    /// <summary>
+                    /// Initialize an instance of this class.
+                    /// </summary>
+                    /// 
+                    /// <param name="channel">
+                    /// The <see cref="Event.Module.Channel"/> to which this attribute is attached.
+                    /// </param>
+                    /// 
+                    public ReviewableIsoCodeAttribute(Event.Module.Channel channel)
+                        : base("ISO Code", delegate { return (channel as AnalogInputChannel).IsoCode.ToString(); })
+                    {
+                    }
+                }
+            }   // *** end Channel ***
+        }   // *** end Module ***
+    }   // *** end Event ***
+}

Common/DTS.Common.Serialization/Control/Event/Module/AnalogInputChannel/ReviewableMeasuredShuntDeflectionAttribute.cs

@@ -0,0 +1,70 @@
+/*
+ * DTS.Slice.Control.Event.Module.AnalogInputChannel.ReviewableMeasuredShuntDeflectionAttribute.cs
+ * 
+ * Copyright © 2009
+ * Diversified Technical Systems, Inc.
+ * All Rights Reserved
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace DTS.Slice.Control
+{
+    // *** see DTS.Slice.Control.Event.cs ***
+    public partial class Event
+    {
+
+        // *** see DTS.Slice.Control.Event.Module.cs ***
+        public partial class Module
+        {
+
+            // *** see DTS.Slice.Control.Event.Module.AnalogInputChannel.cs ***
+            public partial class AnalogInputChannel
+            {
+
+                /// <summary>
+                /// A reviewable measured shunt deflection attribute attached to a specific channel.
+                /// </summary>
+                public class ReviewableMeasuredShuntDeflectionAttribute
+                    : Slice.Control.Event.Module.Channel.ReviewableAttribute
+                {
+                    /// <summary>
+                    /// Initialize an instance of this class.
+                    /// </summary>
+                    /// 
+                    /// <param name="channel">
+                    /// The <see cref="Event.Module.Channel"/> to which this attribute is attached.
+                    /// </param>
+                    /// 
+                    public ReviewableMeasuredShuntDeflectionAttribute(Event.Module.Channel channel)
+                        : base("Measured Shunt Deflection (mV)", delegate { return (channel as DTS.DAS.Concepts.DAS.Channel.IShuntAware).MeasuredShuntDeflectionMv.ToString("F1"); })
+                    {
+                    }
+                }
+
+                /// <summary>
+                /// A reviewable measured shunt deflection attribute attached to a specific channel.
+                /// </summary>
+                public class ReviewableMeasuredCalSignalAttribute
+                    : Slice.Control.Event.Module.Channel.ReviewableAttribute
+                {
+                    /// <summary>
+                    /// Initialize an instance of this class.
+                    /// </summary>
+                    /// 
+                    /// <param name="channel">
+                    /// The <see cref="Event.Module.Channel"/> to which this attribute is attached.
+                    /// </param>
+                    /// 
+                    public ReviewableMeasuredCalSignalAttribute(Event.Module.Channel channel)
+                        : base("Measured Calibration Signal (mV)", delegate { return (channel as DTS.DAS.Concepts.DAS.Channel.ICalSignalAware).MeasuredCalSignalMv.ToString("F1"); })
+                    {
+                    }
+                }
+            }   // *** end Channel ***
+        }   // *** end Module ***
+    }   // *** end Event ***
+}

Common/DTS.Common.Serialization/Control/Event/Module/AnalogInputChannel/ReviewableMinMaxEuAttribute.cs

@@ -0,0 +1,52 @@
+/*
+ * DTS.Slice.Control.Event.Module.AnalogInputChannel.ReviewableMinMaxEuAttribute.cs
+ * 
+ * Copyright © 2009
+ * Diversified Technical Systems, Inc.
+ * All Rights Reserved
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using DTS.Utilities;
+
+namespace DTS.Slice.Control
+{
+    // *** see DTS.Slice.Control.Event.cs ***
+    public partial class Event
+    {
+
+        // *** see DTS.Slice.Control.Event.Module.cs ***
+        public partial class Module
+        {
+
+            // *** see DTS.Slice.Control.Event.Module.AnalogInputChannel.cs ***
+            public partial class AnalogInputChannel
+            {
+
+                /// <summary>
+                /// A reviewable min/max EU attribute attached to a specific channel.
+                /// </summary>
+                public class ReviewableMinMaxEuAttribute
+                    : Slice.Control.Event.Module.Channel.ReviewableAttribute
+                {
+                    /// <summary>
+                    /// Initialize an instance of this class.
+                    /// </summary>
+                    /// 
+                    /// <param name="channel">
+                    /// The <see cref="Event.Module.Channel"/> to which this attribute is attached.
+                    /// </param>
+                    /// 
+                    public ReviewableMinMaxEuAttribute(Event.Module.Channel channel)
+                        : base("Max/Min (EU)", delegate { return channel.DataMaxFilteredEu.ToString("F1") + "/" + channel.DataMinFilteredEu.ToString("F1"); })
+                    {
+                    }
+                }
+            }   // *** end Channel ***
+        }   // *** end Module ***
+    }   // *** end Event ***
+}
+

Common/DTS.Common.Serialization/Control/Event/Module/AnalogInputChannel/ReviewableSerialNumberAttribute.cs

@@ -0,0 +1,50 @@
+/*
+ * DTS.Slice.Control.Event.Module.AnalogInputChannel.ReviewableSerialNumberAttribute.cs
+ * 
+ * Copyright © 2009
+ * Diversified Technical Systems, Inc.
+ * All Rights Reserved
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace DTS.Slice.Control
+{
+    // *** see DTS.Slice.Control.Event.cs ***
+    public partial class Event
+    {
+
+        // *** see DTS.Slice.Control.Event.Module.cs ***
+        public partial class Module
+        {
+
+            // *** see DTS.Slice.Control.Event.Module.AnalogInputChannel.cs ***
+            public partial class AnalogInputChannel
+            {
+
+                /// <summary>
+                /// A reviewable serial number attribute attached to a specific channel.
+                /// </summary>
+                public class ReviewableSerialNumberAttribute
+                    : Slice.Control.Event.Module.Channel.ReviewableAttribute
+                {
+                    /// <summary>
+                    /// Initialize an instance of this class.
+                    /// </summary>
+                    /// 
+                    /// <param name="channel">
+                    /// The <see cref="Event.Module.Channel"/> to which this attribute is attached.
+                    /// </param>
+                    /// 
+                    public ReviewableSerialNumberAttribute(Event.Module.Channel channel)
+                        : base("Serial Number", delegate { return (channel as AnalogInputChannel).SerialNumber.ToString(); })
+                    {
+                    }
+                }
+            }   // *** end Channel ***
+        }   // *** end Module ***
+    }   // *** end Event ***
+}

Common/DTS.Common.Serialization/Control/Event/Module/AnalogInputChannel/ReviewableShuntDeflectionAttribute.cs

@@ -0,0 +1,47 @@
+/*
+ * DTS.Slice.Control.Event.Module.AnalogInputChannel.ReviewableShuntDeflectionAttribute.cs
+ * 
+ * Copyright © 2009
+ * Diversified Technical Systems, Inc.
+ * All Rights Reserved
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace DTS.Slice.Control
+{
+    // *** see DTS.Slice.Control.Event.cs ***
+    public partial class Event              {
+        
+    // *** see DTS.Slice.Control.Event.Module.cs ***
+    public partial class Module             {
+            
+    // *** see DTS.Slice.Control.Event.Module.AnalogInputChannel.cs ***
+    public partial class AnalogInputChannel {
+                
+        /// <summary>
+        /// A reviewable shunt deflection attribute attached to a specific channel.
+        /// </summary>
+        public class ReviewableShuntDeflectionAttribute
+            : Slice.Control.Event.Module.Channel.ReviewableAttribute
+        {
+            /// <summary>
+            /// Initialize an instance of this class.
+            /// </summary>
+            /// 
+            /// <param name="channel">
+            /// The <see cref="Event.Module.Channel"/> to which this attribute is attached.
+            /// </param>
+            /// 
+            public ReviewableShuntDeflectionAttribute( Event.Module.Channel channel )
+                : base( "Shunt Deflection (mV)", delegate { return ( channel as DTS.DAS.Concepts.DAS.Channel.IShuntAware ).MeasuredShuntDeflectionMv.ToString( "F1" ); } )
+            {
+            }
+        }
+    }   // *** end Channel ***
+    }   // *** end Module ***
+    }   // *** end Event ***
+}

Common/DTS.Common.Serialization/Control/Event/Module/AnalogInputChannel/ReviewableShuntDeflectionPercentageAttribute.cs

@@ -0,0 +1,69 @@
+/*
+ * DTS.Slice.Control.Event.Module.AnalogInputChannel.ReviewableShuntDeflectionPercentageAttribute.cs
+ * 
+ * Copyright © 2009
+ * Diversified Technical Systems, Inc.
+ * All Rights Reserved
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace DTS.Slice.Control
+{
+    // *** see DTS.Slice.Control.Event.cs ***
+    public partial class Event
+    {
+
+        // *** see DTS.Slice.Control.Event.Module.cs ***
+        public partial class Module
+        {
+
+            // *** see DTS.Slice.Control.Event.Module.AnalogInputChannel.cs ***
+            public partial class AnalogInputChannel
+            {
+
+                /// <summary>
+                /// A reviewable shunt deflection attribute attached to a specific channel.
+                /// </summary>
+                public class ReviewableShuntDeflectionPercentageAttribute
+                    : Slice.Control.Event.Module.Channel.ReviewableAttribute
+                {
+                    /// <summary>
+                    /// Initialize an instance of this class.
+                    /// </summary>
+                    /// 
+                    /// <param name="channel">
+                    /// The <see cref="Event.Module.Channel"/> to which this attribute is attached.
+                    /// </param>
+                    /// 
+                    public ReviewableShuntDeflectionPercentageAttribute(Event.Module.Channel channel)
+                        : base("Shunt Error (%)", delegate { return (100.0 * ((channel as DTS.DAS.Concepts.DAS.Channel.IShuntAware).MeasuredShuntDeflectionMv - (channel as DTS.DAS.Concepts.DAS.Channel.IShuntAware).TargetShuntDeflectionMv) / (channel as DTS.DAS.Concepts.DAS.Channel.IShuntAware).TargetShuntDeflectionMv).ToString("F1"); })
+                    {
+                    }
+                }
+                /// <summary>
+                /// A reviewable shunt deflection attribute attached to a specific channel.
+                /// </summary>
+                public class ReviewableCalSignalPercentageAttribute
+                    : Slice.Control.Event.Module.Channel.ReviewableAttribute
+                {
+                    /// <summary>
+                    /// Initialize an instance of this class.
+                    /// </summary>
+                    /// 
+                    /// <param name="channel">
+                    /// The <see cref="Event.Module.Channel"/> to which this attribute is attached.
+                    /// </param>
+                    /// 
+                    public ReviewableCalSignalPercentageAttribute(Event.Module.Channel channel)
+                        : base("Calibration Signal Error (%)", delegate { return (100.0 * ((channel as DTS.DAS.Concepts.DAS.Channel.ICalSignalAware).MeasuredCalSignalMv - (channel as DTS.DAS.Concepts.DAS.Channel.ICalSignalAware).TargetCalSignalMv) / (channel as DTS.DAS.Concepts.DAS.Channel.ICalSignalAware).TargetCalSignalMv).ToString("F1"); })
+                    {
+                    }
+                }
+            }   // *** end Channel ***
+        }   // *** end Module ***
+    }   // *** end Event ***
+}

Common/DTS.Common.Serialization/Control/Event/Module/AnalogInputChannel/ReviewableTargetShuntDeflectionAttribute.cs

@@ -0,0 +1,69 @@
+/*
+ * DTS.Slice.Control.Event.Module.AnalogInputChannel.ReviewableTargetShuntDeflectionAttribute.cs
+ * 
+ * Copyright © 2009
+ * Diversified Technical Systems, Inc.
+ * All Rights Reserved
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace DTS.Slice.Control
+{
+    // *** see DTS.Slice.Control.Event.cs ***
+    public partial class Event
+    {
+
+        // *** see DTS.Slice.Control.Event.Module.cs ***
+        public partial class Module
+        {
+
+            // *** see DTS.Slice.Control.Event.Module.AnalogInputChannel.cs ***
+            public partial class AnalogInputChannel
+            {
+
+                /// <summary>
+                /// A reviewable target shunt deflection attribute attached to a specific channel.
+                /// </summary>
+                public class ReviewableTargetShuntDeflectionAttribute
+                    : Slice.Control.Event.Module.Channel.ReviewableAttribute
+                {
+                    /// <summary>
+                    /// Initialize an instance of this class.
+                    /// </summary>
+                    /// 
+                    /// <param name="channel">
+                    /// The <see cref="Event.Module.Channel"/> to which this attribute is attached.
+                    /// </param>
+                    /// 
+                    public ReviewableTargetShuntDeflectionAttribute(Event.Module.Channel channel)
+                        : base("Target Shunt Deflection (mV)", delegate { return (channel as DTS.DAS.Concepts.DAS.Channel.IShuntAware).TargetShuntDeflectionMv.ToString("F1"); })
+                    {
+                    }
+                }
+                /// <summary>
+                /// A reviewable target shunt deflection attribute attached to a specific channel.
+                /// </summary>
+                public class ReviewableTargetCalSignalAttribute
+                    : Slice.Control.Event.Module.Channel.ReviewableAttribute
+                {
+                    /// <summary>
+                    /// Initialize an instance of this class.
+                    /// </summary>
+                    /// 
+                    /// <param name="channel">
+                    /// The <see cref="Event.Module.Channel"/> to which this attribute is attached.
+                    /// </param>
+                    /// 
+                    public ReviewableTargetCalSignalAttribute(Event.Module.Channel channel)
+                        : base("Target Calibration Signal (mV)", delegate { return (channel as DTS.DAS.Concepts.DAS.Channel.ICalSignalAware).TargetCalSignalMv.ToString("F1"); })
+                    {
+                    }
+                }
+            }   // *** end Channel ***
+        }   // *** end Module ***
+    }   // *** end Event ***
+}

Common/DTS.Common.Serialization/Control/Event/Module/AnalogInputChannel/ReviewableUnitsAttribute.cs

@@ -0,0 +1,51 @@
+/*
+ * DTS.Slice.Control.Event.Module.AnalogInputChannel.ReviewableUnitsAttribute.cs
+ * 
+ * Copyright © 2009
+ * Diversified Technical Systems, Inc.
+ * All Rights Reserved
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace DTS.Slice.Control
+{
+    // *** see DTS.Slice.Control.Event.cs ***
+    public partial class Event
+    {
+
+        // *** see DTS.Slice.Control.Event.Module.cs ***
+        public partial class Module
+        {
+
+            // *** see DTS.Slice.Control.Event.Module.AnalogInputChannel.cs ***
+            public partial class AnalogInputChannel
+            {
+
+                /// <summary>
+                /// A reviewable engineering units attribute attached to a specific channel.
+                /// </summary>
+                public class ReviewableUnitsAttribute
+                    : Slice.Control.Event.Module.Channel.ReviewableAttribute
+                {
+                    /// <summary>
+                    /// Initialize an instance of this class.
+                    /// </summary>
+                    /// 
+                    /// <param name="channel">
+                    /// The <see cref="Event.Module.Channel"/> to which this attribute is attached.
+                    /// </param>
+                    /// 
+                    public ReviewableUnitsAttribute(Event.Module.Channel channel)
+                        : base("Units", delegate { return (channel as DTS.DAS.Concepts.DAS.Channel.IEngineeringUnitAware).EngineeringUnits.ToString(); })
+                    {
+                    }
+                }
+            }   // *** end Channel ***
+        }   // *** end Module ***
+    }   // *** end Event ***
+}
+

Common/DTS.Common.Serialization/Control/Event/Module/Channel/CalculatedChannel.cs

@@ -0,0 +1,414 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using DTS.Common.Utilities;
+
+namespace DTS.Slice.Control
+{
+    // *** see DTS.Slice.Control.Event.cs ***
+    public partial class Event
+    {
+        // *** see DTS.Slice.Control.Event.Module.cs ***
+        public partial class Module
+        {
+            public partial class Channel
+            {
+                public abstract class CalculatedChannel : Channel, Common.DAS.Concepts.DAS.Channel.IEngineeringUnitAware
+                {
+                    public enum Operation
+                    {
+                        Integral,
+                        //DefiniteIntegral,
+                        Derivative,
+                        HeadInjuryCriteria,
+                        FFT, 
+                        ImportedCSV,
+                        Resultant,
+                        TSR,
+                        Scale,
+                        Offset,
+                        Sine,
+                        Cosine,
+                    }
+                    private readonly Operation _operation;
+                    public Operation CalculationType => _operation;
+
+                    private readonly List<double> _x = new List<double>();
+                    public double[] X => _x.ToArray();
+
+                    private readonly List<double> _y = new List<double>();
+                    public double[] Y => _y.ToArray();
+
+                    private readonly XUnits _xAxis;
+                    public XUnits XAxis => _xAxis;
+
+                    public string XUnitsString
+                    {
+                        get
+                        {
+                            switch (_xAxis)
+                            {
+                                case XUnits.Hz: return "Hz";
+                                case XUnits.msec: return "ms";
+                                case XUnits.samples: return "samples";
+                                case XUnits.sec: return "s";
+                                default: return "N/A";
+                            }
+                        }
+                    }
+                    private string _yAxis;
+                    public string EngineeringUnits { get => _yAxis;
+                        set => _yAxis = value;
+                    }
+
+
+                    public override bool SupportsADC => false;
+                    public override bool SupportsEU => true;
+                    public override bool SupportsmV => false;
+
+
+                    public override double ActualMaxRangeEu => _y.Max();
+
+                    public override double ActualMaxRangeMv => throw new NotSupportedException();
+
+                    public override double ActualMinRangeEu => _y.Min();
+
+                    public override double ActualMinRangeMv => throw new NotImplementedException();
+
+                    public override double DataHalfRangeValueEu => .5D * (_y.Min() + _y.Max());
+                    public override double DataMaxEu => _y.Max();
+                    public override double DataMinEu => _y.Min();
+                    public override double DataRangeEu => (Math.Max(Math.Abs(_y.Min()), Math.Abs(_y.Max())));
+                    public override short DataZeroLevelAdc => 0;
+
+                    public override bool IsConfigured
+                    {
+                        get => true;
+                        set => throw new NotSupportedException();
+                    }
+                    public override void FromDtsSerializationTestModuleChannel(Serialization.Test.Module.Channel that)
+                    {
+                        throw new NotSupportedException();
+                    }
+                    public override List<double> GetUnfilteredDataEu()
+                    {
+                        return new List<double>(_y);
+                    }
+                    /*
+                    protected override void InitializeReviewableAttributes(List<ReviewableAttribute> reviewableAttributes)
+                    {
+                        switch (CalculationType)
+                        {
+                            case Operation.HeadInjuryCriteria:
+                                break;
+                            case Operation.ImportedCSV:
+                                break;
+                            case Operation.TSR:
+                                break;
+                        }
+                    } */   
+                    public override void SetPropertyValuesFrom(DASLib.Service.DASChannel dasChannel)
+                    {
+                        throw new NotSupportedException();
+                    }
+                    public override void SetPropertyValuesFrom(DASLib.Service.DiagnosticsResult diagResults)
+                    {
+                        throw new NotSupportedException();
+                    }
+                    public override Serialization.Test.Module.Channel ToDtsSerializationTestModuleChannel(Serialization.Test.Module parentModule)
+                    {
+                        throw new NotSupportedException();
+                    }
+                    public override double SensorCapacityEU => throw new NotImplementedException();
+
+                    public override List<double> GetUnfilteredDataMV()
+                    {
+                        throw new NotImplementedException();
+                    }
+                    public override double DesiredRangeEU => throw new NotImplementedException();
+
+                    public enum XUnits
+                    {
+                        msec,
+                        sec,
+                        Hz,
+                        samples
+                    }
+                    public CalculatedChannel(string name, 
+                        XUnits xAxis, 
+                        string yAxis, 
+                        double[] xValues, 
+                        double[] yValues,
+                        Operation calcType,
+                        int number,
+                        Module parentModule
+                        )
+                    {
+                        _x = new List<double>(xValues);
+                        _y = new List<double>(yValues);
+                        _xAxis = xAxis;
+                        _yAxis = yAxis;
+                        ChannelDescriptionString = name;
+                        _operation = calcType;
+                        Number = number;
+                        CurrentFilter = new DefaultSaeJ211Filter(ChannelFilter.Unfiltered);
+                        ParentModule = parentModule;
+                        _UnfilteredDataEu = new List<double>(yValues);
+                        DataCount = yValues.Length;
+                    }
+                    /// <summary>
+                    /// Generate a <see cref="string"/> representation for this object.
+                    /// </summary>
+                    /// 
+                    /// <returns>
+                    /// The <see cref="string"/> representation of this object.
+                    /// </returns>
+                    /// 
+                    public override string ToString()
+                    {
+                        try
+                        {
+                            return !string.IsNullOrEmpty(ChannelDescriptionString) ? ChannelDescriptionString : "N/A";
+                        }
+
+                        catch (System.Exception ex)
+                        {
+                            throw new Exception("encountered problem getting string representation", ex);
+                        }
+                    }
+                }
+                public class FFTCalculatedChannel : CalculatedChannel
+                {
+                    private readonly double _peakFrequency;
+                    public double PeakFrequency => _peakFrequency;
+
+                    public FFTCalculatedChannel(string name,
+                        XUnits xAxis,
+                        string yAxis,
+                        double[] xValues,
+                        double[] yValues,
+                        Operation calcType,
+                        int number,
+                        Module parentModule,
+                        double peakFrequency)
+                        : base(name, xAxis, yAxis, xValues, yValues, calcType, number, parentModule)
+                    {
+                        _peakFrequency = peakFrequency;
+                    }
+                    /*
+                    protected override void InitializeReviewableAttributes(List<ReviewableAttribute> reviewableAttributes)
+                    {
+                        base.InitializeReviewableAttributes(reviewableAttributes);
+
+                        //try { reviewableAttributes.Add(new ReviewablePeakFrequencyAttribute(this)); }
+                        //catch { }
+                    }
+                    public class ReviewablePeakFrequencyAttribute : Slice.Control.Event.Module.Channel.ReviewableAttribute
+                    {
+                        public ReviewablePeakFrequencyAttribute(Event.Module.Channel channel)
+                            : base("Peak (Hz)",
+                                delegate { return (channel as FFTCalculatedChannel).PeakFrequency.ToString("N"); }) { }
+                    }*/
+                }
+                public class IntegralCalculatedChannel : CalculatedChannel
+                {
+                    public IntegralCalculatedChannel(string name,
+                       XUnits xAxis,
+                        string yAxis,
+                        double[] xValues,
+                        double[] yValues,
+                        Operation calcType,
+                        int number,
+                        Module parentModule
+                        )
+                        : base(name, xAxis, yAxis, xValues, yValues, calcType, number, parentModule)
+                    { }
+                }
+                public class DerivativeCalculatedChannel : CalculatedChannel
+                {
+                    public DerivativeCalculatedChannel(string name,
+                       XUnits xAxis,
+                        string yAxis,
+                        double[] xValues,
+                        double[] yValues,
+                        Operation calcType,
+                        int number,
+                        Module parentModule
+                        )
+                        : base(name, xAxis, yAxis, xValues, yValues, calcType, number, parentModule)
+                    { }
+                }
+                public class ScaleCalculatedChannel : CalculatedChannel
+                {
+                    public ScaleCalculatedChannel(string name,
+                        XUnits xAxis,
+                        string yAxis,
+                        double[] xValues,
+                        double[] yValues,
+                        Operation calcType,
+                        int number,
+                        Module parentModule)
+                        : base(name, xAxis, yAxis, xValues, yValues, calcType, number, parentModule)
+                    { }
+                }
+                public class OffsetCalculatedChannel : CalculatedChannel
+                {
+                    public OffsetCalculatedChannel(string name,
+                        XUnits xAxis,
+                        string yAxis,
+                        double[] xValues,
+                        double[] yVAlues,
+                        Operation calcType,
+                        int number,
+                        Module parentModule)
+                        : base(name, xAxis, yAxis, xValues, yVAlues, calcType, number, parentModule)
+                    { }
+                }
+                public class ResultantCalculatedChannel : CalculatedChannel
+                {
+                    public ResultantCalculatedChannel(string name,
+                        XUnits xAxis,
+                        string yAxis,
+                        double[] xValues,
+                        double[] yValues,
+                        Operation calcType,
+                        int number,
+                        Module parentModule)
+                        : base(name, xAxis, yAxis, xValues, yValues, calcType, number, parentModule)
+                    { }
+                }
+                public class AdditiveVectorCalculatedChannel : CalculatedChannel
+                {
+                    public AdditiveVectorCalculatedChannel(string name,
+                        XUnits xAxis,
+                        string yAxis,
+                        double[] xValues,
+                        double[] yValues,
+                        Operation calcType,
+                        int number,
+                        Module parentModule)
+                        : base(name, xAxis, yAxis, xValues, yValues, calcType, number, parentModule)
+                    { }
+                }
+                public class SineCalculatedChannel : CalculatedChannel
+                {
+                    public SineCalculatedChannel(string name,
+                       XUnits xAxis,
+                        string yAxis,
+                        double[] xValues,
+                        double[] yValues,
+                        Operation calcType,
+                        int number,
+                        Module parentModule
+                        )
+                        : base(name, xAxis, yAxis, xValues, yValues, calcType, number, parentModule)
+                    { }
+                }
+                public class CosineCalculatedChannel : CalculatedChannel
+                {
+                    public CosineCalculatedChannel(string name,
+                       XUnits xAxis,
+                        string yAxis,
+                        double[] xValues,
+                        double[] yValues,
+                        Operation calcType,
+                        int number,
+                        Module parentModule
+                        )
+                        : base(name, xAxis, yAxis, xValues, yValues, calcType, number, parentModule)
+                    { }
+                }
+    
+                                  /*
+  public class HICCalculatedChannel : CalculatedChannel
+                {
+                    public double GetT1(bool ms)
+                    {
+                        double start = (double)HIC.StartSample - (double)ParentModule.TriggerSampleNumbers[0] +
+                                    (double)ParentModule.StartRecordSampleNumber;
+
+                        start /= (double)ParentModule.SampleRateHz;
+                        if (ms) { start *= 1000; }
+                        return start;
+                    }
+
+                    public double GetT2(bool ms)
+                    {
+                        double end = (double)HIC.EndSample - (double)ParentModule.TriggerSampleNumbers[0]
+                            + (double)ParentModule.StartRecordSampleNumber;
+                        end /= (double)ParentModule.SampleRateHz;
+                        if (ms) { end *= 1000; }
+                        return end;
+                    }
+
+                      public HICCalculatedChannel(string name,
+                         XUnits xAxis,
+                         string yAxis,
+                         double[] xValues,
+                         double[] yValues,
+                         Operation calcType,
+                         int number,
+                         Module parentModule,
+                         DTS.Calculations.HeadInjuryCriterion.HICResult hic
+                         )
+                         : base(name, xAxis, yAxis, xValues, yValues, calcType, number, parentModule)
+                     {
+                         _hic = hic;
+                     }
+                     private DTS.Calculations.HeadInjuryCriterion.HICResult _hic;
+                     public DTS.Calculations.HeadInjuryCriterion.HICResult HIC { get { return _hic; } }
+
+                     protected override void InitializeReviewableAttributes(List<ReviewableAttribute> reviewableAttributes)
+                     {
+                         base.InitializeReviewableAttributes(reviewableAttributes);
+
+                         try { reviewableAttributes.Add(new ReviewableHICAttribute(this)); }
+                         catch {}
+                         try { reviewableAttributes.Add(new ReviewableHICLengthAttribute(this)); }
+                         catch { }
+                         try { reviewableAttributes.Add(new ReviewableHICT1T2Attribute(this)); }
+                         catch { }
+                     }
+                     public class ReviewableHICLengthAttribute : Slice.Control.Event.Module.Channel.ReviewableAttribute
+                     {
+                         public ReviewableHICLengthAttribute(Event.Module.Channel channel)
+                             : base("Clip Length",
+                                 delegate { return (channel as HICCalculatedChannel).HIC.HicLengthMS.ToString(); }) { }
+                     }
+                     public class ReviewableHICAttribute
+                     : Slice.Control.Event.Module.Channel.ReviewableAttribute
+                     {
+                         /// <summary>
+                         /// Initialize an instance of this class.
+                         /// </summary>
+                         /// 
+                         /// <param name="channel">
+                         /// The <see cref="Event.Module.Channel"/> to which this attribute is attached.
+                         /// </param>
+                         /// 
+                         public ReviewableHICAttribute(Event.Module.Channel channel)
+                             : base("HIC",
+                             delegate { return (channel as HICCalculatedChannel).HIC.HIC.ToString("N1"); })
+                         {
+                         }
+                     }
+                     public class ReviewableHICT1T2Attribute
+                         : Slice.Control.Event.Module.Channel.ReviewableAttribute
+                     {
+                         public ReviewableHICT1T2Attribute(Event.Module.Channel channel)
+                             : base("T1/T2", 
+                             delegate 
+                             {
+                                 HICCalculatedChannel hic = channel as HICCalculatedChannel;
+                                 if (null == hic) { return ""; }
+                                 else { return string.Format("{0}s/{1}s", hic.GetT1(false), hic.GetT2(false)); }
+                             })
+                         {
+                         }
+                     }
+                }
+                          * */
+            }
+       }
+    }
+}

Common/DTS.Common.Serialization/Control/Event/Module/Channel/ChannelDefaultSaeJ211Filter.cs

@@ -0,0 +1,123 @@
+/*
+ * DTS.Slice.Control.Event.Module.Channel.SaeJ211Filter.cs
+ * 
+ * Copyright © 2009
+ * Diversified Technical Systems, Inc.
+ * All Rights Reserved
+ */
+
+using DTS.Common.Utilities;
+
+namespace DTS.Slice.Control
+{
+    public partial class Event
+    { // *** see DTS.Slice.Control.Event.cs ***
+        public partial class Module
+        { // *** see DTS.Slice.Control.Event.Module.cs ***
+            public partial class Channel
+            { // *** see DTS.Slice.Control.Event.Module.Channel.cs ***
+                /// <summary>
+                /// Base class for all SaeJ211-based event module channel filters.  It is intended
+                /// that fixed-filter-setting filters be derived from this class that will set their
+                /// filter setting using the protected constructor.
+                /// </summary>
+                public class DefaultSaeJ211Filter
+                    : SaeJ211Filter
+                {
+                    public DefaultSaeJ211Filter(SaeJ211Filter filter)
+                        : base(filter)
+                    {
+
+                    }
+                    /// <summary>
+                    /// Initialize an instance of the DefaultSaeJ211Filter class.
+                    /// </summary>
+                    /// 
+                    /// <param name="filter">
+                    /// The <see cref="ChannelFilter"/> to be applied by this filter. 
+                    /// </param>
+                    /// 
+                    public DefaultSaeJ211Filter(ChannelFilter filterType)
+                        : base(filterType)
+                    {
+                    }
+
+                    /// <summary>
+                    /// Initialize an instance of the DefaultSaeJ211Filter class.
+                    /// </summary>
+                    /// 
+                    ///<param name="adHocFrequency">
+                    ///The <see cref="double"/> ad hoc frequency of this filter.
+                    /// </param>
+                    ///
+                    public DefaultSaeJ211Filter(double adHocFrequency)
+                        : base(adHocFrequency)
+                    {
+                    }
+
+                    /// <summary>
+                    /// The <see cref="string"/> name of this filter.
+                    /// </summary>
+                    public override string Name
+                    {
+                        get
+                        {
+                            try
+                            {
+                                return "Default (" + base.Name + ")";
+                            }
+
+                            catch (System.Exception ex)
+                            {
+                                throw new Exception("encountered problem generating name string for " + GetType().FullName, ex);
+                            }
+                        }
+                    }
+
+                    /// <summary>
+                    /// Generate a string representation of this object.
+                    /// </summary>
+                    /// 
+                    /// <returns>
+                    /// A <see cref="string"/> representation of this object.
+                    /// </returns>
+                    /// 
+                    public override string ToBaseString()
+                    {
+                        try
+                        {
+                            return base.Name;
+                        }
+
+                        catch (System.Exception ex)
+                        {
+                            throw new Exception("encountered problem generating the string value for " + GetType().FullName, ex);
+                        }
+                    }
+
+                    /// <summary>
+                    /// Generate a string representation of this object.
+                    /// </summary>
+                    /// 
+                    /// <returns>
+                    /// A <see cref="string"/> representation of this object.
+                    /// </returns>
+                    /// 
+                    public override string ToString()
+                    {
+                        try
+                        {
+                            return Name;
+                        }
+
+                        catch (System.Exception ex)
+                        {
+                            throw new Exception("encountered problem generating the string value for " + GetType().FullName, ex);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+}

Common/DTS.Common.Serialization/Control/Event/Module/Channel/DataValues.cs

@@ -0,0 +1,81 @@
+/*
+ * DTS.Slice.Control.Event.Module.Channel.DataValues.cs
+ * 
+ * Copyright © 2009
+ * Diversified Technical Systems, Inc.
+ * All Rights Reserved
+ */
+
+using DTS.Common.Utilities;
+using DTS.Common.Utilities.DotNetProgrammingConstructs;
+
+namespace DTS.Slice.Control
+{
+    // *** see DTS.Slice.Control.Event.cs ***
+    public partial class Event   {
+        
+    // *** see DTS.Slice.Control.Event.Module.cs ***
+    public partial class Module  {
+            
+    // *** see DTS.Slice.Control.Event.Module.Channel.cs ***
+    public partial class Channel {
+
+        /// <summary>
+        /// Representation of a channel's data.
+        /// </summary>
+        public class DataValues : Exceptional
+        {
+            /// <summary>
+            /// Initialize an instance of this class.
+            /// </summary>
+            public DataValues( )
+                : this( true )
+            {
+            }
+
+            /// <summary>
+            /// Initialize an instance of this class.
+            /// </summary>
+            /// 
+            /// <param name="useMemoryMappedFile">
+            /// A <see cref="bool"/> determining whether or not this data class will use memory mapped files
+            /// to store data (necessary for data sets that exceed internal process memory limitations). 
+            /// </param>
+            /// 
+            public DataValues( bool useMemoryMappedFile )
+            {
+                try
+                {
+                    UseMemoryMappedFile = useMemoryMappedFile;
+
+                    if ( UseMemoryMappedFile )
+                    {
+                    }
+                }
+
+                catch ( System.Exception ex )
+                {
+                    throw new Exception( "encountered problem constructing " + GetType( ).FullName, ex );
+                }
+            }
+
+            /// <summary>
+            /// Get/set the switch that will cause this class to use memory mapped files in lieu
+            /// of in-memory list.
+            /// </summary>
+            public bool UseMemoryMappedFile
+            {
+                get => _UseMemoryMappedFile.Value;
+                set => _UseMemoryMappedFile.Value = value;
+            }
+            private readonly Property<bool> _UseMemoryMappedFile =
+                new Property<bool>(
+                    typeof( DataValues ).Namespace + ".UseMemoryMappedFile",
+                    false,
+                    false
+                );
+        }
+    } // *** End Event.Module.Channel ***
+    } // *** End Event.Module ***
+    } // *** End Event ***
+}

Common/DTS.Common.Serialization/Control/Event/Module/Channel/Filter.cs

@@ -0,0 +1,99 @@
+/*
+ * DTS.Slice.Control.Event.Module.Channel.cs
+ * 
+ * Copyright © 2009
+ * Diversified Technical Systems, Inc.
+ * All Rights Reserved
+ */
+
+using System;
+using DTS.Common.Utilities;
+using DTS.Slice.Control.DAS.Channel;
+
+namespace DTS.Slice.Control
+{
+    public partial class Event
+    { // *** see DTS.Slice.Control.Event.cs ***
+        public partial class Module
+        { // *** see DTS.Slice.Control.Event.Module.cs ***
+            public partial class Channel
+            { // *** see DTS.Slice.Control.Event.Module.Channel.cs ***
+                /// <summary>
+                /// A filter for DTS.Slice.Control.Event.Module.Channels.
+                /// </summary>
+                public abstract class Filter
+                    : Exceptional,
+                      IFilter
+                {
+                    /// <summary>
+                    /// A descriptive <see cref="string"/> designation for the filter.
+                    /// </summary>
+                    public abstract string Name
+                    {
+                        get;
+                    }
+
+                    /// <summary>
+                    /// Get the <see cref="Boolean"/> value indicating whether or not this filter
+                    /// corresponds to a CFC value.
+                    /// </summary>
+                    public abstract bool IsCfc
+                    {
+                        get;
+                    }
+
+                    /// <summary>
+                    /// Get a <see cref="ChannelFilter"/> designation for this filter.
+                    /// </summary>
+                    public abstract ChannelFilter Type
+                    {
+                        get;
+                    }
+
+                    /// <summary>
+                    /// Get the <see cref="double"/> cutoff frequency for this filter.
+                    /// </summary>
+                    public abstract double CutoffFrequencyHz
+                    {
+                        get;
+                    }
+
+                    ///  <summary>
+                    ///  Apply the filter to the specified input.
+                    ///  </summary>
+                    /// 
+                    ///  <param name="input">
+                    ///  The input to the filter.
+                    ///  </param>
+                    ///  
+                    ///  <param name="displayUnits">
+                    ///  The <see cref="DTS.Slice.Control.Event.Module.Channel.DataDisplayUnits"/> to be 
+                    ///  filtered from the channel.
+                    ///  </param>
+                    /// <param name="bUseLegacyTDCSoftwareFilterAdjustment">
+                    /// controls whether filtered data is adjusted by one sample to match TDC behavior
+                    /// 8747
+                    /// </param>
+                    /// <returns>
+                    ///  The filtering of the input.
+                    ///  </returns>
+                    ///  
+                    public abstract double[] Apply(
+                        Channel input,
+                        DataDisplayUnits displayUnits, 
+                        bool bUseLegacyTDCSoftwareFilterAdjustment);
+                    public abstract double[] Apply(
+                        double[] data,
+                        double sampleRate, 
+                        bool bUseLegacyTDCSoftwareFilterAdjustment);
+                    /// <summary>
+                    /// the ToString is already overloaded, but we sometimes need the base name, not the decorated name that
+                    /// is returned in ToString.
+                    /// </summary>
+                    /// <returns></returns>
+                    public abstract string ToBaseString();
+                }
+            }
+        }
+    }
+}

Common/DTS.Common.Serialization/Control/Event/Module/Channel/ReviewableAttribute.NotApplicableException.cs

@@ -0,0 +1,81 @@
+/*
+ * DTS.Slice.Control.Event.Module.Channel.ReviewableAttribute.NotApplicableException.cs
+ * 
+ * Copyright © 2009
+ * Diversified Technical Systems, Inc.
+ * All Rights Reserved
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace DTS.Slice.Control
+{
+    // *** see DTS.Slice.Control.Event.cs ***
+    public partial class Event
+    {
+
+        // *** see DTS.Slice.Control.Event.Module.cs ***
+        public partial class Module
+        {
+
+            // *** see DTS.Slice.Control.Event.Module.Channel.cs ***
+            public partial class Channel
+            {
+
+                // *** see DTS.Slice.Control.Event.Module.Channel.ReviewableAttribute.cs ***
+                public partial class ReviewableAttribute
+                {
+
+                    /// <summary>
+                    /// Representation of an attempt to use a channel attribute that is not 
+                    /// applicable to the associated channel.
+                    /// </summary>
+                    public class NotApplicableException : ApplicationException
+                    {   ///
+                        /// <summary>
+                        /// Initialize an instance of the NotApplicableException class.
+                        /// </summary>
+                        /// 
+                        public NotApplicableException()
+                        {
+                        }
+
+                        /// <summary>
+                        /// Initialize an instance of the NotApplicableException class.
+                        /// </summary>
+                        /// 
+                        /// <param name="msg">
+                        /// The <see cref="string"/> message to be associated with this exception.
+                        /// </param>
+                        ///
+                        public NotApplicableException(string msg)
+                            : base(msg)
+                        {
+                        }
+
+                        /// <summary>
+                        /// Initialize an instance of the NotApplicableException class.
+                        /// </summary>
+                        /// 
+                        /// <param name="msg">
+                        /// The <see cref="string"/> message to be associated with this exception.
+                        /// </param>
+                        /// 
+                        /// <param name="innerEx">
+                        /// The <see cref="System.Exception"/> responsible for this exception inception.
+                        /// </param>
+                        /// 
+                        public NotApplicableException(string msg, System.Exception innerEx)
+                            : base(msg, innerEx)
+                        {
+                        }
+                    }
+
+                }   // *** end ReviewableAttribute ***
+            }   // *** end Channel ***
+        }   // *** end Module ***
+    }   // *** end Event ***
+}

Common/DTS.Common.Serialization/Control/Event/Module/Channel/SaeJ211Filter.cs

@@ -0,0 +1,515 @@
+/*
+ * DTS.Slice.Control.Event.Module.Channel.SaeJ211Filter.cs
+ * 
+ * Copyright © 2009
+ * Diversified Technical Systems, Inc.
+ * All Rights Reserved
+ */
+
+using System;
+using DTS.Common.DAS.Concepts.DAS.Channel;
+using DTS.Common.Utilities;
+using DTS.Common.Utilities.DotNetProgrammingConstructs;
+using DTS.Common.Utilities.Logging;
+using DTS.Common.Utilities.SaeJ211;
+
+namespace DTS.Slice.Control
+{
+    public partial class Event
+    { // *** see DTS.Slice.Control.Event.cs ***
+        public partial class Module
+        { // *** see DTS.Slice.Control.Event.Module.cs ***
+            public partial class Channel
+            { // *** see DTS.Slice.Control.Event.Module.Channel.cs ***
+                /// <summary>
+                /// Base class for all SaeJ211-based event module channel filters.  It is intended
+                /// that fixed-filter-setting filters be derived from this class that will set their
+                /// filter setting using the protected constructor.
+                /// </summary>
+                public class SaeJ211Filter
+                    : Filter
+                {
+                    public SaeJ211Filter(SaeJ211Filter originalFilter)
+                    {
+                        OriginalType = originalFilter.OriginalType;
+                        _CutoffFrequencyHz.Value = originalFilter.CutoffFrequencyHz;
+                    }
+                    /// <summary>
+                    /// Initialize an instance of the DTS.Utility.SaeJ211Filter class.
+                    /// </summary>
+                    /// 
+                    /// <param name="originalType">
+                    /// The <see cref="ChannelFilter"/> to be applied by this filter (ad hoc
+                    /// filters that correspond to CFC values will be converted to the CFC, hence the
+                    /// "original" qualification). 
+                    /// </param>
+                    /// 
+                    public SaeJ211Filter(ChannelFilter originalType)
+                    {
+                        try
+                        {
+                            switch (OriginalType = originalType)
+                            {   //
+                                // Try to set the frequency value according to type.  Note that we can't set to
+                                // "ad hoc" using this particular constructor as we don't know what frequency
+                                // should be associated with it.
+                                //
+                                case ChannelFilter.AdHoc:
+                                    throw new Exception("cannot initialize SaeJ211 filter using only ChannelFilter of type " + OriginalType.ToString());
+
+                                default:
+                                    _CutoffFrequencyHz.Value = (double)originalType;
+                                    break;
+                            }
+                        }
+
+                        catch (System.Exception ex)
+                        {
+                            throw new Exception("encountered problem constructing " + GetType().FullName, ex);
+                        }
+                    }
+
+                    /// <summary>
+                    /// Initialize an instance of the DTS.Utility.SaeJ211Filter class.
+                    /// </summary>
+                    /// 
+                    ///<param name="adHocFrequency">
+                    ///The <see cref="double"/> ad hoc frequency of this filter.
+                    /// </param>
+                    ///
+                    public SaeJ211Filter(double cutoffFrequencyHz)
+                    {
+                        try
+                        {
+                            OriginalType = ChannelFilter.AdHoc;
+                            _CutoffFrequencyHz.Value = cutoffFrequencyHz;
+                        }
+
+                        catch (System.Exception ex)
+                        {
+                            throw new Exception("encountered problem constructing " + GetType().FullName, ex);
+                        }
+                    }
+
+                    /// <summary>
+                    /// Get <see cref="Boolean"/> value indicating whether or not this filter matches one of the
+                    /// specified CFC values.
+                    /// </summary>
+                    override public bool IsCfc
+                    {
+                        get
+                        {
+                            try
+                            {   //
+                                // If we're not unfiltered and we're not ad hoc, then we
+                                // must be CFC-compliant.
+                                //
+                                return Type != ChannelFilter.Unfiltered
+                                    && Type != ChannelFilter.AdHoc;
+                            }
+
+                            catch (System.Exception ex)
+                            {
+                                throw new Exception("encountered problem determining whether or not filter corresponds to a CFC value", ex);
+                            }
+                        }
+                    }
+
+                    /// <summary>
+                    /// Convert the specified frequency into a ChannelFilter type.
+                    /// </summary>
+                    /// 
+                    /// <param name="frequency">
+                    /// The <see cref="double"/> frequency to be converted.
+                    /// </param>
+                    /// 
+                    /// <returns>
+                    /// The best matching <see cref="ChannelFilter"/> type.  A CFC match is preferred;
+                    /// if one does not exist, "ad hoc" will be selected (if frequency > 0).
+                    /// </returns>
+                    /// 
+                    private ChannelFilter ConvertFrequencyToChannelFilter(double frequency)
+                    {
+                        try
+                        {
+                            var matchingFilterType = ChannelFilter.Unfiltered;
+                            if (frequency > 0)
+                            {
+                                matchingFilterType = ChannelFilter.AdHoc;
+                                var cfcCoder = new CfcValueAttributeCoder();
+                                foreach (int filterValue in Enum.GetValues(typeof(ChannelFilter)))
+                                    if (frequency == filterValue)
+                                        matchingFilterType = (ChannelFilter)filterValue;
+                            }
+                            return matchingFilterType;
+                        }
+                        catch (System.Exception ex)
+                        {
+                            throw new Exception("encountered problem trying to match frequency to CRC value", ex);
+                        }
+                    }
+
+                    /// <summary>
+                    /// Get the "best fitting" <see cref="ChannelFilter"/> value for this filter.
+                    /// </summary>
+                    override public ChannelFilter Type
+                    {
+                        get
+                        {
+                            try
+                            {
+                                var actualType = OriginalType;
+
+                                switch (OriginalType)
+                                {
+                                    case ChannelFilter.AdHoc:
+                                        actualType = ConvertFrequencyToChannelFilter(CutoffFrequencyHz);
+                                        break;
+
+                                    default:
+                                        //
+                                        // Don't waste time on stuff we don't need to convert.
+                                        //
+                                        actualType = OriginalType;
+                                        break;
+                                }
+
+                                return actualType;
+                            }
+
+                            catch (System.Exception ex)
+                            {
+                                throw new Exception("encountered problem determining filter type", ex);
+                            }
+                        }
+                    }
+
+                    public char IsoDescription => new IsoDescriptionAttributeCoder().DecodeAttributeValue(OriginalType)[0];
+
+                    /// <summary>
+                    /// Get the <see cref="double"/> cutoff frequency value.
+                    /// </summary>
+                    override public double CutoffFrequencyHz => _CutoffFrequencyHz.Value;
+
+                    private readonly Property<double> _CutoffFrequencyHz
+                        = new Property<double>(
+                            typeof(SaeJ211Filter).Namespace + ".SaeJ211Filter.CutoffFrequencyHz",
+                            -1,
+                            true
+                        );
+
+                    /// <summary>
+                    /// The <see cref="ChannelFilter"/>ing done by this object.
+                    /// </summary>
+                    public ChannelFilter OriginalType
+                    {
+                        get => _OriginalType.Value;
+                        private set => _OriginalType.Value = value;
+                    }
+                    private readonly Property<ChannelFilter> _OriginalType
+                        = new Property<ChannelFilter>(
+                            typeof(SaeJ211Filter).Namespace + ".SaeJ211Filter.OriginalType",
+                            ChannelFilter.Unfiltered,
+                            false
+                        );
+
+                    private const string CutoffFrequencyUnitString = "Hz";
+
+                    /// <summary>
+                    /// The <see cref="string"/> name of this filter.
+                    /// </summary>
+                    public override string Name
+                    {
+                        get
+                        {
+                            try
+                            {
+                                if (null == _Name)
+                                {
+                                    var cult = new System.Globalization.CultureInfo("");
+                                    _Name = ChannelFilter.AdHoc == Type
+                                            ? CutoffFrequencyHz.ToString(cult) + CutoffFrequencyUnitString
+                                            : new DescriptionAttributeCoder<ChannelFilter>().DecodeAttributeValue(Type);
+                                }
+                                return _Name;
+                            }
+
+                            catch (System.Exception ex)
+                            {
+                                throw new Exception("encountered problem generating name string for " + GetType().FullName, ex);
+                            }
+                        }
+                    }
+                    private string _Name = null;
+
+                    /// <summary>
+                    /// Apply this filter to the specified channel.
+                    /// </summary>
+                    /// 
+                    /// <param name="channel">
+                    /// The <see cref="DTS.Slice.Control.Event.Module.Channel"/> to be filtered.
+                    /// </param>
+                    /// 
+                    /// <returns>
+                    /// The array of filtered <see cref="double"/> EU data.
+                    /// </returns>
+                    /// 
+                    public override double[] Apply
+                        (
+                        Channel channel,
+                        DataDisplayUnits displayUnits,
+                        bool bUseLegacyTDCSoftwareFilterAdjustment
+                        )
+                    {
+                        try
+                        {
+                            var filterUtility = new FilterUtility();
+                            filterUtility.Cfc = Type;
+                            filterUtility.AdHocFrequency = CutoffFrequencyHz;
+                            filterUtility.SampleRate = channel.ParentModule.SampleRateHz;
+
+                            double[] data;
+                            switch (displayUnits)
+                            {
+                                case DataDisplayUnits.Adc:
+                                    if (channel.UnfilteredData is Serialization.SliceRaw.File.PersistentChannel)
+                                    {
+                                        if (channel.UnfilteredData is ILargeDataAware)
+                                            if (!(channel.UnfilteredData as ILargeDataAware).IsDataArraySized)
+                                                throw new Serialization.SliceRaw.File.PersistentChannel.DataTooBigForArrayException("Data is too big to be viewed or filtered.");
+
+                                        using (var persistentUnfilteredData =
+                                            channel.UnfilteredData as Serialization.SliceRaw.File.PersistentChannel)// ;
+                                        {
+
+                                            var dataCount = persistentUnfilteredData.Count;
+                                            data = new double[dataCount];
+                                            for (var i = 0; i < dataCount; i++)
+                                                data[i] = persistentUnfilteredData[(ulong) i];
+                                        }
+                                            //persistentUnfilteredData.Dispose();
+                                    }
+                                    else if (channel.UnfilteredData is Serialization.TDAS.File.PersistentChannel)
+                                    {
+                                        if (channel.UnfilteredData is ILargeDataAware)
+                                            if (!(channel.UnfilteredData as ILargeDataAware).IsDataArraySized)
+                                                throw new Serialization.TDAS.File.PersistentChannel.DataTooBigForArrayException("Data is too big to be viewed or filtered.");
+
+                                        using (var persistentUnfilteredData =
+                                            channel.UnfilteredData as Serialization.TDAS.File.PersistentChannel)// ;
+                                        {
+
+                                            var dataCount = persistentUnfilteredData.Count;
+                                            data = new double[dataCount];
+                                            for (var i = 0; i < dataCount; i++)
+                                                data[i] = persistentUnfilteredData[(ulong)i];
+                                        }
+                                        //persistentUnfilteredData.Dispose();
+                                    }
+
+                                    else data = channel.UnfilteredData.ConvertAll<double>(delegate(short datum) { return (double)datum; }).ToArray();
+                                    break;
+
+                                case DataDisplayUnits.Eu:
+                                    data = channel.UnfilteredDataEu.ToArray();
+                                    break;
+
+                                case DataDisplayUnits.Mv:
+                                    data = channel.UnfilteredDataMv.ToArray();
+                                    break;
+
+                                default:
+                                    throw new NotImplementedException("handling for display unit type \"" + displayUnits.ToString() + "\" has not been implemented");
+                            }
+
+                    return filterUtility.ApplyFilter(data, new FilterUtility.InvalidDataDelegate(delegate()
+                    {
+                        var msg = string.Format("Invalid data in channel: {0}.", channel.ChannelDescriptionString);
+                        //var dr = System.Windows.Forms.MessageBox.Show(msg, "Warning", System.Windows.Forms.MessageBoxButtons.OK);
+                        APILogger.Log(msg);
+                        throw new Exception(msg);
+                    }), bUseLegacyTDCSoftwareFilterAdjustment);
+                }
+
+                catch ( System.Exception ex )
+                {
+                    throw new Exception( "encountered problem applying filter \"" + Name + "\" to channel", ex );
+                }
+            }
+
+                    /// <summary>
+                    /// Apply this filter to the specified channel.
+                    /// </summary>
+                    /// 
+                    /// <param name="channel">
+                    /// The <see cref="DTS.Slice.Control.Event.Module.Channel"/> to be filtered.
+                    /// </param>
+                    /// <param name="bUseLegacyTDCSoftwareFilterAdjustment">
+                    /// controls whether filtered data is adjusted by one sample to match TDC behavior
+                    /// 8747
+                    /// </param>
+                    /// <returns>
+                    /// The array of filtered <see cref="double"/> EU data.
+                    /// </returns>
+                    public override double[] Apply
+                (
+                double [] data,
+                double sampleRate,
+                bool bUseLegacyTDCSoftwareFilterAdjustment
+                )
+            {
+                try
+                {
+                    var filterUtility = new FilterUtility();
+                    filterUtility.Cfc = Type;
+                    filterUtility.AdHocFrequency = CutoffFrequencyHz;
+                    filterUtility.SampleRate = sampleRate;                   
+
+                    return filterUtility.ApplyFilter(data, new FilterUtility.InvalidDataDelegate(delegate()
+                    {
+                        var msg = string.Format("Invalid data in channel.");
+                        //var dr = System.Windows.Forms.MessageBox.Show(msg, "Warning", System.Windows.Forms.MessageBoxButtons.OK);
+                        APILogger.Log(msg);
+                        throw new Exception(msg);
+                    }), bUseLegacyTDCSoftwareFilterAdjustment);
+                }
+
+                catch (System.Exception ex)
+                {
+                    throw new Exception("encountered problem applying filter \"" + Name + "\" to channel", ex);
+                }
+            }
+            /// <summary>
+            /// Generate a string representation of this object.
+            /// </summary>
+            /// 
+            /// <returns>
+            /// A <see cref="string"/> representation of this object.
+            /// </returns>
+            /// 
+            public override string ToString( )
+            {
+                try
+                {
+                    return Name;
+                }
+
+                catch ( System.Exception ex )
+                {
+                    throw new Exception( "encountered problem generating the string value for " + GetType( ).FullName, ex );
+                }
+            }
+
+            /// <summary>
+            /// Generate a string representation of this object.
+            /// </summary>
+            /// 
+            /// <returns>
+            /// A <see cref="string"/> representation of this object.
+            /// </returns>
+            /// 
+            public override string  ToBaseString()
+            {
+                try
+                {
+                    return Name;
+                }
+
+                catch (System.Exception ex)
+                {
+                    throw new Exception("encountered problem generating the string value for " + GetType().FullName, ex);
+                }
+            }
+            /// <summary>
+            /// Determines whether this filter and the specified filter are the same.
+            /// </summary>
+            /// 
+            /// <param name="obj">
+            /// The filter <see cref="object"/> to be compared with this one.
+            /// </param>
+            /// 
+            /// <returns>
+            /// <see cref="bool"/> true if the filters are the same, false otherwise.
+            /// </returns>
+            ///
+            public override bool Equals( object obj )
+            {
+                try
+                {
+                    if (null == obj as SaeJ211Filter) { return false; }
+                    return Name.Equals( ( obj as SaeJ211Filter ).Name, StringComparison.OrdinalIgnoreCase );
+                }
+
+                catch ( System.Exception ex )
+                {
+                    throw new Exception(
+                        "encountered problem equality checking filter \""
+                        + Name
+                        + "\" with filter "
+                        + ( null != obj && obj is SaeJ211Filter && null != ( obj as SaeJ211Filter ).Name ? "\"" + ( obj as SaeJ211Filter ).Name + "\"" : "<null>" ), ex );
+                }
+            }
+            /// <summary>
+            /// provides an index for a given <see cref="DTS.Slice.Control.Event.Module.Channel.SaeJ211Filter"/>
+            /// since we override Equals we should override get hashcode to ensure that any to objects considered
+            /// "Equal" are also hashed to the same location, however the result index does not need to be unique 
+            /// between non equal objects.  
+            /// 6/10/2010 - dtm
+            /// </summary>
+            /// <returns></returns>
+            public override int GetHashCode()
+            {
+                return Name.ToLower().GetHashCode();
+            }
+            /// <summary>
+            /// Create a filter from the specified string.
+            /// </summary>
+            /// 
+            /// <param name="serialization">
+            /// The <see cref="string"/> representation of the filter to be instantiated.
+            /// </param>
+            /// 
+            /// <returns>
+            /// A <see cref="DTS.Slice.Control.Event.Module.Channel.Filter"/> equivalent of the 
+            /// specified string.  Throws an exception if object could not be created.
+            /// </returns>
+            /// 
+            static public Filter Parse( string serialization )
+            {
+                try
+                {
+                    Filter filter = null;
+
+                    if ( !string.IsNullOrEmpty( serialization ) )
+                    {
+                        if ( serialization.Contains( CutoffFrequencyUnitString ) )
+                        {
+                            var cult = new System.Globalization.CultureInfo("");
+                            filter = new DefaultSaeJ211Filter(double.Parse(serialization.Replace(CutoffFrequencyUnitString, ""), cult));
+                        }
+
+                        else
+                        {
+                            foreach ( ChannelFilter filterType in Enum.GetValues( typeof( ChannelFilter ) ) )
+                            {
+                                var coder = new DescriptionAttributeCoder<ChannelFilter>( );
+                                if ( coder.DecodeAttributeValue( filterType ).Equals( serialization, StringComparison.OrdinalIgnoreCase ) )
+                                    filter = new DefaultSaeJ211Filter( filterType );
+                            }
+                        }
+                    }
+
+                    return ( null != filter ? filter : new SaeJ211Filter( ChannelFilter.Unfiltered ) );
+                }
+
+                catch ( System.Exception ex )
+                {
+                    throw new Exception( "encountered problem parsing string " + ( null != serialization ? "\"" + serialization + "\"" : "<NULL>" ) + " into filter", ex );
+                }
+            }
+        }
+    }
+    }
+    }
+
+}

Common/DTS.Common.Serialization/Control/Event/Module/Module.cs

@@ -0,0 +1,902 @@
+/*
+ * DTS.Slice.Control.Event.Module.cs
+ * 
+ * Copyright © 2009
+ * Diversified Technical Systems, Inc.
+ * All Rights Reserved
+ */
+
+using DTS.Common.DAS.Concepts;
+using DTS.Serialization.StringResources;
+using DTS.Common.Utilities;
+using DTS.Common.Utilities.DotNetProgrammingConstructs;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using DTS.Common.Utilities.Logging;
+
+namespace DTS.Slice.Control
+{
+    // *** see DTS.Slice.Control.Event.cs ***
+    public partial class Event
+    {
+        /// <summary>
+        /// Representation of a Slice Control event module.
+        /// </summary>
+        public partial class Module
+            : Exceptional,
+              Serialization.Test.Module.IConvertable
+        {
+            public Module()
+            {
+                try
+                {
+                    //this.InitializeReviewableAttributes(this.ReviewableAttributes);
+                }
+
+                catch (System.Exception ex)
+                {
+                    throw new Exception("encountered problem zero-parameter constructing " + GetType().FullName, ex);
+                }
+            }
+
+            /// <summary>
+            /// Initialize an instance of the DTS.Slice.Control.Event.Module class.
+            /// </summary>
+            ///
+            /// <param name="parentEvent">
+            /// The parent <see cref="DTS.Slice.Control.Event"/> of this module.
+            /// </param>
+            ///
+            //TODO: this() is not base class
+            public Module(Event parentEvent)
+                : this()
+            {
+                try
+                {
+                    ParentEvent = parentEvent;
+                }
+
+                catch (System.Exception ex)
+                {
+                    throw new Exception("encounterd problem 1-parameter constructing " + GetType().FullName, ex);
+                }
+            }
+
+            /// <summary>
+            /// Initialize an instance of the DTS.Slice.Control.Event.Module class.
+            /// </summary>
+            /// 
+            /// <param name="that">
+            /// A <see cref="DTS.Serialization.Test.Module"/> with which to initialize this object.
+            /// </param>
+            ///
+            /// <param name="parentEvent">
+            /// The parent <see cref="DTS.Slice.Control.Event"/> of this module.
+            /// </param>
+            /// 
+            public Module(Serialization.Test.Module that, Event parent, Serialization.Test.ReportErrors reportErrors)
+                : this(parent)
+            {
+                try
+                {
+                    FromDtsSerializationTestModule(that, reportErrors);
+                }
+                catch (System.IO.InvalidDataException ex) { throw ex; }
+                catch (System.Exception ex)
+                {
+                    throw new Exception("encountered problem 2-parameter constructing " + GetType().FullName, ex);
+                }
+            }
+            
+            /// <summary>
+            /// The <see cref="Event"/> that contains this module.
+            /// </summary>
+            public Event ParentEvent
+            {
+                get => _ParentEvent.Value;
+                private set => _ParentEvent.Value = value;
+            }
+            private readonly Property<Event> _ParentEvent
+                = new Property<Event>(
+                    typeof(Module).Namespace + ".Event.Module.ParentEvent",
+                    null,
+                    false
+                );
+            public void SetParentEvent(Event e) { _ParentEvent.Value = e; }
+            /// <summary>
+            /// Get/set the list of channels on this event module.
+            /// </summary>
+            public List<Channel> Channels
+            {
+                get => _Channels.Value;
+                set => _Channels.Value = value;
+            }
+            private readonly Property<List<Channel>> _Channels = new Property<List<Channel>>("Event.Module.Channels", new List<Channel>(), true);
+
+            /// <summary>
+            /// Get/set the <see cref="int"/> module number of this event module.
+            /// </summary>
+            public int Number
+            {
+                get => _Number.Value;
+                set => _Number.Value = value;
+            }
+            private readonly Property<int> _Number = new Property<int>("Event.Module.Number", 0, false);
+
+            /// <summary>
+            /// Get/set the serial number <see cref="string"/> for this DAS.
+            /// </summary>
+            public string DasSerialNumber
+            {
+                get => _dasSerialNumber.Value;
+                set => _dasSerialNumber.Value = value;
+            }
+
+            private readonly Property<string> _dasSerialNumber = new Property<string>(typeof(Module).Namespace + ".Event.Module.DasSerialNumber", "", true);
+
+            /// <summary>
+            /// Get/set the serial number <see cref="string"/> for this DAS.
+            /// </summary>
+            public string Description
+            {
+                get => _Description.Value;
+                set => _Description.Value = value;
+            }
+            private readonly Property<string> _Description
+                = new Property<string>(
+                    typeof(Module).Namespace + ".Event.Module.Description",
+                    "",
+                    true
+                );
+            public bool IsSlice6DBModule()
+            {
+                return (Description == "slice6db module");
+            }
+
+            /// <summary>
+            /// Get/set the base serial number <see cref="string"/> for this DAS.
+            /// </summary>
+            public string BaseSerialNumber
+            {
+                get => _BaseSerialNumber.Value;
+                set => _BaseSerialNumber.Value = value;
+            }
+            private readonly Property<string> _BaseSerialNumber
+                = new Property<string>(
+                    typeof(Module).Namespace + ".Event.Module.BaseSerialNumber",
+                    "",
+                    true
+                );
+
+            /// <summary>
+            /// Get/set the <see cref="double"/> number of requested seconds pre-trigger for this event module.
+            /// </summary>
+            public double RequestedPreTriggerSeconds
+            {
+                get => _RequestedPreTriggerSeconds.Value;
+                set => _RequestedPreTriggerSeconds.Value = value;
+            }
+            private readonly Property<double> _RequestedPreTriggerSeconds = new Property<double>("Event.Module.RequestedPreTriggerSeconds", 0.0, false);
+
+            /// <summary>
+            /// Get/set the <see cref="double"/> number of requested seconds post-trigger for this event module.
+            /// </summary>
+            public double RequestedPostTriggerSeconds
+            {
+                get => _RequestedPostTriggerSeconds.Value;
+                set => _RequestedPostTriggerSeconds.Value = value;
+            }
+            private readonly Property<double> _RequestedPostTriggerSeconds = new Property<double>("Event.Module.RequestedPostTriggerSeconds", 0.0, false);
+
+            /// <summary>
+            /// Get/set the <see cref="double"/> number of seconds pre-trigger for this event module.
+            /// </summary>
+            public double PreTriggerSeconds
+            {
+                get => _PreTriggerSeconds.Value;
+                set => _PreTriggerSeconds.Value = value;
+            }
+            private readonly Property<double> _PreTriggerSeconds = new Property<double>("Event.Module.PreTriggerSeconds", 0.0, false);
+
+            /// <summary>
+            /// Get/set the <see cref="double"/> number of seconds post-trigger for this event module.
+            /// </summary>
+            public double PostTriggerSeconds
+            {
+                get => _PostTriggerSeconds.Value;
+                set => _PostTriggerSeconds.Value = value;
+            }
+            private readonly Property<double> _PostTriggerSeconds = new Property<double>("Event.Module.PostTriggerSeconds", 0.0, false);
+
+            /// <summary>
+            /// Get/set the number of <see cref="UInt64"/> samples in this event modules.
+            /// </summary>
+            public UInt64 NumberOfSamples
+            {
+                get => _NumberOfSamples.Value;
+                set => _NumberOfSamples.Value = value;
+            }
+            private readonly Property<UInt64> _NumberOfSamples = new Property<UInt64>("Event.Module.NumberOfSamples", 0, false);
+
+            /// <summary>
+            /// Get/set the number of unsubsampled <see cref="UInt64"/> samples in this event modules.
+            /// </summary>
+            public UInt64 UnsubsampledNumberOfSamples
+            {
+                get => _UnsubsampledNumberOfSamples.Value;
+                set => _UnsubsampledNumberOfSamples.Value = value;
+            }
+            private readonly Property<UInt64> _UnsubsampledNumberOfSamples = new Property<UInt64>("Event.Module.UnsubsampledNumberOfSamples", 0, true);
+
+            /// <summary>
+            /// Get/set the <see cref="UInt64"/> trigger sample numbers for this event module.
+            /// </summary>
+            public List<UInt64> TriggerSampleNumbers
+            {
+                get => _TriggerSampleNumbers.Value;
+                set => _TriggerSampleNumbers.Value = value;
+            }
+            private readonly Property<List<UInt64>> _TriggerSampleNumbers = new Property<List<UInt64>>("Event.Module.TriggerSampleNumbers", null, false);
+
+            /// <summary>
+            /// Get/set the <see cref="UInt64"/> unsubsampled trigger sample numbers for this event module.
+            /// </summary>
+            public List<UInt64> UnsubsampledTriggerSampleNumbers
+            {
+                get => _UnsubsampledTriggerSampleNumbers.Value;
+                set => _UnsubsampledTriggerSampleNumbers.Value = value;
+            }
+            private readonly Property<List<UInt64>> _UnsubsampledTriggerSampleNumbers = new Property<List<UInt64>>("Event.Module.UnsubsampledTriggerSampleNumbers", new List<UInt64>(), true);
+
+            /// <summary>
+            /// Get/set the <see cref="UInt64"/> start record sample number for this event module.
+            /// </summary>
+            public UInt64 StartRecordSampleNumber
+            {
+                get => _StartRecordSampleNumber.Value;
+                set => _StartRecordSampleNumber.Value = value;
+            }
+            private readonly Property<UInt64> _StartRecordSampleNumber = new Property<UInt64>("Event.Module.StartRecordSampleNumber", 0, false);
+
+            /// <summary>
+            /// Get/set the <see cref="float"/> sample rate for this event module.
+            /// </summary>
+            public float SampleRateHz
+            {
+                get => _SampleRateHz.Value;
+                set => _SampleRateHz.Value = value;
+            }
+            private readonly Property<float> _SampleRateHz = new Property<float>("Event.Module.SampleRateHz", 0, false);
+
+            /// <summary>
+            /// Get/set the <see cref="double"/> start record timestamp in seconds for this event module.
+            /// </summary>
+            public double StartRecordTimestampSec
+            {
+                get => _StartRecordTimestampSec.Value;
+                set => _StartRecordTimestampSec.Value = value;
+            }
+            private readonly Property<double> _StartRecordTimestampSec = new Property<double>("Event.Module.StartRecordTimestampSec", 0, false);
+
+            /// <summary>
+            /// Get/set the <see cref="double"/> start record timestamp in nanoseconds for this event module.
+            /// </summary>
+            public double StartRecordTimestampNanoSec
+            {
+                get => _StartRecordTimestampNanoSec.Value;
+                set => _StartRecordTimestampNanoSec.Value = value;
+            }
+            private readonly Property<double> _StartRecordTimestampNanoSec = new Property<double>("Event.Module.StartRecordTimestampNanoSec", 0, false);
+
+            /// <summary>
+            /// Get/set the <see cref="double"/> trigger timestamp in seconds for this event module.
+            /// </summary>
+            public double TriggerTimestampSec
+            {
+                get => _TriggerTimestampSec.Value;
+                set => _TriggerTimestampSec.Value = value;
+            }
+            private readonly Property<double> _TriggerTimestampSec = new Property<double>("Event.Module.TriggerTimestampSec", 0, false);
+
+            /// <summary>
+            /// Get/set the <see cref="double"/> trigger timestamp in nanoseconds for this event module.
+            /// </summary>
+            public double TriggerTimestampNanoSec
+            {
+                get => _TriggerTimestampNanoSec.Value;
+                set => _TriggerTimestampNanoSec.Value = value;
+            }
+            private readonly Property<double> _TriggerTimestampNanoSec = new Property<double>("Event.Module.TriggerTimestampNanoSec", 0, false);
+
+            /// <summary>
+            /// Get/set the <see cref="bool"/> whether or not PTP master sync is used for this event module.
+            /// </summary>
+            public bool PTPMasterSync
+            {
+                get => _PTPMasterSync.Value;
+                set => _PTPMasterSync.Value = value;
+            }
+            private readonly Property<bool> _PTPMasterSync = new Property<bool>("Event.Module.PTPMasterSync", false, false);
+
+            /// <summary>
+            /// Get/set the tilt sensor X axis value.
+            /// </summary>
+            public double TiltSensorAxisXDegreesPre
+            {
+                get => _TiltSensorAxisXDegreesPre.Value;
+                set => _TiltSensorAxisXDegreesPre.Value = value;
+            }
+            private readonly Property<double> _TiltSensorAxisXDegreesPre = new Property<double>("Event.Module.TiltSensorAxisXDegreesPre", 0, false);
+
+            /// <summary>
+            /// Get/set the tilt sensor Y axis value.
+            /// </summary>
+            public double TiltSensorAxisYDegreesPre
+            {
+                get => _TiltSensorAxisYDegreesPre.Value;
+                set => _TiltSensorAxisYDegreesPre.Value = value;
+            }
+            private readonly Property<double> _TiltSensorAxisYDegreesPre = new Property<double>("Event.Module.TiltSensorAxis2DegreesPre", 0, false);
+
+            /// <summary>
+            /// Get/set the tilt sensor Z axis value.
+            /// </summary>
+            public double TiltSensorAxisZDegreesPre
+            {
+                get => _TiltSensorAxisZDegreesPre.Value;
+                set => _TiltSensorAxisZDegreesPre.Value = value;
+            }
+            private readonly Property<double> _TiltSensorAxisZDegreesPre = new Property<double>("Event.Module.TiltSensorAxisZDegreesPre", 0, false);
+
+            /// <summary>
+            /// Get/set the tilt sensor X axis value.
+            /// </summary>
+            public double TiltSensorAxisXDegreesPost
+            {
+                get => _TiltSensorAxisXDegreesPost.Value;
+                set => _TiltSensorAxisXDegreesPost.Value = value;
+            }
+            private readonly Property<double> _TiltSensorAxisXDegreesPost = new Property<double>("Event.Module.TiltSensorAxisXDegreesPost", 0, false);
+
+            /// <summary>
+            /// Get/set the tilt sensor Y axis value.
+            /// </summary>
+            public double TiltSensorAxisYDegreesPost
+            {
+                get => _TiltSensorAxisYDegreesPost.Value;
+                set => _TiltSensorAxisYDegreesPost.Value = value;
+            }
+            private readonly Property<double> _TiltSensorAxisYDegreesPost = new Property<double>("Event.Module.TiltSensorAxisYDegreesPost", 0, false);
+
+            /// <summary>
+            /// Get/set the tilt sensor Z axis value.
+            /// </summary>
+            public double TiltSensorAxisZDegreesPost
+            {
+                get => _TiltSensorAxisZDegreesPost.Value;
+                set => _TiltSensorAxisZDegreesPost.Value = value;
+            }
+            private readonly Property<double> _TiltSensorAxisZDegreesPost = new Property<double>("Event.Module.TiltSensorAxisZDegreesPost", 0, false);
+
+            /// <summary>
+            /// Get/set the temperature sensor location 1 value.
+            /// </summary>
+            public float TemperatureLocation1Pre
+            {
+                get => _TemperatureLocation1Pre.Value;
+                set => _TemperatureLocation1Pre.Value = value;
+            }
+            private readonly Property<float> _TemperatureLocation1Pre = new Property<float>("Event.Module.TemperatureLocation1Pre", 0, false);
+
+            /// <summary>
+            /// Get/set the temperature sensor location 2 value.
+            /// </summary>
+            public float TemperatureLocation2Pre
+            {
+                get => _TemperatureLocation2Pre.Value;
+                set => _TemperatureLocation2Pre.Value = value;
+            }
+            private readonly Property<float> _TemperatureLocation2Pre = new Property<float>("Event.Module.TemperatureLocation2Pre", 0, false);
+
+            /// <summary>
+            /// Get/set the temperature sensor location 3 value.
+            /// </summary>
+            public float TemperatureLocation3Pre
+            {
+                get => _TemperatureLocation3Pre.Value;
+                set => _TemperatureLocation3Pre.Value = value;
+            }
+            private readonly Property<float> _TemperatureLocation3Pre = new Property<float>("Event.Module.TemperatureLocation3Pre", 0, false);
+
+            /// <summary>
+            /// Get/set the temperature sensor location 4 value.
+            /// </summary>
+            public float TemperatureLocation4Pre
+            {
+                get => _TemperatureLocation4Pre.Value;
+                set => _TemperatureLocation4Pre.Value = value;
+            }
+            private readonly Property<float> _TemperatureLocation4Pre = new Property<float>("Event.Module.TemperatureLocation4Pre", 0, false);
+
+            /// <summary>
+            /// Get/set the temperature sensor location 1 post value.
+            /// </summary>
+            public float TemperatureLocation1Post
+            {
+                get => _TemperatureLocation1Post.Value;
+                set => _TemperatureLocation1Post.Value = value;
+            }
+            private readonly Property<float> _TemperatureLocation1Post = new Property<float>("Event.Module.TemperatureLocation1Post", 0, false);
+
+            /// <summary>
+            /// Get/set the temperature sensor location 2 value.
+            /// </summary>
+            public float TemperatureLocation2Post
+            {
+                get => _TemperatureLocation2Post.Value;
+                set => _TemperatureLocation2Post.Value = value;
+            }
+            private readonly Property<float> _TemperatureLocation2Post = new Property<float>("Event.Module.TemperatureLocation2Post", 0, false);
+
+            /// <summary>
+            /// Get/set the temperature sensor location 3 post value.
+            /// </summary>
+            public float TemperatureLocation3Post
+            {
+                get => _TemperatureLocation3Post.Value;
+                set => _TemperatureLocation3Post.Value = value;
+            }
+            private readonly Property<float> _TemperatureLocation3Post = new Property<float>("Event.Module.TemperatureLocation3Post", 0, false);
+
+            /// <summary>
+            /// Get/set the temperature sensor location 4 post value.
+            /// </summary>
+            public float TemperatureLocation4Post
+            {
+                get => _TemperatureLocation4Post.Value;
+                set => _TemperatureLocation4Post.Value = value;
+            }
+            private readonly Property<float> _TemperatureLocation4Post = new Property<float>("Event.Module.TemperatureLocation4Post", 0, false);
+
+            /// <summary>
+            /// Get/set the <see cref="float"/> AA filter rate for this event module.
+            /// </summary>
+            public float AaFilterRateHz
+            {
+                get => _AaFilterRateHz.Value;
+                set => _AaFilterRateHz.Value = value;
+            }
+            private readonly Property<float> _AaFilterRateHz = new Property<float>("Event.Module.AaFilterRateHz", 0, false);
+
+            /// <summary>
+            /// Get/set the <see cref="Test.Module.Channel.Sensor.ExcitationVoltageOption"/> nominal
+            /// excitation voltage of this module.
+            /// </summary>
+            public Test.Module.Channel.Sensor.ExcitationVoltageOption NominalExcitationVoltage
+            {
+                get => _NominalExcitationVoltage.Value;
+                set => _NominalExcitationVoltage.Value = value;
+            }
+            private readonly Property<Test.Module.Channel.Sensor.ExcitationVoltageOption> _NominalExcitationVoltage
+                = new Property<Test.Module.Channel.Sensor.ExcitationVoltageOption>(
+                    typeof(Module).Namespace + ".Event.Module.NominalExcitationVoltage",
+                    Test.Module.Channel.Sensor.ExcitationVoltageOption.Volt5,
+                    true
+                );
+
+            /// <summary>
+            /// Get/set the <see cref="Test.Module.RecordingMode"/> of this module.
+            /// </summary>
+            public Test.Module.RecordingMode RecordingMode
+            {
+                get => _RecordingMode.Value;
+                set => _RecordingMode.Value = value;
+            }
+            private readonly Property<Test.Module.RecordingMode> _RecordingMode = new Property<Test.Module.RecordingMode>("Event.Module.RecordingMode", Test.Module.RecordingMode.CircularBuffer, false);
+
+            /// <summary>
+            /// Set the applicable properties of this object from the specified target object.
+            /// </summary>
+            /// 
+            /// <param name="that">
+            /// The <see cref="DTS.DASLib.Service.DASModule"/> that is to have the information it
+            /// shares with this object copied.
+            /// </param>
+            /// 
+            public void SetPropertyValuesFrom(DASLib.Service.DASModule that)
+            {
+                try
+                {
+                    TriggerSampleNumbers = new List<ulong>(null != that.TriggerSampleNumbers ? that.TriggerSampleNumbers : new ulong[] { });
+                    NumberOfSamples = that.NumberOfSamples;
+                    ParentEvent.Guid = that.OwningDAS.EventGuids[0];
+                    ushort faultFlag = 0;
+                    try { faultFlag = ParentEvent.FaultFlags; }
+                    //TODO: handle exception!!!
+                    catch (System.Exception) { }
+                    ParentEvent.FaultFlags = Convert.ToUInt16(faultFlag | that.OwningDAS.FaultFlags[0]);
+                    // that.Description
+                }
+
+                catch (System.Exception ex)
+                {
+                    throw new Exception("encountered problem setting property from target object " + (null != that ? "\"" + that.ToString() + "\"" : "<NULL>"), ex);
+                }
+            }
+
+            /// <summary>
+            /// Test the specified object for equality with this object.
+            /// </summary>
+            /// 
+            /// <param name="obj">
+            /// The <see cref="object"/> to be tested for equality.
+            /// </param>
+            /// 
+            /// <returns>
+            /// <see cref="bool"/> true if the specified object has memeberwise equality with
+            /// this object; false otherwise.
+            /// </returns>
+            /// 
+            public override bool Equals(object obj)
+            {
+                try
+                {
+                    var that = obj as Module;
+                    return null != that
+                        && Description.Equals(that.Description)
+                        && AaFilterRateHz.Equals(that.AaFilterRateHz)
+                        && Number.Equals(that.Number)
+                        && DasSerialNumber.Equals(that.DasSerialNumber)
+                        && NumberOfSamples.Equals(that.NumberOfSamples)
+                        && UnsubsampledNumberOfSamples.Equals(that.UnsubsampledNumberOfSamples)
+                        && RequestedPostTriggerSeconds.Equals(that.RequestedPostTriggerSeconds)
+                        && RequestedPreTriggerSeconds.Equals(that.RequestedPreTriggerSeconds)
+                        && PostTriggerSeconds.Equals(that.PostTriggerSeconds)
+                        && PreTriggerSeconds.Equals(that.PreTriggerSeconds)
+                        && RecordingMode.Equals(that.RecordingMode)
+                        && SampleRateHz.Equals(that.SampleRateHz)
+                        && StartRecordSampleNumber.Equals(that.StartRecordSampleNumber)
+                        && TriggerSampleNumbersEquals(that.TriggerSampleNumbers)
+                        && UnsubsampledTriggerSampleNumbersEquals(that.UnsubsampledTriggerSampleNumbers)
+                        && ChannelsEquals(that.Channels);
+                }
+
+                catch (System.Exception ex)
+                {
+                    throw new Exception(
+                        string.Format(
+                            Strings.DTS_Slice_Control_Equals_ComparisonFailedString, null != obj ? "\"" + obj.ToString() + "\"" : Strings.DTS_Slice_Control_NullIndicatorString),
+                        ex);
+                }
+            }
+
+            /// <summary>
+            /// Test the specified object's trigger sample number list for equality with this
+            /// object's module list.
+            /// </summary>
+            /// 
+            /// <param name="thoseTriggerSampleNumbers">
+            /// The <see cref="List"/> of <see cref="UInt64"/> object to be
+            /// compared for equality with this event's equivalent.
+            /// </param>
+            /// 
+            /// <returns>
+            /// <see cref="bool"/> true if the two lists contain equivalent-valued members;
+            /// false otherwise.
+            /// </returns>
+            /// 
+            private bool TriggerSampleNumbersEquals(List<UInt64> thoseTriggerSampleNumbers)
+            {
+                try
+                {
+                    if (null == thoseTriggerSampleNumbers || TriggerSampleNumbers.Count != thoseTriggerSampleNumbers.Count)
+                        return false;
+                    return !thoseTriggerSampleNumbers.Where((t, i) => !TriggerSampleNumbers[i].Equals(t)).Any();
+                }
+
+                catch (System.Exception ex)
+                {
+                    throw new Exception(Strings.DTS_Slice_Control_Event_Module_TriggerSampleNumbersEquals_ComparisonFailedString, ex);
+                }
+            }
+
+            /// <summary>
+            /// Test the specified object's unsubsampled trigger sample number list for equality with this
+            /// object's module list.
+            /// </summary>
+            /// 
+            /// <param name="thoseUnsubsampledTriggerSampleNumbers">
+            /// The <see cref="List"/> of <see cref="UInt64"/> object to be
+            /// compared for equality with this event's equivalent.
+            /// </param>
+            /// 
+            /// <returns>
+            /// <see cref="bool"/> true if the two lists contain equivalent-valued members;
+            /// false otherwise.
+            /// </returns>
+            /// 
+            private bool UnsubsampledTriggerSampleNumbersEquals(List<UInt64> thoseUnsubsampledTriggerSampleNumbers)
+            {
+                try
+                {
+                    if (null == thoseUnsubsampledTriggerSampleNumbers || UnsubsampledTriggerSampleNumbers.Count != thoseUnsubsampledTriggerSampleNumbers.Count)
+                        return false;
+                    return !thoseUnsubsampledTriggerSampleNumbers.Where((t, i) => !UnsubsampledTriggerSampleNumbers[i].Equals(t)).Any();
+                }
+
+                catch (System.Exception ex)
+                {
+                    throw new Exception("unsubsampled trigger sample number arrays do not match", ex);
+                }
+            }
+
+            /// <summary>
+            /// Test the specified object's module list for equality with this object's
+            /// module list.
+            /// </summary>
+            /// 
+            /// <param name="thoseChannels">
+            /// The <see cref="List"/> of <see cref="DTS.Slice.Control.Event.Module.Channel"/> objects to be
+            /// compared for equality with this module's equivalent.
+            /// </param>
+            /// 
+            /// <returns>
+            /// <see cref="bool"/> true if the two lists contain equivalent-valued members;
+            /// false otherwise.
+            /// </returns>
+            /// 
+            private bool ChannelsEquals(List<Channel> thoseChannels)
+            {
+                try
+                {
+                    if (null == thoseChannels || Channels.Count != thoseChannels.Count)
+                        return false;
+                    return !thoseChannels.Where((t, i) => !Channels[i].Equals(t)).Any();
+                }
+
+                catch (System.Exception ex)
+                {
+                    throw new Exception(Strings.DTS_Slice_Control_Event_Module_ChannelsEquals_ComparisonFailedString, ex);
+                }
+            }
+
+            /// <summary>
+            /// Return the hash code for this object.
+            /// </summary>
+            /// 
+            /// <returns>
+            /// The <see cref="int"/> hash code for this object.
+            /// </returns>
+            /// 
+            public override int GetHashCode()
+            {
+                return base.GetHashCode();
+            }
+
+            /// <summary>
+            /// Convert this object into a DTS.Serialization.Test.Module.
+            /// </summary>
+            /// 
+            /// <returns>
+            /// A <see cref="DTS.Serialization.Test.Module"/> equivalent to this object.
+            /// </returns>
+            /// 
+            public Serialization.Test.Module ToDtsSerializationTestModule(Serialization.Test parentTest)
+            {
+                try
+                {
+                    var that = new Serialization.Test.Module(parentTest)
+                    {
+                        Description = Description,
+                        AaFilterRateHz = AaFilterRateHz,
+                        Number = Number,
+                        SerialNumber = DasSerialNumber,
+                        NumberOfSamples = NumberOfSamples,
+                        UnsubsampledNumberOfSamples = UnsubsampledNumberOfSamples,
+                        RequestedPostTriggerSeconds = RequestedPostTriggerSeconds,
+                        RequestedPreTriggerSeconds = RequestedPreTriggerSeconds,
+                        PostTriggerSeconds = PostTriggerSeconds,
+                        PreTriggerSeconds = PreTriggerSeconds,
+                        RecordingMode = RecordingMode,
+                        SampleRateHz = SampleRateHz,
+                        StartRecordSampleNumber = StartRecordSampleNumber,
+                        TriggerSampleNumbers = TriggerSampleNumbers,
+                        UnsubsampledTriggerSampleNumbers = UnsubsampledTriggerSampleNumbers,
+                        BaseSerialNumber = BaseSerialNumber,
+                        StartRecordTimestampSec = StartRecordTimestampSec,
+                        StartRecordTimestampNanoSec = StartRecordTimestampNanoSec,
+                        TriggerTimestampSec = TriggerTimestampSec,
+                        TriggerTimestampNanoSec = TriggerTimestampNanoSec,
+                        PTPMasterSync = PTPMasterSync,
+                        TiltSensorAxisXDegreesPre = TiltSensorAxisXDegreesPre,
+                        TiltSensorAxisYDegreesPre = TiltSensorAxisYDegreesPre,
+                        TiltSensorAxisZDegreesPre = TiltSensorAxisZDegreesPre,
+                        TiltSensorAxisXDegreesPost = TiltSensorAxisXDegreesPost,
+                        TiltSensorAxisYDegreesPost = TiltSensorAxisYDegreesPost,
+                        TiltSensorAxisZDegreesPost = TiltSensorAxisZDegreesPost,
+                        TemperatureLocation1Pre = TemperatureLocation1Pre,
+                        TemperatureLocation2Pre = TemperatureLocation2Pre,
+                        TemperatureLocation3Pre = TemperatureLocation3Pre,
+                        TemperatureLocation4Pre = TemperatureLocation4Pre,
+                        TemperatureLocation1Post = TemperatureLocation1Post,
+                        TemperatureLocation2Post = TemperatureLocation2Post,
+                        TemperatureLocation3Post = TemperatureLocation3Post,
+                        TemperatureLocation4Post = TemperatureLocation4Post,
+                        Channels = new List<Serialization.Test.Module.Channel>()
+                    };
+
+
+
+                    // Create a test module channel to embody each channel conversion, and then
+                    // copy over all relevant channel data members.
+                    foreach (var thisChannel in Channels)
+                    {
+                        //10988 Do not download/write/purge unneeded files; Only write required channels
+                        if (thisChannel.IsConfigured)
+                        {
+                            //
+                            // Create a test module channel to embody each channel conversion, and then
+                            // copy over all relevant channel data members.
+                            //
+                            that.Channels.Add(thisChannel.ToDtsSerializationTestModuleChannel(that));
+                        }
+                    }
+
+                    return that;
+                }
+
+                catch (System.Exception ex)
+                {
+                    throw new Exception("encountered problem converting " + GetType().FullName + " to " + typeof(Serialization.Test.Module).FullName, ex);
+                }
+            }
+
+            /// <summary>
+            /// Initialize this object from a DTS.Serialization.Test.Module.
+            /// </summary>
+            /// 
+            /// <param name="that">
+            /// A <see cref="DTS.Serialization.Test.Module"/> from which to initialize this object.
+            /// </param>
+            /// <param name="reportErrors"></param>
+            //TODO: use more descriptive variable names
+            public void FromDtsSerializationTestModule(Serialization.Test.Module that, Serialization.Test.ReportErrors reportErrors)
+            {
+                var errors = new List<string>();
+                try
+                {
+                    if (null == that) { throw new ArgumentNullException( $"cannot set this object's properties from null serialization test module reference"); }
+
+                    Description = that.Description;
+                    AaFilterRateHz = that.AaFilterRateHz;
+                    Number = that.Number;
+                    DasSerialNumber = that.SerialNumber;
+                    NumberOfSamples = that.NumberOfSamples;
+                    UnsubsampledNumberOfSamples = that.UnsubsampledNumberOfSamples;
+                    RequestedPostTriggerSeconds = that.RequestedPostTriggerSeconds;
+                    RequestedPreTriggerSeconds = that.RequestedPreTriggerSeconds;
+                    PostTriggerSeconds = that.PostTriggerSeconds;
+                    PreTriggerSeconds = that.PreTriggerSeconds;
+                    RecordingMode = that.RecordingMode;
+                    SampleRateHz = that.SampleRateHz;
+                    StartRecordSampleNumber = that.StartRecordSampleNumber;
+                    TriggerSampleNumbers = that.TriggerSampleNumbers;
+                    UnsubsampledTriggerSampleNumbers = that.UnsubsampledTriggerSampleNumbers;
+                    BaseSerialNumber = that.BaseSerialNumber;
+                    try
+                    {
+                        StartRecordTimestampSec = that.StartRecordTimestampSec;
+                    }
+                    catch (System.Exception ex)
+                    {
+                        APILogger.Log("failed to get StartRecordTimestampSec", ex);
+                    }
+                    //TODO: inappropriate using try/catch!!!
+                    try
+                    {
+                        StartRecordTimestampNanoSec = that.StartRecordTimestampNanoSec;
+                    }
+                    catch (System.Exception ex)
+                    {
+                        APILogger.Log("failed to get StartRecordTimestampSec", ex);
+                    }
+                    //TODO: inappropriate using try/catch!!!
+                    try
+                    {
+                        TriggerTimestampSec = that.TriggerTimestampSec;
+                    }
+                    catch (System.Exception ex)
+                    {
+                        APILogger.Log("failed to get TriggerTimestampSec", ex);
+                    }
+                    //TODO: inappropriate using try/catch!!!
+                    try
+                    {
+                        TriggerTimestampNanoSec = that.StartRecordTimestampNanoSec;
+                    }
+                    catch (System.Exception ex)
+                    {
+                        APILogger.Log("failed to get TriggerTimestampNanoSec", ex);
+                    }
+                    //TODO: inappropriate using try/catch!!!
+                    try
+                    {
+                        PTPMasterSync = that.PTPMasterSync;
+                    }
+                    catch (System.Exception ex)
+                    {
+                        APILogger.Log("failed to get PTPMasterSync", ex);
+                    }
+                    //TODO: inappropriate using try/catch!!!
+                    try
+                    {
+                        TiltSensorAxisXDegreesPre = that.TiltSensorAxisXDegreesPre;
+                        TiltSensorAxisYDegreesPre = that.TiltSensorAxisYDegreesPre;
+                        TiltSensorAxisZDegreesPre = that.TiltSensorAxisZDegreesPre;
+                        TiltSensorAxisXDegreesPost = that.TiltSensorAxisXDegreesPost;
+                        TiltSensorAxisYDegreesPost = that.TiltSensorAxisYDegreesPost;
+                        TiltSensorAxisZDegreesPost = that.TiltSensorAxisZDegreesPost;
+                    }
+                    catch (System.Exception ex)
+                    {
+                        APILogger.Log("failed to get tilt information", ex);
+                    }
+                    //TODO: inappropriate using try/catch!!!
+                    try
+                    {
+                        TemperatureLocation1Pre = that.TemperatureLocation1Pre;
+                        TemperatureLocation2Pre = that.TemperatureLocation2Pre;
+                        TemperatureLocation3Pre = that.TemperatureLocation3Pre;
+                        TemperatureLocation4Pre = that.TemperatureLocation4Pre;
+                        TemperatureLocation1Post = that.TemperatureLocation1Post;
+                        TemperatureLocation2Post = that.TemperatureLocation2Post;
+                        TemperatureLocation3Post = that.TemperatureLocation3Post;
+                        TemperatureLocation4Post = that.TemperatureLocation4Post;
+                    }
+                    catch (System.Exception ex)
+                    {
+                        APILogger.Log("failed to get temperature information", ex);
+                    }
+                    //APILogger.DoPerformanceLog("DTS.Slice.Control.Event.Module:FromDTSSerializationTestModule:6");
+                    var absoluteChannelNumber = ParentEvent.LastAbsoluteChannelNumberInEvent + 1;
+
+                    Channels.Clear();
+                    foreach (var thatChannel in that.Channels)
+                    {   //
+                        // Create a Slice Control channel corresponding to the specified serialization
+                        // channel and populate its relevant properties.
+                        //
+                        try
+                        {
+                            if (thatChannel.AbsoluteDisplayOrder != -2)
+                            {
+                                //Have to count the channels this way as the module isn't a part of the event yet.
+                                var emc = Channel.CreateChannel(thatChannel, this, absoluteChannelNumber++);
+                                Channels.Add(emc);
+                                thatChannel.emc = emc;
+                                Trace.WriteLine("Created EMC: " + absoluteChannelNumber.ToString());
+                            }
+                        }
+                        catch (System.IO.InvalidDataException ex) { errors.Add(ex.Message); }
+                    }
+                    foreach (var thatCalculatedChannel in that.CalculatedChannels)
+                    {
+                        //Have to count the channels this way as the module isn't a part of the event yet.
+                        var emc = Channel.CreateChannel(thatCalculatedChannel, this, absoluteChannelNumber++);
+                        Trace.WriteLine("Created EMC: " + absoluteChannelNumber.ToString());
+                        Channels.Add(emc);
+                        thatCalculatedChannel.emc = emc;
+                    }
+
+                }
+                catch (System.Exception ex)
+                {
+                    throw new Exception("encountered problem initializing " + GetType().FullName + " using " + typeof(Serialization.Test.Module).FullName, ex);
+                }
+                if (errors.Count > 0 && null != reportErrors) { reportErrors(errors); }
+            }
+        }
+    }
+}

Common/DTS.Common.Serialization/Control/Event/Module/ReviewableAttribute.cs

@@ -0,0 +1,74 @@
+/*
+ * DTS.Slice.Control.Event.Module.ReviewableAttribute.cs
+ * 
+ * Copyright © 2009
+ * Diversified Technical Systems, Inc.
+ * All Rights Reserved
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace DTS.Slice.Control
+{
+    // *** see DTS.Slice.Control.Event.cs ***
+    public partial class Event
+    {
+
+        // *** see DTS.Slice.Control.Event.Module.cs ***
+        public partial class Module
+        {
+
+            /// <summary>
+            /// A reviewable attribute attached to a specific channel.
+            /// </summary>
+            abstract public partial class ReviewableAttribute
+                : Slice.Control.ReviewableAttribute
+            {
+                /// <summary>
+                /// The concrete class should implement this constructor.
+                /// </summary>
+                /// 
+                /// <param name="channel">
+                /// The <see cref="DTS.Slice.Control.Event.Module"/> to which a specific instance
+                /// of this reviewable attribute class is attached.  It should be used by this class' subclass'
+                /// DetermineAttributeValueString method.
+                /// </param>
+                /// 
+                public ReviewableAttribute(Event.Module channel)
+                    : this(null, null)
+                {
+                    try
+                    {
+                        throw new NotImplementedException("cannot initialize " + this.GetType().FullName + " with this constructor; must call parameterized version");
+                    }
+
+                    catch (System.Exception ex)
+                    {
+                        throw new Module.ReviewableAttribute.Exception("encountered problem constructing " + this.GetType().FullName, ex);
+                    }
+                }
+
+                /// <summary>
+                /// Initialize an instance of this class.
+                /// </summary>
+                /// 
+                /// <param name="name">
+                /// The <see cref="string"/> name of the attribute represented by this class.
+                /// </param>
+                /// 
+                /// <param name="calculateValue">
+                /// The <see cref="DTS.Slice.Control.ReviewableAttribute.DetermineValueString"/>
+                /// </param>
+                /// 
+                protected ReviewableAttribute(string name, DetermineValueString calculateValue)
+                    : base(name, calculateValue)
+                {
+                }
+            }
+        }   // *** end Module ***
+    }   // *** end Event ***
+}
+

Common/DTS.Common.Serialization/Control/Event/Module/ReviewableDasSerialNumberAttribute.cs

@@ -0,0 +1,46 @@
+/*
+ * DTS.Slice.Control.Event.Module.ReviewableDasSerialNumberAttribute.cs
+ * 
+ * Copyright © 2009
+ * Diversified Technical Systems, Inc.
+ * All Rights Reserved
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using DTS.Utilities;
+
+namespace DTS.Slice.Control
+{
+    // *** see DTS.Slice.Control.Event.cs ***
+    public partial class Event
+    {
+
+        // *** see DTS.Slice.Control.Event.Module.cs ***
+        public partial class Module
+        {
+
+            /// <summary>
+            /// A reviewable filter frequency attribute attached to a specific channel.
+            /// </summary>
+            public class ReviewableDasSerialNumberAttribute
+                : Slice.Control.Event.Module.ReviewableAttribute
+            {
+                /// <summary>
+                /// Initialize an instance of this class.
+                /// </summary>
+                /// 
+                /// <param name="channel">
+                /// The <see cref="Event.Module"/> to which this attribute is attached.
+                /// </param>
+                /// 
+                public ReviewableDasSerialNumberAttribute(Event.Module module)
+                    : base("DAS Serial Number", delegate { return module.DasSerialNumber; })
+                {
+                }
+            }
+        }   // *** end Module ***
+    }   // *** end Event ***
+}

Common/DTS.Common.Serialization/Control/Event/Module/ReviewableSampleRateAttribute.cs

@@ -0,0 +1,81 @@
+/*
+ * DTS.Slice.Control.Event.Module.ReviewableSampleRateAttribute.cs
+ * 
+ * Copyright © 2009
+ * Diversified Technical Systems, Inc.
+ * All Rights Reserved
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using DTS.Utilities;
+
+namespace DTS.Slice.Control
+{
+    // *** see DTS.Slice.Control.Event.cs ***
+    public partial class Event              {
+
+        // *** see DTS.Slice.Control.Event.Module.cs ***
+        public partial class Module             {
+
+            /// <summary>
+            /// A reviewable filter frequency attribute attached to a specific channel.
+            /// </summary>
+            public class ReviewableSampleRateAttribute
+                : Slice.Control.Event.Module.ReviewableAttribute
+            {
+                /// <summary>
+                /// Initialize an instance of this class.
+                /// </summary>
+                /// 
+                /// <param name="channel">
+                /// The <see cref="Event.Module"/> to which this attribute is attached.
+                /// </param>
+                /// 
+                public ReviewableSampleRateAttribute(Event.Module module)
+                    : base("Sample Rate", delegate { return module.SampleRateHz.ToString("N"); })
+                {
+                }
+            }
+
+            /// <summary>
+            /// A reviewable filter frequency attribute attached to a specific channel.
+            /// </summary>
+            public class ReviewableTestDescriptionAttribute
+                : Slice.Control.Event.Module.ReviewableAttribute
+            {
+                /// <summary>
+                /// Initialize an instance of this class.
+                /// </summary>
+                /// 
+                /// <param name="channel">
+                /// The <see cref="Event.Module"/> to which this attribute is attached.
+                /// </param>
+                /// 
+                public ReviewableTestDescriptionAttribute(Event.Module module)
+                    : base("Test Description", delegate { return module.ParentEvent.Description; })
+                {
+                }
+            }
+            public class ReviewableHardwareFrequencyAttribute
+                : Slice.Control.Event.Module.ReviewableAttribute
+            {
+                /// <summary>
+                /// Initialize an instance of this class.
+                /// </summary>
+                /// 
+                /// <param name="channel">
+                /// The <see cref="Event.Module.Channel"/> to which this attribute is attached.
+                /// </param>
+                /// 
+                public ReviewableHardwareFrequencyAttribute(Event.Module module)
+                    : base("HW AAF", delegate { return module.AaFilterRateHz.ToString("N2"); })
+                {
+                }
+            }
+        }   // *** end Module ***
+    }   // *** end Event ***
+}
+