tbf/Config/Entities/Test.cs

///
/// Copyright (c) 2013-2017 Sensus Metering Systems
///
using System;
using System.Collections.Generic;
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());
            output.WriteLine(Publish.ToString());
            output.WriteLine(Evaluate.ToString());
            output.WriteLine(Qfrom.ToString());
            output.WriteLine(Qto.ToString());
            output.WriteLine(Volume.ToString());
            output.WriteLine(TstTime.ToString());
            output.WriteLine(Method);
            output.WriteLine(ErrLimLo.ToString());
            output.WriteLine(ErrLimHi.ToString());
            output.WriteLine(Uncertainty.ToString());
            output.WriteLine(Repeats.ToString());
            output.WriteLine(Draining.ToString());
            output.WriteLine(Zeroing.ToString());
            output.WriteLine(PumpPower.ToString());
            output.WriteLine(MassRepeats.ToString());
            output.WriteLine(MassSpread.ToString());
            output.WriteLine(((byte)MassMethod).ToString());
            output.WriteLine(TimeBeforeFlow.ToString());
            output.WriteLine(TimeFlow2Mass.ToString());
            output.WriteLine(TimePump2StartV.ToString());
            output.WriteLine(TimeStop2Mass.ToString());
            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());
            tst.Publish = sbyte.Parse(input.ReadLine());
            tst.Evaluate = bool.Parse(input.ReadLine());
            tst.Qfrom = float.Parse(input.ReadLine());
            tst.Qto = float.Parse(input.ReadLine());
            tst.Volume = float.Parse(input.ReadLine());
            tst.TstTime = float.Parse(input.ReadLine());
            tst.Method = input.ReadLine();
            tst.ErrLimLo = float.Parse(input.ReadLine());
            tst.ErrLimHi = float.Parse(input.ReadLine());
            tst.Uncertainty = float.Parse(input.ReadLine());
            tst.Repeats = int.Parse(input.ReadLine());
            tst.Draining = bool.Parse(input.ReadLine());
            tst.Zeroing = bool.Parse(input.ReadLine());
            tst.PumpPower = float.Parse(input.ReadLine());
            tst.MassRepeats = int.Parse(input.ReadLine());
            tst.MassSpread = float.Parse(input.ReadLine());
            tst.MassMethod = (MassMethod)byte.Parse(input.ReadLine());
            tst.TimeBeforeFlow = int.Parse(input.ReadLine());
            tst.TimeFlow2Mass = int.Parse(input.ReadLine());
            tst.TimePump2StartV = int.Parse(input.ReadLine());
            tst.TimeStop2Mass = int.Parse(input.ReadLine());
            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);
		}
    }
}