426 lines
15 KiB
Plaintext
426 lines
15 KiB
Plaintext
using System;
|
|
using System.Linq;
|
|
using System.Windows.Media;
|
|
using DTS.Common.Base;
|
|
using DTS.Common.Enums.Sensors;
|
|
using DTS.Common.Interface;
|
|
// ReSharper disable CheckNamespace
|
|
// ReSharper disable RedundantDefaultMemberInitializer
|
|
// ReSharper disable RedundantCast
|
|
|
|
namespace DTS.Common.Classes.Viewer.TestMetadata
|
|
{
|
|
[Serializable]
|
|
public class TestChannel : BasePropertyChanged, ITestChannel
|
|
{
|
|
public string Group { get; set; }
|
|
public string SubGroup { get; set; }
|
|
|
|
private bool _isGraphChannel = false;
|
|
public bool IsGraphChannel { get => _isGraphChannel; set { _isGraphChannel = value; OnPropertyChanged("IsGraphChannel"); } }
|
|
public string GraphName { get; set; }
|
|
public string TestId { get; set; }
|
|
|
|
public string TestSetupName { get; set; }
|
|
public string ModuleSerialNumber { get; set; }
|
|
public string SerialNumber { get; set; }
|
|
public string ChannelId { get; set; }
|
|
private string _channelDisplayName = string.Empty;
|
|
public string ChannelDisplayName
|
|
{
|
|
get => _channelDisplayName;
|
|
set => SetProperty(ref _channelDisplayName, value, "ChannelDisplayName");
|
|
}
|
|
public string Description { get; set; }
|
|
public string IsoCode { get; set; }
|
|
public string IsoChannelName { get; set; }
|
|
public string UserCode { get; set; }
|
|
public string UserChannelName { get; set; }
|
|
public string ChannelGroupName { get; set; }
|
|
public string ChannelType { get; set; }
|
|
private bool _isCalculatedChannel = false;
|
|
|
|
public bool IsCalculatedChannel
|
|
{
|
|
get => _isCalculatedChannel;
|
|
set => SetProperty(ref _isCalculatedChannel, value, "IsCalculatedChannel");
|
|
}
|
|
|
|
public int Number { get; set; }
|
|
public string DigitalMultiplier { get; set; }
|
|
public string DigitalMode { get; set; }
|
|
public DateTime Start { get; set; }
|
|
public string Bridge { get; set; }
|
|
public double BridgeResistanceOhms { get; set; }
|
|
public double ZeroPoint { get; set; }
|
|
private string _channelDescriptionString;
|
|
public ulong T1Sample { get; set; } = 0;
|
|
public ulong T2Sample { get; set; } = 0;
|
|
public double HIC { get; set; } = 0D;
|
|
public bool UseEUScaler { get; set; }
|
|
public double ScaleFactorEU { get; set; } = 0D;
|
|
|
|
public string ChannelDescriptionString
|
|
{
|
|
get => _channelDescriptionString;
|
|
set => SetProperty(ref _channelDescriptionString, value, "ChannelDescriptionString");
|
|
}
|
|
|
|
public void SetChannelDescriptionAndDisplayName(string channelDescription)
|
|
{
|
|
ChannelDescriptionString = channelDescription;
|
|
ChannelDisplayName = $"{ChannelName2} {ChannelDescriptionString}";
|
|
}
|
|
public string ChannelName2 { get; set; }
|
|
public string HardwareChannelName { get; set; }
|
|
public double DesiredRange { get; set; }
|
|
public double ActualMaxRangeEu { get; set; }
|
|
public double ActualMinRangeEu { get; set; }
|
|
public double ActualMaxRangeAdc => short.MaxValue;
|
|
public double ActualMinRangeAdc => short.MinValue;
|
|
public double ActualMaxRangeMv { get; set; }
|
|
public double ActualMinRangeMv { get; set; }
|
|
public double Sensitivity { get; set; }
|
|
public string SoftwareFilter { get; set; }
|
|
public bool ProportionalToExcitation { get; set; }
|
|
public bool IsInverted { get; set; }
|
|
public string LinearizationFormula { get; set; }
|
|
public bool IsSubsampled { get; set; }
|
|
public int AbsoluteDisplayOrder { get; set; }
|
|
public DateTime LastCalibrationDate { get; set; }
|
|
public string SensorId { get; set; }
|
|
public int OffsetToleranceLowMv { get; set; }
|
|
public int OffsetToleranceHighMv { get; set; }
|
|
public int DataFlag { get; set; }
|
|
public string ExcitationVoltage { get; set; }
|
|
public string Eu { get; set; }
|
|
public bool CalSignalEnabled { get; set; }
|
|
public bool ShuntEnabled { get; set; }
|
|
public bool VoltageInsertionCheckEnabled { get; set; }
|
|
public bool RemoveOffset { get; set; }
|
|
public string ZeroMethod { get; set; }
|
|
public double ZeroAverageWindowBegin { get; set; }
|
|
public double ZeroAverageWindowEnd { get; set; }
|
|
public int InitialEu { get; set; }
|
|
public string InitialOffset { get; set; }
|
|
public int UnsubsampledSampleRateHz { get; set; }
|
|
public double MeasuredShuntDeflectionMv { get; set; }
|
|
public double TargetShuntDeflectionMv { get; set; }
|
|
public double MeasuredExcitationVoltage { get; set; }
|
|
public double FactoryExcitationVoltage { get; set; }
|
|
public double TimeOfFirstSample { get; set; }
|
|
public double Multiplier { get; set; }
|
|
public double UserOffsetEu { get; set; }
|
|
public int UnitConversion { get; set; }
|
|
public bool AtCapacity { get; set; }
|
|
public int CapacityOutputIsBasedOn { get; set; }
|
|
public string SourceChannelNumber { get; set; }
|
|
public string SourceModuleNumber { get; set; }
|
|
public string SourceModuleSerialNumber { get; set; }
|
|
public string Calculation { get; set; }
|
|
public int SampleRateHz { get; set; }
|
|
public string SensitivityUnits { get; set; }
|
|
public int SensorCapacity { get; set; }
|
|
public string SensorPolarity { get; set; }
|
|
public int ChannelNumber { get; set; }
|
|
public string BinaryFileName { get; set; }
|
|
public string BinaryFilePath { get; set; }
|
|
public double Xmax { get; set; }
|
|
public double Xmin { get; set; }
|
|
public int SequentialNumbers { get; set; }
|
|
public ITestSetupMetadata ParentTestSetup { get; set; }
|
|
public ITestModule ParentModule { get; set; }
|
|
public IBaseViewModel Parent { get; set; }
|
|
|
|
private Color _channelColor = Colors.Transparent;
|
|
|
|
public Color ChannelColor
|
|
{
|
|
get => _channelColor;
|
|
set => SetProperty(ref _channelColor, value, "ChannelColor");
|
|
}
|
|
|
|
private string _errorMessage = string.Empty;
|
|
|
|
public string ErrorMessage
|
|
{
|
|
get => _errorMessage;
|
|
set
|
|
{
|
|
_errorMessage = value;
|
|
_isError = !string.IsNullOrEmpty(_errorMessage);
|
|
OnPropertyChanged("ErrorMessage");
|
|
}
|
|
}
|
|
|
|
private bool _isError = false;
|
|
public bool IsError
|
|
{
|
|
get => _isError;
|
|
set => SetProperty(ref _isError, value, "IsError");
|
|
}
|
|
|
|
private Color? _errorColor = Colors.Black;
|
|
|
|
public Color? ErrorColor
|
|
{
|
|
get { _errorColor = _isError ? Colors.Red : Colors.Black; return _errorColor; }
|
|
set => SetProperty(ref _errorColor, value, "ErrorColor");
|
|
}
|
|
|
|
|
|
private bool _isLocked = false;
|
|
|
|
public bool IsLocked
|
|
{
|
|
get => _isLocked;
|
|
set
|
|
{
|
|
_isLocked = value;
|
|
if (!_isLocked && !_isSelected && !_isGraphChannel) { ChannelColor = Colors.Transparent; }
|
|
if (CanSelectChannel)
|
|
{
|
|
var parent = Parent;
|
|
if (parent.GetType().GetInterfaces().Contains(typeof(IGraphMainViewModel))) { ((IGraphMainViewModel)parent).AddLockedChannel(this, _isLocked); }
|
|
}
|
|
OnPropertyChanged("IsLocked");
|
|
}
|
|
}
|
|
|
|
private bool _bCanLock = true;
|
|
public bool CanLock
|
|
{
|
|
get => _bCanLock;
|
|
set => SetProperty(ref _bCanLock, !IsError && value, "CanLock");
|
|
}
|
|
private bool _canSelectChannel = true;
|
|
|
|
public bool CanSelectChannel
|
|
{
|
|
get => _canSelectChannel;
|
|
set => SetProperty(ref _canSelectChannel, !IsError && value, "CanSelectChannel");
|
|
}
|
|
|
|
private bool _isExpanded = true;
|
|
|
|
public bool IsExpanded
|
|
{
|
|
get => _isExpanded;
|
|
set => SetProperty(ref _isExpanded, value, "IsExpanded");
|
|
}
|
|
|
|
private bool _isSelected = false;
|
|
|
|
public bool IsSelected
|
|
{
|
|
get => _isSelected;
|
|
set
|
|
{
|
|
var parent = Parent;
|
|
_isSelected = value;
|
|
|
|
if (!_isLocked && !_isSelected && !_isGraphChannel) { ChannelColor = Colors.Transparent; }
|
|
|
|
if (_isSelected && CanSelectChannel)
|
|
{
|
|
if (parent.GetType().GetInterfaces().Contains(typeof(IGraphMainViewModel))) { ((IGraphMainViewModel)parent).AddSelectedChannel(this); }
|
|
OnPropertyChanged("IsSelected");
|
|
}
|
|
}
|
|
}
|
|
|
|
public ITestChannel Copy() { return (TestChannel)MemberwiseClone(); }
|
|
|
|
public override string ToString()
|
|
{
|
|
if( SensorConstants.IsTestSpecificEmbedded(ChannelDescriptionString)) { return Strings.Strings.Table_NA; }
|
|
return ChannelDescriptionString;
|
|
}
|
|
|
|
|
|
private double _minADC = double.NaN;
|
|
/// <summary>
|
|
/// Min value of ADC for entire dataset
|
|
/// </summary>
|
|
public double MinADC
|
|
{
|
|
get => _minADC;
|
|
set => SetProperty(ref _minADC, value, "MinADC");
|
|
}
|
|
private double _maxADC = double.NaN;
|
|
/// <summary>
|
|
/// Max value in ADC for entire dataset
|
|
/// </summary>
|
|
public double MaxADC
|
|
{
|
|
get => _maxADC;
|
|
set => SetProperty(ref _maxADC, value, "MaxADC");
|
|
}
|
|
private double _aveADC = double.NaN;
|
|
/// <summary>
|
|
/// Average value in ADC for entire dataset
|
|
/// </summary>
|
|
public double AveADC
|
|
{
|
|
get => _aveADC;
|
|
set => SetProperty(ref _aveADC, value, "AveADC");
|
|
}
|
|
private double _stdDevADC = double.NaN;
|
|
/// <summary>
|
|
/// STD DEV in ADC for entire dataset
|
|
/// </summary>
|
|
public double StdDevADC
|
|
{
|
|
get => _stdDevADC;
|
|
set => SetProperty(ref _stdDevADC, value, "StdDevADC");
|
|
}
|
|
private double _t0ADC = double.NaN;
|
|
/// <summary>
|
|
/// Value @ T0 in ADC
|
|
/// </summary>
|
|
public double T0ADC
|
|
{
|
|
get => _t0ADC;
|
|
set => SetProperty(ref _t0ADC, value, "T0ADC");
|
|
}
|
|
private double _minMV = double.NaN;
|
|
/// <summary>
|
|
/// Minimum value in mV for entire dataset
|
|
/// </summary>
|
|
public double MinMV
|
|
{
|
|
get => _minMV;
|
|
set => SetProperty(ref _minMV, value, "MinMV");
|
|
}
|
|
private double _maxMV = double.NaN;
|
|
/// <summary>
|
|
/// Maximum value in mV for entire dataset
|
|
/// </summary>
|
|
public double MaxMV
|
|
{
|
|
get => _maxMV;
|
|
set => SetProperty(ref _maxMV, value, "MaxMV");
|
|
}
|
|
private double _aveMV = double.NaN;
|
|
/// <summary>
|
|
/// average value in mV for entire dataset
|
|
/// </summary>
|
|
public double AveMV
|
|
{
|
|
get => _aveMV;
|
|
set => SetProperty(ref _aveMV, value, "AveMV");
|
|
}
|
|
private double _stdDevMV = double.NaN;
|
|
/// <summary>
|
|
/// std dev in mV for entire dataset
|
|
/// </summary>
|
|
public double StdDevMV
|
|
{
|
|
get => _stdDevMV;
|
|
set => SetProperty(ref _stdDevMV, value, "StdDevMV");
|
|
}
|
|
private double _t0MV = double.NaN;
|
|
/// <summary>
|
|
/// value in mV at T0
|
|
/// </summary>
|
|
public double T0MV
|
|
{
|
|
get => _t0MV;
|
|
set => SetProperty(ref _t0MV, value, "T0MV");
|
|
}
|
|
|
|
private double _minEU = double.NaN;
|
|
/// <summary>
|
|
/// minimum value in EU for entire dataset
|
|
/// </summary>
|
|
public double MinEU
|
|
{
|
|
get => _minEU;
|
|
set => SetProperty(ref _minEU, value, "MinEU");
|
|
}
|
|
private double _maxEU = double.NaN;
|
|
/// <summary>
|
|
/// maximum value in EU for entire dataset
|
|
/// </summary>
|
|
public double MaxEU
|
|
{
|
|
get => _maxEU;
|
|
set => SetProperty(ref _maxEU, value, "MaxEU");
|
|
}
|
|
private double _aveEU = double.NaN;
|
|
/// <summary>
|
|
/// average value in EU for entire dataset
|
|
/// </summary>
|
|
public double AveEU
|
|
{
|
|
get => _aveEU;
|
|
set => SetProperty(ref _aveEU, value, "AveEU");
|
|
}
|
|
private double _stdDevEU = double.NaN;
|
|
/// <summary>
|
|
/// std dev in EU
|
|
/// </summary>
|
|
public double StdDevEU
|
|
{
|
|
get => _stdDevEU;
|
|
set => SetProperty(ref _stdDevEU, value, "StdDevEU");
|
|
}
|
|
private double _t0EU = double.NaN;
|
|
/// <summary>
|
|
/// value at T0 in EU
|
|
/// </summary>
|
|
public double T0EU
|
|
{
|
|
get => _t0EU;
|
|
set => SetProperty(ref _t0EU, value, "T0EU");
|
|
}
|
|
|
|
private double _minY = double.NaN;
|
|
/// <summary>
|
|
/// minimum value for whatever current units are for entire dataset
|
|
/// </summary>
|
|
public double MinY
|
|
{
|
|
get => _minY;
|
|
set => SetProperty(ref _minY, value, "MinY");
|
|
}
|
|
private double _maxY = double.NaN;
|
|
/// <summary>
|
|
/// maximum value for whatever current units are for entire dataset
|
|
/// </summary>
|
|
public double MaxY
|
|
{
|
|
get => _maxY;
|
|
set => SetProperty(ref _maxY, value, "MaxY");
|
|
}
|
|
private double _aveY = double.NaN;
|
|
/// <summary>
|
|
/// average value for whatever current units are for entire dataset
|
|
/// </summary>
|
|
public double AveY
|
|
{
|
|
get => _aveY;
|
|
set => SetProperty(ref _aveY, value, "AveY");
|
|
}
|
|
private double _stdDevY = double.NaN;
|
|
/// <summary>
|
|
/// std deviation for whatever current units are
|
|
/// </summary>
|
|
public double StdDevY
|
|
{
|
|
get => _stdDevY;
|
|
set => SetProperty(ref _stdDevY, value, "StdDevY");
|
|
}
|
|
|
|
private double _T0Value = double.NaN;
|
|
/// <summary>
|
|
/// Value at T0 in whatever current units are
|
|
/// </summary>
|
|
public double T0Value
|
|
{
|
|
get => _T0Value;
|
|
set => SetProperty(ref _T0Value, value, "T0Value");
|
|
}
|
|
}
|
|
}
|