511 lines
26 KiB
C#
511 lines
26 KiB
C#
///
|
|
/// Copyright (c) 2013-2023 Sensus Slovensko a.s.
|
|
///
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using Common;
|
|
|
|
namespace Config.Entities
|
|
{
|
|
/// <summary>
|
|
/// Test, consisting of one or more repetitions of the test 'SingleTest'.
|
|
/// </summary>
|
|
public class Test : IHasName, IHasItemNr
|
|
{
|
|
public virtual int Id { get; protected set; }
|
|
public virtual int ItemNr { get; set; }
|
|
public virtual string Name { get; set; }
|
|
public virtual int Part { get; set; } /// Part=0 ... test of all WM-s
|
|
/// Part>0 ... part of a set of tests with the same Name: subset of WM-s is given by MetersPath
|
|
public virtual TestProfile Profile { get; set; } /// UserDefined, Protected, UserDefinedHeatMeter, ProtectedHeatMeter
|
|
public virtual sbyte Publish { get; set; } /// 0=no, 1=in all protocols, 2=on screen, 3=internal
|
|
public virtual bool DoEvaluate { get; set; }
|
|
public virtual double Qtg { get; set; } /// Target water flow [m3/h]
|
|
public virtual double Qfrom { get; set; } /// Water flow low limit in [m3/h]
|
|
public virtual double Qto { get; set; } /// Water flow high limit in [m3/h]
|
|
public virtual double Volume { get; set; } /// Test volume (target) in [l]
|
|
public virtual double TestTime { get; set; } /// Test time (estimate) in [s]
|
|
public virtual string Method { get; set; }
|
|
public virtual float ErrLimLo { get; set; } /// in [%] usually < 0, in case of heat meters: 1=class1, 2=class2, 3=class3
|
|
public virtual float ErrLimHi { get; set; } /// in [%] usually > 0, in case of heat meters: -Qn in m3/h
|
|
public virtual float Uncertainty { get; set; } /// int [%] makes error limits tighter: 0 <= Uncertainty <= abs(ErrLimXx)
|
|
public virtual int Repeats { get; set; }
|
|
public virtual bool DoDraining { get; set; }
|
|
public virtual bool DoDrainingAfter { get; set; }
|
|
public virtual float TempLimLo { get; set; } /// Lower limit for the controlled temperature
|
|
public virtual float TempLimHi { get; set; } /// Upper limit for the controlled temperature
|
|
public virtual string TempControl { get; set; } /// Water temperature controller, null or empty = Do not control water temp
|
|
public virtual float PumpPower { get; set; } /// Power of the pump in [%] in the range 0 .. 100.0f, use values 0% and 100% for non-FM pumps
|
|
public virtual int MassRepeats { get; set; } /// Number of mass. measurements at the beginning/end of test, 0 = default (=5)
|
|
public virtual float MassSpread { get; set; } /// Max spread of mass. measurements at the beginning/end of test, 0 = default
|
|
public virtual MassMethod MassMethod { get; set; } /// method of mass. measurement at the beginning/end of test: false=slow (precise), true=using immediate mass measurement and evaluation
|
|
public virtual int TimeBeforeFlow { get; set; } /// Delay time before the start of flow control in [s]
|
|
public virtual int TimeFlow2Mass { get; set; } /// Delay time from the flow stable to the 1st mass measurement in [s]
|
|
public virtual int TimePump2StartV { get; set; } /// Delay time from the start of the pump to opening the start valve in [s]
|
|
public virtual int TimeStop2Mass { get; set; } /// Delay time from the test end (diverted) to the 2nd mass measuremen in [s]
|
|
public virtual double ShortPulses { get; set; } /// = Filter
|
|
public virtual string RedType { get; set; }
|
|
public virtual string FeedingPath { get; set; }
|
|
public virtual string BenchPath { get; set; }
|
|
public virtual string OutputPath { get; set; }
|
|
public virtual string MetersPath { get; set; }
|
|
#if HEAT_METERS
|
|
public virtual string HeatMetersPath { get; set; }
|
|
#endif
|
|
public virtual string TransBefore { get; set; }
|
|
public virtual string TransBetween { get; set; }
|
|
public virtual string TransAfter { get; set; }
|
|
#if ORACLE_DB
|
|
public virtual int OraId { get; set; }
|
|
public virtual int OraIdRepetMulti { get; set; }
|
|
public virtual string OraDesignation { get; set; }
|
|
public virtual int RawDataId { get; set; }
|
|
public virtual int RawDataIdRepetMulti { get; set; }
|
|
public virtual string RawDataDesignation { get; set; }
|
|
#endif
|
|
public virtual bool IsOuterLoopStart { get; set; } /// Not mapped to database
|
|
public virtual bool IsOuterLoopEnd { get; set; } /// Not mapped to database
|
|
|
|
public virtual bool QtgTextChngd { get; set; } /// Not mapped to database, used in ProcedureDlg / Metrology1Tab
|
|
public virtual bool QfromTextChngd { get; set; } /// Not mapped to database, used in ProcedureDlg / Metrology1Tab
|
|
public virtual bool QtoTextChngd { get; set; } /// Not mapped to database, used in ProcedureDlg / Metrology1Tab
|
|
public virtual bool VolumeTextChngd { get; set; } /// Not mapped to database, used in ProcedureDlg / Metrology1Tab
|
|
public virtual bool TempLimLoTextChngd { get; set; } /// Not mapped to database, used in ProcedureDlg / Metrology1Tab
|
|
public virtual bool TempLimHiTextChngd { get; set; } /// Not mapped to database, used in ProcedureDlg / Metrology1Tab
|
|
public virtual Unit VolumeUnit { get; set; } /// Not mapped to database, used in ProcedureDlg / Metrology1Tab
|
|
public virtual Unit FlowUnit { get; set; } /// Not mapped to database, used in ProcedureDlg / Metrology1Tab
|
|
public virtual Unit MassUnit { get; set; } /// Not mapped to database, used in ProcedureDlg / Metrology1Tab
|
|
public virtual Unit TempUnit { get; set; } /// Not mapped to database, used in ProcedureDlg / Metrology1Tab
|
|
public virtual Unit PressUnit { get; set; } /// Not mapped to database, used in ProcedureDlg / Metrology1Tab
|
|
public virtual Unit LengthUnit { get; set; } /// Not mapped to database, used in ProcedureDlg / Metrology1Tab
|
|
|
|
public virtual IList<ComponentTest> MoreParams { get; set; }
|
|
|
|
public virtual Procedure Procedure { get; set; }
|
|
|
|
/// ------------- Additional stuff not mapped into the database -------------
|
|
|
|
public Test()
|
|
{
|
|
MoreParams = new List<ComponentTest>();
|
|
|
|
///
|
|
/// Default values
|
|
///
|
|
Part = 0;
|
|
Profile = TestProfile.UserDefined;
|
|
Publish = (sbyte)Common.Publish.Always;
|
|
DoEvaluate = true;
|
|
ErrLimLo = -2.0f; /// [%] lower error limit
|
|
ErrLimHi = 2.0f; /// [%] upper error limit
|
|
Uncertainty = 0;
|
|
Repeats = 1;
|
|
DoDraining = false;
|
|
DoDrainingAfter = false;
|
|
TempLimLo = 15.0f;
|
|
TempLimHi = 25.0f;
|
|
TempControl = string.Empty;
|
|
PumpPower = 60.0f; /// [%]
|
|
MassRepeats = 0; /// default
|
|
MassSpread = 0; /// default
|
|
MassMethod = MassMethod.Scale; /// default
|
|
TimeBeforeFlow = 10; /// [s] time before the start of flow control in [s]
|
|
TimeFlow2Mass = 5; /// [s] time from the flow stable to the 1st mass measurement in [s]
|
|
TimePump2StartV = 1; /// [s] time from the 1st mass measurement to the test start in [s]
|
|
TimeStop2Mass = 5; /// [s] between the test end and the final mass measurement
|
|
ShortPulses = 0; /// Short pulses parameter (0 or 1)
|
|
TransBefore = string.Empty;
|
|
TransBetween = string.Empty;
|
|
TransAfter = string.Empty;
|
|
#if ORACLE_DB
|
|
OraId = 0;
|
|
OraIdRepetMulti = 0;
|
|
OraDesignation = string.Empty;
|
|
RawDataId = 0;
|
|
RawDataIdRepetMulti = 0;
|
|
RawDataDesignation = string.Empty;
|
|
#endif
|
|
}
|
|
|
|
public Test(string name, int itemNr, Procedure procedure)
|
|
: this()
|
|
{
|
|
Name = name;
|
|
ItemNr = itemNr;
|
|
Procedure = procedure;
|
|
}
|
|
|
|
public virtual bool IsRegular()
|
|
{
|
|
/// Irregular / event triggered test names have form "[event] TestName"
|
|
return (Name.Length > 0 && Name[0] != '[') || !Name.Contains("]");
|
|
}
|
|
|
|
public virtual bool BelongsTo(IList<string> autoTests)
|
|
{
|
|
if (IsRegular()) return true;
|
|
|
|
if (autoTests == null) return false;
|
|
|
|
string action = Name.Substring(1, Name.IndexOf(']') - 1);
|
|
return autoTests.Contains(action);
|
|
}
|
|
|
|
public virtual void ResetChngdFlags()
|
|
{
|
|
QtgTextChngd = false;
|
|
QfromTextChngd = false;
|
|
QtoTextChngd = false;
|
|
VolumeTextChngd = false;
|
|
TempLimLoTextChngd = false;
|
|
TempLimHiTextChngd = false;
|
|
}
|
|
|
|
// Makes a new copy of this object (not just a reference)
|
|
public virtual Test Clone()
|
|
{
|
|
Test result = new Test(Name, ItemNr, Procedure);
|
|
|
|
result.Part = Part;
|
|
result.Profile = Profile;
|
|
result.Publish = Publish;
|
|
result.DoEvaluate = DoEvaluate;
|
|
result.Qtg = Qtg;
|
|
result.Qfrom = Qfrom;
|
|
result.Qto = Qto;
|
|
result.Volume = Volume;
|
|
result.TestTime = TestTime;
|
|
result.Method = Method;
|
|
result.ErrLimLo = ErrLimLo;
|
|
result.ErrLimHi = ErrLimHi;
|
|
result.Uncertainty = Uncertainty;
|
|
result.Repeats = Repeats;
|
|
result.DoDraining = DoDraining;
|
|
result.DoDrainingAfter = DoDrainingAfter;
|
|
result.TempLimLo = TempLimLo;
|
|
result.TempLimHi = TempLimHi;
|
|
result.TempControl = TempControl;
|
|
result.PumpPower = PumpPower;
|
|
result.MassRepeats = MassRepeats;
|
|
result.MassSpread = MassSpread;
|
|
result.MassMethod = MassMethod;
|
|
result.TimeBeforeFlow = TimeBeforeFlow;
|
|
result.TimeFlow2Mass = TimeFlow2Mass;
|
|
result.TimePump2StartV = TimePump2StartV;
|
|
result.TimeStop2Mass = TimeStop2Mass;
|
|
result.ShortPulses = ShortPulses;
|
|
result.RedType = RedType;
|
|
result.FeedingPath = FeedingPath;
|
|
result.BenchPath = BenchPath;
|
|
result.OutputPath = OutputPath;
|
|
result.MetersPath = MetersPath;
|
|
#if HEAT_METERS
|
|
result.HeatMetersPath = HeatMetersPath;
|
|
#endif
|
|
result.TransBefore = TransBefore;
|
|
result.TransBetween = TransBetween;
|
|
result.TransAfter = TransAfter;
|
|
#if ORACLE_DB
|
|
result.OraId = OraId;
|
|
result.OraIdRepetMulti = OraIdRepetMulti;
|
|
result.OraDesignation = OraDesignation;
|
|
result.RawDataId = RawDataId;
|
|
result.RawDataIdRepetMulti = RawDataIdRepetMulti;
|
|
result.RawDataDesignation = RawDataDesignation;
|
|
#endif
|
|
result.VolumeUnit = VolumeUnit;
|
|
result.FlowUnit = FlowUnit;
|
|
result.MassUnit = MassUnit;
|
|
result.TempUnit = TempUnit;
|
|
result.PressUnit = PressUnit;
|
|
result.LengthUnit = LengthUnit;
|
|
foreach (var prms in MoreParams) { result.MoreParams.Add(prms.Clone()); }
|
|
|
|
return result;
|
|
}
|
|
|
|
public virtual void Export(StreamWriter output)
|
|
{
|
|
CultureInfo ci = CultureInfo.InvariantCulture;
|
|
|
|
output.WriteLine(Name);
|
|
output.WriteLine(Part.ToString(ci));
|
|
output.WriteLine(Publish.ToString(ci));
|
|
output.WriteLine(DoEvaluate.ToString());
|
|
output.WriteLine(Qtg.ToString(ci));
|
|
output.WriteLine(Qfrom.ToString(ci));
|
|
output.WriteLine(Qto.ToString(ci));
|
|
output.WriteLine(Volume.ToString(ci));
|
|
output.WriteLine(TestTime.ToString(ci));
|
|
output.WriteLine(Method);
|
|
output.WriteLine(ErrLimLo.ToString(ci));
|
|
output.WriteLine(ErrLimHi.ToString(ci));
|
|
output.WriteLine(Uncertainty.ToString(ci));
|
|
output.WriteLine(Repeats.ToString(ci));
|
|
output.WriteLine(DoDraining.ToString());
|
|
output.WriteLine(DoDrainingAfter.ToString());
|
|
output.WriteLine(TempLimLo.ToString(ci));
|
|
output.WriteLine(TempLimHi.ToString(ci));
|
|
output.WriteLine((TempControl != null) ? TempControl : string.Empty);
|
|
output.WriteLine(PumpPower.ToString(ci));
|
|
output.WriteLine(MassRepeats.ToString(ci));
|
|
output.WriteLine(MassSpread.ToString(ci));
|
|
output.WriteLine(((byte)MassMethod).ToString(ci));
|
|
output.WriteLine(TimeBeforeFlow.ToString(ci));
|
|
output.WriteLine(TimeFlow2Mass.ToString(ci));
|
|
output.WriteLine(TimePump2StartV.ToString(ci));
|
|
output.WriteLine(TimeStop2Mass.ToString(ci));
|
|
output.WriteLine(FeedingPath);
|
|
output.WriteLine(BenchPath);
|
|
output.WriteLine(OutputPath);
|
|
output.WriteLine(MetersPath);
|
|
output.WriteLine(TransBefore);
|
|
output.WriteLine(TransBetween);
|
|
output.WriteLine(Profile);
|
|
output.WriteLine(TransAfter);
|
|
#if ORACLE_DB
|
|
output.WriteLine(OraId);
|
|
output.WriteLine(OraIdRepetMulti);
|
|
output.WriteLine(OraDesignation);
|
|
output.WriteLine(RawDataId);
|
|
output.WriteLine(RawDataIdRepetMulti);
|
|
output.WriteLine(RawDataDesignation);
|
|
#endif
|
|
foreach (var prms in MoreParams) { prms.Export(output); }
|
|
output.WriteLine();
|
|
}
|
|
|
|
public static Test Import(StreamReader input, Procedure newProcedure)
|
|
{
|
|
string firstLine = input.ReadLine();
|
|
if (string.IsNullOrEmpty(firstLine))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
CultureInfo ci = CultureInfo.InvariantCulture;
|
|
Test tst = new Test();
|
|
|
|
tst.Name = firstLine;
|
|
tst.Part = int.Parse(input.ReadLine(), ci);
|
|
tst.Publish = sbyte.Parse(input.ReadLine(), ci);
|
|
tst.DoEvaluate = bool.Parse(input.ReadLine());
|
|
tst.Qtg = double.Parse(input.ReadLine(), ci);
|
|
tst.Qfrom = double.Parse(input.ReadLine(), ci);
|
|
tst.Qto = double.Parse(input.ReadLine(), ci);
|
|
tst.Volume = double.Parse(input.ReadLine(), ci);
|
|
tst.TestTime = double.Parse(input.ReadLine(), ci);
|
|
tst.Method = input.ReadLine();
|
|
tst.ErrLimLo = float.Parse(input.ReadLine(), ci);
|
|
tst.ErrLimHi = float.Parse(input.ReadLine(), ci);
|
|
tst.Uncertainty = float.Parse(input.ReadLine(), ci);
|
|
tst.Repeats = int.Parse(input.ReadLine(), ci);
|
|
tst.DoDraining = bool.Parse(input.ReadLine());
|
|
tst.DoDrainingAfter = bool.Parse(input.ReadLine());
|
|
tst.TempLimLo = float.Parse(input.ReadLine(), ci);
|
|
tst.TempLimHi = float.Parse(input.ReadLine(), ci);
|
|
tst.TempControl = input.ReadLine();
|
|
tst.PumpPower = float.Parse(input.ReadLine(), ci);
|
|
tst.MassRepeats = int.Parse(input.ReadLine(), ci);
|
|
tst.MassSpread = float.Parse(input.ReadLine(), ci);
|
|
tst.MassMethod = (MassMethod)byte.Parse(input.ReadLine(), ci);
|
|
tst.TimeBeforeFlow = int.Parse(input.ReadLine(), ci);
|
|
tst.TimeFlow2Mass = int.Parse(input.ReadLine(), ci);
|
|
tst.TimePump2StartV = int.Parse(input.ReadLine(), ci);
|
|
tst.TimeStop2Mass = int.Parse(input.ReadLine(), ci);
|
|
tst.FeedingPath = input.ReadLine();
|
|
tst.BenchPath = input.ReadLine();
|
|
tst.OutputPath = input.ReadLine();
|
|
tst.MetersPath = input.ReadLine();
|
|
tst.TransBefore = input.ReadLine();
|
|
tst.TransBetween = input.ReadLine();
|
|
string line = input.ReadLine();
|
|
tst.Profile = line.Equals(TestProfile.ProtectedHeatMeter.ToString()) ? TestProfile.ProtectedHeatMeter
|
|
: line.Equals(TestProfile.UserDefinedHeatMeter.ToString()) ? TestProfile.UserDefinedHeatMeter
|
|
: line.Equals(TestProfile.Protected.ToString()) ? TestProfile.Protected : TestProfile.UserDefined; /// UserDefined is the default
|
|
tst.TransAfter = input.ReadLine();
|
|
#if ORACLE_DB
|
|
tst.OraId = int.Parse(input.ReadLine(), ci);
|
|
tst.OraIdRepetMulti = int.Parse(input.ReadLine(), ci);
|
|
tst.OraDesignation = input.ReadLine();
|
|
tst.RawDataId = int.Parse(input.ReadLine(), ci);
|
|
tst.RawDataIdRepetMulti = int.Parse(input.ReadLine(), ci);
|
|
tst.RawDataDesignation = input.ReadLine();
|
|
#endif
|
|
|
|
while (true)
|
|
{
|
|
ComponentTest prms = ComponentTest.Import(input, tst);
|
|
if (prms == null)
|
|
break;
|
|
else
|
|
tst.MoreParams.Add(prms);
|
|
}
|
|
|
|
tst.Procedure = newProcedure;
|
|
return tst;
|
|
}
|
|
|
|
public virtual string Compare(StreamReader inp)
|
|
{
|
|
System.Text.StringBuilder diff = new System.Text.StringBuilder();
|
|
string fmt = string.Format("Test {0} : ", Name) + "{0} = {1}\r\n (in the file {2})\r\n";
|
|
string ln;
|
|
CultureInfo ci = CultureInfo.InvariantCulture;
|
|
|
|
string firstLine = inp.ReadLine();
|
|
if (string.IsNullOrEmpty(firstLine)) return string.Format("Test {0} is missing in the file\r\n", Name);
|
|
|
|
if (Name != firstLine) { diff.AppendFormat(fmt, "Name", Name, firstLine); };
|
|
ln = inp.ReadLine(); if (ln != Part.ToString(ci)) { diff.AppendFormat(fmt, "Part", Part.ToString(ci), ln); };
|
|
ln = inp.ReadLine(); if (ln != Publish.ToString(ci)) { diff.AppendFormat(fmt, "Publish", Publish.ToString(ci), ln); };
|
|
ln = inp.ReadLine(); if (ln != DoEvaluate.ToString(ci)) { diff.AppendFormat(fmt, "Evaluate", DoEvaluate.ToString(ci), ln); };
|
|
ln = inp.ReadLine(); if (ln != Qtg.ToString(ci)) { diff.AppendFormat(fmt, "Qtg", Qtg.ToString(ci), ln); };
|
|
ln = inp.ReadLine(); if (ln != Qfrom.ToString(ci)) { diff.AppendFormat(fmt, "Qfrom", Qfrom.ToString(ci), ln); };
|
|
ln = inp.ReadLine(); if (ln != Qto.ToString(ci)) { diff.AppendFormat(fmt, "Qto", Qto.ToString(ci), ln); };
|
|
ln = inp.ReadLine(); if (ln != Volume.ToString(ci)) { diff.AppendFormat(fmt, "Volume", Volume.ToString(ci), ln); };
|
|
ln = inp.ReadLine(); if (ln != TestTime.ToString(ci)) { diff.AppendFormat(fmt, "TstTime", TestTime.ToString(ci), ln); };
|
|
ln = inp.ReadLine(); if (ln != Method) { diff.AppendFormat(fmt, "Method", Method, ln); };
|
|
ln = inp.ReadLine(); if (ln != ErrLimLo.ToString(ci)) { diff.AppendFormat(fmt, "ErrLimLo", ErrLimLo.ToString(ci), ln); };
|
|
ln = inp.ReadLine(); if (ln != ErrLimHi.ToString(ci)) { diff.AppendFormat(fmt, "ErrLimHi", ErrLimHi.ToString(ci), ln); };
|
|
ln = inp.ReadLine(); if (ln != Uncertainty.ToString(ci)) { diff.AppendFormat(fmt, "Uncertainty", Uncertainty.ToString(ci), ln); };
|
|
ln = inp.ReadLine(); if (ln != Repeats.ToString(ci)) { diff.AppendFormat(fmt, "Repeats", Repeats.ToString(ci), ln); };
|
|
ln = inp.ReadLine(); if (ln != DoDraining.ToString(ci)) { diff.AppendFormat(fmt, "Draining", DoDraining.ToString(ci), ln); };
|
|
ln = inp.ReadLine(); if (ln != DoDrainingAfter.ToString(ci)) { diff.AppendFormat(fmt, "Zeroing", DoDrainingAfter.ToString(ci), ln); };
|
|
ln = inp.ReadLine(); if (ln != TempLimLo.ToString(ci)) { diff.AppendFormat(fmt, "TempLimLo", TempLimLo.ToString(ci), ln); };
|
|
ln = inp.ReadLine(); if (ln != TempLimHi.ToString(ci)) { diff.AppendFormat(fmt, "TempLimHi", TempLimHi.ToString(ci), ln); };
|
|
ln = inp.ReadLine(); if (ln != TempControl) { diff.AppendFormat(fmt, "TempController", TempControl, ln); };
|
|
ln = inp.ReadLine(); if (ln != PumpPower.ToString(ci)) { diff.AppendFormat(fmt, "PumpPower", PumpPower.ToString(ci), ln); };
|
|
ln = inp.ReadLine(); if (ln != MassRepeats.ToString(ci)) { diff.AppendFormat(fmt, "MassRepeats", MassRepeats.ToString(ci), ln); };
|
|
ln = inp.ReadLine(); if (ln != MassSpread.ToString(ci)) { diff.AppendFormat(fmt, "MassSpread", MassSpread.ToString(ci), ln); };
|
|
ln = inp.ReadLine(); if (ln != ((byte)MassMethod).ToString(ci)) { diff.AppendFormat(fmt, "MassMethod", ((byte)MassMethod).ToString(ci), ln); };
|
|
ln = inp.ReadLine(); if (ln != TimeBeforeFlow.ToString(ci)) { diff.AppendFormat(fmt, "TimeBeforeFlow", TimeBeforeFlow.ToString(ci), ln); };
|
|
ln = inp.ReadLine(); if (ln != TimeFlow2Mass.ToString(ci)) { diff.AppendFormat(fmt, "TimeFlow2Mass", TimeFlow2Mass.ToString(ci), ln); };
|
|
ln = inp.ReadLine(); if (ln != TimePump2StartV.ToString(ci)) { diff.AppendFormat(fmt, "TimePump2StartV", TimePump2StartV.ToString(ci), ln); };
|
|
ln = inp.ReadLine(); if (ln != TimeStop2Mass.ToString(ci)) { diff.AppendFormat(fmt, "TimeStop2Mass", TimeStop2Mass.ToString(ci), ln); };
|
|
ln = inp.ReadLine(); if (ln != FeedingPath) { diff.AppendFormat(fmt, "FeedingPath", FeedingPath, ln); };
|
|
ln = inp.ReadLine(); if (ln != BenchPath) { diff.AppendFormat(fmt, "BenchPath", BenchPath, ln); };
|
|
ln = inp.ReadLine(); if (ln != OutputPath) { diff.AppendFormat(fmt, "OutputPath", OutputPath, ln); };
|
|
ln = inp.ReadLine(); if (ln != MetersPath) { diff.AppendFormat(fmt, "MetersPath", MetersPath, ln); };
|
|
ln = inp.ReadLine(); if (ln != TransBefore) { diff.AppendFormat(fmt, "RelTransBefore", TransBefore, ln); };
|
|
ln = inp.ReadLine(); if (ln != TransBetween) { diff.AppendFormat(fmt, "RelTransBetween", TransBetween, ln); };
|
|
ln = inp.ReadLine(); if (ln != Profile.ToString()) { diff.AppendFormat(fmt, "RelTransAfter", Profile, ln); };
|
|
ln = inp.ReadLine(); if (ln != TransAfter) { diff.AppendFormat(fmt, "TransitionAfter", TransAfter, ln); };
|
|
#if ORACLE_DB
|
|
ln = inp.ReadLine(); if (ln != OraId.ToString(ci)) { diff.AppendFormat(fmt, "OraId", OraId.ToString(ci), ln); };
|
|
ln = inp.ReadLine(); if (ln != OraIdRepetMulti.ToString(ci)) { diff.AppendFormat(fmt, "OraIdRepetMulti", OraIdRepetMulti.ToString(ci), ln); };
|
|
ln = inp.ReadLine(); if (ln != OraDesignation) { diff.AppendFormat(fmt, "OraDesignation", OraDesignation, ln); };
|
|
ln = inp.ReadLine(); if (ln != RawDataId.ToString(ci)) { diff.AppendFormat(fmt, "RawDataId", RawDataId.ToString(ci), ln); };
|
|
ln = inp.ReadLine(); if (ln != RawDataIdRepetMulti.ToString(ci)){ diff.AppendFormat(fmt, "RawDataIdRepetMulti", RawDataIdRepetMulti.ToString(ci), ln); };
|
|
ln = inp.ReadLine(); if (ln != RawDataDesignation) { diff.AppendFormat(fmt, "RawDataDesignation", RawDataDesignation, ln); };
|
|
#endif
|
|
return diff.ToString();
|
|
}
|
|
|
|
public virtual ComponentTest GetTestParamsEntity(string cmpntName)
|
|
{
|
|
foreach (var tstPrms in MoreParams)
|
|
{
|
|
if (tstPrms.CmpntName == cmpntName) return tstPrms;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Return test title for a this test and a given repetition number
|
|
/// </summary>
|
|
/// <param name="repetitonNr">1 .. Nr. repetitions</param>
|
|
/// <returns>Test title (string)</returns>
|
|
public virtual string GetExpandedTestName(int repetitionNr)
|
|
{
|
|
if (Repeats == 1)
|
|
{
|
|
if (Part == 0)
|
|
{
|
|
/// Single test
|
|
return Name;
|
|
}
|
|
else
|
|
{
|
|
/// A part of a single test
|
|
return string.Format("{0} ({1})", Name, Part);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/// More test repetitions
|
|
return string.Format("{0} ({1}/{2})", Name, repetitionNr, Repeats);
|
|
}
|
|
}
|
|
|
|
public virtual double GetErrLimLo(double volumeCTV, double testTime)
|
|
{
|
|
if (ErrLimLo <= ErrLimHi)
|
|
{
|
|
return ErrLimLo; /// Error limit of a water meter
|
|
}
|
|
else
|
|
{
|
|
/// Metrological class and nominal flow of a heat meter
|
|
int metrClass = (int)Math.Round(ErrLimLo);
|
|
double Qp = Math.Abs(ErrLimHi);
|
|
double Q = (testTime == 0) ? 1 : Math.Max(3.6 * volumeCTV / testTime, 0.00001); /// Div. by zero avoided
|
|
|
|
/// Calculate the error limit of a heat meter
|
|
switch (metrClass)
|
|
{
|
|
default:
|
|
case 1: return -Math.Min(3.5, 1.0 + 0.01 * Qp / Q);
|
|
case 2: return -Math.Min(5.0, 2.0 + 0.02 * Qp / Q);
|
|
case 3: return -Math.Min(5.0, 3.0 + 0.05 * Qp / Q);
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual double GetErrLimHi(double volumeCTV, double testTime)
|
|
{
|
|
if (ErrLimLo <= ErrLimHi)
|
|
{
|
|
return ErrLimHi; /// Error limit of a water meter
|
|
}
|
|
else
|
|
{
|
|
/// Metrological class and nominal flow of a heat meter
|
|
int metrClass = (int)Math.Round(ErrLimLo);
|
|
double Qp = Math.Abs(ErrLimHi);
|
|
double Q = (testTime == 0) ? 1 : Math.Max(3.6 * volumeCTV / testTime, 0.00001); /// Div. by zero avoided
|
|
|
|
/// Calculate the error limit of a heat meter
|
|
switch (metrClass)
|
|
{
|
|
default:
|
|
case 1: return +Math.Min(3.5, 1.0 + 0.01 * Qp / Q);
|
|
case 2: return +Math.Min(5.0, 2.0 + 0.02 * Qp / Q);
|
|
case 3: return +Math.Min(5.0, 3.0 + 0.05 * Qp / Q);
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual bool IsPartCompatible(int waterMeterPartNr)
|
|
{
|
|
if ((this.Part == 0) || (waterMeterPartNr == 0)) return true;
|
|
|
|
if ((this.Part % 10) == waterMeterPartNr) return true;
|
|
if (((this.Part / 10) % 10) == waterMeterPartNr) return true;
|
|
if (((this.Part / 100) % 10) == waterMeterPartNr) return true;
|
|
if (((this.Part / 1000) % 10) == waterMeterPartNr) return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string partStr = (Part > 0) ? string.Format(", part {0}", Part) : string.Empty;
|
|
|
|
return string.Format("{0}(P.{1},{2}){3}", Name, ((Publish)Publish).ToString(), DoEvaluate ? "E" : "-", partStr);
|
|
}
|
|
}
|
|
}
|