michal/tbf
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
bf91dc0aa6
tbf/TBF/BenchControl/Various/ErrorFlags/TestParams.cs

433 lines
18 KiB
C#
Raw Blame History

///
/// Copyright (c) 2017-2020 Sensus Slovensko a.s.
///
using System.IO;
using System.Xml.Serialization;
using Config.Entities;
using TBF.BenchControl.Generic;
using TBF.Resources;
namespace TBF.BenchControl.Various.ErrorFlags
{
public class TestParams : TestParamsBase, IParamsProvider, ITestParams
{
public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(TestParams) })[0];
public override XmlSerializer GetSerializer() { return Serializer; }
public sbyte E1; ///
public sbyte E2; ///
public sbyte E3; ///
public sbyte E4; ///
public sbyte E5; ///
public sbyte E6; ///
public sbyte E7; ///
public sbyte E8; ///
public sbyte E9; /// 0=off, 1=info, 2=evaluate, 3=stop the cycle
public sbyte E10; ///
public sbyte E11; ///
public sbyte E12; ///
public sbyte E13; ///
public sbyte E14; ///
public sbyte E15; ///
public sbyte E16; ///
public sbyte E21; ///
public sbyte E36; ///
public double Delta_Q_pct; /// [%] max deviation from the mean flow
public double Delta_T; /// [°C] max. T_up or T_down deviation from the mean temperature
public double Delta_Tup_Tdn; /// [°C] max. difference abs(T_up - T_down)
public double TestTime_min; /// [s]
public double TestTime_max; /// [s]
public double AmbTemp_min; /// [°C] min. ambient temperature
public double AmbTemp_max; /// [°C] max. ambient temperature
public double Pressure_min; /// [bar] min. water pressure
public double Pressure_max; /// [bar] max. water pressure
public double Conductivity_min; /// [uS/cm] min. electrical conductivity of water
public double Conductivity_max; /// [uS/cm] max. electrical conductivity of water
public double Coef_E9; /// Coefficient used in E9, default 0.025
public double Coef_E10; /// Coefficient used in E10, default 0.04
public double Coef_E11; /// Coefficient used in E11, default 0.1
public double Coef_E12; /// Coefficient used in E12, default 1
public double Offset_E9; /// [s] default 0 (no offset)
public double Offset_E12; /// [s] default 0 (no offset)
#if IPERL
public sbyte E25; /// MaxProefindex verification
public sbyte E26; /// Q2 factors verification (saved from production == current)
public sbyte E27; /// Direction verification
public sbyte E28; /// Previous workflow step verification
#endif
public override void InitializeAll()
{
#if IPERL
E1 = (sbyte)ErrorFlagsMode.Info;
E2 = (sbyte)ErrorFlagsMode.Off;
E3 = (sbyte)ErrorFlagsMode.Info;
E4 = (sbyte)ErrorFlagsMode.Off;
E5 = (sbyte)ErrorFlagsMode.Off;
E6 = (sbyte)ErrorFlagsMode.Off;
E7 = (sbyte)ErrorFlagsMode.Off;
E8 = (sbyte)ErrorFlagsMode.Off;
E9 = (sbyte)ErrorFlagsMode.Off;
E10 = (sbyte)ErrorFlagsMode.Off;
E11 = (sbyte)ErrorFlagsMode.Off;
E12 = (sbyte)ErrorFlagsMode.Off;
E13 = (sbyte)ErrorFlagsMode.Off;
E14 = (sbyte)ErrorFlagsMode.Off;
E15 = (sbyte)ErrorFlagsMode.Off;
E16 = (sbyte)ErrorFlagsMode.Off;
E21 = (sbyte)ErrorFlagsMode.Info;
E36 = (sbyte)ErrorFlagsMode.On;
#else
E1 = (sbyte)ErrorFlagsMode.Info;
E2 = (sbyte)ErrorFlagsMode.Info;
E3 = (sbyte)ErrorFlagsMode.Info;
E4 = (sbyte)ErrorFlagsMode.Info;
E5 = (sbyte)ErrorFlagsMode.Info;
E6 = (sbyte)ErrorFlagsMode.Info;
E7 = (sbyte)ErrorFlagsMode.Info;
E8 = (sbyte)ErrorFlagsMode.Info;
E9 = (sbyte)ErrorFlagsMode.Info;
E10 = (sbyte)ErrorFlagsMode.Info;
E11 = (sbyte)ErrorFlagsMode.Info;
E12 = (sbyte)ErrorFlagsMode.Info;
E13 = (sbyte)ErrorFlagsMode.Info;
E14 = (sbyte)ErrorFlagsMode.Info;
E15 = (sbyte)ErrorFlagsMode.Info;
E16 = (sbyte)ErrorFlagsMode.Info;
E21 = (sbyte)ErrorFlagsMode.Info;
E36 = (sbyte)ErrorFlagsMode.Off;
#endif
Delta_Q_pct = 5.0; /// [%]
Delta_T = 10.0; /// [°C]
Delta_Tup_Tdn = 10.0; /// [°C]
TestTime_min = 0; /// [s]
TestTime_max = 99999; /// [s]
AmbTemp_min = 5.0; /// [°C]
AmbTemp_max = 95.0; /// [°C]
Pressure_min = 0; /// [bar]
Pressure_max = 16.0; /// [bar]
Conductivity_min = 600.0; /// [uS/cm]
Conductivity_max = 1200.0; /// [uS/cm]
Coef_E9 = 0.025;
Coef_E10 = 0.04;
Coef_E11 = 0.1;
Coef_E12 = 1.0;
Offset_E9 = 0; /// [s]
Offset_E12 = 0; /// [s]
#if IPERL
E25 = (sbyte)ErrorFlagsMode.Info; /// MaxPruefindex verification
E26 = (sbyte)ErrorFlagsMode.Off; /// Q2 factors verification (saved from production == current)
E27 = (sbyte)ErrorFlagsMode.Off; /// Direction verification
E28 = (sbyte)ErrorFlagsMode.Info; /// Previous workflow step verification
#endif
}
string[] paramNames = new string[]
{
"E1",
"E2",
"E3",
"E4",
"E5",
"E6",
"E7",
"E8",
"E9",
"E10",
"E11",
"E12",
"E13",
"E14",
"E15",
"E16",
"E21",
"E36",
"Delta Q [%]",
"Delta T [°C]",
"max. Abs(Tup - Tdn) [°C]",
string.Format("min. {0}", Strings.Test_time_s_chdr),
string.Format("max. {0}", Strings.Test_time_s_chdr),
string.Format("min. {0} [°C]", Strings.Air_temperature),
string.Format("max. {0} [°C]", Strings.Air_temperature),
string.Format("min. {0} [bar]", Strings.Pressure),
string.Format("max. {0} [bar]", Strings.Pressure),
"min. conductivity [uS/cm]",
"max. conductivity [uS/cm]",
"Coef.E9",
"Coef.E10",
"Coef.E11",
"Coef.E12",
"Offset E9 [s]",
"Offset E12 [s]",
#if IPERL
"E25",
"E26",
"E27",
"E28",
#endif
};
public override string ParamName(int i) { return paramNames[i]; }
public override int ParamsCount() { return paramNames.Length; }
public override string ToString(int i)
{
switch (i)
{
case 0: return ((ErrorFlagsMode)E1).ToDescription();
case 1: return ((ErrorFlagsMode)E2).ToDescription();
case 2: return ((ErrorFlagsMode)E3).ToDescription();
case 3: return ((ErrorFlagsMode)E4).ToDescription();
case 4: return ((ErrorFlagsMode)E5).ToDescription();
case 5: return ((ErrorFlagsMode)E6).ToDescription();
case 6: return ((ErrorFlagsMode)E7).ToDescription();
case 7: return ((ErrorFlagsMode)E8).ToDescription();
case 8: return ((ErrorFlagsMode)E9).ToDescription();
case 9: return ((ErrorFlagsMode)E10).ToDescription();
case 10: return ((ErrorFlagsMode)E11).ToDescription();
case 11: return ((ErrorFlagsMode)E12).ToDescription();
case 12: return ((ErrorFlagsMode)E13).ToDescription();
case 13: return ((ErrorFlagsMode)E14).ToDescription();
case 14: return ((ErrorFlagsMode)E15).ToDescription();
case 15: return ((ErrorFlagsMode)E16).ToDescription();
case 16: return ((ErrorFlagsMode)E21).ToDescription();
case 17: return ((ErrorFlagsMode)E36).ToDescription();
case 18: return Delta_Q_pct.ToString();
case 19: return Delta_T.ToString();
case 20: return Delta_Tup_Tdn.ToString();
case 21: return TestTime_min.ToString();
case 22: return TestTime_max.ToString();
case 23: return AmbTemp_min.ToString();
case 24: return AmbTemp_max.ToString();
case 25: return Pressure_min.ToString();
case 26: return Pressure_max.ToString();
case 27: return Conductivity_min.ToString();
case 28: return Conductivity_max.ToString();
case 29: return Coef_E9.ToString();
case 30: return Coef_E10.ToString();
case 31: return Coef_E11.ToString();
case 32: return Coef_E12.ToString();
case 33: return Offset_E9.ToString();
case 34: return Offset_E12.ToString();
#if IPERL
case 35: return ((ErrorFlagsMode)E25).ToDescription();
case 36: return ((ErrorFlagsMode)E26).ToDescription();
case 37: return ((ErrorFlagsMode)E27).ToDescription();
case 38: return ((ErrorFlagsMode)E28).ToDescription();
#endif
default: return string.Empty;
}
}
/// Retrieves parameters from UI controls
public CfgUpdateFlags UpdateParam(int i, string sVal)
{
switch (i)
{
case 0: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E1 = (sbyte)m; break; }; break;
case 1: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E2 = (sbyte)m; break; }; break;
case 2: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E3 = (sbyte)m; break; }; break;
case 3: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E4 = (sbyte)m; break; }; break;
case 4: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E5 = (sbyte)m; break; }; break;
case 5: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E6 = (sbyte)m; break; }; break;
case 6: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E7 = (sbyte)m; break; }; break;
case 7: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E8 = (sbyte)m; break; }; break;
case 8: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E9 = (sbyte)m; break; }; break;
case 9: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E10 = (sbyte)m; break; }; break;
case 10: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E11 = (sbyte)m; break; }; break;
case 11: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E12 = (sbyte)m; break; }; break;
case 12: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E13 = (sbyte)m; break; }; break;
case 13: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E14 = (sbyte)m; break; }; break;
case 14: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E15 = (sbyte)m; break; }; break;
case 15: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E16 = (sbyte)m; break; }; break;
case 16: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E21 = (sbyte)m; break; }; break;
case 17: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E36 = (sbyte)m; break; }; break;
case 18: Delta_Q_pct = Utils.ParseUDouble(sVal); return CfgUpdateFlags.None;
case 19: Delta_T = Utils.ParseUDouble(sVal); return CfgUpdateFlags.None;
case 20: Delta_Tup_Tdn = Utils.ParseUDouble(sVal); return CfgUpdateFlags.None;
case 21: TestTime_min = Utils.ParseUDouble(sVal); return CfgUpdateFlags.None;
case 22: TestTime_max = Utils.ParseUDouble(sVal); return CfgUpdateFlags.None;
case 23: AmbTemp_min = Utils.ParseUDouble(sVal); return CfgUpdateFlags.None;
case 24: AmbTemp_max = Utils.ParseUDouble(sVal); return CfgUpdateFlags.None;
case 25: Pressure_min = Utils.ParseUDouble(sVal); return CfgUpdateFlags.None;
case 26: Pressure_max = Utils.ParseUDouble(sVal); return CfgUpdateFlags.None;
case 27: Conductivity_min = Utils.ParseUDouble(sVal); return CfgUpdateFlags.None;
case 28: Conductivity_max = Utils.ParseUDouble(sVal); return CfgUpdateFlags.None;
case 29: Coef_E9 = Utils.ParseUDouble(sVal); return CfgUpdateFlags.None;
case 30: Coef_E10 = Utils.ParseUDouble(sVal); return CfgUpdateFlags.None;
case 31: Coef_E11 = Utils.ParseUDouble(sVal); return CfgUpdateFlags.None;
case 32: Coef_E12 = Utils.ParseUDouble(sVal); return CfgUpdateFlags.None;
case 33: Offset_E9 = Utils.ParseUDouble(sVal); return CfgUpdateFlags.None;
case 34: Offset_E12 = Utils.ParseUDouble(sVal); return CfgUpdateFlags.None;
#if IPERL
case 35: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E25 = (sbyte)m; break; }; break;
case 36: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E26 = (sbyte)m; break; }; break;
case 37: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E27 = (sbyte)m; break; }; break;
case 38: for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++) if (m.ToDescription() == sVal) { E28 = (sbyte)m; break; }; break;
#endif
}
return CfgUpdateFlags.None;
}
/// Verifies whether strings in UI controls represent valid parameters
public bool ValidateParam(int i, string strValue, out string message)
{
message = string.Empty;
double dummy;
switch (i)
{
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:
case 10:
case 11:
case 12:
case 13:
case 14:
case 15:
case 16:
case 17:
#if IPERL
case 35:
case 36:
case 37:
case 38:
#endif
for (ErrorFlagsMode m = 0; m < ErrorFlagsMode.Count; m++)
{
if (m.ToDescription() == strValue) return true;
}
break;
case 18:
case 19:
case 20:
case 21:
case 22:
case 23:
case 24:
case 25:
case 26:
case 27:
case 28:
case 29:
case 30:
case 31:
case 32:
case 33:
case 34:
if (Utils.TryParseUDouble(strValue, out dummy)) return true;
break;
default:
message = "Invalid index";
return false;
}
message = ParamName(i) + " is invalid";
return false;
}
void CopyContentTo(TestParams prms)
{
prms.E1 = this.E1;
prms.E2 = this.E2;
prms.E3 = this.E3;
prms.E4 = this.E4;
prms.E5 = this.E5;
prms.E6 = this.E6;
prms.E7 = this.E7;
prms.E8 = this.E8;
prms.E9 = this.E9;
prms.E10 = this.E10;
prms.E11 = this.E11;
prms.E12 = this.E12;
prms.E13 = this.E13;
prms.E14 = this.E14;
prms.E15 = this.E15;
prms.E16 = this.E16;
prms.E21 = this.E21;
prms.E36 = this.E36;
prms.Delta_Q_pct = this.Delta_Q_pct;
prms.Delta_T = this.Delta_T;
prms.Delta_Tup_Tdn = this.Delta_Tup_Tdn;
prms.TestTime_min = this.TestTime_min;
prms.TestTime_max = this.TestTime_max;
prms.AmbTemp_min = this.AmbTemp_min;
prms.AmbTemp_max = this.AmbTemp_max;
prms.Pressure_min = this.Pressure_min;
prms.Pressure_max = this.Pressure_max;
prms.Conductivity_min = this.Conductivity_min;
prms.Conductivity_max = this.Conductivity_max;
prms.Coef_E9 = this.Coef_E9;
prms.Coef_E10 = this.Coef_E10;
prms.Coef_E11 = this.Coef_E11;
prms.Coef_E12 = this.Coef_E12;
prms.Offset_E9 = this.Offset_E9;
prms.Offset_E12 = this.Offset_E12;
#if IPERL
prms.E25 = this.E25;
prms.E26 = this.E26;
prms.E27 = this.E27;
prms.E28 = this.E28;
#endif
}
public IParamsProvider Clone()
{
TestParams pars = new TestParams();
CopyContentTo(pars);
return pars;
}
public override void UpdateFromDbEntity(ComponentTest dbEntity)
{
if (dbEntity == null) return;
try
{
TestParams tmp = Serializer.Deserialize(new StringReader(dbEntity.Parameters)) as TestParams;
testParamsEntity = dbEntity;
componentName = dbEntity.CmpntName;
test = dbEntity.Test;
if (tmp != null) tmp.CopyContentTo(this);
}
catch
{
}
}
public TestParams() { }
public TestParams(bool initialize)
{
if (initialize) InitializeAll();
}
public TestParams(ComponentProcedure procedureParamsEntity, string componentName, Test test)
{
this.testParamsEntity = testParamsEntity;
this.componentName = componentName;
this.test = test;
}
}
}
Reference in New Issue View Git Blame Copy Permalink