tbf/Results/Entities/TestRslt.cs

///
/// Copyright (c) 2015-2018 Sensus Slovensko a.s.
///
using System;
using System.Collections.Generic;
using System.Text;

namespace Results.Entities
{
    public class TestRslt
    {
		/// Identity
        public virtual int Id { get; protected set; }
		public virtual Batch Batch { get; set; }
		public virtual TestData TestData { get; set; }
		public virtual Components Components { get; set; }
        public virtual int Part { get; set; }
		public virtual int RepetitionNr { get; set; }           /// Repetition number from the set of repeated tests (1...)
        public virtual string MethodClass { get; set; }         /// Not mapped to DB, does not depend on localization and customer

		/// Main results
		public virtual bool TestDone { get; set; }
        public virtual string Remark { get; set; }
		public virtual DateTime StartTime { get; set; }         /// Date and time of the test start
		public virtual DateTime EndTime { get; set; }           /// Date and time of the test end
		public virtual int FlowSetTime { get; set; }            /// [s]     Flow set time in seconds
        public virtual int TimeBtwnMassMsrmnts { get; set; }    /// [s]     Time between two mass measurements in seconds (if applicable)
        public virtual double TestTime { get; set; }            /// [s]     Test time in seconds
        public virtual double TestTimeCorrection { get; set; }  /// [s]     Correction of the test time due to diverter (0 for methods w/o diverter or when there is no correction table)
		public virtual double PulsesMaster { get; set; }        /// [pls]   FlyingStartMassCollectionProlonged: MID pulses of the water to the tank 
        public virtual double TotalPulsesMstr { get; set; }     /// [pls]   FlyingStartMassCollectionProlonged: MID pulses of the complete test (not mapped to DB)
        public virtual double ConstMasterRaw { get; set; }      /// [l/pls] Liters per pulse of the master flow meter uncorrected.
        public virtual double ConstMasterCorr { get; set; }     /// [l/pls] Liters per pulse of the master flow meter corrected by a correction table.
        public virtual double ConstMaster { get; set; }         /// [l/pls] Liters per pulse of the master flow meter calculated from a mass measurement.
                                                                ///         When mass measurement is not available, corrected by a correction table.
        public virtual double MassStartRaw { get; set; }	/// [kg]
		public virtual double MassStart { get; set; }		/// [kg]
		public virtual double MassEndRaw { get; set; }		/// [kg]
		public virtual double MassEnd { get; set; }			/// [kg]
		public virtual double DensityIn { get; set; }		/// [kg/m3]
		public virtual double DensityLine { get; set; }		/// [kg/m3]
		public virtual double DensityDiv { get; set; }		/// [kg/m3]
		public virtual double Buoyancy { get; set; }
		public virtual double FlowMass { get; set; }        /// [kg/h] calculated from conventional true value
		public virtual double FlowVolume { get; set; }		/// [m3/h]
		public virtual double VolumeCTV { get; set; }       /// [l]    Volume conventional true value
		public virtual double VolumeMaster { get; set; }    /// [l]    Volume from the master flow meter
		public virtual double ErrorMaster { get; set; }		/// [%]    Error of the master flow meter

        public virtual float  DiverterStart { get; set; }   /// [s]    Diverter switch time when test starts
        public virtual float  DivStart10 { get; set; }      /// [s]    Diverter switch time when test starts at level 10 (e.g. 10%) (not mapped to DB)
        public virtual float  DivStart50 { get; set; }      /// [s]    Diverter switch time when test starts at level 50 (e.g. 50%) (not mapped to DB)
        public virtual float  DivStart90 { get; set; }      /// [s]    Diverter switch time when test starts at level 90 (e.g. 90%) (not mapped to DB)
        
        public virtual float  DiverterEnd { get; set; }     /// [s]    Diverter switch time when test ends
        public virtual float  DivEnd90 { get; set; }        /// [s]    Diverter switch time when test starts at level 90 (e.g. 90%) (not mapped to DB)
        public virtual float  DivEnd50 { get; set; }        /// [s]    Diverter switch time when test starts at level 50 (e.g. 50%) (not mapped to DB)
        public virtual float  DivEnd10 { get; set; }        /// [s]    Diverter switch time when test starts at level 10 (e.g. 10%) (not mapped to DB)
        
        public virtual int    ErrorFlags { get; set; }		/// bitfield : bit0=E1, bit1=E2, bit2=E3, etc.
		public virtual sbyte  ErrorFlagsMd { get; set; }	/// 0=off, 1=info, 2=on (evaluated in MeterTestRslt.Passed)

		/// Main results of heat meters
		public virtual double RefEnergy { get; set; }		/// [J]    Joul

		/// Auxiliary results
        public virtual float AmbTempMean { get; set; }		/// [°C]   Average ambient air temperature
		public virtual float AmbTempStart { get; set; }		/// [°C]   Ambient air temperature on test start
		public virtual float AmbTempEnd { get; set; }		/// [°C]   Ambient air temperature on test end
		public virtual float AmbTempMin { get; set; }		/// [°C]   Minimum ambient air temperature
		public virtual float AmbTempMax { get; set; }		/// [°C]   Maximum ambient air temperature
        public virtual float AmbPressMean { get; set; }		/// [bar]  Average ambient air pressure
		public virtual float AmbPressStart { get; set; }	/// [bar]  Ambient air pressure on test start
		public virtual float AmbPressEnd { get; set; }		/// [bar]  Ambient air pressure on test end
		public virtual float AmbPressMin { get; set; }		/// [bar]  Minimum ambient air pressure
		public virtual float AmbPressMax { get; set; }		/// [bar]  Maximum ambient air pressure
		public virtual float AmbHumiMean { get; set; }		/// [%]    Average ambient air relative humidity
		public virtual float AmbHumiStart { get; set; }		/// [%]    Ambient air relative humidity on test start
		public virtual float AmbHumiEnd { get; set; }		/// [%]    Ambient air relative humidity on test end
		public virtual float AmbHumiMin { get; set; }		/// [%]    Minimum ambient air relative humidity
		public virtual float AmbHumiMax { get; set; }		/// [%]    Maximum ambient air relative humidity
		public virtual float PressUpMean { get; set; }      /// [bar]  Input water pressure (average)
		public virtual float PressUpStart { get; set; }     /// [bar]
		public virtual float PressUpEnd { get; set; }       /// [bar]
		public virtual float PressUpMin { get; set; }		/// [bar]
		public virtual float PressUpMax { get; set; }       /// [bar]
		public virtual float PressDownMean { get; set; }    /// [bar]
		public virtual float PressDownStart { get; set; }   /// [bar]
		public virtual float PressDownEnd { get; set; }     /// [bar]
		public virtual float PressDownMin { get; set; }		/// [bar]
		public virtual float PressDownMax { get; set; }     /// [bar]
		public virtual float PressDeltaMean { get; set; }   /// [bar]
		public virtual float PressDeltaStart { get; set; }  /// [bar]
		public virtual float PressDeltaEnd { get; set; }    /// [bar]
		public virtual float PressDeltaMin { get; set; }	/// [bar]
		public virtual float PressDeltaMax { get; set; }    /// [bar]
		public virtual float TempUpMean { get; set; }		/// [°C]
        public virtual float TempUpStart { get; set; }		/// [°C]
        public virtual float TempUpEnd { get; set; }		/// [°C]
        public virtual float TempUpMin { get; set; }		/// [°C]
        public virtual float TempUpMax { get; set; }		/// [°C]
        public virtual float TempDownMean { get; set; }		/// [°C]
        public virtual float TempDownStart { get; set; }	/// [°C]
        public virtual float TempDownEnd { get; set; }		/// [°C]
        public virtual float TempDownMin { get; set; }		/// [°C]
        public virtual float TempDownMax { get; set; }		/// [°C]
        public virtual float TempDivMean { get; set; }		/// [°C]
        public virtual float TempDivStart { get; set; }		/// [°C]
        public virtual float TempDivEnd { get; set; }		/// [°C]
        public virtual float TempDivMin { get; set; }		/// [°C]
        public virtual float TempDivMax { get; set; }		/// [°C]
		public virtual float FlowMean { get; set; }			/// [m3/h] mean flow from the reference flowmeter
		public virtual float FlowStart { get; set; }		/// [m3/h] flow at the start of test from the reference flowmeter
		public virtual float FlowEnd { get; set; }			/// [m3/h] flow at the end of test from the reference flowmeter
        public virtual float FlowMin { get; set; }			/// [m3/h]
        public virtual float FlowMax { get; set; }			/// [m3/h] 

        public virtual float Uncertnt { get; set; }	/// [%] Relative error uncertainty
        public virtual float UncertntScale { get; set; }	/// [%] Contribution to uncertainty from scale
        public virtual float UncertntDensity { get; set; }	/// [%] Contribution to uncertainty from density
        public virtual float UncertntTemp { get; set; }	/// [%] Contribution to uncertainty from temperature
        public virtual float UncertntPressure { get; set; }	/// [%] Contribution to uncertainty from pressure

        public virtual float Custom1  { get; set; }			/// [°C] T ref hi mean
		public virtual float Custom2  { get; set; }			/// [°C] T ref hi start
		public virtual float Custom3  { get; set; }			/// [°C] T ref hi end
		public virtual float Custom4  { get; set; }			/// [°C] T ref hi min
		public virtual float Custom5  { get; set; }			/// [°C] T ref hi max
		public virtual float Custom6  { get; set; }			/// [°C] T ref lo mean
		public virtual float Custom7  { get; set; }			/// [°C] T ref lo start
		public virtual float Custom8  { get; set; }			/// [°C] T ref lo end
		public virtual float Custom9  { get; set; }			/// [°C] T ref lo min
		public virtual float Custom10 { get; set; }			/// [°C] T ref lo max
                                                            
		/// Wrappers
		public virtual string Name()		 { return Utils.GetTestName(TestData.Name, TestData.Repeats, RepetitionNr); }
        public virtual int Repeats()         { return TestData.Repeats; }
		public virtual double Qfrom()		 { return TestData.Qfrom; }
		public virtual double Qto()			 { return TestData.Qto; }
		public virtual double TargetVolume() { return TestData.TargetVolume; }
		public virtual double TargetTime()	 { return TestData.TargetTime; }
		public virtual string Method()		 { return TestData.Method; }
        public virtual string RefFlowmeter() { return (Components != null) ? Components.Flowmeter : string.Empty; }
        public virtual bool IsRelErrTest()   { return (MethodClass != null) ? (MethodClass.Contains("FixedStart") || MethodClass.Contains("FlyingStart") || MethodClass.Contains("CombinedWithDetection") || MethodClass.Contains("DiverterTest")) : true; }
        public virtual bool IsPMaxTest()     { return (MethodClass != null) ? (MethodClass.Contains("PMaxTest") || MethodClass.Contains("LeakTest")) : true; }
        public virtual bool IsStartStop()    { return (MethodClass != null) ? MethodClass.Contains("FixedStart") : true; }
        public virtual bool IsDiverter()     { return (MethodClass != null) ? ((MethodClass.Contains("FlyingStart") && MethodClass.Contains("MassColl")) || MethodClass.Contains("DiverterTest")) : true; }
        public virtual bool IsVolumeMethod() { return (MethodClass != null) ? (MethodClass.Contains("TestMethods.FixedStart.") || MethodClass.Contains("TestMethods.FlyingStart.")) : false; }

        public virtual string MethodElde()
        {
            if (MethodClass == null) return string.Empty;
            else if (MethodClass.Contains("TestMethods.FlyingStartMassCollection.")) return "MS";
            else if (MethodClass.Contains("TestMethods.FlyingStartMassCollectionProlonged.")) return "MS";
            else if (MethodClass.Contains("TestMethods.FlyingStartMassCollectionComparative.")) return "MS";
            else if (MethodClass.Contains("TestMethods.FlyingStart.")) return "VS";
            else if (MethodClass.Contains("TestMethods.FixedStartMassCollection.")) return "MP";
            else if (MethodClass.Contains("TestMethods.FixedStartTankCollection.")) return "VP";
            else if (MethodClass.Contains("TestMethods.FixedStart.")) return "VP";
            else return string.Empty;
        }

		public virtual double ErrLimLo()
        {
            if (TestData.ErrLimLo <= TestData.ErrLimHi)
            {
                return TestData.ErrLimLo;       /// Error limit of a water meter
            }
            else
            {
                /// Metrological class and nominal flow of a heat meter
                int metrClass = (int)Math.Round(TestData.ErrLimLo);
                double Qp = Math.Abs(TestData.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 ErrLimHi()
        {
            if (TestData.ErrLimLo <= TestData.ErrLimHi)
            {
                return TestData.ErrLimHi;       /// Error limit of a water meter
            }
            else
            {
                /// Metrological class and nominal flow of a heat meter
                int metrClass = (int)Math.Round(TestData.ErrLimLo);
                double Qp = Math.Abs(TestData.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 ErrLimMargin()  { return TestData.ErrLimMargin; }
        public virtual float TempLimLo()     { return TestData.TempLimLo; }
        public virtual float TempLimHi()     { return TestData.TempLimHi; }
        public virtual bool Evaluate()       { return TestData.Evaluate; }
		public virtual Config.Entities.Publish Publish() { return (Config.Entities.Publish)TestData.Publish; }


		protected TestRslt()
		{
		}
        
		public TestRslt(Batch batch, TestData testData, int part, int repetitionNr)
			: this()
        {
			Batch = batch;
			TestData = testData;
			Part = part;
			RepetitionNr = repetitionNr;
		}

        public virtual void CopyContentFrom(TestRslt src)
        {
            if (src == null) return;

		    Components = src.Components;    /// ???
		    Part = src.Part;
		    RepetitionNr = src.RepetitionNr;
            MethodClass = src.MethodClass;
            TestDone = src.TestDone;
			Remark = src.Remark;
		    StartTime = src.StartTime;
		    EndTime = src.EndTime;
		    FlowSetTime = src.FlowSetTime;
            TimeBtwnMassMsrmnts = src.TimeBtwnMassMsrmnts;
		    TestTime = src.TestTime;
		    PulsesMaster = src.PulsesMaster;
            TotalPulsesMstr = src.TotalPulsesMstr;
            ConstMasterRaw = src.ConstMasterRaw;
            ConstMasterCorr = src.ConstMasterCorr;
            ConstMaster = src.ConstMaster;
		    MassStartRaw = src.MassStartRaw;
		    MassStart = src.MassStart;
		    MassEndRaw = src.MassEndRaw;
		    MassEnd = src.MassEnd;
		    DensityIn = src.DensityIn;
		    DensityLine = src.DensityLine;
		    DensityDiv = src.DensityDiv;
		    Buoyancy = src.Buoyancy;
		    FlowMass = src.FlowMass;
		    FlowVolume = src.FlowVolume;
		    VolumeCTV = src.VolumeCTV;
		    VolumeMaster = src.VolumeMaster;
		    ErrorMaster = src.ErrorMaster;
            DiverterStart = src.DiverterStart;
            DivStart10 = src.DivStart10;
            DivStart50 = src.DivStart50;
            DivStart90 = src.DivStart90;
            DiverterEnd = src.DiverterEnd;
            DivEnd10 = src.DivEnd10;
            DivEnd50 = src.DivEnd50;
            DivEnd90 = src.DivEnd90;
			ErrorFlags = src.ErrorFlags;
			ErrorFlagsMd = src.ErrorFlagsMd;
		    RefEnergy = src.RefEnergy;
            AmbTempMean = src.AmbTempMean;
		    AmbTempStart = src.AmbTempStart;
		    AmbTempEnd = src.AmbTempEnd;
		    AmbTempMin = src.AmbTempMin;
		    AmbTempMax = src.AmbTempMax;
            AmbPressMean = src.AmbPressMean;
		    AmbPressStart = src.AmbPressStart;
		    AmbPressEnd = src.AmbPressEnd;
		    AmbPressMin = src.AmbPressMin; 
		    AmbPressMax = src.AmbPressMax; 
		    AmbHumiMean = src.AmbHumiMean; 
		    AmbHumiStart = src.AmbHumiStart;
		    AmbHumiEnd = src.AmbHumiEnd;
		    AmbHumiMin = src.AmbHumiMin;
		    AmbHumiMax = src.AmbHumiMax;
		    PressUpMean = src.PressUpMean;
		    PressUpStart = src.PressUpStart;
		    PressUpEnd = src.PressUpEnd;
		    PressUpMin = src.PressUpMin;
		    PressUpMax = src.PressUpMax;
		    PressDownMean = src.PressDownMean;
		    PressDownStart = src.PressDownStart;
		    PressDownEnd = src.PressDownEnd;
		    PressDownMin = src.PressDownMin;
		    PressDownMax = src.PressDownMax;
		    PressDeltaMean = src.PressDeltaMean;
		    PressDeltaStart = src.PressDeltaStart;
		    PressDeltaEnd = src.PressDeltaEnd;
		    PressDeltaMin = src.PressDeltaMin;
		    PressDeltaMax = src.PressDeltaMax;
		    TempUpMean = src.TempUpMean;
            TempUpStart = src.TempUpStart;
            TempUpEnd = src.TempUpEnd;
            TempUpMin = src.TempUpMin;
            TempUpMax = src.TempUpMax;
            TempDownMean = src.TempDownMean;
            TempDownStart = src.TempDownStart;
            TempDownEnd = src.TempDownEnd;
            TempDownMin = src.TempDownMin;
            TempDownMax = src.TempDownMax;
            TempDivMean = src.TempDivMean;
            TempDivStart = src.TempDivStart;
            TempDivEnd = src.TempDivEnd;
            TempDivMin = src.TempDivMin;
            TempDivMax = src.TempDivMax;
			FlowMean = src.FlowMean;
			FlowStart = src.FlowStart;
		    FlowEnd = src.FlowEnd;
			FlowMin = src.FlowMin;
			FlowMax = src.FlowMax;
            Custom1 = src.Custom1;
		    Custom2 = src.Custom2;
		    Custom3 = src.Custom3;
		    Custom4 = src.Custom4;
		    Custom5 = src.Custom5;
		    Custom6 = src.Custom6;
		    Custom7 = src.Custom7;
		    Custom8 = src.Custom8;
		    Custom9 = src.Custom9;
		    Custom10 = src.Custom10;
        }

		/// <summary> Wrapper </summary>
		public virtual Config.Entities.ErrorFlagsMode ErrorFlagsMode()
		{
			return (Config.Entities.ErrorFlagsMode)ErrorFlagsMd;
		}

        /// <summary> Wrapper </summary>
        public virtual string ErrorFlagsStr()
        {
            string eFlags = Utils.ErrorFlagsStr(ErrorFlags);
#if LANG_PL
            return string.IsNullOrEmpty(eFlags) ? "brak" : eFlags;
#else
            return eFlags;
#endif
        }

		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()
        {
			return string.Format("batch={0}, procedure={1}, test={2}, {3} {4}", Batch.BatchNr, Batch.ProcedureName, Name(), StartTime.ToShortDateString(), StartTime.ToShortTimeString());
        }

		public virtual string ToString(int i)
		{
			return string.Format("TestRslt: Part={0} RepetitionNr={1} TestDone={2} Remark={3} StartTime={4} EndTime={5} FlowSetTime={6} TestTime={7} PulsesMaster={8} ConstMaster={9} MassStartRaw={10} MassStart={11} MassEndRaw={12} MassEnd={13} DensityIn={14} DensityOut={15} DensityDiv={16} Buoyancy={17} FlowMass={18} FlowVolume={19} VolumeCTV={20} VolumeMaster={21} ErrorMaster={22} DiverterStart={85} DiverterEnd={86} ErrorFlags={23} ErrorFlagsMd={24} AmbTempMean={25} AmbTempStart={26} AmbTempEnd={27} AmbTempMin={28} AmbTempMax={29} AmbPressMean={30} AmbPressStart={31} AmbPressEnd={32} AmbPressMin={33}  AmbPressMax={34} AmbHumiMean={35} AmbHumiStart={36} AmbHumiEnd={37} AmbHumiMin={38} AmbHumiMax={39} PressUpMean={40} PressUpStart={41} PressUpEnd={42} PressUpMin={43} PressUpMax={44} PressDownMean={45} PressDownStart={46} PressDownEnd={47} PressDownMin={48} PressDownMax={49} PressDeltaMean={50} PressDeltaStart={51} PressDeltaEnd={52} PressDeltaMin={53} PressDeltaMax={54} TempUpMean={55} TempUpStart={56} TempUpEnd={57} TempUpMin={58} TempUpMax={59} TempDownMean={60} TempDownStart={61} TempDownEnd={62} TempDownMin={63} TempDownMax={64} TempDivMean={65} TempDivStart={66} TempDivEnd={67} TempDivMin={68} TempDivMax={69} FlowMean={70} FlowStart={71} FlowEnd={72} FlowMin={73} FlowMax={74} Custom1={75} Custom2={76} Custom3={77} Custom4={78} Custom5={79} Custom6={80} Custom7={81} Custom8={82} Custom9={83} Custom10={84}", 
								Part, RepetitionNr, TestDone, Remark, StartTime, EndTime, FlowSetTime, TestTime,
								PulsesMaster, ConstMaster, MassStartRaw, MassStart, MassEndRaw, MassEnd,
								DensityIn, DensityLine, DensityDiv, Buoyancy, FlowMass, FlowVolume,
								VolumeCTV, VolumeMaster, ErrorMaster, ErrorFlags, ErrorFlagsMd, 
								AmbTempMean, AmbTempStart, AmbTempEnd, AmbTempMin, AmbTempMax,
								AmbPressMean, AmbPressStart, AmbPressEnd, AmbPressMin, AmbPressMax,
								AmbHumiMean, AmbHumiStart, AmbHumiEnd, AmbHumiMin, AmbHumiMax,
								PressUpMean, PressUpStart, PressUpEnd, PressUpMin, PressUpMax,
								PressDownMean, PressDownStart, PressDownEnd, PressDownMin, PressDownMax,
								PressDeltaMean, PressDeltaStart, PressDeltaEnd, PressDeltaMin, PressDeltaMax,
								TempUpMean, TempUpStart, TempUpEnd, TempUpMin, TempUpMax,
								TempDownMean, TempDownStart, TempDownEnd, TempDownMin, TempDownMax,
								TempDivMean, TempDivStart, TempDivEnd, TempDivMin, TempDivMax,
								FlowMean, FlowStart, FlowEnd, FlowMin, FlowMax,
								Custom1, Custom2, Custom3, Custom4, Custom5, Custom6, Custom7, Custom8, Custom9, Custom10,
                                DiverterStart, DiverterEnd);
		}
	}
}