419 lines
17 KiB
C#
419 lines
17 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using DTS.Common.Interface.DASFactory.Diagnostics;
|
|
using DTS.Common.SerializationPlus;
|
|
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(IDiagnosticResult 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)); }
|
|
})
|
|
{
|
|
}
|
|
}
|
|
}
|
|
* */
|
|
}
|
|
}
|
|
}
|
|
}
|