243 lines
11 KiB
C#
243 lines
11 KiB
C#
///
|
|
/// Copyright (c) 2013-2017 Sensus Metering Systems
|
|
///
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
|
|
namespace Config.Entities
|
|
{
|
|
/// <summary>
|
|
/// Test, consisting of one or more repetitions of the test 'SingleTest'.
|
|
/// </summary>
|
|
public class Test : 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 sbyte Publish { get; set; } /// 0=no, 1=in all protocols, 2=on screen, 3=internal
|
|
public virtual bool Evaluate { get; set; }
|
|
public virtual float Qfrom { get; set; } /// Water flow low limit in [m3/h]
|
|
public virtual float Qto { get; set; } /// Water flow high limit in [m3/h]
|
|
public virtual float Volume { get; set; } /// Test volume (target) in [l]
|
|
public virtual float TstTime { get; set; } /// Test time (estimate) in [s]
|
|
public virtual string Method { get; set; }
|
|
public virtual float ErrLimLo { get; set; } /// in [%] (usually < 0)
|
|
public virtual float ErrLimHi { get; set; } /// in [%] (usually > 0)
|
|
public virtual float Uncertainty { get; set; } /// int [%] makes error limits tighter: 0 <= Uncertainty <= abs(ErrLimXx)
|
|
public virtual int Repeats { get; set; }
|
|
public virtual bool Draining { get; set; }
|
|
public virtual bool Zeroing { get; set; }
|
|
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 TolerRed { get; set; } /// = Filter
|
|
public virtual TestRedType 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 RelTransBefore { get; set; }
|
|
public virtual string RelTransBetween { get; set; }
|
|
public virtual string RelTransAfter { get; set; }
|
|
public virtual string TransitionAfter { get; set; }
|
|
|
|
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
|
|
///
|
|
Publish = (sbyte)Config.Entities.Publish.Always;
|
|
Evaluate = true;
|
|
Repeats = 1;
|
|
Draining = false;
|
|
Zeroing = false;
|
|
ErrLimLo = -2.0f; /// [%] lower error limit
|
|
ErrLimHi = 2.0f; /// [%] upper error limit
|
|
Uncertainty = 0;
|
|
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
|
|
TolerRed = 0; /// = Filter parameter
|
|
RelTransBefore = string.Empty;
|
|
RelTransBetween = string.Empty;
|
|
RelTransAfter = string.Empty;
|
|
TransitionAfter = string.Empty;
|
|
}
|
|
|
|
public Test(string name, int itemNr, Procedure procedure)
|
|
: this()
|
|
{
|
|
Name = name;
|
|
ItemNr = itemNr;
|
|
Procedure = procedure;
|
|
}
|
|
|
|
// 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.Publish = Publish;
|
|
result.Evaluate = Evaluate;
|
|
result.Qfrom = Qfrom;
|
|
result.Qto = Qto;
|
|
result.Volume = Volume;
|
|
result.TstTime = TstTime;
|
|
result.Repeats = Repeats;
|
|
result.Draining = Draining;
|
|
result.Zeroing = Zeroing;
|
|
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.Method = Method;
|
|
result.ErrLimLo = ErrLimLo;
|
|
result.ErrLimHi = ErrLimHi;
|
|
result.Uncertainty = Uncertainty;
|
|
result.TolerRed = TolerRed;
|
|
result.RedType = RedType;
|
|
result.FeedingPath = FeedingPath;
|
|
result.BenchPath = BenchPath;
|
|
result.OutputPath = OutputPath;
|
|
result.MetersPath = MetersPath;
|
|
#if HEAT_METERS
|
|
result.HeatMetersPath = HeatMetersPath;
|
|
#endif
|
|
result.RelTransBefore = RelTransBefore;
|
|
result.RelTransBetween = RelTransBetween;
|
|
result.RelTransAfter = RelTransAfter;
|
|
result.TransitionAfter = TransitionAfter;
|
|
foreach (var prms in MoreParams) { result.MoreParams.Add(prms.Clone()); }
|
|
|
|
return result;
|
|
}
|
|
|
|
public virtual void Export(StreamWriter output)
|
|
{
|
|
output.WriteLine(Name);
|
|
output.WriteLine(Part.ToString(CultureInfo.InvariantCulture));
|
|
output.WriteLine(Publish.ToString(CultureInfo.InvariantCulture));
|
|
output.WriteLine(Evaluate.ToString());
|
|
output.WriteLine(Qfrom.ToString(CultureInfo.InvariantCulture));
|
|
output.WriteLine(Qto.ToString(CultureInfo.InvariantCulture));
|
|
output.WriteLine(Volume.ToString(CultureInfo.InvariantCulture));
|
|
output.WriteLine(TstTime.ToString(CultureInfo.InvariantCulture));
|
|
output.WriteLine(Method);
|
|
output.WriteLine(ErrLimLo.ToString(CultureInfo.InvariantCulture));
|
|
output.WriteLine(ErrLimHi.ToString(CultureInfo.InvariantCulture));
|
|
output.WriteLine(Uncertainty.ToString(CultureInfo.InvariantCulture));
|
|
output.WriteLine(Repeats.ToString(CultureInfo.InvariantCulture));
|
|
output.WriteLine(Draining.ToString());
|
|
output.WriteLine(Zeroing.ToString());
|
|
output.WriteLine(PumpPower.ToString(CultureInfo.InvariantCulture));
|
|
output.WriteLine(MassRepeats.ToString(CultureInfo.InvariantCulture));
|
|
output.WriteLine(MassSpread.ToString(CultureInfo.InvariantCulture));
|
|
output.WriteLine(((byte)MassMethod).ToString(CultureInfo.InvariantCulture));
|
|
output.WriteLine(TimeBeforeFlow.ToString(CultureInfo.InvariantCulture));
|
|
output.WriteLine(TimeFlow2Mass.ToString(CultureInfo.InvariantCulture));
|
|
output.WriteLine(TimePump2StartV.ToString(CultureInfo.InvariantCulture));
|
|
output.WriteLine(TimeStop2Mass.ToString(CultureInfo.InvariantCulture));
|
|
output.WriteLine(FeedingPath);
|
|
output.WriteLine(BenchPath);
|
|
output.WriteLine(OutputPath);
|
|
output.WriteLine(MetersPath);
|
|
output.WriteLine(RelTransBefore);
|
|
output.WriteLine(RelTransBetween);
|
|
output.WriteLine(RelTransAfter);
|
|
output.WriteLine(TransitionAfter);
|
|
|
|
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;
|
|
|
|
Test tst = new Test();
|
|
tst.Name = firstLine;
|
|
tst.Part = int.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
|
|
tst.Publish = sbyte.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
|
|
tst.Evaluate = bool.Parse(input.ReadLine());
|
|
tst.Qfrom = float.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
|
|
tst.Qto = float.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
|
|
tst.Volume = float.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
|
|
tst.TstTime = float.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
|
|
tst.Method = input.ReadLine();
|
|
tst.ErrLimLo = float.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
|
|
tst.ErrLimHi = float.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
|
|
tst.Uncertainty = float.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
|
|
tst.Repeats = int.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
|
|
tst.Draining = bool.Parse(input.ReadLine());
|
|
tst.Zeroing = bool.Parse(input.ReadLine());
|
|
tst.PumpPower = float.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
|
|
tst.MassRepeats = int.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
|
|
tst.MassSpread = float.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
|
|
tst.MassMethod = (MassMethod)byte.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
|
|
tst.TimeBeforeFlow = int.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
|
|
tst.TimeFlow2Mass = int.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
|
|
tst.TimePump2StartV = int.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
|
|
tst.TimeStop2Mass = int.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
|
|
tst.FeedingPath = input.ReadLine();
|
|
tst.BenchPath = input.ReadLine();
|
|
tst.OutputPath = input.ReadLine();
|
|
tst.MetersPath = input.ReadLine();
|
|
tst.RelTransBefore = input.ReadLine();
|
|
tst.RelTransBetween = input.ReadLine();
|
|
tst.RelTransAfter = input.ReadLine();
|
|
tst.TransitionAfter = input.ReadLine();
|
|
|
|
while (true)
|
|
{
|
|
ComponentTest prms = ComponentTest.Import(input, tst);
|
|
if (prms == null)
|
|
break;
|
|
else
|
|
tst.MoreParams.Add(prms);
|
|
}
|
|
|
|
tst.Procedure = newProcedure;
|
|
return tst;
|
|
}
|
|
|
|
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(), Evaluate ? "E" : "-", partStr);
|
|
}
|
|
}
|
|
}
|