/// <summary>
/// 计算圈数
/// </summary>
/// <param name="obj"></param>
private void CheckQs(object obj)
{
try
{
int intFirst = (int)obj;
for (int i = intFirst; i < intFirst + 10; i++)
{
lock (LocdedQs)
{
if (i >= Dgv_Wc.Rows.Count)
{
AsyncOpDone.Set();
return;
}
StPlan_WcPoint _Item = (StPlan_WcPoint)_DnbGroup.CheckPlan[(int)Dgv_Wc.Rows[i].Tag];
_Item.SetLapCount(_DnbGroup.MinConst, _FirstConst, _FirstIb, _xIb, _Qs);
Dgv_Wc.Rows[i].Cells[0].Value = _Item.LapCount; //圈数
Dgv_Wc.Rows[i].Cells[0].Tag = _Item.LapCount; //保存一个副本
}
}
AsyncOpDone.Set();
}
catch
{
AsyncOpDone.Set();
return;
}
}
/// <summary>
/// 移除一个检定点
/// </summary>
/// <param name="PrjID">项目编号</param>
public void RemovePoint(string PrjID)
{
for (int _i = 0; _i < LstCheckPoint.Count; _i++)
{
if (PrjID == LstCheckPoint[_i].PrjID)
{
StPlan_WcPoint _Point = LstCheckPoint[_i];
LstCheckPoint.Remove(_Point);
}
}
return;
}
/// <summary>
/// 设置不平衡负载与平衡负载只差标志
/// </summary>
/// <param name="PrjID"></param>
/// <returns></returns>
public bool SetFHCYn(string PrjID)
{
for (int _i = 0; _i < LstCheckPoint.Count; _i++)
{
if (PrjID == LstCheckPoint[_i].PrjID)
{
StPlan_WcPoint stWc = LstCheckPoint[_i];
stWc.Dif_Err_Flag = 1;
LstCheckPoint.RemoveAt(_i);
LstCheckPoint.Insert(_i, stWc);
return(true);
}
}
return(false);
}
/// <summary>
/// 加载方案XML文档
/// </summary>
private void Load()
{
LstCheckPoint = new List <StPlan_WcPoint>();
clsXmlControl _XmlNode = new clsXmlControl(_FAPath);
if (_XmlNode.Count() == 0)
{
return;
}
string[] _TmpArr = _XmlNode.AttributeValue("", "QSCZ", "QS", "CzWcLimit");
Qscz = _TmpArr[0];
Czqs = int.Parse(_TmpArr[1]);
if (_TmpArr[2] != "")
{
CzWcLimit = _TmpArr[2];
}
for (int _i = 1; _i < 9; _i++) //功率方向1，2，3，4,5,6,7,8
{
XmlNode _Xml = _XmlNode.toXmlNode();
_Xml = clsXmlControl.FindSencetion(_Xml, clsXmlControl.XPath(string.Format("R,GLFX,{0}", _i.ToString())));
if (_Xml == null)
{
continue;
}
GlfxYj[_i - 1] = true;
for (int _j = 0; _j < _Xml.ChildNodes.Count; _j++)
{
StPlan_WcPoint _Point = new StPlan_WcPoint();
_Point.PrjID = _Xml.ChildNodes[_j].Attributes["PrjID"].Value;
_Point.PrjName = _Xml.ChildNodes[_j].Attributes["PrjName"].Value;
_Point.PowerYinSu = _Xml.ChildNodes[_j].Attributes["GLYS"].Value;
_Point.PowerDianLiu = _Xml.ChildNodes[_j].Attributes["xIb"].Value;
if (_Xml.ChildNodes[_j].Attributes.Count > 5)
{
_Point.Dif_Err_Flag = int.Parse(_Xml.ChildNodes[_j].Attributes["FHC"].Value);
}
LstCheckPoint.Add(_Point);
}
}
return;
}
/// <summary>
/// 获取误差限
/// </summary>
/// <param name="obj"></param>
private void CheckWcLimit(object obj)
{
int intFirst = (int)obj;
try
{
for (int i = intFirst; i < intFirst + 10; i++)
{
lock (LockedWcLimit)
{
if (i >= Dgv_Wc.Rows.Count)
{
AsyncOpDone.Set();
return;
}
StPlan_WcPoint _Item = (StPlan_WcPoint)_DnbGroup.CheckPlan[(int)Dgv_Wc.Rows[i].Tag];
_Item.SetWcx(_WcLimitName, _FirstGuiCheng, _FirstDj, _FirstHgq);
Dgv_Wc.Rows[i].Cells[1].Value = _Item.ErrorShangXian; //上线
Dgv_Wc.Rows[i].Cells[3].Value = _Item.ErrorXiaXian; //下限
Dgv_Wc.Rows[i].Cells[2].Value = _Item.ErrorShangXian * _DnbGroup.WcxUpPercent;
Dgv_Wc.Rows[i].Cells[4].Value = _Item.ErrorShangXian * _DnbGroup.WcxDownPercent;
}
}
AsyncOpDone.Set();
}
catch
{
AsyncOpDone.Set();
}
}
/// <summary>
/// 方案加载
/// </summary>
/// <param name="FaItem">方案项目</param>
public void LoadFA(CLDC_DataCore.Model.Plan.Plan_WcPoint FaItem)
{
base.FaName = FaItem.Name;
Cmb_Fa.SelectedIndex = 0;
try
{
Cmb_Fa.Text = FaItem.Name;
}
catch
{
Cmb_Fa.SelectedIndex = 0;
}
if (FaItem.Count > 0)
{
StPlan_WcPoint _Item = FaItem.getCheckPoint(0);
switch (_Item.PowerFangXiang)
{
case CLDC_Comm.Enum.Cus_PowerFangXiang.正向有功:
this.ToolGLFX_Click(Tab_Pz, new EventArgs());
break;
case CLDC_Comm.Enum.Cus_PowerFangXiang.反向有功:
this.ToolGLFX_Click(Tab_Pf, new EventArgs());
break;
case CLDC_Comm.Enum.Cus_PowerFangXiang.正向无功:
this.ToolGLFX_Click(Tab_Qz, new EventArgs());
break;
case CLDC_Comm.Enum.Cus_PowerFangXiang.反向无功:
this.ToolGLFX_Click(Tab_Qf, new EventArgs());
break;
case CLDC_Comm.Enum.Cus_PowerFangXiang.第一象限无功:
this.ToolGLFX_Click(Tab_Q1, new EventArgs());
break;
case CLDC_Comm.Enum.Cus_PowerFangXiang.第二象限无功:
this.ToolGLFX_Click(Tab_Q2, new EventArgs());
break;
case CLDC_Comm.Enum.Cus_PowerFangXiang.第三象限无功:
this.ToolGLFX_Click(Tab_Q3, new EventArgs());
break;
case CLDC_Comm.Enum.Cus_PowerFangXiang.第四象限无功:
this.ToolGLFX_Click(Tab_Q4, new EventArgs());
break;
}
}
else
{
this.ToolGLFX_Click(Tab_Pz, new EventArgs());
}
this.Cmb_xIb.Text = FaItem.Qscz; //参照电流
this.Txt_Qs.Text = FaItem.Czqs.ToString(); //参照圈数
this.Cmb_WcLimit.Text = FaItem.CzWcLimit; //参照误差限
this.Cmb_CheckOutTime.Text = FaItem.CzCheckOutTime;
#region --------设置功率方向按钮样式-------------
this.SetGlfxImageStyle(FaItem.YaoJianGlfx(CLDC_Comm.Enum.Cus_PowerFangXiang.正向有功), Tab_Pz);
this.SetGlfxImageStyle(FaItem.YaoJianGlfx(CLDC_Comm.Enum.Cus_PowerFangXiang.反向有功), Tab_Pf);
this.SetGlfxImageStyle(FaItem.YaoJianGlfx(CLDC_Comm.Enum.Cus_PowerFangXiang.正向无功), Tab_Qz);
this.SetGlfxImageStyle(FaItem.YaoJianGlfx(CLDC_Comm.Enum.Cus_PowerFangXiang.反向无功), Tab_Qf);
this.SetGlfxImageStyle(FaItem.YaoJianGlfx(CLDC_Comm.Enum.Cus_PowerFangXiang.第一象限无功), Tab_Q1);
this.SetGlfxImageStyle(FaItem.YaoJianGlfx(CLDC_Comm.Enum.Cus_PowerFangXiang.第二象限无功), Tab_Q2);
this.SetGlfxImageStyle(FaItem.YaoJianGlfx(CLDC_Comm.Enum.Cus_PowerFangXiang.第三象限无功), Tab_Q3);
this.SetGlfxImageStyle(FaItem.YaoJianGlfx(CLDC_Comm.Enum.Cus_PowerFangXiang.第四象限无功), Tab_Q4);
#endregion
if (this.WcSetup_H != null)
{
this.WcSetup_H.SetWcChecked(FaItem);
}
if (this.WcSetup_A != null)
{
this.WcSetup_A.SetWcChecked(FaItem);
}
if (this.WcSetup_B != null)
{
this.WcSetup_B.SetWcChecked(FaItem);
}
if (this.WcSetup_C != null)
{
this.WcSetup_C.SetWcChecked(FaItem);
}
}
/// <summary>
/// 刷新数据列表
/// </summary>
private void RefreshGrid(CLDC_DataCore.Model.DnbModel.DnbGroupInfo MeterGroup, int CheckOrderID)
{
_DnbGroup = MeterGroup;
int FirstYJMeter = Main.GetFirstYaoJianMeterIndex(MeterGroup);
if (CheckOrderID >= MeterGroup.CheckPlan.Count ||
!(MeterGroup.CheckPlan[CheckOrderID] is StPlan_WcPoint))
{
return;
}
StPlan_WcPoint _Item = (StPlan_WcPoint)MeterGroup.CheckPlan[CheckOrderID];
#region ---------------------动态创建数据表格样式-------------------------------
if (_Item.ToString().IndexOf("FHC") != -1)
{
//带分合差列样式
if (Data_Error.Columns.Count != MeterGroup.WcCheckNumic + 7) //如果误差数据表格的列数大于默认列数，则需要删除大于部分
{
for (int i = Data_Error.Columns.Count - 1; i >= 4; i--)
{
Data_Error.Columns.RemoveAt(i);
}
for (int i = 0; i < MeterGroup.WcCheckNumic; i++)
{
Data_Error.Columns.Add("Tmp_Col" + i.ToString(), "误差" + (i + 1).ToString());
}
Data_Error.Columns.Add("Tmp_Pj", "平均值");
Data_Error.Columns.Add("Tmp_Hz", "化整值");
Data_Error.Columns.Add("Tmp_FhcRand", "差值上下限");
Data_Error.Columns.Add("Tmp_Fhc", "差值");
this.CreateColumnStyle(); //创建表格列样式
}
}
else if (_Item.ToString().IndexOf("标准偏差") == -1) //如果不是标准偏差
{ //普通误差样式
if (Data_Error.Columns.Count != MeterGroup.WcCheckNumic + 6) //如果误差数据表格的列数大于默认列数，则需要删除大于部分
{
for (int i = Data_Error.Columns.Count - 1; i >= 4; i--)
{
Data_Error.Columns.RemoveAt(i);
}
for (int i = 0; i < MeterGroup.WcCheckNumic; i++)
{
Data_Error.Columns.Add("Tmp_Col" + i.ToString(), "误差" + (i + 1).ToString());
}
Data_Error.Columns.Add("Tmp_Pj", "平均值");
Data_Error.Columns.Add("Tmp_Hz", "化整值");
this.CreateColumnStyle(); //创建表格列样式
}
}
else
{ //偏差表格样式
if (Data_Error.Columns.Count != MeterGroup.PcCheckNumic + 6) //如果误差数据表格的列数大于默认列数，则需要删除大于部分
{
for (int i = Data_Error.Columns.Count - 1; i >= 4; i--)
{
Data_Error.Columns.RemoveAt(i);
}
for (int i = 0; i < MeterGroup.PcCheckNumic; i++)
{
Data_Error.Columns.Add("Tmp_Col" + i.ToString(), "误差" + (i + 1).ToString());
}
Data_Error.Columns.Add("Tmp_Pj", "偏差值");
Data_Error.Columns.Add("Tmp_Hz", "化整值");
this.CreateColumnStyle(); //创建表格列样式
}
}
#endregion
for (int i = 0; i < MeterGroup.MeterGroup.Count; i++)
{
CLDC_DataCore.Model.DnbModel.DnbInfo.MeterBasicInfo _MeterInfo = MeterGroup.MeterGroup[i];
DataGridViewRow Row = Data_Error.Rows[i];
Row.Cells[1].Value = _MeterInfo.ToString(); //插入表位号
if (!_MeterInfo.YaoJianYn) //如果不检
{
Row.Cells[0].Value = false;
if (_MeterInfo.Mb_chrBcs == String.Empty || _MeterInfo.Mb_chrBdj == String.Empty) //如果不检，并且常数或者等级都为空，则将勾选单元格设置为只读
{
Row.Cells[0].ReadOnly = true;
}
for (int j = 2; j < Row.Cells.Count; j++)
{
Row.Cells[j].Value = string.Empty;
}
continue;
}
//if (_MeterInfo.Mb_chrResult == CLDC_DataCore.Const.Variable.CTG_BuHeGe)
//{
// Row.HeaderCell.Style.ForeColor = CLDC_DataCore.Const.Variable.Color_Grid_BuHeGe;
//}
//else
//{
// Row.HeaderCell.Style.ForeColor = CLDC_DataCore.Const.Variable.Color_Grid_Normal;
//}
Row.Cells[0].Value = true;
string _Key = _Item.PrjID;
if (_MeterInfo.MeterErrors.ContainsKey(_Key)) //如果数据模型中已经存在该点的数据
{
#region
try
{
if (_MeterInfo.MeterErrors[_Key].Me_chrWcJl == CLDC_DataCore.Const.Variable.CTG_BuHeGe) //如果不合格修改当前行背景颜色为红色
{
Row.DefaultCellStyle.ForeColor = CLDC_DataCore.Const.Variable.Color_Grid_BuHeGe;
foreach (DataGridViewCell cell in Row.Cells)
{
cell.ToolTipText = _MeterInfo.MeterErrors[_Key].AVR_DIS_REASON;
}
}
else
{
Row.DefaultCellStyle.ForeColor = Color.Black;
foreach (DataGridViewCell cell in Row.Cells)
{
cell.ToolTipText = string.Empty;
}
}
}
catch { }
try
{
string[] Arr_WcLimit = _MeterInfo.MeterErrors[_Key].Me_WcLimit.Split('|'); //分解误差限
if (Arr_WcLimit.Length == 2)
{
Row.Cells[2].Value = string.Format("{0} {1}", Arr_WcLimit[0], Arr_WcLimit[1]); //项目误差限
}
else
{
Row.Cells[2].Value = "";
}
}
catch { }
try
{
Row.Cells[3].Value = _MeterInfo.MeterErrors[_Key].Me_chrWcJl;
}
catch { }
try
{
string[] Arr_Err = _MeterInfo.MeterErrors[_Key].Me_chrWcMore.Split('|'); //分解误差
if (Arr_Err.Length == -1)
{
continue;
}
for (int j = 0; j < Arr_Err.Length; j++)
{
if (Data_Error.Columns.Count <= j + 4)
{
break; //如果列数小于当前误差数，则自动退出
}
Row.Cells[j + 4].Value = Arr_Err[j];
}
}
catch { }
try
{
if (_Item.Dif_Err_Flag == 1)
{
Row.Cells[8].Value = _MeterInfo.MeterErrors[_Key].AVR_UPPER_LIMIT + " " + _MeterInfo.MeterErrors[_Key].AVR_LOWER_LIMIT;
Row.Cells[9].Value = _MeterInfo.MeterErrors[_Key].AVR_DIF_ERR_AVG;//AVR_DIF_ERR_AVG
}
}
catch { }
#endregion
}
else
{
//Row.DefaultCellStyle.ForeColor = Color.Black;
for (int j = 2; j < Data_Error.Columns.Count; j++)
{
Row.Cells[j].Value = "";
}
}
if (_MeterInfo.Mb_Result == CLDC_DataCore.Const.Variable.CTG_BuHeGe)
{
Row.DefaultCellStyle.ForeColor = Color.Red;
}
else
{
Row.DefaultCellStyle.ForeColor = Color.Black;
}
}
}
private void thShowData(object obj)
{
CheckPlan = CLDC_DataCore.Const.GlobalUnit.g_CUS.DnbData.CheckPlan;
CLDC_DataCore.Model.DnbModel.DnbInfo.MeterBasicInfo curMeter = null;
if (CLDC_DataCore.Const.GlobalUnit.g_CUS == null)
{
return;
}
lock (objShowDataLock)
{
bool isRead = false;
string strKey = string.Empty;
for (int bw = 0; bw < BwCount; bw++)
{
//if (bw > BwCount) break;
string strMessageValue = string.Empty;
curMeter = CLDC_DataCore.Const.GlobalUnit.Meter(bw);
/*表格显示中的表位序号是从1开始*/
ClientTable.SetCheckBoxValue(bw + 1, curMeter.YaoJianYn);
if (!curMeter.YaoJianYn)
{
continue;
}
if (CLDC_DataCore.Const.GlobalUnit.g_CUS.DnbData.ActiveItemID < 0 ||
CLDC_DataCore.Const.GlobalUnit.g_CUS.DnbData.CheckState == CLDC_Comm.Enum.Cus_CheckStaute.停止检定)
{
//参数录入状态下刷新时显示条形码
strMessageValue = curMeter.Mb_ChrTxm;
}
else
{
//数据验证
//if (curMeter.MeterPlan == null || curMeter.MeterPlan.CheckPlan == null) continue;
//if (CheckPlan.Count <= CLDC_DataCore.Const.GlobalUnit.g_CUS.DnbData.ActiveItemID) return;
strKey = "";
object curPlan = CheckPlan[CLDC_DataCore.Const.GlobalUnit.g_CUS.DnbData.ActiveItemID];
if (curPlan is CLDC_DataCore.Struct.StPlan_ZouZi)
{
strKey = ((CLDC_DataCore.Struct.StPlan_ZouZi)curPlan).PrjID;
}
CLDC_DataCore.Model.DnbModel.DnbInfo.MeterResult curResult = null;
#region 预热数据显示
if (curPlan is StPlan_YuRe)
{
strMessageValue = "预热中";
}
#endregion
#region 起动/启动数据
else if (curPlan is StPlan_QiDong)
{
strKey = ((int)CLDC_Comm.Enum.Cus_MeterResultPrjID.起动试验).ToString("D3");
strKey += ((int)((StPlan_QiDong)curPlan).PowerFangXiang).ToString();
if (curMeter.MeterResults.ContainsKey(strKey))
{
curResult = curMeter.MeterResults[strKey];
strMessageValue = curResult.Mr_chrRstValue;
isRead = curResult.Mr_chrRstValue == CLDC_DataCore.Const.Variable.CTG_BuHeGe;
}
else
{
strMessageValue = "准备检定";
}
}
#endregion
#region 潜动试验显示
else if (curPlan is StPlan_QianDong)
{
strKey = ((int)CLDC_Comm.Enum.Cus_MeterResultPrjID.潜动试验).ToString("000");
strKey += ((int)((StPlan_QianDong)curPlan).PowerFangXiang).ToString();
if (curMeter.MeterResults.ContainsKey(strKey))
{
curResult = curMeter.MeterResults[strKey];
strMessageValue = curResult.Mr_chrRstValue;
isRead = curResult.Mr_chrRstValue == CLDC_DataCore.Const.Variable.CTG_BuHeGe;
}
else
{
strMessageValue = "准备检定";
}
}
#endregion
#region 基本误差/标准偏差
else if (curPlan is StPlan_WcPoint)
{
//strKey = "P_" + CLDC_DataCore.Const.GlobalUnit.g_CUS.DnbData.ActiveItemID;
StPlan_WcPoint _curPoint = (StPlan_WcPoint)curPlan;
CLDC_DataCore.Model.DnbModel.DnbInfo.MeterError curErroWc = null;
strKey = _curPoint.PrjID;
if (curMeter.MeterErrors.ContainsKey(strKey))
{
curErroWc = curMeter.MeterErrors[strKey];
string[] strErrorValue = curErroWc.Me_chrWcMore.Split('|');
if (strErrorValue.Length > 0)
{
strMessageValue = strErrorValue[0];
}
if (curErroWc.Me_chrWcJl == CLDC_DataCore.Const.Variable.CTG_BuHeGe)
{
isRead = true;
}
}
}
#endregion
#region ----------特殊检定-----------
else if (curPlan is StPlan_SpecalCheck)
{
//Comm.Struct.CheckPoint _curPoint = (Comm.Struct.CheckPoint)curPlan;
strKey = "P_" + CLDC_DataCore.Const.GlobalUnit.g_CUS.DnbData.ActiveItemID;
CLDC_DataCore.Model.DnbModel.DnbInfo.MeterSpecialErr curErroWc = null;
//strKey = _curPoint.PrjID;
if (curMeter.MeterSpecialErrs.ContainsKey(strKey))
{
curErroWc = curMeter.MeterSpecialErrs[strKey];
string[] strErrorValue = curErroWc.Mse_Wc.Split('|');
if (strErrorValue.Length > 0)
{
strMessageValue = strErrorValue[0];
}
if (curErroWc.Mse_Result == CLDC_DataCore.Const.Variable.CTG_BuHeGe)
{
isRead = true;
}
}
}
#endregion
#region 走字数据
else if (curPlan is StPlan_ZouZi)
{
CLDC_DataCore.Model.DnbModel.DnbInfo.MeterZZError curZZerror = null;
if (curMeter.MeterZZErrors.ContainsKey(strKey))
{
curZZerror = curMeter.MeterZZErrors[strKey];
if (m_VerifyStep == CLDC_Comm.Enum.Cus_stVerifyStep.走字试验录起码 || m_VerifyStep == CLDC_Comm.Enum.Cus_stVerifyStep.走字试验录止码)
{
strMessageValue = "";
}
else if (m_VerifyStep == CLDC_Comm.Enum.Cus_stVerifyStep.走字试验录止码完毕)
{
//止码
strMessageValue = curZZerror.Mz_chrZiMa.ToString();
}
else if (m_VerifyStep == CLDC_Comm.Enum.Cus_stVerifyStep.走字试验录起码完毕)
{
//起码
strMessageValue = curZZerror.Mz_chrQiMa.ToString();
}
else if (m_VerifyStep == CLDC_Comm.Enum.Cus_stVerifyStep.计算误差完毕)
{
//起码
strMessageValue = curZZerror.Mz_chrWc.ToString();
}
else
{
//中途进入
if (curZZerror.Mz_chrZiMa != -1)
{
strMessageValue = curZZerror.Mz_chrZiMa.ToString();
}
else if (curZZerror.Mz_chrQiMa != -1)
{
strMessageValue = curZZerror.Mz_chrQiMa.ToString();
}
else
{
strMessageValue = "";
}
}
if (curZZerror.Mz_chrJL == CLDC_DataCore.Const.Variable.CTG_BuHeGe)
{
isRead = true;
}
}
}
#endregion
#region 多功能数据
else if (curPlan is CLDC_DataCore.Struct.StPlan_Dgn)
{
strMessageValue = "检定中";
CLDC_DataCore.Struct.StPlan_Dgn DgnPlan = (CLDC_DataCore.Struct.StPlan_Dgn)curPlan;
}
#endregion
#region 载波数据
else if (curPlan is StPlan_Carrier)
{
strMessageValue = "检定中";
StPlan_Carrier CarrierPlan = (StPlan_Carrier)curPlan;
}
#endregion
else
{
//MUSTDO:走字，多功能检定客户端显示还没有做
}
}
//更新到UI
ClientTable.SetTextValue(bw + 1, strMessageValue);
ClientTable.SetTextBackColorValue(bw + 1, isRead);
}
}
}
private void CreateFaInfo()
{
Cmb_xIb.Text = _DnbGroup.CzIb;
Txt_Qs.Text = _DnbGroup.CzQs.ToString();
Cmb_WcLimit.Text = _DnbGroup.CzWcLimit;
Txt_Down.Text = (_DnbGroup.WcxDownPercent * 100).ToString();
Txt_Up.Text = (_DnbGroup.WcxUpPercent * 100).ToString();
_WcLimitName = _DnbGroup.CzWcLimit;
_xIb = _DnbGroup.CzIb;
_Qs = _DnbGroup.CzQs;
int _FirstYaoJian = CLDC_MeterUI.UI_Detection_New.Main.GetFirstYaoJianMeterIndex(_DnbGroup);
CLDC_DataCore.Model.DnbModel.DnbInfo.MeterBasicInfo _MeterInfo = _DnbGroup.MeterGroup[_FirstYaoJian];
_FirstConst = _MeterInfo.Mb_chrBcs;
_FirstIb = _MeterInfo.Mb_chrIb;
_FirstDj = _MeterInfo.Mb_chrBdj;
_FirstGuiCheng = _MeterInfo.GuiChengName;
_FirstHgq = _MeterInfo.Mb_BlnHgq;
_MeterInfo = null;
for (int i = 0; i < _DnbGroup.CheckPlan.Count; i++)
{
if (!(_DnbGroup.CheckPlan[i] is StPlan_WcPoint))
{
continue; //如果不是误差则跳出
}
StPlan_WcPoint _Item = (StPlan_WcPoint)_DnbGroup.CheckPlan[i];
if (_Item.Pc == 1)
{
continue; //如果是偏差则跳出
}
int _RowIndex = Dgv_Wc.Rows.Add();
Dgv_Wc.Rows[_RowIndex].HeaderCell.Value = _Item.ToString(); //方案项目描述
Dgv_Wc.Rows[_RowIndex].Tag = i; //检定序号
}
int _ThreadSum = (int)((int)Dgv_Wc.Rows.Count / 10) + 1; //归纳需要多少个线程来进行处理，固定一个线程最多处理10行数据
for (int i = 0; i < _ThreadSum; i++)
{
System.Threading.ThreadPool.QueueUserWorkItem(new System.Threading.WaitCallback(CheckQs), i * 10); //计算圈数
System.Threading.ThreadPool.QueueUserWorkItem(new System.Threading.WaitCallback(CheckWcLimit), i * 10); //计算误差限
}
AsyncOpDone.WaitOne();
}
/// <summary>
/// 添加一个需要检定的误差点
/// </summary>
/// <param name="WcType">误差类型</param>
/// <param name="GLFX">功率方向 </param>
/// <param name="Yj">元件</param>
/// <param name="Glys">功率因素</param>
/// <param name="xIb">电流倍数</param>
/// <param name="XieBo">是否加谐波0-不加，1-加</param>
/// <param name="Xiangxu">相序0-正相序，1-逆相序</param>
public void Add(CLDC_Comm.Enum.Cus_WcType WcType, CLDC_Comm.Enum.Cus_PowerFangXiang GLFX, CLDC_Comm.Enum.Cus_PowerYuanJian Yj, string Glys, string xIb, int XieBo, int Xiangxu, string strLimit)
{
string _PrjID = getWcPrjID(WcType, GLFX, Yj, Glys, xIb, XieBo, Xiangxu);
if (CheckedYn(_PrjID) || _PrjID.Length != 9)
{
return;
}
StPlan_WcPoint _Point = new StPlan_WcPoint();
_Point.PrjID = _PrjID;
string _GlfxString;
switch ((int)GLFX)
{
case 1:
{
_GlfxString = "P+";
GlfxYj[0] = true;
break;
}
case 2:
{
_GlfxString = "P-";
GlfxYj[1] = true;
break;
}
case 3:
{
_GlfxString = "Q+";
GlfxYj[2] = true;
break;
}
case 4:
{
_GlfxString = "Q-";
GlfxYj[3] = true;
break;
}
case 5:
{
_GlfxString = "Q1";
GlfxYj[4] = true;
break;
}
case 6:
{
_GlfxString = "Q2";
GlfxYj[5] = true;
break;
}
case 7:
{
_GlfxString = "Q3";
GlfxYj[6] = true;
break;
}
case 8:
{
_GlfxString = "Q4";
GlfxYj[7] = true;
break;
}
default:
{
_GlfxString = "P+";
break;
}
}
string _Yj = "";
switch (Yj.ToString().ToUpper())
{
case "H":
_Yj = "合元";
break;
case "A":
_Yj = "A元";
break;
case "B":
_Yj = "B元";
break;
case "C":
_Yj = "C元";
break;
default:
_Yj = "合元";
break;
}
_Point.PrjName = string.Format("{0} {1} {2} {3} {4}",
_GlfxString, _Yj, Glys, xIb, (int)WcType == 2 ? "标准偏差" : "基本误差");
_Point.PowerYinSu = Glys;
_Point.PowerDianLiu = xIb;
CLDC_DataCore.DataBase.IDAndValue _WcLimitName = _WcLimit.getWcLimitNameValue(CzWcLimit);
CLDC_DataCore.DataBase.IDAndValue _GuiChengName = _WcLimit.getGuiChengValue("JJG596-2012");
CLDC_DataCore.DataBase.IDAndValue[] _DjValue = new CLDC_DataCore.DataBase.IDAndValue[2];
CLDC_DataCore.Model.DnbModel.DnbInfo.MeterBasicInfo meter = CLDC_DataCore.Const.GlobalUnit.g_CUS.DnbData.MeterGroup[CLDC_DataCore.Const.GlobalUnit.g_CUS.DnbData.GetFirstYaoJianMeterBwh()];
string[] _DJ = CLDC_DataCore.Function.Number.getDj(meter.Mb_chrBdj);
_DjValue[0] = _WcLimit.getDjValue(_DJ[0]);
_DjValue[1] = _WcLimit.getDjValue(_DJ[1]);
CLDC_DataCore.DataBase.IDAndValue _GlysValue = new CLDC_DataCore.DataBase.IDAndValue(); //功率因素值
CLDC_DataCore.DataBase.IDAndValue _xIbValue = new CLDC_DataCore.DataBase.IDAndValue(); //电流倍数值
_GlysValue.Value = _Point.PowerYinSu;
_GlysValue.id = long.Parse(CLDC_DataCore.Const.GlobalUnit.g_SystemConfig.GlysZiDian.getGlysID(_GlysValue.Value));
_xIbValue.Value = _Point.PowerDianLiu;
_xIbValue.id = long.Parse(CLDC_DataCore.Const.GlobalUnit.g_SystemConfig.xIbDic.getxIbID(_xIbValue.Value));
bool _YouGong = true;
if ((int)_Point.PowerFangXiang > 2)
{
_YouGong = false;
}
if (_Point.Pc == 0) //基本误差的误差限获取
{
_WcLimit.SetWcx(_WcLimitName
, _GuiChengName
, (int)_Point.PowerFangXiang > 2 ? _DjValue[1] : _DjValue[0]
, _Point.PowerYuanJian
, meter.Mb_BlnHgq
, _YouGong, _GlysValue, _xIbValue, strLimit);
}
else
{
string[] _Wcx = _WcLimit.getPcxValue(_WcLimitName
, _GuiChengName
, (int)_Point.PowerFangXiang > 2 ? _DjValue[1] : _DjValue[0]).Split('|');
_Point.SetWcx(float.Parse(_Wcx[0].Replace("+", "")), float.Parse(_Wcx[1])); //设置误差限
}
LstCheckPoint.Add(_Point);
return;
}
/// <summary>
/// 设置检定圈数(09-7-2之后不再使用)
/// </summary>
/// <param name="Current">电流参数1.5(6)</param>
/// <param name="MeConst">当前表常数 有功（无功）</param>
/// <param name="MinConst">当台表最小常数（数组 下标0=有功，1=无功）</param>
//public void SetQs(string Current,string MeConst,int[] MinConst)
//{
// for (int _i = 0; _i < LstCheckPoint.Count; _i++)
// {
// CLDC_DataCore.Struct.CheckPoint _Item = LstCheckPoint[_i];
// _Item.SetLapCount(MinConst, MeConst, Current, Qscz, Czqs);
// LstCheckPoint[_i] = _Item;
// }
//}
/// <summary>
/// 设置各个测试点误差限(09-7-2之后不再使用)
/// </summary>
/// <param name="GuiChengName">规程名称"JJG596-1999"</param>
/// <param name="DjString">等级字符串1.0,0.5S(2.0)</param>
/// <param name="Hgq">是否经互感器0-不，1-要</param>
//public void SetWcx(string GuiChengName,string DjString,int Hgq)
//{
// CLDC_DataCore.DataBase.clsWcLimitDataControl _WcLimit= new clsWcLimitDataControl();
// bool _YouGong =true;
// string[] _Dj = CLDC_DataCore.Function.Number.getDj(DjString);
// if (CzWcLimit == "规程误差限") //参照规程误差限则直接通过公式计算误差限
// {
// for (int _i = 0; _i < LstCheckPoint.Count; _i++)
// {
// if ((int)LstCheckPoint[_i].PowerFangXiang > 2)
// _YouGong = false;
// string _Wcx = "";
// CLDC_DataCore.Struct.CheckPoint _Item = LstCheckPoint[_i];
// if (LstCheckPoint[_i].Pc == 0) //基本误差的误差限获取
// {
// _Wcx = clsWcLimitDataControl.Wcx(LstCheckPoint[_i].PowerDianLiu
// , GuiChengName
// , (int)LstCheckPoint[_i].PowerFangXiang > 2 ? _Dj[1] : _Dj[0]
// , LstCheckPoint[_i].PowerYuanJian
// , LstCheckPoint[_i].PowerYinSu
// , Hgq == 0 ? false : true
// , _YouGong);
// _Item.SetWcx(float.Parse(_Wcx), float.Parse(string.Format("-{0}", _Wcx))); //设置误差限
// }
// else
// {
// _Wcx = clsWcLimitDataControl.Pcx((int)LstCheckPoint[_i].PowerFangXiang > 2 ? _Dj[1] : _Dj[0]).ToString(); //如果是无功则使用无功等级
// _Item.SetWcx(float.Parse(_Wcx), 0F); //设置误差限
// }
// LstCheckPoint[_i] = _Item;
// }
// }
// else
// {
// CLDC_DataCore.DataBase.IDAndValue _WcLimitName = _WcLimit.getWcLimitNameValue(CzWcLimit);
// CLDC_DataCore.DataBase.IDAndValue _GuiChengName = _WcLimit.getGuiChengValue(GuiChengName);
// CLDC_DataCore.DataBase.IDAndValue[] _DjValue = new IDAndValue[2];
// _DjValue[0] = _WcLimit.getDjValue(_Dj[0]);
// _DjValue[1] = _WcLimit.getDjValue(_Dj[1]);
// CLDC_DataCore.SystemModel.Item.csGlys _GlysCol = new CLDC_DataCore.SystemModel.Item.csGlys();
// CLDC_DataCore.SystemModel.Item.csxIbDic _xIbCol = new CLDC_DataCore.SystemModel.Item.csxIbDic();
// _GlysCol.Load();
// _xIbCol.Load();
// for (int _i = 0; _i < LstCheckPoint.Count; _i++)
// {
// CLDC_DataCore.Struct.CheckPoint _Item = LstCheckPoint[_i];
// CLDC_DataCore.DataBase.IDAndValue _GlysValue = new IDAndValue(); //功率因素值
// CLDC_DataCore.DataBase.IDAndValue _xIbValue = new IDAndValue(); //电流倍数值
// _GlysValue.Value = LstCheckPoint[_i].PowerYinSu;
// _GlysValue.id = long.Parse(_GlysCol.getGlysID(_GlysValue.Value));
// _xIbValue.Value = LstCheckPoint[_i].PowerDianLiu;
// _xIbValue.id = long.Parse(_xIbCol.getxIbID(_xIbValue.Value));
// if ((int)LstCheckPoint[_i].PowerFangXiang > 2)
// _YouGong = false;
// if (LstCheckPoint[_i].Pc == 0) //基本误差的误差限获取
// {
// string[] _Wcx = _WcLimit.GetWcx(_WcLimitName
// , _GuiChengName
// , (int)LstCheckPoint[_i].PowerFangXiang > 2 ? _DjValue[1] : _DjValue[0]
// , LstCheckPoint[_i].PowerYuanJian
// , Hgq == 0 ? false : true
// , _YouGong, _GlysValue, _xIbValue).Split('|');
// _Item.SetWcx(float.Parse(_Wcx[0].Replace("+", "")), float.Parse(_Wcx[1])); //设置误差限
// }
// else
// {
// string[] _Wcx = _WcLimit.getPcxValue(_WcLimitName
// , _GuiChengName
// , (int)LstCheckPoint[_i].PowerFangXiang > 2 ? _DjValue[1] : _DjValue[0]).Split('|');
// _Item.SetWcx(float.Parse(_Wcx[0].Replace("+", "")), float.Parse(_Wcx[1])); //设置误差限
// }
// LstCheckPoint[_i] = _Item;
// }
// }
//}
#endregion
/// <summary>
/// 添加一个需要检定的误差点
/// </summary>
/// <param name="WcType">误差类型</param>
/// <param name="GLFX">功率方向 </param>
/// <param name="Yj">元件</param>
/// <param name="Glys">功率因素</param>
/// <param name="xIb">电流倍数</param>
/// <param name="XieBo">是否加谐波0-不加，1-加</param>
/// <param name="Xiangxu">相序0-正相序，1-逆相序</param>
public void Add(CLDC_Comm.Enum.Cus_WcType WcType, CLDC_Comm.Enum.Cus_PowerFangXiang GLFX, CLDC_Comm.Enum.Cus_PowerYuanJian Yj, string Glys, string xIb, int XieBo, int Xiangxu)
{
string _PrjID = getWcPrjID(WcType, GLFX, Yj, Glys, xIb, XieBo, Xiangxu);
if (CheckedYn(_PrjID))
{
return;
}
StPlan_WcPoint _Point = new StPlan_WcPoint();
_Point.PrjID = _PrjID;
string _GlfxString;
switch ((int)GLFX)
{
case 1:
{
_GlfxString = "P+";
GlfxYj[0] = true;
break;
}
case 2:
{
_GlfxString = "P-";
GlfxYj[1] = true;
break;
}
case 3:
{
_GlfxString = "Q+";
GlfxYj[2] = true;
break;
}
case 4:
{
_GlfxString = "Q-";
GlfxYj[3] = true;
break;
}
case 5:
{
_GlfxString = "Q1";
GlfxYj[4] = true;
break;
}
case 6:
{
_GlfxString = "Q2";
GlfxYj[5] = true;
break;
}
case 7:
{
_GlfxString = "Q3";
GlfxYj[6] = true;
break;
}
case 8:
{
_GlfxString = "Q4";
GlfxYj[7] = true;
break;
}
default:
{
_GlfxString = "P+";
break;
}
}
string _Yj = "";
switch (Yj.ToString().ToUpper())
{
case "H":
_Yj = "合元";
break;
case "A":
_Yj = "A元";
break;
case "B":
_Yj = "B元";
break;
case "C":
_Yj = "C元";
break;
default:
_Yj = "合元";
break;
}
_Point.PrjName = string.Format("{0} {1} {2} {3} {4}",
_GlfxString, _Yj, Glys, xIb, (int)WcType == 2 ? "标准偏差" : " "); //基本误差
_Point.PowerYinSu = Glys;
_Point.PowerDianLiu = xIb;
LstCheckPoint.Add(_Point);
return;
}
/// <summary>
/// 列表排序
/// </summary>
private void Sort()
{
#region ----------------------------------排序方式old--------------------------------------------------
/*
* List<Comm.Struct.CheckPoint> _TmpList = new List<Comm.Struct.CheckPoint>();
* for (int i = 0; i < LstCheckPoint.Count; i++)
* {
* if (_TmpList.Count == 0) //如果临时列表元素数量为0，则加入一个
* _TmpList.Add(LstCheckPoint[i]);
* else
* {
* for (int j = _TmpList.Count-1; j>=0 ; j--) //临时列表从最大到最小开始训话
* {
* if (LstCheckPoint[i].PrjID.Substring(0) == "2") //如果是偏差
* {
* if (LstCheckPoint[i].PrjID.Substring(1).CompareTo(_TmpList[j].PrjID.Substring(1)) > 0) //则从第2个字符到最后进行大小比较，
* {
* if (j == _TmpList.Count - 1) //如果比临时列表的最后一个大，则直接追加
* {
* _TmpList.Add(LstCheckPoint[i]);
* }
* else
* {
* _TmpList.Insert(j + 1, LstCheckPoint[i]); //反之则在当前位置追加，这样保证了大的永远在后面
* }
* break;
* }
* }
* else
* {
* if (LstCheckPoint[i].PrjID.CompareTo(_TmpList[j].PrjID) > 0)
* {
* if (j == _TmpList.Count - 1)
* {
* _TmpList.Add(LstCheckPoint[i]);
* }
* else
* {
* _TmpList.Insert(j + 1, LstCheckPoint[i]);
* }
*
* break;
* }
*
* }
* if (j == 0) //如果比较到最小一个都还没有结果，就在临时列表最前面插入一个
* {
* _TmpList.Insert(0, LstCheckPoint[i]);
* }
* }
* }
*
* }
* LstCheckPoint = _TmpList;
*/
#endregion
IDSort[] _TmpPrjIDCol;
_TmpPrjIDCol = new IDSort[this.LstCheckPoint.Count];
for (int i = 0; i < this.LstCheckPoint.Count; i++)
{
StPlan_WcPoint _TmpPrj = this.LstCheckPoint[i];
string _TmpHi = _TmpPrj.PrjID.Substring(0, 3); //取出误差类别+功率方向+元件
string _TmpLo = _TmpPrj.PrjID.Substring(7); //取出谐波+相序
string _TmpGlys = _TmpPrj.PrjID.Substring(3, 2); //取出功率因素
string _TmpxIb = _TmpPrj.PrjID.Substring(5, 2); //取出电流倍数
if (_TmpHi.Substring(0, 1) == "2") //如果是偏差的话，就做一个小处理，以保证默认排序能够按要求排序成功
{
_TmpLo = string.Format("{0}{1}", _TmpLo.Substring(0, _TmpLo.Length - 1), (int.Parse(_TmpLo.Substring(_TmpLo.Length - 1)) + 1).ToString());
_TmpHi = "1" + _TmpHi.Substring(1);
}
_TmpPrjIDCol[i] = new IDSort(string.Format("{0}{1}{2}{3}", _TmpHi, _TmpxIb, _TmpGlys, _TmpLo), i);
}
Array.Sort(_TmpPrjIDCol);
List <StPlan_WcPoint> _TmpLstCheckPiont = new List <StPlan_WcPoint>();
for (int i = 0; i < _TmpPrjIDCol.Length; i++)
{
_TmpLstCheckPiont.Add(LstCheckPoint[_TmpPrjIDCol[i].AscID]);
}
LstCheckPoint = _TmpLstCheckPiont;
}
