584 lines
18 KiB
C#
584 lines
18 KiB
C#
using DTS.Common;
|
|
using DTS.Common.Classes.Sensors;
|
|
using DTS.Common.Enums.Sensors;
|
|
using DTS.Common.Interface;
|
|
using DTS.Common.Interface.Sensors;
|
|
using DTS.Common.Interface.Sensors.SoftwareFilters;
|
|
using DTS.SensorDB;
|
|
using Prism.Commands;
|
|
using System;
|
|
using System.ComponentModel;
|
|
// ReSharper disable InconsistentNaming
|
|
|
|
// ReSharper disable RedundantDefaultMemberInitializer
|
|
// ReSharper disable CheckNamespace
|
|
// ReSharper disable UnassignedGetOnlyAutoProperty
|
|
|
|
namespace DTS.Viewer.ChartOptions.Model
|
|
{
|
|
public class TestModificationModel : ITestModificationModel
|
|
{
|
|
#region Properties
|
|
/// <summary>
|
|
/// the calibration date for cal on channel (or empty if not applicable)
|
|
/// </summary>
|
|
public string CalDate
|
|
{
|
|
get
|
|
{
|
|
if (null == Cal) { return string.Empty; }
|
|
return Cal.CalibrationDate.ToShortDateString();
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// the modify date for cal on channel (or empty if not applicable)
|
|
/// </summary>
|
|
public string ModifyDate
|
|
{
|
|
get
|
|
{
|
|
if (null == Cal) { return string.Empty; }
|
|
return $"{Cal.ModifyDate.ToShortDateString()} {Cal.ModifyDate.ToShortTimeString()}";
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// sensitivity in calibration record for latest cal for sensor on channel
|
|
/// </summary>
|
|
public double CalSensitivity
|
|
{
|
|
get
|
|
{
|
|
if (null == Cal) { return double.NaN; }
|
|
if (null == Cal.Records || null == Cal.Records.Records || 0 == Cal.Records.Records.Length)
|
|
{
|
|
return double.NaN;
|
|
}
|
|
return Cal.Records.Records[0].Sensitivity;
|
|
}
|
|
set
|
|
{
|
|
if (null == Cal) { return; }
|
|
if (null == Cal.Records || null == Cal.Records.Records || 0 == Cal.Records.Records.Length)
|
|
{
|
|
return;
|
|
}
|
|
Cal.Records.Records[0].Sensitivity = value;
|
|
}
|
|
}
|
|
private void RebindCalProperties()
|
|
{
|
|
OnPropertyChanged("CalSensitivity");
|
|
OnPropertyChanged("NonLinear");
|
|
OnPropertyChanged("ProportionalToExcitation");
|
|
OnPropertyChanged("ShowSensorCal");
|
|
OnPropertyChanged("CalDate");
|
|
OnPropertyChanged("ModifyDate");
|
|
}
|
|
/// <summary>
|
|
/// whether latest calibration for channel is proportional to excitation or not
|
|
/// </summary>
|
|
public bool ProportionalToExcitation
|
|
{
|
|
get
|
|
{
|
|
if (null == Cal) { return false; }
|
|
return Cal.IsProportional;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// whether you should show sensor cal or not
|
|
/// </summary>
|
|
public bool ShowSensorCal
|
|
{
|
|
get
|
|
{
|
|
return null != Cal && null != Sensor && !NonLinear;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// whether calibration is non linear or not
|
|
/// </summary>
|
|
public bool NonLinear
|
|
{
|
|
get
|
|
{
|
|
if (null == Cal) { return false; }
|
|
return Cal.NonLinear;
|
|
}
|
|
}
|
|
|
|
private ISensorCalDbRecord _cal;
|
|
/// <summary>
|
|
/// the latest calibration for channel
|
|
/// </summary>
|
|
public ISensorCalDbRecord Cal
|
|
{
|
|
get => _cal;
|
|
set
|
|
{
|
|
_cal = value;
|
|
RebindCalProperties();
|
|
}
|
|
}
|
|
private ISensorDbRecord _sensor;
|
|
/// <summary>
|
|
/// sensor corresponding to channel
|
|
/// </summary>
|
|
public ISensorDbRecord Sensor
|
|
{
|
|
get => _sensor;
|
|
set
|
|
{
|
|
_sensor = value;
|
|
RebindCalProperties();
|
|
}
|
|
}
|
|
|
|
private ITestChannel _selectedChannel;
|
|
|
|
public ITestChannel SelectedChannel
|
|
{
|
|
get => _selectedChannel;
|
|
set
|
|
{
|
|
if (value != _selectedChannel)
|
|
{
|
|
_selectedChannel = value;
|
|
OnPropertyChanged("SelectedChannel");
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool IsModifiedDescription => !Description.Equals(SelectedChannel?.ChannelDescriptionString);
|
|
|
|
private string _description = "";
|
|
|
|
public string Description
|
|
{
|
|
get => _description;
|
|
set
|
|
{
|
|
if (value != _description)
|
|
{
|
|
_description = value;
|
|
OnPropertyChanged("Description");
|
|
OnPropertyChanged("IsModifiedDescription");
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool IsModifiedEuMultiplier => !EuMultiplier.Equals(SelectedChannel?.Multiplier);
|
|
|
|
private double _euMultiplier = 0D;
|
|
|
|
public double EuMultiplier
|
|
{
|
|
get => _euMultiplier;
|
|
set
|
|
{
|
|
if (value != _euMultiplier)
|
|
{
|
|
_euMultiplier = value;
|
|
OnPropertyChanged("EuMultiplier");
|
|
OnPropertyChanged("IsModifiedEuMultiplier");
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool IsModifiedEuOffset => !EuOffset.Equals(SelectedChannel?.UserOffsetEu);
|
|
|
|
private double _euOffset = 0D;
|
|
|
|
public double EuOffset
|
|
{
|
|
get => _euOffset;
|
|
set
|
|
{
|
|
if (value != _euOffset)
|
|
{
|
|
_euOffset = value;
|
|
OnPropertyChanged("EuOffset");
|
|
OnPropertyChanged("IsModifiedEuOffset");
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool IsModifiedT0 => !T0.Equals(0D);
|
|
|
|
private double _t0 = 0D;
|
|
|
|
public double T0
|
|
{
|
|
get => _t0;
|
|
set
|
|
{
|
|
if (value != _t0)
|
|
{
|
|
_t0 = value;
|
|
OnPropertyChanged("T0");
|
|
OnPropertyChanged("IsModifiedT0");
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool _isModified;
|
|
/// <summary>
|
|
/// indicates whether any values have changed from default for the selected channel
|
|
/// </summary>
|
|
public bool IsModified
|
|
{
|
|
|
|
get => _isModified;
|
|
|
|
private set
|
|
{
|
|
if (value != _isModified)
|
|
{
|
|
_isModified = value;
|
|
OnPropertyChanged("IsModified");
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool _isModifiedLineFit;
|
|
public bool IsModifiedLineFit
|
|
{
|
|
get
|
|
{
|
|
_isModifiedLineFit = !T1.Equals(0D) || !T2.Equals(0D);
|
|
return _isModifiedLineFit;
|
|
}
|
|
set
|
|
{
|
|
if (value != _isModifiedLineFit)
|
|
{
|
|
_isModifiedLineFit = value;
|
|
OnPropertyChanged("IsModifiedLineFit");
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Line fit start point (ms)
|
|
/// </summary>
|
|
private double _t1 = 0D;
|
|
|
|
public double T1
|
|
{
|
|
get => _t1;
|
|
set
|
|
{
|
|
if (!_t1.Equals(value))
|
|
{
|
|
_t1 = value;
|
|
OnPropertyChanged("T1");
|
|
OnPropertyChanged("IsModifiedLineFit");
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Line fit end point (ms)
|
|
/// </summary>
|
|
private double _t2 = 0D;
|
|
|
|
public double T2
|
|
{
|
|
get => _t2;
|
|
set
|
|
{
|
|
if (!_t2.Equals(value))
|
|
{
|
|
_t2 = value;
|
|
OnPropertyChanged("T2");
|
|
OnPropertyChanged("IsModifiedLineFit");
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool IsModifiedSensitivity => !Sensitivity.Equals(SelectedChannel?.Sensitivity);
|
|
|
|
private double _sensitivity = 0D;
|
|
|
|
public double Sensitivity
|
|
{
|
|
get => _sensitivity;
|
|
set
|
|
{
|
|
if (!_sensitivity.Equals(value))
|
|
{
|
|
_sensitivity = value;
|
|
OnPropertyChanged("Sensitivity");
|
|
OnPropertyChanged("IsModifiedSensitivity");
|
|
}
|
|
}
|
|
}
|
|
|
|
//FB 13120 updated the IsModifiedFilterto use filter class
|
|
public bool IsModifiedFilter
|
|
{
|
|
get
|
|
{
|
|
var sf = FilterClass.GetFilterClassFromString(SelectedChannel?.SoftwareFilter);
|
|
return !SelectedFilter.Equals(sf);
|
|
}
|
|
}
|
|
|
|
//FB 13120 selected filter
|
|
private IFilterClass _selectedFilter = new FilterClass(FilterClassType.Unfiltered);
|
|
public IFilterClass SelectedFilter
|
|
{
|
|
get => _selectedFilter;
|
|
set
|
|
{
|
|
if (!_selectedFilter.Equals(value))
|
|
{
|
|
_selectedFilter = value;
|
|
OnPropertyChanged("SelectedFilter");
|
|
OnPropertyChanged("IsModifiedFilter");
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// T0 Mode indicates whether T0 changes will be applied to DAS or test
|
|
/// </summary>
|
|
private T0Mode _t0Mode = T0Mode.Test;
|
|
|
|
public T0Mode T0Mode
|
|
{
|
|
get => _t0Mode;
|
|
set
|
|
{
|
|
var newValue = !IsT0ModeTestOnly ? value : T0Mode.Test;
|
|
if (newValue != _t0Mode)
|
|
{
|
|
_t0Mode = newValue;
|
|
OnPropertyChanged("T0Mode");
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool _isT0ModeTestOnly = false;
|
|
public bool IsT0ModeTestOnly
|
|
{
|
|
get => _isT0ModeTestOnly;
|
|
internal set
|
|
{
|
|
if (value != _isT0ModeTestOnly)
|
|
{
|
|
_isT0ModeTestOnly = value;
|
|
OnPropertyChanged("IsT0ModeTestOnly");
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool _enableSensitivityControl = true;
|
|
public bool EnableSensitivityControl
|
|
{
|
|
get => _enableSensitivityControl;
|
|
internal set
|
|
{
|
|
if (value != _enableSensitivityControl)
|
|
{
|
|
_enableSensitivityControl = value;
|
|
OnPropertyChanged("EnableSensitivityControl");
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool _enableLineFitControl = true;
|
|
public bool EnableLineFitControl
|
|
{
|
|
get => _enableLineFitControl;
|
|
internal set
|
|
{
|
|
if (value != _enableLineFitControl)
|
|
{
|
|
_enableLineFitControl = value;
|
|
OnPropertyChanged("EnableLineFitControl");
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool _enableEUOffsetControl = true;
|
|
public bool EnableEUOffsetControl
|
|
{
|
|
get => _enableEUOffsetControl;
|
|
internal set
|
|
{
|
|
if (value != _enableEUOffsetControl)
|
|
{
|
|
_enableEUOffsetControl = value;
|
|
OnPropertyChanged("EnableEUOffsetControl");
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool _enableEUMultiplierControl = true;
|
|
public bool EnableEUMultiplierControl
|
|
{
|
|
get => _enableEUMultiplierControl;
|
|
internal set
|
|
{
|
|
if (value != _enableEUMultiplierControl)
|
|
{
|
|
_enableEUMultiplierControl = value;
|
|
OnPropertyChanged("EnableEUMultiplierControl");
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool _enableFilterControl = true;
|
|
public bool EnableFilterControl
|
|
{
|
|
get => _enableFilterControl;
|
|
internal set
|
|
{
|
|
if (value != _enableFilterControl)
|
|
{
|
|
_enableFilterControl = value;
|
|
OnPropertyChanged("EnableFilterControl");
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool _enableDescriptionControl = true;
|
|
public bool EnableDescriptionControl
|
|
{
|
|
get => _enableDescriptionControl;
|
|
internal set
|
|
{
|
|
if (value != _enableDescriptionControl)
|
|
{
|
|
_enableDescriptionControl = value;
|
|
OnPropertyChanged("EnableDescriptionControl");
|
|
}
|
|
}
|
|
}
|
|
private bool _IsDataFlagEnabled = true;
|
|
public bool IsDataFlagEnabled
|
|
{
|
|
get => _IsDataFlagEnabled;
|
|
internal set
|
|
{
|
|
if (value != _IsDataFlagEnabled)
|
|
{
|
|
_IsDataFlagEnabled = value;
|
|
OnPropertyChanged("IsDataFlagEnabled");
|
|
}
|
|
}
|
|
}
|
|
private bool _IsT0Enabled = true;
|
|
public bool IsT0Enabled
|
|
{
|
|
get => _IsT0Enabled;
|
|
internal set
|
|
{
|
|
if (value != _IsT0Enabled)
|
|
{
|
|
_IsT0Enabled = value;
|
|
OnPropertyChanged("IsT0Enabled");
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool IsModifiedDataFlag => null != SelectedChannel && !SelectedDataFlag.Equals((DataFlag)SelectedChannel.DataFlag);
|
|
|
|
private DataFlag _dataFlag = DataFlag.None;
|
|
|
|
public DataFlag SelectedDataFlag
|
|
{
|
|
get => _dataFlag;
|
|
set
|
|
{
|
|
if (value != _dataFlag)
|
|
{
|
|
_dataFlag = value;
|
|
OnPropertyChanged("SelectedDataFlag");
|
|
OnPropertyChanged("IsModifiedDataFlag");
|
|
}
|
|
}
|
|
}
|
|
|
|
private ITestModificationViewModel _parent;
|
|
|
|
public ITestModificationViewModel Parent
|
|
{
|
|
get => _parent;
|
|
set
|
|
{
|
|
if (value != _parent)
|
|
{
|
|
_parent = value;
|
|
OnPropertyChanged("Parent");
|
|
}
|
|
}
|
|
}
|
|
|
|
///<summary>
|
|
///Occurs when a property value changes.
|
|
///</summary>
|
|
public event PropertyChangedEventHandler PropertyChanged;
|
|
|
|
public void OnPropertyChanged(string propertyName)
|
|
{
|
|
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
|
|
if (propertyName != "IsModified" && propertyName != "LineFitModified" && propertyName != "SelectedDataFlag")
|
|
{
|
|
IsModified = (IsModifiedDescription || IsModifiedEuMultiplier
|
|
|| IsModifiedEuOffset || IsModifiedFilter
|
|
|| IsModifiedLineFit || IsModifiedSensitivity || IsModifiedT0)
|
|
&& SelectedChannel != null; //can't modify nothing
|
|
}
|
|
|
|
if (propertyName == "IsT0ModeTestOnly")
|
|
{
|
|
T0Mode = _t0Mode; //if we've changed the global setting, run a check of the current mode
|
|
}
|
|
|
|
Parent?.PublishChanges();
|
|
}
|
|
|
|
public bool IsSaved { get; }
|
|
|
|
#endregion Properties
|
|
private DelegateCommand _UpdateDatabaseCommand;
|
|
public DelegateCommand UpdateDatabaseCommand => _UpdateDatabaseCommand ?? (_UpdateDatabaseCommand = new DelegateCommand(UpdateDatabaseMethod));
|
|
|
|
private void UpdateDatabaseMethod()
|
|
{
|
|
Parent.UpdateDatabaseMethod();
|
|
}
|
|
#region Functions
|
|
/// <summary>
|
|
/// returns true if T0 is valid
|
|
/// right now this just means T0 falls between the start and end of the current channel's dataset
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public bool ValidateT0()
|
|
{
|
|
var valid = true;
|
|
|
|
if (null == SelectedChannel) { return true; }
|
|
if (null == SelectedChannel.ParentModule) { return true; }
|
|
|
|
var startRecordSampleNumber = Convert.ToDecimal(SelectedChannel.ParentModule.StartRecordSampleNumber);
|
|
var triggerSampleNumber = Convert.ToDecimal(SelectedChannel.ParentModule.TriggerSampleNumbers[0]);
|
|
var totalSamples = Convert.ToDecimal(SelectedChannel.ParentModule.NumberOfSamples);
|
|
var sampleRate = Convert.ToDecimal(SelectedChannel.ParentModule.SampleRateHz);
|
|
|
|
//note that T0 is always in ms, so we just deal in ms here (sampleRate is hz[sps])
|
|
var startTime = -1000 * (triggerSampleNumber - startRecordSampleNumber) / sampleRate;
|
|
var endTime = 1000 * (totalSamples - triggerSampleNumber + startRecordSampleNumber) / sampleRate;
|
|
|
|
var t0 = Convert.ToDecimal(T0);
|
|
|
|
if (t0 < startTime || t0 > endTime) { return false; }
|
|
|
|
return valid;
|
|
}
|
|
#endregion Functions
|
|
}
|
|
}
|