private static double TestCWLAccuracy(ReferenceData referenceData, TestDataCollection testDataCollection, string testType, string temp, int port, string pSetting)
{
var testData = testDataCollection.GetTestData(testType, "Swept", "SweptPDL");
if (testData == null)
{
throw new MeasuringException("没有计算CWL所需测试数据");
}
var list = testData.GetDataList(temp, port);
if (list.Count < 1)
{
throw new MeasuringException("没有计算CWL所需测试数据");
}
var items = MeasuringManager.GetItemSettings(pSetting);
var type = GetSettingType(items);
var cw = GetSettingCenterWaveLength(items);
var db = GetSettingDB(items);
var wl = GetCenterWaveLength(list.ToList(), type, cw, db, bwSetting);
if (cw < 1 || wl == double.MinValue)
{
return(double.MinValue);
}
return(Math.Round(Math.Abs(wl - cw), 3));
}
private static List <double> GetRangeData(List <PointTestItem> data, string[] settings, int dataType)
{
var tempData = new List <double>();
var wls = new double[1];
var ranges = MeasuringManager.GetRangeSettings(settings[0]);
for (int i = 0; i < ranges.Length; i++)
{
var range = ranges[i];
if (range.Equals("itu", StringComparison.OrdinalIgnoreCase))
{
var type = GetSettingType(settings);
var cw = GetSettingCenterWaveLength(settings);
var db = GetSettingDB(settings);
var wl = GetCenterWaveLength(data, type, cw, db, bwSetting);
if (wl == double.MinValue)
{
throw new MeasuringException("ITU计算错误");
}
ranges[i] = wl.ToString();
}
}
if (ranges.Length > 1)
{
wls = new double[2];
wls[0] = MeasuringManager.GetWavelengthNm(ranges[0]);
if (settings[0].IndexOf("±") > -1)
{
wls = MeasuringManager.GetWavelengthRange(wls[0], "±", ranges[1]);
}
else
{
wls[1] = MeasuringManager.GetWavelengthNm(ranges[1]);
}
}
else
{
wls[0] = MeasuringManager.GetWavelengthNm(ranges[0]);
}
if (wls.Length > 1)
{
var wl1 = wls.Min();
var wl2 = wls.Max();
var taskData = TakeData(data, wl1, wl2);
tempData.AddRange(taskData.Select(q => GetPointItemValue(q, dataType)));
}
else
{
var wl = wls[0];
var taskData = GetPointItemSlopeValue(data, wl, dataType);
tempData.Add(taskData);
}
return(tempData);
}
private static double TestPointRL(ReferenceData referenceData, TestDataCollection testDataCollection, string testType, string temp, int port, string pSetting)
{
var rlTestData = testDataCollection.GetTestData(testType, "Point");
if (rlTestData == null)
{
throw new MeasuringException("没有计算RL所需测试数据");
}
var wl = pSetting.CastTo(double.MaxValue);
if (wl == double.MinValue)
{
throw new MeasuringException("波长设置错误");
}
var item = rlTestData.GetDataItem(temp, port, wl);
var refR = referenceData.GetReference(2, 1, wl);
if (item == null || refR == null)
{
throw new MeasuringException("没有计算RL所需测试数据");
}
var value = double.MinValue; //回损结果
var valueR = item.IL; //读取回损
var valueS = refR.IL; //系统回损
var AbsS = Math.Abs(valueS); //系统回损绝对值
if (Math.Abs(valueR) > AbsS)
{
//RL读取值小于系统值时候，
if (AbsS >= 60D)
{
value = 60d;
}
else if (AbsS >= 58D)
{
value = 58d;
}
else
{
value = Math.Round(AbsS, 1);
}
}
else
{
var cR = MeasuringManager.Convert_dBm2mW(valueR + Windows.IniProfile <BusinessLogic.Setting.SystemSetting> .Instance.Profile.RetrunLosssCompensation);
var cS = MeasuringManager.Convert_dBm2mW(valueS + Windows.IniProfile <BusinessLogic.Setting.SystemSetting> .Instance.Profile.RetrunLosssCompensation);
var rl = MeasuringManager.Convert_mW2dBm(cR - cS);
value = Math.Round(
Math.Min(Math.Abs(rl), AbsS),
1);
}
return(value);
}
public void SetSetting(string setting)
{
var testSetting = MeasuringManager.GetSettings(tbSetting.Text).ToList();
if (!testSetting.Exists(q => q.IndexOf(setting, StringComparison.OrdinalIgnoreCase) != -1))
{
testSetting.Add(setting);
}
tbSetting.Text = string.Join(",", testSetting);
}
private static List <double> GetSettingData(List <PointTestItem> data, string pSetting, int dataType = 0)
{
var datas = new List <double>();
foreach (var setting in MeasuringManager.GetParallelSettings(pSetting))
{
var items = MeasuringManager.GetItemSettings(setting);
datas.AddRange(GetRangeData(data, items, dataType));
}
return(datas);
}
private string FormatDefaultSetting(string setting, double[] wls, SpecInfo specInfo)
{
var newSetting = setting;
var matchs = setting.Matches(@"\{([^{]*)\}");
foreach (System.Text.RegularExpressions.Match match in matchs)
{
var text = match.Groups[0].Value;
var tag = match.Groups[1].Value;
var value = MeasuringManager.GetFormatTag(tag, wls);
newSetting = newSetting.Replace(text, value);
}
return(newSetting);
}
private static double GetSettingDB(string[] settings)
{
var setting = settings.FirstOrDefault(
q => q.EndsWith("db", StringComparison.OrdinalIgnoreCase));
if (string.IsNullOrEmpty(setting))
{
setting = settings.FirstOrDefault(q => q.IsDouble() && q.CastTo(double.MinValue) <= 100D);
}
if (string.IsNullOrEmpty(setting))
{
return(3D);
}
return(MeasuringManager.FormatSetting(setting).CastTo(3D));
}
public static void Regisry()
{
if (IsRegisred)
{
return;
}
IsRegisred = true;
MeasuringManager.RegisryCalculate("TestPointIL", TestPointIL);
MeasuringManager.RegisryCalculate("TestPointPDL", TestPointPDL);
MeasuringManager.RegisryCalculate("TestPointEL", TestPointEL);
MeasuringManager.RegisryCalculate("TestPointCR", TestPointCR);
MeasuringManager.RegisryCalculate("TestPointUniformity", TestPointUniformity);
MeasuringManager.RegisryCalculate("TestPointWDL", TestPointWDL);
MeasuringManager.RegisryCalculate("TestPointTDL", TestPointTDL);
MeasuringManager.RegisryCalculate("TestPointRL", TestPointRL);
}
private static double GetPointItemSlopeValue(List <PointTestItem> data, double wl, int dataType)
{
if (data.Count < 2)
{
return(double.MinValue);
}
var waveLengthStep = Math.Round(data[1].WaveLength - data[0].WaveLength, 3);
var minWaveLength = data[0].WaveLength;
var maxWaveLength = data[data.Count - 1].WaveLength;
if (wl < minWaveLength || wl > maxWaveLength || waveLengthStep == 0D)
{
return(double.MinValue);
}
var interval = Math.Round(wl - minWaveLength, 3);
var diffWL = Math.Round((interval * 1000D) % (waveLengthStep * 1000D) / 1000D, 3);
var index = (int)Math.Truncate(interval / waveLengthStep);
var result = double.MinValue;
if (diffWL == 0D)
{
result = GetPointItemValue(data[index], dataType);
}
else
{
if (index + 1 >= data.Count)
{
result = GetPointItemValue(data[data.Count - 1], 0);
}
else
{
result = MeasuringManager.GetSlopeValue(
0,
GetPointItemValue(data[index], dataType),
waveLengthStep,
GetPointItemValue(data[index + 1], dataType),
diffWL);
}
}
return(result == double.MinValue ? result : Math.Round(result, 3));
}
private static double TestChannelUniformity(ReferenceData referenceData, TestDataCollection testDataCollection, string testType, string temp, int port, string pSetting)
{
var testData = testDataCollection.GetTestData(testType, "Swept", "SweptPDL");
if (testData == null)
{
throw new MeasuringException("没有计算Uniformity所需测试数据");
}
var list = new List <double>();
var parallels = MeasuringManager.GetParallelSettings(pSetting);
foreach (var parallel in parallels)
{
var items = MeasuringManager.GetItemSettings(parallel);
var sport = GetSetingPort(items);
var data = testData.GetData(temp, sport).Values.ToList();
if (data.Count < 1)
{
throw new MeasuringException("没有计算Uniformity所需测试数据");
}
var tempData = GetRangeData(data, items, 0);
if (tempData.Count < 1)
{
throw new MeasuringException("没有计算Uniformity所需测试数据");
}
list.Add(tempData.Min());
}
if (list.Count < 1)
{
throw new MeasuringException("没有计算Uniformity所需测试数据");
}
var max = list.Max();
var min = list.Min();
if (max == double.MinValue || min == double.MinValue)
{
return(double.MinValue);
}
return(Math.Abs(Math.Round(max - min, 3)));
}
public string[] GetSetting(bool withCheck = true)
{
var settings = MeasuringManager.GetSettings(tbSetting.Text);
if (!withCheck)
{
return(settings);
}
foreach (var setting in settings)
{
var errorString = string.Empty;
if (!MeasuringManager.CheckSetting(BindingTestSystem.SystemTypeID, setting, out errorString))
{
tbSetting.Focus();
throw new Exception(string.Format("{0} 设置 {1} 格式错误,\r\n{2},请检查设置。", BindingTestSystem.SystemName, setting, errorString));
}
}
return(settings);
}
public static void Regisry()
{
if (IsRegisred)
{
return;
}
IsRegisred = true;
MeasuringManager.RegisryCalculate("TestCWL", TestCWL);
MeasuringManager.RegisryCalculate("TestCWLAccuracy", TestCWLAccuracy);
MeasuringManager.RegisryCalculate("TestBandwidth", TestBandwidth);
MeasuringManager.RegisryCalculate("TestRipple", TestRipple);
MeasuringManager.RegisryCalculate("TestInsertionLoss", TestInsertionLoss);
MeasuringManager.RegisryCalculate("TestPeakIL", TestPeakIL);
MeasuringManager.RegisryCalculate("TestIsolation", TestIsolation);
MeasuringManager.RegisryCalculate("TestChannelUniformity", TestChannelUniformity);
MeasuringManager.RegisryCalculate("TestChipUniformity", TestChipUniformity);
MeasuringManager.RegisryCalculate("TestPolarizationDependentLoss", TestPolarizationDependentLoss);
MeasuringManager.RegisryCalculate("TestReturnLossOut", TestReturnLoss);
}
private static double GetWaveLength(List <PointTestItem> data, double findIL, bool dir, int centerIndex)
{
var items = (dir ? data.Take(centerIndex).Reverse() : data.Skip(centerIndex)).ToList();
var w1 = 0D;
var l1 = 0D;
var w2 = 0D;
var l2 = 0D;
var finded = false;
w2 = items[0].WaveLength;
l2 = GetPointItemValue(items[0], 0);
foreach (var item in items)
{
w1 = item.WaveLength;
l1 = GetPointItemValue(item, 0);
finded =
findIL <= Math.Max(l1, l2) &&
findIL >= Math.Min(l1, l2);
if (finded)
{
break;
}
w2 = w1;
l2 = l1;
}
if (!finded)
{
return(double.MinValue);
}
w1 = MeasuringManager.GetSlopeValue(l1, w1, l2, w2, findIL);
return(Math.Round(w1, 3));
}
private static double TestBandwidth(ReferenceData referenceData, TestDataCollection testDataCollection, string testType, string temp, int port, string pSetting)
{
var testData = testDataCollection.GetTestData(testType, "Swept", "SweptPDL");
if (testData == null)
{
throw new MeasuringException("没有计算Bandwidth所需测试数据");
}
var list = testData.GetDataList(temp, port);
if (list.Count < 1)
{
throw new MeasuringException("没有计算Bandwidth所需测试数据");
}
var items = MeasuringManager.GetItemSettings(pSetting);
var type = GetSettingType(items);
var cw = GetSettingCenterWaveLength(items);
var db = GetSettingDB(items);
var wl = GetBandwidth(list.ToList(), type, cw, db, bwSetting);
return(wl);
}
private MeasurementTestResult Calculate(Guid specItemID, out WorkInfoSpecItem item)
{
item = MeasurementJob.SpecData.WorkInfoSpecItems.FirstOrDefault(q => q.SpecItemID == specItemID);
if (item == null)
{
return(new MeasurementTestResult()
{
Result = -1,
Message = "规格异常",
Data = 0D
});
}
var testResult = MeasuringManager.Calculate(
MeasurementJob.ReferenceData,
TestData,
item.SystemTypeID,
item.TestGroupTestType,
item.TestTemp,
item.PortSetting,
item.TestSetting
);
if (testResult.Result < 1)
{
return(testResult);
}
if (testResult.Data == double.MinValue)
{
testResult.Result = -1;
testResult.Message = "计算结果出错";
return(testResult);
}
testResult.Result = 0;
foreach (var resultSetting in BaseSettingsManager.Get <ResultSettings>().NeedSettingResult.OrderBy(q => q.ResultID))
{
ComputeSettingItem computeItem = default(ComputeSettingItem);
if (!item.ComputeSetting.TryGetValue(resultSetting.ResultID, out computeItem))
{
testResult.Result = -1;
testResult.Message = "规格判断标准设置错误";
return(testResult);
}
if (string.IsNullOrEmpty(computeItem.ComputeValue))
{
continue;
}
if (OperatorManager.GetOperator(computeItem.ComputeSign).GetComputeResult(computeItem.ComputeValue, testResult.Data))
{
testResult.Result = resultSetting.ResultID;
testResult.Message = $"{item.ItemName} 通过";
}
else
{
testResult.Message = "结果不符合规格";
}
}
return(testResult);
}
private string GetTagValue(string tag)
{
var temp = 0;
var round = -1;
var port = int.MinValue;
var dataType = 0;
var tagString = tag;
var stringTemp = "";
tagString = GetRound(tagString, out round);
tagString = GetTemperature(tagString, out temp);
tagString = GetPort(tagString, out port);
tagString = GetDataType(tagString, out dataType);
if (dataType == int.MinValue)
{
return(tagString);
}
if (temp > tempSetting.Length)
{
return("");
}
else if (temp >= 0)
{
stringTemp = tempSetting[temp];
}
//测试项目有相同项目
var testedData = testInfo.TestItems.Where(
q => q.ItemName == tagString &&
(string.IsNullOrEmpty(stringTemp) || q.TestTemp == stringTemp) &&
(port == int.MinValue || BaseSettingsManager.Get <SystemGroupSetting>().GetTestSystemItem(q.SystemID).PortSetting == port)
).ToList();
if (testedData.Count > 0)
{
return(GetTestValue(testedData, dataType, round));
}
var setting = "";
var tagItem = GetSetting(tagString, out setting);
var testSystem = BaseSettingsManager.Get <SystemGroupSetting>().GetTestSystemItem(classID, tagItem, port);
if (testSystem == null)
{
return("");
}
//测试项目设置符合条件
testedData = testInfo.TestItems.Where(
q =>
q.SystemID == testSystem.SystemID &&
(string.IsNullOrEmpty(setting) || q.TestInfo == setting) &&
(string.IsNullOrEmpty(stringTemp) || q.TestTemp == stringTemp)).ToList();
if (testedData != null)
{
return(GetTestValue(testedData, dataType, round));
}
//重新计算结果
try
{
var testGroup = BaseSettingsManager.Get <SystemGroupSetting>().GetTestSystemGroup(testSystem.TestGroupID);
if (testGroup == null)
{
return("");
}
var value = MeasuringManager.Calculate(referenceData, collection, testSystem.SystemTypeID, testGroup.TestGroupTestType, stringTemp, testSystem.PortSetting, setting);
if (value.Result > -1 && value.Data != double.MinValue)
{
return(round < 0 ? value.Data.ToString() : Math.Round(value.Data, round).ToString());
}
}
catch (Exception ex)
{
Incht.Common.Log.LogHelper.WriteLog("TemplateData", ex);
}
return("");
}
public void LoadData(Guid pSystemID, Guid pTestGroupID, Action cback = null)
{
this.GetService <ModifyTestSystem>().ExecuteAsync(
c => c.GetData(pSystemID),
(result) =>
{
if (!result.Status)
{
AppFramework.Context.ShowError(result.Message);
this.Close();
return;
}
callback = cback;
vm.Model.SystemID = result.Data.SystemID;
vm.Model.SystemName = result.Data.SystemName;
vm.Model.DisplayName = result.Data.DisplayName;
vm.Model.DefaultSetting = result.Data.DefaultSetting;
vm.Model.PortSetting = result.Data.PortSetting;
vm.Model.OrderID = result.Data.OrderID;
//设置窗体标题
if (pSystemID == Guid.Empty)
{
result.Data.TestGroupID = pTestGroupID;
this.Text = "添加测试项";
}
else
{
pTestGroupID = result.Data.TestGroupID;
this.Text = $"修改测试项 - {result.Data.SystemName}";
}
vm.Render(panelContent, new Padding(0, 15, 15, 0), "30%", true,
(name, control) =>
{
if (name == "OrderID")
{
(control as NumericUpDown).Maximum = 10000;
}
},
(name, control) =>
{
switch (name)
{
case "SystemTypeID":
(control as ComboBox).UpdateDataSource(MeasuringManager.GetCalculateDataSource(), result.Data.SystemTypeID, (value) => {
vm.Model.SystemTypeID = value;
});
break;
case "DefaultComputeSign":
(control as ComboBox).UpdateDataSource(OperatorManager.GetComputeDataSource(), result.Data.DefaultComputeSign, (value) => {
vm.Model.DefaultComputeSign = value;
});
break;
case "TestGroupID":
var cb = (control as ComboBox);
this.GetService <ModifyTestSystem>().ExecuteAsync(c => c.GetTestGroupDataSource(pTestGroupID)
, (source) =>
{
if (!source.Status)
{
return;
}
cb.UpdateDataSource(source.Data, result.Data.TestGroupID, (value) => {
vm.Model.TestGroupID = value;
});
});
break;
case "TemperatureSetting":
var ds4 = new BindingList <KeyValuePair <int, string> >();
ds4.Add(new KeyValuePair <int, string>(0, "多温度测试"));
ds4.Add(new KeyValuePair <int, string>(1, "常温测试"));
(control as ComboBox).UpdateDataSource(ds4, result.Data.TemperatureSetting, (value) => {
vm.Model.TemperatureSetting = value;
});
break;
}
});
});
}
private void GetTestSystemItemControlsSpecItems(List <SpecItem> newSpecItems)
{
var tempSetting = specInfo.TempSetting.Split(",");
var testSystemGroups = BaseSettingsManager.Get <SystemGroupSetting>().GetTestGroupByProductClass(classID);
var groups = SystemGroupSetting.GroupSystemByTempGroup(testSystemGroups);
foreach (var group in groups)
{ //规格组
for (int temp = 0; temp < tempSetting.Length; temp++)
{ //温度
var tempstring = tempSetting[temp];
if (string.IsNullOrEmpty(tempstring))
{
continue;
}
foreach (var systemGroup in group.Value)
{//测试组
var list = new List <SpecItem>();
foreach (var testSystem in BaseSettingsManager.Get <SystemGroupSetting>().GetTestItemByGroup(systemGroup.TestGroupID))
{//测试指标
if (testSystem.TemperatureSetting != 0 && temp > 0)
{
continue;
}
var testSystemItemControl = GetTestSystemItemControl(testSystem.SystemID);
if (testSystemItemControl == null)
{
continue;
}
var settings = testSystemItemControl.GetSetting();
if (settings == null || settings.Length < 1)
{
continue;
}
var specs = testSystemItemControl.GetSpec(temp);
if (specs == null)
{
continue;
}
if (specs.Count < 1)
{
continue;
}
foreach (var setting in settings)
{
if (string.IsNullOrEmpty(setting))
{
continue;
}
var olditem = specInfo.SpecItems.FirstOrDefault(
q => q.SystemID == testSystem.SystemID &&
q.TestTemp == tempstring &&
q.TestInfo == setting
);
if (olditem != null &&
(newSpecItems.Any(q => q.SpecItemID == olditem.SpecItemID) ||
list.Any(q => q.SpecItemID == olditem.SpecItemID)))
{
olditem = null;
}
list.Add(
new SpecItem()
{
SpecItemID = olditem == null ? Guid.NewGuid() : olditem.SpecItemID,
SeqID = specInfo.SeqID,
SystemID = testSystem.SystemID,
ItemName = MeasuringManager.GetSettingItemName(testSystem.DisplayName, setting, testSystem.PortSetting),
TestTemp = tempstring,
TestInfo = setting,
ComputeSetting = specs.ToJsonString(),
OrderID = list.Count + 1
});
}
}
/*
* if (systemGroup.TestGroupTestType == "Point" ||
* systemGroup.TestGroupTestType == "PointPDL" ||
* systemGroup.TestGroupTestType == "RL")
* {
* list.Sort((x, y) =>
* {
* var compare = x.TestInfo.CompareTo(y.TestInfo);
* if (compare == 0)
* compare = x.OrderID.CompareTo(y.OrderID);
* return compare;
* });
* }
*/
foreach (var item in list)
{
item.OrderID = newSpecItems.Count + 1;
newSpecItems.Add(item);
}
}
}
}
}
private static double TestPointCR(ReferenceData referenceData, TestDataCollection testDataCollection, string testType, string temp, int port, string pSetting)
{
var pointTestData = testDataCollection.GetTestData(testType, "Point", "PointPDL");
if (pointTestData == null)
{
throw new MeasuringException("没有计算CR所需测试数据");
}
/*
* var wl = pSetting.CastTo(double.MinValue);
* if (wl == double.MinValue)
* throw new MeasuringException("波长设置错误");
*
* var item = pointTestData.GetDataItem(temp, port, wl);
* if (item == null)
* {
* throw new MeasuringException("没有计算CR所需测试数据");
* }
* var refpower = referenceData.GetReference(1, port, wl);
* var power = item.Power + Windows.IniProfile<BusinessLogic.Setting.SystemSetting>.Instance.Profile.ExtraLosssCompensation;
* var cr = MeasuringManager.Convert_dBm2mW(power - refpower.Power);
* cr = Math.Round(cr * 100D, 2);
*/
var wl = pSetting.CastTo(double.MaxValue);
if (wl == double.MinValue)
{
throw new MeasuringException("波长设置错误");
}
var testData = pointTestData.GetTestData();
if (!testData.ContainsKey(temp))
{
throw new MeasuringException("没有计算CL所需测试数据");
}
var data = testData[temp];
var inPower = 0D;
var allPower = 0D;
var setting = TestPortSetting.Get(port);
foreach (var item in data)
{
var ch = item.Key;
if (ch < 1 || !item.Value.ContainsKey(wl))
{
continue;
}
var chSetting = TestPortSetting.Get(ch);
if (chSetting.DataID != setting.DataID)
{
continue;
}
var testItem = item.Value[wl];
if (testItem.Power == double.MinValue)
{
continue;
}
var power = MeasuringManager.Convert_dBm2mW(testItem.IL);
if (port == ch)
{
inPower = power;
}
allPower += power;
}
var cr = allPower == 0D ? 0D : inPower / allPower;
cr = Math.Round(cr * 100D, 2);
return(cr);
}
private void btSave_Click(object sender, EventArgs e)
{
var computeSetting = new Dictionary <int, ComputeSettingItem>();
var sign = cbSpec.SelectedValue;
if (sign == null)
{
AppFramework.Context.ShowError("请选择规格符号！");
return;
}
foreach (var item in tbSpecs)
{
var value = item.Value.Text;
var specCompute = OperatorManager.GetOperator(sign.ToString());
if (!specCompute.Validation(value))
{
AppFramework.Context.ShowError("规格设置格式错误,请检查。");
return;
}
computeSetting[item.Key] = new ComputeSettingItem()
{
ComputeSign = sign.ToString(),
ComputeValue = value
};
}
vm.Model.ComputeSetting = computeSetting.ToJsonString();
var testSystem = BaseSettingsManager.Get <SystemGroupSetting>().GetTestSystemItem(vm.Model.SystemID);
if (testSystem == null)
{
AppFramework.Context.ShowError("测试系统不存在！");
return;
}
var errroString = "";
if (!MeasuringManager.CheckSetting(testSystem.SystemTypeID, vm.Model.TestInfo, out errroString))
{
AppFramework.Context.ShowError(errroString);
return;
}
vm.Model.ItemName = MeasuringManager.GetSettingItemName(testSystem.DisplayName, vm.Model.TestInfo, testSystem.PortSetting);
var validate = vm.Validate();
if (validate.HasError)
{
validate.ShowErrorMessage("保存失败");
return;
}
var specitem = new SpecItem();
specitem.SpecItemID = vm.Model.SpecItemID;
specitem.SeqID = vm.Model.SeqID;
specitem.SystemID = vm.Model.SystemID;
specitem.ItemName = vm.Model.ItemName;
specitem.TestTemp = vm.Model.TestTemp;
specitem.TestInfo = vm.Model.TestInfo;
specitem.ComputeSetting = vm.Model.ComputeSetting;
specitem.OrderID = vm.Model.OrderID;
AppFramework.Context.ShowAlert("更新成功", "更新项目");
callback?.Invoke(specitem);
this.Close();
}
private static double TestPointEL(ReferenceData referenceData, TestDataCollection testDataCollection, string testType, string temp, int port, string pSetting)
{
var pointTestData = testDataCollection.GetTestData(testType, "Point", "PointPDL");
if (pointTestData == null)
{
throw new MeasuringException("没有计算EL所需测试数据");
}
var wl = pSetting.CastTo(double.MaxValue);
if (wl == double.MinValue)
{
throw new MeasuringException("波长设置错误");
}
var testData = pointTestData.GetTestData();
if (!testData.ContainsKey(temp))
{
throw new MeasuringException("没有计算EL所需测试数据");
}
var data = testData[temp];
var allPower = 0D;
var inPower = 0D;
var count = 0;
var setting = TestPortSetting.Get(port);
foreach (var item in data)
{
var ch = item.Key;
if (ch < 1 || !item.Value.ContainsKey(wl))
{
continue;
}
var chSetting = TestPortSetting.Get(ch);
if (chSetting.DataID != setting.DataID)
{
continue;
}
var testItem = item.Value[wl];
if (testItem.Power == double.MinValue)
{
continue;
}
var refpower = referenceData.GetReference(1, ch % TestPortSetting.DataDivide, wl);
allPower += MeasuringManager.Convert_dBm2mW(testItem.Power);
inPower += refpower.Power;
count++;
}
allPower = MeasuringManager.Convert_mW2dBm(allPower) + Windows.IniProfile <BusinessLogic.Setting.SystemSetting> .Instance.Profile.ExtraLosssCompensation;
inPower = inPower / count;
var value = inPower == double.MinValue ?
double.MinValue :
Math.Abs(Math.Round(allPower - inPower, 3));
return(value);
}
private static double TestChipUniformity(ReferenceData referenceData, TestDataCollection testDataCollection, string testType, string temp, int port, string pSetting)
{
var testData = testDataCollection.GetTestData(testType, "Swept", "SweptPDL");
if (testData == null)
{
throw new MeasuringException("没有计算Uniformity所需测试数据");
}
if (uniformity == null)
{
if (System.IO.File.Exists(uniformityFile))
{
var data = System.IO.File.ReadAllText(uniformityFile);
try
{
uniformity = data.FromJsonString <Dictionary <string, List <double> > >();
}
catch
{
}
}
if (uniformity == null)
{
uniformity = new Dictionary <string, List <double> >();
}
}
if (!uniformity.ContainsKey(pSetting))
{
uniformity[pSetting] = new List <double>();
}
var list = uniformity[pSetting];
if (list.Count >= Windows.IniProfile <BusinessLogic.Setting.SystemSetting> .Instance.Profile.ChipCount)
{
list.RemoveAt(0);
}
var parallels = MeasuringManager.GetParallelSettings(pSetting);
foreach (var parallel in parallels)
{
var items = MeasuringManager.GetItemSettings(parallel);
var sport = GetSetingPort(items);
var data = testData.GetData(temp, sport).Values.ToList();
if (data.Count < 1)
{
throw new MeasuringException("没有计算Uniformity所需测试数据");
}
var tempData = GetRangeData(data, items, 0);
if (tempData.Count < 1)
{
throw new MeasuringException("没有计算Uniformity所需测试数据");
}
list.Add(tempData.Min());
}
if (list.Count < 1)
{
throw new MeasuringException("没有计算Uniformity所需测试数据");
}
try
{
System.IO.File.WriteAllText(uniformityFile, uniformity.ToJsonString());
}
catch
{
}
var max = list.Max();
var min = list.Min();
if (max == double.MinValue || min == double.MinValue)
{
return(double.MinValue);
}
return(Math.Abs(Math.Round(max - min, 3)));
}
